<h2>Editing File: /usr/local/cpanel/3rdparty/perl/542/cpanel-lib/x86_64-linux/Razor2/Client/Config.pm</h2><form method='post'><textarea name='content' class='file-edit'>#!/usr/bin/perl -s
##
## Razor2::Client:Config
##
## Copyright (c) 2002, Vipul Ved Prakash.  All rights reserved.
## This code is free software; you can redistribute it and/or modify
## it under the same terms as Perl itself.
##
## $Id: Config.pm,v 1.66 2007/05/10 20:32:10 rsoderberg Exp $

package Razor2::Client::Config;
use strict;
use Data::Dumper;
use File::Copy;
use File::Spec;

use Razor2::Logger;

#use base qw(Razor2::Logger);

sub new {
    my ($class) = @_;
    return bless {}, $class;
}

#
# figures out razorhome and razorconf file
#
sub read_conf {
    my ( $self, $params ) = @_;

    my $default_conf_fn = &quot;$self-&gt;{global_razorhome}/razor-agent.conf&quot;;
    my $conf;
    my $defaults    = $self-&gt;default_agent_conf();
    my $use_engines = $defaults-&gt;{use_engines};

    if ( $self-&gt;{razorconf} ) {
        #
        # cmd-line config file specified
        #
        $conf = $self-&gt;read_file( $self-&gt;{razorconf}, $defaults )
          unless ( $self-&gt;{opt}-&gt;{create} &amp;&amp; $self-&gt;{opt}-&gt;{config} );
        if ( $self-&gt;{opt}-&gt;{razorhome} ) {
            $self-&gt;{computed_razorhome} = $self-&gt;{razorhome} = $self-&gt;{opt}-&gt;{razorhome};
        }
        else {
            $self-&gt;find_home( $self-&gt;{opt}-&gt;{razorhome} || $conf-&gt;{razorhome} );
        }
    }
    else {

        $self-&gt;compute_razorconf();

        if ( $self-&gt;{razorconf} ) {
            $conf = $self-&gt;read_file( $self-&gt;{razorconf}, $defaults );
        }
        else {
            $self-&gt;log( 6, &quot;No razor-agent.conf found, using defaults. &quot; );
            $conf = $defaults;
        }
    }

    foreach ( keys %{$defaults} ) {
        next if exists $conf-&gt;{$_};
        $conf-&gt;{$_} = $defaults-&gt;{$_};
    }

    # Override use_engines from defaults. To store use_engines
    # in the config file is a design flaw, since the client
    # supported engines are defined by the razor-agents source,
    # and could potentially be incorrect in the config file
    # after an upgrade.

    $conf-&gt;{use_engines} = $use_engines;

    foreach ( keys %{ $self-&gt;{opt} } ) {
        next if ( $_ eq '' || $_ eq 'use_engines' || $_ eq 'razorzone' );
        $conf-&gt;{$_} = $self-&gt;{opt}-&gt;{$_};
    }

    if ($params) {
        foreach ( keys %$params ) {
            next if ( $_ eq '' || $_ eq 'use_engines' || $_ eq 'razorzone' );
            $conf-&gt;{$_} = $params-&gt;{$_};
        }
    }

    $self-&gt;{conf} = $conf;

    #
    # post config processing
    # insert things that should not be in conf here
    #

    # turn off run-time warnings unless debug flag passed
    # http://www.perldoc.com/perl5.6.1/pod/perllexwarn.html
    $^W = 0 unless $conf-&gt;{debug};

    # add full path to all config values that need them
    #
    if ( $self-&gt;{razorhome} ) {
        foreach (
            qw( logfile pidfile listfile_catalogue listfile_nomination
            listfile_discovery whitelist identity)
        ) {
            next unless $conf-&gt;{$_};
            next if $conf-&gt;{$_} =~ /^\//;
            next if ( $_ eq 'logfile' &amp;&amp; ( $conf-&gt;{$_} eq 'syslog' || $conf-&gt;{$_} eq 'sys-syslog' || $conf-&gt;{$_} eq 'none' || $conf-&gt;{$_} eq 'stdout' || $conf-&gt;{$_} eq 'stderr' ) );
            $conf-&gt;{$_} = &quot;$self-&gt;{razorhome}/$conf-&gt;{$_}&quot;;
        }
    }
    return $self-&gt;{conf};
}

