omi/omi/mir.c

//
//   mir.c
//
//   Oliver Fromme  <olli@fromme.com>
//   @(#)$Id: mir.c,v 1.36 1998/12/04 09:04:43 olli Exp $
//

static const char cvsid[]
    = "@(#)$Id: mir.c,v 1.36 1998/12/04 09:04:43 olli Exp $";

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <dirent.h>
#include <limits.h>
#include <time.h>
#include <utime.h>
#include <errno.h>
extern int errno;

#include "omi.h"
#include "mir.h"
#include "pro.h"
#include "rex.h"

static int
iterate_dir (char *dir, jobfunc *job, void *jobdata)
{
	//
	//   Calls the specified job function for each entry
	//   in the specified directory.  The result of the
	//   job function is ignored.
	//   returns 0 on success, -1 on error.
	//

	DIR *mydir;
	struct dirent *entry;
	char *newpath;
	int dirlen;	//   length of "dir" + "/"
	int namelen, namespace;

	if (!(mydir = opendir(dir))) {
		//
		//   If we're in test mode, ignore non-existent
		//   directories (because directories are not
		//   created in test mode).
		//

		if ((cc->flags & MIRROR_TEST) && errno == ENOENT)
			return 0;
		fprintf (stderr, "%s: opendir(%s): %s\n", me, dir, serror());
		cs->errors++;
		return -1;
	}
	dirlen = strlen(dir) + 1;
	newpath = tmalloc(dirlen + 1);
	strcpy (newpath, dir);
	newpath[dirlen - 1] = '/';
	newpath[dirlen] = '\0';
	namespace = 0;
	while ((entry = readdir(mydir))) {
		//
		//   Be careful to ignore the "." and ".."
		//   entries, otherwise we might get into an
		//   infinite loop somewhere.
		//

		if (entry->d_name[0] == '.' && (entry->d_name[1] == '\0' ||
		    (entry->d_name[1] == '.' && entry->d_name[2] == '\0')))
			continue;
		namelen = strlen(entry->d_name);
		if (namelen > namespace) {
			newpath = realloc(newpath, dirlen + namelen + 1);
			if (!newpath)
				out_of_memory();
			namespace = namelen;
		}
		strcpy (newpath + dirlen, entry->d_name);
		job (newpath, jobdata);
	}
	free (newpath);
	closedir (mydir);
	return 0;
}

static int
time_diff (time_t ltime, time_t rtime, omifile *of)
{
	//
	//   Compares the given local and remote time stamps.
	//   Returns 0 if they are equal, within the precision
	//   value given by of->tprec (or if the local time is
	//   newer than remote).
	//   Returns 1 if they are different, but within the
	//   maximum deviation (or if the IGNORETIME option
	//   is set).
	//   Returns 2 if they are completely different, and
	//   the IGNORETIME option is not set.
	//

	time_t diff;

	if (ltime > rtime)
		if (cc->flags && MIRROR_GETOLDERFILES)
			diff = ltime - rtime;
		else
			return 0;
	else
		diff = rtime - ltime;
	if (diff > of->tprec)
		if (!(cc->flags && MIRROR_IGNORETIME) &&
		    diff > of->tprec + cc->deviation)
			return 2;
		else
			return 1;
	else
		return 0;
}

static char *
timereport (time_t t)
{
	static char buff[12];

	//   Note:  Some versions of gcc print a warning if %y
	//   is used.  Oh how I hate that brain-dead GNU crap.

	if (cc->flags & MIRROR_LOCALTIME)
		strftime (buff, 12, "%y%m%d%H%M", localtime(&t));
	else
		strftime (buff, 12, "%y%m%d%H%M", gmtime(&t));
	return buff;
}

static char *
modereport (mode_t m)
{
	static char buff[12];

	strcpy (buff, "----------");
	if ((m & S_IFMT) == S_IFDIR)	buff[0] = 'd';
	if (m & S_IRUSR)	buff[1] = 'r';
	if (m & S_IWUSR)	buff[2] = 'w';
	if (m & S_IXUSR)	buff[3] = 'x';
	if (m & S_IRGRP)	buff[4] = 'r';
	if (m & S_IWGRP)	buff[5] = 'w';
	if (m & S_IXGRP)	buff[6] = 'x';
	if (m & S_IROTH)	buff[7] = 'r';
	if (m & S_IWOTH)	buff[8] = 'w';
	if (m & S_IXOTH)	buff[9] = 'x';
	return buff;
}

