Commit | Line | Data |
---|---|---|
920dae64 AT |
1 | """An FTP client class and some helper functions. |
2 | ||
3 | Based on RFC 959: File Transfer Protocol (FTP), by J. Postel and J. Reynolds | |
4 | ||
5 | Example: | |
6 | ||
7 | >>> from ftplib import FTP | |
8 | >>> ftp = FTP('ftp.python.org') # connect to host, default port | |
9 | >>> ftp.login() # default, i.e.: user anonymous, passwd anonymous@ | |
10 | '230 Guest login ok, access restrictions apply.' | |
11 | >>> ftp.retrlines('LIST') # list directory contents | |
12 | total 9 | |
13 | drwxr-xr-x 8 root wheel 1024 Jan 3 1994 . | |
14 | drwxr-xr-x 8 root wheel 1024 Jan 3 1994 .. | |
15 | drwxr-xr-x 2 root wheel 1024 Jan 3 1994 bin | |
16 | drwxr-xr-x 2 root wheel 1024 Jan 3 1994 etc | |
17 | d-wxrwxr-x 2 ftp wheel 1024 Sep 5 13:43 incoming | |
18 | drwxr-xr-x 2 root wheel 1024 Nov 17 1993 lib | |
19 | drwxr-xr-x 6 1094 wheel 1024 Sep 13 19:07 pub | |
20 | drwxr-xr-x 3 root wheel 1024 Jan 3 1994 usr | |
21 | -rw-r--r-- 1 root root 312 Aug 1 1994 welcome.msg | |
22 | '226 Transfer complete.' | |
23 | >>> ftp.quit() | |
24 | '221 Goodbye.' | |
25 | >>> | |
26 | ||
27 | A nice test that reveals some of the network dialogue would be: | |
28 | python ftplib.py -d localhost -l -p -l | |
29 | """ | |
30 | ||
31 | # | |
32 | # Changes and improvements suggested by Steve Majewski. | |
33 | # Modified by Jack to work on the mac. | |
34 | # Modified by Siebren to support docstrings and PASV. | |
35 | # | |
36 | ||
37 | import os | |
38 | import sys | |
39 | ||
40 | # Import SOCKS module if it exists, else standard socket module socket | |
41 | try: | |
42 | import SOCKS; socket = SOCKS; del SOCKS # import SOCKS as socket | |
43 | from socket import getfqdn; socket.getfqdn = getfqdn; del getfqdn | |
44 | except ImportError: | |
45 | import socket | |
46 | ||
47 | __all__ = ["FTP","Netrc"] | |
48 | ||
49 | # Magic number from <socket.h> | |
50 | MSG_OOB = 0x1 # Process data out of band | |
51 | ||
52 | ||
53 | # The standard FTP server control port | |
54 | FTP_PORT = 21 | |
55 | ||
56 | ||
57 | # Exception raised when an error or invalid response is received | |
58 | class Error(Exception): pass | |
59 | class error_reply(Error): pass # unexpected [123]xx reply | |
60 | class error_temp(Error): pass # 4xx errors | |
61 | class error_perm(Error): pass # 5xx errors | |
62 | class error_proto(Error): pass # response does not begin with [1-5] | |
63 | ||
64 | ||
65 | # All exceptions (hopefully) that may be raised here and that aren't | |
66 | # (always) programming errors on our side | |
67 | all_errors = (Error, socket.error, IOError, EOFError) | |
68 | ||
69 | ||
70 | # Line terminators (we always output CRLF, but accept any of CRLF, CR, LF) | |
71 | CRLF = '\r\n' | |
72 | ||
73 | ||
74 | # The class itself | |
75 | class FTP: | |
76 | ||
77 | '''An FTP client class. | |
78 | ||
79 | To create a connection, call the class using these argument: | |
80 | host, user, passwd, acct | |
81 | These are all strings, and have default value ''. | |
82 | Then use self.connect() with optional host and port argument. | |
83 | ||
84 | To download a file, use ftp.retrlines('RETR ' + filename), | |
85 | or ftp.retrbinary() with slightly different arguments. | |
86 | To upload a file, use ftp.storlines() or ftp.storbinary(), | |
87 | which have an open file as argument (see their definitions | |
88 | below for details). | |
89 | The download/upload functions first issue appropriate TYPE | |
90 | and PORT or PASV commands. | |
91 | ''' | |
92 | ||
93 | debugging = 0 | |
94 | host = '' | |
95 | port = FTP_PORT | |
96 | sock = None | |
97 | file = None | |
98 | welcome = None | |
99 | passiveserver = 1 | |
100 | ||
101 | # Initialization method (called by class instantiation). | |
102 | # Initialize host to localhost, port to standard ftp port | |
103 | # Optional arguments are host (for connect()), | |
104 | # and user, passwd, acct (for login()) | |
105 | def __init__(self, host='', user='', passwd='', acct=''): | |
106 | if host: | |
107 | self.connect(host) | |
108 | if user: self.login(user, passwd, acct) | |
109 | ||
110 | def connect(self, host = '', port = 0): | |
111 | '''Connect to host. Arguments are: | |
112 | - host: hostname to connect to (string, default previous host) | |
113 | - port: port to connect to (integer, default previous port)''' | |
114 | if host: self.host = host | |
115 | if port: self.port = port | |
116 | msg = "getaddrinfo returns an empty list" | |
117 | for res in socket.getaddrinfo(self.host, self.port, 0, socket.SOCK_STREAM): | |
118 | af, socktype, proto, canonname, sa = res | |
119 | try: | |
120 | self.sock = socket.socket(af, socktype, proto) | |
121 | self.sock.connect(sa) | |
122 | except socket.error, msg: | |
123 | if self.sock: | |
124 | self.sock.close() | |
125 | self.sock = None | |
126 | continue | |
127 | break | |
128 | if not self.sock: | |
129 | raise socket.error, msg | |
130 | self.af = af | |
131 | self.file = self.sock.makefile('rb') | |
132 | self.welcome = self.getresp() | |
133 | return self.welcome | |
134 | ||
135 | def getwelcome(self): | |
136 | '''Get the welcome message from the server. | |
137 | (this is read and squirreled away by connect())''' | |
138 | if self.debugging: | |
139 | print '*welcome*', self.sanitize(self.welcome) | |
140 | return self.welcome | |
141 | ||
142 | def set_debuglevel(self, level): | |
143 | '''Set the debugging level. | |
144 | The required argument level means: | |
145 | 0: no debugging output (default) | |
146 | 1: print commands and responses but not body text etc. | |
147 | 2: also print raw lines read and sent before stripping CR/LF''' | |
148 | self.debugging = level | |
149 | debug = set_debuglevel | |
150 | ||
151 | def set_pasv(self, val): | |
152 | '''Use passive or active mode for data transfers. | |
153 | With a false argument, use the normal PORT mode, | |
154 | With a true argument, use the PASV command.''' | |
155 | self.passiveserver = val | |
156 | ||
157 | # Internal: "sanitize" a string for printing | |
158 | def sanitize(self, s): | |
159 | if s[:5] == 'pass ' or s[:5] == 'PASS ': | |
160 | i = len(s) | |
161 | while i > 5 and s[i-1] in '\r\n': | |
162 | i = i-1 | |
163 | s = s[:5] + '*'*(i-5) + s[i:] | |
164 | return repr(s) | |
165 | ||
166 | # Internal: send one line to the server, appending CRLF | |
167 | def putline(self, line): | |
168 | line = line + CRLF | |
169 | if self.debugging > 1: print '*put*', self.sanitize(line) | |
170 | self.sock.sendall(line) | |
171 | ||
172 | # Internal: send one command to the server (through putline()) | |
173 | def putcmd(self, line): | |
174 | if self.debugging: print '*cmd*', self.sanitize(line) | |
175 | self.putline(line) | |
176 | ||
177 | # Internal: return one line from the server, stripping CRLF. | |
178 | # Raise EOFError if the connection is closed | |
179 | def getline(self): | |
180 | line = self.file.readline() | |
181 | if self.debugging > 1: | |
182 | print '*get*', self.sanitize(line) | |
183 | if not line: raise EOFError | |
184 | if line[-2:] == CRLF: line = line[:-2] | |
185 | elif line[-1:] in CRLF: line = line[:-1] | |
186 | return line | |
187 | ||
188 | # Internal: get a response from the server, which may possibly | |
189 | # consist of multiple lines. Return a single string with no | |
190 | # trailing CRLF. If the response consists of multiple lines, | |
191 | # these are separated by '\n' characters in the string | |
192 | def getmultiline(self): | |
193 | line = self.getline() | |
194 | if line[3:4] == '-': | |
195 | code = line[:3] | |
196 | while 1: | |
197 | nextline = self.getline() | |
198 | line = line + ('\n' + nextline) | |
199 | if nextline[:3] == code and \ | |
200 | nextline[3:4] != '-': | |
201 | break | |
202 | return line | |
203 | ||
204 | # Internal: get a response from the server. | |
205 | # Raise various errors if the response indicates an error | |
206 | def getresp(self): | |
207 | resp = self.getmultiline() | |
208 | if self.debugging: print '*resp*', self.sanitize(resp) | |
209 | self.lastresp = resp[:3] | |
210 | c = resp[:1] | |
211 | if c in ('1', '2', '3'): | |
212 | return resp | |
213 | if c == '4': | |
214 | raise error_temp, resp | |
215 | if c == '5': | |
216 | raise error_perm, resp | |
217 | raise error_proto, resp | |
218 | ||
219 | def voidresp(self): | |
220 | """Expect a response beginning with '2'.""" | |
221 | resp = self.getresp() | |
222 | if resp[0] != '2': | |
223 | raise error_reply, resp | |
224 | return resp | |
225 | ||
226 | def abort(self): | |
227 | '''Abort a file transfer. Uses out-of-band data. | |
228 | This does not follow the procedure from the RFC to send Telnet | |
229 | IP and Synch; that doesn't seem to work with the servers I've | |
230 | tried. Instead, just send the ABOR command as OOB data.''' | |
231 | line = 'ABOR' + CRLF | |
232 | if self.debugging > 1: print '*put urgent*', self.sanitize(line) | |
233 | self.sock.sendall(line, MSG_OOB) | |
234 | resp = self.getmultiline() | |
235 | if resp[:3] not in ('426', '226'): | |
236 | raise error_proto, resp | |
237 | ||
238 | def sendcmd(self, cmd): | |
239 | '''Send a command and return the response.''' | |
240 | self.putcmd(cmd) | |
241 | return self.getresp() | |
242 | ||
243 | def voidcmd(self, cmd): | |
244 | """Send a command and expect a response beginning with '2'.""" | |
245 | self.putcmd(cmd) | |
246 | return self.voidresp() | |
247 | ||
248 | def sendport(self, host, port): | |
249 | '''Send a PORT command with the current host and the given | |
250 | port number. | |
251 | ''' | |
252 | hbytes = host.split('.') | |
253 | pbytes = [repr(port/256), repr(port%256)] | |
254 | bytes = hbytes + pbytes | |
255 | cmd = 'PORT ' + ','.join(bytes) | |
256 | return self.voidcmd(cmd) | |
257 | ||
258 | def sendeprt(self, host, port): | |
259 | '''Send a EPRT command with the current host and the given port number.''' | |
260 | af = 0 | |
261 | if self.af == socket.AF_INET: | |
262 | af = 1 | |
263 | if self.af == socket.AF_INET6: | |
264 | af = 2 | |
265 | if af == 0: | |
266 | raise error_proto, 'unsupported address family' | |
267 | fields = ['', repr(af), host, repr(port), ''] | |
268 | cmd = 'EPRT ' + '|'.join(fields) | |
269 | return self.voidcmd(cmd) | |
270 | ||
271 | def makeport(self): | |
272 | '''Create a new socket and send a PORT command for it.''' | |
273 | msg = "getaddrinfo returns an empty list" | |
274 | sock = None | |
275 | for res in socket.getaddrinfo(None, 0, self.af, socket.SOCK_STREAM, 0, socket.AI_PASSIVE): | |
276 | af, socktype, proto, canonname, sa = res | |
277 | try: | |
278 | sock = socket.socket(af, socktype, proto) | |
279 | sock.bind(sa) | |
280 | except socket.error, msg: | |
281 | if sock: | |
282 | sock.close() | |
283 | sock = None | |
284 | continue | |
285 | break | |
286 | if not sock: | |
287 | raise socket.error, msg | |
288 | sock.listen(1) | |
289 | port = sock.getsockname()[1] # Get proper port | |
290 | host = self.sock.getsockname()[0] # Get proper host | |
291 | if self.af == socket.AF_INET: | |
292 | resp = self.sendport(host, port) | |
293 | else: | |
294 | resp = self.sendeprt(host, port) | |
295 | return sock | |
296 | ||
297 | def makepasv(self): | |
298 | if self.af == socket.AF_INET: | |
299 | host, port = parse227(self.sendcmd('PASV')) | |
300 | else: | |
301 | host, port = parse229(self.sendcmd('EPSV'), self.sock.getpeername()) | |
302 | return host, port | |
303 | ||
304 | def ntransfercmd(self, cmd, rest=None): | |
305 | """Initiate a transfer over the data connection. | |
306 | ||
307 | If the transfer is active, send a port command and the | |
308 | transfer command, and accept the connection. If the server is | |
309 | passive, send a pasv command, connect to it, and start the | |
310 | transfer command. Either way, return the socket for the | |
311 | connection and the expected size of the transfer. The | |
312 | expected size may be None if it could not be determined. | |
313 | ||
314 | Optional `rest' argument can be a string that is sent as the | |
315 | argument to a RESTART command. This is essentially a server | |
316 | marker used to tell the server to skip over any data up to the | |
317 | given marker. | |
318 | """ | |
319 | size = None | |
320 | if self.passiveserver: | |
321 | host, port = self.makepasv() | |
322 | af, socktype, proto, canon, sa = socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM)[0] | |
323 | conn = socket.socket(af, socktype, proto) | |
324 | conn.connect(sa) | |
325 | if rest is not None: | |
326 | self.sendcmd("REST %s" % rest) | |
327 | resp = self.sendcmd(cmd) | |
328 | if resp[0] != '1': | |
329 | raise error_reply, resp | |
330 | else: | |
331 | sock = self.makeport() | |
332 | if rest is not None: | |
333 | self.sendcmd("REST %s" % rest) | |
334 | resp = self.sendcmd(cmd) | |
335 | if resp[0] != '1': | |
336 | raise error_reply, resp | |
337 | conn, sockaddr = sock.accept() | |
338 | if resp[:3] == '150': | |
339 | # this is conditional in case we received a 125 | |
340 | size = parse150(resp) | |
341 | return conn, size | |
342 | ||
343 | def transfercmd(self, cmd, rest=None): | |
344 | """Like ntransfercmd() but returns only the socket.""" | |
345 | return self.ntransfercmd(cmd, rest)[0] | |
346 | ||
347 | def login(self, user = '', passwd = '', acct = ''): | |
348 | '''Login, default anonymous.''' | |
349 | if not user: user = 'anonymous' | |
350 | if not passwd: passwd = '' | |
351 | if not acct: acct = '' | |
352 | if user == 'anonymous' and passwd in ('', '-'): | |
353 | # If there is no anonymous ftp password specified | |
354 | # then we'll just use anonymous@ | |
355 | # We don't send any other thing because: | |
356 | # - We want to remain anonymous | |
357 | # - We want to stop SPAM | |
358 | # - We don't want to let ftp sites to discriminate by the user, | |
359 | # host or country. | |
360 | passwd = passwd + 'anonymous@' | |
361 | resp = self.sendcmd('USER ' + user) | |
362 | if resp[0] == '3': resp = self.sendcmd('PASS ' + passwd) | |
363 | if resp[0] == '3': resp = self.sendcmd('ACCT ' + acct) | |
364 | if resp[0] != '2': | |
365 | raise error_reply, resp | |
366 | return resp | |
367 | ||
368 | def retrbinary(self, cmd, callback, blocksize=8192, rest=None): | |
369 | """Retrieve data in binary mode. | |
370 | ||
371 | `cmd' is a RETR command. `callback' is a callback function is | |
372 | called for each block. No more than `blocksize' number of | |
373 | bytes will be read from the socket. Optional `rest' is passed | |
374 | to transfercmd(). | |
375 | ||
376 | A new port is created for you. Return the response code. | |
377 | """ | |
378 | self.voidcmd('TYPE I') | |
379 | conn = self.transfercmd(cmd, rest) | |
380 | while 1: | |
381 | data = conn.recv(blocksize) | |
382 | if not data: | |
383 | break | |
384 | callback(data) | |
385 | conn.close() | |
386 | return self.voidresp() | |
387 | ||
388 | def retrlines(self, cmd, callback = None): | |
389 | '''Retrieve data in line mode. | |
390 | The argument is a RETR or LIST command. | |
391 | The callback function (2nd argument) is called for each line, | |
392 | with trailing CRLF stripped. This creates a new port for you. | |
393 | print_line() is the default callback.''' | |
394 | if callback is None: callback = print_line | |
395 | resp = self.sendcmd('TYPE A') | |
396 | conn = self.transfercmd(cmd) | |
397 | fp = conn.makefile('rb') | |
398 | while 1: | |
399 | line = fp.readline() | |
400 | if self.debugging > 2: print '*retr*', repr(line) | |
401 | if not line: | |
402 | break | |
403 | if line[-2:] == CRLF: | |
404 | line = line[:-2] | |
405 | elif line[-1:] == '\n': | |
406 | line = line[:-1] | |
407 | callback(line) | |
408 | fp.close() | |
409 | conn.close() | |
410 | return self.voidresp() | |
411 | ||
412 | def storbinary(self, cmd, fp, blocksize=8192): | |
413 | '''Store a file in binary mode.''' | |
414 | self.voidcmd('TYPE I') | |
415 | conn = self.transfercmd(cmd) | |
416 | while 1: | |
417 | buf = fp.read(blocksize) | |
418 | if not buf: break | |
419 | conn.sendall(buf) | |
420 | conn.close() | |
421 | return self.voidresp() | |
422 | ||
423 | def storlines(self, cmd, fp): | |
424 | '''Store a file in line mode.''' | |
425 | self.voidcmd('TYPE A') | |
426 | conn = self.transfercmd(cmd) | |
427 | while 1: | |
428 | buf = fp.readline() | |
429 | if not buf: break | |
430 | if buf[-2:] != CRLF: | |
431 | if buf[-1] in CRLF: buf = buf[:-1] | |
432 | buf = buf + CRLF | |
433 | conn.sendall(buf) | |
434 | conn.close() | |
435 | return self.voidresp() | |
436 | ||
437 | def acct(self, password): | |
438 | '''Send new account name.''' | |
439 | cmd = 'ACCT ' + password | |
440 | return self.voidcmd(cmd) | |
441 | ||
442 | def nlst(self, *args): | |
443 | '''Return a list of files in a given directory (default the current).''' | |
444 | cmd = 'NLST' | |
445 | for arg in args: | |
446 | cmd = cmd + (' ' + arg) | |
447 | files = [] | |
448 | self.retrlines(cmd, files.append) | |
449 | return files | |
450 | ||
451 | def dir(self, *args): | |
452 | '''List a directory in long form. | |
453 | By default list current directory to stdout. | |
454 | Optional last argument is callback function; all | |
455 | non-empty arguments before it are concatenated to the | |
456 | LIST command. (This *should* only be used for a pathname.)''' | |
457 | cmd = 'LIST' | |
458 | func = None | |
459 | if args[-1:] and type(args[-1]) != type(''): | |
460 | args, func = args[:-1], args[-1] | |
461 | for arg in args: | |
462 | if arg: | |
463 | cmd = cmd + (' ' + arg) | |
464 | self.retrlines(cmd, func) | |
465 | ||
466 | def rename(self, fromname, toname): | |
467 | '''Rename a file.''' | |
468 | resp = self.sendcmd('RNFR ' + fromname) | |
469 | if resp[0] != '3': | |
470 | raise error_reply, resp | |
471 | return self.voidcmd('RNTO ' + toname) | |
472 | ||
473 | def delete(self, filename): | |
474 | '''Delete a file.''' | |
475 | resp = self.sendcmd('DELE ' + filename) | |
476 | if resp[:3] in ('250', '200'): | |
477 | return resp | |
478 | elif resp[:1] == '5': | |
479 | raise error_perm, resp | |
480 | else: | |
481 | raise error_reply, resp | |
482 | ||
483 | def cwd(self, dirname): | |
484 | '''Change to a directory.''' | |
485 | if dirname == '..': | |
486 | try: | |
487 | return self.voidcmd('CDUP') | |
488 | except error_perm, msg: | |
489 | if msg.args[0][:3] != '500': | |
490 | raise | |
491 | elif dirname == '': | |
492 | dirname = '.' # does nothing, but could return error | |
493 | cmd = 'CWD ' + dirname | |
494 | return self.voidcmd(cmd) | |
495 | ||
496 | def size(self, filename): | |
497 | '''Retrieve the size of a file.''' | |
498 | # Note that the RFC doesn't say anything about 'SIZE' | |
499 | resp = self.sendcmd('SIZE ' + filename) | |
500 | if resp[:3] == '213': | |
501 | s = resp[3:].strip() | |
502 | try: | |
503 | return int(s) | |
504 | except (OverflowError, ValueError): | |
505 | return long(s) | |
506 | ||
507 | def mkd(self, dirname): | |
508 | '''Make a directory, return its full pathname.''' | |
509 | resp = self.sendcmd('MKD ' + dirname) | |
510 | return parse257(resp) | |
511 | ||
512 | def rmd(self, dirname): | |
513 | '''Remove a directory.''' | |
514 | return self.voidcmd('RMD ' + dirname) | |
515 | ||
516 | def pwd(self): | |
517 | '''Return current working directory.''' | |
518 | resp = self.sendcmd('PWD') | |
519 | return parse257(resp) | |
520 | ||
521 | def quit(self): | |
522 | '''Quit, and close the connection.''' | |
523 | resp = self.voidcmd('QUIT') | |
524 | self.close() | |
525 | return resp | |
526 | ||
527 | def close(self): | |
528 | '''Close the connection without assuming anything about it.''' | |
529 | if self.file: | |
530 | self.file.close() | |
531 | self.sock.close() | |
532 | self.file = self.sock = None | |
533 | ||
534 | ||
535 | _150_re = None | |
536 | ||
537 | def parse150(resp): | |
538 | '''Parse the '150' response for a RETR request. | |
539 | Returns the expected transfer size or None; size is not guaranteed to | |
540 | be present in the 150 message. | |
541 | ''' | |
542 | if resp[:3] != '150': | |
543 | raise error_reply, resp | |
544 | global _150_re | |
545 | if _150_re is None: | |
546 | import re | |
547 | _150_re = re.compile("150 .* \((\d+) bytes\)", re.IGNORECASE) | |
548 | m = _150_re.match(resp) | |
549 | if not m: | |
550 | return None | |
551 | s = m.group(1) | |
552 | try: | |
553 | return int(s) | |
554 | except (OverflowError, ValueError): | |
555 | return long(s) | |
556 | ||
557 | ||
558 | _227_re = None | |
559 | ||
560 | def parse227(resp): | |
561 | '''Parse the '227' response for a PASV request. | |
562 | Raises error_proto if it does not contain '(h1,h2,h3,h4,p1,p2)' | |
563 | Return ('host.addr.as.numbers', port#) tuple.''' | |
564 | ||
565 | if resp[:3] != '227': | |
566 | raise error_reply, resp | |
567 | global _227_re | |
568 | if _227_re is None: | |
569 | import re | |
570 | _227_re = re.compile(r'(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)') | |
571 | m = _227_re.search(resp) | |
572 | if not m: | |
573 | raise error_proto, resp | |
574 | numbers = m.groups() | |
575 | host = '.'.join(numbers[:4]) | |
576 | port = (int(numbers[4]) << 8) + int(numbers[5]) | |
577 | return host, port | |
578 | ||
579 | ||
580 | def parse229(resp, peer): | |
581 | '''Parse the '229' response for a EPSV request. | |
582 | Raises error_proto if it does not contain '(|||port|)' | |
583 | Return ('host.addr.as.numbers', port#) tuple.''' | |
584 | ||
585 | if resp[:3] != '229': | |
586 | raise error_reply, resp | |
587 | left = resp.find('(') | |
588 | if left < 0: raise error_proto, resp | |
589 | right = resp.find(')', left + 1) | |
590 | if right < 0: | |
591 | raise error_proto, resp # should contain '(|||port|)' | |
592 | if resp[left + 1] != resp[right - 1]: | |
593 | raise error_proto, resp | |
594 | parts = resp[left + 1:right].split(resp[left+1]) | |
595 | if len(parts) != 5: | |
596 | raise error_proto, resp | |
597 | host = peer[0] | |
598 | port = int(parts[3]) | |
599 | return host, port | |
600 | ||
601 | ||
602 | def parse257(resp): | |
603 | '''Parse the '257' response for a MKD or PWD request. | |
604 | This is a response to a MKD or PWD request: a directory name. | |
605 | Returns the directoryname in the 257 reply.''' | |
606 | ||
607 | if resp[:3] != '257': | |
608 | raise error_reply, resp | |
609 | if resp[3:5] != ' "': | |
610 | return '' # Not compliant to RFC 959, but UNIX ftpd does this | |
611 | dirname = '' | |
612 | i = 5 | |
613 | n = len(resp) | |
614 | while i < n: | |
615 | c = resp[i] | |
616 | i = i+1 | |
617 | if c == '"': | |
618 | if i >= n or resp[i] != '"': | |
619 | break | |
620 | i = i+1 | |
621 | dirname = dirname + c | |
622 | return dirname | |
623 | ||
624 | ||
625 | def print_line(line): | |
626 | '''Default retrlines callback to print a line.''' | |
627 | print line | |
628 | ||
629 | ||
630 | def ftpcp(source, sourcename, target, targetname = '', type = 'I'): | |
631 | '''Copy file from one FTP-instance to another.''' | |
632 | if not targetname: targetname = sourcename | |
633 | type = 'TYPE ' + type | |
634 | source.voidcmd(type) | |
635 | target.voidcmd(type) | |
636 | sourcehost, sourceport = parse227(source.sendcmd('PASV')) | |
637 | target.sendport(sourcehost, sourceport) | |
638 | # RFC 959: the user must "listen" [...] BEFORE sending the | |
639 | # transfer request. | |
640 | # So: STOR before RETR, because here the target is a "user". | |
641 | treply = target.sendcmd('STOR ' + targetname) | |
642 | if treply[:3] not in ('125', '150'): raise error_proto # RFC 959 | |
643 | sreply = source.sendcmd('RETR ' + sourcename) | |
644 | if sreply[:3] not in ('125', '150'): raise error_proto # RFC 959 | |
645 | source.voidresp() | |
646 | target.voidresp() | |
647 | ||
648 | ||
649 | class Netrc: | |
650 | """Class to parse & provide access to 'netrc' format files. | |
651 | ||
652 | See the netrc(4) man page for information on the file format. | |
653 | ||
654 | WARNING: This class is obsolete -- use module netrc instead. | |
655 | ||
656 | """ | |
657 | __defuser = None | |
658 | __defpasswd = None | |
659 | __defacct = None | |
660 | ||
661 | def __init__(self, filename=None): | |
662 | if filename is None: | |
663 | if "HOME" in os.environ: | |
664 | filename = os.path.join(os.environ["HOME"], | |
665 | ".netrc") | |
666 | else: | |
667 | raise IOError, \ | |
668 | "specify file to load or set $HOME" | |
669 | self.__hosts = {} | |
670 | self.__macros = {} | |
671 | fp = open(filename, "r") | |
672 | in_macro = 0 | |
673 | while 1: | |
674 | line = fp.readline() | |
675 | if not line: break | |
676 | if in_macro and line.strip(): | |
677 | macro_lines.append(line) | |
678 | continue | |
679 | elif in_macro: | |
680 | self.__macros[macro_name] = tuple(macro_lines) | |
681 | in_macro = 0 | |
682 | words = line.split() | |
683 | host = user = passwd = acct = None | |
684 | default = 0 | |
685 | i = 0 | |
686 | while i < len(words): | |
687 | w1 = words[i] | |
688 | if i+1 < len(words): | |
689 | w2 = words[i + 1] | |
690 | else: | |
691 | w2 = None | |
692 | if w1 == 'default': | |
693 | default = 1 | |
694 | elif w1 == 'machine' and w2: | |
695 | host = w2.lower() | |
696 | i = i + 1 | |
697 | elif w1 == 'login' and w2: | |
698 | user = w2 | |
699 | i = i + 1 | |
700 | elif w1 == 'password' and w2: | |
701 | passwd = w2 | |
702 | i = i + 1 | |
703 | elif w1 == 'account' and w2: | |
704 | acct = w2 | |
705 | i = i + 1 | |
706 | elif w1 == 'macdef' and w2: | |
707 | macro_name = w2 | |
708 | macro_lines = [] | |
709 | in_macro = 1 | |
710 | break | |
711 | i = i + 1 | |
712 | if default: | |
713 | self.__defuser = user or self.__defuser | |
714 | self.__defpasswd = passwd or self.__defpasswd | |
715 | self.__defacct = acct or self.__defacct | |
716 | if host: | |
717 | if host in self.__hosts: | |
718 | ouser, opasswd, oacct = \ | |
719 | self.__hosts[host] | |
720 | user = user or ouser | |
721 | passwd = passwd or opasswd | |
722 | acct = acct or oacct | |
723 | self.__hosts[host] = user, passwd, acct | |
724 | fp.close() | |
725 | ||
726 | def get_hosts(self): | |
727 | """Return a list of hosts mentioned in the .netrc file.""" | |
728 | return self.__hosts.keys() | |
729 | ||
730 | def get_account(self, host): | |
731 | """Returns login information for the named host. | |
732 | ||
733 | The return value is a triple containing userid, | |
734 | password, and the accounting field. | |
735 | ||
736 | """ | |
737 | host = host.lower() | |
738 | user = passwd = acct = None | |
739 | if host in self.__hosts: | |
740 | user, passwd, acct = self.__hosts[host] | |
741 | user = user or self.__defuser | |
742 | passwd = passwd or self.__defpasswd | |
743 | acct = acct or self.__defacct | |
744 | return user, passwd, acct | |
745 | ||
746 | def get_macros(self): | |
747 | """Return a list of all defined macro names.""" | |
748 | return self.__macros.keys() | |
749 | ||
750 | def get_macro(self, macro): | |
751 | """Return a sequence of lines which define a named macro.""" | |
752 | return self.__macros[macro] | |
753 | ||
754 | ||
755 | ||
756 | def test(): | |
757 | '''Test program. | |
758 | Usage: ftp [-d] [-r[file]] host [-l[dir]] [-d[dir]] [-p] [file] ... | |
759 | ||
760 | -d dir | |
761 | -l list | |
762 | -p password | |
763 | ''' | |
764 | ||
765 | if len(sys.argv) < 2: | |
766 | print test.__doc__ | |
767 | sys.exit(0) | |
768 | ||
769 | debugging = 0 | |
770 | rcfile = None | |
771 | while sys.argv[1] == '-d': | |
772 | debugging = debugging+1 | |
773 | del sys.argv[1] | |
774 | if sys.argv[1][:2] == '-r': | |
775 | # get name of alternate ~/.netrc file: | |
776 | rcfile = sys.argv[1][2:] | |
777 | del sys.argv[1] | |
778 | host = sys.argv[1] | |
779 | ftp = FTP(host) | |
780 | ftp.set_debuglevel(debugging) | |
781 | userid = passwd = acct = '' | |
782 | try: | |
783 | netrc = Netrc(rcfile) | |
784 | except IOError: | |
785 | if rcfile is not None: | |
786 | sys.stderr.write("Could not open account file" | |
787 | " -- using anonymous login.") | |
788 | else: | |
789 | try: | |
790 | userid, passwd, acct = netrc.get_account(host) | |
791 | except KeyError: | |
792 | # no account for host | |
793 | sys.stderr.write( | |
794 | "No account -- using anonymous login.") | |
795 | ftp.login(userid, passwd, acct) | |
796 | for file in sys.argv[2:]: | |
797 | if file[:2] == '-l': | |
798 | ftp.dir(file[2:]) | |
799 | elif file[:2] == '-d': | |
800 | cmd = 'CWD' | |
801 | if file[2:]: cmd = cmd + ' ' + file[2:] | |
802 | resp = ftp.sendcmd(cmd) | |
803 | elif file == '-p': | |
804 | ftp.set_pasv(not ftp.passiveserver) | |
805 | else: | |
806 | ftp.retrbinary('RETR ' + file, \ | |
807 | sys.stdout.write, 1024) | |
808 | ftp.quit() | |
809 | ||
810 | ||
811 | if __name__ == '__main__': | |
812 | test() |