web-dev-qa-db-fra.com

automatiser la session telnet à l'aide de scripts bash

Je travaille sur l'automatisation de certaines tâches liées à telnet, à l'aide de scripts Bash ... Une fois automatisé, il n'y aura plus d'interaction de l'utilisateur avec telnet. (c'est ce sera totalement automatisé)

les scripts ressemblent à ceci:

# execute some commands on the local system
# access a remote system with an IP address: 10.1.1.1 (for example)

telnet 10.1.1.1

# execute some commands on the remote system
# log all the activity (in a file) on the Local system
# exit telnet
# continue on with executing the rest of the script.

Il y a 2 problèmes que je rencontre ici:

  1. Comment exécuter les commandes sur le système distant à partir du script (sans interaction humaine)? 

    D'après mon expérience avec certains codes de test, j'ai pu déduire que, lorsque telnet 10.1.1.1 est exécuté, telnet passe en session interactive et les lignes de code suivantes du script sont exécutées sur le système local. Comment puis-je exécuter les lignes de code sur le système distant plutôt que local?

  2. Je ne parviens pas à obtenir un fichier journal pour l'activité de la session telnet sur le système local. La redirection stdout que j'ai utilisée crée une copie sur le système distant (je ne souhaite pas effectuer d'opération de copie pour copier le journal sur le système local). Comment puis-je obtenir cette fonctionnalité?

linuxbashtelnet
70
khan

Ecrivez un expect script.

Voici un exemple:

#!/usr/bin/expect

#If it all goes pear shaped the script will timeout after 20 seconds.
set timeout 20
#First argument is assigned to the variable name
set name [lindex $argv 0]
#Second argument is assigned to the variable user
set user [lindex $argv 1]
#Third argument is assigned to the variable password
set password [lindex $argv 2]
#This spawns the telnet program and connects it to the variable name
spawn telnet $name 
#The script expects login
expect "login:" 
#The script sends the user variable
send "$user "
#The script expects Password
expect "Password:"
#The script sends the password variable
send "$password "
#This hands control of the keyboard over two you (Nice expect feature!)
interact
67
joemooney

Bien que je suggère d'utiliser aussi l'attente, pour une utilisation non interactive, les commandes normales de Shell peuvent suffire. Telnet accepte sa commande sur stdin, il vous suffit donc de diriger ou d’écrire les commandes dessus:

telnet 10.1.1.1 <<EOF
remotecommand 1
remotecommand 2
EOF

(Édition: à en juger par les commentaires, la commande à distance a besoin de temps pour traiter les entrées ou le début de SIGHUP n'est pas pris avec élégance par telnet. Dans ce cas, vous pouvez essayer de faire une courte veille sur l'entrée :)

{ echo "remotecommand 1"; echo "remotecommand 2"; sleep 1; } | telnet 10.1.1.1

Dans tous les cas, si cela devient interactif ou quoi que ce soit, utilisez expect.

73
thiton

Telnet est souvent utilisé pour apprendre le protocole HTTP. J'avais l'habitude d'utiliser ce script comme une partie de mon gratte Web:

echo "open www.example.com 80" 
sleep 2 
echo "GET /index.html HTTP/1.1" 
echo "Host: www.example.com" 
echo 
echo 
sleep 2

disons que le nom du script est get-page.sh alors:

get-page.sh | telnet

vous donnera un document HTML.

J'espère que ça va être utile à quelqu'un;)

40
biera

Cela a fonctionné pour moi .. 

J'essayais d'automatiser plusieurs connexions Telnet nécessitant un nom d'utilisateur et un mot de passe. La session telnet doit fonctionner en arrière-plan indéfiniment, car je sauvegarde les journaux de différents serveurs sur mon ordinateur.

telnet.sh automatise la connexion telnet à l'aide de la commande "expect". Plus d'informations peuvent être trouvées ici: http://osix.net/modules/article/?id=30

telnet.sh

