ftplib.py 28 KB
Newer Older
1 2
"""An FTP client class and some helper functions.

3
Based on RFC 959: File Transfer Protocol (FTP), by J. Postel and J. Reynolds
4 5 6 7 8

Example:

>>> from ftplib import FTP
>>> 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 12 13 14 15 16 17 18 19 20 21
>>> ftp.retrlines('LIST') # list directory contents
total 9
drwxr-xr-x   8 root     wheel        1024 Jan  3  1994 .
drwxr-xr-x   8 root     wheel        1024 Jan  3  1994 ..
drwxr-xr-x   2 root     wheel        1024 Jan  3  1994 bin
drwxr-xr-x   2 root     wheel        1024 Jan  3  1994 etc
d-wxrwxr-x   2 ftp      wheel        1024 Sep  5 13:43 incoming
drwxr-xr-x   2 root     wheel        1024 Nov 17  1993 lib
drwxr-xr-x   6 1094     wheel        1024 Sep 13 19:07 pub
drwxr-xr-x   3 root     wheel        1024 Jan  3  1994 usr
-rw-r--r--   1 root     root          312 Aug  1  1994 welcome.msg
22
'226 Transfer complete.'
23
>>> ftp.quit()
24
'221 Goodbye.'
Tim Peters's avatar
Tim Peters committed
25
>>>
26 27 28

A nice test that reveals some of the network dialogue would be:
python ftplib.py -d localhost -l -p -l
29
"""
30

Tim Peters's avatar
Tim Peters committed
31
#
32 33 34
# Changes and improvements suggested by Steve Majewski.
# Modified by Jack to work on the mac.
# Modified by Siebren to support docstrings and PASV.
35
# Modified by Phil Schwartz to add storbinary and storlines callbacks.
36
#
37

Guido van Rossum's avatar
Guido van Rossum committed
38 39 40
import os
import sys

41 42
# Import SOCKS module if it exists, else standard socket module socket
try:
Tim Peters's avatar
Tim Peters committed
43 44
    import SOCKS; socket = SOCKS; del SOCKS # import SOCKS as socket
    from socket import getfqdn; socket.getfqdn = getfqdn; del getfqdn
45
except ImportError:
Tim Peters's avatar
Tim Peters committed
46
    import socket
Georg Brandl's avatar
Georg Brandl committed
47
from socket import _GLOBAL_DEFAULT_TIMEOUT
48

Skip Montanaro's avatar
Skip Montanaro committed
49
__all__ = ["FTP","Netrc"]
Guido van Rossum's avatar
Guido van Rossum committed
50

51
# Magic number from <socket.h>
Tim Peters's avatar
Tim Peters committed
52
MSG_OOB = 0x1                           # Process data out of band
53 54


55
# The standard FTP server control port
Guido van Rossum's avatar
Guido van Rossum committed
56 57 58
FTP_PORT = 21


59
# Exception raised when an error or invalid response is received
60
class Error(Exception): pass
Tim Peters's avatar
Tim Peters committed
61 62 63 64
class error_reply(Error): pass          # unexpected [123]xx reply
class error_temp(Error): pass           # 4xx errors
class error_perm(Error): pass           # 5xx errors
class error_proto(Error): pass          # response does not begin with [1-5]
Guido van Rossum's avatar
Guido van Rossum committed
65 66


67 68
# All exceptions (hopefully) that may be raised here and that aren't
# (always) programming errors on our side
Christian Heimes's avatar
Christian Heimes committed
69
all_errors = (Error, IOError, EOFError)
70 71


Guido van Rossum's avatar
Guido van Rossum committed
72 73
# Line terminators (we always output CRLF, but accept any of CRLF, CR, LF)
CRLF = '\r\n'
74
B_CRLF = b'\r\n'
Guido van Rossum's avatar
Guido van Rossum committed
75 76 77 78

# The class itself
class FTP:

