sites.c

站点映像程序

    for( search=the_site->files; search!=NULL; search=search->next ) {
	if( search->diff != file_new )
	    continue;
	/* OK, we have us a new file... now iterate through the deleted
	 * files and look for a match */
	DEBUG( DEBUG_FILES, "- New file: %s\nComparing:", search->rel_local );
	for( current=the_site->files; current!=NULL ; current=current->next ) {
	    if( (current->diff != file_deleted) || current->dir ) {
		/* Ignore files which aren't deleted, and dirs, completely.
		 * (search->diff==file_new, so we DON'T need to check
		 * that current != search as well) */
		continue;
	    }
	    DEBUG( DEBUG_FILES, " %s", current->rel_local );
	    if( (strcmp( search->filename, current->filename ) == 0) &&
		current->remotesize == search->localsize &&
		current->remotetime == search->localtime ) {
		DEBUG( DEBUG_FILES, " - matched!\n" );
		break;
	    }
	}
	if( current != NULL ) {
	    /* OK, current == the deleted file, search == the new file.
	     * First make sure search knows where it WAS before the move... */
	    search->old = current;
	    /* Remove the deleted file from the list so it doesn't
	     * actually get deleted by site_update */
	    file_delete( the_site, current );
	    /* Diddle the totals a bit */
	    search->diff = file_moved;
	    the_site->numdeleted--;
	    the_site->numnew--;
	    the_site->nummoved++;
	} else {
	    DEBUG( DEBUG_FILES, " - No match found.\n" );
	}
    }
    DEBUG( DEBUG_FILES, "Finished checking for moved files.\n" );
}

/* This writes the remote files list back to the file
 * and has some hairy logic in the middle, but is otherwise
 * pretty simple.
 * TODO: This is crap. What we should really do is only 
 * write out the remote file info, regardless... that is what the 
 * info file is for. This would GREATLY simplify this entire function.
 * Would mean simply that in site_update, copying over the
 * modtimes + sizes.
 */

#define WRITE_REMOTE_FILE( f ) \
fprintf( fp, "%s\t%ld\t%ld\n", f->rel_remote, f->remotetime, f->remotesize );
#define WRITE_LOCAL_FILE( f ) \
fprintf( fp, "%s\t%ld\t%ld\n", f->rel_local, f->localtime, f->localsize );
#define WRITE_REMOTE_LINK( f ) \
fprintf( fp, "%s\t%s\t%s\n", f->rel_remote, LINKWORD, f->remotelink );
#define WRITE_LOCAL_LINK( f ) \
fprintf( fp, "%s\t%s\t%s\n", f->rel_local, LINKWORD, f->locallink );

int site_writefiles( struct site_t *the_site ) {
    FILE *fp;
    struct site_file_t *current;
    fp = fopen( the_site->infofile, "w" );
    if( fp == NULL ) {
	return -1; 
    }
    for( current = the_site->files; current!=NULL; current=current->next ) {
	if( current->dir ) {
	    if( current->updated ) {
		/* DIR: Updated */
		switch( current->diff ) {
		case file_new:
		case file_unchanged:
		    /* It's new, or it's already there... */
		    fprintf( fp, "%s\t%s\n", current->rel_local, DIRWORD );
		    break;
		case file_moved: /* invalid */
		case file_changed: /* invalid */
		case file_deleted:/* it's not there now */
		default:
		    break;
		} 
	    } else {
		/* DIR: Not Updated */
		switch( current->diff ) {
		case file_unchanged: /* ... it was there anyway */
		case file_deleted: /* ... but it wasn't deleted */
		    /* So the directory exists remotely */
		    fprintf( fp, "%s\t%s\n", current->rel_remote, DIRWORD );
		    break;
		case file_new: /* ... but it wasn't created */
		default:
		    /* So the directory does not exist remotely */
		    break;
		}
	    }
	} else if( current->link ) {
	    if( current->updated ) {
		/* LINK: Updated */
		switch( current->diff ) {
		case file_new: /* it's there now */
		case file_unchanged: /* it's still there now */
		case file_changed: /* it's there now but differently */
		    WRITE_LOCAL_LINK( current );
		    break;
		case file_deleted: /* it's not there now */
		default: 
		    break;
		}
	    } else {
		/* LINK: Not Updated */
		switch( current->diff ) {
		case file_unchanged: /* it's still there anyway  */
		case file_changed:   /* it's still there anyway */
		case file_deleted: /* but actually still there */
		    WRITE_REMOTE_LINK( current );
		    break;
		case file_new: /* it's not there */
		default:
		    break;
		}
	    }
	} else {
	    if( current->updated ) {
		/* FILE: Updated */
		switch( current->diff ) {
		case file_unchanged:
		    /* Write state of remote file */
		    WRITE_REMOTE_FILE( current );
		    break;
		case file_moved:
		case file_changed:
		case file_new:
		    /* Write state of local file */
		    WRITE_LOCAL_FILE( current );
		    break;
		case file_deleted:
		    /* So don't write anything out */
		    break;
		}
	    } else {
		/* FILE: Not Updated */
		switch( current->diff ) {
		case file_changed: /* ... but it hasn't been updated */
		case file_unchanged: 
		case file_deleted: /* ... but it hasn't been deleted */
		    /* Write out the remote time */
		    WRITE_REMOTE_FILE( current );
		    break;
		case file_moved: 
		    /* But it hasn't actually been moved, so write out
		     * the 'deleted' file (where the moved file WAS), and 
		     * ignore the 'new' file (where it was moved TO) */
		    WRITE_REMOTE_FILE( current->old );
		    break;
		case file_new: /* So ignore it... */
		    break;
		}
	    }
	}
    }
    fclose( fp );
    return 0;
}

