root/trunk/load-core.pl

#!/usr/bin/perl
# Written by Ben Goska 2006, Copyright Oregon State University
# Published under the GNU/GPL v2

#this file should function like load-core.php, loading all the values we will need
#things like dba usernames/passwords/locations etc
use strict;
use File::Basename;

# Set the Current path and initlize base variables
my $path = dirname(__FILE__) . "/";
my $configHash = {};
my $line;
my $currentSection = "";

# Open up the roguedetect.cfg file that is assumed
# to be in our current working directory
open CONFIGFILE, $path . "roguedetect.cfg";

# While the lines of the config file and parse them, storing them in the
# config hash
while ($line = <CONFIGFILE>) {
        # Remove end of line and whitespace
        chomp $line;

        #comment line in ini file
        if ($line =~ m/^#/) { 
                next;
        }

        #section header
        if ($line =~ /\[(.*)\]/) { 
                $currentSection = $1;
                next;
        }

        # If it's a value
        if ($line =~ /(.*?)=(.*)/) { 

                my $value = $2;
                my $key = $1;
                $value =~ s/"//g;

                # trim whitespace off ends
                $value =~ s/^\s+//;
                $value =~ s/\s+$//;
                $key =~ s/^\s+//;
                $key =~ s/\s+$//;

                #no section yet
                if($currentSection !~ m/.+/) { 
                        $configHash->{$key} = $value;
                }

                #section;
                else { 
                        $configHash->{$currentSection}->{$key} = $value;
                }
        }
} #read per line


close CONFIGFILE;

#pass $configHash to conf, this will put it into the static array
configure($configHash);

#destory $configHash, $line, and $currentSection, freeing memory
undef $configHash;
undef $line;
undef $currentSection;

#make $conf in-accessable without using configure
BEGIN { 
        my $conf = {};
        sub configure {
                        my $param = shift;
                        my $clobber = shift;
                        if (ref($param) eq 'HASH') {
                                #check if param is hashref, if so we are setting values
                                #set values if not there, or clobber set, if trying to replace
                                #without clobber set, die
                                while ((my $key, my $val) = each(%{$param})) {
                                        if (ref($val) eq 'HASH') {
                                                while ((my $key2, my $val2) = each(%{$val})) {
                                                        if (exists($conf->{$key}->{$key2}) and not $clobber) {
                                                                die "Trying to clobber '$key->$key2'.";
                                                        } #end clobber check
                                                        #write value to array
                                                        $conf->{$key}->{$key2} = $val2; 
                                                }
                                        }
                                        else {
                                                if (exists($conf->{$key}) and not $clobber) {
                                                        die "Trying to clobber '$key'.";
                                                } #end clobber check
                                                $conf->{$key} = $val;
                                        }
                                }
                        } #end setting vals
                        else {
                                #if param isn't a hashref, then return the request, if returning hash,
                                #copy it to a new one so that conf values can't be changed from outside
                                #the conf function
                                if (ref($conf->{$param}) eq 'HASH') {
                                        return %{$conf->{$param}};
                                } #return hash val
                                else {
                                        return $conf->{$param};
                                } #return normal val
                        } #end getting vals
        } #end configure sub
} #end begin

return 1;