#############################################################################################################
# AUTOMATION IS FOR EVERYONE --- Neelkanth #
#############################################################################################################
#!/usr/bin/expect -f
##############################################################################################################
# Variables:
##############################################################################################################
# set expect timeout to 60 secs
set timeout 60
set CLI_PROMPT 12345
set ADMIN_USER_NAME admin
set ADMIN_PASSWORD admin123
set PRE_CLI_PROMPT asdf
set NEW_PROMPT zxcv
#############################################################################################################
# Create a array of passwords here
#############################################################################################################
set pwd_list {
admin123
1
fasdfsf
werqwerqwer
213421342134214213
23412341234213333333333
ddddddddddddddddd
a3453345
admin123
}
#################################################################################################################
# PROCEDURES / FUNCTIONS
#################################################################################################################
##############################################################################
# Procedure: terminate_session_from_RG_shell_prompt
#
# Arguments: none
##############################################################################
proc terminate_session_from_RG_shell_prompt {} {
# Send special ^] to telnet so we can tell telnet to quit.
expect "# " { send “35\r” }
expect "telnet>" { send "q\r\r" }
expect eof
# You should also, either call "wait" (block) for process to exit or "wait -nowait"
# (don't block waiting) for process exit.
# Without "wait", expect may sever the connection to the process prematurely, this
# can cause the creation zombies in some rare cases. If the application did not get our
# signal earlier (the EOF from close), or if the process doesn't interpret EOF as an exit
# status then it may also continue running and your script would be none the wiser.
# With wait, we ensure we don't forget about the process until it cleans up and exits.
# < in short, wait is to clean up zombies >
wait
sleep 1
}
##############################################################################
# Procedure: terminate_session_from_RG_CLI_PROMPT
#
# Arguments: none
##############################################################################
proc terminate_session_from_RG_CLI_PROMPT {} {
# Send special ^] to telnet so we can tell telnet to quit.
global CLI_PROMPT
expect $CLI_PROMPT { send “35\r” }
expect "telnet>" { send "q\r\r" }
expect eof
#############################################################################################
# You should also, either call "wait" (block) for process to exit or "wait -nowait" #
# (don't block waiting) for process exit. #
# Without "wait", expect may sever the connection to the process prematurely, this #
# can cause the creation zombies in some rare cases. If the application did not get our #
# signal earlier (the EOF from close), or if the process doesn't interpret EOF as an exit #
# status then it may also continue running and your script would be none the wiser. #
# With wait, we ensure we don't forget about the process until it cleans up and exits. #
# < in short, wait is to clean up zombies > #
#############################################################################################
wait
sleep 1
}
##############################################################################
# Procedure: terminate_telnet_ssh_session
#
# Arguments:
# argv1 : ssh / telnet
##############################################################################
proc terminate_telnet_ssh_session {INPUT} {
if { $INPUT == "telnet"} {
sleep 1
puts "##########################################################################"
puts " Terminate telnet Session"
puts "##########################################################################"
send “35\r”
expect "telnet>" { send "q\r\r"
puts "telnet session terminated successfully"}
expect eof
wait
sleep 1
} elseif {$INPUT == "ssh"} {
sleep 1
puts "##########################################################################"
puts " Terminate ssh Session"
puts "##########################################################################"
send "exit\r"
expect "Goodbye." { puts "ssh session terminated successfully." }
expect eof
wait
sleep 1
}
return
}
##############################################################################
# Procedure: reconnect_to_rg
#
# Arguments:
# arg1: <username>
# arg2: <ip address>
# arg3: <password>
##############################################################################
proc reconnect_to_rg {USERNAME IP_ADDRESS PWD} {
global CLI_PROMPT
global PRE_CLI_PROMPT
puts "#################################################################"
puts "# reconnect_to_rg "
puts "#################################################################"
spawn telnet $IP_ADDRESS
#################################################################
# Enter Login and user name
#################################################################
expect "*login:*" { send "$USERNAME\r"}
expect "*Password:*" {send "$PWD\r" }
sleep 1
puts "\n\n\n***********************************************************"
puts "Debug: Entered username is $USERNAME"
puts "Debug: Entered password is $PWD"
puts "***********************************************************"
#################################################################
# Enter Into pre-cli prompt :
#################################################################
expect $PRE_CLI_PROMPT {send "cli\r"}
puts "\n\n\n***********************************************************"
puts "Status: entering into cli prompt"
puts "\n***********************************************************"
sleep 1
return
}
##############################################################################
# Procedure: test_telnet_to_rg
#
# Arguments:
# arg1: <test case no.>
# arg2: <username>
# arg3: <ip address>
# arg4: <password>
##############################################################################
proc test_telnet_to_rg {TESTCASE_NUM USERNAME IP_ADDRESS PWD} {
global PRE_CLI_PROMPT
puts "\n\n\n$################################################"
puts "Debug: Entered username is $USERNAME"
puts "Debug: Entered password is $PWD"
puts "$################################################"
#################################################################
# spawn telnet to RG session
#################################################################
spawn telnet $IP_ADDRESS
#################################################################
# Enter Login and user name
#################################################################
expect "*login:*" { send "$USERNAME\r"}
expect "*Password:*" {send "$PWD\r" }
sleep 1
if {$USERNAME eq "user" & $PWD eq ""} {
expect "Login incorrect" {
puts "\n\n#################################################################"
puts "Test case $TESTCASE_NUM: $USERNAME account, default pwd:$PWD PASSED"
puts "###################################################################"
terminate_telnet_ssh_session telnet
return
}
# If user account sdb password parameter is empty, then user login should fail
# even when default password is empty.
puts "\n\n#################################################################"
puts "Test case $TESTCASE_NUM: $USERNAME account, default pwd:$PWD FAILED"
puts "###################################################################"
terminate_telnet_ssh_session telnet
return
}
# If login is successful, test case is passed.
expect "$USERNAME completed login" {
puts "\n\n##################################################################"
puts "Test case $TESTCASE_NUM: $USERNAME account, default pwd:$PWD PASSED"
puts "####################################################################"
terminate_telnet_ssh_session telnet
return
}
# If login is not successful, test case is failed.
puts "\n\n#####################################################"
puts "Test case $TESTCASE_NUM: $USERNAME account, default pwd:$PWD FAILED"
puts "#####################################################"
terminate_telnet_ssh_session telnet
return
}
##############################################################################
# Procedure: test_ssh_to_rg
#
# Arguments:
# arg1: <test case no.>
# arg2: <username>
# arg3: <ip address>
# arg4: <password>
##############################################################################
proc test_ssh_to_rg {TESTCASE_NUM USERNAME IP_ADDRESS PWD} {
puts "\n\n\n$################################################"
puts "Debug: Entered username is $USERNAME"
puts "Debug: Entered password is $PWD"
puts "$################################################"
#################################################################
# spawn ssh to RG session
#################################################################
spawn ssh $USERNAME@$IP_ADDRESS
expect "*password" {send "$PWD\r"}
# If ssh login is successful, test case is failed
expect "$USERNAME completed login" {
puts "\n\n################################################################"
puts "Test case $TESTCASE_NUM: $USERNAME account, default pwd:$PWD PASSED"
puts "##################################################################"
terminate_telnet_ssh_session ssh
return
}
# If ssh login fails, test case is failed
puts "\n\n################################################################"
puts "Test case $TESTCASE_NUM: $USERNAME account, default pwd:$PWD FAILED"
puts "##################################################################"
terminate_telnet_ssh_session ssh
return
}
#################################################################################################################
# MAIN SCRIPT STARTS HERE
#################################################################################################################
#################################################################
# spawn telnet to RG session
#################################################################
spawn telnet 192.168.1.254
#################################################################
# Enter Login and user name
#################################################################
expect "*login:*" { send "$ADMIN_USER_NAME\r"}
expect "*Password:*" {send "$ADMIN_PASSWORD\r" }
sleep 1
puts "\n\n\n***********************************************************"
puts "Debug: Entered username is $ADMIN_USER_NAME"
puts "Debug: Entered password is $ADMIN_PASSWORD"
puts "***********************************************************"
#################################################################
# Enter Into pre-cli prompt :
#################################################################
expect $PRE_CLI_PROMPT {send "cli\r"}
puts "\n\n\n***********************************************************"
puts "Status: entering into cli prompt"
puts "\n***********************************************************"
sleep 1
expect $CLI_PROMPT { send "\r\r"
sleep 1 }
puts "\n\n\n*********************************************************"
puts "Status: entered cli prompt successfully"
puts "*********************************************************"
#####################################################################################
#
# Enter Into nsh prompt #
#
#####################################################################################
expect $CLI_PROMPT { send "!nsh\r" }
expect "*login*" { send "admin\r" }
expect "*Password:*" {send "$ADMIN_PASSWORD\r\r\r\r"}
sleep 1
##########################################################################################
#
# why send "[xyz\r]" should be in send "\[xyz\r\]"
##########################################################################################
# -re "[sudo] password for subhasish:" {send "$password\r"}
# In Tcl (and hence in expect) the square brackets are the syntax
# for command substitution (like backticks in the shell). So you
# either need to escape the brackets or use different quotes that
# prevent various expansions:
#
# -re {[sudo] password for subhasish:} {send "$password\r"}
# That brings up a different issue: are you expecting to see these
# exact characters? Because you're instructing expect to treat that as
# a regular expression, and square brackets in a regular expression means
# a character class, so it will match a single character,
# either a 's', 'u', 'd' or 'o'. So what you probably need is this:
# -re {\[sudo\] password for subhasish:} {send "$password\r"}
###########################################################################################
puts "\n##########################################################################"
puts " DISPLAY THE DEFAULT VALUES IN ALL MANAGEMENT ACCOUNTS"
puts "##########################################################################"
for {set acc_number 1} {$acc_number < 8 } {incr acc_number} {
expect $NEW_PROMPT {send "get mgmt.account\[$acc_number\].password\r"}
sleep 1
}
expect $NEW_PROMPT {send "exit\r"}
puts "\n##########################################################################"
puts " Testing Begins "
puts "##########################################################################"
#############################################################################################
# ITERATION BEGINS #
#############################################################################################
set count 0
foreach password $pwd_list {
puts "\n##########################################################################"
incr count
set length [string length $password]
puts "Iteration $count Password: $password Length: $length"
puts "\n##########################################################################"
puts "\n##########################################################################"
puts " In cli prompt, enter TR69 commands for setting admin, user "
puts " and remotessh passwords."
puts "##########################################################################"
expect $CLI_PROMPT {
puts "\n#####################################################################"
send "tr69 set tr69_residential_gateway_device.User.1.Password=$password\r"
expect "SetParameterValues successful" { puts "tr69 parameter user 'admin' set success"}
sleep 1
puts "\n#####################################################################"
}
expect $CLI_PROMPT {
puts "\n#####################################################################"
send "tr69 set tr69_residential_gateway_device.User.2.Password=$password\r"
expect "SetParameterValues successful" { puts "tr69 parameter user 'user' set success"}
puts "#####################################################################"
sleep 1
}
expect $CLI_PROMPT {
puts "\n#####################################################################"
send "tr69 set tr69_residential_gateway_device.User.7.Password=$password\r"
expect "SetParameterValues successful" { puts "tr69 parameter user 'remotessh' set success"}
puts "#####################################################################"
sleep 1
}
###################################################################################################
# Exit from the session now
###################################################################################################
terminate_session_from_RG_CLI_PROMPT
###################################################################################################
# Testing telnet connection for accounts: 'admin', 'user' and ssh connection for account 'remotessh'
###################################################################################################
puts "#####################################################################"
puts "# Iteration:$count Password:$password Account:admin Length: $length"
puts "#####################################################################"
test_telnet_to_rg 1 admin "192.168.1.254" $password
sleep 2
puts "#####################################################################"
puts "# Iteration:$count Password:$password Account:user Length: $length"
puts "#####################################################################"
test_telnet_to_rg 2 user "192.168.1.254" $password
sleep 2
puts "#####################################################################"
puts "# Iteration:$count Password:$password Account:remotessh Length: $length"
puts "#####################################################################"
test_ssh_to_rg 3 remotessh "192.168.1.254" $password
sleep 2
###################################################################################################
# Reconnect to RG via telnet
###################################################################################################
#################################################################
# spawn telnet to RG session
#################################################################
spawn telnet 192.168.1.254
expect "*login:*" { send "$ADMIN_USER_NAME\r"}
expect "*Password:*" {send "$password\r" }
sleep 1
puts "\n\n\n***********************************************************"
puts "Debug: Entered username is $ADMIN_USER_NAME"
puts "Debug: Entered password is $password"
puts "***********************************************************"
#################################################################
# Enter Into pre-cli prompt :
#################################################################
expect $PRE_CLI_PROMPT {send "cli\r"}
puts "\n\n\n***********************************************************"
puts "Status: entering into cli prompt"
puts "\n***********************************************************"
sleep 1
}
#############################################################################################
# ITERATION ENDS #
#############################################################################################