Module telnetlib

Module telnetlib is part of standard Python library. This is telnet client implementation.

Note

It is also possible to connect via telnet using pexpect. The advantage of telnetlib is that this module is part of standard Python library.

Telnetlib resembles pexpect but has several differences. The most notable difference is that telnetlib requires a pass of a byte string, rather than normal one.

Connection is performed as follows:

In [1]: telnet = telnetlib.Telnet('192.168.100.1')

Method read_until

Method read_until specifies till which line the output should be read. However, as an argument, it is necessary to pass bytes, not the usual string:

In [2]: telnet.read_until(b'Username')
Out[2]: b'\r\n\r\nUser Access Verification\r\n\r\nUsername'

Method read_until returns everything it has read before specified string.

Method write

The write method is used to transmit data. You must pass a byte string as an argument:

In [3]: telnet.write(b'cisco\n')

Read output till Password and pass the password:

In [4]: telnet.read_until(b'Password')
Out[4]: b': cisco\r\nPassword'

In [5]: telnet.write(b'cisco\n')

You can now specify what should be read untill prompt and then send the command:

In [6]: telnet.read_until(b'>')
Out[6]: b': \r\nR1>'

In [7]: telnet.write(b'sh ip int br\n')

After sending a command, you can continue to use read_until method:

In [8]: telnet.read_until(b'>')
Out[8]: b'sh ip int br\r\nInterface                  IP-Address      OK? Method Status                Protocol\r\nEthernet0/0                192.168.100.1   YES NVRAM  up                    up      \r\nEthernet0/1                192.168.200.1   YES NVRAM  up                    up      \r\nEthernet0/2                19.1.1.1        YES NVRAM  up                    up      \r\nEthernet0/3                192.168.230.1   YES NVRAM  up                    up      \r\nEthernet0/3.100            10.100.0.1      YES NVRAM  up                    up      \r\nEthernet0/3.200            10.200.0.1      YES NVRAM  up                    up      \r\nEthernet0/3.300            10.30.0.1       YES NVRAM  up                    up      \r\nR1>'

Method read_very_eager

Or use another read method read_very_eager. When using read_very_eager method, you can send multiple commands and then read all available output:

In [9]: telnet.write(b'sh arp\n')

In [10]: telnet.write(b'sh clock\n')

In [11]: telnet.write(b'sh ip int br\n')

In [12]: all_result = telnet.read_very_eager().decode('utf-8')

In [13]: print(all_result)
sh arp
Protocol  Address          Age (min)  Hardware Addr   Type   Interface
Internet  10.30.0.1               -   aabb.cc00.6530  ARPA   Ethernet0/3.300
Internet  10.100.0.1              -   aabb.cc00.6530  ARPA   Ethernet0/3.100
Internet  10.200.0.1              -   aabb.cc00.6530  ARPA   Ethernet0/3.200
Internet  19.1.1.1                -   aabb.cc00.6520  ARPA   Ethernet0/2
Internet  192.168.100.1           -   aabb.cc00.6500  ARPA   Ethernet0/0
Internet  192.168.100.2         124   aabb.cc00.6600  ARPA   Ethernet0/0
Internet  192.168.100.3         143   aabb.cc00.6700  ARPA   Ethernet0/0
Internet  192.168.100.100       160   aabb.cc80.c900  ARPA   Ethernet0/0
Internet  192.168.200.1           -   0203.e800.6510  ARPA   Ethernet0/1
Internet  192.168.200.100        13   0800.27ac.16db  ARPA   Ethernet0/1
Internet  192.168.230.1           -   aabb.cc00.6530  ARPA   Ethernet0/3
R1>sh clock
*19:18:57.980 UTC Fri Nov 3 2017
R1>sh ip int br
Interface                  IP-Address      OK? Method Status                Protocol
Ethernet0/0                192.168.100.1   YES NVRAM  up                    up
Ethernet0/1                192.168.200.1   YES NVRAM  up                    up
Ethernet0/2                19.1.1.1        YES NVRAM  up                    up
Ethernet0/3                192.168.230.1   YES NVRAM  up                    up
Ethernet0/3.100            10.100.0.1      YES NVRAM  up                    up
Ethernet0/3.200            10.200.0.1      YES NVRAM  up                    up
Ethernet0/3.300            10.30.0.1       YES NVRAM  up                    up
R1>

Warning

You should always set time.sleep(n) before using read_very_eager.

With read_until will be a slightly different approach. You can execute the same three commands, but then get the output one by one because of reading till prompt string:

In [14]: telnet.write(b'sh arp\n')

In [15]: telnet.write(b'sh clock\n')

In [16]: telnet.write(b'sh ip int br\n')

