sites.c

站点映像程序

    if( ret != SITE_OK )
	return ret;

    ret = site_synch_create_directories( the_site );
    if( ret == 0 ) {
	ret = site_synch_files( the_site );
	if( ret == 0 ) {
	    ret = site_synch_remove_directories( the_site );
	}
    }
    
    CALL(finish)( );

    if( ret == 0 ) {
	return SITE_OK;
    } else {
	return SITE_ERRORS;
    }

}

static int site_update_create_directories( struct site_t *the_site, bool onlymarked) {
    struct site_file_t *current;
    int ret = 0;

    for( current=the_site->files; current!=NULL; current=current->next ) {
	if( onlymarked && !current->marked ) continue;
	if( current->dir && (current->diff == file_new ) ) {
	    /* New dir! */
	    if( fe_prompting ) if( !fe_can_update( current ) ) continue;
	    fe_updating( current );
	    if( CALL(dir_create)( current->full_remote ) != PROTO_OK ) {
		fe_updated( current, false, the_site->driver->last_error );
		ret = 1;
	    } else {
		fe_updated( current, true, NULL );
		current->updated = true;
	    }
	}
    }

    return ret;
}

static int site_update_delete_files( struct site_t *the_site, bool onlymarked ) {
    struct site_file_t *current;
    int ret = 0;

    for( current=the_site->files; current!=NULL; current=current->next ) {
	if( onlymarked && !current->marked ) continue;
	/* Skip directories and links, and only do deleted files on
	 * this pass */
	if( (current->diff == file_deleted ) &&
	    !( current->dir || current->link ) ) {
	    if( fe_prompting ) if( !fe_can_update( current ) ) break;
	    fe_updating( current );
	    if( CALL(file_delete)( current->full_remote ) != PROTO_OK ) {
		fe_updated( current, false, the_site->driver->last_error  );
		ret = 1;
	    } else {
		/* Successful update - file was deleted */
		fe_updated( current, true, NULL );
		current->updated = true;
	    }
	}
	    
    }
    
    return ret;

}

/* Does everything but file deletes */
static int site_update_files( struct site_t *the_site, bool onlymarked ) {
    struct site_file_t *current;
    char *driver_error = the_site->driver->last_error;
    int ret = 0;

    DEBUG( DEBUG_SITES, "update_files entry.\n" );

    for( current=the_site->files; current!=NULL; current=current->next ) {
	DEBUG( DEBUG_SITES, "loop start.\n" );
	if( current->dir || current->link || 
	    (onlymarked && !current->marked) ) continue;
	switch( current->diff ) {
	case file_new: /* File is new, upload it */
	    DEBUG( DEBUG_SITES, "file_new.\n" );
	    if( fe_prompting ) if( !fe_can_update( current ) ) break;
	    fe_updating( current );
	    if( CALL(file_upload)( current->full_local, current->full_remote, current->isascii ) != PROTO_OK ) {
		DEBUG( DEBUG_SITES, "file_upload failed.\n" );
		fe_updated( current, false, driver_error );
		ret = 1;
	    } else { 
		/* Successful upload... now we need to chmod it? */
		DEBUG( DEBUG_SITES, "file_upload success.\n" );
		if( (the_site->perms == sitep_all) ||
		    ( (current->mode & S_IXUSR) &&
		      (the_site->perms == sitep_exec) ) ) {
		    /* We need to chmod the file ... */
		    if( CALL(file_chmod)( current->full_remote, current->mode ) != PROTO_OK ) {
			fe_updated( current, false, driver_error );
			ret = 1;
		    } else {
			fe_updated( current, true, NULL );
			current->updated = true;
		    }
		} else {
		    fe_updated( current, true, NULL );
		    current->updated = true;
		}
	    }
	    break;
	    
	case file_changed: /* File has changed, upload it */
	    DEBUG( DEBUG_SITES, "file_changed.\n" );
	    if( fe_prompting ) if( !fe_can_update( current ) ) continue;
	    if( the_site->nooverwrite ) {
		/* Must delete remote file before uploading new copy.
		 * FIXME: Icky hack to convince the FE we are about to
		 * delete the file */
		current->diff = file_deleted;
		fe_updating( current );
		if( CALL(file_delete)( current->full_remote ) != PROTO_OK ) {
		    fe_updated( current, false, driver_error );
		    ret = 1;
		    current->diff = file_changed;
		    /* Don't upload it! */
		    break;
		} else {
		    fe_updated( current, true, NULL );
		    current->diff = file_changed;
		}
	    }
	    fe_updating( current );
	    /* Now, upload it */
	    if( CALL(file_upload)( current->full_local, current->full_remote, current->isascii ) != PROTO_OK ) {
		fe_updated( current, false, driver_error );
		ret = 1;
	    } else {
		/* Successful upload... now we need to chmod it? */
		if( (the_site->perms == sitep_all) ||
		    ( (current->mode & S_IXUSR) &&
		      (the_site->perms == sitep_exec) ) ) {
		    /* We need to chmod the file ... */
		    if( CALL(file_chmod)( current->full_remote, current->mode ) != PROTO_OK ) {
			fe_updated( current, false, driver_error );
			ret = 1;
		    } else {
			fe_updated( current, true, NULL );
			current->updated = true;
		    }
		} else {
		    fe_updated( current, true, NULL );
		    current->updated = true;
		}
	    }
	    break;
		
	case file_moved:
	    /* The file has been moved */
	    DEBUG( DEBUG_SITES, "file_moved.\n" );
	    if( fe_prompting ) {
		if( !fe_can_update( current ) ) break;
	    } else {
		fe_updating( current );
	    }
	    if( CALL(file_move)( current->old->full_remote, 
				current->full_remote ) != PROTO_OK ) {
		ret = 1;
		fe_updated( current, false, driver_error );
	    } else {
		/* Successful update - file was moved */
		current->updated = true;
		fe_updated( current, true, NULL );
	    }
	    break;
	    
	default: /* Ignore everything else */
	    DEBUG( DEBUG_SITES, "file ignored.\n" );
	    break;
	}
	DEBUG( DEBUG_SITES, "loop end.\n" );
    }
    DEBUG( DEBUG_SITES, "update_files exit.\n" );

    return ret;
    
}