#define WHY_NEW  1
#define WHY_GONE 2
#define WHY_TIME 3
#define WHY_SIZE 4
#define WHY_LINK 5
#define WHY_MODE 6

static void
report (int why, long old, long new, char *name)
{
	static omisite *lastsite = NULL;
	char whychar = 0;
	char *fname, *tmps;
	int rootlen;

	if (!cc->havereporthead) {
		cc->havereporthead = TRUE;
		putc ('\n', stderr);
		if (lastsite != ct) {
			lastsite = ct;
			fprintf (stderr, "Report for server %s\n", ct->name);
		}
		fprintf (stderr, "Mirror %s -> %s\n",
		    cp->remotedir, cp->localdir);
	}

	rootlen = strlen(cp->localdir);
	if (!strncmp(name, cp->localdir, rootlen)) {
		//
		//   Cut off the root of the
		//   local tree.
		//
		fname = name + rootlen;
		while (*fname == '/')
			fname++;
		if (!*fname)
			fname = ".";
	}
	else
		fname = name;

	switch (why) {
	case WHY_LINK:
		fprintf (stderr, "*        <link> %10s %s\n",
		    timereport(new), fname);
		break;
	case WHY_NEW:
		whychar = '+';
		/* FALLTHROUGH */
	case WHY_GONE:
		if (!whychar)
			whychar = '-';
		if (old == -1)
			fprintf (stderr, "%c         <dir> %10s %s\n",
			    whychar, timereport(new), fname);
		else if (old == -2)
			fprintf (stderr, "%c        <link> %10s %s\n",
			    whychar, timereport(new), fname);
		else
			fprintf (stderr, "%c    %10ld %10s %s\n",
			    whychar, old, timereport(new), fname);
		break;
	case WHY_TIME:
		if (!(tmps = strdup(timereport(old))))
			out_of_memory();
		fprintf (stderr, "* %10s -> %10s %s\n",
		    tmps, timereport(new), fname);
		free (tmps);
		break;
	case WHY_SIZE:
		if (old < new)
			whychar = '>';
		else
			whychar = '<';
		fprintf (stderr, "%c %10ld -> %10ld %s\n",
		    whychar, old, new, fname);
	case WHY_MODE:
		if (!(tmps = strdup(modereport(old))))
			out_of_memory();
		fprintf (stderr, "* %10s -> %10s %s\n",
		    tmps, modereport(new), fname);
		free (tmps);
	}
}

static bool
tonne (char *path, void *allowreport)
{
	//
	//   Removes the specified files (or at least tries to).
	//   If "path" is a directory, tries to recursively
	//   remove the complete tree.  If "path" is a symlink,
	//   only the link is removed.
	//   Returns TRUE on success, FALSE on error.
	//

	struct stat st;
	int result = 0;

	if (!cc->removelimit)
		return TRUE;
	if (lstat(path, &st) < 0) {
		fprintf (stderr, "%s: lstat(%s): %s\n", me, path, serror());
		cs->errors++;
		return FALSE;
	}
	if ((st.st_mode & S_IFMT) == S_IFDIR) {
		if (cc->flags & MIRROR_PRESERVEDIRS) {
			if (cc->debug != DEBUG_NONE) {
				fprintf (stderr,
				    "%s: warning: directory %s:\n", me, path);
				fprintf (stderr,
				    "will not be removed locally, although it"
				    " disappeared from the remote site.\n");
			}
			//
			//   The user set the PRESERVEDIRS flag
			//   and wants it this way, so we return
			//   "success".
			//
			return TRUE;
		}
		iterate_dir (path, (jobfunc *) tonne, allowreport);
		if (cc->debug & DEBUG_REPORT)
			report (WHY_GONE, -1, st.st_mtime, path);
		if (cc->debug & DEBUG_REMOVE_DIRS)
			fprintf (stderr, "rmdir %s\n", path);
		cs->gonedirs++;
		if ((cc->flags & MIRROR_TEST))
			result = 0;
		else
			if ((result = rmdir(path)) < 0) {
				fprintf (stderr, "%s: rmdir(%s): %s\n", me,
				    (cc->debug & DEBUG_REMOVE_DIRS) ? "" : path,
				    serror());
				cs->errors++;
			}
	}
	else {
		int islink, debuginfo;

		if ((islink = (st.st_mode & S_IFMT) == S_IFLNK))
			cs->gonelinks++;
		else {
			cs->gonefiles++;
			cs->gonebytes += st.st_size;
			cs->growbytes -= st.st_size;
		}
		debuginfo = cc->debug &
		    (islink ? DEBUG_REMOVE_LINKS : DEBUG_REMOVE_FILES);
		if (allowreport && cc->debug & DEBUG_REPORT)
			report (WHY_GONE, islink ? -2 : st.st_size,
			    st.st_mtime, path);
		if (debuginfo)
			fprintf (stderr, "unlink %s\n", path);
		if ((cc->flags & MIRROR_TEST))
			result = 0;
		else
			if ((result = unlink(path)) < 0) {
				fprintf (stderr, "%s: unlink(%s): %s\n",
				    me, debuginfo ? "" : path, serror());
				cs->errors++;
			}
	}
	return result >= 0;
}

