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