#!/usr/bin/expect
set timeout 20
set hostName [lindex $argv 0]
set userName [lindex $argv 1]
set password [lindex $argv 2]

spawn telnet $hostName

expect "User Access Verification"
expect "Username:"
send "$userName\r"
expect "Password:"
send "$password\r";
interact

sample_script.sh est utilisé pour créer un processus d'arrière-plan pour chacune des sessions telnet en exécutant telnet.sh. Plus d'informations peuvent être trouvées dans la section commentaires du code.

sample_script.sh

#!/bin/bash
#start screen in detached mode with session-name 'default_session' 
screen -dmS default_session -t screen_name 
#save the generated logs in a log file 'abc.log' 
screen -S default_session -p screen_name -X stuff "script -f /tmp/abc.log $(printf \\r)"
#start the telnet session and generate logs
screen -S default_session -p screen_name -X stuff "expect telnet.sh hostname username password $(printf \\r)"
  1. Assurez-vous qu'aucun écran ne s'exécute dans le fond en utilisant la commande 'Screen -ls'. 
  2. Lisez http://www.gnu.org/software/screen/manual/screen.html#Stuff pour en savoir plus sur l’écran et ses options. 
  3. L’option '-p' dans sample_script.sh présélectionne et réaffecte à une fenêtre spécifique l’envoi d’une commande via l’option ‘-X’, faute de quoi vous obtenez une erreur 'Aucune session écran trouvée.
9
Nikhil

Ce qui suit fonctionne pour moi ... Mettez toutes vos adresses IP que vous voulez telnet dans IP_sheet.txt

while true
read a
do
{
    sleep 3
    echo df -kh
    sleep 3
    echo exit
} | telnet $a
done<IP_sheet.txt
2
SAEED MAHMOOD ASLAM

Vous pouvez utiliser des scripts attendus au lieu de bash . L'exemple ci-dessous montre comment télnexer sur un tableau intégré sans mot de passe

#!/usr/bin/expect

set ip "<ip>"

spawn "/bin/bash"
send "telnet $ip\r"
expect "'^]'."
send "\r"
expect "#"
sleep 2

send "ls\r"
expect "#"

sleep 2
send -- "^]\r"
expect "telnet>"
send  "quit\r"
expect eof
2
A R

Utilisez ssh à cette fin. Générez des clés sans utiliser de mot de passe et placez-les sur .authorized_keys sur la machine distante. Créez le script à exécuter à distance, copiez-le sur l'autre machine, puis exécutez-le à distance à l'aide de ssh.

J'ai utilisé cette approche plusieurs fois avec un grand succès. Notez également que c'est beaucoup plus sécurisé que telnet.

1
TMS

Voici comment utiliser telnet dans bash Shell/expect 

#!/usr/bin/expect
# just do a chmod 755 one the script
# ./YOUR_SCRIPT_NAME.sh $YOUHOST $PORT
# if you get "Escape character is '^]'" as the output it means got connected otherwise it has failed

set ip [lindex $argv 0]
set port [lindex $argv 1]

set timeout 5
spawn telnet $ip $port
expect "'^]'."
0
grepit
#!/bin/bash
ping_count="4"
avg_max_limit="1500"
router="sagemcom-fast-2804-v2"
adress="192.168.1.1"
user="admin"
pass="admin"

VAR=$(
expect -c " 
        set timeout 3
        spawn telnet "$adress"
        expect \"Login:\" 
        send \"$user\n\"
        expect \"Password:\"
        send \"$pass\n\"
        expect \"commands.\"
        send \"ping ya.ru -c $ping_count\n\"
        set timeout 9
        expect \"transmitted\"
        send \"exit\"
        ")

count_ping=$(echo "$VAR" | grep packets | cut -c 1)
avg_ms=$(echo "$VAR" | grep round-trip | cut -d '/' -f 4 | cut -d '.' -f 1)

echo "1_____ping___$count_ping|||____$avg_ms"
echo "$VAR"
0
shaman888