Tim Peters's avatar
Tim Peters committed
79
    '''An FTP client class.
80

81 82 83 84 85 86 87 88 89
    To create a connection, call the class using these arguments:
            host, user, passwd, acct, timeout

    The first four arguments are all strings, and have default value ''.
    timeout must be numeric and defaults to None if not passed,
    meaning that no timeout will be set on any ftp socket(s)
    If a timeout is passed, then this is now the default timeout for all ftp
    socket operations for this instance.

Tim Peters's avatar
Tim Peters committed
90
    Then use self.connect() with optional host and port argument.
91

Tim Peters's avatar
Tim Peters committed
92 93 94 95 96 97 98
    To download a file, use ftp.retrlines('RETR ' + filename),
    or ftp.retrbinary() with slightly different arguments.
    To upload a file, use ftp.storlines() or ftp.storbinary(),
    which have an open file as argument (see their definitions
    below for details).
    The download/upload functions first issue appropriate TYPE
    and PORT or PASV commands.
99
    '''
100

101 102 103 104 105 106 107
    debugging = 0
    host = ''
    port = FTP_PORT
    sock = None
    file = None
    welcome = None
    passiveserver = 1
108
    encoding = "latin1"
109

Tim Peters's avatar
Tim Peters committed
110 111 112 113
    # Initialization method (called by class instantiation).
    # Initialize host to localhost, port to standard ftp port
    # Optional arguments are host (for connect()),
    # and user, passwd, acct (for login())
Georg Brandl's avatar
Georg Brandl committed
114 115
    def __init__(self, host='', user='', passwd='', acct='',
                 timeout=_GLOBAL_DEFAULT_TIMEOUT):
116
        self.timeout = timeout
Tim Peters's avatar
Tim Peters committed
117
        if host:
118
            self.connect(host)
119 120
            if user:
                self.login(user, passwd, acct)
Tim Peters's avatar
Tim Peters committed
121

Georg Brandl's avatar
Georg Brandl committed
122
    def connect(self, host='', port=0, timeout=-999):
123
        '''Connect to host.  Arguments are:
124 125 126 127 128 129 130
         - host: hostname to connect to (string, default previous host)
         - port: port to connect to (integer, default previous port)
        '''
        if host != '':
            self.host = host
        if port > 0:
            self.port = port
Georg Brandl's avatar
Georg Brandl committed
131
        if timeout != -999:
132 133 134
            self.timeout = timeout
        self.sock = socket.create_connection((self.host, self.port), self.timeout)
        self.af = self.sock.family
135
        self.file = self.sock.makefile('r', encoding=self.encoding)
136 137
        self.welcome = self.getresp()
        return self.welcome
Tim Peters's avatar
Tim Peters committed
138 139 140 141 142

    def getwelcome(self):
        '''Get the welcome message from the server.
        (this is read and squirreled away by connect())'''
        if self.debugging:
143
            print('*welcome*', self.sanitize(self.welcome))
Tim Peters's avatar
Tim Peters committed
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
        return self.welcome

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

    def set_pasv(self, val):
        '''Use passive or active mode for data transfers.
        With a false argument, use the normal PORT mode,
        With a true argument, use the PASV command.'''
        self.passiveserver = val

    # Internal: "sanitize" a string for printing
    def sanitize(self, s):
        if s[:5] == 'pass ' or s[:5] == 'PASS ':
            i = len(s)
            while i > 5 and s[i-1] in '\r\n':
                i = i-1
            s = s[:5] + '*'*(i-5) + s[i:]
168
        return repr(s)
Tim Peters's avatar
Tim Peters committed
169 170 171 172

    # Internal: send one line to the server, appending CRLF
    def putline(self, line):
        line = line + CRLF
173
        if self.debugging > 1: print('*put*', self.sanitize(line))
174
        self.sock.sendall(line.encode(self.encoding))
Tim Peters's avatar
Tim Peters committed
175 176 177

    # Internal: send one command to the server (through putline())
    def putcmd(self, line):
178
        if self.debugging: print('*cmd*', self.sanitize(line))
Tim Peters's avatar
Tim Peters committed
179 180 181 182 183 184 185
        self.putline(line)

    # Internal: return one line from the server, stripping CRLF.
    # Raise EOFError if the connection is closed
    def getline(self):
        line = self.file.readline()
        if self.debugging > 1:
186
            print('*get*', self.sanitize(line))
