| r"""TELNET client class. | |
| Based on RFC 854: TELNET Protocol Specification, by J. Postel and | |
| J. Reynolds | |
| Example: | |
| >>> from telnetlib import Telnet | |
| >>> tn = Telnet('www.python.org', 79) # connect to finger port | |
| >>> tn.write('guido\r\n') | |
| >>> print tn.read_all() | |
| Login Name TTY Idle When Where | |
| guido Guido van Rossum pts/2 <Dec 2 11:10> snag.cnri.reston.. | |
| >>> | |
| Note that read_all() won't read until eof -- it just reads some data | |
| -- but it guarantees to read at least one byte unless EOF is hit. | |
| It is possible to pass a Telnet object to select.select() in order to | |
| wait until more data is available. Note that in this case, | |
| read_eager() may return '' even if there was data on the socket, | |
| because the protocol negotiation may have eaten the data. This is why | |
| EOFError is needed in some cases to distinguish between "no data" and | |
| "connection closed" (since the socket also appears ready for reading | |
| when it is closed). | |
| To do: | |
| - option negotiation | |
| - timeout should be intrinsic to the connection object instead of an | |
| option on one of the read calls only | |
| """ | |
| # Imported modules | |
| import sys | |
| import socket | |
| import select | |
| __all__ = ["Telnet"] | |
| # Tunable parameters | |
| DEBUGLEVEL = 0 | |
| # Telnet protocol defaults | |
| TELNET_PORT = 23 | |
| # Telnet protocol characters (don't change) | |
| IAC = chr(255) # "Interpret As Command" | |
| DONT = chr(254) | |
| DO = chr(253) | |
| WONT = chr(252) | |
| WILL = chr(251) | |
| theNULL = chr(0) | |
| SE = chr(240) # Subnegotiation End | |
| NOP = chr(241) # No Operation | |
| DM = chr(242) # Data Mark | |
| BRK = chr(243) # Break | |
| IP = chr(244) # Interrupt process | |
| AO = chr(245) # Abort output | |
| AYT = chr(246) # Are You There | |
| EC = chr(247) # Erase Character | |
| EL = chr(248) # Erase Line | |
| GA = chr(249) # Go Ahead | |
| SB = chr(250) # Subnegotiation Begin | |
| # Telnet protocol options code (don't change) | |
| # These ones all come from arpa/telnet.h | |
| BINARY = chr(0) # 8-bit data path | |
| ECHO = chr(1) # echo | |
| RCP = chr(2) # prepare to reconnect | |
| SGA = chr(3) # suppress go ahead | |
| NAMS = chr(4) # approximate message size | |
| STATUS = chr(5) # give status | |
| TM = chr(6) # timing mark | |
| RCTE = chr(7) # remote controlled transmission and echo | |
| NAOL = chr(8) # negotiate about output line width | |
| NAOP = chr(9) # negotiate about output page size | |
| NAOCRD = chr(10) # negotiate about CR disposition | |
| NAOHTS = chr(11) # negotiate about horizontal tabstops | |
| NAOHTD = chr(12) # negotiate about horizontal tab disposition | |
| NAOFFD = chr(13) # negotiate about formfeed disposition | |
| NAOVTS = chr(14) # negotiate about vertical tab stops | |
| NAOVTD = chr(15) # negotiate about vertical tab disposition | |
| NAOLFD = chr(16) # negotiate about output LF disposition | |
| XASCII = chr(17) # extended ascii character set | |
| LOGOUT = chr(18) # force logout | |
| BM = chr(19) # byte macro | |
| DET = chr(20) # data entry terminal | |
| SUPDUP = chr(21) # supdup protocol | |
| SUPDUPOUTPUT = chr(22) # supdup output | |
| SNDLOC = chr(23) # send location | |
| TTYPE = chr(24) # terminal type | |
| EOR = chr(25) # end or record | |
| TUID = chr(26) # TACACS user identification | |
| OUTMRK = chr(27) # output marking | |
| TTYLOC = chr(28) # terminal location number | |
| VT3270REGIME = chr(29) # 3270 regime | |
| X3PAD = chr(30) # X.3 PAD | |
| NAWS = chr(31) # window size | |
| TSPEED = chr(32) # terminal speed | |
| LFLOW = chr(33) # remote flow control | |
| LINEMODE = chr(34) # Linemode option | |
| XDISPLOC = chr(35) # X Display Location | |
| OLD_ENVIRON = chr(36) # Old - Environment variables | |
| AUTHENTICATION = chr(37) # Authenticate | |
| ENCRYPT = chr(38) # Encryption option | |
| NEW_ENVIRON = chr(39) # New - Environment variables | |
| # the following ones come from | |
| # http://www.iana.org/assignments/telnet-options | |
| # Unfortunately, that document does not assign identifiers | |
| # to all of them, so we are making them up | |
| TN3270E = chr(40) # TN3270E | |
| XAUTH = chr(41) # XAUTH | |
| CHARSET = chr(42) # CHARSET | |
| RSP = chr(43) # Telnet Remote Serial Port | |
| COM_PORT_OPTION = chr(44) # Com Port Control Option | |
| SUPPRESS_LOCAL_ECHO = chr(45) # Telnet Suppress Local Echo | |
| TLS = chr(46) # Telnet Start TLS | |
| KERMIT = chr(47) # KERMIT | |
| SEND_URL = chr(48) # SEND-URL | |
| FORWARD_X = chr(49) # FORWARD_X | |
| PRAGMA_LOGON = chr(138) # TELOPT PRAGMA LOGON | |
| SSPI_LOGON = chr(139) # TELOPT SSPI LOGON | |
| PRAGMA_HEARTBEAT = chr(140) # TELOPT PRAGMA HEARTBEAT | |
| EXOPL = chr(255) # Extended-Options-List | |
| NOOPT = chr(0) | |
| class Telnet: | |
| """Telnet interface class. | |
| An instance of this class represents a connection to a telnet | |
| server. The instance is initially not connected; the open() | |
| method must be used to establish a connection. Alternatively, the | |
| host name and optional port number can be passed to the | |
| constructor, too. | |
| Don't try to reopen an already connected instance. | |
| This class has many read_*() methods. Note that some of them | |
| raise EOFError when the end of the connection is read, because | |
| they can return an empty string for other reasons. See the | |
| individual doc strings. | |
| read_until(expected, [timeout]) | |
| Read until the expected string has been seen, or a timeout is | |
| hit (default is no timeout); may block. | |
| read_all() | |
| Read all data until EOF; may block. | |
| read_some() | |
| Read at least one byte or EOF; may block. | |
| read_very_eager() | |
| Read all data available already queued or on the socket, | |
| without blocking. | |
| read_eager() | |
| Read either data already queued or some data available on the | |
| socket, without blocking. | |
| read_lazy() | |
| Read all data in the raw queue (processing it first), without | |
| doing any socket I/O. | |
| read_very_lazy() | |
| Reads all data in the cooked queue, without doing any socket | |
| I/O. | |
| read_sb_data() | |
| Reads available data between SB ... SE sequence. Don't block. | |
| set_option_negotiation_callback(callback) | |
| Each time a telnet option is read on the input flow, this callback | |
| (if set) is called with the following parameters : | |
| callback(telnet socket, command, option) | |
| option will be chr(0) when there is no option. | |
| No other action is done afterwards by telnetlib. | |
| """ | |
| def __init__(self, host=None, port=0, | |
| timeout=socket._GLOBAL_DEFAULT_TIMEOUT): | |
| """Constructor. | |
| When called without arguments, create an unconnected instance. | |
| With a hostname argument, it connects the instance; port number | |
| and timeout are optional. | |
| """ | |
| self.debuglevel = DEBUGLEVEL | |
| self.host = host | |
| self.port = port | |
| self.timeout = timeout | |
| self.sock = None | |
| self.rawq = '' | |
| self.irawq = 0 | |
| self.cookedq = '' | |
| self.eof = 0 | |
| self.iacseq = '' # Buffer for IAC sequence. | |
| self.sb = 0 # flag for SB and SE sequence. | |
| self.sbdataq = '' | |
| self.option_callback = None | |
| if host is not None: | |
| self.open(host, port, timeout) | |
| def open(self, host, port=0, timeout=socket._GLOBAL_DEFAULT_TIMEOUT): | |
| """Connect to a host. | |
| The optional second argument is the port number, which | |
| defaults to the standard telnet port (23). | |
| Don't try to reopen an already connected instance. | |
| """ | |
| self.eof = 0 | |
| if not port: | |
| port = TELNET_PORT | |
| self.host = host | |
| self.port = port | |
| self.timeout = timeout | |
| self.sock = socket.create_connection((host, port), timeout) | |
| def __del__(self): | |
| """Destructor -- close the connection.""" | |
| self.close() | |
| def msg(self, msg, *args): | |
| """Print a debug message, when the debug level is > 0. | |
| If extra arguments are present, they are substituted in the | |
| message using the standard string formatting operator. | |
| """ | |
| if self.debuglevel > 0: | |
| print 'Telnet(%s,%s):' % (self.host, self.port), | |
| if args: | |
| print msg % args | |
| else: | |
| print msg | |
| def set_debuglevel(self, debuglevel): | |
| """Set the debug level. | |
| The higher it is, the more debug output you get (on sys.stdout). | |
| """ | |
| self.debuglevel = debuglevel | |
| def close(self): | |
| """Close the connection.""" | |
| if self.sock: | |
| self.sock.close() | |
| self.sock = 0 | |
| self.eof = 1 | |
| self.iacseq = '' | |
| self.sb = 0 | |
| def get_socket(self): | |
| """Return the socket object used internally.""" | |
| return self.sock | |
| def fileno(self): | |
| """Return the fileno() of the socket object used internally.""" | |
| return self.sock.fileno() | |
| def write(self, buffer): | |
| """Write a string to the socket, doubling any IAC characters. | |
| Can block if the connection is blocked. May raise | |
| socket.error if the connection is closed. | |
| """ | |
| if IAC in buffer: | |
| buffer = buffer.replace(IAC, IAC+IAC) | |
| self.msg("send %r", buffer) | |
| self.sock.sendall(buffer) | |
| def read_until(self, match, timeout=None): | |
| """Read until a given string is encountered or until timeout. | |
| When no match is found, return whatever is available instead, | |
| possibly the empty string. Raise EOFError if the connection | |
| is closed and no cooked data is available. | |
| """ | |
| n = len(match) | |
| self.process_rawq() | |
| i = self.cookedq.find(match) | |
| if i >= 0: | |
| i = i+n | |
| buf = self.cookedq[:i] | |
| self.cookedq = self.cookedq[i:] | |
| return buf | |
| s_reply = ([self], [], []) | |
| s_args = s_reply | |
| if timeout is not None: | |
| s_args = s_args + (timeout,) | |
| from time import time | |
| time_start = time() | |
| while not self.eof and select.select(*s_args) == s_reply: | |
| i = max(0, len(self.cookedq)-n) | |
| self.fill_rawq() | |
| self.process_rawq() | |
| i = self.cookedq.find(match, i) | |
| if i >= 0: | |
| i = i+n | |
| buf = self.cookedq[:i] | |
| self.cookedq = self.cookedq[i:] | |
| return buf | |
| if timeout is not None: | |
| elapsed = time() - time_start | |
| if elapsed >= timeout: | |
| break | |
| s_args = s_reply + (timeout-elapsed,) | |
| return self.read_very_lazy() | |
| def read_all(self): | |
| """Read all data until EOF; block until connection closed.""" | |
| self.process_rawq() | |
| while not self.eof: | |
| self.fill_rawq() | |
| self.process_rawq() | |
| buf = self.cookedq | |
| self.cookedq = '' | |
| return buf | |
| def read_some(self): | |
| """Read at least one byte of cooked data unless EOF is hit. | |
| Return '' if EOF is hit. Block if no data is immediately | |
| available. | |
| """ | |
| self.process_rawq() | |
| while not self.cookedq and not self.eof: | |
| self.fill_rawq() | |
| self.process_rawq() | |
| buf = self.cookedq | |
| self.cookedq = '' | |
| return buf | |
| def read_very_eager(self): | |
| """Read everything that's possible without blocking in I/O (eager). | |
| Raise EOFError if connection closed and no cooked data | |
| available. Return '' if no cooked data available otherwise. | |
| Don't block unless in the midst of an IAC sequence. | |
| """ | |
| self.process_rawq() | |
| while not self.eof and self.sock_avail(): | |
| self.fill_rawq() | |
| self.process_rawq() | |
| return self.read_very_lazy() | |
| def read_eager(self): | |
| """Read readily available data. | |
| Raise EOFError if connection closed and no cooked data | |
| available. Return '' if no cooked data available otherwise. | |
| Don't block unless in the midst of an IAC sequence. | |
| """ | |
| self.process_rawq() | |
| while not self.cookedq and not self.eof and self.sock_avail(): | |
| self.fill_rawq() | |
| self.process_rawq() | |
| return self.read_very_lazy() | |
| def read_lazy(self): | |
| """Process and return data that's already in the queues (lazy). | |
| Raise EOFError if connection closed and no data available. | |
| Return '' if no cooked data available otherwise. Don't block | |
| unless in the midst of an IAC sequence. | |
| """ | |
| self.process_rawq() | |
| return self.read_very_lazy() | |
| def read_very_lazy(self): | |
| """Return any data available in the cooked queue (very lazy). | |
| Raise EOFError if connection closed and no data available. | |
| Return '' if no cooked data available otherwise. Don't block. | |
| """ | |
| buf = self.cookedq | |
| self.cookedq = '' | |
| if not buf and self.eof and not self.rawq: | |
| raise EOFError, 'telnet connection closed' | |
| return buf | |
| def read_sb_data(self): | |
| """Return any data available in the SB ... SE queue. | |
| Return '' if no SB ... SE available. Should only be called | |
| after seeing a SB or SE command. When a new SB command is | |
| found, old unread SB data will be discarded. Don't block. | |
| """ | |
| buf = self.sbdataq | |
| self.sbdataq = '' | |
| return buf | |
| def set_option_negotiation_callback(self, callback): | |
| """Provide a callback function called after each receipt of a telnet option.""" | |
| self.option_callback = callback | |
| def process_rawq(self): | |
| """Transfer from raw queue to cooked queue. | |
| Set self.eof when connection is closed. Don't block unless in | |
| the midst of an IAC sequence. | |
| """ | |
| buf = ['', ''] | |
| try: | |
| while self.rawq: | |
| c = self.rawq_getchar() | |
| if not self.iacseq: | |
| if c == theNULL: | |
| continue | |
| if c == "\021": | |
| continue | |
| if c != IAC: | |
| buf[self.sb] = buf[self.sb] + c | |
| continue | |
| else: | |
| self.iacseq += c | |
| elif len(self.iacseq) == 1: | |
| # 'IAC: IAC CMD [OPTION only for WILL/WONT/DO/DONT]' | |
| if c in (DO, DONT, WILL, WONT): | |
| self.iacseq += c | |
| continue | |
| self.iacseq = '' | |
| if c == IAC: | |
| buf[self.sb] = buf[self.sb] + c | |
| else: | |
| if c == SB: # SB ... SE start. | |
| self.sb = 1 | |
| self.sbdataq = '' | |
| elif c == SE: | |
| self.sb = 0 | |
| self.sbdataq = self.sbdataq + buf[1] | |
| buf[1] = '' | |
| if self.option_callback: | |
| # Callback is supposed to look into | |
| # the sbdataq | |
| self.option_callback(self.sock, c, NOOPT) | |
| else: | |
| # We can't offer automatic processing of | |
| # suboptions. Alas, we should not get any | |
| # unless we did a WILL/DO before. | |
| self.msg('IAC %d not recognized' % ord(c)) | |
| elif len(self.iacseq) == 2: | |
| cmd = self.iacseq[1] | |
| self.iacseq = '' | |
| opt = c | |
| if cmd in (DO, DONT): | |
| self.msg('IAC %s %d', | |
| cmd == DO and 'DO' or 'DONT', ord(opt)) | |
| if self.option_callback: | |
| self.option_callback(self.sock, cmd, opt) | |
| else: | |
| self.sock.sendall(IAC + WONT + opt) | |
| elif cmd in (WILL, WONT): | |
| self.msg('IAC %s %d', | |
| cmd == WILL and 'WILL' or 'WONT', ord(opt)) | |
| if self.option_callback: | |
| self.option_callback(self.sock, cmd, opt) | |
| else: | |
| self.sock.sendall(IAC + DONT + opt) | |
| except EOFError: # raised by self.rawq_getchar() | |
| self.iacseq = '' # Reset on EOF | |
| self.sb = 0 | |
| pass | |
| self.cookedq = self.cookedq + buf[0] | |
| self.sbdataq = self.sbdataq + buf[1] | |
| def rawq_getchar(self): | |
| """Get next char from raw queue. | |
| Block if no data is immediately available. Raise EOFError | |
| when connection is closed. | |
| """ | |
| if not self.rawq: | |
| self.fill_rawq() | |
| if self.eof: | |
| raise EOFError | |
| c = self.rawq[self.irawq] | |
| self.irawq = self.irawq + 1 | |
| if self.irawq >= len(self.rawq): | |
| self.rawq = '' | |
| self.irawq = 0 | |
| return c | |
| def fill_rawq(self): | |
| """Fill raw queue from exactly one recv() system call. | |
| Block if no data is immediately available. Set self.eof when | |
| connection is closed. | |
| """ | |
| if self.irawq >= len(self.rawq): | |
| self.rawq = '' | |
| self.irawq = 0 | |
| # The buffer size should be fairly small so as to avoid quadratic | |
| # behavior in process_rawq() above | |
| buf = self.sock.recv(50) | |
| self.msg("recv %r", buf) | |
| self.eof = (not buf) | |
| self.rawq = self.rawq + buf | |
| def sock_avail(self): | |
| """Test whether data is available on the socket.""" | |
| return select.select([self], [], [], 0) == ([self], [], []) | |
| def interact(self): | |
| """Interaction function, emulates a very dumb telnet client.""" | |
| if sys.platform == "win32": | |
| self.mt_interact() | |
| return | |
| while 1: | |
| rfd, wfd, xfd = select.select([self, sys.stdin], [], []) | |
| if self in rfd: | |
| try: | |
| text = self.read_eager() | |
| except EOFError: | |
| print '*** Connection closed by remote host ***' | |
| break | |
| if text: | |
| sys.stdout.write(text) | |
| sys.stdout.flush() | |
| if sys.stdin in rfd: | |
| line = sys.stdin.readline() | |
| if not line: | |
| break | |
| self.write(line) | |
| def mt_interact(self): | |
| """Multithreaded version of interact().""" | |
| import thread | |
| thread.start_new_thread(self.listener, ()) | |
| while 1: | |
| line = sys.stdin.readline() | |
| if not line: | |
| break | |
| self.write(line) | |
| def listener(self): | |
| """Helper for mt_interact() -- this executes in the other thread.""" | |
| while 1: | |
| try: | |
| data = self.read_eager() | |
| except EOFError: | |
| print '*** Connection closed by remote host ***' | |
| return | |
| if data: | |
| sys.stdout.write(data) | |
| else: | |
| sys.stdout.flush() | |
| def expect(self, list, timeout=None): | |
| """Read until one from a list of a regular expressions matches. | |
| The first argument is a list of regular expressions, either | |
| compiled (re.RegexObject instances) or uncompiled (strings). | |
| The optional second argument is a timeout, in seconds; default | |
| is no timeout. | |
| Return a tuple of three items: the index in the list of the | |
| first regular expression that matches; the match object | |
| returned; and the text read up till and including the match. | |
| If EOF is read and no text was read, raise EOFError. | |
| Otherwise, when nothing matches, return (-1, None, text) where | |
| text is the text received so far (may be the empty string if a | |
| timeout happened). | |
| If a regular expression ends with a greedy match (e.g. '.*') | |
| or if more than one expression can match the same input, the | |
| results are undeterministic, and may depend on the I/O timing. | |
| """ | |
| re = None | |
| list = list[:] | |
| indices = range(len(list)) | |
| for i in indices: | |
| if not hasattr(list[i], "search"): | |
| if not re: import re | |
| list[i] = re.compile(list[i]) | |
| if timeout is not None: | |
| from time import time | |
| time_start = time() | |
| while 1: | |
| self.process_rawq() | |
| for i in indices: | |
| m = list[i].search(self.cookedq) | |
| if m: | |
| e = m.end() | |
| text = self.cookedq[:e] | |
| self.cookedq = self.cookedq[e:] | |
| return (i, m, text) | |
| if self.eof: | |
| break | |
| if timeout is not None: | |
| elapsed = time() - time_start | |
| if elapsed >= timeout: | |
| break | |
| s_args = ([self.fileno()], [], [], timeout-elapsed) | |
| r, w, x = select.select(*s_args) | |
| if not r: | |
| break | |
| self.fill_rawq() | |
| text = self.read_very_lazy() | |
| if not text and self.eof: | |
| raise EOFError | |
| return (-1, None, text) | |
| def test(): | |
| """Test program for telnetlib. | |
| Usage: python telnetlib.py [-d] ... [host [port]] | |
| Default host is localhost; default port is 23. | |
| """ | |
| debuglevel = 0 | |
| while sys.argv[1:] and sys.argv[1] == '-d': | |
| debuglevel = debuglevel+1 | |
| del sys.argv[1] | |
| host = 'localhost' | |
| if sys.argv[1:]: | |
| host = sys.argv[1] | |
| port = 0 | |
| if sys.argv[2:]: | |
| portstr = sys.argv[2] | |
| try: | |
| port = int(portstr) | |
| except ValueError: | |
| port = socket.getservbyname(portstr, 'tcp') | |
| tn = Telnet() | |
| tn.set_debuglevel(debuglevel) | |
| tn.open(host, port, timeout=0.5) | |
| tn.interact() | |
| tn.close() | |
| if __name__ == '__main__': | |
| test() |