sites.c

站点映像程序

int site_readremotefiles( struct site_t *the_site ) {
    FILE *fp;
    char buf[BUFSIZ], /* for the line */
	tmp[BUFSIZ], /* for the current field */
	*pos, /* for the current position within buf */
	*point, /* for the curpos within tmp */
	*this_file = NULL;
    struct site_file_t *current;
    size_t dir_length;
    int state;
    /* Get the remote files from the storage file */
    DEBUG( DEBUG_FILES, "Reading info file: %s\n", the_site->infofile );
    fp = fopen( the_site->infofile, "r" );
    if( fp == NULL ) {
	/* This is not an error condition, since the info file WILL NOT 
	 * exist until the site has been created, which is okay, just means
	 * there are 'no' files on the remote site */
	return 1;
    }
    /* The file exists, so read it.
     * Format: one item / line, tab-separated fields.
     * First field is filename of item.
     * Second field is 'dir' for directory items, or mtime for files
     * Third field (files only) is size of file */
    current = NULL;
    while( fgets( buf, BUFSIZ, fp) != NULL ) {
	/* Create a new file item and lob it on the end of the linked 
	 * list */
	current = file_append( the_site );
	/* Make sure we have an end-of-buffer */
	buf[BUFSIZ-1] = '\0';
	this_file = NULL;
	/* Now parse the line. Simple DFA, states are:
	 *  0: Reading filename, field 1
	 *  1: Reading date/time stamp or DIRWORD, field 2
	 *  2: Reading file size, field 3 (if file)
	 *  3: Junk state - consume-all-crud-till-end-of-line.
	 * 
	 * We read the current field into tmp char by char.
	 * point is the current point within tmp. */
	state = 0;
	point = tmp;
	for( pos = buf; *pos!='\0'; pos++ ) {
	    if( *pos < 0 ) state = 5;
	    switch( state ) {
	    case 0:
		if( *pos == '\t' ) {
		    /* End of the filename */
		    *point = '\0';
		    this_file = strdup( tmp );
		    point = tmp;
		    state = 1;
		} else {
		    /* Still in the filename */
		    *(point++) = *pos;
		}
		break;
	    case 1:
		if( *pos == '\t' || *pos == '\n' ) {
		    /* End of the second field */
		    *point = '\0';
		    if( strlen( tmp ) > 0 ) {
			if( strcmp( tmp, DIRWORD ) == 0 ) {
			    /* It's a directory! */
			    current->dir = true;
			    state = 3; /* that's all we need */
			} else if( strcmp( tmp, LINKWORD ) == 0 ) {
			    current->link = true;
			    point = tmp;
			    state = 4; /* read the link target */
			} else {
			    /* It's a file! - field 2 is the mtime */
			    current->dir = false;
			    current->remotetime = atol( tmp );
			    point = tmp;
			    state = 2;
			}
		    } else {
			/* Corrupt line, we need at least two fields */
			/* FIXME: Report this to the user. */
			state = 5;
		    }			
		} else {
		    /* Within the second field */
		    *(point++) = *pos;
		}
		break;
	    case 2:
		if( *pos == '\n' ) {
		    /* End of the size field */
		    *point = '\0';
		    current->remotesize = atol( tmp );
		    state = 3;
		} else {
		    /* Within the file size field */
		    *(point++) = *pos;
		}
		break;
	    case 3: /* junk state */
		break;
	    case 4: /* read the link name */
		if( *pos == '\n' ) {
		    /* End of the field */
		    *point = '\0';
		    current->remotelink = strdup( tmp );
		    state = 3;
		} else {
		    *(point++) = *pos;
		}
	    case 5: /* error state */
		break;
	    }
	}
	if( this_file==NULL || state == 5 ) {
	    /* FIXME: Report this to the user */
	    DEBUG( DEBUG_FILES, "Corrupt line.\n" );
	    file_delete( the_site, current );
	    continue;
	}
	current->diff = file_deleted;
	current->filename = strdup( base_name( this_file ) );
	/* we are going to chop the leading / of this_file */
	if( strlen(current->filename) > strlen(this_file) ) {
	    /* FIXME: Handle these errors properly */
	    DEBUG( DEBUG_FILES, "Very corrupt line.\n" );
	    free( current->filename );
	    file_delete( the_site, current );
	    continue;
	}
	dir_length = strlen(this_file) - strlen(current->filename ) - 1;
	current->directory = malloc( dir_length + 1 );
	strncpy( current->directory, this_file + 1, dir_length );
	*(current->directory+dir_length) = '\0'; /* null-term */
	DEBUG( DEBUG_FILES, "Split %s is: Dir [%s], name [%s]\n",
	       this_file, current->directory, current->filename );
	the_site->numdeleted++;
	site_assignnames( current, the_site );
	DEBUG( DEBUG_FILES, "Remote: [%s] - file: size: %ld  time: %ld\n",
	       current->filename, current->remotesize, current->remotetime );
	DEBUG( DEBUG_FILES, 
	       "Directory: [%s]  Filename: %s\n"
	       "rel_local: %s  rel_remote: %s\n"
	       "full_local: %s  full_remote: %s\n",
	       current->directory, current->filename,
	       current->rel_local, current->rel_remote, 
	       current->full_local, current->full_remote );
	free( this_file );
    }
    fclose( fp );
    return 0;
}

