ftp.c

站点映像程序

}

/* Connect to the given host 
 * Returns non-zero value if successfull */
int ftp_connect_pasv() {
    int sock;
    sock = socket_connect( ftp_dtp_addr, ftp_dtp_port );
    if( sock == -1 ) {
	ftp_seterror_err( "Could not connect socket" );
	return 0;
    } else {
	ftp_dtp_socket = sock;
	return 1;
    }
}

int ftp_open( ) {
    int ret;

    if( ftp_connection != false ) return FTP_OK;
    fe_connection( fe_connecting );
    DEBUG( DEBUG_FTP, "Opening socket to port %d\n", ftp_pi_port );
    /* Open the socket. */
    ftp_pi_socket = socket_connect( ftp_pi_addr, ftp_pi_port );
    if( ftp_pi_socket < 0 ) {
	return FTP_CONNECT;
    }
    /* Read the hello message */
    ret = ftp_read();
    if( ret != FTP_OK ) {
	return FTP_HELLO;
    }
    ftp_connection = true;
    if( ftp_login( ) != FTP_OK ) {
/*	ftp_seterror( "Could not log in to server." ); */
	ftp_connection = false;
	close( ftp_pi_socket );
	return FTP_LOGIN;
    }
    fe_connection( fe_connected );

    /* <[e-mail]>: Don't know whether in ASCII or binary mode so try 
     * to fix it.  I don't like this one bit as ftp_settype can call 
     * ftp_open. 
     * joe: Note, ftp_using_ascii is set to -1 to avoid infinite 
     * recursion. Alter with care.
     */
    if(ftp_using_ascii != -1) {
           bool ascii = ftp_using_ascii;
           ftp_using_ascii = -1;
           return ftp_settype(ascii);
    }

    return FTP_OK;
}

int ftp_login( ) {
    char cmd[BUFSIZ];
    int ret;
    DEBUG( DEBUG_FTP,  "FTP: Logging in as %s...\n", ftp_username );
    snprintf( cmd, BUFSIZ, "USER %s", ftp_username );
    ret = ftp_exec( cmd );
    if( ret == FTP_NEEDPASSWORD ) {
	DEBUG( DEBUG_FTP,  "FTP: Supplying password...\n" );
	snprintf( cmd, BUFSIZ, "PASS %s", ftp_password );
	ret = ftp_exec( cmd );
    }
    return ret;
}

/* Returns anything which ftp_read() does */
int ftp_exec( const char *command ) {
    int tries = 0, ret = FTP_ERROR;
    while( ++tries < 3 ) {
	if( ftp_open( ) != FTP_OK ) break;
	if( strncmp( command, "PASS ", 5 ) == 0 ) {
	    DEBUG( DEBUG_SOCKET, "> PASS xxxxxxxx\n" );
	} else {
	    DEBUG( DEBUG_SOCKET, "> %s\n", command );
	}
	/* Send the line */
	if( send_line( ftp_pi_socket, command ) == 0 ) {
	    /* Sent the line... try and read the response */
	    ret = ftp_read();
	    if( ret != FTP_BROKEN ) {
		/* Read the response okay */
		break;
	    }
	}
    }
    /* Don't let FTP_BROKEN get out */
    if( ret == FTP_BROKEN ) 
	ret = FTP_ERROR;
    return ret;
}

/* Returns anything ftp_read() does, or FTP_BROKEN when the
 * socket read fails (indicating a broken socket).  
 */

int ftp_read() {
    int multiline, len, reply_code;
    char buffer[BUFSIZ];

    multiline = 0;
    
    for(;;) {
	len = read_line( ftp_pi_socket, buffer, BUFSIZ );
	if( len < 0 ) {
	    /* It broke. */
	    ftp_seterror_err( "Could not read response line" );
	    ftp_connection = false;
	    break;
	}
	
	DEBUG( DEBUG_SOCKET, "< %s", buffer );
	if(len<5) /* this is a multi-liner, ignore it and carry on */
	    continue; 
	/* parse the reply code from the line */
	reply_code = get_reply_code(buffer);
	
	/* If we have a VALID reply code and we are currently
	 * in a multi line response then this is the end of the
	 * multi line response */
	if(multiline && reply_code)
	    multiline=0;
	
	/* Now, if we aren't in a multi line response... */
	if(!multiline) { 
	    if(buffer[3]=='-') {
		/* A dash in char four denotes beginning of multi
		 * line response  'xxx-' */
		multiline=1;
	    } else {
		/* Looks like we've got a real response line */
		return ftp_response( buffer, reply_code );
	    }
	}
    }
    return FTP_BROKEN;
}

