WebSVN – sysadmin_scripts – Diff – /trunk/mapSwitchPorts/mapSwitches

 # Added the ability to override or supplement arp and dns searches for mac addresses
 # 20230323 RWR v2.3.0
 # Added ability to have one or more non_router files, with mac/name/ip in it in case arp lookup failed
 # added script to create static html file in addition to csv
+#
-# 20230327 RWR v3.0.0
+# 20230324 RWR v3.0.0
 # rewrite to make things more efficient, and store data in different format. You MUST remove old yaml file
 # before running this.
+#
+# 20230325 RWR v3.0.1
+# Added ability to delete entries which haven't been seen since $config->{'ttl'} seconds. ttl can be
+# an integer followed by a unit, with units being single char h,d,w,m,y (hours, days, weeks, months, years)
+# added ability to set so it will only refresh dns and device names every $refresh seconds, decreasing
+# run time to 33% value when not used. Test system decreases from 15s to 5-7s
+# reorganized so system runs smoother (test system decreased from 40 seconds to 15)
+# for Debian, to get the required libraries
+# apt install libyaml-tiny-perl libnet-dns-perl snmp
 use strict;
 use warnings;
 use Data::Dumper; # only used for debugging
 use Socket; # for reverse dns entries
 use YAML::Tiny; # apt-get libyaml-tiny-perl under debian
 use File::Spec; # find location of script so we can put storage in same directory
 use File::Basename;
+use Net::DNS; # dns lookup, apt install libnet-dns-perl
 my $DEBUG = 0;
 # define the version number
 # see https://metacpan.org/pod/release/JPEACOCK/version-0.97/lib/version.pod
 use version;
-our $VERSION = version->declare("v3.3.0");
+our $VERSION = version->declare("v3.3.1");
 # see https://perldoc.perl.org/Getopt/Long.html
 use Getopt::Long;
 # allow -vvn (ie, --verbose --verbose --dryrun)
 Getopt::Long::Configure ("bundling");
 my $scriptDir = dirname( File::Spec->rel2abs( __FILE__ ) );
 # put the statefile in there
 my $STATEFILE = $scriptDir . '/mapSwitches.yaml';
 my $CONFIGFILE = $scriptDir . '/mapSwitches.config.yaml';
 my $SWITCHPORTMIB  = 'iso.3.6.1.2.1.2.2.1.8'; # returns port number and state, with a state of '1' meaning operational
 my $SWITCHMACMIB   = 'iso.3.6.1.2.1.17.4.3.1.1'; # dot1dTpFdbAddress, aka mac addresses
 my $SWITCHIFALIASMIB = 'iso.3.6.1.2.1.31.1.1.1.18'; # ifAlias, the the 'alias' field
 my $SWITCHIFDESCMIB = 'iso.3.6.1.2.1.2.2.1.2'; # ifDescr, the "description" field
 my $BRIDGEPORTSMIB = 'iso.3.6.1.2.1.17.4.3.1.2';
+      }
+   }
    return $return;
+}
+# do a reverse dns lookup of an IP address and return the hostname
+# note that $dns is an instance of Net::DNS
+sub getHostName {
+   my ($dns, $ip ) = @_;
+   foreach my $resource ( @$dns ) {
+      my  $reply = $resource->search( $ip );
+      next unless defined $reply;
+      my @answer = grep { ! /^((;.*)|(\s*))$/ } split( "\n", $reply->string );
+      $answer[0] =~ m/\s([a-z0-9.-]+)\.$/;
+      return $1;
+   }
+   return '';
+}
 # Load configuration file, die if we could not find it
 # config file is a single page YAML file
 sub loadConfig {
    my $filename = shift;
    use File::Basename;
    print basename($0) . " $VERSION\n";
    print <<END
 $0 [options]
 Options:
-   --no-snmp        - do not actually run snmp commands
+   --no-snmp         - do not actually run snmp commands
-   --debug          - set debug level
+   --debug           - set debug level
+   --refresh         - force a refresh even if not time
-   --version        - display version and exit
+   --version         - display version and exit
-   --help           - This page
+   --help            - This page
 END
+}
 # get information about one single switch
