1 """An FTP client class and some helper functions.
3 Based on RFC 959: File Transfer Protocol (FTP), by J. Postel and J. Reynolds
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
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.'
27 A nice test that reveals some of the network dialogue would be:
28 python ftplib.py -d localhost -l -p -l
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.
42 # Import SOCKS module if it exists, else standard socket module socket
44 import SOCKS
; socket
= SOCKS
; del SOCKS
# import SOCKS as socket
45 from socket
import getfqdn
; socket
.getfqdn
= getfqdn
; del getfqdn
48 from socket
import _GLOBAL_DEFAULT_TIMEOUT
50 __all__
= ["FTP","Netrc"]
52 # Magic number from <socket.h>
53 MSG_OOB
= 0x1 # Process data out of band
56 # The standard FTP server control port
60 # Exception raised when an error or invalid response is received
61 class Error(Exception): pass
62 class error_reply(Error
): pass # unexpected [123]xx reply
63 class error_temp(Error
): pass # 4xx errors
64 class error_perm(Error
): pass # 5xx errors
65 class error_proto(Error
): pass # response does not begin with [1-5]
68 # All exceptions (hopefully) that may be raised here and that aren't
69 # (always) programming errors on our side
70 all_errors
= (Error
, IOError, EOFError)
73 # Line terminators (we always output CRLF, but accept any of CRLF, CR, LF)
79 '''An FTP client class.
81 To create a connection, call the class using these arguments:
82 host, user, passwd, acct, timeout
84 The first four arguments are all strings, and have default value ''.
85 timeout must be numeric and defaults to None if not passed,
86 meaning that no timeout will be set on any ftp socket(s)
87 If a timeout is passed, then this is now the default timeout for all ftp
88 socket operations for this instance.
90 Then use self.connect() with optional host and port argument.
92 To download a file, use ftp.retrlines('RETR ' + filename),
93 or ftp.retrbinary() with slightly different arguments.
94 To upload a file, use ftp.storlines() or ftp.storbinary(),
95 which have an open file as argument (see their definitions
97 The download/upload functions first issue appropriate TYPE
98 and PORT or PASV commands.
109 # Initialization method (called by class instantiation).
110 # Initialize host to localhost, port to standard ftp port
111 # Optional arguments are host (for connect()),
112 # and user, passwd, acct (for login())
113 def __init__(self
, host
='', user
='', passwd
='', acct
='',
114 timeout
=_GLOBAL_DEFAULT_TIMEOUT
):
115 self
.timeout
= timeout
119 self
.login(user
, passwd
, acct
)
121 def connect(self
, host
='', port
=0, timeout
=-999):
122 '''Connect to host. Arguments are:
123 - host: hostname to connect to (string, default previous host)
124 - port: port to connect to (integer, default previous port)
131 self
.timeout
= timeout
132 self
.sock
= socket
.create_connection((self
.host
, self
.port
), self
.timeout
)
133 self
.af
= self
.sock
.family
134 self
.file = self
.sock
.makefile('rb')
135 self
.welcome
= self
.getresp()
138 def getwelcome(self
):
139 '''Get the welcome message from the server.
140 (this is read and squirreled away by connect())'''
142 print '*welcome*', self
.sanitize(self
.welcome
)
145 def set_debuglevel(self
, level
):
146 '''Set the debugging level.
147 The required argument level means:
148 0: no debugging output (default)
149 1: print commands and responses but not body text etc.
150 2: also print raw lines read and sent before stripping CR/LF'''
151 self
.debugging
= level
152 debug
= set_debuglevel
154 def set_pasv(self
, val
):
155 '''Use passive or active mode for data transfers.
156 With a false argument, use the normal PORT mode,
157 With a true argument, use the PASV command.'''
158 self
.passiveserver
= val
160 # Internal: "sanitize" a string for printing
161 def sanitize(self
, s
):
162 if s
[:5] == 'pass ' or s
[:5] == 'PASS ':
164 while i
> 5 and s
[i
-1] in '\r\n':
166 s
= s
[:5] + '*'*(i
-5) + s
[i
:]
169 # Internal: send one line to the server, appending CRLF
170 def putline(self
, line
):
172 if self
.debugging
> 1: print '*put*', self
.sanitize(line
)
173 self
.sock
.sendall(line
)
175 # Internal: send one command to the server (through putline())
176 def putcmd(self
, line
):
177 if self
.debugging
: print '*cmd*', self
.sanitize(line
)
180 # Internal: return one line from the server, stripping CRLF.
181 # Raise EOFError if the connection is closed
183 line
= self
.file.readline()
184 if self
.debugging
> 1:
185 print '*get*', self
.sanitize(line
)
186 if not line
: raise EOFError
187 if line
[-2:] == CRLF
: line
= line
[:-2]
188 elif line
[-1:] in CRLF
: line
= line
[:-1]
191 # Internal: get a response from the server, which may possibly
192 # consist of multiple lines. Return a single string with no
193 # trailing CRLF. If the response consists of multiple lines,
194 # these are separated by '\n' characters in the string
195 def getmultiline(self
):
196 line
= self
.getline()
200 nextline
= self
.getline()
201 line
= line
+ ('\n' + nextline
)
202 if nextline
[:3] == code
and \
203 nextline
[3:4] != '-':
207 # Internal: get a response from the server.
208 # Raise various errors if the response indicates an error
210 resp
= self
.getmultiline()
211 if self
.debugging
: print '*resp*', self
.sanitize(resp
)
212 self
.lastresp
= resp
[:3]
214 if c
in ('1', '2', '3'):
217 raise error_temp
, resp
219 raise error_perm
, resp
220 raise error_proto
, resp
223 """Expect a response beginning with '2'."""
224 resp
= self
.getresp()
226 raise error_reply
, resp
230 '''Abort a file transfer. Uses out-of-band data.
231 This does not follow the procedure from the RFC to send Telnet
232 IP and Synch; that doesn't seem to work with the servers I've
233 tried. Instead, just send the ABOR command as OOB data.'''
235 if self
.debugging
> 1: print '*put urgent*', self
.sanitize(line
)
236 self
.sock
.sendall(line
, MSG_OOB
)
237 resp
= self
.getmultiline()
238 if resp
[:3] not in ('426', '226'):
239 raise error_proto
, resp
241 def sendcmd(self
, cmd
):
242 '''Send a command and return the response.'''
244 return self
.getresp()
246 def voidcmd(self
, cmd
):
247 """Send a command and expect a response beginning with '2'."""
249 return self
.voidresp()
251 def sendport(self
, host
, port
):
252 '''Send a PORT command with the current host and the given
255 hbytes
= host
.split('.')
256 pbytes
= [repr(port
//256), repr(port
%256)]
257 bytes
= hbytes
+ pbytes
258 cmd
= 'PORT ' + ','.join(bytes
)
259 return self
.voidcmd(cmd
)
261 def sendeprt(self
, host
, port
):
262 '''Send a EPRT command with the current host and the given port number.'''
264 if self
.af
== socket
.AF_INET
:
266 if self
.af
== socket
.AF_INET6
:
269 raise error_proto
, 'unsupported address family'
270 fields
= ['', repr(af
), host
, repr(port
), '']
271 cmd
= 'EPRT ' + '|'.join(fields
)
272 return self
.voidcmd(cmd
)
275 '''Create a new socket and send a PORT command for it.'''
276 msg
= "getaddrinfo returns an empty list"
278 for res
in socket
.getaddrinfo(None, 0, self
.af
, socket
.SOCK_STREAM
, 0, socket
.AI_PASSIVE
):
279 af
, socktype
, proto
, canonname
, sa
= res
281 sock
= socket
.socket(af
, socktype
, proto
)
283 except socket
.error
, msg
:
290 raise socket
.error
, msg
292 port
= sock
.getsockname()[1] # Get proper port
293 host
= self
.sock
.getsockname()[0] # Get proper host
294 if self
.af
== socket
.AF_INET
:
295 resp
= self
.sendport(host
, port
)
297 resp
= self
.sendeprt(host
, port
)
301 if self
.af
== socket
.AF_INET
:
302 host
, port
= parse227(self
.sendcmd('PASV'))
304 host
, port
= parse229(self
.sendcmd('EPSV'), self
.sock
.getpeername())
307 def ntransfercmd(self
, cmd
, rest
=None):
308 """Initiate a transfer over the data connection.
310 If the transfer is active, send a port command and the
311 transfer command, and accept the connection. If the server is
312 passive, send a pasv command, connect to it, and start the
313 transfer command. Either way, return the socket for the
314 connection and the expected size of the transfer. The
315 expected size may be None if it could not be determined.
317 Optional `rest' argument can be a string that is sent as the
318 argument to a REST command. This is essentially a server
319 marker used to tell the server to skip over any data up to the
323 if self
.passiveserver
:
324 host
, port
= self
.makepasv()
325 conn
= socket
.create_connection((host
, port
), self
.timeout
)
327 self
.sendcmd("REST %s" % rest
)
328 resp
= self
.sendcmd(cmd
)
329 # Some servers apparently send a 200 reply to
330 # a LIST or STOR command, before the 150 reply
331 # (and way before the 226 reply). This seems to
332 # be in violation of the protocol (which only allows
333 # 1xx or error messages for LIST), so we just discard
336 resp
= self
.getresp()
338 raise error_reply
, resp
340 sock
= self
.makeport()
342 self
.sendcmd("REST %s" % rest
)
343 resp
= self
.sendcmd(cmd
)
346 resp
= self
.getresp()
348 raise error_reply
, resp
349 conn
, sockaddr
= sock
.accept()
350 if resp
[:3] == '150':
351 # this is conditional in case we received a 125
352 size
= parse150(resp
)
355 def transfercmd(self
, cmd
, rest
=None):
356 """Like ntransfercmd() but returns only the socket."""
357 return self
.ntransfercmd(cmd
, rest
)[0]
359 def login(self
, user
= '', passwd
= '', acct
= ''):
360 '''Login, default anonymous.'''
361 if not user
: user
= 'anonymous'
362 if not passwd
: passwd
= ''
363 if not acct
: acct
= ''
364 if user
== 'anonymous' and passwd
in ('', '-'):
365 # If there is no anonymous ftp password specified
366 # then we'll just use anonymous@
367 # We don't send any other thing because:
368 # - We want to remain anonymous
369 # - We want to stop SPAM
370 # - We don't want to let ftp sites to discriminate by the user,
372 passwd
= passwd
+ 'anonymous@'
373 resp
= self
.sendcmd('USER ' + user
)
374 if resp
[0] == '3': resp
= self
.sendcmd('PASS ' + passwd
)
375 if resp
[0] == '3': resp
= self
.sendcmd('ACCT ' + acct
)
377 raise error_reply
, resp
380 def retrbinary(self
, cmd
, callback
, blocksize
=8192, rest
=None):
381 """Retrieve data in binary mode. A new port is created for you.
385 callback: A single parameter callable to be called on each
387 blocksize: The maximum number of bytes to read from the
388 socket at one time. [default: 8192]
389 rest: Passed to transfercmd(). [default: None]
394 self
.voidcmd('TYPE I')
395 conn
= self
.transfercmd(cmd
, rest
)
397 data
= conn
.recv(blocksize
)
402 return self
.voidresp()
404 def retrlines(self
, cmd
, callback
= None):
405 """Retrieve data in line mode. A new port is created for you.
408 cmd: A RETR, LIST, NLST, or MLSD command.
409 callback: An optional single parameter callable that is called
410 for each line with the trailing CRLF stripped.
411 [default: print_line()]
416 if callback
is None: callback
= print_line
417 resp
= self
.sendcmd('TYPE A')
418 conn
= self
.transfercmd(cmd
)
419 fp
= conn
.makefile('rb')
422 if self
.debugging
> 2: print '*retr*', repr(line
)
425 if line
[-2:] == CRLF
:
427 elif line
[-1:] == '\n':
432 return self
.voidresp()
434 def storbinary(self
, cmd
, fp
, blocksize
=8192, callback
=None, rest
=None):
435 """Store a file in binary mode. A new port is created for you.
439 fp: A file-like object with a read(num_bytes) method.
440 blocksize: The maximum data size to read from fp and send over
441 the connection at once. [default: 8192]
442 callback: An optional single parameter callable that is called on
443 on each block of data after it is sent. [default: None]
444 rest: Passed to transfercmd(). [default: None]
449 self
.voidcmd('TYPE I')
450 conn
= self
.transfercmd(cmd
, rest
)
452 buf
= fp
.read(blocksize
)
455 if callback
: callback(buf
)
457 return self
.voidresp()
459 def storlines(self
, cmd
, fp
, callback
=None):
460 """Store a file in line mode. A new port is created for you.
464 fp: A file-like object with a readline() method.
465 callback: An optional single parameter callable that is called on
466 on each line after it is sent. [default: None]
471 self
.voidcmd('TYPE A')
472 conn
= self
.transfercmd(cmd
)
477 if buf
[-1] in CRLF
: buf
= buf
[:-1]
480 if callback
: callback(buf
)
482 return self
.voidresp()
484 def acct(self
, password
):
485 '''Send new account name.'''
486 cmd
= 'ACCT ' + password
487 return self
.voidcmd(cmd
)
489 def nlst(self
, *args
):
490 '''Return a list of files in a given directory (default the current).'''
493 cmd
= cmd
+ (' ' + arg
)
495 self
.retrlines(cmd
, files
.append
)
498 def dir(self
, *args
):
499 '''List a directory in long form.
500 By default list current directory to stdout.
501 Optional last argument is callback function; all
502 non-empty arguments before it are concatenated to the
503 LIST command. (This *should* only be used for a pathname.)'''
506 if args
[-1:] and type(args
[-1]) != type(''):
507 args
, func
= args
[:-1], args
[-1]
510 cmd
= cmd
+ (' ' + arg
)
511 self
.retrlines(cmd
, func
)
513 def rename(self
, fromname
, toname
):
515 resp
= self
.sendcmd('RNFR ' + fromname
)
517 raise error_reply
, resp
518 return self
.voidcmd('RNTO ' + toname
)
520 def delete(self
, filename
):
522 resp
= self
.sendcmd('DELE ' + filename
)
523 if resp
[:3] in ('250', '200'):
526 raise error_reply
, resp
528 def cwd(self
, dirname
):
529 '''Change to a directory.'''
532 return self
.voidcmd('CDUP')
533 except error_perm
, msg
:
534 if msg
.args
[0][:3] != '500':
537 dirname
= '.' # does nothing, but could return error
538 cmd
= 'CWD ' + dirname
539 return self
.voidcmd(cmd
)
541 def size(self
, filename
):
542 '''Retrieve the size of a file.'''
543 # The SIZE command is defined in RFC-3659
544 resp
= self
.sendcmd('SIZE ' + filename
)
545 if resp
[:3] == '213':
549 except (OverflowError, ValueError):
552 def mkd(self
, dirname
):
553 '''Make a directory, return its full pathname.'''
554 resp
= self
.sendcmd('MKD ' + dirname
)
555 return parse257(resp
)
557 def rmd(self
, dirname
):
558 '''Remove a directory.'''
559 return self
.voidcmd('RMD ' + dirname
)
562 '''Return current working directory.'''
563 resp
= self
.sendcmd('PWD')
564 return parse257(resp
)
567 '''Quit, and close the connection.'''
568 resp
= self
.voidcmd('QUIT')
573 '''Close the connection without assuming anything about it.'''
577 self
.file = self
.sock
= None
586 '''A FTP subclass which adds TLS support to FTP as described
589 Connect as usual to port 21 implicitly securing the FTP control
590 connection before authenticating.
592 Securing the data connection requires user to explicitly ask
593 for it by calling prot_p() method.
596 >>> from ftplib import FTP_TLS
597 >>> ftps = FTP_TLS('ftp.python.org')
598 >>> ftps.login() # login anonimously previously securing control channel
599 '230 Guest login ok, access restrictions apply.'
600 >>> ftps.prot_p() # switch to secure data connection
601 '200 Protection level set to P'
602 >>> ftps.retrlines('LIST') # list directory content securely
604 drwxr-xr-x 8 root wheel 1024 Jan 3 1994 .
605 drwxr-xr-x 8 root wheel 1024 Jan 3 1994 ..
606 drwxr-xr-x 2 root wheel 1024 Jan 3 1994 bin
607 drwxr-xr-x 2 root wheel 1024 Jan 3 1994 etc
608 d-wxrwxr-x 2 ftp wheel 1024 Sep 5 13:43 incoming
609 drwxr-xr-x 2 root wheel 1024 Nov 17 1993 lib
610 drwxr-xr-x 6 1094 wheel 1024 Sep 13 19:07 pub
611 drwxr-xr-x 3 root wheel 1024 Jan 3 1994 usr
612 -rw-r--r-- 1 root root 312 Aug 1 1994 welcome.msg
613 '226 Transfer complete.'
618 ssl_version
= ssl
.PROTOCOL_TLSv1
620 def __init__(self
, host
='', user
='', passwd
='', acct
='', keyfile
=None,
621 certfile
=None, timeout
=_GLOBAL_DEFAULT_TIMEOUT
):
622 self
.keyfile
= keyfile
623 self
.certfile
= certfile
625 FTP
.__init
__(self
, host
, user
, passwd
, acct
, timeout
)
627 def login(self
, user
='', passwd
='', acct
='', secure
=True):
628 if secure
and not isinstance(self
.sock
, ssl
.SSLSocket
):
630 return FTP
.login(self
, user
, passwd
, acct
)
633 '''Set up secure control connection by using TLS/SSL.'''
634 if isinstance(self
.sock
, ssl
.SSLSocket
):
635 raise ValueError("Already using TLS")
636 if self
.ssl_version
== ssl
.PROTOCOL_TLSv1
:
637 resp
= self
.voidcmd('AUTH TLS')
639 resp
= self
.voidcmd('AUTH SSL')
640 self
.sock
= ssl
.wrap_socket(self
.sock
, self
.keyfile
, self
.certfile
,
641 ssl_version
=self
.ssl_version
)
642 self
.file = self
.sock
.makefile(mode
='rb')
646 '''Set up secure data connection.'''
647 # PROT defines whether or not the data channel is to be protected.
648 # Though RFC-2228 defines four possible protection levels,
649 # RFC-4217 only recommends two, Clear and Private.
650 # Clear (PROT C) means that no security is to be used on the
651 # data-channel, Private (PROT P) means that the data-channel
652 # should be protected by TLS.
653 # PBSZ command MUST still be issued, but must have a parameter of
654 # '0' to indicate that no buffering is taking place and the data
655 # connection should not be encapsulated.
656 self
.voidcmd('PBSZ 0')
657 resp
= self
.voidcmd('PROT P')
662 '''Set up clear text data connection.'''
663 resp
= self
.voidcmd('PROT C')
667 # --- Overridden FTP methods
669 def ntransfercmd(self
, cmd
, rest
=None):
670 conn
, size
= FTP
.ntransfercmd(self
, cmd
, rest
)
672 conn
= ssl
.wrap_socket(conn
, self
.keyfile
, self
.certfile
,
673 ssl_version
=self
.ssl_version
)
676 def retrbinary(self
, cmd
, callback
, blocksize
=8192, rest
=None):
677 self
.voidcmd('TYPE I')
678 conn
= self
.transfercmd(cmd
, rest
)
681 data
= conn
.recv(blocksize
)
686 if isinstance(conn
, ssl
.SSLSocket
):
690 return self
.voidresp()
692 def retrlines(self
, cmd
, callback
= None):
693 if callback
is None: callback
= print_line
694 resp
= self
.sendcmd('TYPE A')
695 conn
= self
.transfercmd(cmd
)
696 fp
= conn
.makefile('rb')
700 if self
.debugging
> 2: print '*retr*', repr(line
)
703 if line
[-2:] == CRLF
:
705 elif line
[-1:] == '\n':
709 if isinstance(conn
, ssl
.SSLSocket
):
714 return self
.voidresp()
716 def storbinary(self
, cmd
, fp
, blocksize
=8192, callback
=None, rest
=None):
717 self
.voidcmd('TYPE I')
718 conn
= self
.transfercmd(cmd
, rest
)
721 buf
= fp
.read(blocksize
)
724 if callback
: callback(buf
)
726 if isinstance(conn
, ssl
.SSLSocket
):
730 return self
.voidresp()
732 def storlines(self
, cmd
, fp
, callback
=None):
733 self
.voidcmd('TYPE A')
734 conn
= self
.transfercmd(cmd
)
740 if buf
[-1] in CRLF
: buf
= buf
[:-1]
743 if callback
: callback(buf
)
745 if isinstance(conn
, ssl
.SSLSocket
):
749 return self
.voidresp()
751 __all__
.append('FTP_TLS')
752 all_errors
= (Error
, IOError, EOFError, ssl
.SSLError
)
758 '''Parse the '150' response for a RETR request.
759 Returns the expected transfer size or None; size is not guaranteed to
760 be present in the 150 message.
762 if resp
[:3] != '150':
763 raise error_reply
, resp
767 _150_re
= re
.compile("150 .* \((\d+) bytes\)", re
.IGNORECASE
)
768 m
= _150_re
.match(resp
)
774 except (OverflowError, ValueError):
781 '''Parse the '227' response for a PASV request.
782 Raises error_proto if it does not contain '(h1,h2,h3,h4,p1,p2)'
783 Return ('host.addr.as.numbers', port#) tuple.'''
785 if resp
[:3] != '227':
786 raise error_reply
, resp
790 _227_re
= re
.compile(r
'(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)')
791 m
= _227_re
.search(resp
)
793 raise error_proto
, resp
795 host
= '.'.join(numbers
[:4])
796 port
= (int(numbers
[4]) << 8) + int(numbers
[5])
800 def parse229(resp
, peer
):
801 '''Parse the '229' response for a EPSV request.
802 Raises error_proto if it does not contain '(|||port|)'
803 Return ('host.addr.as.numbers', port#) tuple.'''
805 if resp
[:3] != '229':
806 raise error_reply
, resp
807 left
= resp
.find('(')
808 if left
< 0: raise error_proto
, resp
809 right
= resp
.find(')', left
+ 1)
811 raise error_proto
, resp
# should contain '(|||port|)'
812 if resp
[left
+ 1] != resp
[right
- 1]:
813 raise error_proto
, resp
814 parts
= resp
[left
+ 1:right
].split(resp
[left
+1])
816 raise error_proto
, resp
823 '''Parse the '257' response for a MKD or PWD request.
824 This is a response to a MKD or PWD request: a directory name.
825 Returns the directoryname in the 257 reply.'''
827 if resp
[:3] != '257':
828 raise error_reply
, resp
829 if resp
[3:5] != ' "':
830 return '' # Not compliant to RFC 959, but UNIX ftpd does this
838 if i
>= n
or resp
[i
] != '"':
841 dirname
= dirname
+ c
845 def print_line(line
):
846 '''Default retrlines callback to print a line.'''
850 def ftpcp(source
, sourcename
, target
, targetname
= '', type = 'I'):
851 '''Copy file from one FTP-instance to another.'''
852 if not targetname
: targetname
= sourcename
853 type = 'TYPE ' + type
856 sourcehost
, sourceport
= parse227(source
.sendcmd('PASV'))
857 target
.sendport(sourcehost
, sourceport
)
858 # RFC 959: the user must "listen" [...] BEFORE sending the
860 # So: STOR before RETR, because here the target is a "user".
861 treply
= target
.sendcmd('STOR ' + targetname
)
862 if treply
[:3] not in ('125', '150'): raise error_proto
# RFC 959
863 sreply
= source
.sendcmd('RETR ' + sourcename
)
864 if sreply
[:3] not in ('125', '150'): raise error_proto
# RFC 959
870 """Class to parse & provide access to 'netrc' format files.
872 See the netrc(4) man page for information on the file format.
874 WARNING: This class is obsolete -- use module netrc instead.
881 def __init__(self
, filename
=None):
883 if "HOME" in os
.environ
:
884 filename
= os
.path
.join(os
.environ
["HOME"],
888 "specify file to load or set $HOME"
891 fp
= open(filename
, "r")
896 if in_macro
and line
.strip():
897 macro_lines
.append(line
)
900 self
.__macros
[macro_name
] = tuple(macro_lines
)
903 host
= user
= passwd
= acct
= None
906 while i
< len(words
):
914 elif w1
== 'machine' and w2
:
917 elif w1
== 'login' and w2
:
920 elif w1
== 'password' and w2
:
923 elif w1
== 'account' and w2
:
926 elif w1
== 'macdef' and w2
:
933 self
.__defuser
= user
or self
.__defuser
934 self
.__defpasswd
= passwd
or self
.__defpasswd
935 self
.__defacct
= acct
or self
.__defacct
937 if host
in self
.__hosts
:
938 ouser
, opasswd
, oacct
= \
941 passwd
= passwd
or opasswd
943 self
.__hosts
[host
] = user
, passwd
, acct
947 """Return a list of hosts mentioned in the .netrc file."""
948 return self
.__hosts
.keys()
950 def get_account(self
, host
):
951 """Returns login information for the named host.
953 The return value is a triple containing userid,
954 password, and the accounting field.
958 user
= passwd
= acct
= None
959 if host
in self
.__hosts
:
960 user
, passwd
, acct
= self
.__hosts
[host
]
961 user
= user
or self
.__defuser
962 passwd
= passwd
or self
.__defpasswd
963 acct
= acct
or self
.__defacct
964 return user
, passwd
, acct
966 def get_macros(self
):
967 """Return a list of all defined macro names."""
968 return self
.__macros
.keys()
970 def get_macro(self
, macro
):
971 """Return a sequence of lines which define a named macro."""
972 return self
.__macros
[macro
]
978 Usage: ftp [-d] [-r[file]] host [-l[dir]] [-d[dir]] [-p] [file] ...
985 if len(sys
.argv
) < 2:
991 while sys
.argv
[1] == '-d':
992 debugging
= debugging
+1
994 if sys
.argv
[1][:2] == '-r':
995 # get name of alternate ~/.netrc file:
996 rcfile
= sys
.argv
[1][2:]
1000 ftp
.set_debuglevel(debugging
)
1001 userid
= passwd
= acct
= ''
1003 netrc
= Netrc(rcfile
)
1005 if rcfile
is not None:
1006 sys
.stderr
.write("Could not open account file"
1007 " -- using anonymous login.")
1010 userid
, passwd
, acct
= netrc
.get_account(host
)
1012 # no account for host
1014 "No account -- using anonymous login.")
1015 ftp
.login(userid
, passwd
, acct
)
1016 for file in sys
.argv
[2:]:
1017 if file[:2] == '-l':
1019 elif file[:2] == '-d':
1021 if file[2:]: cmd
= cmd
+ ' ' + file[2:]
1022 resp
= ftp
.sendcmd(cmd
)
1024 ftp
.set_pasv(not ftp
.passiveserver
)
1026 ftp
.retrbinary('RETR ' + file, \
1027 sys
.stdout
.write
, 1024)
1031 if __name__
== '__main__':