void ftp_seterror( const char *error ) {
    memset( ftp_error, 0, BUFSIZ );
    strncpy( ftp_error, error, BUFSIZ );
/*    DEBUG( DEBUG_FTP, "FTP Error set: %s\n", ftp_error ); */
}

/* Sets the error string and appends ": strerror(errno)" */
void ftp_seterror_err( const char *error ) {
    snprintf( ftp_error, BUFSIZ, "%s: %s", error, strerror(errno) );
    DEBUG( DEBUG_FTP, "FTP Error set: %s\n", ftp_error );
}

int ftp_response( const char *response, const int code ) {
    char *newline;
    /* Set the error string up. */
    ftp_seterror( response );
    /* Chop the newline */
    newline = strrchr( ftp_error, '\r' );
    if( newline ) *newline = '\0';	
    switch( code ) {
    case 200: /* misc OK codes */
    case 220:
    case 230:
    case 250: /* completed file action */
    case 257: /* mkdir success */
	return FTP_OK;
    case 226: /* received file okay */
	return FTP_SENT;
    case 150: /* file transfer... ready for data */
    case 125:
	return FTP_READY;
    case 550: /* couldn't complete file action */
	return FTP_FILEBAD;
    case 331: /* got username, want password */
	return FTP_NEEDPASSWORD;
    case 350: /* file action pending further info - RNFR */
	return FTP_FILEMORE;
    case 221:
	/* They've closed the connection, the swine. */
	ftp_connection = false;
	return FTP_CLOSED;
    case 421: /* service denied */
	return FTP_DENIED;
    case 213: /* MDTM response, hopefully */
	return ftp_read_mdtm( response );
    case 227: /* PASV response, hopefully */
	return ftp_read_pasv( response );
    case 553: /* couldn't create directory */
	return FTP_ERROR;
    default:
	return FTP_ERROR;
    }
}

/* Parses the 213 response to a MDTM command... on success,
 * returns FTP_MODTIME and sets ftp_modtime to the time in the response.
 * On failute, returns FTP_ERROR. */
int ftp_read_mdtm( const char *response ) {
    struct tm time;
    char year[5], month[3], mday[3], hour[3], min[3], sec[3];
    char *pnt;

    if( (pnt = strrchr( response, '\n' ))!=NULL ) *pnt='\0';
    if( (pnt = strrchr( response, '\r' ))!=NULL ) *pnt='\0';
    DEBUG( DEBUG_FTP, "Reading modtime: %s\n", response );
    if( strlen( response ) != 18 ) {
	DEBUG( DEBUG_FTP, "Incorrect length response." );
	return FTP_ERROR;
    }
    if( sscanf( response, "213 %4s%2s%2s" "%2s%2s%2s",
		year, month, mday,   hour, min, sec ) < 6 ) {
	DEBUG( DEBUG_FTP, "sscanf couldn't parse it.\n" );
	return FTP_ERROR;
    }
    DEBUG( DEBUG_FTP, "Parsed: %d/%d/%d %s:%s:%s\n",
	   atoi(year), atoi(month), atoi(mday), hour, min, sec );
    
    memset( &time, 0, sizeof( struct tm ) );
    
    time.tm_year = atoi( year ) - 1900; /* years since 1900 */
    time.tm_mon = atoi( month ) - 1; /* months since jan */
    time.tm_mday = atoi( mday );
    
    time.tm_hour = atoi( hour );
    time.tm_min = atoi( min );
    time.tm_sec = atoi( sec );

    time.tm_isdst = -1;
    ftp_modtime = mktime( &time );

    DEBUG( DEBUG_FTP, "Converted to: %s", ctime( &ftp_modtime ) );

    return FTP_MODTIME;
}