#undef WRITE_REMOTE_FILE
#undef WRITE_LOCAL_FILE

/* Simply marks all the files in the given site as 'updated'.
 * For 'dynamic updating', this will do, by diff==
 *   file_deleted: Remove the file from the list
 *   file_changed, file_new: Set diff=file_unchanged
 *   file_moved: Remove the ->old, set diff=file_unchanged
 *   file_unchanged: Do nothing.
 */
void site_catchup( struct site_t *the_site ) {
    struct site_file_t *current;
    for( current=the_site->files; current!=NULL; current=current->next ) {
	current->updated = true;
    }
    /* Mark it as mirrored */
    the_site->is_different = false;
}

/* Reinitializes the site - clears any remote files
 * from the list, and marks all other files as 'new locally'.
 */
void site_initialize( struct site_t *the_site ) {
    struct site_file_t *current, *next;
    
    current = the_site->files;

    while( current!= NULL ) {
	next = current->next;
	switch( current->diff ) {
	case file_deleted:
	    file_delete( the_site, current );
	    the_site->numdeleted--;
	    break;
	case file_moved:
	    /* Current is the NEW file, current->old is the DELETED
	     * file. So, simply nuke current->old. */
	    current->old = NULL;
	    current->updated = false;
	    the_site->nummoved--;
	    the_site->numnew++;
	    current->diff = file_new;
	    break;
	case file_changed:
	    current->updated = false;
	    the_site->numchanged--;
	    the_site->numnew++;
	    current->diff = file_new;
	    break;
	case file_unchanged:
	    current->updated = false;
	    the_site->numunchanged--;
	    the_site->numnew++;
	    current->diff = file_new;
	    break;
	case file_new:
	    current->updated = false;
	    break;
	}
	current = next;
    }
    
    if( the_site->files == NULL ) {
	/* There are no files remotely OR locally, so the
	 * sites are the same */
	the_site->is_different = false;
    } else {
	/* Otherwise, we KNOW that there are no files remotely
	 * since we just removed them from memory, so any 
	 * remaining files must be local ones. Hence, the sites
	 * ARE different */
	the_site->is_different = true;
    }

}

/* This walks the files list as returned by the protocol driver,
 * and converts it into a 'real' files list. */