int
mkdir_parents (char *path)
{
	//
	//   Creates the parent directories of the given path,
	//   if necessary (note: it doesn't try to mkdir path
	//   itself).
	//

	char *parent, *slash;
	struct stat st;

	if (!(slash = strrchr(path, '/')) || slash == path)
		return 0;
	if (!(parent = strndup(path, slash - path)))
		out_of_memory();

	//
	// *TODO* We're following local symlinks here.
	//        We have to think about whether it makes
	//        sense or not (I think it does).
	//
	if (stat(parent, &st) < 0) {
		if (mkdir_parents(parent) < 0) {
			free (parent);
			return -1;
		}
		if (cc->debug & DEBUG_REPORT)
			report (WHY_NEW, -1, now, parent);
		if (cc->debug & DEBUG_CREATE_DIRS)
			fprintf (stderr, "mkdir %s\n", parent);
		cs->newdirs++;
		if (!(cc->flags & MIRROR_TEST) && mkdir(parent, 0700) < 0) {
			fprintf (stderr, "%s: mkdir(%s): %s\n", me,
			    (cc->debug & DEBUG_CREATE_DIRS) ? "" : parent,
			    serror());
			cs->errors++;
			free (parent);
			return -1;
		}
		if (cc->changegroup) {
			if (cc->debug & DEBUG_CHX)
				fprintf (stderr, "chown(\"%s\", -1, %d)\n",
				    parent, cc->newgroup);
			if (!(cc->flags & MIRROR_TEST))
				chown (parent, -1, cc->newgroup);
		}
		if (cc->debug & DEBUG_CHX)
			fprintf (stderr, "chmod(\"%s\", 0%o)\n",
			    parent, cc->perms_dir);
		if (!(cc->flags & MIRROR_TEST))
			chmod (parent, cc->perms_dir);
	}
	free (parent);
	return 0;
}

static int
check_mkdir (omifile *od, char *path, mode_t *oldmode)
{
	//
	//   Creates the specified directory, if it does not
	//   already exist.  If there is already an entry with
	//   that name which is not a directory (and not a
	//   symlink to a directory), it is tried to be removed
	//   first.
	//
	//   Return values:
	//      -1   error
	//       0   success, the directory already exists
	//       1   success, dir exists, mtime has to be updated
	//       2   success, dir exists, mtime & modes have to be updated
	//       3   success, dir did not exist and has been created
	//

	struct stat st;
	mode_t perms;

	//
	//   *TODO* We are following local symlinks here.
	//          This should be an option.
	//
	if (stat(path, &st) >= 0)
		if ((st.st_mode & S_IFMT) == S_IFDIR) {
			od->flags |= OFLAG_LEXISTS;
			if ((cc->flags & MIRROR_PERMISSIONS)
			    && !(od->flags & OFLAG_BADPERM))
				perms = od->mode & ACCESSPERMS;
			else
				perms = cc->perms_dir;
			if ((st.st_mode & ALLPERMS) != perms) {
				*oldmode = st.st_mode;
				return 2;
			}
			else if (od->mtime &&
			    time_diff(st.st_mtime, od->mtime, od) >= 1)
				return 1;
			else
				return 0;
		}
		else
			tonne (path, path);
	if (cc->debug & DEBUG_REPORT)
		report (WHY_NEW, -1, od->mtime, path);
	if (cc->debug & DEBUG_CREATE_DIRS)
		fprintf (stderr, "mkdir %s\n", path);
	cs->newdirs++;
	if (!(cc->flags & MIRROR_TEST) && mkdir(path, 0700) < 0) {
		fprintf (stderr, "%s: mkdir(%s): %s\n", me,
		    (cc->debug & DEBUG_CREATE_DIRS) ? "" : path,
		    serror());
		cs->errors++;
		return -1;
	}
	if (cc->changegroup) {
		if (cc->debug & DEBUG_CHX)
			fprintf (stderr, "chown(\"%s\", -1, %d)\n",
			    path, cc->newgroup);
		if (!(cc->flags & MIRROR_TEST))
			chown (path, -1, cc->newgroup);
	}
	return 3;
}