/* Parses the response to a PASV command.
 * Sets ftp_dtp_port to the port and ftp_dtp_addr to the address given
 * in the response and returns FTP_PASSIVE on success.
 * On failure, returns FTP_ERROR;
 */
int ftp_read_pasv( const char *response ) {
    int h1, h2, h3, h4, p1, p2;
    char *start;
    start = strchr( response, '(' );
    /* get the host + port */
    if( sscanf( ++start, "%d,%d,%d,%d,%d,%d", &h1, &h2, &h3, &h4, &p1, &p2 ) < 6 )
	/* didn't match, give up */
	return FTP_ERROR;
    /* Record this for future reference */
    ftp_dtp_port = (p1<<8) | p2;
    ftp_dtp_addr.s_addr = htonl( (h1<<24) | (h2<<16) | (h3<<8) | h4 );
    return FTP_PASSIVE;
}

/* Takes the response line from an FTP command and returns the value
 * of the response code, or 0 if none is found.
 */
int get_reply_code( const char *buffer) {
    if(strlen(buffer) > 3)
	if( isdigit((unsigned)buffer[0]) &&
	    isdigit((unsigned)buffer[1]) && 
	    isdigit((unsigned)buffer[2]) )
	    /* looks good */
	    return atoi(buffer);
    return 0;
}

/* This one does the ls -laR, and tries it's best to parse the resulting
 * list. Currently implemented only for Unix-style servers, which go:
 * dirlist
 * new/directory/name:
 * dirlist
 * another/directory/name:
 * dirlist
 * etc. where dirlist is a straight ls -al listing
 */
int ftp_fetch_gettree( const char *startdir, struct proto_file_t **files ) {
    struct proto_file_t *this_file, *last_file;
    char command[BUFSIZ], buffer[BUFSIZ], *pnt;
    char *curdir;   /* Holds the path of the current directory */
    char perms[BUFSIZ], filename[BUFSIZ], tmp[BUFSIZ];
    int ret, filesize, buflen;
    bool afterblank;

    snprintf( command, BUFSIZ, "LIST -laR %s", startdir );
    if( (ret = ftp_data_open( command )) != FTP_READY ) {
	return PROTO_ERROR;
    }

    /* The current directory is a 0-length string. */
    curdir = malloc( 1 );
    *curdir = '\0';
    last_file = NULL;

    afterblank = false;
    while( read_line( ftp_dtp_socket, buffer, BUFSIZ ) >= 0 ) {
	/* Get rid of the EOL */
	if( (pnt = strrchr( buffer, '\n' ))!=NULL ) *pnt='\0';
	if( (pnt = strrchr( buffer, '\r' ))!=NULL ) *pnt='\0';
	DEBUG( DEBUG_FTP, "[ls] < %s\n", buffer );
	buflen = strlen( buffer );
	if( buflen > 0 ) {
	    if( strncmp( buffer, "total ", 6 ) == 0 ) {
		/* ignore the line */
		DEBUG( DEBUG_FTP, "Line ignored.\n" );
	    } else if( *(buffer+buflen-1) == ':' && afterblank ) {
		/* A new directory name indicator, which goes:
		 *    `directory/name/here:'
		 * We want directory names as:
		 *    `/directory/name/here' 
		 * Hence a bit of messing about. */
		free( curdir );
		buflen = buflen - strlen(startdir );
		curdir = malloc( buflen + 1 );
		strncpy( curdir, buffer+strlen(startdir), buflen );
		*(curdir+buflen-1) = '/';
		*(curdir+buflen) = '\0';
		DEBUG( DEBUG_FTP, "Now in directory: %s\n", curdir );
	    } else {
		/* Weird bit at the end should pick up everything
		 * to the EOL... filenames could have whitespace in.
		 */
		sscanf( buffer, "%s %s %s %s %d %s %s %s %[^*]",  
			perms, tmp, tmp, tmp, &filesize,
			tmp, tmp, tmp, filename);
		if( perms!=NULL && filename!=NULL ) {
		    if( *perms == '-' ) {
			/* Normal file. */
			DEBUG( DEBUG_FTP, "File: %s, size %d\n",
			       filename, filesize );
			this_file = malloc( sizeof(struct proto_file_t) );
			memset( this_file, 0, sizeof(struct proto_file_t) );
			this_file->next = *files;
			*files = this_file;
			if( last_file==NULL ) last_file = this_file;
			this_file->filename = strdup( filename );
			this_file->directory = strdup( curdir );
			this_file->isdir = false;
			this_file->size = filesize;
		    } else if( *perms == 'd' ) {
			/* Subdirectory */
			if( strcmp( filename, "." ) == 0 ||
			    strcmp( filename, ".." ) == 0 ) {
			    DEBUG( DEBUG_FTP, "Ignoring: %s\n", filename );
			} else {
			    DEBUG( DEBUG_FTP, "Subdir: %s\n", filename );
			    this_file = malloc( sizeof(struct proto_file_t) );
			    memset( this_file, 0, sizeof(struct proto_file_t) );
			    if( last_file==NULL ) {
				*files = this_file;
			    } else {
				last_file->next = this_file;
			    }
			    last_file = this_file;
			    this_file->filename = strdup( filename );
			    this_file->directory = strdup( curdir );
			    this_file->isdir = true;
			}
		    } else { 
			/* Summant else... ignore */
			DEBUG( DEBUG_FTP, "Ignoring: %s\n", filename );
		    }
		} else {
		    DEBUG( DEBUG_FTP, "Could not parse line.\n" );
		}
	    }
	} else {
	    DEBUG( DEBUG_FTP, "Blank line.\n" );
	    afterblank = true;
	}
    }
    DEBUG( DEBUG_FTP, "Fetch finished successfully.\n" );
    if( ftp_data_close( ) == FTP_SENT ) {
	return FTP_OK;
    } else {
	return FTP_ERROR;
    }
}