static int site_update_delete_directories( struct site_t *the_site, bool onlymarked ){
    struct site_file_t *current;
    int ret = 0;

    /* This one must iterate through the list BACKWARDS, so
     * directories are deleted bottom up */
    for( current=the_site->files_tail; current!=NULL; current=current->prev ) {
	if( onlymarked && !current->marked ) continue;
	if( current->dir && (current->diff == file_deleted ) ) {
	    if( fe_prompting ) if( !fe_can_update( current ) ) continue;
	    fe_updating( current );
	    if( CALL(dir_remove)( current->full_remote ) != PROTO_OK ) {
		ret = 1;
		fe_updated( current, false, the_site->driver->last_error );
	    } else {
		/* Successful delete */
		current->updated = true;
		fe_updated( current, true, NULL );
	    }
	}
    }
    return ret;
}

static int site_update_links( struct site_t *the_site, bool onlymarked ) {
    struct site_file_t *current;
    int ret = 0;

    for( current=the_site->files; current!=NULL; current=current->next ) {
	if( onlymarked && !current->marked ) continue;
	if( current->link ) {
	    switch( current->diff ) {
	    case file_new:
		fe_updating( current );
		if( CALL(link_create)( current->full_remote,
				      current->locallink ) != PROTO_OK ) {
		    fe_updated( current, false, the_site->driver->last_error );
		    ret = 1;
		} else {
		    fe_updated( current, true, NULL );
		    current->updated = true;
		}
		break;
	    case file_changed:
		fe_updating( current );
		if( CALL(link_change)( current->full_remote,
				      current->locallink ) != PROTO_OK ) {
		    fe_updated( current, false, the_site->driver->last_error );
		    ret = 1;
		} else {
		    fe_updated( current, true, NULL );
		    current->updated = true;
		}
		break;
	    case file_deleted:
		fe_updating( current );
		if( CALL(link_delete)( current->full_remote ) !=
		    PROTO_OK ) {
		    fe_updated( current, false, the_site->driver->last_error );
		    ret = 1;
		} else {
		    fe_updated( current, true, NULL );
		    current->updated = true;
		}
	    default:
		break;
	    }
	}
    }
    return ret;

}

