Lib/ftplib.py

# An FTP client class.  Based on RFC 959: File Transfer Protocol
# (FTP), by J. Postel and J. Reynolds


import os
import sys
import socket
import string


# Default port numbers used by the FTP protocol
FTP_PORT = 21
FTP_DATA_PORT = 20


# Exception raiseds when an error or invalid response is received
error_reply = 'nntp.error_reply'	# unexpected [123]xx reply
error_function = 'nntp.error_function'	# 4xx errors
error_form = 'nntp.error_form'		# 5xx errors
error_protocol = 'nntp.error_protocol'	# response does not begin with [1-5]


# Line terminators (we always output CRLF, but accept any of CRLF, CR, LF)
CRLF = '\r\n'


# Next port to be used by makeport(), with PORT_OFFSET added
nextport = 0
PORT_OFFSET = 40000
PORT_CYCLE = 1000
# XXX This is a nuisance: when using the program several times in a row,
# reusing the port doesn't work and you have to edit the first port
# assignment...


# The class itself
class FTP:

	# Initialize an instance.  Arguments:
	# - host: hostname to connect to
	# - port: port to connect to (default the standard FTP port)
	def init(self, host, *args):
		if len(args) > 1: raise TypeError, 'too many args'
		if args: port = args[0]
		else: port = FTP_PORT
		self.host = host
		self.port = port
		self.debugging = 0
		self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
		self.sock.connect(self.host, self.port)
		self.file = self.sock.makefile('r')
		self.welcome = self.getresp()
		return self

	# Get the welcome message from the server
	# (this is read and squirreled away by init())
	def getwelcome(self):
		if self.debugging: print '*welcome*', `self.welcome`
		return self.welcome

	# Set the debugging level.  Argument level means:
	# 0: no debugging output (default)
	# 1: print commands and responses but not body text etc.
	# 2: also print raw lines read and sent before stripping CR/LF
	def debug(self, level):
		self.debugging = level

	# Internal: send one line to the server, appending CRLF
	def putline(self, line):
		line = line + CRLF
		if self.debugging > 1: print '*put*', `line`
		self.sock.send(line)

	# Internal: send one command to the server (through putline())
	def putcmd(self, line):
		if self.debugging: print '*cmd*', `line`
		self.putline(line)

	# Internal: return one line from the server, stripping CRLF.
	# Raise EOFError if the connection is closed
	def getline(self):
		line = self.file.readline()
		if self.debugging > 1:
			print '*get*', `line`
		if not line: raise EOFError
		if line[-2:] == CRLF: line = line[:-2]
		elif line[-1:] in CRLF: line = line[:-1]
		return line

	# Internal: get a response from the server, which may possibly
	# consist of multiple lines.  Return a single string with no
	# trailing CRLF.  If the response consists of multiple lines,
	# these are separated by '\n' characters in the string
	def getmultiline(self):
		line = self.getline()
		if line[3:4] == '-':
			code = line[:3]
			while 1:
				nextline = self.getline()
				line = line + ('\n' + nextline)
				if nextline[:3] == code and \
					nextline[3:4] <> '-':
					break
		return line

	# Internal: get a response from the server.
	# Raise various errors if the response indicates an error
	def getresp(self):
		resp = self.getmultiline()
		if self.debugging: print '*resp*', `resp`
		self.lastresp = resp[:3]
		c = resp[:1]
		if c == '4':
			raise error_function, resp
		if c == '5':
			raise error_form, resp
		if c not in '123':
			raise error_protocol, resp
		return resp

	# Send a command and return the response
	def sendcmd(self, cmd):
		self.putcmd(cmd)
		return self.getresp()

	# Send a PORT command with the current host and the given port number
	def sendport(self, port):
		hostname = socket.gethostname()
		hostaddr = socket.gethostbyname(hostname)
		hbytes = string.splitfields(hostaddr, '.')
		pbytes = [`port/256`, `port%256`]
		bytes = hbytes + pbytes
		cmd = 'PORT ' + string.joinfields(bytes, ',')
		resp = self.sendcmd(cmd)
		if resp[:3] <> '200':
			raise error_reply, resp

	# Create a new socket and send a PORT command for it
	def makeport(self):
		global nextport
		port = nextport + PORT_OFFSET
		nextport = (nextport + 1) % PORT_CYCLE
		sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
		sock.bind('', port)
		sock.listen(0)
		resp = self.sendport(port)
		return sock

	# Retrieve data in binary mode.  (You must set the mode first.)
	# The argument is a RETR command.
	# The callback function is called for each block.
	# This creates a new port for you
	def retrbinary(self, cmd, callback, blocksize):
		sock = self.makeport()
		resp = self.sendcmd(cmd)
		if resp[0] <> '1':
			raise error_reply, resp
		conn, host = sock.accept()
		sock.close()
		while 1:
			data = conn.recv(blocksize)
			if not data:
				break
			callback(data)
		conn.close()
		resp = self.getresp()
		if resp[0] <> '2':
			raise error_reply, resp

	# Retrieve data in line mode.  (You must set the mode first.)
	# The argument is a RETR or LIST command.
	# The callback function is called for each line, with trailing
	# CRLF stripped.  This creates a new port for you
	def retrlines(self, cmd, callback):
		sock = self.makeport()
		resp = self.sendcmd(cmd)
		if resp[0] <> '1':
			raise error_reply, resp
		conn, host = sock.accept()
		sock.close()
		fp = conn.makefile('r')
		while 1:
			line = fp.readline()
			if not line:
				break
			if line[-2:] == CRLF:
				line = line[:-2]
			elif line[:-1] == '\n':
				line = line[:-1]
			callback(line)
		fp.close()
		conn.close()
		resp = self.getresp()
		if resp[0] <> '2':
			raise error_reply, resp

	# Login as user anonymous with given passwd (default user@thishost)
	def anonymouslogin(self, *args):
		resp = self.sendcmd('USER anonymous')
		if resp[0] == '3':
			if args:
				passwd = args[0]
			else:
				thishost = socket.gethostname()
				if os.environ.has_key('LOGNAME'):
					user = os.environ['LOGNAME']
				elif os.environ.has_key('USER'):
					user = os.environ['USER']
				else:
					user = 'anonymous'
				passwd = user + '@' + thishost
			resp = self.sendcmd('PASS ' + passwd)
		if resp[0] <> '2':
			raise error_reply, resp

	# Quit, and close the connection
	def quit(self):
		resp = self.sendcmd('QUIT')
		if resp[0] <> '2':
			raise error_reply, resp
		self.file.close()
		self.sock.close()


# Test program.
# Usage: ftp [-d] host [-l[dir]] [-d[dir]] [file] ...
def test():
	import marshal
	global nextport
	try:
		nextport = marshal.load(open('.@nextport', 'r'))
	except IOError:
		pass
	try:
		debugging = 0
		while sys.argv[1] == '-d':
			debugging = debugging+1
			del sys.argv[1]
		host = sys.argv[1]
		ftp = FTP().init(host)
		ftp.debug(debugging)
		ftp.anonymouslogin()
		def writeln(line): print line
		for file in sys.argv[2:]:
			if file[:2] == '-l':
				cmd = 'LIST'
				if file[2:]: cmd = cmd + ' ' + file[2:]
				ftp.retrlines(cmd, writeln)
			elif file[:2] == '-d':
				cmd = 'CWD'
				if file[2:]: cmd = cmd + ' ' + file[2:]
				resp = ftp.sendcmd(cmd)
			else:
				ftp.retrbinary('RETR ' + file, \
					       sys.stdout.write, 1024)
		ftp.quit()
	finally:
		marshal.dump(nextport, open('.@nextport', 'w'))