In [17]: telnet.read_until(b'>')
Out[17]: b'sh arp\r\nProtocol  Address          Age (min)  Hardware Addr   Type   Interface\r\nInternet  10.30.0.1               -   aabb.cc00.6530  ARPA   Ethernet0/3.300\r\nInternet  10.100.0.1              -   aabb.cc00.6530  ARPA   Ethernet0/3.100\r\nInternet  10.200.0.1              -   aabb.cc00.6530  ARPA   Ethernet0/3.200\r\nInternet  19.1.1.1                -   aabb.cc00.6520  ARPA   Ethernet0/2\r\nInternet  192.168.100.1           -   aabb.cc00.6500  ARPA   Ethernet0/0\r\nInternet  192.168.100.2         126   aabb.cc00.6600  ARPA   Ethernet0/0\r\nInternet  192.168.100.3         145   aabb.cc00.6700  ARPA   Ethernet0/0\r\nInternet  192.168.100.100       162   aabb.cc80.c900  ARPA   Ethernet0/0\r\nInternet  192.168.200.1           -   0203.e800.6510  ARPA   Ethernet0/1\r\nInternet  192.168.200.100        15   0800.27ac.16db  ARPA   Ethernet0/1\r\nInternet  192.168.230.1           -   aabb.cc00.6530  ARPA   Ethernet0/3\r\nR1>'

In [18]: telnet.read_until(b'>')
Out[18]: b'sh clock\r\n*19:20:39.388 UTC Fri Nov 3 2017\r\nR1>'

In [19]: telnet.read_until(b'>')
Out[19]: b'sh ip int br\r\nInterface                  IP-Address      OK? Method Status                Protocol\r\nEthernet0/0                192.168.100.1   YES NVRAM  up                    up      \r\nEthernet0/1                192.168.200.1   YES NVRAM  up                    up      \r\nEthernet0/2                19.1.1.1        YES NVRAM  up                    up      \r\nEthernet0/3                192.168.230.1   YES NVRAM  up                    up      \r\nEthernet0/3.100            10.100.0.1      YES NVRAM  up                    up      \r\nEthernet0/3.200            10.200.0.1      YES NVRAM  up                    up      \r\nEthernet0/3.300            10.30.0.1       YES NVRAM  up                    up      \r\nR1>'

read_until vs read_very_eager

An important difference between read_until and read_very_eager is how they react to the lack of output.

Method read_until waits for a certain string. By default, if it does not exist, method will “freeze”. Timeout option allows you to specify how long to wait for the desired string:

In [20]: telnet.read_until(b'>', timeout=5)
Out[20]: b''

If no string appears during the specified time, an empty string is returned.

Method read_very_eager simply returns an empty string if there is no output:

In [21]: telnet.read_very_eager()
Out[21]: b''

Method expect

Method expect allows you to specify a list with regular expressions. It works like pexpect but telnetlib always has to pass a list of regular expressions.

You can then pass byte strings or compiled regular expressions:

In [22]: telnet.write(b'sh clock\n')

In [23]: telnet.expect([b'[>#]'])
Out[23]:
(0,
 <_sre.SRE_Match object; span=(46, 47), match=b'>'>,
 b'sh clock\r\n*19:35:10.984 UTC Fri Nov 3 2017\r\nR1>')

Method expect returns tuple of their three elements:

  • index of matched expression
  • object Match
  • byte string that contains everything read till regular expression including regular expression

Accordingly, if necessary you can continue working with these elements:

In [24]: telnet.write(b'sh clock\n')

In [25]: regex_idx, match, output = telnet.expect([b'[>#]'])

In [26]: regex_idx
Out[26]: 0

In [27]: match.group()
Out[27]: b'>'

In [28]: match
Out[28]: <_sre.SRE_Match object; span=(46, 47), match=b'>'>

In [29]: match.group()
Out[29]: b'>'

In [30]: output
Out[30]: b'sh clock\r\n*19:37:21.577 UTC Fri Nov 3 2017\r\nR1>'

In [31]: output.decode('utf-8')
Out[31]: 'sh clock\r\n*19:37:21.577 UTC Fri Nov 3 2017\r\nR1>'

Method close

Method close closes connection but it’s better to open and close connection using context manager:

In [32]: telnet.close()

Note

Using Telnet object as context manager added in version 3.6

Telnetlib usage example

Working principle of telnetlib resembles pexpect, so the example below should be clear (2_telnetlib.py):

import telnetlib
import time
from pprint import pprint


def to_bytes(line):
    return f"{line}\n".encode("utf-8")