void site_fetch_walk( struct site_t *the_site,
		      struct proto_file_t *files ) {
    struct proto_file_t *this_file, *next_file;
    struct site_file_t *file;
    char rel_local[BUFSIZ]; /* temporary */

    site_destroy( the_site );

    this_file = files;
    while( this_file != NULL ) {
	/* Check whether the filename is excluded.  Mock up a rel_local
	 * for it. Bit noddy */
	/* rel_local starts with a / */
	rel_local[0] = '/'; rel_local[1] = '\0';
	/* FIXME: Buffer ovverrun here. */
	strcat( rel_local, this_file->directory );
	strcat( rel_local, this_file->filename );
	
	if( !file_isexcluded( this_file->filename, rel_local, the_site ) ) {
	    /* Add the file to the list */
	    if( this_file->isdir ) {
		file = file_append( the_site );
	    } else {
		file = file_prepend( the_site );
	    }
	    
	    /* Pointer copy the filename and directory strings...  nothing
	     * to free out of this_file now. */
	    file->filename = this_file->filename;
	    file->directory = this_file->directory;
	    file->dir = this_file->isdir;
	    /* Sort out the names */
	    site_assignnames( file, the_site );
	    
	    file->diff = file_deleted;
	    file->updated = false;
	    /* ... so, it exists remotely only and hasn't been deleted.
	     * bit of a hack, but okay for the moment... */
	    
	    if( ! this_file->isdir ) {
		file->remotesize = this_file->size;
		file->remotetime = this_file->modtime;
	    }
	    
	    fe_fetch_found( file );
	    
	}

	next_file = this_file->next;
	free( this_file );
	this_file = next_file;
    }

}

/* Updates the remote file list... site_fetch_callback is called for
 * every remote file found.
 */
int site_fetch( struct site_t *the_site ) {
    struct proto_file_t *files = NULL;
    int ret;

    if( CALL(fetch_list) == NULL ) {
	return SITE_UNIMPL;
    }

    ret = proto_init( the_site );
    if( ret != SITE_OK )
	return ret;

    ret = CALL(fetch_list)( the_site->remote_root, &files );

    CALL(finish)( );
    
    if( ret == PROTO_OK ) {
	/* Copy over the list of files */
	site_fetch_walk( the_site, files );
	return SITE_OK;
    } else {
	return SITE_FAILED;
    }

}

/* Destroys a file */
void site_destroyfile( struct site_file_t *file ) {
    
    free( file->directory );
    free( file->filename );

    free( file->full_local );
    free( file->full_remote );

    free( file->rel_local );
    free( file->rel_remote );

    free( file );

}

/* Called to delete all the files associated with the site */
void site_destroy( struct site_t *the_site ) {
    struct site_file_t *current, *next;

    current = the_site->files;

    while( current != NULL ) {
	next = current->next;
	if( current->old != NULL ) {
	    site_destroyfile( current->old );
	}
	site_destroyfile( current );
	current = next;
    }

    the_site->files = NULL;
    the_site->files_tail = NULL;

}


/* Produces a section of the flat listing output, of all the items
 * with the given diff type in the given site, using the given section
 * name. */
void site_flatlist_items( FILE *f, struct site_t *the_site, 
			  const enum file_diff diff, const char *name ) {
    struct site_file_t *current;
    fprintf( f, "sectstart|%s", name );
    putc( '\n', f );
    for( current = the_site->files; current!=NULL; current=current->next) {
	if( current->diff == diff ) {
	    fprintf( f, "item|%s%s", current->rel_remote,
		    current->dir?"/":"" );
	    if( current->old !=NULL ) {
		fprintf( f, "|%s\n", current->old->rel_remote );
	    } else {
		putc( '\n', f );
	    }	    
	}
    }
    fprintf( f, "sectend|%s\n", name );
}

/* Produce the flat listing output for the given site */
void site_flatlist( FILE *f, struct site_t *the_site ) {
    fprintf( f, "sitestart|%s", the_site->name );
    if( the_site->url )	fprintf( f, "|%s", the_site->url );
    putc( '\n', f );
    if( the_site->numnew > 0 )
	site_flatlist_items( f, the_site, file_new, "added" );
    if( the_site->numchanged > 0 )
	site_flatlist_items( f, the_site, file_changed, "changed" );
    if( the_site->numdeleted > 0 )
	site_flatlist_items( f, the_site, file_deleted, "deleted" );
    if( the_site->nummoved > 0 )
	site_flatlist_items( f, the_site, file_moved, "moved" );
    fprintf( f, "siteend|%s\n", the_site->is_different?"changed":"unchanged" );
}

const char *site_pseudourl( struct site_t *the_site ) {
    static char urlbuf[256];
    snprintf( urlbuf, 256, 
	      "%s://%s%s",
	      the_site->driver->service_name, the_site->server, 
	      the_site->remote_root_user +
	      ( the_site->remote_isrel ? 1 : 0 ) );
    return urlbuf;
}