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 | # Modified by Phil Schwartz to add storbinary and storlines callbacks. |
---|
36 | # Modified by Giampaolo Rodola' to add TLS support. |
---|
37 | # |
---|
38 | |
---|
39 | import os |
---|
40 | import sys |
---|
41 | |
---|
42 | # Import SOCKS module if it exists, else standard socket module socket |
---|
43 | try: |
---|
44 | import SOCKS; socket = SOCKS; del SOCKS # import SOCKS as socket |
---|
45 | from socket import getfqdn; socket.getfqdn = getfqdn; del getfqdn |
---|
46 | except ImportError: |
---|
47 | import socket |
---|
48 | from socket import _GLOBAL_DEFAULT_TIMEOUT |
---|
49 | |
---|
50 | __all__ = ["FTP","Netrc"] |
---|
51 | |
---|
52 | # Magic number from <socket.h> |
---|
53 | MSG_OOB = 0x1 # Process data out of band |
---|
54 | |
---|
55 | |
---|
56 | # The standard FTP server control port |
---|
57 | FTP_PORT = 21 |
---|
58 | # The sizehint parameter passed to readline() calls |
---|
59 | MAXLINE = 8192 |
---|
60 | |
---|
61 | |
---|
62 | # Exception raised when an error or invalid response is received |
---|
63 | class Error(Exception): pass |
---|
64 | class error_reply(Error): pass # unexpected [123]xx reply |
---|
65 | class error_temp(Error): pass # 4xx errors |
---|
66 | class error_perm(Error): pass # 5xx errors |
---|
67 | class error_proto(Error): pass # response does not begin with [1-5] |
---|
68 | |
---|
69 | |
---|
70 | # All exceptions (hopefully) that may be raised here and that aren't |
---|
71 | # (always) programming errors on our side |
---|
72 | all_errors = (Error, IOError, EOFError) |
---|
73 | |
---|
74 | |
---|
75 | # Line terminators (we always output CRLF, but accept any of CRLF, CR, LF) |
---|
76 | CRLF = '\r\n' |
---|
77 | |
---|
78 | # The class itself |
---|
79 | class FTP: |
---|
80 | |
---|
81 | '''An FTP client class. |
---|
82 | |
---|
83 | To create a connection, call the class using these arguments: |
---|
84 | host, user, passwd, acct, timeout |
---|
85 | |
---|
86 | The first four arguments are all strings, and have default value ''. |
---|
87 | timeout must be numeric and defaults to None if not passed, |
---|
88 | meaning that no timeout will be set on any ftp socket(s) |
---|
89 | If a timeout is passed, then this is now the default timeout for all ftp |
---|
90 | socket operations for this instance. |
---|
91 | |
---|
92 | Then use self.connect() with optional host and port argument. |
---|
93 | |
---|
94 | To download a file, use ftp.retrlines('RETR ' + filename), |
---|
95 | or ftp.retrbinary() with slightly different arguments. |
---|
96 | To upload a file, use ftp.storlines() or ftp.storbinary(), |
---|
97 | which have an open file as argument (see their definitions |
---|
98 | below for details). |
---|
99 | The download/upload functions first issue appropriate TYPE |
---|
100 | and PORT or PASV commands. |
---|
101 | ''' |
---|
102 | |
---|
103 | debugging = 0 |
---|
104 | host = '' |
---|
105 | port = FTP_PORT |
---|
106 | maxline = MAXLINE |
---|
107 | sock = None |
---|
108 | file = None |
---|
109 | welcome = None |
---|
110 | passiveserver = 1 |
---|
111 | |
---|
112 | # Initialization method (called by class instantiation). |
---|
113 | # Initialize host to localhost, port to standard ftp port |
---|
114 | # Optional arguments are host (for connect()), |
---|
115 | # and user, passwd, acct (for login()) |
---|
116 | def __init__(self, host='', user='', passwd='', acct='', |
---|
117 | timeout=_GLOBAL_DEFAULT_TIMEOUT): |
---|
118 | self.timeout = timeout |
---|
119 | if host: |
---|
120 | self.connect(host) |
---|
121 | if user: |
---|
122 | self.login(user, passwd, acct) |
---|
123 | |
---|
124 | def connect(self, host='', port=0, timeout=-999): |
---|
125 | '''Connect to host. Arguments are: |
---|
126 | - host: hostname to connect to (string, default previous host) |
---|
127 | - port: port to connect to (integer, default previous port) |
---|
128 | ''' |
---|
129 | if host != '': |
---|
130 | self.host = host |
---|
131 | if port > 0: |
---|
132 | self.port = port |
---|
133 | if timeout != -999: |
---|
134 | self.timeout = timeout |
---|
135 | self.sock = socket.create_connection((self.host, self.port), self.timeout) |
---|
136 | self.af = self.sock.family |
---|
137 | self.file = self.sock.makefile('rb') |
---|
138 | self.welcome = self.getresp() |
---|
139 | return self.welcome |
---|
140 | |
---|
141 | def getwelcome(self): |
---|
142 | '''Get the welcome message from the server. |
---|
143 | (this is read and squirreled away by connect())''' |
---|
144 | if self.debugging: |
---|
145 | print '*welcome*', self.sanitize(self.welcome) |
---|
146 | return self.welcome |
---|
147 | |
---|
148 | def set_debuglevel(self, level): |
---|
149 | '''Set the debugging level. |
---|
150 | The required argument level means: |
---|
151 | 0: no debugging output (default) |
---|
152 | 1: print commands and responses but not body text etc. |
---|
153 | 2: also print raw lines read and sent before stripping CR/LF''' |
---|
154 | self.debugging = level |
---|
155 | debug = set_debuglevel |
---|
156 | |
---|
157 | def set_pasv(self, val): |
---|
158 | '''Use passive or active mode for data transfers. |
---|
159 | With a false argument, use the normal PORT mode, |
---|
160 | With a true argument, use the PASV command.''' |
---|
161 | self.passiveserver = val |
---|
162 | |
---|
163 | # Internal: "sanitize" a string for printing |
---|
164 | def sanitize(self, s): |
---|
165 | if s[:5] == 'pass ' or s[:5] == 'PASS ': |
---|
166 | i = len(s) |
---|
167 | while i > 5 and s[i-1] in '\r\n': |
---|
168 | i = i-1 |
---|
169 | s = s[:5] + '*'*(i-5) + s[i:] |
---|
170 | return repr(s) |
---|
171 | |
---|
172 | # Internal: send one line to the server, appending CRLF |
---|
173 | def putline(self, line): |
---|
174 | line = line + CRLF |
---|
175 | if self.debugging > 1: print '*put*', self.sanitize(line) |
---|
176 | self.sock.sendall(line) |
---|
177 | |
---|
178 | # Internal: send one command to the server (through putline()) |
---|
179 | def putcmd(self, line): |
---|
180 | if self.debugging: print '*cmd*', self.sanitize(line) |
---|
181 | self.putline(line) |
---|
182 | |
---|
183 | # Internal: return one line from the server, stripping CRLF. |
---|
184 | # Raise EOFError if the connection is closed |
---|
185 | def getline(self): |
---|
186 | line = self.file.readline(self.maxline + 1) |
---|
187 | if len(line) > self.maxline: |
---|
188 | raise Error("got more than %d bytes" % self.maxline) |
---|
189 | if self.debugging > 1: |
---|
190 | print '*get*', self.sanitize(line) |
---|
191 | if not line: raise EOFError |
---|
192 | if line[-2:] == CRLF: line = line[:-2] |
---|
193 | elif line[-1:] in CRLF: line = line[:-1] |
---|
194 | return line |
---|
195 | |
---|
196 | # Internal: get a response from the server, which may possibly |
---|
197 | # consist of multiple lines. Return a single string with no |
---|
198 | # trailing CRLF. If the response consists of multiple lines, |
---|
199 | # these are separated by '\n' characters in the string |
---|
200 | def getmultiline(self): |
---|
201 | line = self.getline() |
---|
202 | if line[3:4] == '-': |
---|
203 | code = line[:3] |
---|
204 | while 1: |
---|
205 | nextline = self.getline() |
---|
206 | line = line + ('\n' + nextline) |
---|
207 | if nextline[:3] == code and \ |
---|
208 | nextline[3:4] != '-': |
---|
209 | break |
---|
210 | return line |
---|
211 | |
---|
212 | # Internal: get a response from the server. |
---|
213 | # Raise various errors if the response indicates an error |
---|
214 | def getresp(self): |
---|
215 | resp = self.getmultiline() |
---|
216 | if self.debugging: print '*resp*', self.sanitize(resp) |
---|
217 | self.lastresp = resp[:3] |
---|
218 | c = resp[:1] |
---|
219 | if c in ('1', '2', '3'): |
---|
220 | return resp |
---|
221 | if c == '4': |
---|
222 | raise error_temp, resp |
---|
223 | if c == '5': |
---|
224 | raise error_perm, resp |
---|
225 | raise error_proto, resp |
---|
226 | |
---|
227 | def voidresp(self): |
---|
228 | """Expect a response beginning with '2'.""" |
---|
229 | resp = self.getresp() |
---|
230 | if resp[:1] != '2': |
---|
231 | raise error_reply, resp |
---|
232 | return resp |
---|
233 | |
---|
234 | def abort(self): |
---|
235 | '''Abort a file transfer. Uses out-of-band data. |
---|
236 | This does not follow the procedure from the RFC to send Telnet |
---|
237 | IP and Synch; that doesn't seem to work with the servers I've |
---|
238 | tried. Instead, just send the ABOR command as OOB data.''' |
---|
239 | line = 'ABOR' + CRLF |
---|
240 | if self.debugging > 1: print '*put urgent*', self.sanitize(line) |
---|
241 | self.sock.sendall(line, MSG_OOB) |
---|
242 | resp = self.getmultiline() |
---|
243 | if resp[:3] not in ('426', '225', '226'): |
---|
244 | raise error_proto, resp |
---|
245 | |
---|
246 | def sendcmd(self, cmd): |
---|
247 | '''Send a command and return the response.''' |
---|
248 | self.putcmd(cmd) |
---|
249 | return self.getresp() |
---|
250 | |
---|
251 | def voidcmd(self, cmd): |
---|
252 | """Send a command and expect a response beginning with '2'.""" |
---|
253 | self.putcmd(cmd) |
---|
254 | return self.voidresp() |
---|
255 | |
---|
256 | def sendport(self, host, port): |
---|
257 | '''Send a PORT command with the current host and the given |
---|
258 | port number. |
---|
259 | ''' |
---|
260 | hbytes = host.split('.') |
---|
261 | pbytes = [repr(port//256), repr(port%256)] |
---|
262 | bytes = hbytes + pbytes |
---|
263 | cmd = 'PORT ' + ','.join(bytes) |
---|
264 | return self.voidcmd(cmd) |
---|
265 | |
---|
266 | def sendeprt(self, host, port): |
---|
267 | '''Send a EPRT command with the current host and the given port number.''' |
---|
268 | af = 0 |
---|
269 | if self.af == socket.AF_INET: |
---|
270 | af = 1 |
---|
271 | if self.af == socket.AF_INET6: |
---|
272 | af = 2 |
---|
273 | if af == 0: |
---|
274 | raise error_proto, 'unsupported address family' |
---|
275 | fields = ['', repr(af), host, repr(port), ''] |
---|
276 | cmd = 'EPRT ' + '|'.join(fields) |
---|
277 | return self.voidcmd(cmd) |
---|
278 | |
---|
279 | def makeport(self): |
---|
280 | '''Create a new socket and send a PORT command for it.''' |
---|
281 | err = None |
---|
282 | sock = None |
---|
283 | for res in socket.getaddrinfo(None, 0, self.af, socket.SOCK_STREAM, 0, socket.AI_PASSIVE): |
---|
284 | af, socktype, proto, canonname, sa = res |
---|
285 | try: |
---|
286 | sock = socket.socket(af, socktype, proto) |
---|
287 | sock.bind(sa) |
---|
288 | except socket.error, err: |
---|
289 | if sock: |
---|
290 | sock.close() |
---|
291 | sock = None |
---|
292 | continue |
---|
293 | break |
---|
294 | if sock is None: |
---|
295 | if err is not None: |
---|
296 | raise err |
---|
297 | else: |
---|
298 | raise socket.error("getaddrinfo returns an empty list") |
---|
299 | sock.listen(1) |
---|
300 | port = sock.getsockname()[1] # Get proper port |
---|
301 | host = self.sock.getsockname()[0] # Get proper host |
---|
302 | if self.af == socket.AF_INET: |
---|
303 | resp = self.sendport(host, port) |
---|
304 | else: |
---|
305 | resp = self.sendeprt(host, port) |
---|
306 | if self.timeout is not _GLOBAL_DEFAULT_TIMEOUT: |
---|
307 | sock.settimeout(self.timeout) |
---|
308 | return sock |
---|
309 | |
---|
310 | def makepasv(self): |
---|
311 | if self.af == socket.AF_INET: |
---|
312 | host, port = parse227(self.sendcmd('PASV')) |
---|
313 | else: |
---|
314 | host, port = parse229(self.sendcmd('EPSV'), self.sock.getpeername()) |
---|
315 | return host, port |
---|
316 | |
---|
317 | def ntransfercmd(self, cmd, rest=None): |
---|
318 | """Initiate a transfer over the data connection. |
---|
319 | |
---|
320 | If the transfer is active, send a port command and the |
---|
321 | transfer command, and accept the connection. If the server is |
---|
322 | passive, send a pasv command, connect to it, and start the |
---|
323 | transfer command. Either way, return the socket for the |
---|
324 | connection and the expected size of the transfer. The |
---|
325 | expected size may be None if it could not be determined. |
---|
326 | |
---|
327 | Optional `rest' argument can be a string that is sent as the |
---|
328 | argument to a REST command. This is essentially a server |
---|
329 | marker used to tell the server to skip over any data up to the |
---|
330 | given marker. |
---|
331 | """ |
---|
332 | size = None |
---|
333 | if self.passiveserver: |
---|
334 | host, port = self.makepasv() |
---|
335 | conn = socket.create_connection((host, port), self.timeout) |
---|
336 | try: |
---|
337 | if rest is not None: |
---|
338 | self.sendcmd("REST %s" % rest) |
---|
339 | resp = self.sendcmd(cmd) |
---|
340 | # Some servers apparently send a 200 reply to |
---|
341 | # a LIST or STOR command, before the 150 reply |
---|
342 | # (and way before the 226 reply). This seems to |
---|
343 | # be in violation of the protocol (which only allows |
---|
344 | # 1xx or error messages for LIST), so we just discard |
---|
345 | # this response. |
---|
346 | if resp[0] == '2': |
---|
347 | resp = self.getresp() |
---|
348 | if resp[0] != '1': |
---|
349 | raise error_reply, resp |
---|
350 | except: |
---|
351 | conn.close() |
---|
352 | raise |
---|
353 | else: |
---|
354 | sock = self.makeport() |
---|
355 | try: |
---|
356 | if rest is not None: |
---|
357 | self.sendcmd("REST %s" % rest) |
---|
358 | resp = self.sendcmd(cmd) |
---|
359 | # See above. |
---|
360 | if resp[0] == '2': |
---|
361 | resp = self.getresp() |
---|
362 | if resp[0] != '1': |
---|
363 | raise error_reply, resp |
---|
364 | conn, sockaddr = sock.accept() |
---|
365 | if self.timeout is not _GLOBAL_DEFAULT_TIMEOUT: |
---|
366 | conn.settimeout(self.timeout) |
---|
367 | finally: |
---|
368 | sock.close() |
---|
369 | if resp[:3] == '150': |
---|
370 | # this is conditional in case we received a 125 |
---|
371 | size = parse150(resp) |
---|
372 | return conn, size |
---|
373 | |
---|
374 | def transfercmd(self, cmd, rest=None): |
---|
375 | """Like ntransfercmd() but returns only the socket.""" |
---|
376 | return self.ntransfercmd(cmd, rest)[0] |
---|
377 | |
---|
378 | def login(self, user = '', passwd = '', acct = ''): |
---|
379 | '''Login, default anonymous.''' |
---|
380 | if not user: user = 'anonymous' |
---|
381 | if not passwd: passwd = '' |
---|
382 | if not acct: acct = '' |
---|
383 | if user == 'anonymous' and passwd in ('', '-'): |
---|
384 | # If there is no anonymous ftp password specified |
---|
385 | # then we'll just use anonymous@ |
---|
386 | # We don't send any other thing because: |
---|
387 | # - We want to remain anonymous |
---|
388 | # - We want to stop SPAM |
---|
389 | # - We don't want to let ftp sites to discriminate by the user, |
---|
390 | # host or country. |
---|
391 | passwd = passwd + 'anonymous@' |
---|
392 | resp = self.sendcmd('USER ' + user) |
---|
393 | if resp[0] == '3': resp = self.sendcmd('PASS ' + passwd) |
---|
394 | if resp[0] == '3': resp = self.sendcmd('ACCT ' + acct) |
---|
395 | if resp[0] != '2': |
---|
396 | raise error_reply, resp |
---|
397 | return resp |
---|
398 | |
---|
399 | def retrbinary(self, cmd, callback, blocksize=8192, rest=None): |
---|
400 | """Retrieve data in binary mode. A new port is created for you. |
---|
401 | |
---|
402 | Args: |
---|
403 | cmd: A RETR command. |
---|
404 | callback: A single parameter callable to be called on each |
---|
405 | block of data read. |
---|
406 | blocksize: The maximum number of bytes to read from the |
---|
407 | socket at one time. [default: 8192] |
---|
408 | rest: Passed to transfercmd(). [default: None] |
---|
409 | |
---|
410 | Returns: |
---|
411 | The response code. |
---|
412 | """ |
---|
413 | self.voidcmd('TYPE I') |
---|
414 | conn = self.transfercmd(cmd, rest) |
---|
415 | while 1: |
---|
416 | data = conn.recv(blocksize) |
---|
417 | if not data: |
---|
418 | break |
---|
419 | callback(data) |
---|
420 | conn.close() |
---|
421 | return self.voidresp() |
---|
422 | |
---|
423 | def retrlines(self, cmd, callback = None): |
---|
424 | """Retrieve data in line mode. A new port is created for you. |
---|
425 | |
---|
426 | Args: |
---|
427 | cmd: A RETR, LIST, NLST, or MLSD command. |
---|
428 | callback: An optional single parameter callable that is called |
---|
429 | for each line with the trailing CRLF stripped. |
---|
430 | [default: print_line()] |
---|
431 | |
---|
432 | Returns: |
---|
433 | The response code. |
---|
434 | """ |
---|
435 | if callback is None: callback = print_line |
---|
436 | resp = self.sendcmd('TYPE A') |
---|
437 | conn = self.transfercmd(cmd) |
---|
438 | fp = conn.makefile('rb') |
---|
439 | while 1: |
---|
440 | line = fp.readline(self.maxline + 1) |
---|
441 | if len(line) > self.maxline: |
---|
442 | raise Error("got more than %d bytes" % self.maxline) |
---|
443 | if self.debugging > 2: print '*retr*', repr(line) |
---|
444 | if not line: |
---|
445 | break |
---|
446 | if line[-2:] == CRLF: |
---|
447 | line = line[:-2] |
---|
448 | elif line[-1:] == '\n': |
---|
449 | line = line[:-1] |
---|
450 | callback(line) |
---|
451 | fp.close() |
---|
452 | conn.close() |
---|
453 | return self.voidresp() |
---|
454 | |
---|
455 | def storbinary(self, cmd, fp, blocksize=8192, callback=None, rest=None): |
---|
456 | """Store a file in binary mode. A new port is created for you. |
---|
457 | |
---|
458 | Args: |
---|
459 | cmd: A STOR command. |
---|
460 | fp: A file-like object with a read(num_bytes) method. |
---|
461 | blocksize: The maximum data size to read from fp and send over |
---|
462 | the connection at once. [default: 8192] |
---|
463 | callback: An optional single parameter callable that is called on |
---|
464 | each block of data after it is sent. [default: None] |
---|
465 | rest: Passed to transfercmd(). [default: None] |
---|
466 | |
---|
467 | Returns: |
---|
468 | The response code. |
---|
469 | """ |
---|
470 | self.voidcmd('TYPE I') |
---|
471 | conn = self.transfercmd(cmd, rest) |
---|
472 | while 1: |
---|
473 | buf = fp.read(blocksize) |
---|
474 | if not buf: break |
---|
475 | conn.sendall(buf) |
---|
476 | if callback: callback(buf) |
---|
477 | conn.close() |
---|
478 | return self.voidresp() |
---|
479 | |
---|
480 | def storlines(self, cmd, fp, callback=None): |
---|
481 | """Store a file in line mode. A new port is created for you. |
---|
482 | |
---|
483 | Args: |
---|
484 | cmd: A STOR command. |
---|
485 | fp: A file-like object with a readline() method. |
---|
486 | callback: An optional single parameter callable that is called on |
---|
487 | each line after it is sent. [default: None] |
---|
488 | |
---|
489 | Returns: |
---|
490 | The response code. |
---|
491 | """ |
---|
492 | self.voidcmd('TYPE A') |
---|
493 | conn = self.transfercmd(cmd) |
---|
494 | while 1: |
---|
495 | buf = fp.readline(self.maxline + 1) |
---|
496 | if len(buf) > self.maxline: |
---|
497 | raise Error("got more than %d bytes" % self.maxline) |
---|
498 | if not buf: break |
---|
499 | if buf[-2:] != CRLF: |
---|
500 | if buf[-1] in CRLF: buf = buf[:-1] |
---|
501 | buf = buf + CRLF |
---|
502 | conn.sendall(buf) |
---|
503 | if callback: callback(buf) |
---|
504 | conn.close() |
---|
505 | return self.voidresp() |
---|
506 | |
---|
507 | def acct(self, password): |
---|
508 | '''Send new account name.''' |
---|
509 | cmd = 'ACCT ' + password |
---|
510 | return self.voidcmd(cmd) |
---|
511 | |
---|
512 | def nlst(self, *args): |
---|
513 | '''Return a list of files in a given directory (default the current).''' |
---|
514 | cmd = 'NLST' |
---|
515 | for arg in args: |
---|
516 | cmd = cmd + (' ' + arg) |
---|
517 | files = [] |
---|
518 | self.retrlines(cmd, files.append) |
---|
519 | return files |
---|
520 | |
---|
521 | def dir(self, *args): |
---|
522 | '''List a directory in long form. |
---|
523 | By default list current directory to stdout. |
---|
524 | Optional last argument is callback function; all |
---|
525 | non-empty arguments before it are concatenated to the |
---|
526 | LIST command. (This *should* only be used for a pathname.)''' |
---|
527 | cmd = 'LIST' |
---|
528 | func = None |
---|
529 | if args[-1:] and type(args[-1]) != type(''): |
---|
530 | args, func = args[:-1], args[-1] |
---|
531 | for arg in args: |
---|
532 | if arg: |
---|
533 | cmd = cmd + (' ' + arg) |
---|
534 | self.retrlines(cmd, func) |
---|
535 | |
---|
536 | def rename(self, fromname, toname): |
---|
537 | '''Rename a file.''' |
---|
538 | resp = self.sendcmd('RNFR ' + fromname) |
---|
539 | if resp[0] != '3': |
---|
540 | raise error_reply, resp |
---|
541 | return self.voidcmd('RNTO ' + toname) |
---|
542 | |
---|
543 | def delete(self, filename): |
---|
544 | '''Delete a file.''' |
---|
545 | resp = self.sendcmd('DELE ' + filename) |
---|
546 | if resp[:3] in ('250', '200'): |
---|
547 | return resp |
---|
548 | else: |
---|
549 | raise error_reply, resp |
---|
550 | |
---|
551 | def cwd(self, dirname): |
---|
552 | '''Change to a directory.''' |
---|
553 | if dirname == '..': |
---|
554 | try: |
---|
555 | return self.voidcmd('CDUP') |
---|
556 | except error_perm, msg: |
---|
557 | if msg.args[0][:3] != '500': |
---|
558 | raise |
---|
559 | elif dirname == '': |
---|
560 | dirname = '.' # does nothing, but could return error |
---|
561 | cmd = 'CWD ' + dirname |
---|
562 | return self.voidcmd(cmd) |
---|
563 | |
---|
564 | def size(self, filename): |
---|
565 | '''Retrieve the size of a file.''' |
---|
566 | # The SIZE command is defined in RFC-3659 |
---|
567 | resp = self.sendcmd('SIZE ' + filename) |
---|
568 | if resp[:3] == '213': |
---|
569 | s = resp[3:].strip() |
---|
570 | try: |
---|
571 | return int(s) |
---|
572 | except (OverflowError, ValueError): |
---|
573 | return long(s) |
---|
574 | |
---|
575 | def mkd(self, dirname): |
---|
576 | '''Make a directory, return its full pathname.''' |
---|
577 | resp = self.sendcmd('MKD ' + dirname) |
---|
578 | return parse257(resp) |
---|
579 | |
---|
580 | def rmd(self, dirname): |
---|
581 | '''Remove a directory.''' |
---|
582 | return self.voidcmd('RMD ' + dirname) |
---|
583 | |
---|
584 | def pwd(self): |
---|
585 | '''Return current working directory.''' |
---|
586 | resp = self.sendcmd('PWD') |
---|
587 | return parse257(resp) |
---|
588 | |
---|
589 | def quit(self): |
---|
590 | '''Quit, and close the connection.''' |
---|
591 | resp = self.voidcmd('QUIT') |
---|
592 | self.close() |
---|
593 | return resp |
---|
594 | |
---|
595 | def close(self): |
---|
596 | '''Close the connection without assuming anything about it.''' |
---|
597 | try: |
---|
598 | file = self.file |
---|
599 | self.file = None |
---|
600 | if file is not None: |
---|
601 | file.close() |
---|
602 | finally: |
---|
603 | sock = self.sock |
---|
604 | self.sock = None |
---|
605 | if sock is not None: |
---|
606 | sock.close() |
---|
607 | |
---|
608 | try: |
---|
609 | import ssl |
---|
610 | except ImportError: |
---|
611 | pass |
---|
612 | else: |
---|
613 | class FTP_TLS(FTP): |
---|
614 | '''A FTP subclass which adds TLS support to FTP as described |
---|
615 | in RFC-4217. |
---|
616 | |
---|
617 | Connect as usual to port 21 implicitly securing the FTP control |
---|
618 | connection before authenticating. |
---|
619 | |
---|
620 | Securing the data connection requires user to explicitly ask |
---|
621 | for it by calling prot_p() method. |
---|
622 | |
---|
623 | Usage example: |
---|
624 | >>> from ftplib import FTP_TLS |
---|
625 | >>> ftps = FTP_TLS('ftp.python.org') |
---|
626 | >>> ftps.login() # login anonymously previously securing control channel |
---|
627 | '230 Guest login ok, access restrictions apply.' |
---|
628 | >>> ftps.prot_p() # switch to secure data connection |
---|
629 | '200 Protection level set to P' |
---|
630 | >>> ftps.retrlines('LIST') # list directory content securely |
---|
631 | total 9 |
---|
632 | drwxr-xr-x 8 root wheel 1024 Jan 3 1994 . |
---|
633 | drwxr-xr-x 8 root wheel 1024 Jan 3 1994 .. |
---|
634 | drwxr-xr-x 2 root wheel 1024 Jan 3 1994 bin |
---|
635 | drwxr-xr-x 2 root wheel 1024 Jan 3 1994 etc |
---|
636 | d-wxrwxr-x 2 ftp wheel 1024 Sep 5 13:43 incoming |
---|
637 | drwxr-xr-x 2 root wheel 1024 Nov 17 1993 lib |
---|
638 | drwxr-xr-x 6 1094 wheel 1024 Sep 13 19:07 pub |
---|
639 | drwxr-xr-x 3 root wheel 1024 Jan 3 1994 usr |
---|
640 | -rw-r--r-- 1 root root 312 Aug 1 1994 welcome.msg |
---|
641 | '226 Transfer complete.' |
---|
642 | >>> ftps.quit() |
---|
643 | '221 Goodbye.' |
---|
644 | >>> |
---|
645 | ''' |
---|
646 | ssl_version = ssl.PROTOCOL_SSLv23 |
---|
647 | |
---|
648 | def __init__(self, host='', user='', passwd='', acct='', keyfile=None, |
---|
649 | certfile=None, context=None, |
---|
650 | timeout=_GLOBAL_DEFAULT_TIMEOUT, source_address=None): |
---|
651 | if context is not None and keyfile is not None: |
---|
652 | raise ValueError("context and keyfile arguments are mutually " |
---|
653 | "exclusive") |
---|
654 | if context is not None and certfile is not None: |
---|
655 | raise ValueError("context and certfile arguments are mutually " |
---|
656 | "exclusive") |
---|
657 | self.keyfile = keyfile |
---|
658 | self.certfile = certfile |
---|
659 | if context is None: |
---|
660 | context = ssl._create_stdlib_context(self.ssl_version, |
---|
661 | certfile=certfile, |
---|
662 | keyfile=keyfile) |
---|
663 | self.context = context |
---|
664 | self._prot_p = False |
---|
665 | FTP.__init__(self, host, user, passwd, acct, timeout) |
---|
666 | |
---|
667 | def login(self, user='', passwd='', acct='', secure=True): |
---|
668 | if secure and not isinstance(self.sock, ssl.SSLSocket): |
---|
669 | self.auth() |
---|
670 | return FTP.login(self, user, passwd, acct) |
---|
671 | |
---|
672 | def auth(self): |
---|
673 | '''Set up secure control connection by using TLS/SSL.''' |
---|
674 | if isinstance(self.sock, ssl.SSLSocket): |
---|
675 | raise ValueError("Already using TLS") |
---|
676 | if self.ssl_version >= ssl.PROTOCOL_SSLv23: |
---|
677 | resp = self.voidcmd('AUTH TLS') |
---|
678 | else: |
---|
679 | resp = self.voidcmd('AUTH SSL') |
---|
680 | self.sock = self.context.wrap_socket(self.sock, |
---|
681 | server_hostname=self.host) |
---|
682 | self.file = self.sock.makefile(mode='rb') |
---|
683 | return resp |
---|
684 | |
---|
685 | def prot_p(self): |
---|
686 | '''Set up secure data connection.''' |
---|
687 | # PROT defines whether or not the data channel is to be protected. |
---|
688 | # Though RFC-2228 defines four possible protection levels, |
---|
689 | # RFC-4217 only recommends two, Clear and Private. |
---|
690 | # Clear (PROT C) means that no security is to be used on the |
---|
691 | # data-channel, Private (PROT P) means that the data-channel |
---|
692 | # should be protected by TLS. |
---|
693 | # PBSZ command MUST still be issued, but must have a parameter of |
---|
694 | # '0' to indicate that no buffering is taking place and the data |
---|
695 | # connection should not be encapsulated. |
---|
696 | self.voidcmd('PBSZ 0') |
---|
697 | resp = self.voidcmd('PROT P') |
---|
698 | self._prot_p = True |
---|
699 | return resp |
---|
700 | |
---|
701 | def prot_c(self): |
---|
702 | '''Set up clear text data connection.''' |
---|
703 | resp = self.voidcmd('PROT C') |
---|
704 | self._prot_p = False |
---|
705 | return resp |
---|
706 | |
---|
707 | # --- Overridden FTP methods |
---|
708 | |
---|
709 | def ntransfercmd(self, cmd, rest=None): |
---|
710 | conn, size = FTP.ntransfercmd(self, cmd, rest) |
---|
711 | if self._prot_p: |
---|
712 | conn = self.context.wrap_socket(conn, |
---|
713 | server_hostname=self.host) |
---|
714 | return conn, size |
---|
715 | |
---|
716 | def retrbinary(self, cmd, callback, blocksize=8192, rest=None): |
---|
717 | self.voidcmd('TYPE I') |
---|
718 | conn = self.transfercmd(cmd, rest) |
---|
719 | try: |
---|
720 | while 1: |
---|
721 | data = conn.recv(blocksize) |
---|
722 | if not data: |
---|
723 | break |
---|
724 | callback(data) |
---|
725 | # shutdown ssl layer |
---|
726 | if isinstance(conn, ssl.SSLSocket): |
---|
727 | conn.unwrap() |
---|
728 | finally: |
---|
729 | conn.close() |
---|
730 | return self.voidresp() |
---|
731 | |
---|
732 | def retrlines(self, cmd, callback = None): |
---|
733 | if callback is None: callback = print_line |
---|
734 | resp = self.sendcmd('TYPE A') |
---|
735 | conn = self.transfercmd(cmd) |
---|
736 | fp = conn.makefile('rb') |
---|
737 | try: |
---|
738 | while 1: |
---|
739 | line = fp.readline(self.maxline + 1) |
---|
740 | if len(line) > self.maxline: |
---|
741 | raise Error("got more than %d bytes" % self.maxline) |
---|
742 | if self.debugging > 2: print '*retr*', repr(line) |
---|
743 | if not line: |
---|
744 | break |
---|
745 | if line[-2:] == CRLF: |
---|
746 | line = line[:-2] |
---|
747 | elif line[-1:] == '\n': |
---|
748 | line = line[:-1] |
---|
749 | callback(line) |
---|
750 | # shutdown ssl layer |
---|
751 | if isinstance(conn, ssl.SSLSocket): |
---|
752 | conn.unwrap() |
---|
753 | finally: |
---|
754 | fp.close() |
---|
755 | conn.close() |
---|
756 | return self.voidresp() |
---|
757 | |
---|
758 | def storbinary(self, cmd, fp, blocksize=8192, callback=None, rest=None): |
---|
759 | self.voidcmd('TYPE I') |
---|
760 | conn = self.transfercmd(cmd, rest) |
---|
761 | try: |
---|
762 | while 1: |
---|
763 | buf = fp.read(blocksize) |
---|
764 | if not buf: break |
---|
765 | conn.sendall(buf) |
---|
766 | if callback: callback(buf) |
---|
767 | # shutdown ssl layer |
---|
768 | if isinstance(conn, ssl.SSLSocket): |
---|
769 | conn.unwrap() |
---|
770 | finally: |
---|
771 | conn.close() |
---|
772 | return self.voidresp() |
---|
773 | |
---|
774 | def storlines(self, cmd, fp, callback=None): |
---|
775 | self.voidcmd('TYPE A') |
---|
776 | conn = self.transfercmd(cmd) |
---|
777 | try: |
---|
778 | while 1: |
---|
779 | buf = fp.readline(self.maxline + 1) |
---|
780 | if len(buf) > self.maxline: |
---|
781 | raise Error("got more than %d bytes" % self.maxline) |
---|
782 | if not buf: break |
---|
783 | if buf[-2:] != CRLF: |
---|
784 | if buf[-1] in CRLF: buf = buf[:-1] |
---|
785 | buf = buf + CRLF |
---|
786 | conn.sendall(buf) |
---|
787 | if callback: callback(buf) |
---|
788 | # shutdown ssl layer |
---|
789 | if isinstance(conn, ssl.SSLSocket): |
---|
790 | conn.unwrap() |
---|
791 | finally: |
---|
792 | conn.close() |
---|
793 | return self.voidresp() |
---|
794 | |
---|
795 | __all__.append('FTP_TLS') |
---|
796 | all_errors = (Error, IOError, EOFError, ssl.SSLError) |
---|
797 | |
---|
798 | |
---|
799 | _150_re = None |
---|
800 | |
---|
801 | def parse150(resp): |
---|
802 | '''Parse the '150' response for a RETR request. |
---|
803 | Returns the expected transfer size or None; size is not guaranteed to |
---|
804 | be present in the 150 message. |
---|
805 | ''' |
---|
806 | if resp[:3] != '150': |
---|
807 | raise error_reply, resp |
---|
808 | global _150_re |
---|
809 | if _150_re is None: |
---|
810 | import re |
---|
811 | _150_re = re.compile("150 .* \((\d+) bytes\)", re.IGNORECASE) |
---|
812 | m = _150_re.match(resp) |
---|
813 | if not m: |
---|
814 | return None |
---|
815 | s = m.group(1) |
---|
816 | try: |
---|
817 | return int(s) |
---|
818 | except (OverflowError, ValueError): |
---|
819 | return long(s) |
---|
820 | |
---|
821 | |
---|
822 | _227_re = None |
---|
823 | |
---|
824 | def parse227(resp): |
---|
825 | '''Parse the '227' response for a PASV request. |
---|
826 | Raises error_proto if it does not contain '(h1,h2,h3,h4,p1,p2)' |
---|
827 | Return ('host.addr.as.numbers', port#) tuple.''' |
---|
828 | |
---|
829 | if resp[:3] != '227': |
---|
830 | raise error_reply, resp |
---|
831 | global _227_re |
---|
832 | if _227_re is None: |
---|
833 | import re |
---|
834 | _227_re = re.compile(r'(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)') |
---|
835 | m = _227_re.search(resp) |
---|
836 | if not m: |
---|
837 | raise error_proto, resp |
---|
838 | numbers = m.groups() |
---|
839 | host = '.'.join(numbers[:4]) |
---|
840 | port = (int(numbers[4]) << 8) + int(numbers[5]) |
---|
841 | return host, port |
---|
842 | |
---|
843 | |
---|
844 | def parse229(resp, peer): |
---|
845 | '''Parse the '229' response for a EPSV request. |
---|
846 | Raises error_proto if it does not contain '(|||port|)' |
---|
847 | Return ('host.addr.as.numbers', port#) tuple.''' |
---|
848 | |
---|
849 | if resp[:3] != '229': |
---|
850 | raise error_reply, resp |
---|
851 | left = resp.find('(') |
---|
852 | if left < 0: raise error_proto, resp |
---|
853 | right = resp.find(')', left + 1) |
---|
854 | if right < 0: |
---|
855 | raise error_proto, resp # should contain '(|||port|)' |
---|
856 | if resp[left + 1] != resp[right - 1]: |
---|
857 | raise error_proto, resp |
---|
858 | parts = resp[left + 1:right].split(resp[left+1]) |
---|
859 | if len(parts) != 5: |
---|
860 | raise error_proto, resp |
---|
861 | host = peer[0] |
---|
862 | port = int(parts[3]) |
---|
863 | return host, port |
---|
864 | |
---|
865 | |
---|
866 | def parse257(resp): |
---|
867 | '''Parse the '257' response for a MKD or PWD request. |
---|
868 | This is a response to a MKD or PWD request: a directory name. |
---|
869 | Returns the directoryname in the 257 reply.''' |
---|
870 | |
---|
871 | if resp[:3] != '257': |
---|
872 | raise error_reply, resp |
---|
873 | if resp[3:5] != ' "': |
---|
874 | return '' # Not compliant to RFC 959, but UNIX ftpd does this |
---|
875 | dirname = '' |
---|
876 | i = 5 |
---|
877 | n = len(resp) |
---|
878 | while i < n: |
---|
879 | c = resp[i] |
---|
880 | i = i+1 |
---|
881 | if c == '"': |
---|
882 | if i >= n or resp[i] != '"': |
---|
883 | break |
---|
884 | i = i+1 |
---|
885 | dirname = dirname + c |
---|
886 | return dirname |
---|
887 | |
---|
888 | |
---|
889 | def print_line(line): |
---|
890 | '''Default retrlines callback to print a line.''' |
---|
891 | print line |
---|
892 | |
---|
893 | |
---|
894 | def ftpcp(source, sourcename, target, targetname = '', type = 'I'): |
---|
895 | '''Copy file from one FTP-instance to another.''' |
---|
896 | if not targetname: targetname = sourcename |
---|
897 | type = 'TYPE ' + type |
---|
898 | source.voidcmd(type) |
---|
899 | target.voidcmd(type) |
---|
900 | sourcehost, sourceport = parse227(source.sendcmd('PASV')) |
---|
901 | target.sendport(sourcehost, sourceport) |
---|
902 | # RFC 959: the user must "listen" [...] BEFORE sending the |
---|
903 | # transfer request. |
---|
904 | # So: STOR before RETR, because here the target is a "user". |
---|
905 | treply = target.sendcmd('STOR ' + targetname) |
---|
906 | if treply[:3] not in ('125', '150'): raise error_proto # RFC 959 |
---|
907 | sreply = source.sendcmd('RETR ' + sourcename) |
---|
908 | if sreply[:3] not in ('125', '150'): raise error_proto # RFC 959 |
---|
909 | source.voidresp() |
---|
910 | target.voidresp() |
---|
911 | |
---|
912 | |
---|
913 | class Netrc: |
---|
914 | """Class to parse & provide access to 'netrc' format files. |
---|
915 | |
---|
916 | See the netrc(4) man page for information on the file format. |
---|
917 | |
---|
918 | WARNING: This class is obsolete -- use module netrc instead. |
---|
919 | |
---|
920 | """ |
---|
921 | __defuser = None |
---|
922 | __defpasswd = None |
---|
923 | __defacct = None |
---|
924 | |
---|
925 | def __init__(self, filename=None): |
---|
926 | if filename is None: |
---|
927 | if "HOME" in os.environ: |
---|
928 | filename = os.path.join(os.environ["HOME"], |
---|
929 | ".netrc") |
---|
930 | else: |
---|
931 | raise IOError, \ |
---|
932 | "specify file to load or set $HOME" |
---|
933 | self.__hosts = {} |
---|
934 | self.__macros = {} |
---|
935 | fp = open(filename, "r") |
---|
936 | in_macro = 0 |
---|
937 | while 1: |
---|
938 | line = fp.readline(self.maxline + 1) |
---|
939 | if len(line) > self.maxline: |
---|
940 | raise Error("got more than %d bytes" % self.maxline) |
---|
941 | if not line: break |
---|
942 | if in_macro and line.strip(): |
---|
943 | macro_lines.append(line) |
---|
944 | continue |
---|
945 | elif in_macro: |
---|
946 | self.__macros[macro_name] = tuple(macro_lines) |
---|
947 | in_macro = 0 |
---|
948 | words = line.split() |
---|
949 | host = user = passwd = acct = None |
---|
950 | default = 0 |
---|
951 | i = 0 |
---|
952 | while i < len(words): |
---|
953 | w1 = words[i] |
---|
954 | if i+1 < len(words): |
---|
955 | w2 = words[i + 1] |
---|
956 | else: |
---|
957 | w2 = None |
---|
958 | if w1 == 'default': |
---|
959 | default = 1 |
---|
960 | elif w1 == 'machine' and w2: |
---|
961 | host = w2.lower() |
---|
962 | i = i + 1 |
---|
963 | elif w1 == 'login' and w2: |
---|
964 | user = w2 |
---|
965 | i = i + 1 |
---|
966 | elif w1 == 'password' and w2: |
---|
967 | passwd = w2 |
---|
968 | i = i + 1 |
---|
969 | elif w1 == 'account' and w2: |
---|
970 | acct = w2 |
---|
971 | i = i + 1 |
---|
972 | elif w1 == 'macdef' and w2: |
---|
973 | macro_name = w2 |
---|
974 | macro_lines = [] |
---|
975 | in_macro = 1 |
---|
976 | break |
---|
977 | i = i + 1 |
---|
978 | if default: |
---|
979 | self.__defuser = user or self.__defuser |
---|
980 | self.__defpasswd = passwd or self.__defpasswd |
---|
981 | self.__defacct = acct or self.__defacct |
---|
982 | if host: |
---|
983 | if host in self.__hosts: |
---|
984 | ouser, opasswd, oacct = \ |
---|
985 | self.__hosts[host] |
---|
986 | user = user or ouser |
---|
987 | passwd = passwd or opasswd |
---|
988 | acct = acct or oacct |
---|
989 | self.__hosts[host] = user, passwd, acct |
---|
990 | fp.close() |
---|
991 | |
---|
992 | def get_hosts(self): |
---|
993 | """Return a list of hosts mentioned in the .netrc file.""" |
---|
994 | return self.__hosts.keys() |
---|
995 | |
---|
996 | def get_account(self, host): |
---|
997 | """Returns login information for the named host. |
---|
998 | |
---|
999 | The return value is a triple containing userid, |
---|
1000 | password, and the accounting field. |
---|
1001 | |
---|
1002 | """ |
---|
1003 | host = host.lower() |
---|
1004 | user = passwd = acct = None |
---|
1005 | if host in self.__hosts: |
---|
1006 | user, passwd, acct = self.__hosts[host] |
---|
1007 | user = user or self.__defuser |
---|
1008 | passwd = passwd or self.__defpasswd |
---|
1009 | acct = acct or self.__defacct |
---|
1010 | return user, passwd, acct |
---|
1011 | |
---|
1012 | def get_macros(self): |
---|
1013 | """Return a list of all defined macro names.""" |
---|
1014 | return self.__macros.keys() |
---|
1015 | |
---|
1016 | def get_macro(self, macro): |
---|
1017 | """Return a sequence of lines which define a named macro.""" |
---|
1018 | return self.__macros[macro] |
---|
1019 | |
---|
1020 | |
---|
1021 | |
---|
1022 | def test(): |
---|
1023 | '''Test program. |
---|
1024 | Usage: ftp [-d] [-r[file]] host [-l[dir]] [-d[dir]] [-p] [file] ... |
---|
1025 | |
---|
1026 | -d dir |
---|
1027 | -l list |
---|
1028 | -p password |
---|
1029 | ''' |
---|
1030 | |
---|
1031 | if len(sys.argv) < 2: |
---|
1032 | print test.__doc__ |
---|
1033 | sys.exit(0) |
---|
1034 | |
---|
1035 | debugging = 0 |
---|
1036 | rcfile = None |
---|
1037 | while sys.argv[1] == '-d': |
---|
1038 | debugging = debugging+1 |
---|
1039 | del sys.argv[1] |
---|
1040 | if sys.argv[1][:2] == '-r': |
---|
1041 | # get name of alternate ~/.netrc file: |
---|
1042 | rcfile = sys.argv[1][2:] |
---|
1043 | del sys.argv[1] |
---|
1044 | host = sys.argv[1] |
---|
1045 | ftp = FTP(host) |
---|
1046 | ftp.set_debuglevel(debugging) |
---|
1047 | userid = passwd = acct = '' |
---|
1048 | try: |
---|
1049 | netrc = Netrc(rcfile) |
---|
1050 | except IOError: |
---|
1051 | if rcfile is not None: |
---|
1052 | sys.stderr.write("Could not open account file" |
---|
1053 | " -- using anonymous login.") |
---|
1054 | else: |
---|
1055 | try: |
---|
1056 | userid, passwd, acct = netrc.get_account(host) |
---|
1057 | except KeyError: |
---|
1058 | # no account for host |
---|
1059 | sys.stderr.write( |
---|
1060 | "No account -- using anonymous login.") |
---|
1061 | ftp.login(userid, passwd, acct) |
---|
1062 | for file in sys.argv[2:]: |
---|
1063 | if file[:2] == '-l': |
---|
1064 | ftp.dir(file[2:]) |
---|
1065 | elif file[:2] == '-d': |
---|
1066 | cmd = 'CWD' |
---|
1067 | if file[2:]: cmd = cmd + ' ' + file[2:] |
---|
1068 | resp = ftp.sendcmd(cmd) |
---|
1069 | elif file == '-p': |
---|
1070 | ftp.set_pasv(not ftp.passiveserver) |
---|
1071 | else: |
---|
1072 | ftp.retrbinary('RETR ' + file, \ |
---|
1073 | sys.stdout.write, 1024) |
---|
1074 | ftp.quit() |
---|
1075 | |
---|
1076 | |
---|
1077 | if __name__ == '__main__': |
---|
1078 | test() |
---|