int entries_total;		//  total number of (local) entries
simple_list removal_list;	//  list of entries queued for removal

static void
queue_tonne (char *path)
{
	//
	//   Queues a file for removal.
	//

	simple_list_add_string (&removal_list, path);
}

static int
perform_tonne (char *path)
{
	//
	//   Performs all file removals that have been
	//   queued, if allowed by the removelimit.
	//
	//   Returns 1 if at least one file has been
	//   removed, otherwise 0.
	//

	int entries_tonne;
	int changes;

	changes = 0;
	entries_tonne = simple_list_count(&removal_list);
	if (entries_total && (cc->removelimit > 99 ||
	    ((100 * entries_tonne) / entries_total < cc->removelimit))) {
		if ((changes = entries_tonne) > 0)
			simple_list_traverse (&removal_list, (jobfunc *) tonne,
			    &removal_list, TRAVERSE_IGNORERESULT);
	}
	else
		if (entries_tonne && cc->debug != DEBUG_NONE) {
			fprintf (stderr,
			    "%s: warning: directory %s:\n", me, path);
			fprintf (stderr,
			    "Number of disappeared files exceeds removal "
			    "limit of %d%%: no files removed.\n",
			    cc->removelimit);
		}
	simple_list_done (&removal_list);
	return changes;
}

static int
match_locexclude (char *path)
{
	//
	//   Returns MATCH_EXCLUDE or MATCH_INCLUDE.
	//

	int result;

	if (!(result = simple_list_traverse(globalconfig.locexclude,
	    (jobfunc *) regex_job, path, 0))) {
		if (!(result = simple_list_traverse(ct->conf->locexclude,
		    (jobfunc *) regex_job, path, 0))) {
			if (!(result = simple_list_traverse(cc->locexclude,
			    (jobfunc *) regex_job, path, 0))) {
				if (cc->debug & DEBUG_LOCAL_REGEX)
					fprintf (stderr, "local  %s: %s\n",
					    matchdesc[MATCH_INCLUDE], path);
				return MATCH_INCLUDE;
			}
		}
	}
	if ((cc->debug & DEBUG_LOCAL_REGEX) && result)
		fprintf (stderr, "local  %s: %s\n", matchdesc[result], path);
	return result;
}

