telnet.py without fork()

[deckerben]

Hello.


I need telnet.py to run in a single-tasking environment (i.e. without
posix.fork())for PythonD as a demo of the socketmodule. It seems that
socketmodule runs exactly as it should, but the terminal output is
sometimes a little confusing ... (i.e. CR needs to be pressed more
than normal)

As I still have limited experience with python itself (other than
porting it) and even less with socketmodule, I was hoping for a couple
pointers on how this could run better.

This is a non-forking telnet client for PythonD based on the
socket/telnet.py sample that accompanies the 2.2.1 source
distribution.

 
begin code:
##########################################################################
#! /usr/bin/env python

# Minimal interface to the Internet telnet protocol.
#
# It refuses all telnet options and does not recognize any of the
other
# telnet commands, but can still be used to connect in line-by-line
mode.
# It's also useful to play with a number of other services,
# like time, finger, smtp and even ftp.
#
# Usage: telnet host [port]
#
# The port may be a service name or a decimal port number;
# it defaults to 'telnet'.


import sys, nt, time
from socket import *

BUFSIZE = 1024

# Telnet protocol characters

IAC  = chr(255) # Interpret as command
DONT = chr(254)
DO   = chr(253)
WONT = chr(252)
WILL = chr(251)

def main():
	host = sys.argv[1]
	sock_bit = chr(66)
	try:
		hostaddr = gethostbyname(host)
	except error:
		sys.stderr.write(sys.argv[1] + ': bad host name\n')
		sys.exit(2)
	#
	if len(sys.argv) > 2:
		servname = sys.argv[2]
	else:
		servname = 'telnet'
	#
	if '0' <= servname[:1] <= '9':
		port = eval(servname)
	else:
		try:
			port = getservbyname(servname, 'tcp')
		except error:
			sys.stderr.write(servname + ': bad tcp service name\n')
			sys.exit(2)
	#
	s = socket(AF_INET, SOCK_STREAM)
	#
	try:
		s.connect((host, port))
	except error, msg:
		sys.stderr.write('connect failed: ' + `msg` + '\n')
		sys.exit(1)

	# parent -- read socket, write stdout
	while 1:
		def readsock(sock_bit):
			iac = 0         # Interpret next char as command
			opt = ''        # Interpret next char as option
			data = sock_bit + s.recv(BUFSIZE)
			# print ord(sock_bit) # for displaying test char
			cleandata = ''
			for c in data:
				if opt:
					print ord(c)
					s.send(opt + c)
					opt = ''
				elif iac:
					iac = 0
					if c == IAC:
						cleandata = cleandata + c
					elif c in (DO, DONT):
						if c == DO: print '(DO)',
						else: print '(DONT)',
						opt = IAC + WONT
					elif c in (WILL, WONT):
						if c == WILL: print '(WILL)',
						else: print '(WONT)',
						opt = IAC + DONT
					else:
						print '(command)', ord(c)
				elif c == IAC:
					iac = 1
					print '(IAC)',
				else:
					cleandata = cleandata + c
			sys.stdout.write(cleandata)
			sys.stdout.flush()

		def sendsock():
			line = sys.stdin.readline()
			s.send(line)

		sock_bit = s.recv(2)
		if sock_bit != '': readsock(sock_bit)
		sendsock()
		readsock('\n')
		
try:
	main()
except KeyboardInterrupt:
	pass

##############################################################################

As you can see, my biggest problem is finding a routine to smoothly
merge user input with output that is returned from the server. Does
anyone happen to know if there is a definite telnet character(s) that
signal the client terminal that user input is now required?

Is there perhaps a socketmodule function that would serve this
purpose?


Thanks
ben