I think that if you store your values in a hash rather than individual variables then you'll find your system will be much easier to extend.

Here's a first draft of how I'd do it. It creates a hash called %cnf and the way the hash is built is controlled by another (potentially confusingly named) has called %config. In this example, 'to' and 'from' are set in the user input (simulated with the DATA filehandle) and the 'subject' is set from a default.

use strict;
use warnings;

sub subject {
  'Subject: default subject';
}

sub to {
  'To: default_to@example.com';
}

sub from {
  'From: default_from@example.com';
}

my %config = (
  to =>      { regex => '^To:\s', sub => \&to },
  from =>    { regex => '^From:\s', sub => \&from },
  subject => { regex => '^Subject:\s', sub => \&subject },
);

my %cnf;

# Load user data
foreach (<DATA>) {
  chomp;

  foreach my $c (keys %config) {
    if (/$config{$c}{regex}/) {
      $cnf{$c} = $_;
      last;
    }
  }
}

# Look for missing values and fill in defaults
foreach (keys %config) {
  unless (exists $cnf{$_}) {
    $cnf{$_} = $config{$_}{sub}->();
  }
}

use Data::Dumper;
print Dumper \%cnf;

__DATA__
To: foo@example.com
From: bar@example.com
[download]

Hi Davorg

I am facing little problem. By using your program i got the header values which is either default values or user defined values.But the problem is that from the same program suppose i got the values for a INVITE request, during the running of the program i suppose use your program for getting the header values of a ACK request, then the values of the hash (%cnf) are not changed. It takes the previous value which is stored during the procesing of the INVITE request. How it can take different values for different requests?

Sounds like a scoping issue to me. You need to ensure that each time you process an new message that you also create a new %cnf variable. I'd guess that you need to add my %cnf; near the start of your processing loop.

--
<http://dave.org.uk>

"The first rule of Perl club is you do not talk about Perl club."
-- Chip Salzenberg

Hi thanks for suggestion. but i have little doubts.Actually your progran only prints the default values. It does not take the values mentioned by the user in the config file. Suppose the default values are kept in sub routines like


sub subject {
  'Subject: default subject';
}

sub to {
  'To: default_to@example.com';
}

sub from {
  'From: default_from@example.com';
}
[download]

I could not understand the following syntax, Just give me some hints about it.


my %config = (
  to =>      { regex => '^To:\s', sub => \&to },
  from =>    { regex => '^From:\s', sub => \&from },
  subject => { regex => '^Subject:\s', sub => \&subject },
);

my %cnf;

# Load user data
open DATA,'sss.txt' or die $!;
foreach (<DATA>) {
  chomp;

  foreach my $c (keys %config) {
    if (/$config{$c}{regex}/) {
      $cnf{$c} = $_;
      last;
    }
  }
}
[download]


sss.txt contains
To:sanjay<sanjay@36.212.176.92>
From:sanjay1<sanjay1@36.212.176.90>
Subject:Hi
Actually what i need, if it does not get any value in the config file it will call the sub routines for taking the default values.After that How can i assign the keys and its values in a variable so that i can use that variable for different purpose?

Hi thanks for suggestion. but i have little doubts.Actually your progran only prints the default values.

Actually, my code works fine on my sample data. It appears not to work on your data, but that's because your data is subtley different to mine. Explaining why (later) will give me a good way to show how flexible my approach is.

I could not understand the following syntax, Just give me some hints about it.

my %config = (
  to =>      { regex => '^To:\s', sub => \&to },
  from =>    { regex => '^From:\s', sub => \&from },
  subject => { regex => '^Subject:\s', sub => \&subject },
);
[download]

Here we're defining a hash which controls how the config is produced from the input files. It basically defines three things. The keys in the hash are the names of the data items that we are looking for. They will also contain the names of the keys in the hash that will contain the _actual_ configuration. Each associated value in the hash is a reference to another hash which contains details on how to find that value. This is in two parts. There is a regular expression which matches against the user input and a reference to a subroutine which is called to give the default value if no value is found in the user input.

