def dataReceived(self, data):
"""
Handle incoming data over the wire.
This method will split the incoming data depending on if it
starts with IAC (a telnet command) or not. All other data will
be handled in line mode. Some clients also sends an erroneous
line break after IAC, which we must watch out for.
Args:
data (str): Incoming data.
Notes:
OOB protocols (MSDP etc) already intercept subnegotiations on
their own, never entering this method. They will relay their
parsed data directly to self.data_in.
"""
if data and data[0] == IAC or self.iaw_mode:
try:
super(TelnetProtocol, self).dataReceived(data)
if len(data) == 1:
self.iaw_mode = True
else:
self.iaw_mode = False
return
except Exception as err1:
conv = ""
try:
for b in data:
conv += " " + repr(ord(b))
except Exception as err2:
conv = str(err2) + ":", str(data)
out = "Telnet Error (%s): %s (%s)" % (err1, data, conv)
logger.log_trace(out)
return
if data and data.strip() == NULL:
# This is an ancient type of keepalive still used by some
# legacy clients. There should never be a reason to send
# a lone NULL character so this seems ok to support for
# backwards compatibility.
data = _IDLE_COMMAND
if self.no_lb_mode and _RE_LEND.search(data):
# we are in no_lb_mode and receive a line break;
# this means we should empty the buffer and send
# the command.
data = "".join(self.line_buffer) + data
data = data.rstrip("\r\n") + "\n"
self.line_buffer = []
self.no_lb_mode = False
elif not _RE_LEND.search(data):
# no line break at the end of the command, buffer instead.
self.line_buffer.append(data)
self.no_lb_mode = True
return
# if we get to this point the command should end with a linebreak.
StatefulTelnetProtocol.dataReceived(self, data)
def dataReceived(self, data):
"""
Handle incoming data over the wire.
This method will split the incoming data depending on if it
starts with IAC (a telnet command) or not. All other data will
be handled in line mode. Some clients also sends an erroneous
line break after IAC, which we must watch out for.
Args:
data (str): Incoming data.
Notes:
OOB protocols (MSDP etc) already intercept subnegotiations on
their own, never entering this method. They will relay their
parsed data directly to self.data_in.
"""
if data and data[0] == IAC or self.iaw_mode:
try:
super(TelnetProtocol, self).dataReceived(data)
if len(data) == 1:
self.iaw_mode = True
else:
self.iaw_mode = False
return
except Exception as err1:
conv = ""
try:
for b in data:
conv += " " + repr(ord(b))
except Exception as err2:
conv = str(err2) + ":", str(data)
out = "Telnet Error (%s): %s (%s)" % (err1, data, conv)
logger.log_trace(out)
return
if data and data.strip() == NULL:
# This is an ancient type of keepalive still used by some
# legacy clients. There should never be a reason to send
# a lone NULL character so this seems ok to support for
# backwards compatibility.
data = _IDLE_COMMAND
if self.no_lb_mode and _RE_LEND.search(data):
# we are in no_lb_mode and receive a line break;
# this means we should empty the buffer and send
# the command.
data = "".join(self.line_buffer) + data
data = data.rstrip("\r\n") + "\n"
self.line_buffer = []
self.no_lb_mode = False
elif not _RE_LEND.search(data):
# no line break at the end of the command, buffer instead.
self.line_buffer.append(data)
self.no_lb_mode = True
return
# if we get to this point the command should end with a linebreak.
StatefulTelnetProtocol.dataReceived(self, data)
def dataReceived(self, data):
"""
This method will split the incoming data depending on if it
starts with IAC (a telnet command) or not. All other data will
be handled in line mode. Some clients also sends an erroneous
line break after IAC, which we must watch out for.
"""
#print "dataRcv (%s):" % data,
#try:
# for b in data:
# print ord(b),
# print ""
#except Exception, e:
# print str(e) + ":", str(data)
if data and data[0] == IAC or self.iaw_mode:
try:
#print "IAC mode"
super(TelnetProtocol, self).dataReceived(data)
if len(data) == 1:
self.iaw_mode = True
else:
self.iaw_mode = False
return
except Exception:
logger.log_trace()
# if we get to this point the command must end with a linebreak.
# We make sure to add it, to fix some clients messing this up.
data = data.rstrip("\r\n") + "\n"
#print "line data in:", repr(data)
StatefulTelnetProtocol.dataReceived(self, data)
def connectionLost(self, reason):
print "Connection lost."
StatefulTelnetProtocol.connectionLost(self, reason)
try:
# noinspection PyUnresolvedReferences
reactor.stop()
except ReactorNotRunning:
pass
def dataReceived(self, data):
"""
Handle incoming data over the wire.
This method will split the incoming data depending on if it
starts with IAC (a telnet command) or not. All other data will
be handled in line mode. Some clients also sends an erroneous
line break after IAC, which we must watch out for.
Args:
data (str): Incoming data.
Notes:
OOB protocols (MSDP etc) already intercept subnegotiations on
their own, never entering this method. They will relay their
parsed data directly to self.data_in.
"""
if data and data[0] == IAC or self.iaw_mode:
try:
super(TelnetProtocol, self).dataReceived(data)
if len(data) == 1:
self.iaw_mode = True
else:
self.iaw_mode = False
return
except Exception as err1:
conv = ""
try:
for b in data:
conv += " " + repr(ord(b))
except Exception as err2:
conv = str(err2) + ":", str(data)
out = "Telnet Error (%s): %s (%s)" % (err1, data, conv)
logger.log_trace(out)
return
if self.no_lb_mode and _RE_LEND.match(data):
# we are in no_lb_mode and we get a single line break
# - this line break should have come with the previous
# command - it was already added so we drop it here
self.no_lb_mode = False
return
elif not _RE_LEND.search(data):
# no line break at the end of the command, note this.
data = data.rstrip("\r\n") + "\n"
self.no_lb_mode = True
# if we get to this point the command should end with a linebreak.
# We make sure to add it, to fix some clients messing this up.
StatefulTelnetProtocol.dataReceived(self, data)
def dataReceived(self, data):
"""
Handle incoming data over the wire.
This method will split the incoming data depending on if it
starts with IAC (a telnet command) or not. All other data will
be handled in line mode. Some clients also sends an erroneous
line break after IAC, which we must watch out for.
Args:
data (str): Incoming data.
Notes:
OOB protocols (MSDP etc) already intercept subnegotiations on
their own, never entering this method. They will relay their
parsed data directly to self.data_in.
"""
if data and data[0] == IAC or self.iaw_mode:
try:
super(TelnetProtocol, self).dataReceived(data)
if len(data) == 1:
self.iaw_mode = True
else:
self.iaw_mode = False
return
except Exception as err1:
conv = ""
try:
for b in data:
conv += " " + repr(ord(b))
except Exception as err2:
conv = str(err2) + ":", str(data)
out = "Telnet Error (%s): %s (%s)" % (err1, data, conv)
logger.log_trace(out)
return
if self.no_lb_mode and _RE_LEND.match(data):
# we are in no_lb_mode and we get a single line break
# - this line break should have come with the previous
# command - it was already added so we drop it here
self.no_lb_mode = False
return
elif not _RE_LEND.search(data):
# no line break at the end of the command, note this.
data = data.rstrip("\r\n") + "\n"
self.no_lb_mode = True
# if we get to this point the command should end with a linebreak.
# We make sure to add it, to fix some clients messing this up.
StatefulTelnetProtocol.dataReceived(self, data)
def connectionLost(self, reason):
StatefulTelnetProtocol.connectionLost(self, reason)
if self.from_addr is not None:
self.vumi_transport.deregister_client(self)
if self.no_lb_mode and _RE_LEND.match(data):
# we are in no_lb_mode and we get a single line break
# - this line break should have come with the previous
# command - it was already added so we drop it here
self.no_lb_mode = False
return
elif not _RE_LEND.search(data):
# no line break at the end of the command, note this.
data = data.rstrip("\r\n") + "\n"
self.no_lb_mode = True
# if we get to this point the command should end with a linebreak.
# We make sure to add it, to fix some clients messing this up.
#print "line data in:", repr(data)
StatefulTelnetProtocol.dataReceived(self, data)
def _write(self, data):
"hook overloading the one used in plain telnet"
# print "_write (%s): %s" % (self.state, " ".join(str(ord(c)) for c in data))
data = data.replace('\n', '\r\n').replace('\r\r\n', '\r\n')
#data = data.replace('\n', '\r\n')
super(TelnetProtocol, self)._write(mccp_compress(self, data))
def sendLine(self, line):
"hook overloading the one used by linereceiver"
#print "sendLine (%s):\n%s" % (self.state, line)
#escape IAC in line mode, and correctly add \r\n
line += self.delimiter
line = line.replace(IAC, IAC + IAC).replace('\n', '\r\n')
return self.transport.write(mccp_compress(self, line))
def lineReceived(self, p_line):
StatefulTelnetProtocol.lineReceived(self, p_line)
LOG.info('Line Received.\n\tData:{}'.format(p_line))
def connectionLost(self, reason):
StatefulTelnetProtocol.connectionLost(self, reason)
if self.from_addr is not None:
self.vumi_transport.deregister_client(self)
return
except Exception, err1:
conv = ""
try:
for b in data:
conv += " " + repr(ord(b))
except Exception, err2:
conv = str(err2) + ":", str(data)
out = "Telnet Error (%s): %s (%s)" % (err1, data, conv)
logger.log_trace(out)
return
# if we get to this point the command must end with a linebreak.
# We make sure to add it, to fix some clients messing this up.
data = data.rstrip("\r\n") + "\n"
#print "line data in:", repr(data)
StatefulTelnetProtocol.dataReceived(self, data)
def _write(self, data):
"hook overloading the one used in plain telnet"
# print "_write (%s): %s" % (self.state, " ".join(str(ord(c)) for c in data))
data = data.replace('\n', '\r\n').replace('\r\r\n', '\r\n')
#data = data.replace('\n', '\r\n')
super(TelnetProtocol, self)._write(mccp_compress(self, data))
def sendLine(self, line):
"hook overloading the one used by linereceiver"
#print "sendLine (%s):\n%s" % (self.state, line)
#escape IAC in line mode, and correctly add \r\n
line += self.delimiter
line = line.replace(IAC, IAC + IAC).replace('\n', '\r\n')
return self.transport.write(mccp_compress(self, line))
def sendLine(self, line):
# Override, perform filters and fall back to original functionality
StatefulTelnetProtocol.sendLine(self, line)
def unhandledSubnegotiation(self, command, by):
rr = StatefulTelnetProtocol.unhandledSubnegotiation(self, command, by)
logger.log("SUB NEG Command: %s %s" % (command, by))
return rr