+#
 sub getSwitchInfo {
-   my ( $ip, $community, $ignorePorts, $switchInfo ) = @_;
+   my ( $ip, $community, $ignorePorts ) = @_;
+   my $switchInfo = {};
    print "Working on $ip with community $community\n" if $DEBUG;
    $switchInfo->{$ip}->{'name'} = # get actual device name
       &getOneSNMPValue( $DEVICENAMEMIB,
                         $community,
                         $ip,
             $community,
             $ip,
             qr/\.\d+ = STRING: "?([^\"]*)"?$/ );
       $switchInfo->{$ip}->{'ports'}->{$port}->{'description'} = $port unless defined ( $switchInfo->{$ip}->{'ports'}->{$port}->{'description'} );
+   }
+   return $switchInfo->{$ip};
+}
 # get all MAC addresses on switch and associate them with the correct port numbers
 # https://www.cisco.com/c/en/us/support/docs/ip/simple-network-management-protocol-snmp/44800-mactoport44800.html
 sub getSwitchPortMacs {
       $macList->{&makeMAC($mac)}->{'originalMAC'} = $mac;
       $macList->{&makeMAC($mac)}->{'lastseen'} = time();
+   }
+}
-# get IP address from router(s), and hostname from rdns
+# get IP address from router(s)
+# since the information is already there, we grab the interface also
 sub getRouterInfo {
    my ( $ip, $community, $routerInfo ) = @_;
    print "Working on $ip\n" if $DEBUG;
    print "snmpwalk -v1 -c $community $ip $ROUTERIPMACMIB\n" if $DEBUG > 1;
    my $values = `snmpwalk -v1 -c $community $ip $ROUTERIPMACMIB`;
       my $interface = $1;
       my $ip = $2;
       my $mac = &cleanMac( $3 );
       $routerInfo->{$mac}->{'ip'} = $ip;
       $routerInfo->{$mac}->{'interface'} = $interface;
-      $routerInfo->{$mac}->{'hostname'} = gethostbyaddr( inet_aton( $ip ), AF_INET );
+   }
+}
 # load tab delimited values from $filename into hashref $nonRouterEntries
 # format is
 #     'ip' = IP Address
 #     'mac' = MAC Address
 #     'hostname' = HostName
 sub loadNonRouterEntries {
-   my ( $nonRouterEntries, $filename ) = @_;
+   my ( $scriptDir, $files, $staticMaps, $routerARP ) = @_;
-   print "In loadNonRouterEntries with $filename\n" if $DEBUG > 1;
-   open FN,"<$filename" or die "Could not open $filename: $!\n";
+   # first, load the information from the files
-   my $line = <FN>;
-   chomp $line;
-   my @headers = split( "\t", $line );
-   my $macIndex = 0;
-   while ( $headers[$macIndex] !~ 'mac' && $macIndex < @headers ) {
-      $macIndex++;
-   }
-   if ( $macIndex >= @headers ) {
+   foreach my $filename ( @$files ) {
-      warn "File $filename does not appear to contain a mac column\n";
+      open FN,"<$scriptDir/$filename" or die "Could not open $scriptDir/$filename: $!\n";
-      return;
-   }
-   while ( $line = <FN> ) {
+      my $line = <FN>;
-      next if $line =~ m/^#/;
       chomp $line;
-      my @values = split( "\t", $line );
+      my @headers = split( "\t", $line );
+      my $macIndex = 0;
+      while ( $headers[$macIndex] !~ 'mac' && $macIndex < @headers ) {
+         $macIndex++;
+      }
-      for( my $i = 0; $i < @headers; $i++ ) {
+      if ( $macIndex >= @headers ) {
-         $nonRouterEntries->{&cleanMac($values[$macIndex])}->{$headers[$i]} = lc $values[$i];
+         warn "File $filename does not appear to contain a mac column\n";
+         return;
+      }
+      while ( $line = <FN> ) {
+         next if $line =~ m/^#/;
+         chomp $line;
+         my @values = split( "\t", $line );
+         my $mac = &cleanMac($values[$macIndex]);
+         for( my $i = 0; $i < @headers; $i++ ) {
+            # update the value if one does not already exist
+            $routerARP->{$mac}->{$headers[$i]} = lc $values[$i] unless $routerARP->{$mac}->{$headers[$i]};
+         }
+      }
+      close FN;
+   }
+   # now, update from our staticmaps
+   foreach my $mac ( keys %$staticMaps ) {
+      # only update ip if it doesn't exist, or if we have an override
+      $routerARP->{$mac}->{'ip'} = $staticMaps->{$mac}->{'ip'} if $staticMaps->{$mac}->{'override'} || ! $routerARP->{$mac}->{'ip'};
+      # these don't exist in $routerARP, so we just add them
+      $routerARP->{$mac}->{'hostname'} = $staticMaps->{$mac}->{'hostname'};
+      $routerARP->{$mac}->{'override'} = $staticMaps->{$mac}->{'override'};
+   }
-   close FN;
+}
 # merge nonRouterEntries into $routerARP, with $routerARP having precedence
 sub updateRouterWithStatic {
    my ( $routerARP, $nonRouterEntries ) = @_;
    foreach my $mac ( keys %$nonRouterEntries ) {
                   || $nonRouterEntries->{$mac}->{'override'}
+                  )
                );
+   }
+}
+# get IP addresses from the list of them we have
+sub getIPAddresses {
+   my ( $macList, $ipList ) = @_;
+   foreach my $mac ( keys %$macList ) {
+      $macList->{$mac}->{'ip'} = $ipList->{$mac}->{'ip'} if $ipList->{$mac}->{'ip'};
+   }
+}
+# grab names by reverse DNS from the IP addresses
+# if that fails, or if there is an override
+# use the name from $routerARP, if it exists;
+sub getDNSNames {
+   my ( $macList, $dnsResource, $routerARP ) = @_;
+   foreach my $mac ( keys %$macList ) {
+      if ( $routerARP->{$mac}->{'override'} && $routerARP->{$mac}->{'hostname'} ) {
+         $macList->{$mac}->{'hostname'} = $routerARP->{$mac}->{'hostname'};
+      } else { # try a DNS lookup
+         $macList->{$mac}->{'hostname'} = &getHostName( $dnsResource, $macList->{$mac}->{'ip'} );
+         # still didn't find one, so add one from $routerARP if it exists
+         $macList->{$mac}->{'hostname'} = $routerARP->{$mac}->{'hostname'} if ! $macList->{$mac}->{'hostname'} && $routerARP->{$mac}->{'hostname'};
+      }
+   }
+}
+# given a value of a number follwed by a unit (ie, 2w, 12h, 3m), determine
+# the unixtime for that long ago.
+sub calcAge {
+   my $time = shift;
+   my %seconds = (
+      's' => 1,
+      'h' => 60*60,
+      'd' => 86400,
+      'w' => 7*86400,
+      'm' => 7*30.5*86400,
+      'y' => 86400*365.2425
+      );
+   $time = lc $time;
+   $time =~ m/^(\d+)(.*)/;
+   $time = $1;
+   my $unit = $2;
+   $unit = 's' unless $unit;
+   return defined( $seconds{$unit} ) ? $time * $seconds{$unit} : 0;
+}
+# given an integer/modifier (1w, 3d, 10h), remove all mac entries which have not
+# been seen since then.
+sub cleanUpOldEntries {
+   my ( $ttl, $list ) = @_;
+   my $currentTime = time;
+   my $deleteBefore = &calcAge( $ttl );
+   if ( $deleteBefore == 0 ) {
+      warn "Invalid ttl definition [$ttl], not cleaning up\n";
+      return;
+   }
+   $deleteBefore = time - $deleteBefore;
+   foreach my $mac ( keys %{ $list->{'macList'} } ) {
+      if ( $list->{'macList'}->{$mac}->{'lastseen'} < $deleteBefore ) {
+#         print
+#            "Deleting $mac with a last seen of " .
+#            $list->{'macList'}->{$mac}->{'lastseen'} .
+#            ", current time is $currentTime for a difference of " .
+#            ( $currentTime - $list->{'macList'}->{$mac}->{'lastseen'} ) .
+#            "\n";
+         delete $list->{'macList'}->{$mac} if $list->{'macList'}->{$mac}->{'lastseen'};
+      }
+   }
+}
 ################################################################################
 #              Main
 ################################################################################
 # handle any command line parameters that may have been passed in
 my $version = 0; # just used to determine if we should display the version
 my $help = 0; # also if we want help
 my $nosnmp = 0; # we do NOT want to run snmp commands