static int
check_cleanfile (char *name, omifile *omidir)
{
	//
	//   Try to locate the local file "name" in the remote
	//   directory.  If not found, or if the remote file
	//   has an incompatible type (e.g. directory <-> plain
	//   file), then remove the local file.
	//

	struct stat st;
	omifile *of;
	char *basename;
	int i;

	if (match_locexclude(name) == MATCH_EXCLUDE)
		return 0;

	entries_total++;
	if ((basename = strrchr(name, '/')))
		basename++;
	else
		basename = name;

	//
	//   We perform a linear search to locate the name in
	//   "omidir".  Note that we cannot assume that omidir
	//   is sorted.  It might be more efficient to qsort()
	//   omidir first in check_cleandir() and then perform
	//   a binary search here, especially if the directory
	//   is very large.
	//

	of = (omifile *) omidir->data;
	for (i = 0; i < omidir->size; i++, of++)
		if (!strcmp(of->name, basename)
		    && !(of->flags & OFLAG_EXCLUDE))
			break;
	if (i >= omidir->size) {
		//
		//   If not found in remote dir, remove it.
		//
		queue_tonne (name);
		return 0;
	}

	//
	//   The file exists both locally and on the remote
	//   site.  Further handling depends on the type of
	//   the files.
	//
	//   If the remote file is a symlink, we have to mirror
	//   it as such, because following remote symlinks is
	//   difficult (and normally we don't want to follow
	//   remote symlinks anyway).
	//
	//   *TODO* We are following local symlinks here
	//          (except if the remote file is a symlink,
	//          too).  This should be an option.
	//

	if ((of->mode & S_IFMT) == S_IFLNK) {
		//
		//   If the remote file is a symlink, the local
		//   file must be a symlink, too, otherwise
		//   remove it.
		//
		if (lstat(name, &st) < 0) {
			//
			//   Trouble.  Bad luck.
			//   Probably "permission denied".
			//
			fprintf (stderr, "%s: lstat(%s): %s\n",
			    me, name, serror());
			cs->errors++;
			return -1;
		}
		if ((st.st_mode & S_IFMT) != S_IFLNK) {
			queue_tonne (name);
		}
		else
			of->flags |= OFLAG_LEXISTS;
		return 0;
	}

	//
	// *TODO* *CHANGED* lstat() instead of stat():
	//                  Do not follow local symlinks
	//                  by default!
	//
	if (lstat(name, &st) < 0) {
		//
		//   If the stat fails (although we know that
		//   the file exists), it's probably a problem
		//   with the permissions.  We can't do much
		//   about that.
		//
		fprintf (stderr, "%s: stat(%s): %s\n", me, name, serror());
		cs->errors++;
		return -1;
	}
	if ((of->mode & S_IFMT) != (st.st_mode & S_IFMT)) {
		//
		//   If the remote file is a directory and the
		//   local file is a plain file, or vice versa,
		//   remove the local file.
		//
		queue_tonne (name);
	}
	else
		of->flags |= OFLAG_LEXISTS;
	return 0;
}

static int
check_cleandir (char *path, omifile *omidir)
{
	//
	//   Remove entries in the specified local directory
	//   which are not present on the remote site, or which
	//   have incompatible types.
	//
	//   Return values:
	//      0   no files removed.
	//      1   one or more files have been removed.
	//

	entries_total = 0;
	simple_list_init (&removal_list);
	iterate_dir (path, (jobfunc *) check_cleanfile, omidir);
	return perform_tonne(path);
}

static int
update_mtime (char *name, omifile *of)
{
	struct utimbuf times;
	int result;

	if ((cc->flags & MIRROR_DONTTOUCH) || !of->mtime)
		return 0;
	times.actime = of->mtime;
	times.modtime = of->mtime;
	if (cc->debug & DEBUG_CHX)
		fprintf (stderr, "utime(\"%s\", [%ld])\n",
		    name, (long) times.modtime);
	if ((cc->flags & MIRROR_TEST))
		result = 0;
	else
		if ((result = utime(name, &times)) < 0) {
			fprintf (stderr, "%s: utime(): %s\n", me, serror());
			cs->errors++;
		}
	return result;
}