/* Sorts out the modtimes for all the files in the list.
 * Returns FTP_OK on success, else FTP_ERROR. */
int ftp_fetch_walktree( const char *rootdir, struct proto_file_t *files ) {
    struct proto_file_t *this_file;
    char command[BUFSIZ];
 
    /* Walk the files list. Okay, it's not really a tree */
    for( this_file=files; this_file!=NULL; this_file=this_file->next ) {
	if( this_file->isdir ) {
	    continue;
	}
	DEBUG( DEBUG_FTP, "File: %s%s%s\n", rootdir,
	       this_file->directory, this_file->filename );
	snprintf( command, BUFSIZ, "MDTM %s%s%s", 
		  rootdir, this_file->directory, this_file->filename );
	if( ftp_exec( command ) == FTP_MODTIME ) {
	    DEBUG( DEBUG_FTP, "Got modtime.\n" );
	    this_file->modtime = ftp_modtime;
	} else {
	    DEBUG( DEBUG_FTP, "Didn't get modtime.\n" );
	    return FTP_ERROR;
	}
    }
    DEBUG( DEBUG_FTP, "Walk finished ok.\n" );

    return FTP_OK;
}

/* Retrieves remote file listings.
 * This is a multi-stage operation.
 * First off, we do a LIST -R, which returns a recursive file listing.
 * Next, we go through the entire list of files returned and do a
 * MDTM on them to retrieve their accurate modtime.
 * If we can successfully retrieve every modtime, then we pass the
 * files one by one back up to the sites code. About as inefficient
 * as it gets.
 */
int ftp_fetch( const char *startdir, struct proto_file_t **files ) {
    int ret;

    ret = ftp_fetch_gettree( startdir, files );
    if( ret == FTP_OK ) {
	ret = ftp_fetch_walktree( startdir, *files );
    }
    
    if( ret == FTP_OK ) {
	return PROTO_OK;
    } else {
	return PROTO_ERROR;
    }   

}