+my $forceRefres = 0; # force a refresh even if one is not called for now
 GetOptions (
             'debug|d=i'     => \$DEBUG,
             'nosnmp|n'      => \$nosnmp,
+            'refresh|r'     => \$forceRefres,
             'help|h'        => \$help,
             'version|v'     => \$version,
             ) or die "Error parsing command line\n";
 if ( $help ) { &help() ; exit; }
 if ( $version ) { use File::Basename; print basename($0) . " $VERSION\n"; exit; }
 # Get configuration file into $config
 my $config = &loadConfig( $CONFIGFILE );
-print Dumper( $config ) if $DEBUG > 1;
+print Dumper( $config ) if $DEBUG > 1; die if $DEBUG > 4;
+# load the savefile, if it exists
+my $saveFile = { 'macList' => {}, 'switchInfo' => {} };
+# read the saved state into memory if it exists
+if ( -e $STATEFILE ) {
+   my $yaml = YAML::Tiny->read( $STATEFILE );
+   $saveFile = \%{ $yaml->[0] };
+}
+# set up one dns resource for every router we have
+# too many failures when trying to define both of them at the same time
+my $dnsResource = [];
+foreach my $router ( keys %{ $config->{'routers'} } ) {
+   push @$dnsResource, Net::DNS::Resolver->new(
+    'nameservers' => [ $router ],
+    'recurse' => 0
+    );
+}
+my $refresh = 1; # determines if we get extra information like switch info, port aliases, etc...
+if ( defined( $config->{'refresh'} ) ) {
+   # get the number of seconds between refreshes
+   $refresh = &calcAge( $config->{'refresh'} );
+   # if we have not recorded a refresh, set the refresh time to run now
+   $saveFile->{'lastrefresh'} = time - &calcAge( $config->{'refresh'} ) - 1
+      unless defined $saveFile->{'lastrefresh'};
+   $refresh = $saveFile->{'lastrefresh'} + &calcAge( $config->{'refresh'} ) < time || $forceRefres;
+   $saveFile->{'lastrefresh'} = time if $refresh;
+}
+print STDERR "Doing a full refresh\n" if $refresh && $DEBUG > 1;
-die if $DEBUG > 4;
-my $switchInfo = {}; # stores information about switches
-my $macList = {}; # a list of all MAC addresses
 # load the information for the switches into $switchInfo.
 foreach my $switch ( keys %{$config->{'switches'}} ) {
    last if $nosnmp; # do not read switches if $nosnmp set
-   my %ignoreList = map { $_ => 1 } @{ $config->{'switches'}->{$switch}->{'portsToIgnore'} }; # hash of ports to ignore
+   my $ignoreList = { map { $_ => 1 } @{ $config->{'switches'}->{$switch}->{'portsToIgnore'} } }; # hash of ports to ignore
-   my $ignoreList = \%ignoreList;
+   #my $ignoreList = \%ignoreList;
    print "ignoreList for $switch\n" . Dumper ($ignoreList) if $DEBUG > 2;
    # just get basic switch information, inlcuding a list of all ports which are active and not in portsToIgnore
-   &getSwitchInfo( $switch, $config->{'switches'}->{$switch}->{'community'}, $ignoreList, $switchInfo );
+   $saveFile->{'switchInfo'}->{$switch} = &getSwitchInfo( $switch, $config->{'switches'}->{$switch}->{'community'}, $ignoreList ) if $refresh;
    # get all the MAC's on this switch
-   &getSwitchPortMacs( $switch, $config->{'switches'}->{$switch}->{'community'}, $ignoreList, $macList );
+   &getSwitchPortMacs( $switch, $config->{'switches'}->{$switch}->{'community'}, $ignoreList, $saveFile->{'macList'} );
+}
-print "switchInfo\n" . Dumper( $switchInfo ) if $DEBUG > 2;
-print "macList\n" . Dumper( $macList ) if $DEBUG > 2;
 my $routerARP = {};
 # Read the ARP table from the router(s)
 foreach my $router ( keys %{$config->{'routers'}} ) {
-   last if $nosnmp; # do not read routers if $nosnmp set
+   #last if $nosnmp; # do not read routers if $nosnmp set
-   &getRouterInfo( $router,  $config->{'routers'}->{$router}->{'community'}, $routerARP );
+   &getRouterInfo( $router,  $config->{'routers'}->{$router}->{'community'}, $routerARP ) if $refresh;
+}
 print "Routers\n" . Dumper ($routerARP ) if $DEBUG > 2;