static int
retrieve (ftpstat *fs, char *rname, char *lname, omifile *of)
{
	//
	//   Retrieve the remote file "rname" to the local file
	//   "lname".  It is a plain file (no directory and no
	//   symlink).
	//
	//   We first create the local file under a temporary
	//   name, which we rename to "lname" when the transfer
	//   is done successfully.  (This causes the mtime of
	//   the local directory to be changed, so we have to
	//   reset it after we're done with that directory.)
	//
	//   Return values:
	//      -3   error, stop
	//      -2   error, and we did retry
	//      -1   error, no retry was done, or rename() failed
	//       0   success
	//
	// *TODO* The error handling definitely needs to be
	//        improved!!!
	//

	char *tmpname, *cptr;
	ftpreply *fr;
	int result;
	mode_t perms;

	tmpname = tmalloc(strlen(lname) + 10);
	if ((cptr = strrchr(lname, '/')))
		strncpy (tmpname, lname, ++cptr - lname);
	else
		cptr = lname;
	tmpname[cptr - lname] = 0;
	strcat (tmpname, ".in.");
	strcat (tmpname, cptr);
	strcat (tmpname, ".omi.");
	if (cc->debug & DEBUG_CREATE_FILES)
		fprintf (stderr, "creating %s\n", lname);
	if (of->flags & OFLAG_LEXISTS) {
		cs->updfiles++;
		cs->updbytes += of->size;
	}
	else {
		cs->newfiles++;
		cs->newbytes += of->size;
	}
	cs->growbytes += of->size;
	if (!(cc->flags & MIRROR_TEST)) {
		setsize_progress (of->size);
		fr = ftp_retrieve(fs, rname, tmpname);
		if (fr->code >= 400) {
			free (tmpname);
			if (fr->code % 100 != 99) {
				fprintf (stderr,
				    "%s: error retrieving file %s\n",
				    me, rname);
				fprintf (stderr,
				    "%s: [%d] %s\n", cptr, fr->code, fr->line);
			}
			cs->errors++;
			if (fr->retry == RETRY_NO)
				result = -1;
			else if (fr->retry == RETRY_STOP)
				result = -3;
			else
				result = -2;
			ftp_freereply (fr);
			return result;
		}
		ftp_freereply (fr);
	}
	if (cc->changegroup) {
		if (cc->debug & DEBUG_CHX)
			fprintf (stderr, "chown(\"%s\", -1, %d)\n",
			    tmpname, cc->newgroup);
		if (!(cc->flags & MIRROR_TEST))
			chown (tmpname, -1, cc->newgroup);
	}
	if ((cc->flags & MIRROR_PERMISSIONS) && !(of->flags & OFLAG_BADPERM))
		perms = of->mode & ACCESSPERMS;
	else
		perms = cc->perms_file;
	if (cc->debug & DEBUG_CHX)
		fprintf (stderr, "chmod(\"%s\", 0%o)\n",
		    tmpname, perms);
	if (!(cc->flags & MIRROR_TEST))
		chmod (tmpname, perms);
	update_mtime (tmpname, of);
	if (cc->debug & DEBUG_CHX)
		fprintf (stderr, "rename(\"%s\", \"%s\")\n", tmpname, lname);
	if ((cc->flags & MIRROR_TEST))
		result = 0;
	else
		result = rename(tmpname, lname);
	free (tmpname);
	return result;
}

static int
check_symlink (char *name, omifile *of)
{
	//
	//   Check if the remote symlink already exists locally
	//   and points to the same target.  If not, create it.
	//
	//   Return values:
	//      < 0   error
	//        0   no change
	//        1   symlink is new or has changed
	//

	int namesize;
	char linkname[PATH_MAX + 1];
	int result;

	if ((namesize = readlink(name, linkname, PATH_MAX)) >= 0) {
		linkname[namesize] = '\0';
		if (!strcmp(linkname, (char *) of->data)) {
			//
			//   The symlink already exists locally
			//   and points to the same target.
			//
			return 0;
		}
		else {
			//
			//   There is a symlink with that name,
			//   but it points to a different
			//   target, so remove it.
			//
			if (cc->debug & DEBUG_REPORT)
				report (WHY_LINK, -2, of->mtime, name);
			tonne (name, NULL);
			cs->gonelinks--;
			cs->updlinks++;
		}
	}
	else {
		cs->newlinks++;
		if (cc->debug & DEBUG_REPORT)
			report (WHY_NEW, -2, of->mtime, name);
	}
	if (cc->debug & DEBUG_CREATE_LINKS)
		fprintf (stderr, "symlink %s -> %s\n",
		    name, (char *) of->data);
	if ((cc->flags & MIRROR_TEST))
		result = 0;
	else
		if ((result = symlink((char *) of->data, name)) < 0) {
			fprintf (stderr, "%s: symlink(%s): %s\n", me,
			    (cc->debug & DEBUG_CREATE_LINKS) ? "" : name,
			    serror());
			cs->errors++;
			return -1;
		}
	return 1;
}