/* Read the local site files... 
 * A stack is used for directories within the site - this is not recursive.
 * Each item on the stack is a FULL PATH to the directory, i.e., including
 * the local site root. */

int site_readlocalfiles( struct site_t *the_site ) {
    char *dirstack[MAXDIRS], *this;
    char *full = NULL, *fname, *temp;
    struct stat item;
    DIR *curdir;
    struct dirent *ent;
    int dirtop = 0;
    size_t dir_length;
    struct site_file_t *current;

    /* Push the root directory on to the stack */
    dirstack[dirtop++] = strdup( the_site->local_root );
    
    /* Now, for all items in the stack, process all the files, and
     * add the dirs to the stack. Everything we put on the stack is
     * temporary and gets freed eventually. */

    while( dirtop > 0 ) {
	/* Pop the stack */
	this = dirstack[--dirtop];
	
	DEBUG( DEBUG_FILES, "Dir: %s\n", this );
	curdir = opendir( this );
	if( curdir == NULL ) {
	    free( this );
	    continue;
	}

	/* Now read all the directory entries */

	while( (ent = readdir( curdir )) != NULL ) {
	    if( full != NULL ) 
		free( full );
	    full = malloc( strlen( this ) + strlen( ent->d_name ) + 1 );
	    strcpy( full, this );
	    strcat( full, ent->d_name );
	    DEBUG( DEBUG_FILES, "Item: %s - ", ent->d_name );
#ifndef __EMX__
 	    if( lstat( full, &item ) == -1 ) {
#else
	    /* There are no symlinks under OS/2, use stat() instead */
	    if( stat( full, &item ) == -1 ) {
#endif
		/* FIXME: FE warning here */
		continue;
	    }
#ifndef __EMX__
	    /* Is this a symlink? */
	    if( S_ISLNK( item.st_mode ) ) {
		DEBUG( DEBUG_FILES, "symlink - " );
		if( the_site->symlinks == sitesym_ignore ) {
		    /* Just skip it */
		    DEBUG( DEBUG_FILES, "ignoring.\n" );
		    continue;
		} else if( the_site->symlinks == sitesym_follow ) {
		    DEBUG( DEBUG_FILES, "followed - " );
		    /* Else, carry on as normal, stat the real file */
		    if( stat( full, &item ) == -1 ) {
			/* It's probably a broken link */
			DEBUG( DEBUG_FILES, "broken.\n" );
			continue;
		    }
		} else {
		    DEBUG( DEBUG_FILES, "maintained:\n" );
		}
	    }
#endif /* __EMX__ */
	    /* Now process it */

	    /* This is the rel_local of this file - i.e., everything
	     * apart from the local root */
	    fname = (char *)full+strlen(the_site->local_root)-1;

	    /* Check for excludes */
	    if( file_isexcluded( ent->d_name, fname, the_site ) )
		continue;

   
	    for( current=the_site->files; current!=NULL; current=current->next ) {
		if( strcmp( current->rel_local, fname ) == 0 )
		    /* Match found! */
		    break;
/*		last = current; */
	    }
	    
	    if( S_ISREG( item.st_mode ) ) {
		DEBUG( DEBUG_FILES, "file - " );

		if( current == NULL ) {
		    /* This is a new local file... */

		    DEBUG( DEBUG_FILES, "new - " );
		    the_site->numnew++;
		    /* Add a new file to the beginning of the list */
		    current = file_prepend( the_site );
		    current->filename = strdup( base_name( fname ) );
		    /* This is the length of the directory name...
		     * fname = "/full/file/name.ext", filename = "name.ext"
		     * we want directory = "full/file/"... do the maths */
		    dir_length = strlen(fname) - strlen(current->filename)-1;
		    DEBUG( DEBUG_FILES, "dir_length = %ld\n", (long) dir_length );
		    current->directory = malloc( dir_length + 1 );
		    strncpy( current->directory, fname+1, dir_length );
		    *(current->directory+dir_length) = '\0'; /* nullterm */
		    DEBUG( DEBUG_FILES, "directory = %s\n", current->directory );
		    site_assignnames( current, the_site );
		    current->localtime = item.st_mtime;
		    current->localsize = item.st_size;
		    current->diff = file_new;
		    current->mode = item.st_mode;
		    current->dir = false;
		    the_site->totalnew += item.st_size;
/*		    DEBUG( DEBUG_FILES, "new; size: %ld, time: %ld\n", item.st_size, item.st_mtime );  */
		} else {
		    /* Match found... compare it */
		    current->localtime = item.st_mtime;
		    current->localsize = item.st_size;
		    the_site->numdeleted--;
		    if( (current->localtime > current->remotetime) ||
			(current->localsize != current->remotesize) ) {
			/* Changed file */
			current->diff = file_changed;
			current->mode = item.st_mode;
			the_site->numchanged++;
			the_site->totalchanged += item.st_size;
			DEBUG( DEBUG_FILES, "changed (%ld -> %ld)\n", current->localtime, current->remotetime );
		    } else {
			current->diff = file_unchanged;
			current->updated = true;
			the_site->numunchanged++;
			DEBUG( DEBUG_FILES, "unchanged.\n" );
		    }
		    /* The names will already have been assigned */
		}
				    
		/* Assign the ASCII type value */
		current->isascii = file_isascii( fname, the_site );

	    } else if( S_ISDIR( item.st_mode ) ) {
		/* THIS IS A DIRECTORY! */
		if( strcmp( ent->d_name, "." )==0 ||
		    strcmp( ent->d_name, ".." )==0 ) {
		    DEBUG( DEBUG_FILES, "ignored.\n" );
		    continue;
		}
		
		DEBUG( DEBUG_FILES, "directory - " );
		if( dirtop < MAXDIRS ) {
		    temp = malloc( strlen( full ) + 2 );
		    strcpy( temp, full );
		    strcat( temp, "/" );
		    dirstack[dirtop++] = temp;
		} else {
		    /* No more room in stack
		     * FIXME: Report this to the user.*/
		}
		if( current == NULL ) {
		    /* New Directory */
		    the_site->numnew++;
		    current = file_append( the_site );
		    current->filename = strdup( base_name( fname ) );
		    /* Work out the directory name */
		    dir_length = strlen(fname) - strlen(current->filename )-1;
		    current->directory = malloc( dir_length + 1 );
		    strncpy( current->directory, fname+1, dir_length );
		    *(current->directory+dir_length) = '\0'; /* null-term */
		    site_assignnames( current, the_site );
		    current->dir = true;
		    current->diff = file_new;
		    current->mode = item.st_mode;
		    current->localsize = item.st_size;
		    DEBUG( DEBUG_FILES, "new.\n" ); 
		} else {
		    /* It's an existing directory */
		    the_site->numdeleted--;
		    the_site->numunchanged++;
		    current->diff = file_unchanged;
		    current->updated = true;
		    DEBUG( DEBUG_FILES, "existing.\n" ); 
		}
	    } 
#ifndef __EMX__
	    else if( S_ISLNK( item.st_mode ) ) {
		char tmp[BUFSIZ];
		memset( tmp, 0, BUFSIZ );
		DEBUG( DEBUG_FILES, "symlink being maintained.\n" );
		if( readlink( full, tmp, BUFSIZ ) == -1 ) {
		    DEBUG( DEBUG_FILES, "readlink failed: %s\n", 
			   strerror(errno) );
		    continue;
		}
		DEBUG( DEBUG_FILES, "Link target: %s\n", tmp );
		if( current == NULL ) {
		    /* New link */
		    the_site->numnew++;
		    current = file_append( the_site );
		    current->filename = strdup( base_name( fname ) );
		    dir_length = strlen(fname) - strlen(current->filename)-1;
		    DEBUG( DEBUG_FILES, "dir_length = %ld\n", (long) dir_length );
		    current->directory = malloc( dir_length + 1 );
		    strncpy( current->directory, fname+1, dir_length );
		    *(current->directory+dir_length) = '\0'; /* nullterm */
		    DEBUG( DEBUG_FILES, "directory = %s\n", current->directory );
		    current->locallink = strdup( tmp );
		    current->diff = file_new;
		    current->link = true;
		    site_assignnames( current, the_site );
		} else {
		    /* Existing link... compare */
		    the_site->numdeleted--;
		    current->locallink = strdup( tmp );
		    if( strcmp( current->remotelink, tmp ) == 0 ) {
			/* Links match */
			current->updated = true;
			current->diff = file_unchanged;
			the_site->numunchanged++;
		    } else {
			current->diff = file_changed;
			the_site->numchanged++;
		    }
		}
	    }
#endif /* __EMX__ */
	    else {
		DEBUG( DEBUG_FILES, "something else.\n" );
	    }
	}
	/* Close the open directory */
	closedir( curdir );
	/* And we're finished with this */
	free( this );
    }
    return 0;
}

static void site_checkmoved( struct site_t *the_site ) {
    /* Have any files been moved?
     * We look for new files, then see if we can find a deleted file
     * which matches filename, mod time, and size exactly.
     * 
     * This is simplistic, and it is possible to get it wrong in some
     * (unusual) circumstances:
     *    Old: /bar/file1.zip, /foo/file1.zip 
     *    New: /new/file1.zip.
     * If all the file1.zip's have the same size and mod time, it
     * IS NOT POSSIBLE to know which one has become /new/file1.zip without 
     * storing remembering the contents of /bar/file1.zip somehow and 
     * comparing, or using a filesystem which remembers stuff. In any case
     * it's pretty silly to try - so the whole shabang is optional.
     *
     * It would probably be better to search for DELETED files, then 
     * check them against NEW files, since files are more often added
     * to sites then they are deleted. But hey, this is C, who'll notice?
     */
    struct site_file_t *search, *current;
    /*  char *bname, *tmp; */
    /* First off, find the new files... */
    DEBUG( DEBUG_FILES, "Checking for moved files...\n" );