# $Header: Ptdpm9.pm 31-dec-2003.11:38:23 skumar Exp $
#
# Package : Ptdpm9.pm
#
# Copyright (c) 2002, 2003, Oracle Corporation.  All rights reserved.  
#
#     NAME
#         Ptdpm9.pm
#
#     DESCRIPTION
#         Collects OS Configuration Properties and Parameters
#
#     NOTES
#
#     MODIFIED     (MM/DD/YY)
#        skumar     12/31/03 - AIX changes 
#      mgoodric   06/16/03 - fix converting Solaris timezone to JAVA timezones
#      mgoodric   05/11/03 - added -debug tracing
#      mgoodric   04/15/03 - fix using uname for arch
#      mgoodric   04/07/03 - fix finding MAC address
#      goramamo   08/16/02 - 904 Changes
#      xxu        06/25/02 - remove /usr/local/bin/perl
#      vkhizder   06/20/02 - vkhizder_compare_fix_2420795_collection_script_changes
#      goramamo   06/12/02 - Added more parm collection
#      goramamo   06/02/02 - Moved Boot Parm Collection from Ptdpm7.pm
#      goramamo   06/02/02 - Creation
#
#*************************************************************

use strict;

package Ptdpm9;

use Carp;
require 5.005;

#  require 5.6.1;
require Exporter;

use Ptdpm0;
use Ptdpm2;
use Ptdpm3;

#******************************************
#   Export Subroutines
#******************************************

@Ptdpm9::ISA    = ('Exporter');
@Ptdpm9::EXPORT = qw(
  &getOSConfiguration
  &getBootTimeParameters
  &getMaxSwapSpace
  );

#******************************************
#     Global Variables
#******************************************
use constant NIL => '';

%Ptdpm9::OSConf = ();

@Ptdpm9::PropertyExcludes = ('random', '-nr', '-state',
                             'fs.quota.syncs', 'fs.aio-pinned');

#******************************************
#     Exported Subroutines
#******************************************

sub getOSConfiguration
{
    debugTrace('Calling... getOSConfiguration()');

    getCurrSysDefn();
    getSysConfig();
    getAIXKernelDriverSettings();
    #getGlobalSettings();
    #getDefaultrouter();
    getDNSNameServers();

    my @bootparm = getAIXBootTimeParameters();
    loadAIXBootParmsToHash(@bootparm);

    return %Ptdpm9::OSConf;

}

#******************************************
#     Non-exported Subroutines
#******************************************

sub getCurrSysDefn
{
    debugTrace('Calling... getCurrSysDefn()');

    getIPCSStatus();

    my (@parm) = getCurrSysDef();
    my $size     = scalar(@parm);
    my $i        = 0;
    my $j        = 0;
    my @parms    = ();
    my @value    = ();
    my $procflag = 0;
    for ($i = 0 ; $i < $size ; $i++)
    {

        if ($procflag == 0)
        {
            if (index($parm[$i], "* Tunable Parameters") > -1)
            {
                $procflag = 1;
            }
        }
        elsif (substr($parm[$i], 0, 1) eq '*') { next; }

        # To be rewritten later in a better way.
        elsif (index($parm[$i], "mapped memory") > -1)
        {
            ($value[$j], $parms[$j]) = split ("mapped memory", $parm[$i], 2);
            $parms[$j] = "mapped memory";
            $j++;
        }
        else
        {
            ($value[$j], $parms[$j]) = split (' ', $parm[$i], 2);
            $j++;
        }
    }
    $parms[$j] = "Maximum Swap Space (MB)";
    $value[$j] = getMaxSwapSpace();
    $value[$j] = sprintf('%.3f', (trim($value[$j])) / (1024 * 1024));

    loadKernelParmsToHash($Ptdpm0::SYSDEF, \@parms, \@value);
}

sub getSysConfig
{
    debugTrace('Calling... getSysConfig()');

    my @parmlist = ('OPEN_MAX', 'CHILD_MAX');

    #  If you want to collect all the param under getconf,
    #  uncommnet next line;  comment previous line.
    #  my @parmlist  = ('-a');

    my $i     = 0;
    my $j     = 0;
    my $k     = 0;
    my $rest1 = NIL;
    my $rest2 = NIL;
    my @value = ();
    my @parms = ();
    my @sdef  = getSysConf();

    my $size2 = scalar(@sdef);
    my $size1 = scalar(@parmlist);
    if (($size1 == 1) && ($parmlist[0] eq '-a'))
    {
        for ($i = 0 ; $i < $size2 ; $i++)
        {
            ($parms[$i], $value[$i]) = split ($Ptdpm2::SEP, $sdef[$i], 2);
        }
    }
    else
    {
        for ($j = 0 ; $j < $size1 ; $j++)
        {
            for ($i = 0 ; $i < $size2 ; $i++)
            {
                ($rest1, $rest2) = split ($Ptdpm2::SEP, $sdef[$i], 2);
                if (defined $rest1)
                {
                    $rest1 = trim($rest1);
                    if ($rest1 eq $parmlist[$j])
                    {
                        $parms[$k] = $rest1;
                        $value[$k] = $rest2;
                        $k++;
                        last;
                    }
                }
            }
        }
    }
    loadKernelParmsToHash($Ptdpm0::GETCONF, \@parms, \@value);

}