Tim Peters's avatar
Tim Peters committed
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211
        if not line: raise EOFError
        if line[-2:] == CRLF: line = line[:-2]
        elif line[-1:] in CRLF: line = line[:-1]
        return line

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

    # Internal: get a response from the server.
    # Raise various errors if the response indicates an error
    def getresp(self):
        resp = self.getmultiline()
212
        if self.debugging: print('*resp*', self.sanitize(resp))
Tim Peters's avatar
Tim Peters committed
213 214
        self.lastresp = resp[:3]
        c = resp[:1]
215 216
        if c in ('1', '2', '3'):
            return resp
Tim Peters's avatar
Tim Peters committed
217
        if c == '4':
218
            raise error_temp(resp)
Tim Peters's avatar
Tim Peters committed
219
        if c == '5':
220 221
            raise error_perm(resp)
        raise error_proto(resp)
Tim Peters's avatar
Tim Peters committed
222 223 224 225

    def voidresp(self):
        """Expect a response beginning with '2'."""
        resp = self.getresp()
Benjamin Peterson's avatar
Benjamin Peterson committed
226
        if resp[:1] != '2':
227
            raise error_reply(resp)
Tim Peters's avatar
Tim Peters committed
228 229 230 231 232 233 234 235
        return resp

    def abort(self):
        '''Abort a file transfer.  Uses out-of-band data.
        This does not follow the procedure from the RFC to send Telnet
        IP and Synch; that doesn't seem to work with the servers I've
        tried.  Instead, just send the ABOR command as OOB data.'''
        line = 'ABOR' + CRLF
236
        if self.debugging > 1: print('*put urgent*', self.sanitize(line))
237
        self.sock.sendall(line, MSG_OOB)
Tim Peters's avatar
Tim Peters committed
238 239
        resp = self.getmultiline()
        if resp[:3] not in ('426', '226'):
240
            raise error_proto(resp)
Tim Peters's avatar
Tim Peters committed
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255

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

    def voidcmd(self, cmd):
        """Send a command and expect a response beginning with '2'."""
        self.putcmd(cmd)
        return self.voidresp()

    def sendport(self, host, port):
        '''Send a PORT command with the current host and the given
        port number.
        '''
256
        hbytes = host.split('.')
