| # 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')) |