static int proto_init( struct site_t *the_site ) {
    /* TODO: Move the proto_host's into site_t */
    struct proto_host_t server, proxy, *proxy_pass;
    int ret;

    ftp_use_passive = the_site->ftp_pasv_mode;
#ifdef USE_DAV
    http_disable_expect = the_site->http_no_expect;
    http_conn_limit = the_site->http_limit;
#endif

    server.hostname = the_site->server;
    server.port = the_site->port;
    server.username = the_site->username;
    server.password = the_site->password;

    proxy.hostname = the_site->proxy_server;
    proxy.port = the_site->proxy_port;
    proxy.username = the_site->username;
    proxy.password = the_site->password;

    if( the_site->proxy_server == NULL ) {
	proxy_pass = NULL;
    } else {
	proxy_pass = &proxy;
    }

    ret = CALL(init)( the_site->remote_root, &server, proxy_pass );
    switch( ret ) {
    case PROTO_LOOKUP:
	ret = SITE_LOOKUP;
	break;
    case PROTO_CONNECT:
	ret = SITE_CONNECT;
	break;
    case PROTO_AUTH:
	ret = SITE_AUTH;
	break;
    default:
	ret = SITE_OK;
	break;
    }
    return ret;
}


/* Updates the remote site with the local copy.
 * This is the core functionality of sitecopy.
 * All we do is compare the local files list with the remote files
 * list, and upload any changed or new files.
 * Directories are treated differently - any new ones must be created BEFORE
 * any files are uploaded, and any old ones must be deleted AFTER any files
 * are deleted, since most FTP servers will not allow you to DELE a 
 * non-empty directory.
 */
int site_update( struct site_t *the_site, bool onlymarked )  {
    int ret = 0;
    
    ret = proto_init( the_site );
    if( ret != SITE_OK )
	return ret;

    ret = site_update_create_directories( the_site, onlymarked );
    if( ret == 0 || site_keepgoing ) {
	/* Delete files first, since they might be quota-limited
	 * on the remote site */
	if( !the_site->nodelete ) {
	    ret += site_update_delete_files( the_site, onlymarked );
	}
	if( ret == 0 || site_keepgoing ) {
	    ret += site_update_files( the_site, onlymarked );
	    if( (ret == 0 || site_keepgoing) && 
		(the_site->symlinks == sitesym_maintain ) ) {
		ret += site_update_links( the_site, onlymarked );
	    }
	    if( (ret == 0 || site_keepgoing) && !the_site->nodelete ) {
		ret += site_update_delete_directories( the_site, onlymarked );
	    }
	}
    }

    CALL(finish)( );

    if( ret == 0 ) {
	/* Site updated successfully.
	 * Mark the site as 'unchanged' so, in a GUI FE, they
	 * don't try and update it again. Hopefully.
	 */
	the_site->is_different = false;
	return SITE_OK;
    } else {
	/* Update not totally successfull */
	return SITE_ERRORS;
    }

}

/* This populates the additional names in the site_file_t struct given,
 * using information in the given site */
void site_assignnames( struct site_file_t *the_file, struct site_t *the_site ){

    the_file->full_remote = malloc( strlen(the_site->remote_root) + 
				    strlen(the_file->directory) +
				    strlen(the_file->filename) + 1 );
    the_file->full_local = malloc( strlen(the_site->local_root) + 
				   strlen(the_file->directory) +
				   strlen(the_file->filename) + 1 );
    the_file->rel_local = malloc( strlen(the_file->directory) +
				  strlen(the_file->filename) + 2 );
    the_file->rel_remote = malloc( strlen(the_file->directory) +
				   strlen(the_file->filename) + 2 );
    
    strcpy( the_file->full_remote, the_site->remote_root );
    strcat( the_file->full_remote, the_file->directory );
    strcat( the_file->full_remote, the_file->filename );

    strcpy( the_file->full_local, the_site->local_root );
    strcat( the_file->full_local, the_file->directory );
    strcat( the_file->full_local, the_file->filename );

    strcpy( the_file->rel_local, "/" );
    strcat( the_file->rel_local, the_file->directory );
    strcat( the_file->rel_local, the_file->filename );

    strcpy( the_file->rel_remote, "/" );
    strcat( the_file->rel_remote, the_file->directory );
    strcat( the_file->rel_remote, the_file->filename );

}

/* This reads off the remote files and the local files */
int site_readfiles( struct site_t *the_site ) {
    if( site_readremotefiles( the_site ) < 0 )
	return -1;
    if( site_readlocalfiles( the_site ) )
	return -2;
    /* Check for moved files - compare new files with deleted ones */
    if( the_site->checkmoved ) {
	site_checkmoved( the_site );
    }
    /* Summing up... */
    if( (the_site->numchanged +
	 the_site->nummoved + 
	 the_site->numnew +
	 (the_site->nodelete?0:the_site->numdeleted) ) > 0 ) {
	the_site->is_different = true;
    } else {
	the_site->is_different = false;
    }
    return 0;
}