diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | nyancat.c | 1 | ||||
| -rwxr-xr-x | nyancat.py | 30 | ||||
| -rw-r--r-- | telnetsrvlib.py | 776 |
4 files changed, 808 insertions, 0 deletions
@@ -1 +1,2 @@ nyancat +*.pyc @@ -827,6 +827,7 @@ char ** frames[] = { int main(int argc, char ** argv) { printf("\033[H\033[2J"); + fflush(stdout); try_again: printf("Select a mode:\n"); printf(" 1 xterm 256-color compatible mode (best)\n"); diff --git a/nyancat.py b/nyancat.py new file mode 100755 index 0000000..ebeb303 --- /dev/null +++ b/nyancat.py @@ -0,0 +1,30 @@ +#!/usr/bin/env python +import SocketServer +from subprocess import Popen, PIPE +from telnetsrvlib import TelnetHandler + +class TNS(SocketServer.TCPServer): + allow_reuse_address = True + +class TNH(TelnetHandler): + def handle(self): + print self.TERM + p = Popen(["./nyancat"], shell=False, stdout=PIPE, stdin=PIPE, bufsize=0) + if (self.TERM.lower().find("xterm") != -1): + p.stdin.write("1\n") + elif (self.TERM.lower().find("linux") != -1): + p.stdin.write("3\n") + elif (self.TERM.lower().find("fallback") != -1): + p.stdin.write("4\n") + else: + p.stdin.write("2\n") + while 1: + s = p.stdout.read(1) + try: + self.write(s) + except: + p.kill() + return + +tns = TNS(("0.0.0.0", 23), TNH) +tns.serve_forever() diff --git a/telnetsrvlib.py b/telnetsrvlib.py new file mode 100644 index 0000000..14b9b2f --- /dev/null +++ b/telnetsrvlib.py @@ -0,0 +1,776 @@ +#!/usr/bin/python +"""TELNET server class + +Based on the telnet client in telnetlib.py + +Presents a command line interface to the telnet client. +Various settings can affect the operation of the server: + + authCallback = Reference to authentication function. If + there is none, no un/pw is requested. Should + raise an exception if authentication fails + Default: None + authNeedUser = Should a username be requested? + Default: False + authNeedPass = Should a password be requested? + Default: False + COMMANDS = Dictionary of supported commands + Key = command (Must be upper case) + Value = List of (function, help text) + Function.__doc__ should be long help + Function.aliases may be a list of alternative spellings +""" + +#from telnetlib import IAC, WILL, WONT, DO, DONT, ECHO, SGA, Telnet +import threading +import SocketServer +import socket +import time +import sys +import traceback +import curses.ascii +import curses.has_key +import curses +import logging +import re +if not hasattr(socket, 'SHUT_RDWR'): + socket.SHUT_RDWR = 2 + +__all__ = ["TelnetHandler", "TelnetCLIHandler"] + +IAC = chr(255) # "Interpret As Command" +DONT = chr(254) +DO = chr(253) +WONT = chr(252) +WILL = chr(251) +theNULL = chr(0) + +SE = chr(240) # Subnegotiation End +NOP = chr(241) # No Operation +DM = chr(242) # Data Mark +BRK = chr(243) # Break +IP = chr(244) # Interrupt process +AO = chr(245) # Abort output +AYT = chr(246) # Are You There +EC = chr(247) # Erase Character +EL = chr(248) # Erase Line +GA = chr(249) # Go Ahead +SB = chr(250) # Subnegotiation Begin + +BINARY = chr(0) # 8-bit data path +ECHO = chr(1) # echo +RCP = chr(2) # prepare to reconnect +SGA = chr(3) # suppress go ahead +NAMS = chr(4) # approximate message size +STATUS = chr(5) # give status +TM = chr(6) # timing mark +RCTE = chr(7) # remote controlled transmission and echo +NAOL = chr(8) # negotiate about output line width +NAOP = chr(9) # negotiate about output page size +NAOCRD = chr(10) # negotiate about CR disposition +NAOHTS = chr(11) # negotiate about horizontal tabstops +NAOHTD = chr(12) # negotiate about horizontal tab disposition +NAOFFD = chr(13) # negotiate about formfeed disposition +NAOVTS = chr(14) # negotiate about vertical tab stops +NAOVTD = chr(15) # negotiate about vertical tab disposition +NAOLFD = chr(16) # negotiate about output LF disposition +XASCII = chr(17) # extended ascii character set +LOGOUT = chr(18) # force logout +BM = chr(19) # byte macro +DET = chr(20) # data entry terminal +SUPDUP = chr(21) # supdup protocol +SUPDUPOUTPUT = chr(22) # supdup output +SNDLOC = chr(23) # send location +TTYPE = chr(24) # terminal type +EOR = chr(25) # end or record +TUID = chr(26) # TACACS user identification +OUTMRK = chr(27) # output marking +TTYLOC = chr(28) # terminal location number +VT3270REGIME = chr(29) # 3270 regime +X3PAD = chr(30) # X.3 PAD +NAWS = chr(31) # window size +TSPEED = chr(32) # terminal speed +LFLOW = chr(33) # remote flow control +LINEMODE = chr(34) # Linemode option +XDISPLOC = chr(35) # X Display Location +OLD_ENVIRON = chr(36) # Old - Environment variables +AUTHENTICATION = chr(37) # Authenticate +ENCRYPT = chr(38) # Encryption option +NEW_ENVIRON = chr(39) # New - Environment variables +# the following ones come from +# http://www.iana.org/assignments/telnet-options +# Unfortunately, that document does not assign identifiers +# to all of them, so we are making them up +TN3270E = chr(40) # TN3270E +XAUTH = chr(41) # XAUTH +CHARSET = chr(42) # CHARSET +RSP = chr(43) # Telnet Remote Serial Port +COM_PORT_OPTION = chr(44) # Com Port Control Option +SUPPRESS_LOCAL_ECHO = chr(45) # Telnet Suppress Local Echo +TLS = chr(46) # Telnet Start TLS +KERMIT = chr(47) # KERMIT +SEND_URL = chr(48) # SEND-URL +FORWARD_X = chr(49) # FORWARD_X +PRAGMA_LOGON = chr(138) # TELOPT PRAGMA LOGON +SSPI_LOGON = chr(139) # TELOPT SSPI LOGON +PRAGMA_HEARTBEAT = chr(140) # TELOPT PRAGMA HEARTBEAT +EXOPL = chr(255) # Extended-Options-List +NOOPT = chr(0) + +#Codes used in SB SE data stream for terminal type negotiation +IS = chr(0) +SEND = chr(1) + +CMDS = { + WILL: 'WILL', + WONT: 'WONT', + DO: 'DO', + DONT: 'DONT', + SE: 'Subnegotiation End', + NOP: 'No Operation', + DM: 'Data Mark', + BRK: 'Break', + IP: 'Interrupt process', + AO: 'Abort output', + AYT: 'Are You There', + EC: 'Erase Character', + EL: 'Erase Line', + GA: 'Go Ahead', + SB: 'Subnegotiation Begin', + BINARY: 'Binary', + ECHO: 'Echo', + RCP: 'Prepare to reconnect', + SGA: 'Suppress Go-Ahead', + NAMS: 'Approximate message size', + STATUS: 'Give status', + TM: 'Timing mark', + RCTE: 'Remote controlled transmission and echo', + NAOL: 'Negotiate about output line width', + NAOP: 'Negotiate about output page size', + NAOCRD: 'Negotiate about CR disposition', + NAOHTS: 'Negotiate about horizontal tabstops', + NAOHTD: 'Negotiate about horizontal tab disposition', + NAOFFD: 'Negotiate about formfeed disposition', + NAOVTS: 'Negotiate about vertical tab stops', + NAOVTD: 'Negotiate about vertical tab disposition', + NAOLFD: 'Negotiate about output LF disposition', + XASCII: 'Extended ascii character set', + LOGOUT: 'Force logout', + BM: 'Byte macro', + DET: 'Data entry terminal', + SUPDUP: 'Supdup protocol', + SUPDUPOUTPUT: 'Supdup output', + SNDLOC: 'Send location', + TTYPE: 'Terminal type', + EOR: 'End or record', + TUID: 'TACACS user identification', + OUTMRK: 'Output marking', + TTYLOC: 'Terminal location number', + VT3270REGIME: '3270 regime', + X3PAD: 'X.3 PAD', + NAWS: 'Window size', + TSPEED: 'Terminal speed', + LFLOW: 'Remote flow control', + LINEMODE: 'Linemode option', + XDISPLOC: 'X Display Location', + OLD_ENVIRON: 'Old - Environment variables', + AUTHENTICATION: 'Authenticate', + ENCRYPT: 'Encryption option', + NEW_ENVIRON: 'New - Environment variables', +} + +class TelnetHandler(SocketServer.BaseRequestHandler): + "A telnet server based on the client in telnetlib" + + # What I am prepared to do? + DOACK = { + ECHO: WILL, + SGA: WILL, + NEW_ENVIRON: WONT, + } + # What do I want the client to do? + WILLACK = { + ECHO: DONT, + SGA: DO, + NAWS: DONT, + TTYPE: DO, + LINEMODE: DONT, + NEW_ENVIRON: DO, + } + # Default terminal type - used if client doesn't tell us its termtype + TERM = "ansi" + # Keycode to name mapping - used to decide which keys to query + KEYS = { # Key escape sequences + curses.KEY_UP: 'Up', # Cursor up + curses.KEY_DOWN: 'Down', # Cursor down + curses.KEY_LEFT: 'Left', # Cursor left + curses.KEY_RIGHT: 'Right', # Cursor right + curses.KEY_DC: 'Delete', # Delete right + curses.KEY_BACKSPACE: 'Backspace', # Delete left + } + # Reverse mapping of KEYS - used for cooking key codes + ESCSEQ = { + } + # Terminal output escape sequences + CODES = { + 'DEOL': '', # Delete to end of line + 'DEL': '', # Delete and close up + 'INS': '', # Insert space + 'CSRLEFT': '', # Move cursor left 1 space + 'CSRRIGHT': '', # Move cursor right 1 space + } + # What prompt to display + PROMPT = "Telnet Server> " + # The function to call to verify authentication data + authCallback = None + # Does authCallback want a username? + authNeedUser = False + # Does authCallback want a password? + authNeedPass = False + +# --------------------------- Environment Setup ---------------------------- + + def __init__(self, request, client_address, server): + """Constructor. + + When called without arguments, create an unconnected instance. + With a hostname argument, it connects the instance; a port + number is optional. + """ + # Am I doing the echoing? + self.DOECHO = True + # What opts have I sent DO/DONT for and what did I send? + self.DOOPTS = {} + # What opts have I sent WILL/WONT for and what did I send? + self.WILLOPTS = {} + # What commands does this CLI support + self.COMMANDS = {} + self.sock = None # TCP socket + self.rawq = '' # Raw input string + self.cookedq = [] # This is the cooked input stream (list of charcodes) + self.sbdataq = '' # Sub-Neg string + self.eof = 0 # Has EOF been reached? + self.iacseq = '' # Buffer for IAC sequence. + self.sb = 0 # Flag for SB and SE sequence. + self.history = [] # Command history + self.IQUEUELOCK = threading.Lock() + self.OQUEUELOCK = threading.Lock() + self.RUNSHELL = True + # A little magic - Everything called cmdXXX is a command + for k in dir(self): + if k[:3] == 'cmd': + name = k[3:] + method = getattr(self, k) + self.COMMANDS[name] = method + for alias in getattr(method, "aliases", []): + self.COMMANDS[alias] = self.COMMANDS[name] + SocketServer.BaseRequestHandler.__init__(self, request, client_address, server) + + def setterm(self, term): + "Set the curses structures for this terminal" + logging.debug("Setting termtype to %s" % (term, )) + curses.setupterm(term) # This will raise if the termtype is not supported + self.TERM = term + self.ESCSEQ = {} + for k in self.KEYS.keys(): + str = curses.tigetstr(curses.has_key._capability_names[k]) + if str: + self.ESCSEQ[str] = k + self.CODES['DEOL'] = curses.tigetstr('el') + self.CODES['DEL'] = curses.tigetstr('dch1') + self.CODES['INS'] = curses.tigetstr('ich1') + self.CODES['CSRLEFT'] = curses.tigetstr('cub1') + self.CODES['CSRRIGHT'] = curses.tigetstr('cuf1') + + def setup(self): + "Connect incoming connection to a telnet session" + self.setterm(self.TERM) + self.sock = self.request._sock + for k in self.DOACK.keys(): + self.sendcommand(self.DOACK[k], k) + for k in self.WILLACK.keys(): + self.sendcommand(self.WILLACK[k], k) + self.thread_ic = threading.Thread(target=self.inputcooker) + self.thread_ic.setDaemon(True) + self.thread_ic.start() + # Sleep for 0.5 second to allow options negotiation + time.sleep(0.5) + + def finish(self): + "End this session" + self.sock.shutdown(socket.SHUT_RDWR) + +# ------------------------- Telnet Options Engine -------------------------- + + def options_handler(self, sock, cmd, opt): + "Negotiate options" +# if CMDS.has_key(cmd): +# cmdtxt = CMDS[cmd] +# else: +# cmdtxt = "cmd:%d" % ord(cmd) +# if cmd in [WILL, WONT, DO, DONT]: +# if CMDS.has_key(opt): +# opttxt = CMDS[opt] +# else: +# opttxt = "opt:%d" % ord(opt) +# else: +# opttxt = "" +# logging.debug("OPTION: %s %s" % (cmdtxt, opttxt, )) + if cmd == NOP: + self.sendcommand(NOP) + elif cmd == WILL or cmd == WONT: + if self.WILLACK.has_key(opt): + self.sendcommand(self.WILLACK[opt], opt) + else: + self.sendcommand(DONT, opt) + if cmd == WILL and opt == TTYPE: + self.writecooked(IAC + SB + TTYPE + SEND + IAC + SE) + elif cmd == DO or cmd == DONT: + if self.DOACK.has_key(opt): + self.sendcommand(self.DOACK[opt], opt) + else: + self.sendcommand(WONT, opt) + if opt == ECHO: + self.DOECHO = (cmd == DO) + elif cmd == SE: + subreq = self.read_sb_data() + if subreq[0] == TTYPE and subreq[1] == IS: + try: + self.setterm(subreq[2:]) + except: + logging.debug("Terminal type not known") + elif cmd == SB: + pass + else: + logging.debug("Unhandled option: %s %s" % (cmdtxt, opttxt, )) + + def sendcommand(self, cmd, opt=None): + "Send a telnet command (IAC)" +# if CMDS.has_key(cmd): +# cmdtxt = CMDS[cmd] +# else: +# cmdtxt = "cmd:%d" % ord(cmd) +# if opt == None: +# opttxt = '' +# else: +# if CMDS.has_key(opt): +# opttxt = CMDS[opt] +# else: +# opttxt = "opt:%d" % ord(opt) + if cmd in [DO, DONT]: + if not self.DOOPTS.has_key(opt): + self.DOOPTS[opt] = None + if (((cmd == DO) and (self.DOOPTS[opt] != True)) + or ((cmd == DONT) and (self.DOOPTS[opt] != False))): +# logging.debug("Sending %s %s" % (cmdtxt, opttxt, )) + self.DOOPTS[opt] = (cmd == DO) + self.writecooked(IAC + cmd + opt) +# else: +# logging.debug("Not resending %s %s" % (cmdtxt, opttxt, )) + elif cmd in [WILL, WONT]: + if not self.WILLOPTS.has_key(opt): + self.WILLOPTS[opt] = '' + if (((cmd == WILL) and (self.WILLOPTS[opt] != True)) + or ((cmd == WONT) and (self.WILLOPTS[opt] != False))): +# logging.debug("Sending %s %s" % (cmdtxt, opttxt, )) + self.WILLOPTS[opt] = (cmd == WILL) + self.writecooked(IAC + cmd + opt) +# else: +# logging.debug("Not resending %s %s" % (cmdtxt, opttxt, )) + else: + self.writecooked(IAC + cmd) + + def read_sb_data(self): + """Return any data available in the SB ... SE queue. + + Return '' if no SB ... SE available. Should only be called + after seeing a SB or SE command. When a new SB command is + found, old unread SB data will be discarded. Don't block. + + """ + buf = self.sbdataq + self.sbdataq = '' + return buf + +# ---------------------------- Input Functions ----------------------------- + + def _readline_echo(self, char, echo): + """Echo a recieved character, move cursor etc...""" + if echo == True or (echo == None and self.DOECHO == True): + self.write(char) + + def readline(self, echo=None): + """Return a line of text, including the terminating LF + If echo is true always echo, if echo is false never echo + If echo is None follow the negotiated setting. + """ + line = [] + insptr = 0 + histptr = len(self.history) + while True: + c = self.getc(block=True) + if c == theNULL: + continue + elif c == curses.KEY_LEFT: + if insptr > 0: + insptr = insptr - 1 + self._readline_echo(self.CODES['CSRLEFT'], echo) + else: + self._readline_echo(chr(7), echo) + continue + elif c == curses.KEY_RIGHT: + if insptr < len(line): + insptr = insptr + 1 + self._readline_echo(self.CODES['CSRRIGHT'], echo) + else: + self._readline_echo(chr(7), echo) + continue + elif c == curses.KEY_UP or c == curses.KEY_DOWN: + if c == curses.KEY_UP: + if histptr > 0: + histptr = histptr - 1 + else: + self._readline_echo(chr(7), echo) + continue + elif c == curses.KEY_DOWN: + if histptr < len(self.history): + histptr = histptr + 1 + else: + self._readline_echo(chr(7), echo) + continue + line = [] + if histptr < len(self.history): + line.extend(self.history[histptr]) + for char in range(insptr): + self._readline_echo(self.CODES['CSRLEFT'], echo) + self._readline_echo(self.CODES['DEOL'], echo) + self._readline_echo(''.join(line), echo) + insptr = len(line) + continue + elif c == chr(3): + self._readline_echo('\n' + curses.ascii.unctrl(c) + ' ABORT\n', echo) + return '' + elif c == chr(4): + if len(line) > 0: + self._readline_echo('\n' + curses.ascii.unctrl(c) + ' ABORT (QUIT)\n', echo) + return '' + self._readline_echo('\n' + curses.ascii.unctrl(c) + ' QUIT\n', echo) + return 'QUIT' + elif c == chr(10): + self._readline_echo(c, echo) + if echo == True or (echo == None and self.DOECHO == True): + self.history.append(line) + return ''.join(line) + elif c == curses.KEY_BACKSPACE or c == chr(127) or c == chr(8): + if insptr > 0: + self._readline_echo(self.CODES['CSRLEFT'] + self.CODES['DEL'], echo) + insptr = insptr - 1 + del line[insptr] + else: + self._readline_echo(chr(7), echo) + continue + elif c == curses.KEY_DC: + if insptr < len(line): + self._readline_echo(self.CODES['DEL'], echo) + del line[insptr] + else: + self._readline_echo(chr(7), echo) + continue + else: + if ord(c) < 32: + c = curses.ascii.unctrl(c) + self._readline_echo(c, echo) + line[insptr:insptr] = c + insptr = insptr + len(c) + + def getc(self, block=True): + """Return one character from the input queue""" + if not block: + if not len(self.cookedq): + return '' + while not len(self.cookedq): + time.sleep(0.05) + self.IQUEUELOCK.acquire() + ret = self.cookedq[0] + self.cookedq = self.cookedq[1:] + self.IQUEUELOCK.release() + return ret + +# --------------------------- Output Functions ----------------------------- + + def writeline(self, text): + """Send a packet with line ending.""" + self.write(text+chr(10)) + + def write(self, text): + """Send a packet to the socket. This function cooks output.""" + text = text.replace(IAC, IAC+IAC) + text = text.replace(chr(10), chr(13)+chr(10)) + self.writecooked(text) + + def writecooked(self, text): + """Put data directly into the output queue (bypass output cooker)""" + self.OQUEUELOCK.acquire() + self.sock.sendall(text) + self.OQUEUELOCK.release() + +# ------------------------------- Input Cooker ----------------------------- + + def _inputcooker_getc(self, block=True): + """Get one character from the raw queue. Optionally blocking. + Raise EOFError on end of stream. SHOULD ONLY BE CALLED FROM THE + INPUT COOKER.""" + if self.rawq: + ret = self.rawq[0] + self.rawq = self.rawq[1:] + return ret + if not block: + if select.select([self.sock.fileno()], [], [], 0) == ([], [], []): + return '' + ret = self.sock.recv(20) + self.eof = not(ret) + self.rawq = self.rawq + ret + if self.eof: + raise EOFError + return self._inputcooker_getc(block) + + def _inputcooker_ungetc(self, char): + """Put characters back onto the head of the rawq. SHOULD ONLY + BE CALLED FROM THE INPUT COOKER.""" + self.rawq = char + self.rawq + + def _inputcooker_store(self, char): + """Put the cooked data in the correct queue (with locking)""" + if self.sb: + self.sbdataq = self.sbdataq + char + else: + self.IQUEUELOCK.acquire() + if type(char) in [type(()), type([]), type("")]: + for v in char: + self.cookedq.append(v) + else: + self.cookedq.append(char) + self.IQUEUELOCK.release() + + def inputcooker(self): + """Input Cooker - Transfer from raw queue to cooked queue. + + Set self.eof when connection is closed. Don't block unless in + the midst of an IAC sequence. + """ + try: + while True: + c = self._inputcooker_getc() + if not self.iacseq: + if c == IAC: + self.iacseq += c + continue + elif c == chr(13) and not(self.sb): + c2 = self._inputcooker_getc(block=False) + if c2 == theNULL or c2 == '': + c = chr(10) + elif c2 == chr(10): + c = c2 + else: + self._inputcooker_ungetc(c2) + c = chr(10) + elif c in [x[0] for x in self.ESCSEQ.keys()]: + 'Looks like the begining of a key sequence' + codes = c + for keyseq in self.ESCSEQ.keys(): + if len(keyseq) == 0: + continue + while codes == keyseq[:len(codes)] and len(codes) <= keyseq: + if codes == keyseq: + c = self.ESCSEQ[keyseq] + break + codes = codes + self._inputcooker_getc() + if codes == keyseq: + break + self._inputcooker_ungetc(codes[1:]) + codes = codes[0] + self._inputcooker_store(c) + elif len(self.iacseq) == 1: + 'IAC: IAC CMD [OPTION only for WILL/WONT/DO/DONT]' + if c in (DO, DONT, WILL, WONT): + self.iacseq += c + continue + self.iacseq = '' + if c == IAC: + self._inputcooker_store(c) + else: + if c == SB: # SB ... SE start. + self.sb = 1 + self.sbdataq = '' + # continue + elif c == SE: # SB ... SE end. + self.sb = 0 + # Callback is supposed to look into + # the sbdataq + self.options_handler(self.sock, c, NOOPT) + elif len(self.iacseq) == 2: + cmd = self.iacseq[1] + self.iacseq = '' + if cmd in (DO, DONT, WILL, WONT): + self.options_handler(self.sock, cmd, c) + except EOFError: + pass + +# ------------------------------- Basic Commands --------------------------- + +# Format of docstrings for command methods: +# Line 0: Command paramater(s) if any. (Can be blank line) +# Line 1: Short descriptive text. (Mandatory) +# Line 2+: Long descriptive text. (Can be blank line) + + def cmdHELP(self, params): + """[<command>] + Display help + Display either brief help on all commands, or detailed + help on a single command passed as a parameter. + """ + if params: + cmd = params[0].upper() + if self.COMMANDS.has_key(cmd): + method = self.COMMANDS[cmd] + doc = method.__doc__.split("\n") + docp = doc[0].strip() + docl = '\n'.join(doc[2:]).replace("\n\t\t", " ").replace("\t", "").strip() + if len(docl) < 4: + docl = doc[1].strip() + self.writeline( + "%s %s\n\n%s" % ( + cmd, + docp, + docl, + ) + ) + return + else: + self.writeline("Command '%s' not known" % cmd) + else: + self.writeline("Help on built in commands\n") + keys = self.COMMANDS.keys() + keys.sort() + for cmd in keys: + method = self.COMMANDS[cmd] + doc = method.__doc__.split("\n") + docp = doc[0].strip() + docs = doc[1].strip() + if len(docp) > 0: + docps = "%s - %s" % (docp, docs, ) + else: + docps = "- %s" % (docs, ) + self.writeline( + "%s %s" % ( + cmd, + docps, + ) + ) + cmdHELP.aliases = ['?'] + + def cmdEXIT(self, params): + """ + Exit the command shell + """ + self.RUNSHELL = False + self.writeline("Goodbye") + cmdEXIT.aliases = ['QUIT', 'BYE', 'LOGOUT'] + + def cmdDEBUG(self, params): + """ + Display some debugging data + """ + for (v,k) in self.ESCSEQ.items(): + line = '%-10s : ' % (self.KEYS[k], ) + for c in v: + if ord(c)<32 or ord(c)>126: + line = line + curses.ascii.unctrl(c) + else: + line = line + c + self.writeline(line) + + def cmdHISTORY(self, params): + """ + Display the command history + """ + cnt = 0 + self.writeline('Command history\n') + for line in self.history: + cnt = cnt + 1 + self.writeline("%-5d : %s" % (cnt, ''.join(line))) + +# ----------------------- Command Line Processor Engine -------------------- + + def handleException(self, exc_type, exc_param, exc_tb): + "Exception handler (False to abort)" + self.writeline(traceback.format_exception_only(exc_type, exc_param)[-1]) + return True + + def handle(self): + "The actual service to which the user has connected." + username = None + password = None + if self.authCallback: + if self.authNeedUser: + if self.DOECHO: + self.write("Username: ") + username = self.readline() + if self.authNeedPass: + if self.DOECHO: + self.write("Password: ") + password = self.readline(echo=False) + if self.DOECHO: + self.write("\n") + try: + self.authCallback(username, password) + except: + return + while self.RUNSHELL: + if self.DOECHO: + self.write(self.PROMPT) + cmdlist = [item.strip() for item in self.readline().split()] + idx = 0 + while idx < (len(cmdlist) - 1): + if cmdlist[idx][0] in ["'", '"']: + cmdlist[idx] = cmdlist[idx] + " " + cmdlist.pop(idx+1) + if cmdlist[idx][0] != cmdlist[idx][-1]: + continue + cmdlist[idx] = cmdlist[idx][1:-1] + idx = idx + 1 + if cmdlist: + cmd = cmdlist[0].upper() + params = cmdlist[1:] + if self.COMMANDS.has_key(cmd): + try: + self.COMMANDS[cmd](params) + except: + (t, p, tb) = sys.exc_info() + if self.handleException(t, p, tb): + break + else: + self.write("Unknown command '%s'\n" % cmd) + logging.debug("Exiting handler") + +if __name__ == '__main__': + "Testing - Accept a single connection" + class TNS(SocketServer.TCPServer): + allow_reuse_address = True + + class TNH(TelnetHandler): + def cmdECHO(self, params): + """ [<arg> ...] + Echo parameters + Echo command line parameters back to user, one per line. + """ + self.writeline("Parameters:") + for item in params: + self.writeline("\t%s" % item) + + logging.getLogger('').setLevel(logging.DEBUG) + + tns = TNS(("0.0.0.0", 23), TNH) + tns.serve_forever() + +# vim: set syntax=python ai showmatch: + |