And this is where we can make changes to make your input work. For example, my regex for finding a "To:" header is ^To:\s. And that works on my input. But in your sample data you don't have a space after the colon. So the regex no longer matches and you end up getting the default values. To change the regex so it matches your data, you simply need to change the regex to remove the \s. See, you just edit the configuration, not the actual code.

Actually what i need, if it does not get any value in the config file it will call the sub routines for taking the default values.

I know. And that's exactly what I've given you.

After that How can i assign the keys and its values in a variable so that i can use that variable for different purpose?

The configuration (taken from the user input or the default subroutines) ends up in the hash %cnf. In this example, %cnf ends up with the keys 'to', 'from' and 'subject'. If this code was in "read_config" subroutine, then you could return the %cnf hash from that subroutine and use it elsewhere in your program.

--
<http://dave.org.uk>

"The first rule of Perl club is you do not talk about Perl club."
-- Chip Salzenberg

First, I think I would store the config file data in a hash, rather than an array. That way you can look up a particular datum more easily, by its name.

As for the code that reads the config file, there are modules on the CPAN for reading config files, see for instance here, although some of those may require the config file to be in a certain format that may not match yours. (On the other hand, if you don't have to accommodate pre-existing config files, you could just define your config file format to be the format that the module reads.)

Now, the other thing you asked about is checking the config data for each of several values and, if they are not present, calling a routine to construct them. If I were doing that, the first thing I'd do is make a list of the values I want (e.g., From, To, Cc, and so forth). The second thing I'd do is make the list a hash, with the name of the header being the key, and the subroutine that constructs the header would be the value. Something along these lines...

my %dispatch = (
  From    => sub { return '"Nobody" <nobody@localhost>'; },
  Subject => sub { die "The GNKSA requires that the subject field alwa
+ys be specified by the user."; },
  # and so forth.
);
[download]

The third thing would be to actually do the assignments, and I'd probably use a foreach loop over the keys for that part. Something like this...

   for my $k (keys %dispatch) {
      if (exists $config{$k}) {
         $value{$k} = $config{$k};
      } else {
         $value{$k} = $dispatch{$k}->();
      }
   }
[download]

It is possible to golf that loop down to one line, but you either lose the exists test (resulting in a situation where a user cannot specify a false value) or else have to use the ? : operator, which I find beginners often don't like. Anyway, the dispatch table is going to be most of the work.

use warnings;
use strict;

use Config::IniHash;

# parse the config file into a hashref
my $config   = ReadINI 'pm1562.ini';

# default values
my $defaults = { header => { to => 'foo', from => 'bar' } };

# iterate the defaults and put them into $config if they not 
# already exist
for my $section ( keys %{$defaults} )
{
    for my $option ( keys %{$defaults->{$section}} )
    {
        $config->{$section}->{$option} = $defaults->{$section}->{$opti
+on}
            unless exists $config->{$section}->{$option};
    }
}

#use the values, no need for a variable $to or $from
print $config->{header}->{to}, "\n", 
      $config->{header}->{from}, "\n",
[download]

[header]
to=holli
[download]

holli
bar
[download]

$config->{$section}->{$option} = $defaults->{$section}->{$option}
            unless $config->{$section}->{$option};
[download]

I would throw the word exists (or defined) in there after the unless, just in case a user ever wants to specify a false value (e.g., a blank subject line is very rarely a good idea, but occasionally when sending mail to certain kinds of really old autoresponders that read commands from the subject line it can be desirable; there are also highly specialised cases for a blank From field).

---

Sanity? Oh, yeah, I've got all kinds of sanity. In fact, I've developed whole new kinds of sanity. Why, I've got so much sanity it's driving me crazy.

Is the format of the configuration file set, or can you make it whatever you want it to be? If you can choose the file format then you can use one of the many Config modules in CPAN.

If you do not have any choice over the configuration file format then consider using a hash to store the configuration values:

my %configOptions = (
  To => Header::To (),
  From => Header::From (),
  ...
  );

# code to read configuration file
[download]