sub getKernelDriverSettings
{
    debugTrace('Calling... getKernelDriverSettings()');

    my @prots = ('/dev/tcp', '/dev/udp');

    # To collect ip parameters using ndd, root access is required.
    my @value     = ();
    my $noOfProts = 0;
    my $noOfParms = 0;
    my $parmlist  = '';
    my $i         = 0;

    $noOfProts = scalar(@prots);
    for ($i = 0 ; $i < $noOfProts ; $i++)
    {
        my (@parms) = getKernelDriverTunables($prots[$i]);
        $noOfParms = scalar(@parms);
        if ($noOfParms > 0)
        {
            @parms    = filterList(@parms);
            $parmlist = join (' ', $prots[$i], @parms);
            @value    = getKernelDriverTunableValues($parmlist);
            loadKernelParmsToHash("$Ptdpm0::NDD $prots[$i]", \@parms, \@value);
        }
    }

}

sub loadKernelParmsToHash
{

    my $source = $_[0];
    my $parms  = $_[1];
    my $value  = $_[2];

    my $size1 = 0;
    my $size2 = 0;
    $size1 = scalar(@$parms);
    $size2 = scalar(@$value);
    my $i = 0;
    my $j = 0;
    for ($i = 0 ; $i < $size1 ; $i++)
    {
        if (!defined @$parms[$i] || @$parms[$i] eq NIL) { next; }
        $Ptdpm9::OSConf{$source}{@$parms[$i]}{$Ptdpm2::TYPE_TAG}  = $source;
        $Ptdpm9::OSConf{$source}{@$parms[$i]}{$Ptdpm2::NAME_TAG}  = @$parms[$i];
        $Ptdpm9::OSConf{$source}{@$parms[$i]}{$Ptdpm2::VALUE_TAG} = trim(@$value[$j]);
        if (index($source, $Ptdpm0::NDD) > -1)
        {
            $j++;
        }
        $j++;
    }
}

sub getBootTimeParameters
{
    debugTrace('Calling... getBootTimeParameters()');

    #Arguments:
    #Outputs  : array containing os kernel param name and value
    #Function : detects OS kernel params

    my (@nameSorted) = ();
    my $etc = getEtcSystemLocation();
    if ($etc eq '') { return @nameSorted; }

    my (%name_no_dups) = ();
    my (@instdate)     = ();
    my (@name)         = ();
    my $pgkg   = '';
    my $pkgid  = '';
    my $reqpkg = '';
    my $i      = 0;
    my $k      = 0;
    my $dupk   = 0;
    my $m      = 0;
    my $pname  = '';
    my $value  = '';

    my $line = '';
    debugTrace('Opening... ' . $etc);
    open(ES, "$etc");
    while (<ES>)
    {
        $line = $_;
        $m    = 0;

        # Trim string
        $line =~ s/^\s//;
        $line =~ s/\s$//;

        # Remove comments
        $line =~ s/\#.+$//;
        $line =~ s/\*.+$//;
        $line =~ s/^set\s+//;

        # Only take lines in the form 'name=value'
        next if ($line !~ /.+=.+/);

        # Get values, and put in array
        ($pname, $value) = split ('=', $line, 2);

        # Trim pname and value parameters
        $pname =~ s/^\s//;
        $pname =~ s/\s$//;
        $value =~ s/^\s//;
        $value =~ s/\s$//;

        # Store in list, name_no_dups holds index of named param in @name
        if (exists $name_no_dups{$pname})
        {

            # param name already seen, just replace its value
            $dupk = $name_no_dups{$pname};
            $name[$dupk][2] = joinValue($Ptdpm2::VALUE_TAG, $value);
            next;
        }
        else
        {

            # first occurrence of param name, save its index
            $name_no_dups{$pname} = $k;
        }

        $name[$k][$m] = joinValue($Ptdpm2::TYPE_TAG, 'KERNEL_PARAM');
        $m++;
        $name[$k][$m] = joinValue($Ptdpm2::NAME_TAG, $pname);
        $m++;
        $name[$k][$m] = joinValue($Ptdpm2::VALUE_TAG, $value);
        $m++;
        $k++;
    }
    close(ES);

    # return @name;

    # sort by kernel param name
    $k = 0;
    my $indexSorted = 0;
    foreach my $key (sort(keys(%name_no_dups)))
    {
        $indexSorted = $name_no_dups{$key};
        $m           = 0;
        $nameSorted[$k][$m] = $name[$indexSorted][$m];
        $m++;
        $nameSorted[$k][$m] = $name[$indexSorted][$m];
        $m++;
        $nameSorted[$k][$m] = $name[$indexSorted][$m];
        $m++;
        $k++;
    }

    return @nameSorted;
}

