Hye-Shik Chang | e029da0 | 2005-09-07 07:40:05 +0000 | [diff] [blame] | 1 | r"""TELNET client class. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 2 | |
| 3 | Based on RFC 854: TELNET Protocol Specification, by J. Postel and |
| 4 | J. Reynolds |
| 5 | |
| 6 | Example: |
| 7 | |
| 8 | >>> from telnetlib import Telnet |
| 9 | >>> tn = Telnet('www.python.org', 79) # connect to finger port |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 10 | >>> tn.write(b'guido\r\n') |
Guido van Rossum | 7131f84 | 2007-02-09 20:13:25 +0000 | [diff] [blame] | 11 | >>> print(tn.read_all()) |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 12 | Login Name TTY Idle When Where |
| 13 | guido Guido van Rossum pts/2 <Dec 2 11:10> snag.cnri.reston.. |
Tim Peters | b90f89a | 2001-01-15 03:26:36 +0000 | [diff] [blame] | 14 | |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 15 | >>> |
| 16 | |
| 17 | Note that read_all() won't read until eof -- it just reads some data |
| 18 | -- but it guarantees to read at least one byte unless EOF is hit. |
| 19 | |
Charles-François Natali | 6459025 | 2013-10-21 14:02:12 +0200 | [diff] [blame^] | 20 | It is possible to pass a Telnet object to a selector in order to wait until |
| 21 | more data is available. Note that in this case, read_eager() may return b'' |
| 22 | even if there was data on the socket, because the protocol negotiation may have |
| 23 | eaten the data. This is why EOFError is needed in some cases to distinguish |
| 24 | between "no data" and "connection closed" (since the socket also appears ready |
| 25 | for reading when it is closed). |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 26 | |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 27 | To do: |
| 28 | - option negotiation |
Guido van Rossum | ccb5ec6 | 1997-12-24 22:24:19 +0000 | [diff] [blame] | 29 | - timeout should be intrinsic to the connection object instead of an |
| 30 | option on one of the read calls only |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 31 | |
| 32 | """ |
| 33 | |
| 34 | |
| 35 | # Imported modules |
Guido van Rossum | ccb5ec6 | 1997-12-24 22:24:19 +0000 | [diff] [blame] | 36 | import sys |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 37 | import socket |
Charles-François Natali | 6459025 | 2013-10-21 14:02:12 +0200 | [diff] [blame^] | 38 | import selectors |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 39 | |
Skip Montanaro | 40fc160 | 2001-03-01 04:27:19 +0000 | [diff] [blame] | 40 | __all__ = ["Telnet"] |
| 41 | |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 42 | # Tunable parameters |
| 43 | DEBUGLEVEL = 0 |
| 44 | |
| 45 | # Telnet protocol defaults |
| 46 | TELNET_PORT = 23 |
| 47 | |
| 48 | # Telnet protocol characters (don't change) |
Jack Diederich | 1c8f38c | 2009-04-10 05:33:26 +0000 | [diff] [blame] | 49 | IAC = bytes([255]) # "Interpret As Command" |
| 50 | DONT = bytes([254]) |
| 51 | DO = bytes([253]) |
| 52 | WONT = bytes([252]) |
| 53 | WILL = bytes([251]) |
| 54 | theNULL = bytes([0]) |
Martin v. Löwis | 574deae | 2002-11-04 17:34:07 +0000 | [diff] [blame] | 55 | |
Jack Diederich | 1c8f38c | 2009-04-10 05:33:26 +0000 | [diff] [blame] | 56 | SE = bytes([240]) # Subnegotiation End |
| 57 | NOP = bytes([241]) # No Operation |
| 58 | DM = bytes([242]) # Data Mark |
| 59 | BRK = bytes([243]) # Break |
| 60 | IP = bytes([244]) # Interrupt process |
| 61 | AO = bytes([245]) # Abort output |
| 62 | AYT = bytes([246]) # Are You There |
| 63 | EC = bytes([247]) # Erase Character |
| 64 | EL = bytes([248]) # Erase Line |
| 65 | GA = bytes([249]) # Go Ahead |
| 66 | SB = bytes([250]) # Subnegotiation Begin |
Martin v. Löwis | 574deae | 2002-11-04 17:34:07 +0000 | [diff] [blame] | 67 | |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 68 | |
Martin v. Löwis | b0162f9 | 2001-09-06 08:51:38 +0000 | [diff] [blame] | 69 | # Telnet protocol options code (don't change) |
| 70 | # These ones all come from arpa/telnet.h |
Jack Diederich | 1c8f38c | 2009-04-10 05:33:26 +0000 | [diff] [blame] | 71 | BINARY = bytes([0]) # 8-bit data path |
| 72 | ECHO = bytes([1]) # echo |
| 73 | RCP = bytes([2]) # prepare to reconnect |
| 74 | SGA = bytes([3]) # suppress go ahead |
| 75 | NAMS = bytes([4]) # approximate message size |
| 76 | STATUS = bytes([5]) # give status |
| 77 | TM = bytes([6]) # timing mark |
| 78 | RCTE = bytes([7]) # remote controlled transmission and echo |
| 79 | NAOL = bytes([8]) # negotiate about output line width |
| 80 | NAOP = bytes([9]) # negotiate about output page size |
| 81 | NAOCRD = bytes([10]) # negotiate about CR disposition |
| 82 | NAOHTS = bytes([11]) # negotiate about horizontal tabstops |
| 83 | NAOHTD = bytes([12]) # negotiate about horizontal tab disposition |
| 84 | NAOFFD = bytes([13]) # negotiate about formfeed disposition |
| 85 | NAOVTS = bytes([14]) # negotiate about vertical tab stops |
| 86 | NAOVTD = bytes([15]) # negotiate about vertical tab disposition |
| 87 | NAOLFD = bytes([16]) # negotiate about output LF disposition |
| 88 | XASCII = bytes([17]) # extended ascii character set |
| 89 | LOGOUT = bytes([18]) # force logout |
| 90 | BM = bytes([19]) # byte macro |
| 91 | DET = bytes([20]) # data entry terminal |
| 92 | SUPDUP = bytes([21]) # supdup protocol |
| 93 | SUPDUPOUTPUT = bytes([22]) # supdup output |
| 94 | SNDLOC = bytes([23]) # send location |
| 95 | TTYPE = bytes([24]) # terminal type |
| 96 | EOR = bytes([25]) # end or record |
| 97 | TUID = bytes([26]) # TACACS user identification |
| 98 | OUTMRK = bytes([27]) # output marking |
| 99 | TTYLOC = bytes([28]) # terminal location number |
| 100 | VT3270REGIME = bytes([29]) # 3270 regime |
| 101 | X3PAD = bytes([30]) # X.3 PAD |
| 102 | NAWS = bytes([31]) # window size |
| 103 | TSPEED = bytes([32]) # terminal speed |
| 104 | LFLOW = bytes([33]) # remote flow control |
| 105 | LINEMODE = bytes([34]) # Linemode option |
| 106 | XDISPLOC = bytes([35]) # X Display Location |
| 107 | OLD_ENVIRON = bytes([36]) # Old - Environment variables |
| 108 | AUTHENTICATION = bytes([37]) # Authenticate |
| 109 | ENCRYPT = bytes([38]) # Encryption option |
| 110 | NEW_ENVIRON = bytes([39]) # New - Environment variables |
Martin v. Löwis | b0162f9 | 2001-09-06 08:51:38 +0000 | [diff] [blame] | 111 | # the following ones come from |
| 112 | # http://www.iana.org/assignments/telnet-options |
| 113 | # Unfortunately, that document does not assign identifiers |
| 114 | # to all of them, so we are making them up |
Jack Diederich | 1c8f38c | 2009-04-10 05:33:26 +0000 | [diff] [blame] | 115 | TN3270E = bytes([40]) # TN3270E |
| 116 | XAUTH = bytes([41]) # XAUTH |
| 117 | CHARSET = bytes([42]) # CHARSET |
| 118 | RSP = bytes([43]) # Telnet Remote Serial Port |
| 119 | COM_PORT_OPTION = bytes([44]) # Com Port Control Option |
| 120 | SUPPRESS_LOCAL_ECHO = bytes([45]) # Telnet Suppress Local Echo |
| 121 | TLS = bytes([46]) # Telnet Start TLS |
| 122 | KERMIT = bytes([47]) # KERMIT |
| 123 | SEND_URL = bytes([48]) # SEND-URL |
| 124 | FORWARD_X = bytes([49]) # FORWARD_X |
| 125 | PRAGMA_LOGON = bytes([138]) # TELOPT PRAGMA LOGON |
| 126 | SSPI_LOGON = bytes([139]) # TELOPT SSPI LOGON |
| 127 | PRAGMA_HEARTBEAT = bytes([140]) # TELOPT PRAGMA HEARTBEAT |
| 128 | EXOPL = bytes([255]) # Extended-Options-List |
| 129 | NOOPT = bytes([0]) |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 130 | |
Charles-François Natali | 6459025 | 2013-10-21 14:02:12 +0200 | [diff] [blame^] | 131 | |
| 132 | # poll/select have the advantage of not requiring any extra file descriptor, |
| 133 | # contrarily to epoll/kqueue (also, they require a single syscall). |
| 134 | if hasattr(selectors, 'PollSelector'): |
| 135 | _TelnetSelector = selectors.PollSelector |
| 136 | else: |
| 137 | _TelnetSelector = selectors.SelectSelector |
| 138 | |
| 139 | |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 140 | class Telnet: |
| 141 | |
| 142 | """Telnet interface class. |
| 143 | |
| 144 | An instance of this class represents a connection to a telnet |
| 145 | server. The instance is initially not connected; the open() |
| 146 | method must be used to establish a connection. Alternatively, the |
| 147 | host name and optional port number can be passed to the |
| 148 | constructor, too. |
| 149 | |
| 150 | Don't try to reopen an already connected instance. |
| 151 | |
| 152 | This class has many read_*() methods. Note that some of them |
| 153 | raise EOFError when the end of the connection is read, because |
| 154 | they can return an empty string for other reasons. See the |
| 155 | individual doc strings. |
| 156 | |
| 157 | read_until(expected, [timeout]) |
| 158 | Read until the expected string has been seen, or a timeout is |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 159 | hit (default is no timeout); may block. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 160 | |
| 161 | read_all() |
| 162 | Read all data until EOF; may block. |
| 163 | |
| 164 | read_some() |
| 165 | Read at least one byte or EOF; may block. |
| 166 | |
| 167 | read_very_eager() |
| 168 | Read all data available already queued or on the socket, |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 169 | without blocking. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 170 | |
| 171 | read_eager() |
| 172 | Read either data already queued or some data available on the |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 173 | socket, without blocking. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 174 | |
| 175 | read_lazy() |
| 176 | Read all data in the raw queue (processing it first), without |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 177 | doing any socket I/O. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 178 | |
| 179 | read_very_lazy() |
| 180 | Reads all data in the cooked queue, without doing any socket |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 181 | I/O. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 182 | |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 183 | read_sb_data() |
| 184 | Reads available data between SB ... SE sequence. Don't block. |
| 185 | |
Martin v. Löwis | b0162f9 | 2001-09-06 08:51:38 +0000 | [diff] [blame] | 186 | set_option_negotiation_callback(callback) |
| 187 | Each time a telnet option is read on the input flow, this callback |
| 188 | (if set) is called with the following parameters : |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 189 | callback(telnet socket, command, option) |
| 190 | option will be chr(0) when there is no option. |
Martin v. Löwis | b0162f9 | 2001-09-06 08:51:38 +0000 | [diff] [blame] | 191 | No other action is done afterwards by telnetlib. |
| 192 | |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 193 | """ |
| 194 | |
Georg Brandl | f78e02b | 2008-06-10 17:40:04 +0000 | [diff] [blame] | 195 | def __init__(self, host=None, port=0, |
| 196 | timeout=socket._GLOBAL_DEFAULT_TIMEOUT): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 197 | """Constructor. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 198 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 199 | When called without arguments, create an unconnected instance. |
Georg Brandl | f78e02b | 2008-06-10 17:40:04 +0000 | [diff] [blame] | 200 | With a hostname argument, it connects the instance; port number |
| 201 | and timeout are optional. |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 202 | """ |
| 203 | self.debuglevel = DEBUGLEVEL |
| 204 | self.host = host |
| 205 | self.port = port |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 206 | self.timeout = timeout |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 207 | self.sock = None |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 208 | self.rawq = b'' |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 209 | self.irawq = 0 |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 210 | self.cookedq = b'' |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 211 | self.eof = 0 |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 212 | self.iacseq = b'' # Buffer for IAC sequence. |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 213 | self.sb = 0 # flag for SB and SE sequence. |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 214 | self.sbdataq = b'' |
Martin v. Löwis | b0162f9 | 2001-09-06 08:51:38 +0000 | [diff] [blame] | 215 | self.option_callback = None |
Raymond Hettinger | 10ff706 | 2002-06-02 03:04:52 +0000 | [diff] [blame] | 216 | if host is not None: |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 217 | self.open(host, port, timeout) |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 218 | |
Georg Brandl | f78e02b | 2008-06-10 17:40:04 +0000 | [diff] [blame] | 219 | def open(self, host, port=0, timeout=socket._GLOBAL_DEFAULT_TIMEOUT): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 220 | """Connect to a host. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 221 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 222 | The optional second argument is the port number, which |
| 223 | defaults to the standard telnet port (23). |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 224 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 225 | Don't try to reopen an already connected instance. |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 226 | """ |
| 227 | self.eof = 0 |
| 228 | if not port: |
| 229 | port = TELNET_PORT |
| 230 | self.host = host |
| 231 | self.port = port |
Georg Brandl | f78e02b | 2008-06-10 17:40:04 +0000 | [diff] [blame] | 232 | self.timeout = timeout |
| 233 | self.sock = socket.create_connection((host, port), timeout) |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 234 | |
| 235 | def __del__(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 236 | """Destructor -- close the connection.""" |
| 237 | self.close() |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 238 | |
| 239 | def msg(self, msg, *args): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 240 | """Print a debug message, when the debug level is > 0. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 241 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 242 | If extra arguments are present, they are substituted in the |
| 243 | message using the standard string formatting operator. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 244 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 245 | """ |
| 246 | if self.debuglevel > 0: |
R. David Murray | 32ef70c | 2010-12-14 14:16:20 +0000 | [diff] [blame] | 247 | print('Telnet(%s,%s):' % (self.host, self.port), end=' ') |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 248 | if args: |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 249 | print(msg % args) |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 250 | else: |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 251 | print(msg) |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 252 | |
| 253 | def set_debuglevel(self, debuglevel): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 254 | """Set the debug level. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 255 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 256 | The higher it is, the more debug output you get (on sys.stdout). |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 257 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 258 | """ |
| 259 | self.debuglevel = debuglevel |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 260 | |
| 261 | def close(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 262 | """Close the connection.""" |
| 263 | if self.sock: |
| 264 | self.sock.close() |
| 265 | self.sock = 0 |
| 266 | self.eof = 1 |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 267 | self.iacseq = b'' |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 268 | self.sb = 0 |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 269 | |
| 270 | def get_socket(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 271 | """Return the socket object used internally.""" |
| 272 | return self.sock |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 273 | |
| 274 | def fileno(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 275 | """Return the fileno() of the socket object used internally.""" |
| 276 | return self.sock.fileno() |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 277 | |
| 278 | def write(self, buffer): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 279 | """Write a string to the socket, doubling any IAC characters. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 280 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 281 | Can block if the connection is blocked. May raise |
Andrew Svetlov | 0832af6 | 2012-12-18 23:10:48 +0200 | [diff] [blame] | 282 | OSError if the connection is closed. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 283 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 284 | """ |
| 285 | if IAC in buffer: |
Eric S. Raymond | 6b8c528 | 2001-02-09 07:10:12 +0000 | [diff] [blame] | 286 | buffer = buffer.replace(IAC, IAC+IAC) |
Walter Dörwald | 70a6b49 | 2004-02-12 17:35:32 +0000 | [diff] [blame] | 287 | self.msg("send %r", buffer) |
Martin v. Löwis | e12454f | 2002-02-16 23:06:19 +0000 | [diff] [blame] | 288 | self.sock.sendall(buffer) |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 289 | |
| 290 | def read_until(self, match, timeout=None): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 291 | """Read until a given string is encountered or until timeout. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 292 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 293 | When no match is found, return whatever is available instead, |
| 294 | possibly the empty string. Raise EOFError if the connection |
| 295 | is closed and no cooked data is available. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 296 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 297 | """ |
| 298 | n = len(match) |
| 299 | self.process_rawq() |
Eric S. Raymond | 6b8c528 | 2001-02-09 07:10:12 +0000 | [diff] [blame] | 300 | i = self.cookedq.find(match) |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 301 | if i >= 0: |
| 302 | i = i+n |
| 303 | buf = self.cookedq[:i] |
| 304 | self.cookedq = self.cookedq[i:] |
| 305 | return buf |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 306 | if timeout is not None: |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 307 | from time import time |
Charles-François Natali | 6459025 | 2013-10-21 14:02:12 +0200 | [diff] [blame^] | 308 | deadline = time() + timeout |
| 309 | with _TelnetSelector() as selector: |
| 310 | selector.register(self, selectors.EVENT_READ) |
| 311 | while not self.eof: |
| 312 | if selector.select(timeout): |
| 313 | i = max(0, len(self.cookedq)-n) |
| 314 | self.fill_rawq() |
| 315 | self.process_rawq() |
| 316 | i = self.cookedq.find(match, i) |
| 317 | if i >= 0: |
| 318 | i = i+n |
| 319 | buf = self.cookedq[:i] |
| 320 | self.cookedq = self.cookedq[i:] |
| 321 | return buf |
| 322 | if timeout is not None: |
| 323 | timeout = deadline - time() |
| 324 | if timeout < 0: |
| 325 | break |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 326 | return self.read_very_lazy() |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 327 | |
| 328 | def read_all(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 329 | """Read all data until EOF; block until connection closed.""" |
| 330 | self.process_rawq() |
| 331 | while not self.eof: |
| 332 | self.fill_rawq() |
| 333 | self.process_rawq() |
| 334 | buf = self.cookedq |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 335 | self.cookedq = b'' |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 336 | return buf |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 337 | |
| 338 | def read_some(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 339 | """Read at least one byte of cooked data unless EOF is hit. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 340 | |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 341 | Return b'' if EOF is hit. Block if no data is immediately |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 342 | available. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 343 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 344 | """ |
| 345 | self.process_rawq() |
| 346 | while not self.cookedq and not self.eof: |
| 347 | self.fill_rawq() |
| 348 | self.process_rawq() |
| 349 | buf = self.cookedq |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 350 | self.cookedq = b'' |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 351 | return buf |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 352 | |
| 353 | def read_very_eager(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 354 | """Read everything that's possible without blocking in I/O (eager). |
Tim Peters | b90f89a | 2001-01-15 03:26:36 +0000 | [diff] [blame] | 355 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 356 | Raise EOFError if connection closed and no cooked data |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 357 | available. Return b'' if no cooked data available otherwise. |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 358 | Don't block unless in the midst of an IAC sequence. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 359 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 360 | """ |
| 361 | self.process_rawq() |
| 362 | while not self.eof and self.sock_avail(): |
| 363 | self.fill_rawq() |
| 364 | self.process_rawq() |
| 365 | return self.read_very_lazy() |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 366 | |
| 367 | def read_eager(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 368 | """Read readily available data. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 369 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 370 | Raise EOFError if connection closed and no cooked data |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 371 | available. Return b'' if no cooked data available otherwise. |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 372 | Don't block unless in the midst of an IAC sequence. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 373 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 374 | """ |
| 375 | self.process_rawq() |
| 376 | while not self.cookedq and not self.eof and self.sock_avail(): |
| 377 | self.fill_rawq() |
| 378 | self.process_rawq() |
| 379 | return self.read_very_lazy() |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 380 | |
| 381 | def read_lazy(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 382 | """Process and return data that's already in the queues (lazy). |
Tim Peters | b90f89a | 2001-01-15 03:26:36 +0000 | [diff] [blame] | 383 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 384 | Raise EOFError if connection closed and no data available. |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 385 | Return b'' if no cooked data available otherwise. Don't block |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 386 | unless in the midst of an IAC sequence. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 387 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 388 | """ |
| 389 | self.process_rawq() |
| 390 | return self.read_very_lazy() |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 391 | |
| 392 | def read_very_lazy(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 393 | """Return any data available in the cooked queue (very lazy). |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 394 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 395 | Raise EOFError if connection closed and no data available. |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 396 | Return b'' if no cooked data available otherwise. Don't block. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 397 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 398 | """ |
| 399 | buf = self.cookedq |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 400 | self.cookedq = b'' |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 401 | if not buf and self.eof and not self.rawq: |
Collin Winter | ce36ad8 | 2007-08-30 01:19:48 +0000 | [diff] [blame] | 402 | raise EOFError('telnet connection closed') |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 403 | return buf |
Tim Peters | 230a60c | 2002-11-09 05:08:07 +0000 | [diff] [blame] | 404 | |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 405 | def read_sb_data(self): |
| 406 | """Return any data available in the SB ... SE queue. |
| 407 | |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 408 | Return b'' if no SB ... SE available. Should only be called |
Tim Peters | 230a60c | 2002-11-09 05:08:07 +0000 | [diff] [blame] | 409 | after seeing a SB or SE command. When a new SB command is |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 410 | found, old unread SB data will be discarded. Don't block. |
| 411 | |
| 412 | """ |
| 413 | buf = self.sbdataq |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 414 | self.sbdataq = b'' |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 415 | return buf |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 416 | |
Martin v. Löwis | b0162f9 | 2001-09-06 08:51:38 +0000 | [diff] [blame] | 417 | def set_option_negotiation_callback(self, callback): |
| 418 | """Provide a callback function called after each receipt of a telnet option.""" |
| 419 | self.option_callback = callback |
| 420 | |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 421 | def process_rawq(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 422 | """Transfer from raw queue to cooked queue. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 423 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 424 | Set self.eof when connection is closed. Don't block unless in |
| 425 | the midst of an IAC sequence. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 426 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 427 | """ |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 428 | buf = [b'', b''] |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 429 | try: |
| 430 | while self.rawq: |
| 431 | c = self.rawq_getchar() |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 432 | if not self.iacseq: |
| 433 | if c == theNULL: |
| 434 | continue |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 435 | if c == b"\021": |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 436 | continue |
| 437 | if c != IAC: |
| 438 | buf[self.sb] = buf[self.sb] + c |
| 439 | continue |
Martin v. Löwis | b0162f9 | 2001-09-06 08:51:38 +0000 | [diff] [blame] | 440 | else: |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 441 | self.iacseq += c |
| 442 | elif len(self.iacseq) == 1: |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 443 | # 'IAC: IAC CMD [OPTION only for WILL/WONT/DO/DONT]' |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 444 | if c in (DO, DONT, WILL, WONT): |
| 445 | self.iacseq += c |
| 446 | continue |
Tim Peters | 230a60c | 2002-11-09 05:08:07 +0000 | [diff] [blame] | 447 | |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 448 | self.iacseq = b'' |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 449 | if c == IAC: |
| 450 | buf[self.sb] = buf[self.sb] + c |
Martin v. Löwis | b0162f9 | 2001-09-06 08:51:38 +0000 | [diff] [blame] | 451 | else: |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 452 | if c == SB: # SB ... SE start. |
| 453 | self.sb = 1 |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 454 | self.sbdataq = b'' |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 455 | elif c == SE: |
| 456 | self.sb = 0 |
| 457 | self.sbdataq = self.sbdataq + buf[1] |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 458 | buf[1] = b'' |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 459 | if self.option_callback: |
| 460 | # Callback is supposed to look into |
| 461 | # the sbdataq |
| 462 | self.option_callback(self.sock, c, NOOPT) |
| 463 | else: |
| 464 | # We can't offer automatic processing of |
| 465 | # suboptions. Alas, we should not get any |
| 466 | # unless we did a WILL/DO before. |
| 467 | self.msg('IAC %d not recognized' % ord(c)) |
| 468 | elif len(self.iacseq) == 2: |
Jack Diederich | 36596a3 | 2009-07-26 22:23:04 +0000 | [diff] [blame] | 469 | cmd = self.iacseq[1:2] |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 470 | self.iacseq = b'' |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 471 | opt = c |
| 472 | if cmd in (DO, DONT): |
Tim Peters | 230a60c | 2002-11-09 05:08:07 +0000 | [diff] [blame] | 473 | self.msg('IAC %s %d', |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 474 | cmd == DO and 'DO' or 'DONT', ord(opt)) |
| 475 | if self.option_callback: |
| 476 | self.option_callback(self.sock, cmd, opt) |
| 477 | else: |
| 478 | self.sock.sendall(IAC + WONT + opt) |
| 479 | elif cmd in (WILL, WONT): |
| 480 | self.msg('IAC %s %d', |
| 481 | cmd == WILL and 'WILL' or 'WONT', ord(opt)) |
| 482 | if self.option_callback: |
| 483 | self.option_callback(self.sock, cmd, opt) |
| 484 | else: |
| 485 | self.sock.sendall(IAC + DONT + opt) |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 486 | except EOFError: # raised by self.rawq_getchar() |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 487 | self.iacseq = b'' # Reset on EOF |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 488 | self.sb = 0 |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 489 | pass |
Martin v. Löwis | 1da9c57 | 2002-11-04 09:56:00 +0000 | [diff] [blame] | 490 | self.cookedq = self.cookedq + buf[0] |
| 491 | self.sbdataq = self.sbdataq + buf[1] |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 492 | |
| 493 | def rawq_getchar(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 494 | """Get next char from raw queue. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 495 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 496 | Block if no data is immediately available. Raise EOFError |
| 497 | when connection is closed. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 498 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 499 | """ |
| 500 | if not self.rawq: |
| 501 | self.fill_rawq() |
| 502 | if self.eof: |
| 503 | raise EOFError |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 504 | c = self.rawq[self.irawq:self.irawq+1] |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 505 | self.irawq = self.irawq + 1 |
| 506 | if self.irawq >= len(self.rawq): |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 507 | self.rawq = b'' |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 508 | self.irawq = 0 |
| 509 | return c |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 510 | |
| 511 | def fill_rawq(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 512 | """Fill raw queue from exactly one recv() system call. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 513 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 514 | Block if no data is immediately available. Set self.eof when |
| 515 | connection is closed. |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 516 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 517 | """ |
| 518 | if self.irawq >= len(self.rawq): |
Benjamin Peterson | 3de7fb8 | 2008-10-15 20:54:24 +0000 | [diff] [blame] | 519 | self.rawq = b'' |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 520 | self.irawq = 0 |
| 521 | # The buffer size should be fairly small so as to avoid quadratic |
| 522 | # behavior in process_rawq() above |
| 523 | buf = self.sock.recv(50) |
Walter Dörwald | 70a6b49 | 2004-02-12 17:35:32 +0000 | [diff] [blame] | 524 | self.msg("recv %r", buf) |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 525 | self.eof = (not buf) |
| 526 | self.rawq = self.rawq + buf |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 527 | |
| 528 | def sock_avail(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 529 | """Test whether data is available on the socket.""" |
Charles-François Natali | 6459025 | 2013-10-21 14:02:12 +0200 | [diff] [blame^] | 530 | with _TelnetSelector() as selector: |
| 531 | selector.register(self, selectors.EVENT_READ) |
| 532 | return bool(selector.select(0)) |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 533 | |
| 534 | def interact(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 535 | """Interaction function, emulates a very dumb telnet client.""" |
Guido van Rossum | 82eae9e | 1998-12-23 23:04:17 +0000 | [diff] [blame] | 536 | if sys.platform == "win32": |
| 537 | self.mt_interact() |
| 538 | return |
Charles-François Natali | 6459025 | 2013-10-21 14:02:12 +0200 | [diff] [blame^] | 539 | with _TelnetSelector() as selector: |
| 540 | selector.register(self, selectors.EVENT_READ) |
| 541 | selector.register(sys.stdin, selectors.EVENT_READ) |
| 542 | |
| 543 | while True: |
| 544 | for key, events in selector.select(): |
| 545 | if key.fileobj is self: |
| 546 | try: |
| 547 | text = self.read_eager() |
| 548 | except EOFError: |
| 549 | print('*** Connection closed by remote host ***') |
| 550 | return |
| 551 | if text: |
| 552 | sys.stdout.write(text.decode('ascii')) |
| 553 | sys.stdout.flush() |
| 554 | elif key.fileobj is sys.stdin: |
| 555 | line = sys.stdin.readline().encode('ascii') |
| 556 | if not line: |
| 557 | return |
| 558 | self.write(line) |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 559 | |
Guido van Rossum | 82eae9e | 1998-12-23 23:04:17 +0000 | [diff] [blame] | 560 | def mt_interact(self): |
| 561 | """Multithreaded version of interact().""" |
Georg Brandl | 2067bfd | 2008-05-25 13:05:15 +0000 | [diff] [blame] | 562 | import _thread |
| 563 | _thread.start_new_thread(self.listener, ()) |
Guido van Rossum | 82eae9e | 1998-12-23 23:04:17 +0000 | [diff] [blame] | 564 | while 1: |
| 565 | line = sys.stdin.readline() |
| 566 | if not line: |
| 567 | break |
R. David Murray | ba488d1 | 2010-10-26 12:42:24 +0000 | [diff] [blame] | 568 | self.write(line.encode('ascii')) |
Guido van Rossum | 82eae9e | 1998-12-23 23:04:17 +0000 | [diff] [blame] | 569 | |
| 570 | def listener(self): |
| 571 | """Helper for mt_interact() -- this executes in the other thread.""" |
| 572 | while 1: |
| 573 | try: |
| 574 | data = self.read_eager() |
| 575 | except EOFError: |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 576 | print('*** Connection closed by remote host ***') |
Guido van Rossum | 82eae9e | 1998-12-23 23:04:17 +0000 | [diff] [blame] | 577 | return |
| 578 | if data: |
R. David Murray | ba488d1 | 2010-10-26 12:42:24 +0000 | [diff] [blame] | 579 | sys.stdout.write(data.decode('ascii')) |
Guido van Rossum | 82eae9e | 1998-12-23 23:04:17 +0000 | [diff] [blame] | 580 | else: |
| 581 | sys.stdout.flush() |
| 582 | |
Guido van Rossum | ccb5ec6 | 1997-12-24 22:24:19 +0000 | [diff] [blame] | 583 | def expect(self, list, timeout=None): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 584 | """Read until one from a list of a regular expressions matches. |
Guido van Rossum | ccb5ec6 | 1997-12-24 22:24:19 +0000 | [diff] [blame] | 585 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 586 | The first argument is a list of regular expressions, either |
| 587 | compiled (re.RegexObject instances) or uncompiled (strings). |
| 588 | The optional second argument is a timeout, in seconds; default |
| 589 | is no timeout. |
Guido van Rossum | ccb5ec6 | 1997-12-24 22:24:19 +0000 | [diff] [blame] | 590 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 591 | Return a tuple of three items: the index in the list of the |
| 592 | first regular expression that matches; the match object |
| 593 | returned; and the text read up till and including the match. |
Guido van Rossum | ccb5ec6 | 1997-12-24 22:24:19 +0000 | [diff] [blame] | 594 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 595 | If EOF is read and no text was read, raise EOFError. |
| 596 | Otherwise, when nothing matches, return (-1, None, text) where |
| 597 | text is the text received so far (may be the empty string if a |
| 598 | timeout happened). |
Guido van Rossum | ccb5ec6 | 1997-12-24 22:24:19 +0000 | [diff] [blame] | 599 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 600 | If a regular expression ends with a greedy match (e.g. '.*') |
| 601 | or if more than one expression can match the same input, the |
| 602 | results are undeterministic, and may depend on the I/O timing. |
Guido van Rossum | ccb5ec6 | 1997-12-24 22:24:19 +0000 | [diff] [blame] | 603 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 604 | """ |
| 605 | re = None |
| 606 | list = list[:] |
| 607 | indices = range(len(list)) |
| 608 | for i in indices: |
| 609 | if not hasattr(list[i], "search"): |
| 610 | if not re: import re |
| 611 | list[i] = re.compile(list[i]) |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 612 | if timeout is not None: |
| 613 | from time import time |
Charles-François Natali | 6459025 | 2013-10-21 14:02:12 +0200 | [diff] [blame^] | 614 | deadline = time() + timeout |
| 615 | with _TelnetSelector() as selector: |
| 616 | selector.register(self, selectors.EVENT_READ) |
| 617 | while not self.eof: |
| 618 | self.process_rawq() |
| 619 | for i in indices: |
| 620 | m = list[i].search(self.cookedq) |
| 621 | if m: |
| 622 | e = m.end() |
| 623 | text = self.cookedq[:e] |
| 624 | self.cookedq = self.cookedq[e:] |
| 625 | return (i, m, text) |
| 626 | if timeout is not None: |
| 627 | ready = selector.select(timeout) |
| 628 | timeout = deadline - time() |
| 629 | if not ready: |
| 630 | if timeout < 0: |
| 631 | break |
| 632 | else: |
| 633 | continue |
| 634 | self.fill_rawq() |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 635 | text = self.read_very_lazy() |
| 636 | if not text and self.eof: |
| 637 | raise EOFError |
| 638 | return (-1, None, text) |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 639 | |
| 640 | |
| 641 | def test(): |
| 642 | """Test program for telnetlib. |
| 643 | |
| 644 | Usage: python telnetlib.py [-d] ... [host [port]] |
| 645 | |
| 646 | Default host is localhost; default port is 23. |
| 647 | |
| 648 | """ |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 649 | debuglevel = 0 |
| 650 | while sys.argv[1:] and sys.argv[1] == '-d': |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 651 | debuglevel = debuglevel+1 |
| 652 | del sys.argv[1] |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 653 | host = 'localhost' |
| 654 | if sys.argv[1:]: |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 655 | host = sys.argv[1] |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 656 | port = 0 |
| 657 | if sys.argv[2:]: |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 658 | portstr = sys.argv[2] |
| 659 | try: |
| 660 | port = int(portstr) |
| 661 | except ValueError: |
| 662 | port = socket.getservbyname(portstr, 'tcp') |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 663 | tn = Telnet() |
| 664 | tn.set_debuglevel(debuglevel) |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 665 | tn.open(host, port, timeout=0.5) |
Guido van Rossum | b9b50eb | 1997-12-24 21:07:04 +0000 | [diff] [blame] | 666 | tn.interact() |
| 667 | tn.close() |
| 668 | |
| 669 | if __name__ == '__main__': |
| 670 | test() |