-# load non-router entries, if they exist
-my $nonRouterEntries = {};
-if ( defined ( $config->{'nonrouter'} ) ) {
-   foreach my $filename ( @{$config->{'nonrouter'}} ) {
+# add in anything we have defined in files or in staticmaps in the config file
-      &loadNonRouterEntries( $nonRouterEntries, $scriptDir . '/' . $filename );
+&loadNonRouterEntries( $scriptDir, $config->{'nonrouter'}, $config->{'staticmaps'}, $routerARP );
-   }
-}
-print "Non-Router Entries\n" . Dumper ( $nonRouterEntries ) if $DEBUG > 2;
+print "Routers after loadNonRouterEntries\n" . Dumper ($routerARP ) if $DEBUG > 2;
-# add in any staticmaps we may have. Note it will overwrite anything from files above
-foreach my $mac ( keys %{$config->{'staticmaps'} } ) {
+# populate the mac list with information from $routerARP
-   $nonRouterEntries->{$mac}->{'hostname'} = $config->{'staticmaps'}->{$mac}->{'hostname'} if $config->{'staticmaps'}->{$mac}->{'hostname'};
-   $nonRouterEntries->{$mac}->{'ip'} = $config->{'staticmaps'}->{$mac}->{'ip'} if $config->{'staticmaps'}->{$mac}->{'ip'};
-   $nonRouterEntries->{$mac}->{'override'} = $config->{'staticmaps'}->{$mac}->{'override'} if $config->{'staticmaps'}->{$mac}->{'override'};
-}
-&updateRouterWithStatic( $routerARP, $nonRouterEntries );
+&getIPAddresses( $saveFile->{'macList'}, $routerARP );
-print "routerInfo\n" . Dumper ( $routerARP ) if $DEBUG > 2;
+print "Routers after getIPAddresses\n" . Dumper ($routerARP ) if $DEBUG > 2;
-#print Dumper( $macList ); die;
-my $saveFile = {};
+# get the DNS names
-# read the saved state into memory if it exists
-if ( -e $STATEFILE ) {
-   my $yaml = YAML::Tiny->read( $STATEFILE );
-   $saveFile = \%{ $yaml->[0] };
-}
-$saveFile->{'switchInfo'} = $switchInfo;
-foreach my $mac ( keys %$macList ) {
-   $saveFile->{'macList'}->{$mac} = $macList->{$mac};
-   $saveFile->{'macList'}->{$mac}->{'hostname'} = $routerARP->{$mac}->{'hostname'};
+&getDNSNames( $saveFile->{'macList'}, $dnsResource, $routerARP ) if $refresh;
-   $saveFile->{'macList'}->{$mac}->{'ip'} = $routerARP->{$mac}->{'ip'};
+print "Routers after getDNSNames\n" . Dumper ($routerARP ) if $DEBUG > 2;
-}
-#print Dumper( $saveFile ); die;
+# clean up any old entries
-#print Dumper( $switchInfo); die;
+&cleanUpOldEntries( $config->{'ttl'}, $saveFile ) if $config->{'ttl'} && $refresh;
 # save the file
 my $yaml = YAML::Tiny->new( $saveFile );
 $yaml->write( $STATEFILE );

Subversion Repositories sysadmin_scripts

(root)/trunk/mapSwitchPorts/mapSwitches – Rev 134 → 136