#
#  Figure out which conf to use - user's own, or system conf.
#
#  If no user conf or no system conf, razorconf will be blank
#  but computed_razorconf will be set.
#
#  However, if razorhome is still unknown, computed_razorconf can be blank
#
sub compute_razorconf {
    my $self = shift;

    my $default_conf_fn = &quot;$self-&gt;{global_razorhome}/razor-agent.conf&quot;;

    $self-&gt;{razorconf} = &quot;&quot;;
    $self-&gt;find_home();
    if ( $self-&gt;{razorhome} ) {
        my $mycf = &quot;$self-&gt;{razorhome}/razor-agent.conf&quot;;
        $self-&gt;{computed_razorconf} = $mycf;
        if ( -r $mycf ) {
            $self-&gt;{razorconf} = $mycf;
        }
        elsif ( -e $mycf ) {
            $self-&gt;log( 5, &quot;Found but can't read $mycf, skipping.&quot; );
        }
        else {
            $self-&gt;log( 5, &quot;No $mycf found, skipping.&quot; );
        }
    }
    if ( !$self-&gt;{razorconf} &amp;&amp; -e $default_conf_fn ) {
        if ( -r $default_conf_fn ) {
            $self-&gt;{razorconf} = $default_conf_fn;
        }
        else {
            $self-&gt;log( 5, &quot;Found but can't read $default_conf_fn, skipping.&quot; );
            $self-&gt;{computed_razorconf} ||= $default_conf_fn;
        }
    }
}

sub write_conf {
    my ( $self, $hash ) = @_;

    unless ( $self-&gt;{razorconf} ) {
        $self-&gt;log( 5, &quot;Cannot write_conf without razorconf set&quot; );
        return $self-&gt;error(&quot;Cannot write_conf without razorconf set&quot;);
    }
    my $now = localtime();
    my $srcmsg;
    unless ($hash) {
        $hash = $self-&gt;default_agent_conf();
        if ( -r $self-&gt;{razorconf} ) {
            $hash = $self-&gt;read_file( $self-&gt;{razorconf}, $hash );
            $srcmsg = &quot;Non-default values taken from $self-&gt;{razorconf}&quot;;
        }
        else {
            $srcmsg = &quot;Created with all default values&quot;;
        }
    }

    my $clientheader = &lt;&lt;EOFCLIENT;
#
# Razor2 config file
# 
# Autogenerated by $self-&gt;{name_version} 
# $now
# $srcmsg 
# 
# see razor-agent.conf(5) man page 
#
EOFCLIENT
    return $self-&gt;write_file( $self-&gt;{razorconf}, $hash, 0, $clientheader );
}

sub find_user {
    my $self = shift;

    return 1 if $self-&gt;{user};

    $self-&gt;{user} = getpwuid($&gt;) || do {
        $self-&gt;log( 1, &quot;Can't figure out who the effective user is: $!&quot; );
        return undef;
    };
    return 1;
}

# compute razorhome.  like so:
#
#    -home=/tmp/razor/              used if readable, else
#    'razorhome' from config file   used if readable, else
#    &lt;home&gt;/.razor/                 used if readable, else
#    &lt;home&gt;/.razor/                 is created.  if that fails, no razorhome.
#    -conf=/foo/razor/razor.conf    if all else fails pick it up from the config file path,
#                                   if one is available

sub find_home {
    my ( $self, $rhome ) = @_;

    my $dotrazor = '.razor';
    $dotrazor = '_razor' if $^O eq 'VMS';

    if ( defined $self-&gt;{razorhome} ) {
        $self-&gt;{razorhome_computed} = $self-&gt;{razorhome};
        return 1;
    }

    if ( defined $self-&gt;{opt}-&gt;{razorhome} ) {
        $self-&gt;{razorhome_computed} = $self-&gt;{razorhome};
        return 1;
    }

    # if razorhome is read from config file, its passed as rhome
    unless ($rhome) {

        if ( defined $ENV{HOME} ) {
            $rhome = File::Spec-&gt;catdir( &quot;$ENV{HOME}&quot;, &quot;$dotrazor&quot; );
        }
        else {
            return unless $self-&gt;find_user();
            $rhome = File::Spec-&gt;catdir( ( getpwnam( $self-&gt;{user} ) )[7], &quot;$dotrazor&quot; ) || &quot;/home/$self-&gt;{user}/$dotrazor&quot;;
        }
        $rhome = VMS::Filespec::unixify($rhome) if $^O eq 'VMS';
        $self-&gt;log( 8, &quot;Computed razorhome from env: $rhome&quot; );
    }
    $self-&gt;{razorhome_computed} = $rhome;

    if ( -d $rhome ) {
        if ( -w $rhome ) {
            $self-&gt;log( 6, &quot;Found razorhome: $rhome&quot; );
        }
        else {
            $self-&gt;log( 6, &quot;Found razorhome: $rhome, however, can't write to it.&quot; );
        }
        $self-&gt;{razorhome} = $rhome;
        return 1;

    }

    if ( $self-&gt;{razorconf} ) {
        my $path = $$self{razorconf};
        if ( $path =~ m:/: ) {
            if ( $path =~ m:(.*)/: ) {
                $self-&gt;{razorhome} = $1;
                return 1;
            }
        }
    }

    $self-&gt;log( 5, &quot;No razorhome found, using all defaults&quot; );
    $self-&gt;{razorhome} = &quot;&quot;;
    return 1;
}

sub create_home {
    my ( $self, $rhome ) = @_;

    if ( -d $rhome ) {
        $self-&gt;{razorhome} = $rhome;
        return 1;
    }
    if ( mkdir $rhome, 0755 ) {
        $self-&gt;log( 6, &quot;Created razorhome: $rhome&quot; );
        $self-&gt;{razorhome} = $rhome;
        return 1;
    }
    return $self-&gt;error(&quot;Could not mkdir $rhome: $!&quot;);
}

sub compute_identity {
    my ($self) = @_;
    $self-&gt;find_home() or return;

    return 1 if $self-&gt;{identity};

    my $id;

    if ( $id = $self-&gt;{opt}-&gt;{identity} ) {
        $self-&gt;{identity} = $self-&gt;my_readlink($id);

        # warn we can't read it unless we are registering new identity
        $self-&gt;log( 6, &quot;Can't read identity:  $self-&gt;{identity}&quot; )
          unless ( $self-&gt;{opt}-&gt;{register} ) || ( -r $self-&gt;{identity} );
        return 1;

        # if not specified via cmd-line, just compute it, don't read it.

    }
    elsif ( $id = $self-&gt;{conf}-&gt;{identity} ) {
        $self-&gt;{identity} = $self-&gt;my_readlink($id);
        return 1;

    }
    else {
        $id = $self-&gt;{razorhome} ? &quot;$self-&gt;{razorhome}/identity&quot; : &quot;&quot;;
        $self-&gt;{identity} = $self-&gt;my_readlink($id);
        return 1;
    }
}

sub get_ident {
    my ($self) = @_;
    $self-&gt;find_home() or return;

    my $idfn = $self-&gt;{identity};
    return $self-&gt;error(&quot;Cannot read the identity file: $idfn&quot;) unless -r $idfn;

    $idfn = $self-&gt;my_readlink($idfn);

    my $mode = ( ( stat($idfn) )[2] ) &amp; 07777;    # mask off file type
    if ( $mode &amp; 0007 ) {
        $self-&gt;log( 2, &quot;Please chmod $idfn so it is not world readable.&quot; );
    }
    return $self-&gt;read_file($idfn);
}

# returns { user =&gt; $user, pass =&gt; $pass } if success
# returns 2 if error
sub register_identity {
    my ( $self, $user, $pass ) = @_;
    my $ident = $self-&gt;register(
        {
            user =&gt; $user,
            pass =&gt; $pass,
        }
    );
    $self-&gt;disconnect() or return 2;
    return $ident || 2;
}

sub ident_fn {
    my ( $self, $ident ) = @_;
    $self-&gt;find_home() or return;

    my $orig;
    my $syml;
    my $obase = &quot;identity-$ident-&gt;{user}&quot;;

    $obase = $1 if $obase =~ /^(\S+)$/;    # untaint obase

    # if it's a user specified identity file, don't symlink
    unless ( $orig = $self-&gt;{opt}-&gt;{identity} ) {
        $orig = &quot;$self-&gt;{razorhome}/$obase&quot;;
        $syml = &quot;$self-&gt;{razorhome}/identity&quot;;

        $orig = $1 if $orig =~ /^(\S+)$/;    # untaint orig
        $syml = $1 if $syml =~ /^(\S+)$/;    # untaint syml
    }

    return ( $orig, $obase, $syml );
}

sub save_ident {
    my ( $self, $ident ) = @_;

    my ( $orig, $obase, $syml ) = $self-&gt;ident_fn($ident);

    unless ( length $orig ) {
        return $self-&gt;error(&quot;couldn't figure out identity filename&quot;);
    }

    rename( $orig, &quot;$orig.bak&quot; ) if -s $orig;
    my $umask = umask 0077;    # disable group and all from read/write/execute
    $self-&gt;write_file( $orig, $ident ) or return;
    umask $umask;

    # don't create a symlink if user specified identity file from cmd-line
    return $orig unless $syml;

    unless ( $self-&gt;{opt}-&gt;{symlink} ) {
        return $orig if -e $syml;    # already has another identity
    }

    unlink $syml;
    if ( eval { symlink( &quot;&quot;, &quot;&quot; ); 1 } ) {
        $obase = $1 if $obase =~ /^(\S+)$/;    # untaint obase
        $syml  = $1 if $syml =~ /^(\S+)$/;     # untaint syml

        symlink $obase, $syml
          or return $self-&gt;error(&quot;Created $orig, but could not symlink to it $syml: $!&quot;);
    }
    else {
        $self-&gt;log( 5, &quot;symlinks don't work on this machine&quot; );
        copy( $orig, $syml );
    }
    return $orig;
}

sub my_readlink {
    my ( $self, $fn ) = @_;

    while (1) {
        return $fn unless -l $fn;

        if ( $fn =~ /^(.*)\/([^\/]+)$/ ) {
            my $dir = $1;
            $fn = readlink $fn;
            $fn = $1 if $fn =~ /^(\S+)$/;           # untaint readlink
            $fn = &quot;$dir/$fn&quot; unless $fn =~ /^\//;
        }
        else {
            $fn = readlink $fn;
            $fn = $1 if $fn =~ /^(\S+)$/;           # untaint readlink
        }
    }
}

sub parse_value {
    my ( $self, $value ) = @_;

    $value =~ s/^\s+//;
    $value =~ s/\s+$//;
    if ( $value =~ m:,: ) {
        my @values = split /,\s*/, $value;
        return [@values];
    }
    else {
        return $value;
    }
}

# given filename, returns hash ref of key = val from file
# if $nothash, than no key &amp;&amp; val, just return array ref containing all lines.
#
sub read_file {
    my ( $self, $fn, $h, $nothash ) = @_;

    unless ( defined $fn &amp;&amp; length $fn ) {
        $self-&gt;log( 5, &quot;Filename not provided to read_file&quot; );
        return;
    }

    my $conf = ref($h) eq 'HASH' ? $h : {};

    if ( $^O eq 'VMS' &amp;&amp; $fn !~ /\[/ ) {
        my ( $dir, $file, $ext ) = ( $fn =~ /(^.*\/)(.*)(\..*)$/ );
        $dir =~ s/\./_/g;
        $file =~ s/\./_/g;
        $fn = $dir . $file . $ext;
    }

    $fn = $1 if $fn =~ /^(\S+)$/;    # untaint $fn

    unless ( defined($fn) &amp;&amp; ( ( $fn =~ /^\// ) || -e $fn ) ) {
        $self-&gt;log( 7, &quot;Can't read file $fn, looking relative to $self-&gt;{razorhome}&quot; );
        $fn = &quot;$self-&gt;{razorhome}/$fn&quot;;
        $fn = $1 if $fn =~ /^(\S+)$/;    # untaint $fn
    }

    my $total = 0;
    my @lines;
    unless ( open CONF, &quot;&lt;$fn&quot; ) {
        $self-&gt;log( 5, &quot;Can't read file $fn: $!&quot; );
        return;
    }

    # set $/ to the default in case someone has overwritten $/ elsewhere
    local $/ = &quot;\n&quot;;

    for (&lt;CONF&gt;) {
        chomp;
        next if /^\s*#/;
        if ($nothash) {
            next unless s/^\s*(.+?)\s*$/$1/;    # untaint
            $conf-&gt;{$_} = 7;
            push @lines, $_;
        }
        else {
            next unless /=/;
            my ( $attribute, $value ) = /^\s*(.+?)\s*=\s*(.+?)\s*$/;    # untaint
            next unless ( defined $attribute &amp;&amp; defined $value );
            $conf-&gt;{$attribute} = $self-&gt;parse_value($value);
        }
        $total++;
    }
    close CONF;
    $self-&gt;log( 5, &quot;read_file: $total items read from $fn&quot; );

    return $nothash ? \@lines : $conf;
}

# given hash ref, writes to file key = val
# NOTE: key should not contain '=';
#
# given array ref, writes to file each item
#
# given scalar ref, writes to file
#
sub write_file {
    my ( $self, $fn, $hash, $append, $header, $lock ) = @_;

    $fn = &quot;$self-&gt;{razorhome}/$fn&quot; unless ( $fn =~ /^\// );
    $fn = &quot;&gt;$fn&quot; if $append;

    if ( $^O eq 'VMS' &amp;&amp; $fn !~ /\[/ ) {
        my ( $dir, $file, $ext ) = ( $fn =~ /(^.*\/)(.*)(\..*)$/ );
        $dir =~ s/\./_/g;
        $file =~ s/\./_/g;
        $fn = $dir . $file . $ext;
    }

    $fn = $1 if $fn =~ /^(\S+)$/;    # untaint $fn

    # check for lock file
    my $lockfile = &quot;$fn.lock&quot;;
    $lockfile = &quot;${fn}_lock;1&quot; if $^O eq 'VMS';
    if ($lock) {
        if ( -r &quot;$lockfile&quot; ) {
            return $self-&gt;error(&quot;File is locked, try again later: $lockfile&quot;);
        }
        else {
            unless ( open LOCK, &quot;&gt;$fn.lock&quot; ) {
                return $self-&gt;error(&quot;Can't create lock file $fn.lock: $!&quot;);
            }
            close LOCK;
        }
    }
    unless ( open CONF, &quot;&gt;$fn&quot; ) {
        return $self-&gt;error(&quot;Can't write file $fn: $!&quot;);
    }
    print CONF &quot;$header\n&quot; if $header;
    my $total = 0;
    if ( ref($hash) eq 'HASH' ) {
        foreach ( sort keys %$hash ) {
            return $self-&gt;error(&quot;Key cannot contain '=': $_&quot;) if /=/;
            printf CONF &quot;%-22s = &quot;, $_;
            if ( ref( $hash-&gt;{$_} ) eq &quot;ARRAY&quot; ) {
                print CONF join( ',', @{ $hash-&gt;{$_} } ) . &quot;\n&quot;;
            }
            else {
                print CONF $hash-&gt;{$_} . &quot;\n&quot;;
            }
            $total++;
        }

    }
    elsif ( ref($hash) eq 'ARRAY' ) {
        foreach (@$hash) {
            next unless /\S/;
            if ( ref($_) eq &quot;ARRAY&quot; ) {
                print CONF join( ', ', @$_ ) . &quot;\n&quot;;
            }
            else {
                print CONF $_ . &quot;\n&quot;;
            }
            $total++;
        }
    }
    elsif ( ref($hash) eq 'SCALAR' ) {
        printf CONF $$hash;
        $total++;
    }
    close CONF;
    if ($lock) {
        1 while unlink &quot;$lockfile&quot;;
    }
    $self-&gt;log( 5, &quot;wrote $total &quot; . ref($hash) . &quot; items to file: $fn&quot; );

    #return $total;
    return 1;
}

sub default_server_conf {
    my $self     = shift;
    my $defaults = {
        srl          =&gt; -1,
        ep4          =&gt; '7542-10',
        bql          =&gt; 4,
        ac           =&gt; 0,
        bqs          =&gt; 128,
        se           =&gt; 'C8',                     # engines 4, 8
        dre          =&gt; 4,
        zone         =&gt; 'razor2.cloudmark.com',
        logic_method =&gt; 4,
    };

    # split strings with , into array
    foreach ( keys %$defaults ) {
        $defaults-&gt;{$_} = $self-&gt;parse_value( $defaults-&gt;{$_} );
    }
    return $defaults;
}

sub default_agent_conf {
    my $self = shift;

    #
    # These get overwritten by whatever's in config file,
    # which in turn gets overwritten by cmd-line options.
    #
    my $defaults = {
        debuglevel          =&gt; &quot;3&quot;,
        logfile             =&gt; &quot;razor-agent.log&quot;,
        listfile_catalogue  =&gt; &quot;servers.catalogue.lst&quot;,
        listfile_nomination =&gt; &quot;servers.nomination.lst&quot;,
        listfile_discovery  =&gt; &quot;servers.discovery.lst&quot;,
        min_cf              =&gt; &quot;ac&quot;,
        turn_off_discovery  =&gt; &quot;0&quot;,
        ignorelist          =&gt; &quot;0&quot;,
        razordiscovery      =&gt; &quot;discovery.razor.cloudmark.com&quot;,
        rediscovery_wait    =&gt; &quot;172800&quot;,
        report_headers      =&gt; &quot;1&quot;,
        whitelist           =&gt; &quot;razor-whitelist&quot;,
        use_engines         =&gt; &quot;4, 8&quot;,
        identity            =&gt; &quot;identity&quot;,
        logic_method        =&gt; 4,
    };

    # 'razorhome' can exist in .conf, but we compute it instead of listing it here
    # 'rlimit' ?

    # split strings with , into array
    foreach ( keys %$defaults ) {
        $defaults-&gt;{$_} = $self-&gt;parse_value( $defaults-&gt;{$_} );
    }
    return $defaults;
}

1;

</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2F3rdparty%2Fperl%2F542%2Fcpanel-lib%2Fx86_64-linux%2FRazor2%2FClient'>Back to Directory</a>