static int
check_retrieve (ftpstat *fs, char *rpath, char *lpath, omifile *omidir)
{
	//
	//   Retrieve all files from "omidir" that are not
	//   present locally, or that have changed.  Also
	//   recurse into subdirectories as necessary.
	//
	//   Return values:
	//      < 0   error
	//        0   nothing changed
	//        1   at least one new or updated file
	//

	omifile *of;
	char *lname, *rname;
	struct stat st;
	int i, result, changed;
	mode_t perms;

	changed = 0;
	of = (omifile *) omidir->data;
	for (i = 0; i < omidir->size; i++, of++) {
		if (of->flags & OFLAG_EXCLUDE)
			continue;
		//
		// *TODO* This lname/rname stuff could be
		//        optimized like in iterate_dir().
		//
		lname = tmalloc(strlen(lpath) + strlen(of->name) + 2);
		strcpy (lname, lpath);
		strcat (lname, "/");
		strcat (lname, of->name);
		rname = tmalloc(strlen(rpath) + strlen(of->name) + 2);
		strcpy (rname, rpath);
		strcat (rname, "/");
		strcat (rname, of->name);
		if ((of->mode & S_IFMT) == S_IFDIR) {
			//
			//   If the remote file has type
			//   "directory", recurse into it.
			//   It doesn't matter whether it
			//   exists locally or not, and which
			//   type it has, since mirror_dir()
			//   cares for that.
			//
			result = mirror_dir(fs, rname, lname, of);
			if (result < -1) {
				free (lname);
				free (rname);
				return result;
			}
			if (result >= 1)
				changed = 1;
		}
		else if ((of->mode & S_IFMT) == S_IFLNK) {
			//
			//   If the remote file has type
			//   "symlink", duplicate it locally
			//   if it doesn't already exist and
			//   point to the same target.
			//
			cs->totallinks++;
			if (check_symlink(lname, of) >= 1)
				changed = 1;
		}
		else {
		    //
		    //   The remote file is a plain file.
		    //
		    cs->totalfiles++;
		    cs->totalbytes += of->size;
		    if (stat(lname, &st) < 0) {
			//
			//   The remote file is a plain file.
			//   Since it doesn't exist locally,
			//   get it.
			//
			if (cc->debug & DEBUG_REASONING)
				fprintf (stderr, "new file %s\n",
				    lname);
			if (cc->debug & DEBUG_REPORT)
				report (WHY_NEW, of->size, of->mtime, lname);
			changed = 1;
			result = retrieve(fs, rname, lname, of);
			if (result < -1) {
				free (lname);
				free (rname);
				return result;
			}
		    }
		    else if (st.st_size != of->size) {
			//
			//   It's a plain file that is both
			//   present on the local and remote
			//   site, but with different sizes.
			//   Get the file from the remote site.
			//   Note that we do not have to remove
			//   the local file, as it will be
			//   overwritten when the retrieval is
			//   done.
			//
			// *TODO* In a later version, it might
			//        be useful to try a "reget" if
			//        the local file is smaller
			//        than the remote file, but
			//        with the same mtime.  This
			//        could at least be an option.
			//        Of course we have to check
			//        first that the remote server
			//        supports the REST command
			//        appropriately.
			//
			if (cc->debug & DEBUG_REASONING)
				fprintf (stderr, "size mismatch for %s\n",
				    lname);
			if (cc->debug & DEBUG_REPORT)
				report (WHY_SIZE,
				    st.st_size, of->size, lname);
			cs->growbytes -= st.st_size;
			//
			//   We have to set `changed' to 1 in
			//   this case, too, because retrieve()
			//   changes the mtime of the local
			//   directory!
			//
			changed = 1;
			result = retrieve(fs, rname, lname, of);
			if (result < -1) {
				free (lname);
				free (rname);
				return result;
			}
		    }
		    else if ((result =
		      time_diff(st.st_mtime, of->mtime, of)) > 1) {
			//
			//   The size is the same, but the
			//   mtimes differ.  Get the file.
			//
			if (cc->debug & DEBUG_REASONING)
				fprintf (stderr, "mtime mismatch for %s\n",
				    lname);
			if (cc->debug & DEBUG_REPORT)
				report (WHY_TIME,
				    st.st_mtime, of->mtime, lname);
			cs->growbytes -= st.st_size;
			changed = 1;	//   Se above!
			result = retrieve(fs, rname, lname, of);
			if (result < -1) {
				free (lname);
				free (rname);
				return result;
			}
		    }
		    else {
			if ((cc->flags & MIRROR_PERMISSIONS)
			    && !(of->flags & OFLAG_BADPERM))
				perms = of->mode & ACCESSPERMS;
			else
				perms = cc->perms_file;
			if ((st.st_mode & ALLPERMS) != perms) {
				cs->permfiles++;
				if (cc->debug & DEBUG_REPORT)
					report (WHY_MODE,
					    st.st_mode, perms, lname);
				if (cc->debug & DEBUG_CHX)
					fprintf (stderr, "chmod(\"%s\", 0%o)\n",
					    lname, perms);
				if (!(cc->flags & MIRROR_TEST))
					chmod (lname, perms);
			}
			if (result == 1)	// result from time_diff()
				update_mtime (lname, of);
		    }
		}
		free (rname);
		free (lname);
	}
	return changed;
}