def send_show_command(ip, username, password, enable, commands):
    with telnetlib.Telnet(ip) as telnet:
        telnet.read_until(b"Username")
        telnet.write(to_bytes(username))
        telnet.read_until(b"Password")
        telnet.write(to_bytes(password))
        index, m, output = telnet.expect([b">", b"#"])
        if index == 0:
            telnet.write(b"enable\n")
            telnet.read_until(b"Password")
            telnet.write(to_bytes(enable))
            telnet.read_until(b"#", timeout=5)
        telnet.write(b"terminal length 0\n")
        telnet.read_until(b"#", timeout=5)
        time.sleep(3)
        telnet.read_very_eager()

        result = {}
        for command in commands:
            telnet.write(to_bytes(command))
            output = telnet.read_until(b"#", timeout=5).decode("utf-8")
            result[command] = output.replace("\r\n", "\n")
        return result


if __name__ == "__main__":
    devices = ["192.168.100.1", "192.168.100.2", "192.168.100.3"]
    commands = ["sh ip int br", "sh arp"]
    for ip in devices:
        result = send_show_command(ip, "cisco", "cisco", "cisco", commands)
        pprint(result, width=120)

Since bytes need to be passed to write method and new line character should be added each time, a small function to_bytes is created that does the conversion to bytes and adds a new line.

Script execution:

{'sh int desc': 'sh int desc\n'
                'Interface             Status         Protocol Description\n'
                'Et0/0                 up             up       \n'
                'Et0/1                 up             up       \n'
                'Et0/2                 up             up       \n'
                'Et0/3                 up             up       \n'
                'R1#',
 'sh ip int br': 'sh ip int br\n'
                 'Interface         IP-Address      OK? Method Status                Protocol\n'
                 'Ethernet0/0       192.168.100.1   YES NVRAM  up                    up      \n'
                 'Ethernet0/1       192.168.200.1   YES NVRAM  up                    up      \n'
                 'Ethernet0/2       unassigned      YES NVRAM  up                    up      \n'
                 'Ethernet0/3       192.168.130.1   YES NVRAM  up                    up      \n'
                 'R1#'}
{'sh int desc': 'sh int desc\n'
                'Interface             Status         Protocol Description\n'
                'Et0/0                 up             up       \n'
                'Et0/1                 up             up       \n'
                'Et0/2                 admin down     down     \n'
                'Et0/3                 admin down     down     \n'
                'R2#',
 'sh ip int br': 'sh ip int br\n'
                 'Interface         IP-Address      OK? Method Status                Protocol\n'
                 'Ethernet0/0       192.168.100.2   YES NVRAM  up                    up      \n'
                 'Ethernet0/1       unassigned      YES NVRAM  up                    up      \n'
                 'Ethernet0/2       unassigned      YES NVRAM  administratively down down    \n'
                 'Ethernet0/3       unassigned      YES NVRAM  administratively down down    \n'
                 'R2#'}
{'sh int desc': 'sh int desc\n'
                'Interface             Status         Protocol Description\n'
                'Et0/0                 up             up       \n'
                'Et0/1                 up             up       \n'
                'Et0/2                 admin down     down     \n'
                'Et0/3                 admin down     down     \n'
                'R3#',
 'sh ip int br': 'sh ip int br\n'
                 'Interface         IP-Address      OK? Method Status                Protocol\n'
                 'Ethernet0/0       192.168.100.3   YES NVRAM  up                    up      \n'
                 'Ethernet0/1       unassigned      YES NVRAM  up                    up      \n'
                 'Ethernet0/2       unassigned      YES NVRAM  administratively down down    \n'
                 'Ethernet0/3       unassigned      YES NVRAM  administratively down down    \n'

Paginated command output

Example of using telnetlib to work with paginated output of show commands (2_telnetlib_more.py file):

import telnetlib
import time
from pprint import pprint
import re


def to_bytes(line):
    return f"{line}\n".encode("utf-8")


def send_show_command(ip, username, password, enable, command):
    with telnetlib.Telnet(ip) as telnet:
        telnet.read_until(b"Username")
        telnet.write(to_bytes(username))
        telnet.read_until(b"Password")
        telnet.write(to_bytes(password))
        index, m, output = telnet.expect([b">", b"#"])
        if index == 0:
            telnet.write(b"enable\n")
            telnet.read_until(b"Password")
            telnet.write(to_bytes(enable))
            telnet.read_until(b"#", timeout=5)
        time.sleep(3)
        telnet.read_very_eager()

        telnet.write(to_bytes(command))
        result = ""

        while True:
            index, match, output = telnet.expect([b"--More--", b"#"], timeout=5)
            output = output.decode("utf-8")
            output = re.sub(" +--More--| +\x08+ +\x08+", "\n", output)
            result += output
            if index in (1, -1):
                break
            telnet.write(b" ")
            time.sleep(1)
            result.replace("\r\n", "\n")

        return result


if __name__ == "__main__":
    devices = ["192.168.100.1", "192.168.100.2", "192.168.100.3"]
    for ip in devices:
        result = send_show_command(ip, "cisco", "cisco", "cisco", "sh run")
        pprint(result, width=120)