257
        pbytes = [repr(port//256), repr(port%256)]
Tim Peters's avatar
Tim Peters committed
258
        bytes = hbytes + pbytes
259
        cmd = 'PORT ' + ','.join(bytes)
Tim Peters's avatar
Tim Peters committed
260 261
        return self.voidcmd(cmd)

262
    def sendeprt(self, host, port):
263 264 265 266 267 268 269
        '''Send a EPRT command with the current host and the given port number.'''
        af = 0
        if self.af == socket.AF_INET:
            af = 1
        if self.af == socket.AF_INET6:
            af = 2
        if af == 0:
270
            raise error_proto('unsupported address family')
271
        fields = ['', repr(af), host, repr(port), '']
272
        cmd = 'EPRT ' + '|'.join(fields)
273
        return self.voidcmd(cmd)
274

Tim Peters's avatar
Tim Peters committed
275
    def makeport(self):
276
        '''Create a new socket and send a PORT command for it.'''
277
        msg = "getaddrinfo returns an empty list"
278
        sock = None
279 280 281 282 283
        for res in socket.getaddrinfo(None, 0, self.af, socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
            af, socktype, proto, canonname, sa = res
            try:
                sock = socket.socket(af, socktype, proto)
                sock.bind(sa)
284
            except socket.error as msg:
285 286
                if sock:
                    sock.close()
287 288 289 290
                sock = None
                continue
            break
        if not sock:
291
            raise socket.error(msg)
292 293 294 295 296 297 298 299
        sock.listen(1)
        port = sock.getsockname()[1] # Get proper port
        host = self.sock.getsockname()[0] # Get proper host
        if self.af == socket.AF_INET:
            resp = self.sendport(host, port)
        else:
            resp = self.sendeprt(host, port)
        return sock
300 301

    def makepasv(self):
302 303 304 305 306
        if self.af == socket.AF_INET:
            host, port = parse227(self.sendcmd('PASV'))
        else:
            host, port = parse229(self.sendcmd('EPSV'), self.sock.getpeername())
        return host, port
Tim Peters's avatar
Tim Peters committed
307 308 309 310 311 312 313 314 315 316 317 318

    def ntransfercmd(self, cmd, rest=None):
        """Initiate a transfer over the data connection.

        If the transfer is active, send a port command and the
        transfer command, and accept the connection.  If the server is
        passive, send a pasv command, connect to it, and start the
        transfer command.  Either way, return the socket for the
        connection and the expected size of the transfer.  The
        expected size may be None if it could not be determined.

        Optional `rest' argument can be a string that is sent as the
319
        argument to a REST command.  This is essentially a server
Tim Peters's avatar
Tim Peters committed
320 321 322 323 324
        marker used to tell the server to skip over any data up to the
        given marker.
        """
        size = None
        if self.passiveserver:
325
            host, port = self.makepasv()
326
            conn = socket.create_connection((host, port), self.timeout)
Tim Peters's avatar
Tim Peters committed
327 328 329
            if rest is not None:
                self.sendcmd("REST %s" % rest)
            resp = self.sendcmd(cmd)
330 331 332 333 334 335 336
            # Some servers apparently send a 200 reply to
            # a LIST or STOR command, before the 150 reply
            # (and way before the 226 reply). This seems to
            # be in violation of the protocol (which only allows
            # 1xx or error messages for LIST), so we just discard
            # this response.
            if resp[0] == '2':
337
                resp = self.getresp()
Tim Peters's avatar
Tim Peters committed
338
            if resp[0] != '1':
339
                raise error_reply(resp)
Tim Peters's avatar
Tim Peters committed
340 341 342 343 344
        else:
            sock = self.makeport()
            if rest is not None:
                self.sendcmd("REST %s" % rest)
            resp = self.sendcmd(cmd)
345 346
            # See above.
            if resp[0] == '2':
347
                resp = self.getresp()
Tim Peters's avatar
Tim Peters committed
348
            if resp[0] != '1':
349
                raise error_reply(resp)
Tim Peters's avatar
Tim Peters committed
350 351 352 353 354 355 356
            conn, sockaddr = sock.accept()
        if resp[:3] == '150':
            # this is conditional in case we received a 125
            size = parse150(resp)
        return conn, size

    def transfercmd(self, cmd, rest=None):
357
        """Like ntransfercmd() but returns only the socket."""
Tim Peters's avatar
Tim Peters committed
358 359 360 361 362 363 364 365
        return self.ntransfercmd(cmd, rest)[0]

    def login(self, user = '', passwd = '', acct = ''):
        '''Login, default anonymous.'''
        if not user: user = 'anonymous'
        if not passwd: passwd = ''
        if not acct: acct = ''
        if user == 'anonymous' and passwd in ('', '-'):
Tim Peters's avatar
Tim Peters committed
366 367 368 369 370 371 372
            # If there is no anonymous ftp password specified
            # then we'll just use anonymous@
            # We don't send any other thing because:
            # - We want to remain anonymous
            # - We want to stop SPAM
            # - We don't want to let ftp sites to discriminate by the user,
            #   host or country.
373
            passwd = passwd + 'anonymous@'
Tim Peters's avatar
Tim Peters committed
374 375 376 377
        resp = self.sendcmd('USER ' + user)
        if resp[0] == '3': resp = self.sendcmd('PASS ' + passwd)
        if resp[0] == '3': resp = self.sendcmd('ACCT ' + acct)
        if resp[0] != '2':
378
            raise error_reply(resp)
Tim Peters's avatar
Tim Peters committed
379 380 381
        return resp

    def retrbinary(self, cmd, callback, blocksize=8192, rest=None):
382 383 384 385 386 387 388 389 390 391 392 393
        """Retrieve data in binary mode.  A new port is created for you.

        Args:
          cmd: A RETR command.
          callback: A single parameter callable to be called on each
                    block of data read.
          blocksize: The maximum number of bytes to read from the
                     socket at one time.  [default: 8192]
          rest: Passed to transfercmd().  [default: None]

        Returns:
          The response code.
Tim Peters's avatar
Tim Peters committed
394 395 396 397 398 399 400 401 402 403 404 405
        """
        self.voidcmd('TYPE I')
        conn = self.transfercmd(cmd, rest)
        while 1:
            data = conn.recv(blocksize)
            if not data:
                break
            callback(data)
        conn.close()
        return self.voidresp()

    def retrlines(self, cmd, callback = None):
406 407 408 409 410 411 412 413 414 415 416
        """Retrieve data in line mode.  A new port is created for you.

        Args:
          cmd: A RETR, LIST, NLST, or MLSD command.
          callback: An optional single parameter callable that is called
                    for each line with the trailing CRLF stripped.
                    [default: print_line()]

        Returns:
          The response code.
        """
417
        if callback is None: callback = print_line
Tim Peters's avatar
Tim Peters committed
418 419
        resp = self.sendcmd('TYPE A')
        conn = self.transfercmd(cmd)
420
        fp = conn.makefile('r', encoding=self.encoding)
Tim Peters's avatar
Tim Peters committed
421 422
        while 1:
            line = fp.readline()
423
            if self.debugging > 2: print('*retr*', repr(line))
Tim Peters's avatar
Tim Peters committed
424 425 426 427 428 429 430 431 432 433 434
            if not line:
                break
            if line[-2:] == CRLF:
                line = line[:-2]
            elif line[-1:] == '\n':
                line = line[:-1]
            callback(line)
        fp.close()
        conn.close()
        return self.voidresp()

435 436 437 438 439 440 441 442 443 444 445 446 447 448
    def storbinary(self, cmd, fp, blocksize=8192, callback=None):
        """Store a file in binary mode.  A new port is created for you.

        Args:
          cmd: A STOR command.
          fp: A file-like object with a read(num_bytes) method.
          blocksize: The maximum data size to read from fp and send over
                     the connection at once.  [default: 8192]
          callback: An optional single parameter callable that is called on
                    on each block of data after it is sent.  [default: None]

        Returns:
          The response code.
        """
Tim Peters's avatar
Tim Peters committed
449 450 451 452 453
        self.voidcmd('TYPE I')
        conn = self.transfercmd(cmd)
        while 1:
            buf = fp.read(blocksize)
            if not buf: break
454
            conn.sendall(buf)
455
            if callback: callback(buf)
Tim Peters's avatar
Tim Peters committed
456 457 458
        conn.close()
        return self.voidresp()

459 460 461 462 463 464 465 466 467 468 469 470
    def storlines(self, cmd, fp, callback=None):
        """Store a file in line mode.  A new port is created for you.

        Args:
          cmd: A STOR command.
          fp: A file-like object with a readline() method.
          callback: An optional single parameter callable that is called on
                    on each line after it is sent.  [default: None]

        Returns:
          The response code.
        """
Tim Peters's avatar
Tim Peters committed
471 472 473 474 475
        self.voidcmd('TYPE A')
        conn = self.transfercmd(cmd)
        while 1:
            buf = fp.readline()
            if not buf: break
476 477 478
            if buf[-2:] != B_CRLF:
                if buf[-1] in B_CRLF: buf = buf[:-1]
                buf = buf + B_CRLF
479
            conn.sendall(buf)
480
            if callback: callback(buf)
Tim Peters's avatar
Tim Peters committed
481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516
        conn.close()
        return self.voidresp()

    def acct(self, password):
        '''Send new account name.'''
        cmd = 'ACCT ' + password
        return self.voidcmd(cmd)

    def nlst(self, *args):
        '''Return a list of files in a given directory (default the current).'''
        cmd = 'NLST'
        for arg in args:
            cmd = cmd + (' ' + arg)
        files = []
        self.retrlines(cmd, files.append)
        return files

    def dir(self, *args):
        '''List a directory in long form.
        By default list current directory to stdout.
        Optional last argument is callback function; all
        non-empty arguments before it are concatenated to the
        LIST command.  (This *should* only be used for a pathname.)'''
        cmd = 'LIST'
        func = None
        if args[-1:] and type(args[-1]) != type(''):
            args, func = args[:-1], args[-1]
        for arg in args:
            if arg:
                cmd = cmd + (' ' + arg)
        self.retrlines(cmd, func)

    def rename(self, fromname, toname):
        '''Rename a file.'''
        resp = self.sendcmd('RNFR ' + fromname)
        if resp[0] != '3':
517
            raise error_reply(resp)
Tim Peters's avatar
Tim Peters committed
518 519 520 521 522 523 524 525
        return self.voidcmd('RNTO ' + toname)

    def delete(self, filename):
        '''Delete a file.'''
        resp = self.sendcmd('DELE ' + filename)
        if resp[:3] in ('250', '200'):
            return resp
        else:
526
            raise error_reply(resp)
Tim Peters's avatar
Tim Peters committed
527 528 529 530 531 532

    def cwd(self, dirname):
        '''Change to a directory.'''
        if dirname == '..':
            try:
                return self.voidcmd('CDUP')
533
            except error_perm as msg:
534 535
                if msg.args[0][:3] != '500':
                    raise
Tim Peters's avatar
Tim Peters committed
536 537 538 539 540 541 542
        elif dirname == '':
            dirname = '.'  # does nothing, but could return error
        cmd = 'CWD ' + dirname
        return self.voidcmd(cmd)

    def size(self, filename):
        '''Retrieve the size of a file.'''
543
        # The SIZE command is defined in RFC-3659
Tim Peters's avatar
Tim Peters committed
544 545
        resp = self.sendcmd('SIZE ' + filename)
        if resp[:3] == '213':
546 547 548
            s = resp[3:].strip()
            try:
                return int(s)
549
            except (OverflowError, ValueError):
550
                return int(s)
Tim Peters's avatar
Tim Peters committed
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573

    def mkd(self, dirname):
        '''Make a directory, return its full pathname.'''
        resp = self.sendcmd('MKD ' + dirname)
        return parse257(resp)

    def rmd(self, dirname):
        '''Remove a directory.'''
        return self.voidcmd('RMD ' + dirname)

    def pwd(self):
        '''Return current working directory.'''
        resp = self.sendcmd('PWD')
        return parse257(resp)

    def quit(self):
        '''Quit, and close the connection.'''
        resp = self.voidcmd('QUIT')
        self.close()
        return resp

    def close(self):
        '''Close the connection without assuming anything about it.'''
574 575 576 577
        if self.file:
            self.file.close()
            self.sock.close()
            self.file = self.sock = None
578 579


580
_150_re = None
581 582

def parse150(resp):
Tim Peters's avatar
Tim Peters committed
583 584 585 586 587
    '''Parse the '150' response for a RETR request.
    Returns the expected transfer size or None; size is not guaranteed to
    be present in the 150 message.
    '''
    if resp[:3] != '150':
588
        raise error_reply(resp)
Tim Peters's avatar
Tim Peters committed
589 590 591
    global _150_re
    if _150_re is None:
        import re
592 593
        _150_re = re.compile(
            "150 .* \((\d+) bytes\)", re.IGNORECASE | re.ASCII)
Tim Peters's avatar
Tim Peters committed
594
    m = _150_re.match(resp)
595 596 597 598 599
    if not m:
        return None
    s = m.group(1)
    try:
        return int(s)
600
    except (OverflowError, ValueError):
601
        return int(s)
602 603


604 605
_227_re = None

606
def parse227(resp):
Tim Peters's avatar
Tim Peters committed
607 608 609 610 611
    '''Parse the '227' response for a PASV request.
    Raises error_proto if it does not contain '(h1,h2,h3,h4,p1,p2)'
    Return ('host.addr.as.numbers', port#) tuple.'''

    if resp[:3] != '227':
612
        raise error_reply(resp)
613 614 615
    global _227_re
    if _227_re is None:
        import re
616
        _227_re = re.compile(r'(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)', re.ASCII)
617 618
    m = _227_re.search(resp)
    if not m:
619
        raise error_proto(resp)
620
    numbers = m.groups()
621 622
    host = '.'.join(numbers[:4])
    port = (int(numbers[4]) << 8) + int(numbers[5])
Tim Peters's avatar
Tim Peters committed
623
    return host, port
624 625


626 627 628 629 630
def parse229(resp, peer):
    '''Parse the '229' response for a EPSV request.
    Raises error_proto if it does not contain '(|||port|)'
    Return ('host.addr.as.numbers', port#) tuple.'''

631
    if resp[:3] != '229':
632
        raise error_reply(resp)
633
    left = resp.find('(')
634
    if left < 0: raise error_proto(resp)
635
    right = resp.find(')', left + 1)
636
    if right < 0:
637
        raise error_proto(resp) # should contain '(|||port|)'
638
    if resp[left + 1] != resp[right - 1]:
639
        raise error_proto(resp)
640
    parts = resp[left + 1:right].split(resp[left+1])
641
    if len(parts) != 5:
642
        raise error_proto(resp)
643
    host = peer[0]
644
    port = int(parts[3])
645 646 647
    return host, port


648
def parse257(resp):
Tim Peters's avatar
Tim Peters committed
649 650 651 652 653
    '''Parse the '257' response for a MKD or PWD request.
    This is a response to a MKD or PWD request: a directory name.
    Returns the directoryname in the 257 reply.'''

    if resp[:3] != '257':
654
        raise error_reply(resp)
Tim Peters's avatar
Tim Peters committed
655 656 657 658 659 660 661 662 663 664 665 666 667 668
    if resp[3:5] != ' "':
        return '' # Not compliant to RFC 959, but UNIX ftpd does this
    dirname = ''
    i = 5
    n = len(resp)
    while i < n:
        c = resp[i]
        i = i+1
        if c == '"':
            if i >= n or resp[i] != '"':
                break
            i = i+1
        dirname = dirname + c
    return dirname
Guido van Rossum's avatar
Guido van Rossum committed
669

670

671
def print_line(line):
Tim Peters's avatar
Tim Peters committed
672
    '''Default retrlines callback to print a line.'''
673
    print(line)
674

675

676
def ftpcp(source, sourcename, target, targetname = '', type = 'I'):
Tim Peters's avatar
Tim Peters committed
677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
    '''Copy file from one FTP-instance to another.'''
    if not targetname: targetname = sourcename
    type = 'TYPE ' + type
    source.voidcmd(type)
    target.voidcmd(type)
    sourcehost, sourceport = parse227(source.sendcmd('PASV'))
    target.sendport(sourcehost, sourceport)
    # RFC 959: the user must "listen" [...] BEFORE sending the
    # transfer request.
    # So: STOR before RETR, because here the target is a "user".
    treply = target.sendcmd('STOR ' + targetname)
    if treply[:3] not in ('125', '150'): raise error_proto  # RFC 959
    sreply = source.sendcmd('RETR ' + sourcename)
    if sreply[:3] not in ('125', '150'): raise error_proto  # RFC 959
    source.voidresp()
    target.voidresp()


695
class Netrc:
Tim Peters's avatar
Tim Peters committed
696 697 698 699 700 701 702 703 704 705 706 707
    """Class to parse & provide access to 'netrc' format files.

    See the netrc(4) man page for information on the file format.

    WARNING: This class is obsolete -- use module netrc instead.

    """
    __defuser = None
    __defpasswd = None
    __defacct = None

    def __init__(self, filename=None):
708
        if filename is None:
709
            if "HOME" in os.environ:
Tim Peters's avatar
Tim Peters committed
710 711 712
                filename = os.path.join(os.environ["HOME"],
                                        ".netrc")
            else:
713
                raise IOError("specify file to load or set $HOME")
Tim Peters's avatar
Tim Peters committed
714 715 716 717 718 719 720
        self.__hosts = {}
        self.__macros = {}
        fp = open(filename, "r")
        in_macro = 0
        while 1:
            line = fp.readline()
            if not line: break
721
            if in_macro and line.strip():
Tim Peters's avatar
Tim Peters committed
722 723 724 725 726
                macro_lines.append(line)
                continue
            elif in_macro:
                self.__macros[macro_name] = tuple(macro_lines)
                in_macro = 0
727
            words = line.split()
Tim Peters's avatar
Tim Peters committed
728 729 730 731 732 733 734 735 736 737 738 739
            host = user = passwd = acct = None
            default = 0
            i = 0
            while i < len(words):
                w1 = words[i]
                if i+1 < len(words):
                    w2 = words[i + 1]
                else:
                    w2 = None
                if w1 == 'default':
                    default = 1
                elif w1 == 'machine' and w2:
740
                    host = w2.lower()
Tim Peters's avatar
Tim Peters committed
741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
                    i = i + 1
                elif w1 == 'login' and w2:
                    user = w2
                    i = i + 1
                elif w1 == 'password' and w2:
                    passwd = w2
                    i = i + 1
                elif w1 == 'account' and w2:
                    acct = w2
                    i = i + 1
                elif w1 == 'macdef' and w2:
                    macro_name = w2
                    macro_lines = []
                    in_macro = 1
                    break
                i = i + 1
            if default:
                self.__defuser = user or self.__defuser
                self.__defpasswd = passwd or self.__defpasswd
                self.__defacct = acct or self.__defacct
            if host:
762
                if host in self.__hosts:
Tim Peters's avatar
Tim Peters committed
763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781
                    ouser, opasswd, oacct = \
                           self.__hosts[host]
                    user = user or ouser
                    passwd = passwd or opasswd
                    acct = acct or oacct
                self.__hosts[host] = user, passwd, acct
        fp.close()

    def get_hosts(self):
        """Return a list of hosts mentioned in the .netrc file."""
        return self.__hosts.keys()

    def get_account(self, host):
        """Returns login information for the named host.

        The return value is a triple containing userid,
        password, and the accounting field.

        """
782
        host = host.lower()
Tim Peters's avatar
Tim Peters committed
783
        user = passwd = acct = None
784
        if host in self.__hosts:
Tim Peters's avatar
Tim Peters committed
785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800
            user, passwd, acct = self.__hosts[host]
        user = user or self.__defuser
        passwd = passwd or self.__defpasswd
        acct = acct or self.__defacct
        return user, passwd, acct

    def get_macros(self):
        """Return a list of all defined macro names."""
        return self.__macros.keys()

    def get_macro(self, macro):
        """Return a sequence of lines which define a named macro."""
        return self.__macros[macro]



Guido van Rossum's avatar
Guido van Rossum committed
801
def test():
Tim Peters's avatar
Tim Peters committed
802
    '''Test program.
803 804 805 806 807 808 809 810
    Usage: ftp [-d] [-r[file]] host [-l[dir]] [-d[dir]] [-p] [file] ...

    -d dir
    -l list
    -p password
    '''

    if len(sys.argv) < 2:
811
        print(test.__doc__)
812
        sys.exit(0)
Tim Peters's avatar
Tim Peters committed
813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853

    debugging = 0
    rcfile = None
    while sys.argv[1] == '-d':
        debugging = debugging+1
        del sys.argv[1]
    if sys.argv[1][:2] == '-r':
        # get name of alternate ~/.netrc file:
        rcfile = sys.argv[1][2:]
        del sys.argv[1]
    host = sys.argv[1]
    ftp = FTP(host)
    ftp.set_debuglevel(debugging)
    userid = passwd = acct = ''
    try:
        netrc = Netrc(rcfile)
    except IOError:
        if rcfile is not None:
            sys.stderr.write("Could not open account file"
                             " -- using anonymous login.")
    else:
        try:
            userid, passwd, acct = netrc.get_account(host)
        except KeyError:
            # no account for host
            sys.stderr.write(
                    "No account -- using anonymous login.")
    ftp.login(userid, passwd, acct)
    for file in sys.argv[2:]:
        if file[:2] == '-l':
            ftp.dir(file[2:])
        elif file[:2] == '-d':
            cmd = 'CWD'
            if file[2:]: cmd = cmd + ' ' + file[2:]
            resp = ftp.sendcmd(cmd)
        elif file == '-p':
            ftp.set_pasv(not ftp.passiveserver)
        else:
            ftp.retrbinary('RETR ' + file, \
                           sys.stdout.write, 1024)
    ftp.quit()
854 855 856


if __name__ == '__main__':
Tim Peters's avatar
Tim Peters committed
857
    test()