def test_telnet_client_send_tspeed(event_loop, bind_host, unused_tcp_port):
"""Test Client's callback method send_tspeed()."""
# given
_waiter = asyncio.Future()
given_rx, given_tx = 1337, 1919
class ServerTestTspeed(telnetlib3.TelnetServer):
def on_tspeed(self, rx, tx):
super().on_tspeed(rx, tx)
_waiter.set_result((rx, tx))
def begin_advanced_negotiation(self):
from telnetlib3.telopt import DO, TSPEED
super().begin_advanced_negotiation()
self.writer.iac(DO, TSPEED)
yield from telnetlib3.create_server(protocol_factory=ServerTestTspeed,
host=bind_host,
port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from telnetlib3.open_connection(
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
tspeed=(given_rx, given_tx),
connect_minwait=0.05)
recv_rx, recv_tx = yield from asyncio.wait_for(_waiter, 0.5)
assert recv_rx == given_rx
assert recv_tx == given_tx
def test_telnet_server_on_xdisploc(event_loop, bind_host, unused_tcp_port):
"""Test Server's callback method on_xdisploc()."""
# given
from telnetlib3.telopt import (IAC, WILL, SB, SE, IS, XDISPLOC)
_waiter = asyncio.Future()
given_xdisploc = 'alpha:0'
class ServerTestXdisploc(telnetlib3.TelnetServer):
def on_xdisploc(self, xdisploc):
super().on_xdisploc(xdisploc)
_waiter.set_result(self)
yield from telnetlib3.create_server(protocol_factory=ServerTestXdisploc,
host=bind_host,
port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from asyncio.open_connection(host=bind_host,
port=unused_tcp_port,
loop=event_loop)
# exercise,
writer.write(IAC + WILL + XDISPLOC)
writer.write(IAC + SB + XDISPLOC + IS + given_xdisploc.encode('ascii') +
IAC + SE)
# verify,
srv_instance = yield from asyncio.wait_for(_waiter, 0.5)
assert srv_instance.get_extra_info('xdisploc') == 'alpha:0'
def main():
global game
props = Properties()
props.init_props('properties.yml')
configure_log_file(props.get('log.prefix'))
logging.info('******************')
connect(props.get('db.database'),
host='mongodb://' + props.get('db.user') + ':' +
props.get('db.password') + '@' + props.get('db.host'))
logging.info('Connected to database')
logging.info('Host: %s', props.get('db.host'))
logging.info('Database: %s', props.get('db.database'))
logging.info('User: %s', props.get('db.user'))
props.load_config()
game = Game()
game_manager = GameManager()
loop = asyncio.get_event_loop()
coro = telnetlib3.create_server(port=props.get('server.port'),
log=logging.getLogger(),
shell=shell,
timeout=0)
server = loop.run_until_complete(coro)
logging.info('Server started on 127.0.0.1:' +
str(props.get('server.port')))
loop.call_later(1, game_manager.execute_timed_actions)
loop.run_until_complete(server.wait_closed())
def test_telnet_server_on_tspeed(event_loop, bind_host, unused_tcp_port):
"""Test Server's callback method on_tspeed()."""
# given
from telnetlib3.telopt import IAC, WILL, SB, SE, IS, TSPEED
_waiter = asyncio.Future()
class ServerTestTspeed(telnetlib3.TelnetServer):
def on_tspeed(self, rx, tx):
super().on_tspeed(rx, tx)
_waiter.set_result(self)
yield from telnetlib3.create_server(protocol_factory=ServerTestTspeed,
host=bind_host,
port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from asyncio.open_connection(host=bind_host,
port=unused_tcp_port,
loop=event_loop)
# exercise,
writer.write(IAC + WILL + TSPEED)
writer.write(IAC + SB + TSPEED + IS + b'123,456' + IAC + SE)
# verify,
srv_instance = yield from asyncio.wait_for(_waiter, 0.5)
assert srv_instance.get_extra_info('tspeed') == '123,456'
def test_telnet_client_send_naws(event_loop, bind_host, unused_tcp_port):
"""Test Client's NAWS of callback method send_naws()."""
# given a server
_waiter = asyncio.Future()
given_cols, given_rows = 40, 20
class ServerTestNaws(telnetlib3.TelnetServer):
def on_naws(self, width, height):
super().on_naws(width, height)
_waiter.set_result((height, width))
yield from telnetlib3.create_server(protocol_factory=ServerTestNaws,
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
connect_maxwait=0.05)
reader, writer = yield from telnetlib3.open_connection(
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
cols=given_cols,
rows=given_rows,
connect_minwait=0.05)
recv_cols, recv_rows = yield from asyncio.wait_for(_waiter, 0.5)
assert recv_cols == given_cols
assert recv_rows == given_rows
def test_telnet_client_send_tty_naws(event_loop, bind_host, unused_tcp_port):
"""Test Client's NAWS of callback method send_naws()."""
# given a client,
_waiter = asyncio.Future()
given_cols, given_rows = 40, 20
prog, args = 'telnetlib3-client', [
bind_host,
str(unused_tcp_port), '--loglevel=warn', '--connect-minwait=0.005',
'--connect-maxwait=0.010'
]
# a server,
class ServerTestNaws(telnetlib3.TelnetServer):
def on_naws(self, width, height):
super().on_naws(width, height)
_waiter.set_result((height, width))
event_loop.call_soon(self.connection_lost, None)
yield from telnetlib3.create_server(protocol_factory=ServerTestNaws,
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
connect_maxwait=0.05)
proc = pexpect.spawn(prog, args, dimensions=(given_rows, given_cols))
yield from proc.expect(pexpect.EOF, async=True, timeout=5)
assert proc.match == pexpect.EOF
recv_cols, recv_rows = yield from asyncio.wait_for(_waiter, 0.5)
assert recv_cols == given_cols
assert recv_rows == given_rows
def test_send_eor(event_loop, bind_host, unused_tcp_port):
"""Writer sends IAC + EOR if client requests by DO."""
from telnetlib3.telopt import IAC, DO, WILL, CMD_EOR, EOR
given = IAC + DO + EOR
expected = IAC + WILL + EOR + b'<' + IAC + CMD_EOR + b'>'
# just verify rfc constants are used appropriately in this context
assert EOR == bytes([25])
assert CMD_EOR == bytes([239])
@asyncio.coroutine
def shell(reader, writer):
writer.write('<')
result = writer.send_eor()
assert result is True
writer.write('>')
writer.close()
yield from telnetlib3.create_server(
protocol_factory=telnetlib3.BaseServer, host=bind_host, shell=shell,
port=unused_tcp_port, loop=event_loop, connect_maxwait=0.05)
client_reader, client_writer = yield from asyncio.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop)
# verify,
client_writer.write(given)
result = yield from asyncio.wait_for(client_reader.read(), 0.5)
assert result == expected
async def test_telnet_client_send_charset(event_loop, bind_host, unused_tcp_port):
"""Test Client's callback method send_charset() selection for illegals."""
# given
_waiter = asyncio.Future()
class ServerTestCharset(telnetlib3.TelnetServer):
def on_request_charset(self):
return ['illegal', 'cp437']
class ClientTestCharset(telnetlib3.TelnetClient):
def send_charset(self, offered):
selected = super().send_charset(offered)
_waiter.set_result(selected)
return selected
await asyncio.wait_for(
telnetlib3.create_server(
protocol_factory=ServerTestCharset,
host=bind_host, port=unused_tcp_port,
loop=event_loop),
0.15)
reader, writer = await asyncio.wait_for(
telnetlib3.open_connection(
client_factory=ClientTestCharset,
host=bind_host, port=unused_tcp_port, loop=event_loop,
encoding='latin1', connect_minwait=0.05),
0.15)
val = await asyncio.wait_for(_waiter, 1.5)
assert val == 'cp437'
assert writer.get_extra_info('charset') == 'cp437'
def test_send_iac_dont_dont(event_loop, bind_host, unused_tcp_port):
"""Try a DONT and ensure it cannot be sent twice."""
from telnetlib3.telopt import DONT, ECHO
_waiter = asyncio.Future()
yield from telnetlib3.create_server(
protocol_factory=telnetlib3.BaseServer, host=bind_host,
port=unused_tcp_port, loop=event_loop, connect_maxwait=0.05,
_waiter_connected=_waiter)
_, client_writer = yield from telnetlib3.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop,
connect_minwait=0.05)
# say it once,
result = client_writer.iac(DONT, ECHO)
assert result == True
# say it again, suppressed
result = client_writer.iac(DONT, ECHO)
assert result == False
server_writer = (yield from asyncio.wait_for(_waiter, 0.5)).writer
assert client_writer.remote_option[ECHO] is False
assert server_writer.local_option[ECHO] is False
def test_not_send_ga(event_loop, bind_host, unused_tcp_port):
"""Writer does not send IAC + GA when SGA is negotiated."""
from telnetlib3.telopt import IAC, DO, WILL, SGA
# we requires IAC + DO + SGA, and expect a confirming reply. We also
# call writer.send_ga() from the shell, whose result should be False
# (not sent). The reader never receives an IAC + GA.
expected = IAC + WILL + SGA
@asyncio.coroutine
def shell(reader, writer):
result = writer.send_ga()
assert result is False
writer.close()
yield from telnetlib3.create_server(
protocol_factory=telnetlib3.BaseServer, host=bind_host, shell=shell,
port=unused_tcp_port, loop=event_loop, connect_maxwait=0.05)
client_reader, client_writer = yield from asyncio.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop)
client_writer.write(IAC + DO + SGA)
# verify,
result = yield from asyncio.wait_for(client_reader.read(), 0.5)
assert result == expected
def test_iac_dont_dont(event_loop, bind_host, unused_tcp_port):
"""WILL/WONT replied only once for repeated DO."""
from telnetlib3.telopt import IAC, DONT, ECHO
@asyncio.coroutine
def shell(reader, writer):
writer.close()
# given,
given_from_client = IAC + DONT + ECHO + IAC + DONT + ECHO
expect_from_server = b''
yield from telnetlib3.create_server(
protocol_factory=telnetlib3.BaseServer, host=bind_host, shell=shell,
port=unused_tcp_port, loop=event_loop, connect_maxwait=0.05)
client_reader, client_writer = yield from asyncio.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop)
# exercise,
client_writer.write(given_from_client)
# verify,
result_from_server = yield from asyncio.wait_for(client_reader.read(), 0.5)
assert result_from_server == expect_from_server
def test_telnet_server_encoding_client_will(event_loop, bind_host,
unused_tcp_port):
"""Server Default encoding (utf8) incoming when client WILL."""
from telnetlib3.telopt import IAC, WONT, WILL, TTYPE, BINARY
# given
_waiter = asyncio.Future()
yield from telnetlib3.create_server(host=bind_host,
port=unused_tcp_port,
_waiter_connected=_waiter,
loop=event_loop)
reader, writer = yield from asyncio.open_connection(host=bind_host,
port=unused_tcp_port,
loop=event_loop)
# exercise, quickly failing negotiation/encoding.
writer.write(IAC + WILL + BINARY)
writer.write(IAC + WONT + TTYPE)
# verify,
srv_instance = yield from asyncio.wait_for(_waiter, 0.5)
assert srv_instance.encoding(incoming=True) == 'utf8'
assert srv_instance.encoding(outgoing=True) == 'US-ASCII'
assert srv_instance.encoding(incoming=True, outgoing=True) == 'US-ASCII'
def test_telnet_client_and_server_escape_iac_binary(event_loop, bind_host,
unused_tcp_port):
"""Ensure that IAC (byte 255) may be sent across the wire in binary."""
# given
_waiter = asyncio.Future()
given_string = bytes(range(256)) * 2
yield from telnetlib3.create_server(host=bind_host,
port=unused_tcp_port,
_waiter_connected=_waiter,
loop=event_loop,
encoding=False,
connect_maxwait=0.05)
client_reader, client_writer = yield from telnetlib3.open_connection(
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
encoding=False,
connect_minwait=0.05)
server = yield from asyncio.wait_for(_waiter, 0.5)
server.writer.write(given_string)
result = yield from client_reader.read(len(given_string))
assert result == given_string
server.writer.close()
eof = yield from asyncio.wait_for(client_reader.read(), 0.5)
assert eof == b''
def test_telnet_client_send_xdisploc(event_loop, bind_host, unused_tcp_port):
"""Test Client's callback method send_xdisploc()."""
# given
_waiter = asyncio.Future()
given_xdisploc = 'alpha'
class ServerTestXdisploc(telnetlib3.TelnetServer):
def on_xdisploc(self, xdisploc):
super().on_xdisploc(xdisploc)
_waiter.set_result(xdisploc)
def begin_advanced_negotiation(self):
from telnetlib3.telopt import DO, XDISPLOC
super().begin_advanced_negotiation()
self.writer.iac(DO, XDISPLOC)
yield from telnetlib3.create_server(protocol_factory=ServerTestXdisploc,
host=bind_host,
port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from telnetlib3.open_connection(
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
xdisploc=given_xdisploc,
connect_minwait=0.05)
recv_xdisploc = yield from asyncio.wait_for(_waiter, 0.5)
assert recv_xdisploc == given_xdisploc
def test_telnet_server_on_naws(event_loop, bind_host, unused_tcp_port):
"""Test Server's Negotiate about window size (NAWS)."""
# given
from telnetlib3.telopt import IAC, WILL, SB, SE, NAWS
_waiter = asyncio.Future()
given_cols, given_rows = 40, 20
class ServerTestNaws(telnetlib3.TelnetServer):
def on_naws(self, width, height):
super().on_naws(width, height)
_waiter.set_result(self)
yield from telnetlib3.create_server(protocol_factory=ServerTestNaws,
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
connect_maxwait=0.05)
reader, writer = yield from asyncio.open_connection(host=bind_host,
port=unused_tcp_port,
loop=event_loop)
# exercise,
writer.write(IAC + WILL + NAWS)
writer.write(IAC + SB + NAWS + struct.pack('!HH', given_cols, given_rows) +
IAC + SE)
srv_instance = yield from asyncio.wait_for(_waiter, 0.5)
assert srv_instance.get_extra_info('cols') == given_cols
assert srv_instance.get_extra_info('rows') == given_rows
def test_telnet_server_reject_environ(event_loop, bind_host,
unused_tcp_port):
"""Test Client's callback method send_environ() for specific requests."""
from telnetlib3.telopt import SB, NEW_ENVIRON
# given
given_cols = 19
given_rows = 84
given_encoding = 'cp437'
given_term = 'vt220'
class ServerTestEnviron(telnetlib3.TelnetServer):
def on_request_environ(self):
return None
yield from telnetlib3.create_server(
protocol_factory=ServerTestEnviron,
host=bind_host, port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from telnetlib3.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop,
cols=given_cols, rows=given_rows, encoding=given_encoding,
term=given_term, connect_minwait=0.05, connect_maxwait=0.05)
# this causes the client to expect the server to have demanded environment
# values, since it did, of course demand DO NEW_ENVIRON! However, our API
# choice here has chosen not to -- the client then indicates this as a
# failed sub-negotiation (SB + NEW_ENVIRON).
_failed = {key: val for key, val in writer.pending_option.items() if val}
assert _failed == {SB + NEW_ENVIRON: True}
def test_telnet_client_send_environ(event_loop, bind_host,
unused_tcp_port):
"""Test Client's callback method send_environ() for specific requests."""
# given
_waiter = asyncio.Future()
given_cols = 19
given_rows = 84
given_encoding = 'cp437'
given_term = 'vt220'
class ServerTestEnviron(telnetlib3.TelnetServer):
def on_environ(self, mapping):
super().on_environ(mapping)
_waiter.set_result(mapping)
yield from telnetlib3.create_server(
protocol_factory=ServerTestEnviron,
host=bind_host, port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from telnetlib3.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop,
cols=given_cols, rows=given_rows, encoding=given_encoding,
term=given_term, connect_minwait=0.05)
mapping = yield from asyncio.wait_for(_waiter, 0.5)
assert mapping == {
'COLUMNS': str(given_cols),
'LANG': 'en_US.' + given_encoding,
'LINES': str(given_rows),
'TERM': 'vt220'
}
def setup():
if (len(sys.argv) > 1) and sys.argv[1] == "cli":
try:
import telnetlib3
except:
print("Please run 'pip install telnetlib3' to use remote CLI")
ConfigUtil.save()
exit(0)
try:
import telnetlib3
import asyncio
from util.RemoteCliHandler import RemoteCliHandler
port = 8888
if (len(sys.argv) > 2):
port = int(sys.argv[2])
print("Running in remote CLI Mode on port {0}".format(port))
print("Access by 'telnet {0} {1}'".format(RemoteCliHandler.get_ip(), port))
print("Press Ctrl-C to stop the server")
loop = asyncio.get_event_loop()
coro = telnetlib3.create_server(port=port, shell=RemoteCliHandler.shell)
server = loop.run_until_complete(coro)
loop.run_until_complete(server.wait_closed())
exit(0)
except KeyboardInterrupt:
exit(0)
except Exception as e:
print(str(e))
exit(-1)
def mock_telnet_echo(event_loop: asyncio.AbstractEventLoop):
"""Mock a silent telnet server."""
async def shell(reader: telnetlib3.TelnetReader,
writer: telnetlib3.TelnetWriter):
await reader.readuntil(separator=b"\r")
writer.write("PWON\ra1\r")
await writer.drain()
await asyncio.sleep(1)
writer.write("a\r")
await writer.drain()
await asyncio.sleep(0.25)
writer.write("a\r")
await writer.drain()
await asyncio.sleep(0.25)
writer.write("a\r")
await writer.drain()
coro = telnetlib3.create_server(port=4000, shell=shell)
server = event_loop.run_until_complete(coro)
yield
server.close()
event_loop.run_until_complete(server.wait_closed())
def test_telnet_server_on_charset(event_loop, bind_host, unused_tcp_port):
"""Test Server's callback method on_charset()."""
# given
from telnetlib3.telopt import (IAC, WILL, WONT, SB, SE, TTYPE, CHARSET,
ACCEPTED)
_waiter = asyncio.Future()
given_charset = 'KOI8-U'
class ServerTestCharset(telnetlib3.TelnetServer):
def on_charset(self, charset):
super().on_charset(charset)
_waiter.set_result(self)
yield from telnetlib3.create_server(protocol_factory=ServerTestCharset,
host=bind_host,
port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from asyncio.open_connection(host=bind_host,
port=unused_tcp_port,
loop=event_loop)
val = yield from asyncio.wait_for(reader.readexactly(3), 0.5)
# exercise,
writer.write(IAC + WILL + CHARSET)
writer.write(IAC + WONT + TTYPE)
writer.write(IAC + SB + CHARSET + ACCEPTED +
given_charset.encode('ascii') + IAC + SE)
# verify,
srv_instance = yield from asyncio.wait_for(_waiter, 2.0)
assert srv_instance.get_extra_info('charset') == given_charset
def test_telnet_client_no_charset(event_loop, bind_host, unused_tcp_port):
"""Test Client's callback method send_charset() does not select."""
# given
_waiter = asyncio.Future()
class ServerTestCharset(telnetlib3.TelnetServer):
def on_request_charset(self):
return ['illegal', 'this-is-no-good-either']
class ClientTestCharset(telnetlib3.TelnetClient):
def send_charset(self, offered):
selected = super().send_charset(offered)
_waiter.set_result(selected)
return selected
yield from telnetlib3.create_server(protocol_factory=ServerTestCharset,
host=bind_host,
port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from telnetlib3.open_connection(
client_factory=ClientTestCharset,
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
encoding='latin1',
connect_minwait=0.05)
# charset remains latin1
val = yield from asyncio.wait_for(_waiter, 0.5)
assert val == ''
assert writer.get_extra_info('charset') == 'latin1'
def test_telnet_server_on_ttype_empty(
event_loop, bind_host, unused_tcp_port):
"""Test Server's callback method on_ttype(): empty value is ignored. """
# given
from telnetlib3.telopt import IAC, WILL, SB, SE, IS, TTYPE
_waiter = asyncio.Future()
given_ttypes = ('ALPHA', '', 'BETA')
class ServerTestTtype(telnetlib3.TelnetServer):
def on_ttype(self, ttype):
super().on_ttype(ttype)
if ttype == given_ttypes[-1]:
_waiter.set_result(self)
yield from telnetlib3.create_server(
protocol_factory=ServerTestTtype,
host=bind_host, port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from asyncio.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop)
# exercise,
writer.write(IAC + WILL + TTYPE)
for send_ttype in given_ttypes:
writer.write(IAC + SB + TTYPE + IS +
send_ttype.encode('ascii') +
IAC + SE)
# verify,
srv_instance = yield from asyncio.wait_for(_waiter, 0.5)
assert srv_instance.get_extra_info('ttype1') == 'ALPHA'
assert srv_instance.get_extra_info('ttype2') == 'BETA'
assert srv_instance.get_extra_info('TERM') == 'BETA'
def test_telnet_server_on_ttype(event_loop, bind_host, unused_tcp_port):
"""Test Server's callback method on_ttype()."""
# given
from telnetlib3.telopt import IAC, WILL, SB, SE, IS, TTYPE
_waiter = asyncio.Future()
class ServerTestTtype(telnetlib3.TelnetServer):
def on_ttype(self, ttype):
super().on_ttype(ttype)
_waiter.set_result(self)
yield from telnetlib3.create_server(
protocol_factory=ServerTestTtype,
host=bind_host, port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from asyncio.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop)
# exercise,
writer.write(IAC + WILL + TTYPE)
writer.write(IAC + SB + TTYPE + IS + b'ALPHA' + IAC + SE)
writer.write(IAC + SB + TTYPE + IS + b'ALPHA' + IAC + SE)
# verify,
srv_instance = yield from asyncio.wait_for(_waiter, 0.5)
assert 'ALPHA' == srv_instance.get_extra_info('ttype1')
assert 'ALPHA' == srv_instance.get_extra_info('ttype2')
assert 'ALPHA' == srv_instance.get_extra_info('TERM')
def test_telnet_server_default_timeout(event_loop, bind_host, unused_tcp_port):
"""Test callback on_timeout() as coroutine of create_server()."""
from telnetlib3.telopt import IAC, WONT, TTYPE
# given,
_waiter = asyncio.Future()
given_timeout = 19.29
yield from telnetlib3.create_server(_waiter_connected=_waiter,
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
timeout=given_timeout)
reader, writer = yield from asyncio.open_connection(host=bind_host,
port=unused_tcp_port,
loop=event_loop)
writer.write(IAC + WONT + TTYPE)
server = yield from asyncio.wait_for(_waiter, 0.5)
assert server.get_extra_info('timeout') == given_timeout
# exercise, calling set_timeout remains the default given_value.
server.set_timeout()
assert server.get_extra_info('timeout') == given_timeout
async def test_telnet_client_send_charset(event_loop, bind_host,
unused_tcp_port):
"""Test Client's callback method send_charset() selection for illegals."""
# given
_waiter = asyncio.Future()
class ServerTestCharset(telnetlib3.TelnetServer):
def on_request_charset(self):
return ['illegal', 'cp437']
class ClientTestCharset(telnetlib3.TelnetClient):
def send_charset(self, offered):
selected = super().send_charset(offered)
_waiter.set_result(selected)
return selected
await asyncio.wait_for(
telnetlib3.create_server(protocol_factory=ServerTestCharset,
host=bind_host,
port=unused_tcp_port,
loop=event_loop), 0.15)
reader, writer = await asyncio.wait_for(
telnetlib3.open_connection(client_factory=ClientTestCharset,
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
encoding='latin1',
connect_minwait=0.05), 0.15)
val = await asyncio.wait_for(_waiter, 1.5)
assert val == 'cp437'
assert writer.get_extra_info('charset') == 'cp437'
def test_telnet_server_closed_by_error(event_loop, bind_host, unused_tcp_port):
"""Exercise TelnetServer.connection_lost by exception."""
from telnetlib3.telopt import IAC, DO, WONT, TTYPE
# given
_waiter_connected = asyncio.Future()
_waiter_closed = asyncio.Future()
yield from telnetlib3.create_server(_waiter_connected=_waiter_connected,
_waiter_closed=_waiter_closed,
host=bind_host,
port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from asyncio.open_connection(host=bind_host,
port=unused_tcp_port,
loop=event_loop)
writer.write(IAC + WONT + TTYPE)
server = yield from asyncio.wait_for(_waiter_connected, 0.5)
class CustomException(Exception):
pass
# exercise, by connection_lost(exc=Exception())..
server.writer.write('Bye!')
server.connection_lost(CustomException('blah!'))
# verify, custom exception is thrown into any yielding reader
with pytest.raises(CustomException):
yield from server.reader.read()
def test_telnet_server_negotiation_fail(event_loop, bind_host,
unused_tcp_port):
"""Test telnetlib3.TelnetServer() negotiation failure with client."""
from telnetlib3.telopt import DO, TTYPE
# given
_waiter_connected = asyncio.Future()
yield from telnetlib3.create_server(_waiter_connected=_waiter_connected,
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
connect_maxwait=0.05)
reader, writer = yield from asyncio.open_connection(host=bind_host,
port=unused_tcp_port,
loop=event_loop)
# exercise,
reader.readexactly(3) # IAC DO TTYPE, we ignore it!
# negotiation then times out, deferring to waiter_connected.
server = yield from asyncio.wait_for(_waiter_connected, 1.0)
# verify,
assert server.negotiation_should_advance() is False
assert server.writer.pending_option[DO + TTYPE] == True
assert repr(server.writer) == ('<TelnetWriter server '
'mode:local +lineflow -xon_any +slc_sim '
'failed-reply:DO TTYPE>')
def test_telnet_server_closed_by_client(event_loop, bind_host,
unused_tcp_port):
"""Exercise TelnetServer.connection_lost."""
# given
_waiter = asyncio.Future()
yield from telnetlib3.create_server(_waiter_closed=_waiter,
host=bind_host,
port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from asyncio.open_connection(host=bind_host,
port=unused_tcp_port,
loop=event_loop)
# exercise,
writer.close()
# verify,
srv_instance = yield from asyncio.wait_for(_waiter, 0.5)
assert srv_instance._closing
# exercise, a 2nd call to .connection_lost() returns early,
# allowing callbacks the freedom to call it at any time from
# the server-end to dump the client.
srv_instance.connection_lost(exc=None)
def test_telnet_reader_read_beyond_limit_bytes(
event_loop, bind_host, unused_tcp_port):
"""Ensure ability to read(-1) beyond segment sizes of reader._limit."""
# given
_waiter = asyncio.Future()
limit = 10
def shell(reader, writer):
assert reader._limit == limit
given = b'x' * (limit + 1)
writer.write(given)
writer.close()
yield from telnetlib3.create_server(
host=bind_host, port=unused_tcp_port, loop=event_loop,
connect_maxwait=0.05, shell=shell, encoding=False, limit=limit)
client_reader, client_writer = yield from telnetlib3.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop,
connect_minwait=0.05, encoding=False, limit=limit)
assert client_reader._limit == limit
value = yield from asyncio.wait_for(client_reader.read(), 0.5)
assert value == b'x' * (limit + 1)
def test_telnet_reader_read_exactly_bytes(
event_loop, bind_host, unused_tcp_port):
"""Ensure TelnetReader.readexactly, especially IncompleteReadError."""
# given
_waiter = asyncio.Future()
given = string.ascii_letters.encode('ascii')
given_partial = b'zzz'
def shell(reader, writer):
writer.write(given + given_partial)
writer.close()
yield from telnetlib3.create_server(
host=bind_host, port=unused_tcp_port, loop=event_loop,
connect_maxwait=0.05, shell=shell, encoding=False)
client_reader, client_writer = yield from telnetlib3.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop,
connect_minwait=0.05, encoding=False)
# exercise, readexactly # bytes of given
result = yield from asyncio.wait_for(
client_reader.readexactly(len(given)), 0.5)
# verify,
assert result == given
# exercise, read 1 byte beyond given_partial
given_readsize = len(given_partial) + 1
with pytest.raises(asyncio.IncompleteReadError) as exc_info:
result = yield from asyncio.wait_for(
client_reader.readexactly(given_readsize), 0.5)
assert exc_info.value.partial == given_partial
assert exc_info.value.expected == given_readsize
def test_telnet_server_set_timeout(event_loop, bind_host, unused_tcp_port):
"""Test callback on_timeout() as coroutine of create_server()."""
from telnetlib3.telopt import IAC, WONT, TTYPE
# given,
_waiter = asyncio.Future()
# exercise,
yield from telnetlib3.create_server(_waiter_connected=_waiter,
host=bind_host,
port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from asyncio.open_connection(host=bind_host,
port=unused_tcp_port,
loop=event_loop)
writer.write(IAC + WONT + TTYPE)
server = yield from asyncio.wait_for(_waiter, 0.5)
for value in (19.29, 0):
server.set_timeout(value)
assert server.get_extra_info('timeout') == value
# calling with no arguments does nothing, only resets
# the timer. value remains the last-most value from
# previous loop
server.set_timeout()
assert server.get_extra_info('timeout') == 0
def test_extended(server_factory, event_loop, bind_host, unused_tcp_port, log):
"""Using coupled connections, exercise extended telnet options."""
event_loop.set_debug(True)
waiter_server_connected = asyncio.Future()
waiter_client_connected = asyncio.Future()
waiter_client_closed = asyncio.Future()
server = yield from telnetlib3.create_server(
host=bind_host, port=unused_tcp_port,
waiter_connected=waiter_server_connected,
log=log)
log.info('Listening on {0}'.format(server.sockets[0].getsockname()))
_, client = yield from event_loop.create_connection(
protocol_factory=lambda: TestTelnetClient(
waiter_connected=waiter_client_connected,
waiter_closed=waiter_client_closed,
encoding='utf8', log=log),
host=bind_host, port=unused_tcp_port)
wait_for = [waiter_client_connected, waiter_server_connected]
done, pending = yield from asyncio.wait(wait_for,
loop=event_loop,
timeout=1)
assert not pending, (done, pending, wait_for)
from telnetlib3.telopt import WILL, TSPEED
client.writer.iac(WILL, TSPEED)
client.writer.write(u'quit\r')
wait_for = [waiter_client_closed]
done, pending = yield from asyncio.wait(wait_for,
loop=event_loop,
timeout=1)
assert not pending, (done, pending, wait_for)
server.close()
yield from server.wait_closed()
def test_telnet_coupled(server_factory, event_loop, bind_host, unused_tcp_port, log):
"""Couple TelnetClient to TelnetServer as standard protocol connection."""
event_loop.set_debug(True)
waiter_server_connected = asyncio.Future()
waiter_client_connected = asyncio.Future()
waiter_client_closed = asyncio.Future()
server = yield from telnetlib3.create_server(
host=bind_host, port=unused_tcp_port,
waiter_connected=waiter_server_connected,
log=log)
log.info('Listening on {0}'.format(server.sockets[0].getsockname()))
_, client = yield from event_loop.create_connection(
protocol_factory=lambda: TestTelnetClient(
waiter_connected=waiter_client_connected,
waiter_closed=waiter_client_closed,
encoding='utf8', log=log),
host=bind_host, port=unused_tcp_port)
wait_for = [waiter_client_connected, waiter_server_connected]
done, pending = yield from asyncio.wait(wait_for,
loop=event_loop,
timeout=1)
assert not pending, wait_for
client.writer.write(u'quit\r')
server.close()
wait_for = [waiter_client_closed, server.wait_closed()]
done, pending = yield from asyncio.wait(wait_for,
loop=event_loop,
timeout=1)
assert not pending, (done, pending, wait_for)
import asyncio, telnetlib3
@asyncio.coroutine
def shell(reader, writer):
writer.write('Would you like to play a game? ')
inp = yield from reader.read(1)
if inp:
writer.echo(inp)
writer.write('\r\nThey say the only way to win '
'is to not play at all.\r\n')
yield from writer.drain()
writer.close()
loop = asyncio.get_event_loop()
coro = telnetlib3.create_server(port=6023, shell=shell)
server = loop.run_until_complete(coro)
loop.run_until_complete(server.wait_closed())
def test_bsdtelnet(server_factory, event_loop, bind_host, unused_tcp_port, log):
"""Simple telnet(1) as client (issues 'quit' command)."""
# if the event loop is not set in debug mode, pexpect blows up !
# https://github.com/pexpect/pexpect/issues/294
event_loop.set_debug(True)
server_connected = asyncio.Future()
server_closed = asyncio.Future()
server = yield from telnetlib3.create_server(
host=bind_host, port=unused_tcp_port,
waiter_connected=server_connected,
waiter_closed=server_closed,
log=log)
log.info('Listening on {0}'.format(server.sockets[0].getsockname()))
child = pexpect.spawn(command='telnet', encoding='utf8',
echo=False, maxread=65534,
searchwindowsize=1024, timeout=1)
child.delaybeforesend = 0.0
child.delayafterterminate = 0.0
child.delayafterclose = 0.0
# set client-side debugging of telnet negotiation
yield from child.expect("telnet> ", async=True)
child.sendline(u"set options")
# and connect,
yield from child.expect(u"telnet> ", async=True)
child.sendline(u"open {0} {1}".format(bind_host, unused_tcp_port))
# await connection banner,
yield from child.expect_exact("Trying {0}...\r\n".format(bind_host),
timeout=5,
async=True)
# find the prompt, '%'
client_connected = child.expect('.* % ', async=True, timeout=None)
done, pending = yield from asyncio.wait(
[client_connected, server_connected],
loop=event_loop, timeout=1,
return_when=asyncio.ALL_COMPLETED)
assert not pending, (client_connected, server_connected)
cancelled = {future for future in done if future.cancelled()}
log.debug('done {0}'.format(done))
log.debug('pending {0}'.format(pending))
log.debug('cancelled {0}'.format(cancelled))
assert not cancelled, (done, pending, cancelled, child.buffer)
child.sendline(u"quit")
telnet_closed = child.expect(pexpect.EOF, async=True, timeout=None)
done, pending = yield from asyncio.wait(
[telnet_closed, server_closed],
loop=event_loop, timeout=1,
return_when=asyncio.ALL_COMPLETED)
assert not any(future.cancelled() for future in done), done
assert not pending, (telnet_closed, server_closed)