typedef int sortjob(const void *, const void *);

static int
timesortjob (const omifile *a, const omifile *b)
{
	//
	//   Sort two files according to the timestamp,
	//   so that the newer one comes first.
	//
	//   If there are files with the EXCLUDE flag,
	//   they should come last.
	//

	bool excla, exclb;

	excla = (a->flags & OFLAG_EXCLUDE) != 0;
	exclb = (b->flags & OFLAG_EXCLUDE) != 0;
	if (excla != exclb)
		if (excla)
			return 1;
		else
			return -1;

	if (a->mtime > b->mtime)
		return -1;
	if (a->mtime < b->mtime)
		return 1;
	return 0;
}

static void
filter_dir (omifile *od)
{
	omifile *of;
	int i;

	if (cc->newest && od->size > cc->newest) {
		//
		//   First sort the directory entries by timestamps,
		//   newest first.
		//

		qsort (od->data, od->size, sizeof(omifile),
		    (sortjob *) timesortjob);

		//
		//   Now we only need the first cc->newest entries,
		//   so we discard all the rest.
		//

		of = (omifile *) od->data + cc->newest;
		for (i = cc->newest; i < od->size; i++, of++) {
			if (of->name)
				free (of->name);
			switch (of->mode & S_IFMT) {
			case S_IFDIR:
				free_tree (of);
				break;
			case S_IFLNK:
				if (of->data)
					free (of->data);
			}
		}
		od->size = cc->newest;
		if (!(od->data = realloc(od->data, od->size * sizeof(omifile))))
			out_of_memory();
	}
}

int
mirror_dir (ftpstat *fs, char *rpath, char *lpath, omifile *omidir)
{
	//
	//   Mirror the remote directory "rpath" (the tree
	//   structure is given in "omidir") to the local
	//   directory "lpath".
	//
	//   Return values
	//      < 0   error
	//        0   the directory already existed locally
	//        1   it's a new directory
	//

	int retrresult, cleanresult, makeresult;
	mode_t perms, oldmode;

	cs->totaldirs++;

	//
	//   Filter entries in this directory, if necessary.
	//

	filter_dir (omidir);

	//
	//   First, create the local directory if it doesn't
	//   already exist.
	//

	if ((makeresult = check_mkdir(omidir, lpath, &oldmode)) < 0) {
		fprintf (stderr, "%s: Can't create local directory, "
		    "skipping directory tree.\n", me);
		return -1;
	}

	//
	//   Second, iterate the local directory, compare
	//   each entry with the "omidir", and remove local
	//   files not present on the remote server.
	//

	if ((cleanresult = check_cleandir(lpath, omidir)) < 0)
		return cleanresult;

	//
	//   Third, iterate the "omidir", compare every entry
	//   with the local file (if present), and download it
	//   if necessary.  Also recurse into subdirectories.
	//

	if ((retrresult = check_retrieve(fs, rpath, lpath, omidir)) < 0)
		return retrresult;

	if ((omidir->flags & OFLAG_LEXISTS) && (cleanresult || retrresult))
		cs->upddirs++;

	//
	//   Finally, update permission modes and time stamps
	//   of the local directory if anything has changed
	//   inside, or if the local directory's timestamp is
	//   different from the remote one's.
	//

	if (makeresult >= 2) {
		if ((cc->flags & MIRROR_PERMISSIONS)
		    && !(omidir->flags & OFLAG_BADPERM))
			perms = omidir->mode & ACCESSPERMS;
		else
			perms = cc->perms_dir;
		if (makeresult < 3) {
			cs->permdirs++;
			if (cc->debug & DEBUG_REPORT)
				report (WHY_MODE,
				    oldmode, perms | S_IFDIR, lpath);
		}
		if (cc->debug & DEBUG_CHX)
			fprintf (stderr, "chmod(\"%s\", 0%o)\n",
			    lpath, perms);
		if (!(cc->flags & MIRROR_TEST))
			chmod (lpath, perms);
	}
	if (makeresult || cleanresult || retrresult)
		update_mtime (lpath, omidir);
	return makeresult >= 3;
}

//--