if line[-2:] == CRLF:                line = line[:-2]            elif line[-1:] == '\n':                line = line[:-1]            callback(line)        fp.close()        conn.close()        return self.voidresp()    def storbinary(self, cmd, fp, blocksize=8192):        '''Store a file in binary mode.'''        self.voidcmd('TYPE I')        conn = self.transfercmd(cmd)        while 1:            buf = fp.read(blocksize)            if not buf: break            conn.sendall(buf)        conn.close()        return self.voidresp()    def storlines(self, cmd, fp):        '''Store a file in line mode.'''        self.voidcmd('TYPE A')        conn = self.transfercmd(cmd)        while 1:            buf = fp.readline()            if not buf: break            if buf[-2:] != CRLF:                if buf[-1] in CRLF: buf = buf[:-1]                buf = buf + CRLF            conn.sendall(buf)        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':            raise error_reply, resp        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        elif resp[:1] == '5':            raise error_perm, resp        else:            raise error_reply, resp    def cwd(self, dirname):        '''Change to a directory.'''        if dirname == '..':            try:                return self.voidcmd('CDUP')            except error_perm, msg:                if msg.args[0][:3] != '500':                    raise        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.'''        # Note that the RFC doesn't say anything about 'SIZE'        resp = self.sendcmd('SIZE ' + filename)        if resp[:3] == '213':            s = resp[3:].strip()            try:                return int(s)            except (OverflowError, ValueError):                return long(s)    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.'''        if self.file:            self.file.close()            self.sock.close()            self.file = self.sock = None_150_re = Nonedef parse150(resp):    '''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':        raise error_reply, resp    global _150_re    if _150_re is None:        import re        _150_re = re.compile("150 .* \((\d+) bytes\)", re.IGNORECASE)    m = _150_re.match(resp)    if not m:        return None    s = m.group(1)    try:        return int(s)    except (OverflowError, ValueError):        return long(s)_227_re = Nonedef parse227(resp):    '''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':        raise error_reply, resp    global _227_re    if _227_re is None:        import re        _227_re = re.compile(r'(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)')    m = _227_re.search(resp)    if not m:        raise error_proto, resp    numbers = m.groups()    host = '.'.join(numbers[:4])    port = (int(numbers[4]) << 8) + int(numbers[5])    return host, portdef 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.'''    if resp[:3] <> '229':        raise error_reply, resp    left = string.find(resp, '(')    if left < 0: raise error_proto, resp    right = string.find(resp, ')', left + 1)    if right < 0:        raise error_proto, resp # should contain '(|||port|)'    if resp[left + 1] <> resp[right - 1]:        raise error_proto, resp    parts = string.split(resp[left + 1:right], resp[left+1])    if len(parts) <> 5:        raise error_proto, resp    host = peer[0]    port = string.atoi(parts[3])    return host, portdef parse257(resp):    '''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':        raise error_reply, resp    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 dirnamedef print_line(line):    '''Default retrlines callback to print a line.'''    print linedef ftpcp(source, sourcename, target, targetname = '', type = 'I'):    '''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()class Netrc:    """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):        if not filename:            if os.environ.has_key("HOME"):                filename = os.path.join(os.environ["HOME"],                                        ".netrc")            else:                raise IOError, \                      "specify file to load or set $HOME"        self.__hosts = {}        self.__macros = {}        fp = open(filename, "r")        in_macro = 0        while 1:            line = fp.readline()            if not line: break            if in_macro and line.strip():                macro_lines.append(line)                continue            elif in_macro:                self.__macros[macro_name] = tuple(macro_lines)                in_macro = 0            words = line.split()            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:                    host = w2.lower()                    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:                if self.__hosts.has_key(host):                    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.        """        host = host.lower()        user = passwd = acct = None        if self.__hosts.has_key(host):            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]def test():    '''Test program.    Usage: ftp [-d] [-r[file]] host [-l[dir]] [-d[dir]] [-p] [file] ...'''    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()if __name__ == '__main__':    test()