sub filterList
{
    my (@parms) = @_;

    my $i     = 0;
    my $par   = '';
    my $value = '';

    my @tmp = grep /(read and write)/, @parms;
    my $size = scalar(@tmp);
    for ($i = 0 ; $i < $size ; $i++)
    {
        ($par, $value) = split (' ', $tmp[$i], 2);
        if (!(index($par, "no read or write") > -1))
        {
            $tmp[$i] = $par;
        }
    }
    return @tmp;

}

sub getMaxSwapSpace
{
    debugTrace('Calling... getMaxSwapSpace()');

    return getAIXMaxSwapSpace();

    #Function: Calculate maximum swap space

    my ($i)         = 0;
    my ($swapspace) = 0;
    my (@swap)      = getSwapSpaceInfo();

    $swapspace = $swap[0] * 1024;
    return $swapspace;
}

sub getDNSNameServers
{
    debugTrace('Calling... getDNSNameServers()');

    my $file  = getResolvConf();
    my @parms = ();
    my @value = ();
    my @val   = ();
    my $i     = 0;
    if ($file ne NIL)
    {
        debugTrace('Opening... ' . $file);
        open(ES, "$file");
        while (<ES>)
        {
            if (index($_, "nameserver") > -1)
            {
                @val = split (' ', $_, 2);
                $value[$i++] = $val[1];
                $parms[$i] = "nameserver $i";
            }
        }
        close(ES);
        loadKernelParmsToHash($Ptdpm0::ETCRESOLVCONFFILE, \@parms, \@value);
    }

}

sub getAIXKernelDriverSettings
{
    debugTrace('Calling... getKernelDriverSettings()');

    my @value     = ();
    my $noOfParms = 0;
    my $parmlist  = '';
    my $i         = 0;
    my (@parms) = getKernelDriverTunables("all");

    $noOfParms = scalar(@parms);
    if ($noOfParms > 0)
    {
        @value    = getKernelDriverTunableValues("all");
        loadKernelParmsToHash("$Ptdpm0::NO", \@parms, \@value);
    }
}

sub getAIXMaxSwapSpace
{
    debugTrace('Calling... getAIXMaxSwapSpace()');

    #Function: Calculate maximum swap space

    my ($swapspace) = 0;
    my (@swap)      = getSwapSpaceInfo();

    $swapspace = trim($swap[0]);
    $swapspace =~ s/MB.*//;
    return $swapspace*1024*1024;
}

sub loadAIXBootParmsToHash
{
    my (@parms) = @_;

    my $source = 'SYS0';
    my $value  = '';
    my $rest   = '';
    my $i      = 0;
    my $j      = 0;
    my $size   = scalar(@parms);
    for ($i = 0 ; $i < $size ; $i++)
    {
        ($rest, $value) = split (':', $parms[$i][1], 2);
        if (!defined $value) { $value = ''; }
        chomp($value);
        if (trim($value) eq '') { next; }
        $Ptdpm9::OSConf{$source}{$parms[$i][1]}{$Ptdpm2::NAME_TAG} = $value;

        ($rest, $value) = split (':', $parms[$i][0], 2);
        chomp($value);
        $Ptdpm9::OSConf{$source}{$parms[$i][1]}{$Ptdpm2::TYPE_TAG} = $value;

        ($rest, $value) = split (':', $parms[$i][2], 2);
        chomp($value);
        $Ptdpm9::OSConf{$source}{$parms[$i][1]}{$Ptdpm2::VALUE_TAG} = $value;
    }
}

sub getAIXBootTimeParameters
{
    debugTrace('Calling... getBootTimeParameters()');

    my $pname  = '';
    my $value  = '';
    my $descr  = '';

    my $line = '';

    my $k = 0;
    my @namevalue = ();
    my @sysparams = ();

    @sysparams = `$Ptdpm0::LSATTR -l sys0 -E 2>$Ptdpm0::DEVNULL`;

    foreach $line (@sysparams)
    {
        ($pname, $value, $descr) = split (" ", $line, 3);
         $namevalue[$k][0] = joinValue($Ptdpm2::TYPE_TAG, 'KERNEL_PARAM');
         $namevalue[$k][1] = joinValue($Ptdpm2::NAME_TAG, $pname);
         $namevalue[$k][2] = joinValue($Ptdpm2::VALUE_TAG, $value);
         $k++;
    }
    return @namevalue;
}

#  ******************************************
#     Programming Comments
#  ******************************************

1;

#   End of the Program