The excerpts below are part of the Infrastructure Emulator that I originally 
developed in late '94 using Perl Version 4. This may be a little lengthy but I 
wanted you to see some of the standard documentation that is built-in to all 
of my scripts and how their organized. Of course, everyone wants to document 
better but they're rarely allowed the time to do it.

The first program is the wrapper script that is called by cron to start the 
collection process. The second is the script the generates on-the-fly expect** 
scripts to handle the telnetting into our switch system. The third is a 
settings/environment file that all the scripts have in common that allow 
configurational changes to be handled in a single place. **When I created this 
package the telnet module was not even available so I improvised, fortunately, 
it's all freeware.

What these scripts do is pull parameter settings from our switch system and 
load in onto our unix system and then the output is filtered and massaged into 
comma-delimited tables that the emulator scripts reference. When the collection 
completes and everything is filtered it is then loaded into both unix tables and 
a ZIP file that is accessible from a intranet page allowing it to be downloaded 
to a field persons laptop. When they unzip and run the update script it updates 
the data on the laptop. What was especially fun is that the emulator scripts for 
unix and win95 are identical. The only variation is the settings/environment file 
which is the only part that is OS dependent.

Now the fourth program is the emulator's main calling program that calls individual 
scripts. The fifth is one of the individual scripts and displays the parameter data. 
The sixth is the settings file that would exist on a Win95 system.

FIRST PROGRAM ------------------------------------------------------------------
#!/usr/local/bin/perl

# For   :  Network & RF Engineering
# Author:  Craig Steffler  714-222-8583
#          craigs@la.airtouch.com

# REVISION HISTORY
# DATE       BY    VER  DESCRIPTION
# 13-Jun-95  cws   1.0  Original

$VER = "2.25";
$PROG = "bbpmcp";

# PENDING
# INCLUDE SAMPLE OUTPUT WITH SOURCE CODE + ANY MEMOS REQUESTS IN DOCUMENTATION
# CHECK FOR ERROR RETURNS FROM ALL SYSTEM CALLS
# --------------------------------------------------------------------------
#                            BBPMCP


# BBPMCP is short for Big Brother Project Master Control Program. BBPMCP 
# is designed to control the collection of Switch parameter data then control 
# the auditing process before continuing. 
# When run by cron the program is called with a flag argument to determine
# which type of collecting, auditing, and updating is to be done. Use of 
# this program and those programs which it calls will directly impact the
# switches, but will exit cleanly if it should run into problems. 
##

# DISCLAIMER: This program as it is and all of its related programs as they
#             are should be considered as Proprietary and Confidential to
#             Air Touch Cellular and Air Touch Communications and should not
#             be distributed without prior written permission. There is also
#             no guarantee as to the use-ability outside of the L.A. Market.

# OUTPUT
# Any output is controlled by the called programs and therefore this program
# is not intended to have any output other than progress reports as to which
# section is running.

# PRINTED OUTPUT
# BBPMCP does not generate any printed reports. To generate a printed report
# please check the logging section of Big Brother to determine which log you
# need.

#                           MAINTENANCE
# REPORT GENERATION
# None

# SCHEDULED REPORT GENERATION
# The collections are run daily from a cron on an NCC station. Check with the
# NCC System Administrator for clarification. A typical cron entry is:
# 00 02 * * 1-5 /home/bigb/bin/bbpmcp >>/home/bigb/logs/bbpmcpa 2>&1
# Program runs @2am. Messages go to /home/bigb/logs/bbpmcpa.

# MESSAGES
# When run from cron, the program places messages in  /home/bigb/logs/bbpmcpa
# To see how the program is doing, look at these messages

# INPUT
# There are 2 sources of input but only from the command-line or cron:
#   -a              Collect All regular parameters.
#   -c              Collect All channel parameters.

# SEE ALSO
# /home/bigs/bin/bspmcp           Produces the Digital Counterpart

# DESCRIPTION
# More detailed description of what the program does and why. Special features.

# LOCATION
# Source:     /home/bigb/src/bbpmcp
# Production: /home/bigb/bin/bbpmcp

#                           ADMINISTRATION
# CONFIGURATION
# User-settable constants (see DEFINED CONSTANTS below):

# INSTALLATION
# bbpmcp has been tested on SUN SPARC workstations under SUN OS 4.1.3
# System requirements:
#    Perl, sh, pl, and /usr/5bin/pr
# Also requires:
#    /home/bigb/lib/bigbenv

# ENVIRONMENT
# No hardcoded paths are included other than the one to bigbenv.

# INTERNALS
# The input is assumed to be complete. If any problems are encountered
# check the logs in /home/bigd/logs
# The code is divided into 2 sections:
#  1. Collect all Regular Parameter Tables
#  2. Collect all Channel Parameter Tables

# INPUT FORMATS
# None

# OUTPUT FORMATS
# None 

# --------------------------------------------------------------------------
# ---------------------------- IMPORTS -------------------------------------
# Set the current environment
$bigbenv = "/home/bigb/lib/bigbenv";
open(FILE, $bigbenv) || die "Can't find $bigbenv: $!\n";
while (<FILE>)
{   eval; print $@; }
close(FILE);

# Trap the following signals (* means core is dumped):
$SIG{'HUP'} = 'trap';           #  1   Hangup   
$SIG{'INT'} = 'trap';           #  2   Interrupt ^C
$SIG{'QUIT'} = 'trap';          #  3   Quit
$SIG{'ABRT'} = 'trap';          #  6*  Abort (generated by abort(3) routine)
$SIG{'SYS'} = 'trap';           # 12*  Bad argument to system call
$SIG{'ALRM'} = 'trap';          # 14   Alarm clock
$SIG{'TERM'} = 'trap';          # 15   Software termination signal

# ------------------------  DEFINED CONSTANTS  -----------------------------
# Sizes:
$DAY = 24 * 60 * 60;            # Seconds per day
# Debug
#$trace1 = 1;			# Trace section 1

