From 4f6276d74bb23bb40a9b565347a06cc8c0f601db Mon Sep 17 00:00:00 2001 From: Mike Shoup Date: Fri, 6 Feb 2015 11:52:13 -0700 Subject: [PATCH] Initial revision that works... --- README.md | 5 + hmsmlogin | 804 +++++++++++++++++++++++++++++++++++++++++++++++++++++ hmsmrancid | 517 ++++++++++++++++++++++++++++++++++ 3 files changed, 1326 insertions(+) create mode 100644 README.md create mode 100755 hmsmlogin create mode 100755 hmsmrancid diff --git a/README.md b/README.md new file mode 100644 index 0000000..d897298 --- /dev/null +++ b/README.md @@ -0,0 +1,5 @@ +# hmsmrancid + +The two scripts in this repository, `hmsmlogin` and `hmsmrancid` are hacked copies of the original hlogin and hrancid scripts from the Rancid project. + +The scripts are designed to work with an HP MSM wireless access point. Tested with an MSM430. diff --git a/hmsmlogin b/hmsmlogin new file mode 100755 index 0000000..7f79012 --- /dev/null +++ b/hmsmlogin @@ -0,0 +1,804 @@ +#! /usr/bin/expect -- +## +## rancid 3.1 +## Copyright (c) 1997-2014 by Terrapin Communications, Inc. +## All rights reserved. +## +## This code is derived from software contributed to and maintained by +## Terrapin Communications, Inc. by Henry Kilmer, John Heasley, Andrew Partan, +## Pete Whiting, Austin Schutz, and Andrew Fort. +## +## Redistribution and use in source and binary forms, with or without +## modification, are permitted provided that the following conditions +## are met: +## 1. Redistributions of source code must retain the above copyright +## notice, this list of conditions and the following disclaimer. +## 2. Redistributions in binary form must reproduce the above copyright +## notice, this list of conditions and the following disclaimer in the +## documentation and/or other materials provided with the distribution. +## 3. All advertising materials mentioning features or use of this software +## must display the following acknowledgement: +## This product includes software developed by Terrapin Communications, +## Inc. and its contributors for RANCID. +## 4. Neither the name of Terrapin Communications, Inc. nor the names of its +## contributors may be used to endorse or promote products derived from +## this software without specific prior written permission. +## 5. It is requested that non-binding fixes and modifications be contributed +## back to Terrapin Communications, Inc. +## +## THIS SOFTWARE IS PROVIDED BY Terrapin Communications, INC. AND CONTRIBUTORS +## ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +## TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +## PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COMPANY OR CONTRIBUTORS +## BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +## CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +## SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +## INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +## CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +## ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +## POSSIBILITY OF SUCH DAMAGE. +# +# The expect login scripts were based on Erik Sherk's gwtn, by permission. +# +# hmsmlogin - HP MSM login +# +# Most options are intuitive for logging into a Cisco router. +# The default is to enable (thus -noenable). Some folks have +# setup tacacs to have a user login at priv-lvl = 15 (enabled) +# so the -autoenable flag was added for this case (don't go through +# the process of enabling and the prompt will be the "#" prompt. +# The default username password is the same as the vty password. +# + +# Usage line +set usage "Usage: $argv0 \[-dSV\] \[-autoenable\] \[-noenable\] \[-c command\] \ +\[-Evar=x\] \[-e enable-password\] \[-f cloginrc-file\] \[-p user-password\] \ +\[-r passphrase\] \[-s script-file\] \[-t timeout\] \[-u username\] \ +\[-v vty-password\] \[-w enable-username\] \[-x command-file\] \ +\[-y ssh_cypher_type\] router \[router...\]\n" + +# env(CLOGIN) may contain: +# x == do not set xterm banner or name + +# Password file +set password_file $env(HOME)/.cloginrc +# Default is to login to the router +set do_command 0 +set do_script 0 +# The default is to automatically enable +set avenable 1 +# The default is that you login non-enabled (tacacs can have you login already +# enabled) +set avautoenable 0 +# The default is to look in the password file to find the passwords. This +# tracks if we receive them on the command line. +set do_passwd 1 +set do_enapasswd 1 +# Save config, if prompted +set do_saveconfig 0 +# Sometimes routers take awhile to answer (the default is 10 sec) +set timeoutdflt 45 +# +set send_human {.2 .1 .4 .2 1} + +# Find the user in the ENV, or use the unix userid. +if {[ info exists env(CISCO_USER) ]} { + set default_user $env(CISCO_USER) +} elseif {[ info exists env(USER) ]} { + set default_user $env(USER) +} elseif {[ info exists env(LOGNAME) ]} { + set default_user $env(LOGNAME) +} else { + # This uses "id" which I think is portable. At least it has existed + # (without options) on all machines/OSes I've been on recently - + # unlike whoami or id -nu. + if [ catch {exec id} reason ] { + send_error "\nError: could not exec id: $reason\n" + exit 1 + } + regexp {\(([^)]*)} "$reason" junk default_user +} +if {[ info exists env(CLOGINRC) ]} { + set password_file $env(CLOGINRC) +} + +# Process the command line +for {set i 0} {$i < $argc} {incr i} { + set arg [lindex $argv $i] + + switch -glob -- $arg { + # Expect debug mode + -d* { + exp_internal 1 + # Username + } -u* { + if {! [ regexp .\[uU\](.+) $arg ignore user]} { + incr i + set username [ lindex $argv $i ] + } + # VTY Password + } -p* { + if {! [ regexp .\[pP\](.+) $arg ignore userpasswd]} { + incr i + set userpasswd [ lindex $argv $i ] + } + set do_passwd 0 + # ssh passphrase + } -r* { + if {! [ regexp .\[rR\](.+) $arg ignore passphrase]} { + incr i + set vapassphrase [ lindex $argv $i ] + } + # VTY Password + } -v* { + if {! [ regexp .\[vV\](.+) $arg ignore passwd]} { + incr i + set passwd [ lindex $argv $i ] + } + set do_passwd 0 + # Version string + } -V* { + send_user "rancid 3.1\n" + exit 0 + # Enable Username + } -w* { + if {! [ regexp .\[wW\](.+) $arg ignore enauser]} { + incr i + set enausername [ lindex $argv $i ] + } + # Environment variable to pass to -s scripts + } -E* { + if {[ regexp .\[E\](.+)=(.+) $arg ignore varname varvalue]} { + set E$varname $varvalue + } else { + send_user "\nError: invalid format for -E in $arg\n" + exit 1 + } + # Enable Password + } -e* { + if {! [ regexp .\[e\](.+) $arg ignore enapasswd]} { + incr i + set enapasswd [ lindex $argv $i ] + } + set do_enapasswd 0 + # Command to run. + } -c* { + if {! [ regexp .\[cC\](.+) $arg ignore command]} { + incr i + set command [ lindex $argv $i ] + } + set do_command 1 + # Expect script to run. + } -s* { + if {! [ regexp .\[sS\](.+) $arg ignore sfile]} { + incr i + set sfile [ lindex $argv $i ] + } + if { ! [ file readable $sfile ] } { + send_user "\nError: Can't read $sfile\n" + exit 1 + } + set do_script 1 + # save config on exit + } -S* { + set do_saveconfig 1 + # 'ssh -c' cypher type + } -y* { + if {! [ regexp .\[eE\](.+) $arg ignore cypher]} { + incr i + set cypher [ lindex $argv $i ] + } + # alternate cloginrc file + } -f* { + if {! [ regexp .\[fF\](.+) $arg ignore password_file]} { + incr i + set password_file [ lindex $argv $i ] + } + # Timeout + } -t* { + if {! [ regexp .\[tT\](.+) $arg ignore timeout]} { + incr i + set timeoutdflt [ lindex $argv $i ] + } + # Command file + } -x* { + if {! [ regexp .\[xX\](.+) $arg ignore cmd_file]} { + incr i + set cmd_file [ lindex $argv $i ] + } + if [ catch {set cmd_fd [open $cmd_file r]} reason ] { + send_user "\nError: $reason\n" + exit 1 + } + set cmd_text [read $cmd_fd] + close $cmd_fd + set command [join [split $cmd_text \n] \;] + set do_command 1 + # Do we enable? + } -noenable { + set avenable 0 + # Does tacacs automatically enable us? + } -autoenable { + set avautoenable 1 + set avenable 0 + } -* { + send_user "\nError: Unknown argument! $arg\n" + send_user $usage + exit 1 + } default { + break + } + } +} +# Process routers...no routers listed is an error. +if { $i == $argc } { + send_user "\nError: $usage" +} + +# Only be quiet if we are running a script (it can log its output +# on its own) +if { $do_script } { + log_user 0 +} else { + log_user 1 +} + +# +# Done configuration/variable setting. Now run with it... +# + +# Sets Xterm title if interactive...if its an xterm and the user cares +proc label { host } { + global env + # if CLOGIN has an 'x' in it, don't set the xterm name/banner + if [info exists env(CLOGIN)] { + if {[string first "x" $env(CLOGIN)] != -1} { return } + } + # take host from ENV(TERM) + if [info exists env(TERM)] { + if [regexp \^(xterm|vs) $env(TERM) ignore ] { + send_user "\033]1;[lindex [split $host "."] 0]\a" + send_user "\033]2;$host\a" + } + } +} + +# This is a helper function to make the password file easier to +# maintain. Using this the password file has the form: +# add password sl* pete cow +# add password at* steve +# add password * hanky-pie +proc add {var args} { global int_$var ; lappend int_$var $args} +proc include {args} { + global env + regsub -all "(^{|}$)" $args {} args + if { [ regexp "^/" $args ignore ] == 0 } { + set args $env(HOME)/$args + } + source_password_file $args +} + +proc find {var router} { + upvar int_$var list + if { [info exists list] } { + foreach line $list { + if { [string match [lindex $line 0] $router ] } { + return [lrange $line 1 end] + } + } + } + return {} +} + +# Loads the password file. Note that as this file is tcl, and that +# it is sourced, the user better know what to put in there, as it +# could install more than just password info... I will assume however, +# that a "bad guy" could just as easy put such code in the clogin +# script, so I will leave .cloginrc as just an extention of that script +proc source_password_file { password_file } { + global env + if { ! [file exists $password_file] } { + send_user "\nError: password file ($password_file) does not exist\n" + exit 1 + } + file stat $password_file fileinfo + if { [expr ($fileinfo(mode) & 007)] != 0000 } { + send_user "\nError: $password_file must not be world readable/writable\n" + exit 1 + } + if [ catch {source $password_file} reason ] { + send_user "\nError: $reason\n" + exit 1 + } +} + +# Log into the router. +# returns: 0 on success, 1 on failure +proc login { router user userpswd passwd enapasswd cmethod cyphertype identfile } { + global spawn_id in_proc do_command do_script passphrase + global prompt u_prompt p_prompt e_prompt sshcmd + set in_proc 1 + + # try each of the connection methods in $cmethod until one is successful + set progs [llength $cmethod] + foreach prog [lrange $cmethod 0 end] { + incr progs -1 + regexp {(telnet|ssh)(:([^[:space:]]+))*} $prog command suffix junk port + if [string match "telnet*" $prog] { + if {"$port" == ""} { + if { $do_command || $do_script } { + set retval [ catch {spawn hpuifilter -- telnet $router} reason ] + } else { + set retval [ catch {spawn telnet $router} reason ] + } + } else { + set retval [ catch {spawn hpuifilter -- telnet $router $port} reason ] + } + if { $retval } { + send_user "\nError: telnet failed: $reason\n" + return 1 + } + } elseif [string match "ssh*" $prog] { + # ssh to the router & try to login with or without an identfile. + regexp {ssh(:([^[:space:]]+))*} $prog methcmd suffix port + set cmd $sshcmd + if {"$port" != ""} { + set cmd "$cmd -p $port" + } + if {"$identfile" != ""} { + set cmd "$cmd -i $identfile" + } + if { $do_command || $do_script } { + set retval [ catch {eval spawn hpuifilter -- [split "$cmd -c $cyphertype -x -l $user $router" { }]} reason ] + } else { + set retval [ catch {eval spawn [split "$cmd -c $cyphertype -x -l $user $router" { }]} reason ] + } + if { $retval } { + send_user "\nError: $cmd failed: $reason\n" + return 1 + } + } elseif ![string compare $prog "rsh"] { + send_error "\nError: unsupported method: rsh\n" + if { $progs == 0 } { + return 1 + } + continue; + } else { + send_user "\nError: unknown connection method: $prog\n" + return 1 + } + sleep 0.3 + + # This helps cleanup each expect clause. + expect_after { + timeout { + send_user "\nError: TIMEOUT reached\n" + catch {close}; catch {wait}; + if { $in_proc} { + return 1 + } else { + continue + } + } eof { + send_user "\nError: EOF received\n" + catch {close}; catch {wait}; + if { $in_proc} { + return 1 + } else { + continue + } + } + } + + # Here we get a little tricky. There are several possibilities: + # the router can ask for a username and passwd and then + # talk to the TACACS server to authenticate you, or if the + # TACACS server is not working, then it will use the enable + # passwd. Or, the router might not have TACACS turned on, + # then it will just send the passwd. + # if telnet fails with connection refused, try ssh + expect { + "Press any key to continue" { + send " " + exp_continue + } + "Enter switch number to connect to or :" { + send "\r" + exp_continue + } + -re "(Connection refused|Secure connection \[^\n\r]+ refused|Connection closed by)" { + catch {close}; catch {wait}; + if !$progs { + send_user "\nError: Connection Refused ($prog)\n"; return 1 + } + } + "Host is unreachable" { + catch {close}; catch {wait}; + send_user "\nError: Host Unreachable!\n"; wait; return 1 + } + "No address associated with name" { + catch {close}; catch {wait}; + send_user "\nError: Unknown host\n"; wait; return 1 + } + -re "(Host key not found |The authenticity of host .* be established).* \\(yes/no\\)\\?" { + send "yes\r" + send_user "\nHost $router added to the list of known hosts.\n" + exp_continue } + -re "HOST IDENTIFICATION HAS CHANGED.* \\(yes/no\\)\\?" { + send "no\r" + send_user "\nError: The host key for $router has changed. Update the SSH known_hosts file accordingly.\n" + return 1 + } + -re "HOST IDENTIFICATION HAS CHANGED\[^\n\r]+" { + send_user "\nError: The host key for $router has changed. Update the SSH known_hosts file accordingly.\n" + return 1 + } + -re "Offending key for .* \\(yes/no\\)\\?" { + send "no\r" + send_user "\nError: host key mismatch for $router. Update the SSH known_hosts file accordingly.\n" + return 1 + } + eof { send_user "\nError: Couldn't login\n"; wait; return 1 } + -nocase "unknown host\r" { + catch {close}; catch {wait}; + send_user "\nError: Unknown host\n"; wait; return 1 + } + -re "Enter passphrase.*: " { + # sleep briefly to allow time for stty -echo + sleep 1 + send -- "$passphrase\r" + exp_continue + } + -re "$u_prompt" { send -- "$user\r" + expect { + eof { send_user "\nError: Couldn't login\n"; wait; return 1 } + "Login invalid" { send_user "\nError: Invalid login\n"; + catch {close}; catch {wait}; + return 1 } + -re "$p_prompt" { send -- "$userpswd\r" } + "$prompt" { set in_proc 0; return 0 } + "Press any key to continue" { + send " " + exp_continue + } + } + exp_continue + } + -re "$p_prompt" { + if ![string compare $prog "ssh"] { + send -- "$userpswd\r" + } else { + send -- "$passwd\r" + } + expect { + eof { send_user "\nError: Couldn't login\n"; + wait; + return 1 + } + "Press any key to continue" { + send " "; + exp_continue + } + -re "$e_prompt" { send -- "$enapasswd\r" } + "$prompt" { set in_proc 0; + return 0 + } + } + exp_continue + } + "$prompt" { break; } + denied { send_user "\nError: Check your passwd for $router\n" + catch {close}; catch {wait}; return 1 + } + "% Bad passwords" {send_user "\nError: Check your passwd for $router\n"; return 1 } + } + } + + set in_proc 0 + return 0 +} + +# Enable +proc do_enable { enauser enapasswd } { + global prompt in_proc + global u_prompt e_prompt + set in_proc 1 + + send "enable\r" + expect { + -re "$u_prompt" { send -- "$enauser\r"; exp_continue} + -re "$e_prompt" { send -- "$enapasswd\r"; exp_continue} + "#" { set prompt "#" } + "(enable)" { set prompt "> (enable) " } + denied { send_user "\nError: Check your Enable passwd\n"; return 1} + "% Bad passwords" { send_user "\nError: Check your Enable passwd\n" + return 1 + } + } + # We set the prompt variable (above) so script files don't need + # to know what it is. + set in_proc 0 + return 0 +} + +# Run commands given on the command line. +proc run_commands { prompt command } { + global do_saveconfig in_proc + set in_proc 1 + + # Turn off the pager and escape regex meta characters in the $prompt + send "no page\r" + regsub -all {[)(]} $prompt {\\&} reprompt + regsub -all {^(.{1,11}).*([#>])$} $reprompt {\1([^#>\r\n]+)?[#>](\\([^)\\r\\n]+\\))?} reprompt + expect { + -re $reprompt {} + -re "\[\n\r]+" { exp_continue } + } + # this is the only way i see to get rid of more prompts in o/p..grrrrr + log_user 0 + + set sep "\\1\u001" + regsub -all {([^\\])\;} $command "$sep" esccommand + set sep "\u001" + set commands [split $esccommand $sep] + set num_commands [llength $commands] + # if the pager can not be turned off, we have to look for the "More" + # prompt. + for {set i 0} {$i < $num_commands} { incr i} { + send -- "[subst -nocommands [lindex $commands $i]]\r" + expect { + -re "^\[^\n\r *]*$reprompt" { catch {send_user -- "$expect_out(buffer)"} } + -re "^\[^\n\r]*$reprompt " { catch {send_user -- "$expect_out(buffer)"} } + -re "\[\n\r]+" { catch {send_user -- "$expect_out(buffer)"} + exp_continue } + -re "\[^\r\n]*Press to cont\[^\r\n]*" { + catch {send " "}; + expect { + # gag, 2 more prompts + -re "\[\r\n]*\r" {} + -re "\[^\r\n]*Press to cont\[^\r\n]*" { + catch {send " "}; + exp_continue + } + } + exp_continue + } + -re "^<-+ More -+>\[^\n\r]*" { catch {send " "} + exp_continue } + -re "^-+ MORE -+\[^\n\r]*" { catch {send " "} + exp_continue } + # 3 flavours of the more prompt, -- first -More-, then --More-- (for + # cisco/riverhead AGM), then with more dashes. + -re "^-More-\[^\n\r-]*" { catch {send " "} + exp_continue } + -re "^--More--\[^\n\r-]*" { catch {send " "} + exp_continue } + -re "^---+More---+\[^\n\r]*" { + catch {send " "} + exp_continue } + -re "\b+" { exp_continue } + } + } + log_user 1 + send -h "quit\r" + expect { + "Do you want to save current configuration" { + if {$do_saveconfig} { + catch {send "y\r"} + } else { + catch {send "n\r"} + } + exp_continue + } + "Do you wish to save " { + if {$do_saveconfig} { + catch {send "y\r"} + } else { + catch {send "n\r"} + } + exp_continue + } + "Do you want to log out" { + catch {send "y\r"} + exp_continue + } + -re "\[\r\n]+" { exp_continue } + -re "^.+>" { + catch {send -h "exit\r"} + exp_continue + } + timeout { catch {close}; catch {wait}; + return 0 + } + eof { return 0 } + } + set in_proc 0 +} + +# +# For each router... (this is main loop) +# +source_password_file $password_file +set in_proc 0 +set exitval 0 +foreach router [lrange $argv $i end] { + set router [string tolower $router] + send_user "$router\n" + + # device timeout + set timeout [find timeout $router] + if { [llength $timeout] == 0 } { + set timeout $timeoutdflt + } + + # Figure out prompt. + # Since autoenable is off by default, if we have it defined, it + # was done on the command line. If it is not specifically set on the + # command line, check the password file. + if $avautoenable { + set autoenable 1 + set enable 0 + set prompt "#" + } else { + set ae [find autoenable $router] + if { "$ae" == "1" } { + set autoenable 1 + set enable 0 + set prompt "#" + } else { + set autoenable 0 + set enable $avenable + set prompt ">" + } + } + + # look for noenable option in .cloginrc + if { [find noenable $router] == "1" } { + set enable 0 + } + + # Figure out passwords + if { $do_passwd || $do_enapasswd } { + set pswd [find password $router] + if { [llength $pswd] == 0 } { + send_user "\nError: no password for $router in $password_file.\n" + continue + } + if { $enable && $do_enapasswd && $autoenable == 0 && [llength $pswd] < 2 } { + send_user "\nError: no enable password for $router in $password_file.\n" + continue + } + set passwd [join [lindex $pswd 0] ""] + set enapasswd [join [lindex $pswd 1] ""] + } else { + set passwd $userpasswd + set enapasswd $enapasswd + } + + # Figure out username + if {[info exists username]} { + # command line username + set ruser $username + } else { + set ruser [join [find user $router] ""] + if { "$ruser" == "" } { set ruser $default_user } + } + + # Figure out username's password (if different from the vty password) + if {[info exists userpasswd]} { + # command line username + set userpswd $userpasswd + } else { + set userpswd [join [find userpassword $router] ""] + if { "$userpswd" == "" } { set userpswd $passwd } + } + + # Figure out enable username + if {[info exists enausername]} { + # command line enausername + set enauser $enausername + } else { + set enauser [join [find enauser $router] ""] + if { "$enauser" == "" } { set enauser $ruser } + } + + # Figure out prompts + set u_prompt [find userprompt $router] + if { "$u_prompt" == "" } { + set u_prompt "(\[Uu]sername|\[Ll]ogin|user name|Login Name):" + } else { + set u_prompt [join [lindex $u_prompt 0] ""] + } + set p_prompt [find passprompt $router] + if { "$p_prompt" == "" } { + set p_prompt "(\[Pp]assword|passwd):" + } else { + set p_prompt [join [lindex $p_prompt 0] ""] + } + set e_prompt [find enableprompt $router] + if { "$e_prompt" == "" } { + set e_prompt "\[Pp]assword:" + } else { + set e_prompt [join [lindex $e_prompt 0] ""] + } + + # Figure out identity file to use + set identfile [join [lindex [find identity $router] 0] ""] + + # Figure out passphrase to use + if {[info exists avpassphrase]} { + set passphrase $avpassphrase + } else { + set passphrase [join [lindex [find passphrase $router] 0] ""] + } + if { ! [string length "$passphrase"]} { + set passphrase $passwd + } + + # Figure out cypher type + if {[info exists cypher]} { + # command line cypher type + set cyphertype $cypher + } else { + set cyphertype [find cyphertype $router] + if { "$cyphertype" == "" } { set cyphertype "3des" } + } + + # Figure out connection method + set cmethod [find method $router] + if { "$cmethod" == "" } { set cmethod {{telnet} {ssh}} } + + # Figure out the SSH executable name + set sshcmd [join [lindex [find sshcmd $router] 0] ""] + if { "$sshcmd" == "" } { set sshcmd {ssh} } + + # Adjust our path to find hpuifilter + set hpf_path "" + regexp {(.*)/[^/]+} $argv0 junk hpf_path + if { "$hpf_path" != "" && "$hpf_path" != "." } { + append env(PATH) ":$hpf_path" + } + + # Login to the router + if {[login $router $ruser $userpswd $passwd $enapasswd $cmethod $cyphertype $identfile]} { + incr exitval + continue + } + if { $enable } { + if {[do_enable $enauser $enapasswd]} { + if { $do_command || $do_script } { + incr exitval + catch {close}; catch {wait}; + continue + } + } + } + # we are logged in, now figure out the full prompt + send "\r" + expect { + -re "\[\r\n]+" { exp_continue; } + -re "^.+$prompt" { set prompt $expect_out(0,string); } + } + + if { $do_command } { + if {[run_commands $prompt $command]} { + incr exitval + continue + } + } elseif { $do_script } { + # disable the pager + send "no page\r" + expect -re $prompt {} + source $sfile + catch {close}; + } else { + label $router + log_user 1 + interact + } + + # End of for each router + catch {wait}; + sleep 0.3 +} +exit $exitval diff --git a/hmsmrancid b/hmsmrancid new file mode 100755 index 0000000..6a1431c --- /dev/null +++ b/hmsmrancid @@ -0,0 +1,517 @@ +#! /usr/bin/perl +## +## rancid 3.1 +## Copyright (c) 1997-2014 by Terrapin Communications, Inc. +## All rights reserved. +## +## This code is derived from software contributed to and maintained by +## Terrapin Communications, Inc. by Henry Kilmer, John Heasley, Andrew Partan, +## Pete Whiting, Austin Schutz, and Andrew Fort. +## +## Redistribution and use in source and binary forms, with or without +## modification, are permitted provided that the following conditions +## are met: +## 1. Redistributions of source code must retain the above copyright +## notice, this list of conditions and the following disclaimer. +## 2. Redistributions in binary form must reproduce the above copyright +## notice, this list of conditions and the following disclaimer in the +## documentation and/or other materials provided with the distribution. +## 3. All advertising materials mentioning features or use of this software +## must display the following acknowledgement: +## This product includes software developed by Terrapin Communications, +## Inc. and its contributors for RANCID. +## 4. Neither the name of Terrapin Communications, Inc. nor the names of its +## contributors may be used to endorse or promote products derived from +## this software without specific prior written permission. +## 5. It is requested that non-binding fixes and modifications be contributed +## back to Terrapin Communications, Inc. +## +## THIS SOFTWARE IS PROVIDED BY Terrapin Communications, INC. AND CONTRIBUTORS +## ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +## TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +## PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COMPANY OR CONTRIBUTORS +## BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +## CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +## SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +## INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +## CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +## ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +## POSSIBILITY OF SUCH DAMAGE. +# +# usage: hrancid [-dltCV] [-f filename | hostname] +# +# Horrifically hacked version of the HP procurve rancid script that is an +# amazingly hacked version of Hank's rancid. +# +# usage: hmsmrancid [-dltCV] [-f filename | hostname] +# +use Getopt::Std; +getopts('dflt:CV'); +if ($opt_V) { + print "rancid 3.1\n"; + exit(0); +} +$log = $opt_l; +$debug = $opt_d; +$file = $opt_f; +$host = $ARGV[0]; +$clean_run = 0; +$found_end = 0; # unused - hp lacks an end-of-config tag +$timeo = 90; # hmsmlogin timeout in seconds + +my(@commandtable, %commands, @commands);# command lists +my($aclsort) = ("ipsort"); # ACL sorting mode +my($filter_commstr); # SNMP community string filtering +my($filter_pwds); # password filtering mode + +my($systeminfo) = 0; # show system-information + +# This routine is used to print out the router configuration +sub ProcessHistory { + my($new_hist_tag,$new_command,$command_string,@string) = (@_); + if ((($new_hist_tag ne $hist_tag) || ($new_command ne $command)) + && scalar(%history)) { + print eval "$command \%history"; + undef %history; + } + if (($new_hist_tag) && ($new_command) && ($command_string)) { + if ($history{$command_string}) { + $history{$command_string} = "$history{$command_string}@string"; + } else { + $history{$command_string} = "@string"; + } + } elsif (($new_hist_tag) && ($new_command)) { + $history{++$#history} = "@string"; + } else { + print "@string"; + } + $hist_tag = $new_hist_tag; + $command = $new_command; + 1; +} + +sub numerically { $a <=> $b; } + +# This is a sort routine that will sort numerically on the +# keys of a hash as if it were a normal array. +sub keynsort { + local(%lines) = @_; + local($i) = 0; + local(@sorted_lines); + foreach $key (sort numerically keys(%lines)) { + $sorted_lines[$i] = $lines{$key}; + $i++; + } + @sorted_lines; +} + +# This is a sort routine that will sort on the +# keys of a hash as if it were a normal array. +sub keysort { + local(%lines) = @_; + local($i) = 0; + local(@sorted_lines); + foreach $key (sort keys(%lines)) { + $sorted_lines[$i] = $lines{$key}; + $i++; + } + @sorted_lines; +} + +# This is a sort routine that will sort on the +# values of a hash as if it were a normal array. +sub valsort{ + local(%lines) = @_; + local($i) = 0; + local(@sorted_lines); + foreach $key (sort values %lines) { + $sorted_lines[$i] = $key; + $i++; + } + @sorted_lines; +} + +# This is a numerical sort routine (ascending). +sub numsort { + local(%lines) = @_; + local($i) = 0; + local(@sorted_lines); + foreach $num (sort {$a <=> $b} keys %lines) { + $sorted_lines[$i] = $lines{$num}; + $i++; + } + @sorted_lines; +} + +# This is a sort routine that will sort on the +# ip address when the ip address is anywhere in +# the strings. +sub ipsort { + local(%lines) = @_; + local($i) = 0; + local(@sorted_lines); + foreach $addr (sort sortbyipaddr keys %lines) { + $sorted_lines[$i] = $lines{$addr}; + $i++; + } + @sorted_lines; +} + +# These two routines will sort based upon IP addresses +sub ipaddrval { + my(@a) = ($_[0] =~ m#^(\d+)\.(\d+)\.(\d+)\.(\d+)$#); + $a[3] + 256 * ($a[2] + 256 * ($a[1] +256 * $a[0])); +} +sub sortbyipaddr { + &ipaddrval($a) <=> &ipaddrval($b); +} + +# This routine parses "show system-information" or "show system information" +sub ShowSystem { + print STDERR " In ShowSystem: $_" if ($debug); + + if ($systeminfo) { + $_ = ; + return(0); + } + + while () { + tr/\015//d; + last if (/^$prompt/); + next if (/^(\s*|\s*$cmd\s*)$/); + return(-1) if (/command authorization failed/i); + return(0) if /^(Invalid|Ambiguous) input:/i; + return(0) if /^% Unknown command/i; + + /Serial\s+Number:\s+(\S+)/i && + ProcessHistory("COMMENTS","keysort","A1",";Serial Number: $1\n"); + /Firmware\s+Version:\s+(\S+)/i && + ProcessHistory("COMMENTS","keysort","B0",";Firmware Version: $1\n"); + /Board\s+Revision:\s+(\S+)/i && + ProcessHistory("COMMENTS","keysort","C0",";Board Revision: $1\n"); + } + $systeminfo = 1; + + return(0); +} + +# This routine processes a "write term" +sub WriteTerm { + print STDERR " In WriteTerm: $_" if ($debug); + + while () { + tr/\015//d; + if (/$prompt\s*(exit|logout|quit)\s*$/i) { + $clean_run=1; + last; + } + last if(/^$prompt/); + return(-1) if (/command authorization failed/i); + # the pager can not be disabled per-session + s/^<-+ More -+>\s*//; + s/^$/;/; + + # skip the crap + /^running configuration:/i && next; + + # filter out any RCS/CVS tags to avoid confusing local CVS storage + s/\$(Revision|Id):/ $1:/; + /^; (\S+) configuration editor;/i && + ProcessHistory("COMMENTS","keysort","A0",";Chassis type: $1\n") && + ProcessHistory("","","",";\n;Running config file:\n$_") && + next; + + # order logging statements - doesnt appear to do syslog as of right now + /^logging (\d+\.\d+\.\d+\.\d+)/ && + ProcessHistory("LOGGING","ipsort","$1","$_") && next; + + # no so sure this match is correct. show running doesnt seem to + # actually o/p anything after "password (manager|operator)" + if (/^(\s*)password (manager|operator)?/ && $filter_pwds >= 1) { + ProcessHistory("LINE-PASS","","",";$1password $2 \n"); + next; + } + + if (/^(snmp-server community) (\S+)/) { + if ($filter_commstr) { + ProcessHistory("SNMPSERVERCOMM","keysort","$_", + ";$1 $'") && next; + } else { + ProcessHistory("SNMPSERVERCOMM","keysort","$_","$_") && next; + } + } + # order/prune snmp-server host statements - it actually appears to do + # the sortting for us, but just in case it changes ... + # we only prune lines of the form + # snmp-server host a.b.c.d + if (/^snmp-server host (\d+\.\d+\.\d+\.\d+) /) { + if ($filter_commstr) { + my($ip) = $1; + my($line) = "snmp-server host $ip"; + my(@tokens) = split(' ', $'); + my($token); + while ($token = shift(@tokens)) { + if ($token eq 'version') { + $line .= " " . join(' ', ($token, shift(@tokens))); + } elsif ($token =~ /^(informs?|traps?|(no)?auth)$/) { + $line .= " " . $token; + } else { + $line = ";$line " . join(' ', ("", join(' ',@tokens))); + last; + } + } + ProcessHistory("SNMPSERVERHOST","ipsort","$ip","$line\n"); + } else { + ProcessHistory("SNMPSERVERHOST","ipsort","$1","$_"); + } + next; + } + + # order/prune tacacs/radius server statements + if (/^(tacacs-server|radius-server) key / && $filter_pwds >= 1) { + ProcessHistory("","","",";$1 key \n"); + next; + } + if (/^(tacacs-server host \d+\.\S+) key / && $filter_pwds >= 1) { + ProcessHistory("","","",";$1 key \n"); + next; + } + + # prune passwords from stack member statements + if (/^(stack member .* password )\S+/ && $filter_pwds >= 1) { + ProcessHistory("","","",";$1$'"); + next; + } + + # order arp lists + /^ip arp\s+(\d+\.\d+\.\d+\.\d+)/ && + ProcessHistory("ARP","$aclsort","$1","$_") && next; + + /^ip prefix-list\s+(\S+)\s+seq\s+(\d+)\s+(permit|deny)\s+(\d\S+)(\/.*)$/ && + ProcessHistory("PACL $1 $3","$aclsort","$4","ip prefix-list $1 $3 $4$5\n") + && next; + + # blech!!!! + /^auto-tftp / && + ProcessHistory("","","",";$_") && next; + + + # the rest are from rancid (i.e.: cisco), but suspect they will someday + # be applicable or close to it. + + /^tftp-server flash / && next; # kill any tftp remains + /^ntp clock-period / && next; # kill ntp clock-period + /^ length / && next; # kill length on serial lines + /^ width / && next; # kill width on serial lines + if (/^(enable )?(password|passwd) / && $filter_pwds >= 1) { + ProcessHistory("ENABLE","","",";$1$2 \n"); + next; + } + if (/^username (\S+)(\s.*)? password /) { + if ($filter_pwds >= 1) { + ProcessHistory("USER","keysort","$1",";username $1$2 password \n"); + } else { + ProcessHistory("USER","keysort","$1","$_"); + } + next; + } + + if (/^(ip ftp password) / && $filter_pwds >= 1) { + ProcessHistory("","","",";$1 \n"); next; + } + if (/^( ip ospf authentication-key) / && $filter_pwds >= 1) { + ProcessHistory("","","",";$1 \n"); next; + } + if (/^( ip ospf message-digest-key \d+ md5) / && $filter_pwds >= 1) { + ProcessHistory("","","",";$1 \n"); next; + } + # sort route-maps + if (/^route-map (\S+)/) { + my($key) = $1; + my($routemap) = $_; + while () { + tr/\015//d; + last if (/^$prompt/ || ! /^(route-map |[ !])/); + if (/^route-map (\S+)/) { + ProcessHistory("ROUTEMAP","keysort","$key","$routemap"); + $key = $1; + $routemap = $_; + } else { + $routemap .= $_; + } + } + ProcessHistory("ROUTEMAP","keysort","$key","$routemap"); + } + # order access-lists + /^access-list\s+(\d\d?)\s+(\S+)\s+(\S+)/ && + ProcessHistory("ACL $1 $2","$aclsort","$3","$_") && next; + # order extended access-lists + /^access-list\s+(\d\d\d)\s+(\S+)\s+ip\s+host\s+(\S+)/ && + ProcessHistory("EACL $1 $2","$aclsort","$3","$_") && next; + /^access-list\s+(\d\d\d)\s+(\S+)\s+ip\s+(\d\S+)/ && + ProcessHistory("EACL $1 $2","$aclsort","$3","$_") && next; + /^access-list\s+(\d\d\d)\s+(\S+)\s+ip\s+any/ && + ProcessHistory("EACL $1 $2","$aclsort","0.0.0.0","$_") && next; + + # order alias statements + /^alias / && ProcessHistory("ALIAS","keysort","$_","$_") && next; + # delete ntp auth password + if (/^(ntp authentication-key \d+ md5) / && $filter_pwds >= 1) { + ProcessHistory("","","",";$1 \n"); next; + } + # order ntp peers/servers + if (/^ntp (server|peer) (\d+)\.(\d+)\.(\d+)\.(\d+)/) { + $sortkey = sprintf("$1 %03d%03d%03d%03d",$2,$3,$4,$5); + ProcessHistory("NTP","keysort",$sortkey,"$_"); + next; + } + # order ip host line statements + /^ip host line(\d+)/ && + ProcessHistory("IPHOST","numsort","$1","$_") && next; + # order ip nat source static statements + /^ip nat (\S+) source static (\S+)/ && + ProcessHistory("IP NAT $1","ipsort","$2","$_") && next; + # order ip rcmd lines + /^ip rcmd/ && ProcessHistory("RCMD","keysort","$_","$_") && next; + + # Kill the following two lines, they change everytime a config is pulled: + /^# Who: / && next; + /^# When: / && next; + + # catch anything that wasnt match above. + ProcessHistory("","","","$_"); + } + return(0); +} + +# Main +@commandtable = ( + {'show system info' => 'ShowSystem'}, + {'show all config' => 'WriteTerm'} +); +# Use an array to preserve the order of the commands and a hash for mapping +# commands to the subroutine and track commands that have been completed. +@commands = map(keys(%$_), @commandtable); +%commands = map(%$_, @commandtable); +$commandcnt = scalar(keys %commands); + +$commandstr=join(";",@commands); +$cmds_regexp = join("|", map quotemeta($_), @commands); + +if (length($host) == 0) { + if ($file) { + print(STDERR "Too few arguments: file name required\n"); + exit(1); + } else { + print(STDERR "Too few arguments: host name required\n"); + exit(1); + } +} +if ($opt_C) { + print "hmsmlogin -t $timeo -c\'$commandstr\' $host\n"; + exit(0); +} +open(OUTPUT,">$host.new") || die "Can't open $host.new for writing: $!\n"; +select(OUTPUT); +# make OUTPUT unbuffered if debugging +if ($debug) { $| = 1; } + +if ($file) { + print STDERR "opening file $host\n" if ($debug); + print STDOUT "opening file $host\n" if ($log); + open(INPUT,"<$host") || die "open failed for $host: $!\n"; +} else { + print STDERR "executing hmsmlogin -t $timeo -c\"$commandstr\" $host\n" if ($debug); + print STDOUT "executing hmsmlogin -t $timeo -c\"$commandstr\" $host\n" if ($log); + if (defined($ENV{NOPIPE}) && $ENV{NOPIPE} =~ /^YES/i) { + system "hmsmlogin -t $timeo -c \"$commandstr\" $host $host.raw 2>&1" || die "hmsmlogin failed for $host: $!\n"; + open(INPUT, "< $host.raw") || die "hmsmlogin failed for $host: $!\n"; + } else { + open(INPUT,"hmsmlogin -t $timeo -c \"$commandstr\" $host ) { + tr/\015//d; + if (/$prompt\s*(exit|logout|quit)\s*$/i) { + $clean_run=1; + last; + } + if (/^Error:/) { + print STDOUT ("$host clogin error: $_"); + print STDERR ("$host clogin error: $_") if ($debug); + $clean_run=0; + last; + } + while (/#\s*($cmds_regexp)\s*$/) { + $cmd = $1; + if (!defined($prompt)) { + $prompt = ($_ =~ /^([^#]+)/)[0]; + $prompt =~ s/([][}{)(\\])/\\$1/g; + $prompt .= "[#>]"; + print STDERR ("PROMPT MATCH: $prompt\n") if ($debug); + } + print STDERR ("HIT COMMAND:$_") if ($debug); + if (! defined($commands{$cmd})) { + print STDERR "$host: found unexpected command - \"$cmd\"\n"; + $clean_run = 0; + last TOP; + } + $rval = &{$commands{$cmd}}(*INPUT, *OUTPUT, $cmd); + delete($commands{$cmd}); + if ($rval == -1) { + $clean_run = 0; + last TOP; + } + } +} +print STDOUT "Done $logincmd: $_\n" if ($log); +# Flush History +ProcessHistory("","","",""); +# Cleanup +close(INPUT); +close(OUTPUT); + +if (defined($ENV{NOPIPE}) && $ENV{NOPIPE} =~ /^YES/i) { + unlink("$host.raw") if (! $debug); +} + +# check for completeness +if (scalar(%commands) || !$clean_run) { + if (scalar(keys %commands) eq $commandcnt) { + printf(STDERR "$host: missed cmd(s): all commands\n"); + } elsif (scalar(%commands)) { + printf(STDOUT "$host: missed cmd(s): %s\n", join(',', keys(%commands))); + printf(STDERR "$host: missed cmd(s): %s\n", join(',', keys(%commands))) if ($debug); + } + if (!$clean_run) { + print STDOUT "$host: End of run not found\n"; + print STDERR "$host: End of run not found\n" if ($debug); + system("/usr/bin/tail -1 $host.new"); + } + unlink "$host.new" if (! $debug); +}