# ------------------------- GLOBAL VARIABLES -------------------------------
# Flags:
# --------------------------- MAIN PROGRAM ---------------------------------
# Get arguments from the command line
&usage("No args") if ($#ARGV < 0);

# Start up
print STDERR "$PROG ($VER) Pid $$. Starting at ", `date`;
# Get the current date
$date = `date +%y%m%d`; chop $date;

# ------------------ 1. GET ALL TABLES -------------------------------------
if ($ARGV[0] eq "-a")
{
  # This option is for getting all data from all tables and then audit,
  # report, and then update existing tables.
  print STDERR "$PROG ($VER) Section 1 - All Tables\n";

  # Normal running of Part A
  if ($trace1) { print "$SWITCHPARM a\n"; exit 1; }
  else { system("$SWITCHPARM a"); } 
  sleep($TENMINUTES);      # Delay to allow collection
  system("rm $STAGETABLES/*la*");
  system($REDOCPARM1); # Normal running
  system("cp $BBTABLES/*.la? $BBTABLES/older");
  $DIRFILE = "/tmp/cparm.dir";
  system("ls -la $STAGETABLES/cparm1* >$DIRFILE");
  open(DIRFILE,$DIRFILE);
  while (<DIRFILE>)
  {
    chop;
    @FIELD = split(/ +/o);
    if (($FIELD[4] + 0) && (substr($FIELD[0],0,1) eq "-"))
    {
      @F = split(/\//,$FIELD[8]);
      system("cp $FIELD[8] $BBTABLES");
      system("echo $date >$BBTABLES/$F[$#F].date");
    }
  }
  system("rm $DIRFILE");

  sleep($TENMINUTES);      # Delay to allow collection
  system("$SWITCHPARM b"); # Normal running of Part B 

  sleep($TENMINUTES);      # Delay to allow collection
  sleep($ONEHOUR); # Delay to allow collection
  sleep($ONEHOUR); # Delay to allow collection
  sleep($ONEHOUR); # Delay to allow collection
  sub rfm
  {
    system("/usr/bin/sed 's/\\000//g' <$FIELD[8] >/tmp/$FIELD[8].rfm");
    system("/usr/bin/sed 's/\r//g' </tmp/$FIELD[8].rfm >/tmp/$FIELD[8]");
    # system("$CRTR /tmp/$FIELD[8].rfm /tmp/$FIELD[8]");
    system("cp /tmp/$FIELD[8] $FIELD[8]");
    system("rm /tmp/$FIELD[8]*");
  }
  system($REDOPARMS); # Normal running
  system($REDOSECP); # Normal Running 
  system($REDOSEC2);
  system($REDOSECT);
  system($REDOOMNIP); # Normal Running
  system($REDOOMNI2);
  system($REDOOMNIT);
  system($REDODIRT);
  system($REDOCELVER);
  system($REDOCSCPRM);
  system($REDOHOTMRS);
  system($REDOCFEAT);
  system($REDOVCCPRM);
  system($REDOSMCELL);
  system($REDOSECORG);
  system($REDONAILED);
  system($REDODMXS);
  system("cp $BBTABLES/*.la* $BBTABLES/older");
  foreach $switch (@LASWITCHLIST)
  {
    for ($table=1;$table <= $TABLEMAX; $table++)
    {
      $TESTFILE = "$STAGETABLES/$TABLE{$table}$switch";
      if (-s $TESTFILE)
      {
        system("cp $TESTFILE $BBTABLES");
        system("echo $date >$BBTABLES/$TABLE{$table}$switch.date");
      }
    }
  }
  system("cp $BBTABLES/*.la* $BBTABLES3PP");

  # Copy data to Working area for compression and move to midas
  system("cp $BBTABLES/*la* $WORKINGDIR");
  $cmd  = "pkzip $WORKINGDIR/current.zip $WORKINGDIR/*la* $WORKINGDIR/bbsetup*";
  system($cmd);
  $cmd  = "pkzip $WORKINGDIR/bigbrother.zip $WORKINGDIR/*la* ";
  $cmd .= "$WORKINGDIR/disp* $WORKINGDIR/*BAT $WORKINGDIR/bigbenv";
  system($cmd);
  system("cp $WORKINGDIR/*zip $MIDASDOWN");

  # Now Audit the new tables against the old
  system("$AUDITPARMS -d");
  system("$AUDITSECP -d");
  system("$AUDITSEC2 -d");
  system("$AUDITSECT -d");
  system("$AUDITOMNIP -d");
  system("$AUDITOMNI2 -d");
  system("$AUDITOMNIT -d");
  system("$AUDITDIRT -d");
  system("$AUDITCSCPRM -d");
  system("$AUDITCFEAT -d");

print STDERR "$PROG ($VER) Finished at ", `date`;

# --------------------------- LOCAL FUNCTIONS ------------------------------
# --------------------------------------------------------------------------
# trap - Catch signals and handle them gracefully 
#
# INPUTS  The number of the signal sent to this process
# OUTPUTS Send message to user
# RETURNS Never returns
# --------------------------------------------------------------------------
sub trap
{
    local($sig) = @_;
    print STDERR "SIG$sig received by $PROG. Shutting down.\n";
    exit(1);
}
# --------------------------------------------------------------------------
# usage - Print usage message
#
# INPUTS  Error message string.
# OUTPUTS Sends message to stderr
# RETURNS Never returns
# --------------------------------------------------------------------------
sub usage
{
    print STDERR <<"EOF";
    $PROG ($VER) - Big Brother Project Master Control Program 
    Usage: $PROG -acdu
      where: (at least one flag is required)
             a   for all tables
             c   for cparms and dlparms (daily quick collect)
             d   for dmx tables: adjs and covars
             u   for cparms, dlparms and updating tables due to new cells
      EXAMPLE: $PROG -c

EOF
    print STDERR "Failed: $_[0] \n";
    exit 1;
}

# 34567890123456789012345678901234567890123456789012345678901234567890123456
# bbpmcp -------------------------------------------------------------------


SECOND PROGRAM -----------------------------------------------------------------
#!/usr/local/bin/perl

# For   :  RF Engineering
# Author:  Craig Steffler  714-222-8583
#          craigs@la.airtouch.com

# REVISION HISTORY
# DATE       BY    VER  DESCRIPTION
# 06-Oct-95  cws   1.0  Original

$VER = "1.9";
$PROG = "switchparm";

# PENDING
# Commented out most of startupscript to make it wait for > prompt. 970916
# INCLUDE SAMPLE OUTPUT WITH SOURCE CODE + ANY MEMOS REQUESTS IN DOCUMENTATION
# CHECK FOR ERROR RETURNS FROM ALL SYSTEM CALLS
# --------------------------------------------------------------------------
#                            SWITCHPARM

# This program creates a script for each switch that collects all the desired 
# tables one after another until finished. Since all the data is collected 
# using a single large script per switch instead of a series of smaller 
# scripts that login in and out of the switches, there is less of a chance 
# that the script will run into problems and not collect a particular table. 
# This program then allows the reformatting programs to update all the tables 
# very easily and without gaps in data as before. This program is designed to
# run automatically thru the cron utility probably on a daily basis.
##

# DISCLAIMER: This program as it is and all of its related programs as they
#             are should be considered as Proprietary and Confidential to
#             Air Touch Cellular and Air Touch Communications and should not
#             be distributed without prior written permission. There is also
#             no guarantee as to the use-ability outside of the L.A. Market.

# OUTPUT
# This program puts the scripts into the collecting directory that uses the
# runtime shell scripts which calls the collecting scripts to initiate 
# collecting and puts the raw output files into the download directory.

.
.
.

# ------------------------  DEFINED CONSTANTS  -----------------------------
# Sizes:
$maxmemnum = "128";
$WAIT30MIN = 30 * 60;		# Seconds to wait
$DAY = 24 * 60 * 60;		# Seconds per day

.
.
.

# --------------------------- LOCAL FUNCTIONS ------------------------------
# --------------------------------------------------------------------------
# endascript - Generates the ending portion of a script for a switch
#
# INPUTS  None
# OUTPUTS Sends data to proper scriptfile and directory
# RETURNS Returns to a generate... routine
# --------------------------------------------------------------------------
sub endascript
{
  $cmd = "send $DOUBLEQUOTE";
  $cmd .= "LOGO\\r$DOUBLEQUOTE\n";
  print SCRIPT $cmd;
  $cmd = "expect $DOUBLEQUOTE...>$DOUBLEQUOTE\n";
  print SCRIPT $cmd;
  $cmd = "exit\n";
  print SCRIPT $cmd;
  close(SCRIPT);
}
# --------------------------------------------------------------------------
# generateALLscripts - Generates an ALL other commands script for a switch
#
# INPUTS  switch number from Main Program
# OUTPUTS Sends data to proper scriptfile and directory
# RETURNS Returns to Main Program
# --------------------------------------------------------------------------
sub generateALLscripts
{
  # Create a wrapper script
  $CMDFILE = "$RUNTIME/swprmall-$sw";
  open(CMDFILE,">$CMDFILE") || die "Can't write to $CMDFILE: $!\n";
  print CMDFILE "$HDR_BOURNE\n";
  print CMDFILE "TERM\=vt100 \; export TERM\n";
  print CMDFILE "$COLLECTING/swprmall-$sw >$DOWNLOADDIR/swprmall.$sw\n";
#  print CMDFILE "$CRTR $DOWNLOADDIR/swprmall.$sw $DOWNLOADDIR/swall.$sw\n";
#  print CMDFILE "
  close(CMDFILE);
  system("chmod 755 $CMDFILE");

  # STARTING AND FIRST SCRIPT SECTION
  $scriptfile = "swprmall-";
  &startascript;   # makes startup portion for a switch START HERE ONLY

#  if ($flag eq "") || ($flag >= 1)
#  {
    # CREATE CPARM2 SCRIPT
    $capturefile = "bc.cpm2.";
    $tablecommand = "DISP MOB CPARM2";
    $cmdresponse = "NUMBER(S):";
    &makeaRANGE;     # makes command portion for a switch
#  }

#  if ($flag eq "") || ($flag >= 2)
    # CREATE DLPARM SCRIPT
    $capturefile = "bc.dlp.";
    $tablecommand = "DISP MOB DLPARM";
    $cmdresponse = "NUMBER(S)       :";
    &makeaRANGE;     # makes command portion for a switch

    # CREATE SECTOP SCRIPT
    $capturefile = "bc.sect.";
    $tablecommand = "DISP MOB SECT";
    $cmdresponse = "CELL NUMBER:";
    &makea3SEC;      # makes command portion for a switch

.
.
.

  &endascript;     # makes ending portion for a switch  END HERE ONLY
  system("chmod 755 $COLLECTING/$scriptfile$sw");
}
# --------------------------------------------------------------------------
# makeaBIGLOOP - Makes a COVAR script for each switch
#
# INPUTS  All variables
# OUTPUTS Sends data to proper scriptfile and directory
# RETURNS Returns to Main Program
# --------------------------------------------------------------------------
sub makeaBIGLOOP
{
  # Setup to capture first
  $cmd = "log_file -a $DOWNLOADDIR/$capturefile$sw\n";
  print SCRIPT $cmd;
  # Then begin Display command
  $cmd = "send $DOUBLEQUOTE";
  $cmd .= $tablecommand;
  $cmd .= "\\r$DOUBLEQUOTE\n";
  print SCRIPT $cmd;

# Run the Loop
  foreach $emx (@EMXLIST)
  {
    for ($loop = 1; $loop <= $loopsize; $loop++)
    {
    # Wait for the response
      $cmd = "expect $DOUBLEQUOTE";
      $cmd .= "$cmdresponse$DOUBLEQUOTE\n";
      print SCRIPT $cmd;
    # Then Display what currently exists
      $cmd = "send $DOUBLEQUOTE";
      $cmd .= "$emx $loop";
      $cmd .= "\\r$DOUBLEQUOTE\n";
      print SCRIPT $cmd;
    # Wait for the response
      $cmd = "expect $DOUBLEQUOTE";
      $cmd .= "$cmdresponse$DOUBLEQUOTE\n";
      print SCRIPT $cmd;
    # Then Display what currently exists
      $cmd = "send $DOUBLEQUOTE";
      $cmd .= "$emx $loop";
      $cmd .= "\\r$DOUBLEQUOTE\n";
      print SCRIPT $cmd;
    # Wait for the response
      $cmd = "expect $DOUBLEQUOTE";
      $cmd .= "$cmdresponse$DOUBLEQUOTE\n";
      print SCRIPT $cmd;
    # Then Display what currently exists
      $cmd = "send $DOUBLEQUOTE";
      $cmd .= "$emx $loop";
      $cmd .= "\\r$DOUBLEQUOTE\n";
      print SCRIPT $cmd;
    }
  }

  # Wait for the response
  $cmd = "expect $DOUBLEQUOTE";
  $cmd .= "$cmdresponse$DOUBLEQUOTE\n";
  print SCRIPT $cmd;

# Break out to prompt
  print SCRIPT "sleep 5\n";
  print SCRIPT "send $DOUBLEQUOTE$CTRLA$DOUBLEQUOTE\n";
  print SCRIPT "expect $DOUBLEQUOTE>$DOUBLEQUOTE\n";
  print SCRIPT "send $DOUBLEQUOTE\\r$DOUBLEQUOTE\n";
  print SCRIPT "expect $DOUBLEQUOTE>$DOUBLEQUOTE\n";

# Finish ending off
# Break out to prompt
  $cmd = "log_file\n";
  print SCRIPT $cmd;
}
# --------------------------------------------------------------------------
# makeaCELL - Makes a CELL-WIDE type script for a switch
#
# INPUTS  Variable values from a generate... routine
# OUTPUTS Sends data to proper scriptfile and directory
# RETURNS Returns to a generate... routine
# --------------------------------------------------------------------------
sub makeaCELL
{
  # Setup to capture first
  $cmd = "log_file -a $DOWNLOADDIR/$capturefile$sw\n";
  print SCRIPT $cmd;

  # Then begin Display command
  $cmd = "send $DOUBLEQUOTE";
  $cmd .= "$tablecommand";
  $cmd .= "\\r$DOUBLEQUOTE\n";
  print SCRIPT $cmd;

  # Now open CPARM1 file to get the sectored sites to be requested
  open(CPARM1,"$CPARM1$sw")
       || die "Can't open $CPARM1$sw: $!\n";
  while (<CPARM1>)
  {
      ($csn,$rest) = split(/,/,$_,2);
      # Wait for the response
      $cmd = "expect $DOUBLEQUOTE";
      $cmd .= "$cmdresponse$DOUBLEQUOTE\n";
      print SCRIPT $cmd;
      
      # Then Display what currently exists
      $cmd = "send $DOUBLEQUOTE";
      $cmd .= "$csn";
      $cmd .= "\\r$DOUBLEQUOTE\n";
      print SCRIPT $cmd;
  }
  close(CPARM1);
  # Wait for the response
  $cmd = "expect $DOUBLEQUOTE";
  $cmd .= "$cmdresponse$DOUBLEQUOTE\n";
  print SCRIPT $cmd;
# Break out to prompt
  print SCRIPT "send $DOUBLEQUOTE$CTRLA$DOUBLEQUOTE\n";
  print SCRIPT "expect $DOUBLEQUOTE>$DOUBLEQUOTE\n";
  print SCRIPT "send $DOUBLEQUOTE\\r$DOUBLEQUOTE\n";
  print SCRIPT "expect $DOUBLEQUOTE>$DOUBLEQUOTE\n";
# Finish ending off
# Break out to prompt
  $cmd = "log_file\n";
  print SCRIPT $cmd;
}
# --------------------------------------------------------------------------
# makeaCELLLOOP - Makes a CELL-WIDE type LOOP script for a switch
#
# INPUTS  Variable values from a generate... routine
# OUTPUTS Sends data to proper scriptfile and directory
# RETURNS Returns to a generate... routine
# --------------------------------------------------------------------------
sub makeaCELLLOOP
{
  # Setup to capture first
  $cmd = "log_file -a $DOWNLOADDIR/$capturefile$sw\n";
  print SCRIPT $cmd;

  # Now open CPARM1 file to get the sectored sites to be requested
  open(CPARM1,"$CPARM1$sw")
       || die "Can't open $CPARM1$sw: $!\n";
  while (<CPARM1>)
  {
    ($csn,$rest) = split(/,/,$_,2);

    # Then begin Display command
    $cmd = "send $DOUBLEQUOTE";
    $cmd .= "$tablecommand ";
    for ($loop=1; $loop <= $loopsize; $loop++)
    {  
      $cmd .= "$csn $loop ";
    }
    $cmd .= "\\r$DOUBLEQUOTE\n";
    print SCRIPT $cmd;

    # Wait for the response
    $cmd = "expect $DOUBLEQUOTE";
    $cmd .= "$cmdresponse$DOUBLEQUOTE\n";
    print SCRIPT $cmd;

    # Break out to prompt
    print SCRIPT "send $DOUBLEQUOTE$CTRLA$DOUBLEQUOTE\n";
    print SCRIPT "expect $DOUBLEQUOTE>$DOUBLEQUOTE\n";
    print SCRIPT "send $DOUBLEQUOTE\\r$DOUBLEQUOTE\n";
    print SCRIPT "expect $DOUBLEQUOTE>$DOUBLEQUOTE\n";
  }
  close(CPARM1);

# Finish ending off
# Break out to prompt
  $cmd = "log_file\n";
  print SCRIPT $cmd;
}
# --------------------------------------------------------------------------
# makeaCELLPLUS - Makes a CELL-WIDE type script for a switch
#
# INPUTS  Variable values from a generate... routine
# OUTPUTS Sends data to proper scriptfile and directory
# RETURNS Returns to a generate... routine
# --------------------------------------------------------------------------
sub makeaCELLPLUS
{
  # Setup to capture first
  $cmd = "log_file -a $DOWNLOADDIR/$capturefile$sw\n";
  print SCRIPT $cmd;

  # Then begin Display command
  $cmd = "send $DOUBLEQUOTE";
  $cmd .= "$tablecommand";
  $cmd .= "\\r$DOUBLEQUOTE\n";
  print SCRIPT $cmd;

  # Now open CPARM1 file to get the sectored sites to be requested
  open(CPARM1,"$CPARM1$sw")
       || die "Can't open $CPARM1$sw: $!\n";
  while (<CPARM1>)
  {
      ($csn,$rest) = split(/,/,$_,2);
      # Wait for the response
      $cmd = "expect $DOUBLEQUOTE";
      $cmd .= "$cmdresponse$DOUBLEQUOTE\n";
      print SCRIPT $cmd;
      
      # Then Display what currently exists
      $cmd = "send $DOUBLEQUOTE";
      $cmd .= "$csn $commandplus";
      $cmd .= "\\r$DOUBLEQUOTE\n";
      print SCRIPT $cmd;
  }
  close(CPARM1);
  # Wait for the response
  $cmd = "expect $DOUBLEQUOTE";
  $cmd .= "$cmdresponse$DOUBLEQUOTE\n";
  print SCRIPT $cmd;
# Break out to prompt
  print SCRIPT "send $DOUBLEQUOTE$CTRLA$DOUBLEQUOTE\n";
  print SCRIPT "expect $DOUBLEQUOTE>$DOUBLEQUOTE\n";
  print SCRIPT "send $DOUBLEQUOTE\\r$DOUBLEQUOTE\n";
  print SCRIPT "expect $DOUBLEQUOTE>$DOUBLEQUOTE\n";
# Finish ending off
# Break out to prompt
  $cmd = "log_file\n";
  print SCRIPT $cmd;
}
# --------------------------------------------------------------------------
# runchild - Runs a Switch Command to get a Table as a child process
#
# INPUTS  $cmd $note & $sw from calling routine
# OUTPUTS Send message to user or to a log if run by cron
# RETURNS Returns to calling routine
# --------------------------------------------------------------------------
sub runchild
{
  # Fork a child.  The parent sets an alarm and also waits for the child.
  if (($cpid = fork) != 0)
  {   # Parent process returns here with child's pid
      # Set an alarm.
     # alarm($SNOOZE);
      # Note the beginning time
      $begtm = `date +%H%M%S`; chop $begtm;
      print STDERR "@$begtm: Set alarm for child $note $sw.\n";
      # Wait for the child to return
      waitpid($cpid, 0);
      $status = $?;
      $endtm = `date +%H%M%S`; chop $endtm;
      print STDERR "@$endtm: Child for $note $sw exits with $status.\n";
    #  alarm(0);               # Turn off alarm
      # Quit with error status if premature return
     # if ($endtm - $begtm <= $SOON)
     # {   print STDERR "@$endtm: Premature return from child $note $sw.\n";
#        exit 2;
     # }
#      exit 0;  			# All's well that ends
  }
  else # Child process returns here
  {   $curtm = `date +%H%M%S`; chop $curtm;
      print STDERR "@$curtm: Child $note $sw starts $$\n";
      # Child execs a process.
      exec($cmd);
#      die "Child cannot execute $note $sw: $!\n";
  }
}
# --------------------------------------------------------------------------
# runcparm - Runs the TERM Script to get CPARM1s as a child process
#
# INPUTS  Switch Number
# OUTPUTS Send message to user or to a log if run by cron
# RETURNS Returns to Main Program - Part 2
# --------------------------------------------------------------------------
sub runcparm
{
  # Generate CPARM1 and ignore checking each result
  $cmd = "$RUNTIME/swprmcparm1-$sw &";
  &runchild($cmd);     # Runs command as child to avoid hanging everything
#  if ($erno = $? >> 8)
#  {   print STDERR "$cmd fails: $erno\n";}
#  if (! -r "$DOWNLOADDIR/bc.cpm1.$sw")
#  {   print STDERR "SWPRMCPARM1 for $sw not generated$again1!\n"; $ok1 = $sw;}
}
# --------------------------------------------------------------------------
# runall - Runs the TERM Script to get ALL Tables as a child process
#
# INPUTS  Switch Number
# OUTPUTS Send message to user or to a log if run by cron
# RETURNS Returns to Main Program - Part 1
# --------------------------------------------------------------------------
sub runall
{
  # Generate ALL and ignore checking each result
  $cmd = "$RUNTIME/swprmall-$sw &";
  &runchild($cmd);     # Runs command as child to avoid hanging everything
#  if ($erno = $? >> 8)
#  {   print STDERR "$cmd fails: $erno\n";}
#  if (! -r "$DOWNLOADDIR/bc.cpm2.$sw")
#  {   print STDERR "Cparm1 for $sw not generated$again1!\n"; $ok1 = $sw;}
}
# --------------------------------------------------------------------------
# startascript - Generates the startup portion of a script for a switch
#
# INPUTS  Variable values from Generate Scripts section
# OUTPUTS Sends data to proper scriptfile and directory
# RETURNS Returns to Main Program
# --------------------------------------------------------------------------
sub startascript
{
  open(SCRIPT,">$COLLECTING/$scriptfile$sw")
       || die "Can't write to $COLLECTING/$scriptfile$sw: $!\n";
  print SCRIPT "$HDR_EXPECT\n";
  print SCRIPT "spawn telnet $BBP_SVR $PORT{$sw}\n";
#  print SCRIPT "log_user 0\n";
  print SCRIPT "send $DOUBLEQUOTE\\r\\r\\r$DOUBLEQUOTE\n";
  print SCRIPT "sleep 10\n";
  print SCRIPT "send $DOUBLEQUOTE\\021$DOUBLEQUOTE\n";
  print SCRIPT "sleep 10\n";
  print SCRIPT "send $DOUBLEQUOTE\\001$DOUBLEQUOTE\n";
  print SCRIPT "sleep 10\n";
  $cmd = "send $DOUBLEQUOTE";
  $cmd .= "STOP IPR\\r$DOUBLEQUOTE\n";
  print SCRIPT $cmd;
  print SCRIPT "sleep 10\n";
  $cmd = "send $DOUBLEQUOTE";
  $cmd .= "LOGO\\r$DOUBLEQUOTE\n";
  print SCRIPT $cmd;
  print SCRIPT "sleep 10\n";
  $cmd = "send $DOUBLEQUOTE";
  $cmd .= "LOGI\\r$DOUBLEQUOTE\n";
  print SCRIPT $cmd;
  # NOW TO LOGIN 
  $cmd = "expect $DOUBLEQUOTE";
  $cmd .= "NAME:$DOUBLEQUOTE\n";
  print SCRIPT $cmd;
  $cmd = "send $DOUBLEQUOTE";
  $cmd .= "$un\\r$DOUBLEQUOTE\n";
  print SCRIPT $cmd;
  $cmd = "expect $DOUBLEQUOTE";
  $cmd .= "WORD:$DOUBLEQUOTE\n";
  print SCRIPT $cmd;
  $cmd = "send $DOUBLEQUOTE";
  $cmd .= "$pd\\r$DOUBLEQUOTE\n";
  print SCRIPT $cmd;
  print SCRIPT "expect $DOUBLEQUOTE>$DOUBLEQUOTE\n";
  print SCRIPT "set timeout $WAIT30MIN\n";
}
# --------------------------------------------------------------------------
# trap - Catch signals and handle them gracefully 
#
# INPUTS  The number of the signal sent to this process
# OUTPUTS Send message to user
# RETURNS Never returns
# --------------------------------------------------------------------------
sub trap
{
    local($sig) = @_;
    print STDERR "SIG$sig received by $PROG. Shutting down.\n";
    exit(1);
}
# --------------------------------------------------------------------------
# usage - Print usage message
#
# INPUTS  Error message string.
# OUTPUTS Sends message to stderr
# RETURNS Never returns
# --------------------------------------------------------------------------
sub usage
{
    print STDERR <<"EOF";
    $PROG ($VER) - Switch Parameters Collector 
    Usage: $PROG abcd[no][sw]
      where:
           a is to run CPARM1 Section Only
             OR
           b is to run ALL OTHERS [a,b,c or d MUST BE USED]
	   n is for specifying a switch with a new Software Version [OPTIONAL]
	   o is for specifying a switch with an old Software Version [OPTIONAL]
	   sw is a switch number from 3 to 7 [OPTIONAL]
      NOTE: if n or o options are used switch number must be next character

      EXAMPLE 1: $PROG a       run CPARM1 Section only for all switches
      EXAMPLE 2: $PROG b6      run ALL OTHERS for Switch 6 only
      EXAMPLE 3: $PROG b       run ALL OTHERS for all switches
      EXAMPLE 4: $PROG an4     run CPARM1 Section for New Version on Switch 4
      EXAMPLE 5: $PROG ao5     run CPARM1 Section for Old Version on Switch 5
      EXAMPLE 6: $PROG c       run ALL CHANNELS for all switches
      EXAMPLE 7: $PROG d       run CHANNELS for only certain switch/cells

EOF
    print STDERR "Failed: $_[0] \n";
    exit 1;
}

# 34567890123456789012345678901234567890123456789012345678901234567890123456
# switchparm ---------------------------------------------------------------

THIRD PROGRAM ---------------------------------------------------------------------
#!/usr/local/bin/perl
# setbigbrother - Set Big Brother environment variables
# A perl script to set environment variables for Big Brother scripts.
# Make sure you don't use same names as perlenv.
# This is especially important for scripts run from cron.
# Update this script as the system configuration changes (SINGLE LINES ONLY).
# It is important to not bury these details in individual scripts!

# REVISION HISTORY
# VER DATE       BY    DESCRIPTION
# 1.0 27-Jan-95  cws   Original
.
.
.
# 9.7 06-Jan-99  cws   Added MIDASDOWN to Miscellaneous Paths

# Environment
umask(0);

# DEFINED CONSTANTS
$BBPADM = "craigs@la.airtouch.com";
$BBPADMNOTE = "Please send questions to Craig Steffler 714-222-8583 or $BBPADM";
$BBPCHGLOG = "/usr/local/csn/reports/celldata/bbpchglog.cur";
$BBP_SVR = "laforge";
$CELLSFIRST = "/usr/nss/nms/utils/data/cells"; # Looked at first
%CELLTYPE = ("TSRS 120 DEG","120 Degree","TORO ","Omni");
$COMMANDFILE = "/net/vulcan/u1/bbwork/b_";
$CRTR = "/usr/local/csn/reports/lib/crtr";
$DOT1 = 1;
#$DOUBLEQUOTE = "\"";
@EMXLIST = (1,2,3,12,11,16,6,19);
$EMXLISTING = "1, 2, 3, 12, 11, or 16";
%EMX2SWITCH = (1,3,2,4,3,5,12,6,6,"SD",19,"SB",11,7,16,8);
$HDR_BOURNE = "\#\!/bin/sh";
$HDR_EXPECT = "\#\!/usr/local/bin/expect --";
$HDR_EXPECT_F = "\#\!/usr/local/bin/expect -f";
$HELPDIR = "/home/bigb/bin/bb20/commands/help";
$HOME = $ENV{'HOME'};
@LASWITCHLIST = (3,4,5,6,7,8);
$LOGFILE = "/usr/local/csn/reports/celldata/bblog.cur";
$LOGNAME = $ENV{'LOGNAME'};
@OLDERLASWITCHES = (3,4,5,6);
%PORT = (3,8036,4,8037,5,8038,6,8039,7,8040,8,8041,11,8042,12,8043,13,8044);
#$REPORTPEOPLE = "rftraf,rfnorth,rfeast,rfsouth,rfwest";
$REPORTPEOPLE = "craigs";
$SCRIPTFILE = "$ENV{'HOME'}/swscr.";
$SCRIPTLOG = "/usr/local/csn/reports/celldata/bbscrlog.cur";
%SWITCH2EMX = (3,1,4,2,5,3,6,12,7,11,8,16,11,8,12,9);
$SWITCHLISTING = "3, 4, 5, 6, 7, or 8";
$TERMAPP = "/net/crusher/usr/bin/term -ltelnet:yar";
$TERMAPPQ = "/net/crusher/usr/bin/term -q -l/usr/local/bin/dkdest:laforge:";
$TERMLIB = "/usr/local/csn/reports/lib/term";
$TMPDIR = "/tmp";
$UPGRADEDSWITCHES = "345678";
$USERSDIR = "/home/bigb/bin/bb20/commands/Users";
$USRLOG = "/home/bigb/logs/usrlog";
$WORKFILE = "$ENV{'HOME'}/.bbpw";
$YESTERDAY = "/usr/local/bin/yesterday";

# Miscellaneous Paths
$AMADOT1 = "/usr/local/amadot1";
$MIDASDOWN = "/net/midasprod/usr/ns-home/prod/docs/depts/network/downloads";

# Collecting Paths
$DOWNLOADDIR = "/home/bigb/bin/bb20/staging/download";
$CAPTUREDIR = "/home/bigb/bin/bb20/staging/captured";
$AUDITLOGDIR = "/home/bigb/bin/bb20/staging/logs";
$WORKINGDIR = "/home/bigb/bin/bb20/staging/working";
$REPORTSDIR = "/home/bigb/bin/bb20/staging/reports";
$BBTABLES = "/home/bigb/bin/bb20/bbtables";
$BBTABLES3PP = "/home/bigb3pp/bin/bb20/bbtables";
$STAGETABLES = "/home/bigb/bin/bb20/staging/tables";
$RUNTIME = "/home/bigb/bin/bb20/staging/runtime";
$COLLECTING = "/home/bigb/bin/bb20/commands/collecting";
$RAWCPARM1 = "$DOWNLOADDIR/bc.cpm1.";
$RAWCPARM2 = "$DOWNLOADDIR/bc.cpm2.";
$RAWDLPARM = "$DOWNLOADDIR/bc.dlp.";
$RAWADJEMX = "$DOWNLOADDIR/bd.adj.";
$RAWCOVAR = "$DOWNLOADDIR/bd.cov.";
.
.
.
$RAWVCCPRM = "$DOWNLOADDIR/be.vccprm.";
$CHANCHGFILE = "/net/locutus/u/craigs/staging/working/chanchgfile";

# Big Brother Tables
$SECPRM = "/home/bigb/bin/bb20/bbtables/secprm.la";
$SEC2PRM = "/home/bigb/bin/bb20/bbtables/sec2prm.la";
.
.
.
$CHAN = "/home/bigb/bin/bb20/bbtables/chan.la";
$CHNSAT = "/home/bigb/bin/bb20/bbtables/chnsat.la";

# Paths to DISPLAY Programs referred to by DISP Program
$SECP = "/home/bigb/bin/bb20/commands/disp/disp.mob.secp";
$SEC2 = "/home/bigb/bin/bb20/commands/disp/disp.mob.sec2";
$SECT = "/home/bigb/bin/bb20/commands/disp/disp.mob.sect";
.
.
.
$DISPSECORG = "/home/bigb/bin/bb20/commands/disp/disp.cp.secorg";

# Paths to CHANGE Programs referred to by CHAN Program
$CHANSECP = "/home/bigb/bin/bb20/commands/chan/chan.mob.secp";
$CHANSEC2 = "/home/bigb/bin/bb20/commands/chan/chan.mob.sec2";
$CHANSECT = "/home/bigb/bin/bb20/commands/chan/chan.mob.sect";
.
.
.
$CHANCFEAT = "/home/bigb/bin/bb20/commands/chan/chan.cell.feat";
$CHANCVER = "/home/bigb/bin/bb20/commands/chan/chan.cell.ver";

# Paths to STATUS Programs referred to by STAT Program
#$STATCELL = "/home/craigs/Projects/BigBrother/Stat/stat.mob.cell";
$STATCELL = "/home/bigb/bin/bb20/commands/stat/stat.mob.cell";

# Paths for Auditing Programs
$AUDITSECP = "/home/bigb/bin/bb20/commands/auditing/audit.secp";
$AUDITSEC2 = "/home/bigb/bin/bb20/commands/auditing/audit.sec2";
$AUDITSECT = "/home/bigb/bin/bb20/commands/auditing/audit.sect";
.
.
.
$ANOMOLYFILE = "/home/bigb/bin/bb20/staging/reports/anomolous.changes";
$DISP = "/usr/local/csn/reports/celldata/DISP";
$CHAN = "/usr/local/csn/reports/celldata/CHAN";
$BBOLAUDIT = "/home/bigb/bin/bb20/commands/auditing/bbolaudit";
$CHANGEFILE = "/home/bigb/bin/bb20/staging/reports/normal.changes";

# Paths for Collecting Programs
$UPDATECELLS = "/home/bigb/bin/bb20/commands/collecting/updatecells";
$SWITCHPARM = "/home/bigb/bin/bb20/commands/collecting/switchparm";
.
.
.
$REDOSECORG = "/home/bigb/bin/bb20/commands/collecting/redosecorg";
$REDONAILED = "/home/bigb/bin/bb20/commands/collecting/redonailed";
$REDOCHANPRM = "/home/bigb/bin/bb20/commands/collecting/redochanprm";
$REDOCHAN = "/home/bigb/bin/bb20/commands/collecting/redochan";
$REDOCHNSAT = "/home/bigb/bin/bb20/commands/collecting/redochnsat";


FOURTH PROGRAM -------------------------------------------------------------------
#!/usr/local/bin/perl

# For   :  RF Engineering
# Author:  Craig Steffler  714-222-8583
#          craigs@la.airtouch.com

# REVISION HISTORY
# DATE       BY    VER  DESCRIPTION
# 19-Dec-94  cws   1.0  Original
.
.
.

$VER = "1.17";
$PROG = "DISP";

# PENDING
# INCLUDE SAMPLE OUTPUT WITH SOURCE CODE + ANY MEMOS REQUESTS IN DOCUMENTATION
# CHECK FOR ERROR RETURNS FROM ALL SYSTEM CALLS
# --------------------------------------------------------------------------
#                            DISP

# DISP is the main server portion of the BIG BROTHER PROJECT to emulate the 
# Motorola EMX-2500 Switches. DISP is used in upper case as to allow the same 
# commands to work as in the switch eliminating another set of commands for 
# the user to learn. Along with the CHAN server portion this makes dialing 
# into the switch for the most part obsolete and at the same time allows users 
# to get significantly more information than is available in the switch. Since 
# changes can be made from Unix instead of the switch it allows the Unix to 
# keep real-time data for the switch on Unix and allows the switch to do its 
# primary job of processing call traffic. Used primarily by RF System 
# Performance Engineers it also allows auditing and logging of changes the 
# keep them informed of what is happening in their switch aand to their cells. 
# Another advantage is that if an outdated or incorrect tape is reloaded into 
# the switch a backup copy will exist on the Unix allowing easier and more 
# accurate recovery when needed. The DISP program will function primarily as a 
# server that will initiate the proper sub-program allowing a modular design 
# that can be adjusted as needed.
.
.
.
# --------------------------------------------------------------------------
# ---------------------------- IMPORTS -------------------------------------
# Set the current environment
$bigbenv = "/home/bigb/lib/bigbenv";
$bigbenv3pp = "/home/bigb3pp/lib/bigbenv";
$bigbenvpc = "C:\\home\\bigb\\lib\\bigbenv";
open(FILE, $bigbenv) 
     || open(FILE, $bigbenv3pp)
     || open(FILE, $bigbenvpc) || die "Sorry, Big Brother is down: $!\n";
while (<FILE>)
{   eval; print $@; }
close(FILE);
# ------------------------  DEFINED CONSTANTS  -----------------------------
# Sizes:
$DAY = 24 * 60 * 60;            # Seconds per day

# Debug
$trace1 = 0;			# Trace section 1

# ------------------------- GLOBAL VARIABLES -------------------------------
# Flags:
$flag = 1;
# --------------------------- MAIN PROGRAM ---------------------------------
# Get arguments from the command line
&usage("No args") if ($#ARGV < 0);
# Load parameters from ARGV array into single string for passing on
$values = '';
for ($lcv=2; $lcv<=$#ARGV; $lcv++)
  {
    $values .= sprintf("%s ",$ARGV[$lcv]);
  }

#  Write information about the DISP User to a file
#$lcadate = `date +%y%m%d`; chop $lcadate; 
$hold = localtime();
$lcaname = getlogin;
#$cmd = "DISP,$hold,$lcaname,$ARGV[0] $ARGV[1] $values";
#$cmd  = "\@echo $DOUBLEQUOTE";
$cmd .= "DISP,$hold,$lcaname,$ARGV[0] $ARGV[1] $values";
#$cmd .= ">>$USRLOG";
#$returnvalue = &system95("$cmd");
open(USRLOG,">>$USRLOG") || warn "Problem with log\n";
print USRLOG "$cmd\n";
close(USRLOG);
#system("$cmd >>$USRLOG");

# ------------------ I.  SEND TO PROPER COMMAND ----------------------------

if (($ARGV[0] eq "MOB") or ($ARGV[0] eq "mob"))
  {
    if ($ARGV[1] eq "SECP") { $flag=0; system("$SECP $values"); }
    if ($ARGV[1] eq "SECPRM") { $flag=0; system("$SECP $values"); }
    if ($ARGV[1] eq "SEC2") { $flag=0; system("$SEC2 $values"); }
    .
    .
    .
    if ($ARGV[1] eq "HOTMRS") { $flag=0; system("$DISPHOTMRS $values"); }
    if ($flag) { $flag=0; print "\nSorry, command is not yet supported.\n"; }
  }
if ($ARGV[0] eq "CP")
  {
    if ($ARGV[1] eq "SECORG") { $flag=0; system("$DISPSECORG $values"); }
    if ($ARGV[1] eq "NAILED") { $flag=0; system("$DISPNAILED $values"); }
    if ($flag) { $flag=0; print "\nSorry, command is not yet supported.\n"; }
  }
if ($ARGV[0] eq "CELNET")
  {
    if ($ARGV[1] eq "ADJEMX") { $flag=0; system("$DISPADJ $values"); }
    if ($ARGV[1] eq "COVAR") { $flag=0; system("$DISPCOVAR $values"); }
    if ($ARGV[1] eq "COVAR2") { $flag=0; system("$DISPCOVAR2 $values"); }
    if ($flag) { $flag=0; print "\nSorry, command is not yet supported.\n"; }
  }
if ($ARGV[0] eq "CELL")
  {
    if ($ARGV[1] eq "FEAT") { $flag=0; system("$DISPCFEAT $values"); }
    if ($flag) { $flag=0; print "\nSorry, command is not yet supported.\n"; }
  }
if ($ARGV[0] eq "IPR")
  {
    if ($ARGV[1] eq "DICT") { $flag=0; system("$IPRDICT $values"); }
    if ($flag) { $flag=0; print "\nSorry, command is not yet supported.\n"; }
  }
if ($flag) { print "\nSorry, command is not yet supported.\n"; }

# --------------------------- LOCAL FUNCTIONS ------------------------------
# --------------------------------------------------------------------------
# trap - Catch signals and handle them gracefully 
#
# INPUTS  The number of the signal sent to this process
# OUTPUTS Send message to user
# RETURNS Never returns
# --------------------------------------------------------------------------
sub trap
{
#    local($sig) = @_;
#    print STDERR "SIG$sig received by $PROG. Shutting down.\n";
#    exit(1);
}
# --------------------------------------------------------------------------
# usage - Print usage message
#
# INPUTS  Error message string.
# OUTPUTS Sends message to stderr
# RETURNS Never returns
# --------------------------------------------------------------------------
sub usage
{
    print STDERR <<"EOF";
    $PROG ($VER) - Motorola EMX 2500 Switch Emulator 
    Usage: $PROG MOB CMD csn [csn...]
    Usage: $PROG CELNET CMD csn [csn...]
    Usage: $PROG CELL CMD csn [csn...]
      where:
             MOB CMD is MOB SECP
	     CELNET CMD is CELNET ADJEMX
	     CELL CMD is CELL FEAT
	     csn is 2 to 511
             (if csn exists in multiple switches you get to choose a switch)

      EXAMPLE: $PROG MOB SECP 191 205 366

EOF
    print STDERR "Failed: $_[0] \n";
    exit 1;
}

# 34567890123456789012345678901234567890123456789012345678901234567890123456
# DISP ---------------------------------------------------------------------


FIFTH PROGRAM ------------------------------------------------------------------------
#!/usr/local/bin/perl

# For   :  RF Engineering
# Author:  Craig Steffler  714-222-8583
#          craigs@la.airtouch.com

# REVISION HISTORY
# DATE       BY    VER  DESCRIPTION
# 04-Jan-95  cws   1.0  Original
.
.
.

$VER = "2.0";
$PROG = "DISP MOB SECP";

# PENDING
# INCLUDE SAMPLE OUTPUT WITH SOURCE CODE + ANY MEMOS REQUESTS IN DOCUMENTATION
# CHECK FOR ERROR RETURNS FROM ALL SYSTEM CALLS
# --------------------------------------------------------------------------
#                            DISP MOB SECP

# Emulates the DISPLAY MOB SECPRM in a Motorola switch almost identically
# except that a switch designation may be used to eliminate superfluous data.
# Eliminates the necessity of requiring the user to dial into a switch to get
# near realtime data on cell site information. Used primarily by the RF System
# Performance Field Engineers it is also useful to others in Network
# Engineering.
##

# OUTPUT
# There are 2 sets of basic reports generated. They are:
# Motorola Standard "by default". (as it appears in the switch)
#          CMP       #   MAX  MAX  MIN  MIN RC           LNA NOM  MX EHO  OU OU 
#SW CSN S  FLG PSHO IHO    SS   #    SS   # ANT RPV FCT  OFS   SS PL  THR MX EHO
#-- --- -  --- ---- ---  ---- ---  ---- --- --- --- ---- --- ---- -- ---- -- ---
# 4 226 1  REL  136   3   148   3   125   3   3  10  125  51  147  0   50  0  NA
# 4 226 2  REL  136   3   148   3   120   3   3   9  125  70  140  0   50  0  NA
# 4 226 3  REL  129   3   149   3   125   2   3   7  125  61  129  2   78  0  NA
#
# By dBM value (reality).
#          CMP       #   MAX  MAX  MIN  MIN RC           LNA NOM  MX EHO  OU OU 
#SW CSN S  FLG PSHO IHO    SS   #    SS   # ANT RPV FCT  OFS   SS PL  THR MX EHO
#-- --- -  --- ---- ---  ---- ---  ---- --- --- --- ---- --- ---- -- ---- -- ---
# 4 226 1  REL  -79   3   -74   3   -84   3   3  10  -84  51  -74  0 -118  0  NA
# 4 226 2  REL  -71   3   -66   3   -78   3   3   9  -76  70  -69  0 -109  0  NA
# 4 226 3  REL  -78   3   -69   3   -80   2   3   7  -80  61  -78  2 -101  0  NA
#
#
# There are also 3 additional options available that can be used in any
# combination or together:
#   By specific switch (3,4,5,6)
#   Motorola with dBM values
#   Ranges as in 3-511 OR 50-100 (Best to specify switch)

# FUTURE PLANS
# To include COMPARE FLAG data when available

# PRINTED OUTPUT
# No output is printed but can be piped to lp or lpr

#                           MAINTENANCE
# REPORT GENERATION
# No report generated.

# SCHEDULED REPORT GENERATION
# No scheduled report generated.

# MESSAGES
# When run the standard starting message indicates when it started
# DISP MOB SECP (1.0) Pid 3773. Starting at Tue Jan  3 15:15:49 PST 1995

# INPUT
# There are 5 optional and 1 required sources of input:
#   csn                         Required Cell Site Number
#   csn ...                     Optional Multiple Cell Site Numbers
#   switch                      Optional Switch Number (3-6)
#   d                           Optional dBM values
#   m                           Optional Motorola values (default)
#   begin-end                   Optional Ranges of csn's 

# SEE ALSO
# disp.mob.sec2        Display Mobile Sec2prm
# disp.mob.sect        Display Mobile Sectop
# disp.mob.omnip       Display Mobile Omniprm
# disp.mob.omni2       Display Mobile Omni2prm
# disp.mob.omnit       Display Mobile Omnitop
# OTHER RELATED COMMANDS
# chan.mob.secp        Change Mobile Secprm
# DISP                 Display Commands

# DESCRIPTION
# Emulates the DISPLAY MOB SECPRM command in a Motorola switch almost
# identically except that the user is allowed to specify switch, dBM
# values, dBM and Motorola values together and a range of cells. The
# primary advantage is that it allows the user to get near realtime cell
# information without having to dial into a switch, thus alleviating a
# mundane task from the switch allowing it to use the time to process
# calls. Used primarily by the RF System Performance Field Engineers it is
# also useful to others in Network Engineering like Switching & Interconnect
# and Network Operations. Another advantage is that the syntax is very close
# to the syntax required by the Switch when directly dialed in, the only
# differences being that switch, dBM values and ranges of cells can be
# requested which aren't available in the switch. Also since the data is on
# Unix it allows auditing, trouble shooting, easy file capturing for further
# processing  and fancier output if needed. Additionally it can be used when
# remotely dialed into Unix where graphical user interfaces are usually
# useless. 

# LOCATION
# Source:     /home/bigb/src/Disp/disp.mob.secp 
# Production: /home/bigb/bin/bb20/commands/disp/disp.mob.secp
#         or: /home/bigb3pp/bin/bb20/commands/disp/disp.mob.secp
#         or: C:\home\bigb\bin\bb20\commands\disp\disp.mob.secp

#                           ADMINISTRATION
# CONFIGURATION
# User-settable constants (see DEFINED CONSTANTS below):
#  $LRFLOSS 	Threshold for RF Loss Assign in %

# INSTALLATION
# xxx has been tested on SUN SPARC workstations under SUN OS 4.1.3
# System requirements:
#    Perl, sh, pl, and /usr/5bin/pr
# Also requires:
#    /home/bigb/lib/bigbenv
#    or /home/bigb3pp/lib/bigbenv
#    or C:\home\bigb\lib\bigbenv

# ENVIRONMENT
# No hardcoded paths are included other than the one to bigbenv.

# INTERNALS
# The input is checked for completeness. If any ... are missing ...
# The code is divided into xxx sections:
#  1. xxx

# INPUT FORMATS
# The xxx formats are noted below.  xxx

# OUTPUT FORMATS
# 1 xxx 

# --------------------------------------------------------------------------
# ---------------------------- IMPORTS -------------------------------------
# SET THE CURRENT ENVIRONMENT
# The use of several paths for the environment files is to allow for Windows 
# and numerous unix paths depending on what system you are using at the time. 
# It also allows the same script to operate on any operating system without 
# changes.
$bigbenv = "/home/bigb/lib/bigbenv";
$bigbenv3pp = "/home/bigb3pp/lib/bigbenv";
$bigbenvpc = "C:\\home\\bigb\\lib\\bigbenv";
open(FILE, $bigbenv)
     || open(FILE, $bigbenv3pp)
     || open(FILE, $bigbenvpc)
     || die "Sorry, Big Brother is down: $!\n";
while (<FILE>)
{   eval; print $@; }
close(FILE);

# Trap the following signals (* means core is dumped):
$SIG{'HUP'} = 'trap';           #  1   Hangup   
$SIG{'INT'} = 'trap';           #  2   Interrupt ^C
$SIG{'QUIT'} = 'trap';          #  3   Quit
if (!$WINDOWS) 
{
  $SIG{'ABRT'} = 'trap';          #  6*  Abort (generated by abort(3) routine)
}
$SIG{'SYS'} = 'trap';           # 12*  Bad argument to system call
$SIG{'ALRM'} = 'trap';          # 14   Alarm clock
$SIG{'TERM'} = 'trap';          # 15   Software termination signal

# ------------------------  DEFINED CONSTANTS  -----------------------------
# Sizes:
$DAY = 24 * 60 * 60;            # Seconds per day

# Formatting:
# for normal operation
$headformat = " %2s %3s %1s  %3s %4s %3s  %4s %3s  %4s %3s %3s %3s %4s";
$headformat .= " %3s %4s %2s %4s %2s %3s\n";
$bodyformat = " %2d %3d %1d  %3s %4d %3d  %4d %3d  %4d %3d %3d %3d %4d";
$bodyformat .= " %3d %4d %2d %4d %2d %3s\n";
# for multiple versions 
$headformatM = " %2s %3s %1s %3s %4s %3s %4s %3s %4s %3s %3s %3s %4s";
$headformatM .= " %3s %4s %2s %4s %2s %2s %3s\n";
$bodyformatM = " %2d %3d %1d %3s %4d %3d %4d %3d %4d %3d %3d %3d %4d";
$bodyformatM .= " %3d %4d %2d %4d %2d %2s %3s\n";

# Debug
$trace1 = 0;			# Trace section 1

# ------------------------- GLOBAL VARIABLES -------------------------------
# Flags:
$headerflag = 1;
$loadflag = 1;
$switchflag = 1;
$switch = $dbmflag = $motoflag = 0;

# --------------------------- MAIN PROGRAM ---------------------------------

# Check to see if "-p" prompting is requested as for Workspace Menu Option
if ($ARGV[0] eq "-p") { &menuprompting; }

# Get arguments from the command line
if ($WINDOWS) { &usage("No args") if ($ARGV[0] eq "-h"); }
else { &usage("No args") if ($#ARGV < 0); }

# Start up
if ($WINDOWS) 
{
  $hold = localtime();
  print STDERR "$PROG ($VER) Pid $$. Starting at $hold\n"; 
  open(OUTFILE,">$DESKTOP\\d.m.secp.txt");
}
else { print STDERR "$PROG ($VER) Pid $$. Starting at ", `date`; }

foreach $input (@ARGV)
  {
    # Load Tables into memory if first time into program 
    if ($loadflag) { &loader; }
    # DASHER - Look for Range
    if (index($input,"-") >= 0) # See if a switch was mentioned
    { 
      # LOOPER - See if range requested
      if (index($input,"-")>0) # Check if range mentioned
      {  
        $range = 1;
        $left = substr($input,0,index($input,"-"));
        $rightstart = index($input,"-")+1;
        $end = length($input);
        $right = substr($input,$rightstart,$end-$rightstart);
        for ($rangectr=0; $rangectr < $totals; $rangectr++)
        { 
          if ($switch)
          { 
            if (($ssw[$rangectr] == $switch) &&
             (($left <= $scsn[$rangectr]) && ($right >= $scsn[$rangectr])))
             {
               $looker = $rangectr; &datasend;
             }
          }
          else
          {
            if (($left <= $scsn[$rangectr]) && ($right >= $scsn[$rangectr]))
            {
               $looker = $rangectr; &datasend;
            }
          }
        } # End of FOR range
      } # End of range checking
    } # End of Switch or Range checking
    else
    {
      # Print if no range was mentioned
      for ($ctr=0; $ctr < $totals; $ctr++)
      { 
        if ($switch) # Print for switch AND cell if mentioned
        { 
          if (($input == $scsn[$ctr]) && ($ssw[$ctr] == $switch))
          { 
            $looker = $ctr; &datasend;
          }
        }
        else # Print for cells regardless of switch
        { 
          if ($input == $scsn[$ctr]) 
          {
            $looker = $ctr; &datasend;
          }
        }
      } # End of Query
    }
  } # End of Program

if ($WINDOWS) { close(OUTFILE); }

if ($prompted)
{
  print "\n\nWhen finished press the <RETURN> to exit\n";
  $exit = <STDIN>;
}

# --------------------------- LOCAL FUNCTIONS ------------------------------
# --------------------------------------------------------------------------
# datasend - Sends data to print routine for printing
#
# INPUTS  LNAO value
# OUTPUTS Stores data to variable called $result
# RETURNS Returns to printdata
# --------------------------------------------------------------------------
sub datasend
{
  $swout = $ssw[$looker];
  $csnout = $scsn[$looker];
  $restout = $srest[$looker];
  &printdata;
}
# --------------------------------------------------------------------------
# dbms - Converts Motorola value to dBM value
#
# INPUTS  LNAO value
# OUTPUTS Stores data to variable called $result
# RETURNS Returns to printdata
# --------------------------------------------------------------------------
sub dbms
{
  local($moto) = @_;
  if ($lnao >= 83)
  {
    $adjustment = $lnao - 83;
  }
  else
  {
    $adjustment = $lnao - 51;
  }
  $value = ($moto + $adjustment - 314.5) / 2.25;
  $result = int($value);
  if (substr($value,index($value,".")+1,1)>4) { $result--; }
}
# --------------------------------------------------------------------------
# loader - Loads 1 or all data tables and sets flags
#
# INPUTS  Input from command line
# OUTPUTS Data loaded into array
# RETURNS Returns to Main Program
# --------------------------------------------------------------------------
sub loader
{
# LOAD DATA
  if ((substr($ARGV[0],0,1) eq "-") && (substr($ARGV[0],1,1) + 0))
  {
    $sw = substr($ARGV[0],1,1);
    open(SECPRM,"$SECPRM$sw") || die "Can't find $SECPRM$sw: $!\n";
    while (<SECPRM>)
    {
      ($f1,$rest) = split(/,/,$_,2);
      @ssw[$ctr] = $sw; @scsn[$ctr] = $f1; @srest[$ctr] = $rest;
      $ctr++;
    }
    close(SECPRM);
    if ($WINDOWS) { $data[$sw] = `type $SECPRM$sw.date`; }
    else { $data[$sw] = `cat $SECPRM$sw.date`; }
    chop $data[$sw]; 
  }
  else
  {
    foreach $sw (@LASWITCHLIST)
    {
      open(SECPRM,"$SECPRM$sw") || die "Can't find $SECPRM$sw: $!\n";
      while (<SECPRM>)
      {
        ($f1,$rest) = split(/,/,$_,2);
        @ssw[$ctr] = $sw; @scsn[$ctr] = $f1; @srest[$ctr] = $rest;
        $ctr++;
      }
      close(SECPRM);
      if ($WINDOWS) { $data[$sw] = `type $SECPRM$sw.date`; }
      else { $data[$sw] = `cat $SECPRM$sw.date`; }
      chop $data[$sw]; 
    }
  }
  $loadflag = 0; # zero out flag
  $totals = $ctr;
# SET FLAGS
  if ($ARGV[0] =~ /^-[345678dmDM]/) 
  { 
    $switch = 3 if ($input =~ /3/);
    $switch = 4 if ($input =~ /4/);
    $switch = 5 if ($input =~ /5/);
    $switch = 6 if ($input =~ /6/);
    $switch = 7 if ($input =~ /7/);
    $switch = 8 if ($input =~ /8/);
    $dbmflag = 1 if ($input =~ /d/);
    $motoflag = 1 if ($input =~ /m/);
    $dbmflag = 1 if ($input =~ /D/);
    $motoflag = 1 if ($input =~ /M/);
  }
}
# --------------------------------------------------------------------------
# menuprompting - Provide prompting of parameters as in switch 
#                 Required for Workspace Menu capability
#
# INPUTS  Resets $ARGV[0] and get others from user
# OUTPUTS Sends reloaded $ARGV values thru regular program w/$prompted set
# RETURNS Returns to beginning of main program
# --------------------------------------------------------------------------
sub menuprompting
{
  $prompted = 1;
  print STDERR "$PROG ($VER) - Display Mobile Secprm\n";
  print "Please enter as prompted or just press <RETURN> to skip option\n\n";
  print "Switch Number (3,4,5,6,7,8 or <RETURN> for system-wide):  ";
  $part1 = <STDIN>; chop $part1;
  print "Enter d for -dBM values if desired:  ";
  $part2 = <STDIN>; chop $part2;
  print "Enter m for Motorola values for both -dBM and Motorola:  ";
  $part3 = <STDIN>; chop $part3;
  print "Enter 1 or more cell numbers\n";
  print "  OR a range of cells like 1-511:  ";
  $part4 = <STDIN>; chop $part4;
  @cells = split(/ /,$part4);
  if (($part1) || (length($part2)))
  {
    $flags = "-$part1$part2$part3";
    @ARGV = ($flags,@cells);
  }
  else { @ARGV = @cells; }
}
# --------------------------------------------------------------------------
# printdata - Print data to screen
#   Several test for a New Version Switch are done pending a complete
#   rewrite of the program to avoid these kind of modification nightmares.
#   In basics the heading goes first, then the splitting of fields, followed
#   by the actual printing. Within each of those portions is the test for
#   the Newer Version vs. the Normal.
#
# INPUTS  Error message string
# OUTPUTS Sends data to screen
# RETURNS Returns to main program
# --------------------------------------------------------------------------
sub printdata
{ 
  if ($headerflag)
  {
    if ($THREEPARK) { print "WARNING - Data is from 3 Park Database\n"; }
    if ($switch)
    {
      if ($WINDOWS) { print OUTFILE "Data Collected $data[$switch]\n"; }
      else { print "Data Collected $data[$switch]\n"; }
    }
    else
    {
      if ($WINDOWS)
      {
        print OUTFILE " Data Collected: LA3 $data[3], LA4 $data[4], LA5 $data[5],\n";
        print OUTFILE "                LA6 $data[6], LA7 $data[7], LA8 $data[8]\n";
      }
      else
      {
        print "Data Collected: LA3 $data[3], LA4 $data[4], LA5 $data[5],\n";
        print "                LA6 $data[6], LA7 $data[7], LA8 $data[8]\n";
      }
    }
    if ($switch =~ /$UPGRADEDSWITCHES/) # Test for New Version Switch
    { # Use Newer Version Printing
      if ($WINDOWS)
      {
      printf(OUTFILE $headformatM," "," "," ","CMP"," "," # ","MAX ","MAX","MIN ",
           "MIN","RC "," "," ","LNA","NOM ","MX","EHO ","OU","OU","SIG");
      printf(OUTFILE $headformatM,"SW","CSN","S","FLG","PSHO","IHO","  SS","#",
             "  SS","#","ANT","RPV","FCT ","OFS","  SS","PL"," THR","MX",
             "EH","FCT");
      printf(OUTFILE $headformatM,"--","---","-","---","----","---","----","---",
             "----","---","---","---","----","---","----","--","----",
             "--","--","---");
      }
      else
      {
      printf($headformatM," "," "," ","CMP"," "," # ","MAX ","MAX","MIN ",
           "MIN","RC "," "," ","LNA","NOM ","MX","EHO ","OU","OU","SIG");
      printf($headformatM,"SW","CSN","S","FLG","PSHO","IHO","  SS","#",
             "  SS","#","ANT","RPV","FCT ","OFS","  SS","PL"," THR","MX",
             "EH","FCT");
      printf($headformatM,"--","---","-","---","----","---","----","---",
             "----","---","---","---","----","---","----","--","----",
             "--","--","---");
      }
    }
    else
    { # Use Normal Printing
      if ($WINDOWS)
      {
      printf(OUTFILE $headformat," "," "," ","CMP"," "," # ","MAX ","MAX","MIN ",
           "MIN","RC "," "," ","LNA","NOM ","MX","EHO ","OU","OU ");
      printf(OUTFILE $headformat,"SW","CSN","S","FLG","PSHO","IHO","  SS","#",
             "  SS","#","ANT","RPV","FCT ","OFS","  SS","PL"," THR","MX",
             "EHO");
      printf(OUTFILE $headformat,"--","---","-","---","----","---","----","---",
             "----","---","---","---","----","---","----","--","----",
             "--","---");
      }
      else
      {
      printf($headformat," "," "," ","CMP"," "," # ","MAX ","MAX","MIN ",
           "MIN","RC "," "," ","LNA","NOM ","MX","EHO ","OU","OU ");
      printf($headformat,"SW","CSN","S","FLG","PSHO","IHO","  SS","#",
             "  SS","#","ANT","RPV","FCT ","OFS","  SS","PL"," THR","MX",
             "EHO");
      printf($headformat,"--","---","-","---","----","---","----","---",
             "----","---","---","---","----","---","----","--","----",
             "--","---");
      }
    }
    $headerflag = 0;
  }
  if ($switch =~ /$UPGRADEDSWITCHES/)
  {
    ($f2,$f3,$f4,$f5,$f6,$f7,$f8,$f9,$f10,$f11,$f12,$f13,$f14,$f15,
     $f16,$f17,$f18,$f19) = split(/,/,$restout);
    chop $f19;
  }
  else
  {
    ($f2,$f3,$f4,$f5,$f6,$f7,$f8,$f9,$f10,$f11,$f12,$f13,$f14,$f15,
     $f16,$f17,$f18) = split(/,/,$restout,17);
    chop $f18;
  }
  $lnao = $f13;
  &dbms($f4); $psho = $result;
  &dbms($f6); $maxss = $result;
  &dbms($f8); $minss = $result;
  &dbms($f12); $fct = $result;
  &dbms($f14); $nomss = $result;
  &dbms($f16); $ehothr = $result;
  if ($switch =~ /$UPGRADEDSWITCHES/) # Test for New Version Switch
  { # Use Newer Version Printing
    if ($range)
    {
      if ($dbmflag)
      { 
        if ($motoflag)
        {
          if ($WINDOWS)
          {
          printf(OUTFILE $bodyformatM,$swout,$csnout,$f2,$f3,$f4,$f5,$f6,$f7,$f8,
                        $f9,$f10,$f11,$f12,$f13,$f14,$f15,$f16,$f17,$f18,$f19);
          }
          else
          {
          printf($bodyformatM,$swout,$csnout,$f2,$f3,$f4,$f5,$f6,$f7,$f8,
                        $f9,$f10,$f11,$f12,$f13,$f14,$f15,$f16,$f17,$f18,$f19);
          }
        }
        if ($WINDOWS)
        {
        printf(OUTFILE $bodyformatM,$swout,$csnout,$f2,$f3,$psho,$f5,$maxss,
                        $f7,$minss,$f9,$f10,$f11,$fct,$f13,$nomss,$f15,
                        $ehothr,$f17,$f18,$f19);
        }
        else
        {
        printf($bodyformatM,$swout,$csnout,$f2,$f3,$psho,$f5,$maxss,
                        $f7,$minss,$f9,$f10,$f11,$fct,$f13,$nomss,$f15,
                        $ehothr,$f17,$f18,$f19);
        }
      }
      else 
      {
        if ($WINDOWS)
        {
          printf(OUTFILE $bodyformatM,$swout,$csnout,$f2,$f3,$f4,$f5,$f6,$f7,$f8,
                      $f9,$f10,$f11,$f12,$f13,$f14,$f15,$f16,$f17,$f18,$f19);
        }
        else
        {
          printf($bodyformatM,$swout,$csnout,$f2,$f3,$f4,$f5,$f6,$f7,$f8,
                      $f9,$f10,$f11,$f12,$f13,$f14,$f15,$f16,$f17,$f18,$f19);
        }
      }
    }
    else
    {
      if ($dbmflag)
      { 
        if ($motoflag)
        {
          if ($WINDOWS)
          {
            printf(OUTFILE $bodyformatM,$swout,$csnout,$f2,$f3,$f4,$f5,$f6,$f7,$f8,
                      $f9,$f10,$f11,$f12,$f13,$f14,$f15,$f16,$f17,$f18,$f19);
          }
          else
          {
          printf($bodyformatM,$swout,$csnout,$f2,$f3,$f4,$f5,$f6,$f7,$f8,
                      $f9,$f10,$f11,$f12,$f13,$f14,$f15,$f16,$f17,$f18,$f19);
          }
        }
        if ($WINDOWS)
        {
        printf(OUTFILE $bodyformatM,$swout,$csnout,$f2,$f3,$psho,$f5,$maxss,$f7,$minss,
                    $f9,$f10,$f11,$fct,$f13,$nomss,$f15,$ehothr,$f17,$f18,$f19);
        }
        else
        {
        printf($bodyformatM,$swout,$csnout,$f2,$f3,$psho,$f5,$maxss,$f7,$minss,
                    $f9,$f10,$f11,$fct,$f13,$nomss,$f15,$ehothr,$f17,$f18,$f19);
        }
      }
      else 
      {
        if ($WINDOWS)
        {
        printf(OUTFILE $bodyformatM,$swout,$csnout,$f2,$f3,$f4,$f5,$f6,$f7,$f8,
                    $f9,$f10,$f11,$f12,$f13,$f14,$f15,$f16,$f17,$f18,$f19);
        }
        else
        {
        printf($bodyformatM,$swout,$csnout,$f2,$f3,$f4,$f5,$f6,$f7,$f8,
                    $f9,$f10,$f11,$f12,$f13,$f14,$f15,$f16,$f17,$f18,$f19);
        }
      }
    }
  }
  else
  { # Use Normal Printing
    if ($range)
    {
      if ($dbmflag)
      { 
        if ($motoflag)
        {
          if ($WINDOWS)
          {
          printf(OUTFILE $bodyformat,$swout,$csnout,$f2,$f3,$f4,$f5,$f6,$f7,$f8,
                        $f9,$f10,$f11,$f12,$f13,$f14,$f15,$f16,$f17,$f18);
          }
          else
          {
          printf($bodyformat,$swout,$csnout,$f2,$f3,$f4,$f5,$f6,$f7,$f8,
                        $f9,$f10,$f11,$f12,$f13,$f14,$f15,$f16,$f17,$f18);
          }
        }
        if ($WINDOWS)
        {
        printf(OUTFILE $bodyformat,$swout,$csnout,$f2,$f3,$psho,$f5,$maxss,
                        $f7,$minss,$f9,$f10,$f11,$fct,$f13,$nomss,$f15,
                        $ehothr,$f17,$f18);
        }
        else
        {
        printf($bodyformat,$swout,$csnout,$f2,$f3,$psho,$f5,$maxss,
                        $f7,$minss,$f9,$f10,$f11,$fct,$f13,$nomss,$f15,
                        $ehothr,$f17,$f18);
        }
      }
      else 
      {
        if ($WINDOWS)
        {
          printf(OUTFILE $bodyformat,$swout,$csnout,$f2,$f3,$f4,$f5,$f6,$f7,$f8,
                      $f9,$f10,$f11,$f12,$f13,$f14,$f15,$f16,$f17,$f18);
        }
        else
        {
          printf($bodyformat,$swout,$csnout,$f2,$f3,$f4,$f5,$f6,$f7,$f8,
                      $f9,$f10,$f11,$f12,$f13,$f14,$f15,$f16,$f17,$f18);
        }
      }
    }
    else
    {
      if ($dbmflag)
      { 
        if ($motoflag)
        {
          if ($WINDOWS)
          {
          printf(OUTFILE$bodyformat,$swout,$csnout,$f2,$f3,$f4,$f5,$f6,$f7,$f8,
                      $f9,$f10,$f11,$f12,$f13,$f14,$f15,$f16,$f17,$f18);
          }
          else
          {
          printf($bodyformat,$swout,$csnout,$f2,$f3,$f4,$f5,$f6,$f7,$f8,
                      $f9,$f10,$f11,$f12,$f13,$f14,$f15,$f16,$f17,$f18);
          }
        }
        if ($WINDOWS)
        {
        printf(OUTFILE $bodyformat,$swout,$csnout,$f2,$f3,$psho,$f5,$maxss,$f7,$minss,
                    $f9,$f10,$f11,$fct,$f13,$nomss,$f15,$ehothr,$f17,$f18);
        }
        else
        {
        printf($bodyformat,$swout,$csnout,$f2,$f3,$psho,$f5,$maxss,$f7,$minss,
                    $f9,$f10,$f11,$fct,$f13,$nomss,$f15,$ehothr,$f17,$f18);
        }
      }
      else 
      {
        if ($WINDOWS)
        {
        printf(OUTFILE $bodyformat,$swout,$csnout,$f2,$f3,$f4,$f5,$f6,$f7,$f8,
                    $f9,$f10,$f11,$f12,$f13,$f14,$f15,$f16,$f17,$f18);
        }
        else
        {
        printf($bodyformat,$swout,$csnout,$f2,$f3,$f4,$f5,$f6,$f7,$f8,
                    $f9,$f10,$f11,$f12,$f13,$f14,$f15,$f16,$f17,$f18);
        }
      }
    }
  }
}
# --------------------------------------------------------------------------
# trap - Catch signals and handle them gracefully 
#
# INPUTS  The number of the signal sent to this process
# OUTPUTS Send message to user
# RETURNS Never returns
# --------------------------------------------------------------------------
sub trap
{
    local($sig) = @_;
    print STDERR "SIG$sig received by $PROG. Shutting down.\n";
    exit(1);
}
# --------------------------------------------------------------------------
# usage - Print usage message
#
# INPUTS  Error message string.
# OUTPUTS Sends message to stderr
# RETURNS Never returns
# --------------------------------------------------------------------------
sub usage
{
    print STDERR <<"EOF";
    $PROG ($VER) - Display Mobile Secprm 
    Usage: $PROG [-[switch][dm]] csn [[csn ...] or [begin-end]]
      where:
             switch is 3 to 8 [optional]
               (otherwise if csn exists in multiple switches you get both)
             d is dBM value [optional]
             m is Motorola Standard value (default) [optional]
	     csn is any number from 3 to 511. can give 1 or more csn's
             begin-end is for a range of cells 3-511 or within 

      EXAMPLE 1: $PROG -6d 205 366
                    gives dBM values for switch 6 cells
      EXAMPLE 2: $PROG 191 205 366
                    gives Motorola values for any of 3
      EXAMPLE 3: $PROG -dm 191 205 366
                    gives both values for any of 3
      EXAMPLE 4: $PROG 3-511
                    gives Motorola values system-wide
      EXAMPLE 5: $PROG -4 3-511
                    gives Motorola values for switch 4

EOF
    print STDERR "Failed: $_[0] \n";
    if ($prompted)
    {
      print "\n\nWhen finished press the <RETURN> to exit\n";
      $exit = <STDIN>;
    }
    exit 1;
}

# 34567890123456789012345678901234567890123456789012345678901234567890123456
# disp.mob.secp ------------------------------------------------------------


SIXTH PROGRAM --------------------------------------------------------------------
#!/usr/local/bin/perl
# setbigbrother - Set Big Brother environment variables
# A perl script to set environment variables for Big Brother scripts.
# Make sure you don't use same names as perlenv.
# This is especially important for scripts run from cron.
# Update this script as the system configuration changes (SINGLE LINES ONLY).
# It is important to not bury these details in individual scripts!

# REVISION HISTORY
# VER DATE       BY    DESCRIPTION
# 1.0 27-Jan-95  cws   Original
.
.
.

# Environment
umask(0);

# DEFINED CONSTANTS
$WINDOWS = 1;  # FOR WINDOWS THIS IS THE MOST IMPORTANT VARIABLE IN THE FILE
$DESKTOP = "C:\\WINDOWS\\DESKTOP";
$BBPADM = "craigs\@la.airtouch.com";
$BBPADMNOTE = "Please send questions to Craig Steffler 714-222-8583 or $BBPADM";
$BBPCHGLOG = "/usr/local/csn/reports/celldata/bbpchglog.cur";
$BBP_SVR = "laforge";
$CELLSTHIRD = "/net/devo/u/nss/nms/utils/data/cells"; # Looked at third
$CELLSFIRST = "/net/john/usr/nss/nms/utils/data/cells"; # Looked at first
$CELLSSECOND = "/net/ringo/usr/nss/nms/utils/data/cells"; # Looked at second
%CELLTYPE = ("TSRS 120 DEG","120 Degree","TORO ","Omni");
$COMMANDFILE = "/net/vulcan/u1/bbwork/b_";
$CRTR = "/usr/local/csn/reports/lib/crtr";
#$DOUBLEQUOTE = "\"";
@EMXLIST = (1,2,3,12,11,16,6,19);
$EMXLISTING = "1, 2, 3, 12, 11, or 16";
%EMX2SWITCH = (1,3,2,4,3,5,12,6,6,"SD",19,"SB",11,7,16,8);
$HDR_BOURNE = "\#\!/bin/sh";
$HDR_EXPECT = "\#\!/usr/local/bin/expect --";
$HELPDIR = "/home/bigb/bin/bb20/commands/help";
$HOME = $ENV{'HOME'};
@LASWITCHLIST = (3,4,5,6,7,8);
$LOGFILE = "/usr/local/csn/reports/celldata/bblog.cur";
$LOGNAME = $ENV{'LOGNAME'};
@OLDERLASWITCHES = (3,4,5,6);
%PORT = (3,8036,4,8037,5,8038,6,8039,7,8040,8,8041,11,8042,12,8043,13,8044);
$REPORTPEOPLE = "rftraf,rfnorth,rfeast,rfsouth,rfwest";
$SCRIPTFILE = "$ENV{'HOME'}/swscr.";
$SCRIPTLOG = "/usr/local/csn/reports/celldata/bbscrlog.cur";
%SWITCH2EMX = (3,1,4,2,5,3,6,12,7,11,8,16,11,8,12,9);
$SWITCHLISTING = "3, 4, 5, 6, 7, or 8";
$TERMAPP = "/net/crusher/usr/bin/term -ltelnet:yar";
$TERMAPPQ = "/net/crusher/usr/bin/term -q -l/usr/local/bin/dkdest:laforge:";
$TERMLIB = "/usr/local/csn/reports/lib/term";
$TMPDIR = "/tmp";
$UPGRADEDSWITCHES = "345678";
$USERSDIR = "/home/bigb/bin/bb20/commands/Users";
$USRLOG = "C:\\home\\bigb\\logs\\usrlog.txt";
$WORKFILE = "$ENV{'HOME'}/.bbpw";

# Big Brother Tables
$SECPRM = "C:\\home\\bigb\\bin\\bb20\\bbtables\\secprm.la";
$SEC2PRM = "C:\\home\\bigb\\bin\\bb20\\bbtables\\sec2prm.la";
$SECTOP = "C:\\home\\bigb\\bin\\bb20\\bbtables\\sectop.la";
$OMNITOP = "C:\\home\\bigb\\bin\\bb20\\bbtables\\omnitop.la";
$OMNIPRM = "C:\\home\\bigb\\bin\\bb20\\bbtables\\omniprm.la";
$OMNI2PRM = "C:\\home\\bigb\\bin\\bb20\\bbtables\\omni2prm.la";
$DLPARM = "C:\\home\\bigb\\bin\\bb20\\bbtables\\dlparm.la";
$CPARM1 = "C:\\home\\bigb\\bin\\bb20\\bbtables\\cparm1.la";
$CPARM2 = "C:\\home\\bigb\\bin\\bb20\\bbtables\\cparm2.la";
$ADJEMX = "C:\\home\\bigb\\bin\\bb20\\bbtables\\adjemx.la";
$COVAR = "C:\\home\\bigb\\bin\\bb20\\bbtables\\covar.la";
$COVAR2 = "C:\\home\\bigb\\bin\\bb20\\bbtables\\covar2.la";
$CHANPRM = "C:\\home\\bigb\\bin\\bb20\\bbtables\\chanprm.la";
$CSCPRM = "C:\\home\\bigb\\bin\\bb20\\bbtables\\cscprm.la";
$CELVER = "C:\\home\\bigb\\bin\\bb20\\bbtables\\celver.la";
$CELLFEAT = "C:\\home\\bigb\\bin\\bb20\\bbtables\\cellfeat.la";
$DIRTOP = "C:\\home\\bigb\\bin\\bb20\\bbtables\\dirtop.la";
$HOTMRS = "C:\\home\\bigb\\bin\\bb20\\bbtables\\hotmrs.la";
$SMCELL = "C:\\home\\bigb\\bin\\bb20\\bbtables\\smcell.la";
$SECORG = "C:\\home\\bigb\\bin\\bb20\\bbtables\\secorg.la";
$NAILED = "C:\\home\\bigb\\bin\\bb20\\bbtables\\nailed.la";
$VCCPRM = "C:\\home\\bigb\\bin\\bb20\\bbtables\\vccprm.la";

# Paths to DISPLAY Programs referred to by DISP Program
$SECP = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.mob.secp";
$SEC2 = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.mob.sec2";
$SECT = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.mob.sect";
$OMNIP = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.mob.omnip";
$OMNI2 = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.mob.omni2";
$OMNIT = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.mob.omnit";
$DISPDLPARM = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.mob.dlparm";
$DIRT = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.mob.dirt";
$CPRM1 = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.mob.cparm1";
$CPRM2 = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.mob.cparm2";
$DISPADJ = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.celnet.adj";
$DISPCOVAR = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.celnet.covar";
$DISPCOVAR2 = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.celnet.covar2";
$CHANP = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.mob.chanp";
$DISPCHAN = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.mob.chan";
$DISPCHNSAT = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.mob.chnsat";
$DISPVCCPRM = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.mob.vccprm";
$DISPCSCPRM = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.mob.cscprm";
$DISPCVER = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.mob.celver";
$DISPCFEAT = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.cell.feat";
$DISPHOTMRS = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.mob.hotmrs";
$IPRDICT = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.ipr.dict";
$DISPNAILED = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.cp.nailed";
$DISPSECORG = "perl C:\\home\\bigb\\bin\\bb20\\commands\\disp\\disp.cp.secorg";

FINALLY THE END.