Remove building with NOCRYPTO option

[minix3.git] / minix / commands / synctree / synctree.c

/*      synctree 4.16 - Synchronise file tree.          Author: Kees J. Bot
 *                                                              5 Apr 1989
 * SYNOPSYS
 *      synctree [-iuf] [[user1@machine1:]dir1 [[user2@]machine2:]dir2
 *
 * Dir2 will then be synchronized to dir1 with respect to the flags.
 * The flags mean:
 *      -i  Be interactive on files other than directories too.
 *      -u  Only install files that are newer, i.e. that need an update.
 *      -f  Force.  Don't ask for confirmation, all answers are 'yes'.
 *
 * Hitting return lets synctree use its proposed answer.  Hitting CTRL-D is
 * like typing return to all questions that follow.
 *
 * If either of the directories to be synchronized contains the file ".backup"
 * then it is a backup directory.  The file ".backup" in this directory is
 * an array of mode information indexed on inode number.
 *
 * 89/04/05, Kees J. Bot - Birth of tree synchronizing program.
 * 92/02/02              - General overhaul, rcp(1) like syntax.
 */

#define nil 0
#include <sys/types.h>
#include <stddef.h>
#include <stdio.h>
#include <sys/stat.h>
#include <utime.h>
#include <string.h>
#include <signal.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <sys/wait.h>

#define USE_SHADOWING 0

#ifndef PATH_MAX

#define PATH_MAX        1024
#endif

#ifndef S_ISLNK
/* There were no symlinks in medieval times. */
#define S_ISLNK(mode)                   (0)
#define lstat                           stat
#define symlink(path1, path2)           (errno= ENOSYS, -1)
#define readlink(path, buf, len)        (errno= ENOSYS, -1)
#endif

#define NUMBYTES     4  /* Any number fits in this many bytes. */
#define CHUNK     4096  /* Transfer files in this size chunks. */

static int install= 0;  /* Install files, do not delete, update if newer. */
static int interact= 0; /* Ask permission to install too. */
static int force= 0;    /* Force trees to be completely equal. */
static int backup= 0;   /* This tree is for backup. */

static char SYNCNAME[]  = "synctree";
static char SLAVENAME[] = "==SLAVE==";
static char MASTERNAME[]= "==MASTER==";


static char BACKUP[] = ".backup";       /* Backup filemodes. */
static int filemodes;                   /* Filemodes fildes. */

static int chan[2]= { 0, 1 };   /* In and output channel to opposite side. */

#define BUCKSIZE (1+NUMBYTES+CHUNK)
static char bucket[BUCKSIZE];   /* Put a lot of things here before sending. */
static char *buckp= bucket;     /* Fill pointer. */
static int buckn= 0;            /* # bytes in bucket. */

enum orders {   /* What back breaking labour should the slave perform? */
        ENTER= 128,     /* Make ready to process contents of directory. */
        ADVANCE,        /* Determine next pathname and report it back. */
        CAT,            /* Send contents of file. */
        MORE,           /* Send more file contents. */
        ORDER_CANCEL,           /* Current pathname is not installed, remove as link. */
        DIE,            /* Die with exit(0); */
        DIE_BAD,        /* exit(1); */
        POSITIVE,       /* Ask a yes/no question expecting yes. */
        NEGATIVE,       /* Same expecting no. */
        PASS_YES,       /* Pass this to the master will you. */
        PASS_NO         /* Same here. */
};

#ifdef DEBUG
char *ORDERS[]= {
        "ENTER", "ADVANCE", "CAT", "MORE", "CANCEL", "DIE", "DIE_BAD",
        "POSITIVE", "NEGATIVE", "PASS_YES", "PASS_NO"
};
#endif

enum answers {
        PATH= 128,      /* Report pathname, and stat(2) info. */
        LINK,           /* Report linkname, pathname, and stat(2) info. */
        DATA,           /* Contents of file follow. */
        NODATA,         /* Can't read file. */
        DONE,           /* Nothing more to advance to. */
        SYMLINK,        /* Report symlinkname, pathname, and stat(2) info. */
        YES, NO         /* Result of an ASK. */
};

#ifdef DEBUG
char *ANSWERS[]= {
        "PATH", "LINK", "DATA", "NODATA", "DONE", "SYMLINK", "YES", "NO"
};

#define DPRINTF(format, arg)    fprintf(stderr, format, arg0, arg)
#else
#define DPRINTF(format, arg)
#endif

struct mode {
        unsigned short  md_mode;
        unsigned short  md_uid;
        unsigned short  md_gid;
        unsigned short  md_rdev;
        unsigned short  md_devsiz;
};

static char *arg0;      /* basename(argv[0]) */
static int ex= 0;       /* exit status. */

static void because()
{
        fprintf(stderr, ": %s\n", strerror(errno));
        ex= 1;
}

static void perr(char *label)
{
        fprintf(stderr, "%s: %s: %s\n", arg0, label, strerror(errno));
        ex= 1;
}

static void perrx(char *label)
{
        perr(label);
        exit(1);
}

#if S_HIDDEN
/* Support for per achitecture hidden files. */
static int transparent= 0;

static void isvisible(char *name)
{
        char *p= name + strlen(name);

        while (p > name && *--p == '/') {}

        if (p > name && *p == '@' && p[-1] != '/') transparent= 1;
}
#else
#define transparent     0
#define isvisible(name) ((void) 0)
#endif

static void isbackup(int slave)
{
        if ((filemodes= open(BACKUP, slave ? O_RDONLY : O_RDWR)) >= 0)
                backup= 1;
        else {
                if (errno != ENOENT) perrx(BACKUP);
        }
}

static char path[PATH_MAX+1];   /* Holds pathname of file being worked on. */
static char lnkpth[PATH_MAX+1]; /* (Sym)link to path. */
static char *linkpath;          /* What path is, or should be linked to. */
static struct stat st;          /* Corresponding stat(2) info. */
static char Spath[PATH_MAX+1];  /* Slave is looking at this. */
static char Slnkpth[PATH_MAX+1];/* (Sym)link to Spath. */
static char *Slinkpath=nil;     /* Either nil or Slnkpth. */
static struct stat Sst;         /* Slave's stat(2). */

static char *addpath(char *p, char *n)
/* Add a name to the path, return pointer to end. */
{
        if (p - path + 1 + strlen(n) > PATH_MAX) {
                *p= 0;
                fprintf(stderr, "%s: %s/%s is too long.\n", arg0, path, n);
                fprintf(stderr, "%s: Unable to continue.\n", arg0);
                exit(1);
        }
        if (p == path+1 && path[0] == '.') p= path;

        if (p > path) *p++ = '/';

        while (*n != 0) *p++ = *n++;
        *p= 0;
        return p;
}

struct entry {  /* A directory entry. */
        struct entry    *next;  /* Next entry in same directory */
        struct entry    *dir;   /* It is part of this directory */
        struct entry    *con;   /* If a dir, its contents */
        char            *name;  /* Name of this dir entry */
};

static struct entry *E= nil;            /* File being processed. */

static void setpath(struct entry *e)
/* Set path leading to e. */
{
        static char *pend;

        if (e == nil)
                pend= path;
        else {
                setpath(e->dir);
                pend= addpath(pend, e->name);
        }
}

static void sort(struct entry **ae)
/* This is either a stable mergesort, or thermal noise, I'm no longer sure.
 * It must be called like this: if (L!=nil && L->next!=nil) sort(&L);
 */
{
        /* static */ struct entry *e1, **mid;  /* Need not be local */
        struct entry *e2;

        e1= *(mid= &(*ae)->next);
        do {
                if ((e1= e1->next) == nil) break;
                mid= &(*mid)->next;
        } while ((e1= e1->next) != nil);

        e2= *mid;
        *mid= nil;

        if ((*ae)->next != nil) sort(ae);
        if (e2->next != nil) sort(&e2);

        e1= *ae;
        for (;;) {
                if (strcmp(e1->name, e2->name)<=0) {
                        if ((e1= *(ae= &e1->next)) == nil) {
                                *ae= e2;
                                break;
                        }
                } else {
                        *ae= e2;
                        e2= *(ae= &e2->next);
                        *ae= e1;
                        if (e2 == nil) break;
                }
        }
}

static void enter()
/* Collect directory entries of E. */
{
        struct entry **last= &E->con, *new;
        struct dirent *e;
        DIR *d;

        if ((d= opendir(path)) == nil) {
                fprintf(stderr, "%s: Can't read dir %s\n", arg0, path);
                return;
        }

        while ((e= readdir(d)) != nil) {
                if (e->d_name[0] == '.' && (e->d_name[1] == 0
                        || (e->d_name[1] == '.' && e->d_name[2] == 0)
                )) continue;

                new= (struct entry *) malloc(sizeof(*new));

                new->next= nil;
                new->dir= E;
                new->con= nil;
                new->name= (char *) malloc(strlen(e->d_name) + 1);
                strcpy(new->name, e->d_name);
                *last= new;
                last= &new->next;
        }
        closedir(d);
        if (E->con != nil && E->con->next != nil) sort(&E->con);
}

#define arraysize(a)    (sizeof(a) / sizeof((a)[0]))
#define arraylimit(a)   ((a) + arraysize(a))

static char *link_islink(struct stat *stp, const char *file)
{
    /* Tell if a file, which stat(2) information in '*stp', has been seen
     * earlier by this function under a different name.  If not return a
     * null pointer with errno set to ENOENT, otherwise return the name of
     * the link.  Return a null pointer with an error code in errno for any
     * error, using E2BIG for a too long file name.
     *
     * Use link_islink(nil, nil) to reset all bookkeeping.
     *
     * Call for a file twice to delete it from the store.
     */

    typedef struct link {       /* In-memory link store. */
        struct link     *next;          /* Hash chain on inode number. */
        ino_t           ino;            /* File's inode number. */
        off_t           off;            /* Offset to more info in temp file. */
    } link_t;
    typedef struct dlink {      /* On-disk link store. */
        dev_t           dev;            /* Device number. */
        char            file[PATH_MAX]; /* Name of earlier seen link. */
    } dlink_t;
    static link_t *links[256];          /* Hash list of known links. */
    static int tfd= -1;                 /* Temp file for file name storage. */
    static dlink_t dlink;
    link_t *lp, **plp;
    size_t len;
    off_t off;

    if (file == nil) {
        /* Reset everything. */
        for (plp= links; plp < arraylimit(links); plp++) {
            while ((lp= *plp) != nil) {
                *plp= lp->next;
                free(lp);
            }
        }
        if (tfd != -1) close(tfd);
        tfd= -1;
        return nil;
    }

    /* The file must be a non-directory with more than one link. */
    if (S_ISDIR(stp->st_mode) || stp->st_nlink <= 1) {
        errno= ENOENT;
        return nil;
    }

    plp= &links[stp->st_ino % arraysize(links)];

    while ((lp= *plp) != nil) {
        if (lp->ino == stp->st_ino) {
            /* May have seen this link before.  Get it and check. */
            if (lseek(tfd, lp->off, SEEK_SET) == -1) return nil;
            if (read(tfd, &dlink, sizeof(dlink)) < 0) return nil;

            /* Only need to check the device number. */
            if (dlink.dev == stp->st_dev) {
                if (strcmp(file, dlink.file) == 0) {
                    /* Called twice.  Forget about this link. */
                    *plp= lp->next;
                    free(lp);
                    errno= ENOENT;
                    return nil;
                }

                /* Return the name of the earlier link. */
                return dlink.file;
            }
        }
        plp= &lp->next;
    }

    /* First time I see this link.  Add it to the store. */
    if (tfd == -1) {
        for (;;) {
            char *tmp;

            tmp= tmpnam(nil);
            tfd= open(tmp, O_RDWR|O_CREAT|O_EXCL, 0600);
            if (tfd < 0) {
                if (errno != EEXIST) return nil;
            } else {
                (void) unlink(tmp);
                break;
            }
        }
    }
    if ((len= strlen(file)) >= PATH_MAX) {
        errno= E2BIG;
        return nil;
    }

    dlink.dev= stp->st_dev;
    strcpy(dlink.file, file);
    len += offsetof(dlink_t, file) + 1;
    if ((off= lseek(tfd, 0, SEEK_END)) == -1) return nil;
    if (write(tfd, &dlink, len) != len) return nil;

    if ((lp= malloc(sizeof(*lp))) == nil) return nil;
    lp->next= nil;
    lp->ino= stp->st_ino;
    lp->off= off;
    *plp= lp;
    errno= ENOENT;
    return nil;
}

#define cancellink()    ((void) islink())

static char *islink()
/* Returns the name of the file path is linked to.  If no such link can be
 * found, then path is added to the list and nil is returned.  If all the
 * links of a file have been seen, then it is removed from the list.
 * Directories are not seen as linkable.
 */
{
        char *name;

        name= link_islink(&st, path);
        if (name == nil && errno != ENOENT) perrx(path);
        return name;
}

static void setstat(ino_t ino, struct stat *stp)
/* Set backup status info, we know that backup is true. */
{
        struct mode md;

        md.md_mode = stp->st_mode;
        md.md_uid = stp->st_uid;
        md.md_gid = stp->st_gid;
        md.md_rdev = stp->st_rdev;
        md.md_devsiz = stp->st_size / 1024;

        if (lseek(filemodes, (off_t) sizeof(md) * (off_t) ino, 0) == -1
                || write(filemodes, (char *) &md, sizeof(md)) != sizeof(md)
        ) perrx(BACKUP);
}

static int getstat(char *name, struct stat *stp)
/* Get status information of file name, skipping some files.  Backup info
 * is inserted as needed.
 */
{
        errno= 0;

        if (strcmp(name, BACKUP) == 0) return -1;

        if (lstat(name, stp) < 0) return -1;

        if (stp->st_mode == S_IFREG && stp->st_mtime == 0) return -1;

        if (backup) {
                struct mode md;

                if (lseek(filemodes,
                        (off_t) sizeof(md) * (off_t) stp->st_ino, 0) == -1
                    || read(filemodes, (char *) &md, sizeof(md)) != sizeof(md)
                    || md.md_mode == 0
                ) {
                        errno= 0;
                        setstat(stp->st_ino, stp);
                } else {
                        stp->st_mode = md.md_mode;
                        stp->st_uid = md.md_uid;
                        stp->st_gid = md.md_gid;
                        stp->st_rdev = md.md_rdev;
                        if (S_ISBLK(stp->st_mode))
                                stp->st_size= (off_t) md.md_devsiz * 1024;
                }
        }
        return 0;
}

static int advance()
/* Determine next pathname, return true on success. */
{
        for (;;) {
                if (E==nil) {   /* First call, enter root dir. */
                        E= (struct entry *) malloc(sizeof(*E));
                        E->dir= nil;
                        E->con= nil;
                        E->next= nil;
                        E->name= (char *) malloc(3);
                        strcpy(E->name, transparent ? ".@" : ".");
                } else
                if (E->con != nil)      /* Dir's files must be processed. */
                        E= E->con;
                else {
                        for (;;) {
                                /* Remove E from it's parents list, then
                                 * try next entry, if none, go to parent dir.
                                 */
                                struct entry *junk= E, *parent= E->dir;

                                if (parent != nil) parent->con= E->next;
                                E= E->next;
                                free(junk->name);
                                free(junk);

                                if (E != nil) break;

                                if ((E= parent) == nil) return 0;
                        }
                }
                setpath(E);
                if (getstat(path, &st) == 0) {
                        if (S_ISLNK(st.st_mode)) {
                                int n;

                                if ((n= readlink(path, lnkpth, PATH_MAX)) >= 0)
                                {
                                        lnkpth[n]= 0;
                                        break;
                                }
                        } else {
                                break;
                        }
                }
                if (errno != 0 && errno != ENOENT) perr(path);
        }

        linkpath= islink();
        DPRINTF("%s: path = %s\n", path);
        return 1;
}

static enum orders request()
/* Slave reads command sent by master. */
{
        static char buf[64], *bp;
        static int n= 0;
        int req;

        for (;;) {
                if (n == 0) {
                        if ((n= read(chan[0], buf, (int) sizeof(buf))) <= 0) {
                                if (n < 0) perrx("request()");
                                /* Master died, try to report it then follow. */
                                fprintf(stderr,
                                        "%s: Master died prematurely.\n", arg0);
                                exit(1);
                        }
                        bp= buf;
                }
                req= *bp++ & 0xFF;
                n--;
                if (req >= (int) ENTER) break;

                /* Master using slave to print to stdout: */
                putchar(req);
        }
        DPRINTF("%s: request() == %s\n", ORDERS[req - (int) ENTER]);

        return (enum orders) req;
}

static void report()
{
        int r;

        DPRINTF("%s: reporting now!\n", 0);

        buckp= bucket;

        while (buckn > 0) {
                r = buckn;
                if (r > (512 << sizeof(char*))) r= (512 << sizeof(char*));

                if ((r= write(chan[1], buckp, r)) < 0) perrx("report()");

                buckp += r;
                buckn -= r;
        }
        buckp= bucket;
        buckn= 0;
}

static void inform(enum answers a)
/* Slave replies to master. */
{
        DPRINTF("%s: inform(%s)\n", ANSWERS[(int) a - (int) PATH]);

        *buckp++ = (int) a;
        buckn++;
}

#define wwrite(buf, n)  (memcpy(buckp, (buf), (n)), buckp+= (n), buckn+= (n))

static void sendnum(long n)
/* Send number from least to most significant byte. */
{
#if BYTE_ORDER == LITTLE_ENDIAN
        wwrite((char *) &n, sizeof(n));
#else
        char buf[NUMBYTES];

        buf[0]= (char) (n >>  0);
        buf[1]= (char) (n >>  8);
        buf[2]= (char) (n >> 16);
        buf[3]= (char) (n >> 24);
        wwrite(buf, sizeof(buf));
#endif
}

static void send(char *buf, int n)
/* Slave sends size and contents of buf. */
{
        sendnum((long) n);
        if (n > 0) wwrite(buf, (size_t) n);
}

static void sendstat(struct stat *stp)
{
        sendnum((long) stp->st_mode);
        sendnum((long) stp->st_uid);
        sendnum((long) stp->st_gid);
        sendnum((long) stp->st_rdev);
        sendnum((long) stp->st_size);
        sendnum((long) stp->st_mtime);
}

static int ask();

static void slave()
/* Carry out orders from the master, such as transmitting path names.
 * Note that the slave uses path, not Spath, the master uses Spath.
 */
{
        int f, n;
        char buf[CHUNK];
        enum { run, done, die } state= run;

        do {
                switch (request()) {
                case ENTER:
                        enter();
                        break;
                case ADVANCE:
                        if (!advance() || state == done) {
                                inform(DONE);
                                state= done;
                        } else {
                                if (linkpath!=nil) {
                                        inform(LINK);
                                        send(linkpath, strlen(linkpath) + 1);
                                } else
                                if (S_ISLNK(st.st_mode)) {
                                        inform(SYMLINK);
                                        send(lnkpth, strlen(lnkpth) + 1);
                                } else {
                                        inform(PATH);
                                }
                                send(path, strlen(path) + 1);
                                sendstat(&st);
                        }
                        break;
                case CAT:
                        if ((f= open(path, O_RDONLY))<0) {
                                fprintf(stderr, "%s: Can't open %s",
                                        arg0, path);
                                because();
                                inform(NODATA);
                                break;
                        }
                        inform(DATA);
                        do {
                                n= read(f, buf, sizeof(buf));
                                if (n < 0) perr(path);
                                send(buf, n);
                                if (n > 0) report();
                        } while (n > 0);
                        close(f);
                        break;
                case ORDER_CANCEL:
                        cancellink();
                        break;
                case DIE_BAD:
                        ex= 1;
                        /*FALL THROUGH*/
                case DIE:
                        state= die;
                        break;
                case POSITIVE:
                        inform(ask('y') ? YES : NO);
                        break;
                case NEGATIVE:
                        inform(ask('n') ? YES : NO);
                        break;
                case PASS_YES:
                        inform(YES);
                        break;
                case PASS_NO:
                        inform(NO);
                        break;
                default:
                        fprintf(stderr, "%s: strange request\n", arg0);
                        exit(1);
                }
                report();
        } while (state != die);
}

static int execute(char **argv)
/* Execute a command and return its success or failure. */
{
        int pid, r, status;

        if ((pid= fork())<0) {
                perr("fork()");
                return 0;
        }
        if (pid == 0) {
                execvp(argv[0], argv);
                perrx(argv[0]);
        }
        while ((r= wait(&status)) != pid) {
                if (r < 0) {
                        perr(argv[0]);
                        return 0;
                }
        }
        return status == 0;
}

static int removedir(char *dir)
/* Remove a directory and its contents. */
{
        static char *argv[] = { "rm", "-r", nil, nil };

        printf("(rm -r %s)\n", dir);

        argv[2]= dir;
        return execute(argv);
}

static void order(enum orders o)
/* Master tells slave what to do. */
{
        char c= (char) o;

        DPRINTF("%s: order(%s)\n", ORDERS[o - (int) ENTER]);

        if (write(chan[1], &c, 1) != 1) perrx("order()");
}

static void rread(char *buf, int n)
/* Master gets buf of size n from slave, doing multiple reads if needed. */
{
        int r;

        while (n > 0) {
                if (buckn == 0) {
                        switch (buckn= read(chan[0], bucket, BUCKSIZE)) {
                        case -1:
                                perrx("reply channel from slave");
                        case  0:
                                fprintf(stderr,
                                        "%s: slave died prematurely.\n",
                                        arg0);
                                exit(1);
                        }
                        buckp= bucket;
                }
                r= n < buckn ? n : buckn;
                memcpy(buf, buckp, r);
                buckp+= r;
                buckn-= r;
                buf+= r;
                n-= r;
        }
}

static enum answers answer()
/* Master reads slave's reply. */
{
        char c;
        int a;

        rread(&c, 1);
        a= c & 0xFF;

        DPRINTF("%s: answer() == %s\n", ANSWERS[a - (int) PATH]);

        return (enum answers) a;
}

static long recnum()
/* Read number as pack of bytes from least to most significant.  The data
 * is on the wire in little-endian format.  (Mostly run on PC's).
 */
{
#if BYTE_ORDER == LITTLE_ENDIAN
        long n;

        rread((char *) &n, (int) sizeof(n));
        return n;
#else
        unsigned char buf[NUMBYTES];

        rread(buf, sizeof(buf));
        return  buf[0]
                | ((unsigned) buf[1] << 8)
                | ((unsigned long) buf[2] << 16)
                | ((unsigned long) buf[3] << 24);
#endif
}

static int receive(char *buf, int max)
/* Master get's data from slave, by first reading size, then data. */
{
        int n;

        n= recnum();
        if (n > max) {
                fprintf(stderr, "%s: panic: Can't read %d bytes\n", arg0, n);
                exit(1);
        }
        if (n > 0) rread(buf, n);
        return n;
}

static void recstat(struct stat *stp)
{
        stp->st_mode= recnum();
        stp->st_uid= recnum();
        stp->st_gid= recnum();
        stp->st_rdev= recnum();
        stp->st_size= recnum();
        stp->st_mtime= recnum();
}

static int key()
{
        int c;
        static int tty= -1;

        if (tty < 0) tty= isatty(0);

        if (feof(stdin) || (c= getchar()) == EOF) {
                c= '\n';
                if (tty) putchar('\n');
        }

        if (!tty) putchar(c);

        return c;
}

static int ask(int def)
/* Ask for a yes or no, anything else means choose def. */
{
        int y, c;

        if (chan[0] == 0) {
                /* I'm running remote, tell the slave to ask. */
                fflush(stdout);
                order(def == 'y' ? POSITIVE : NEGATIVE);
                return answer() == YES;
        }

        printf("? (%c) ", def);
        fflush(stdout);

        do c= key(); while (c == ' ' || c == '\t');

        y= c;

        while (c != '\n') c= key();

        if (y != 'y' && y != 'Y' && y != 'n' && y != 'N') y= def;

        return y == 'y' || y == 'Y';
}

static void setmodes(int silent)
{
        struct stat st;
        int change= 0;
        struct utimbuf tms;

        errno= 0;
        getstat(Spath, &st);
        if (backup && silent) {
                setstat(st.st_ino, &Sst);
                getstat(Spath, &st);
        }

        if (S_ISLNK(st.st_mode)) return;

        if (errno == 0 && st.st_mode != Sst.st_mode) {
                if (!backup) chmod(Spath, Sst.st_mode & 07777);
                change= 1;
        }
        if (errno == 0
                && (st.st_uid != Sst.st_uid || st.st_gid != Sst.st_gid)
                && (backup || geteuid() == 0)
        ) {
                errno= 0;
                if (!backup) chown(Spath, Sst.st_uid, Sst.st_gid);
                change= 1;
        }

        if (backup && !silent) setstat(st.st_ino, &Sst);

        if (errno == 0 && S_ISREG(Sst.st_mode) && st.st_mtime != Sst.st_mtime) {
                time(&tms.actime);
                tms.modtime= Sst.st_mtime;
                errno= 0;
                utime(Spath, &tms);
                change= 1;
        }
        if (errno != 0) {
                fprintf(stderr, "%s: Can't set modes of %s", arg0, Spath);
                because();
        } else
        if (change && !silent) {
                printf("Mode changed of %s\n", Spath);
        }
}

static void makeold()
{
        static struct utimbuf tms= { 0, 0 };

        if (utime(Spath, &tms) < 0) {
                if (errno != ENOENT) {
                        fprintf(stderr,
                                "%s: can't make %s look old", arg0, Spath);
                        because();
                }
        } else {
                fprintf(stderr, "%s: made %s look old.\n", arg0, Spath);
        }
}

static int busy= 0;

static void bail_out(int sig)
{
        signal(sig, SIG_IGN);

        fprintf(stderr, "%s: Exiting after signal %d\n", arg0, sig);

        if (busy) {
                fprintf(stderr, "%s: was installing %s\n", arg0, Spath);
                makeold();
        }
        order(DIE_BAD);

        exit(sig);
}

static int makenode(char *name, int mode, dev_t addr, off_t size)
{
        int r;

        if (!backup) {
                r= mknod(name, mode, addr);
        } else {
                if ((r= creat(name, 0644)) >= 0) close(r);
        }
        return r;
}

static void add(int update)
/* Add Spath to the filesystem. */
{
        int f, n;
        char buf[CHUNK];
        int forced_update= force && update;

        if (Slinkpath != nil && !S_ISLNK(Sst.st_mode)) {
                if (interact && !update) {
                        printf("Link %s to %s", Spath, Slinkpath);
                        if (!ask('n')) return;
                }
                if (link(Slinkpath, Spath) >= 0) {
                        printf("Linked %s to %s\n", Spath, Slinkpath);
                        return;
                } else {
                        fprintf(stderr,
                                "%s: Can't link %s to %s",
                                arg0, Slinkpath, Spath);
                        because();
                        /* Try to install instead. */
                }
        }
        switch (Sst.st_mode & S_IFMT) {
        case S_IFDIR:
                if (!force) {
                        printf("Add dir %s", Spath);
                        if (!ask('n')) return;
                }
                if (mkdir(Spath, backup ? 0755 : Sst.st_mode) < 0) {
                        perr(Spath);
                        return;
                }
                printf("Directory %s created.\n", Spath);
                order(ENTER);
                break;
        case S_IFBLK:
        case S_IFCHR:
        case S_IFIFO:
                if (interact && !update) {
                        printf("Create special file %s", Spath);
                        if (!ask('n')) { order(ORDER_CANCEL); return; }
                }
                if (makenode(Spath, Sst.st_mode, Sst.st_rdev, Sst.st_size)<0) {
                        fprintf(stderr,
                                "%s: Can't create special file %s",
                                arg0, Spath);
                        because();
                        return;
                }
                printf("Special file %s created\n", Spath);
                break;
#ifdef S_IFLNK
        case S_IFLNK:
                if (interact && !update) {
                        printf("Install %s -> %s", Spath, Slnkpth);
                        if (!ask('n')) { order(ORDER_CANCEL); return; }
                }
                if (symlink(Slnkpth, Spath) < 0) {
                        fprintf(stderr, "%s: Can't create symlink %s",
                                arg0, Spath);
                        because();
                        return;
                }
                printf("%s %s -> %s\n",
                        forced_update ? "Updated:  " : "Installed:",
                        Spath, Slnkpth);
                break;
#endif
        case S_IFREG:
                if (interact && !update) {
                        printf("Install %s", Spath);
                        if (!ask('n')) { order(ORDER_CANCEL); return; }
                }
                order(CAT);
                if (answer() != DATA) return;

                busy= 1;
                if ((f= creat(Spath, backup ? 0644 : Sst.st_mode&07777)) < 0) {
                        busy= 0;
                        fprintf(stderr, "%s: Can't create %s", arg0, Spath);
                        because();
                }

                while ((n= receive(buf, sizeof(buf)))>0) {
                        if (f >= 0 && write(f, buf, n) != n) {
                                fprintf(stderr, "%s: Write error on %s",
                                        arg0, Spath);
                                because();
                                close(f); f= -1;
                        }
                }
                if (n < 0) {
                        fprintf(stderr, "%s: Slave read err on %s\n",
                                arg0, Spath);
                }
                if (f >= 0) close(f);
                if (n < 0 || f < 0) { makeold(); busy= 0; return; }
                busy= 0;
                printf("%s %s\n",
                        forced_update ?
                                Sst.st_mtime < st.st_mtime ? "Restored: " :
                                        "Updated:  " :
                                "Installed:",
                        Spath
                );
                break;
        default:
                fprintf(stderr,
                        "%s: Won't add file with strange mode %05o: %s\n",
                        arg0, Sst.st_mode, Spath);
                order(ORDER_CANCEL);
                return;
        }
        setmodes(1);
}

static int delete(int update)
/* Delete path. */
{
        int forced_update= force && update;

        if (S_ISDIR(st.st_mode)) {
                if (install) return 0;
                if (!force) {
                        printf("Delete dir %s", path);
                        if (!ask('n')) return 0;
                }
                if (!removedir(path)) { ex= 1; return 0; }
                if (!forced_update) printf("Directory %s deleted.\n", path);
                return 1;
        }

        if (install && !update) return 0;

        if (!force) {
                printf("Delete %s", path);
                if (!ask((interact && !update) ? 'n' : 'y')) return 0;
        }

        if (unlink(path)<0) {
                fprintf(stderr, "Can't delete %s", path);
                because();
                return 0;
        }
        cancellink();
        if (!forced_update) printf("Deleted:   %s\n", path);
        return 1;
}

static int different()
/* Return true iff path and Spath are different. */
{
        if (! ( (linkpath == nil && Slinkpath == nil)
                || (linkpath != nil && Slinkpath != nil
                        && strcmp(linkpath, Slinkpath) == 0)
        )) {
                linkpath= Slinkpath;
                return 1;
        }

        if ((st.st_mode & S_IFMT) != (Sst.st_mode & S_IFMT)) return 1;

        switch (st.st_mode & S_IFMT) {
        case S_IFDIR:
                return 0;
        case S_IFBLK:
        case S_IFCHR:
                return st.st_rdev != Sst.st_rdev;
        case S_IFREG:
                if (install) return Sst.st_mtime > st.st_mtime;
                return st.st_size != Sst.st_size
                        || st.st_mtime != Sst.st_mtime;
        case S_IFIFO:   return 0;
#ifdef S_IFLNK
        case S_IFLNK:   return strcmp(lnkpth, Slnkpth) != 0;
#endif
        default:        return 1;
        }
}

static void compare()
/* See if path and Spath are same. */
{
        if (different()) {
                if (!force) {
                        printf("%sing %s (delete + add)\n",
                                Sst.st_mtime < st.st_mtime ? "Restor" : "Updat",
                                path);
                }
                if (delete(1)) add(1);
        } else {
                if (!install) setmodes(0);

                if (S_ISDIR(st.st_mode)) {
                        order(ENTER);
                        enter();
                }
        }
}

static int done= 0, Sdone= 0;

static enum action { ADD, COMPARE, DELETE } action()
/* Look at path's of master and slave, compare them alphabetically to see
 * who is ahead of who, then tell what is to be done.
 */
{
        int c;
        char *Sp, *p;

        if (done) return ADD;           /* Slave still has names. */
        if (Sdone) return DELETE;       /* Master has too many names. */

        /* Compare paths.  Let "a/a" come before "a.a". */
        Sp= Spath;
        p= path;
        while (*Sp == *p && *Sp != 0) { Sp++; p++; }
        if (*Sp == '/') return ADD;
        if (*p == '/') return DELETE;
        return (c= strcmp(Sp, p)) == 0 ? COMPARE : c < 0 ? ADD : DELETE;
}

static void master()
/* Synchronise file tree to that of its slave. */
{
        enum action a= COMPARE; /* Trick first advances. */

        umask(backup ? 0022 : 0000);

        signal(SIGPIPE, SIG_IGN);
        signal(SIGHUP, bail_out);
        signal(SIGINT, bail_out);
        signal(SIGTERM, bail_out);

        while (!done || !Sdone) {
                if (!Sdone && (a == ADD || a == COMPARE)) {
                        /* Slave advances. */
                        order(ADVANCE);
                        switch (answer()) {
                        case PATH:
                                Slinkpath= nil;
                                receive(Spath, sizeof(Spath));
                                recstat(&Sst);
                                break;
                        case LINK:
                                receive(Slnkpth, sizeof(Slnkpth));
                                Slinkpath= Slnkpth;
                                receive(Spath, sizeof(Spath));
                                recstat(&Sst);
                                break;
                        case SYMLINK:
                                Slinkpath= nil;
                                receive(Slnkpth, sizeof(Slnkpth));
                                receive(Spath, sizeof(Spath));
                                recstat(&Sst);
                                break;
                        case DONE:
                                Sdone= 1;
                                break;
                        default:
                                fprintf(stderr,
                                        "%s: Strange answer from slave.\n",
                                        arg0);
                                exit(1);
                        }
                }
                if (!done && (a == COMPARE || a == DELETE)) {
                        /* Master advances. */
                        if (!advance()) done= 1;
                }

                if (done && Sdone) break;

                switch (a= action()) {
                case ADD:       /* Spath exists, path doesn't, add? */
                        add(0);
                        break;
                case COMPARE:   /* They both exist, are they the same? */
                        compare();
                        break;
                case DELETE:    /* path exists, Spath doesn't, delete? */
                        delete(0);
                }
                fflush(stdout); /* Don't keep user in suspense. */
        }
        order(ex == 0 ? DIE : DIE_BAD);
}

static void mediator()
/* Sits at the local machine and passes orders from master to slave, both
 * on remote machines.  Only diagnostics and questions are handled.
 */
{
        enum orders req;

        for (;;) {
                switch (req= request()) {
                case DIE_BAD:
                        ex= 1;
                        /*FALL THROUGH*/
                case DIE:
                        order(DIE);
                        return;
                case POSITIVE:
                        order(ask('y') ? PASS_YES : PASS_NO);
                        break;
                case NEGATIVE:
                        order(ask('n') ? PASS_YES : PASS_NO);
                        break;
                default:
                        order(req);
                }
        }
}

#define P_EXIT          1       /* Make sure process doesn't return. */
#define P_SHADOW        2       /* Always use exec on 68000. */

static void startprocess(void (*proc)(), char *machine, char *path,
        int p_flags)
{
        char *argv[10], **argp= argv;
        char flags[10], *pfl= flags;

        if (machine != nil) {
                char *u= machine, *m;

                *argp++ = "rsh";
                if ((m= strchr(machine, '@')) != nil) {
                        *m++ = 0;
                        *argp++ = "-l";
                        *argp++ = u;
                        machine= m;
                }
                *argp++ = machine;
        } else
        /* Without this check it would run like a pig on an non MMU 68000: */
        if (!(USE_SHADOWING && p_flags & P_SHADOW)) {
                if (chdir(path) < 0) {
                        if (proc != master || errno != ENOENT
                                                || mkdir(path, 0700) < 0)
                                perrx(path);
                        if (chdir(path) < 0) perrx(path);
                        printf("Destination directory %s created\n", path);
                }
                isvisible(path);
                isbackup(proc == slave);
                (*proc)();
                if (p_flags & P_EXIT) exit(ex);
                return;
        }
        *argp++ = SYNCNAME;
        *pfl++ = '-';
        if (interact) *pfl++ = 'i';
        if (install) *pfl++ = 'u';
        if (force) *pfl++ = 'f';
        *pfl= 0;
        *argp++ = flags;
        *argp++ = proc == slave ? SLAVENAME : MASTERNAME;
        *argp++ = path;
        *argp++ = nil;
#ifdef DEBUG
        fprintf(stderr, "execlp(");
        for (argp= argv; *argp != nil; argp++) fprintf(stderr, "%s, ", *argp);
        fprintf(stderr, "nil);\n");
#endif
        execvp(argv[0], argv);
        perrx(argv[0]);
}

void splitcolon(char *path, char **amach, char **adir)
{
        char *dir= path;

        for (;;) {
                if (*dir == ':') {
                        *dir++ = 0;
                        *amach= path;
                        *adir= dir;
                        break;
                }
                if (*dir == 0 || *dir == '/') {
                        *amach= nil;
                        *adir= path;
                        break;
                }
                dir++;
        }
}

static void Usage()
{
        fprintf(stderr,
            "Usage: %s [-iuf] [[user@]machine:]dir1 [[user@]machine:]dir2\n",
                arg0);
        exit(1);
}

int main(int argc, char **argv)
{
        char *s_mach, *s_dir;
        char *m_mach, *m_dir;
        int m2s[2], s2m[2], m2m[2];
        int s_pid= 0, m_pid= 0;
        int r;

        if ((arg0= strrchr(argv[0], '/')) == nil) arg0= argv[0]; else arg0++;

        while (argc>1 && argv[1][0] == '-') {
                char *f= argv[1]+1;

                while (*f != 0) {
                        switch (*f++) {
                        case 'i':       interact= 1; break;
                        case 'u':       install= 1; break;
                        case 'f':       force= 1; break;
                        default:        Usage();
                        }
                }
                argc--;
                argv++;
        }

        if (argc != 3) Usage();

        if (strcmp(argv[1], SLAVENAME) == 0) {
                arg0= "Slave";
                splitcolon(argv[2], &s_mach, &s_dir);
                startprocess(slave, s_mach, s_dir, P_EXIT);
        } else
        if (strcmp(argv[1], MASTERNAME) == 0) {
                arg0= "Master";
                splitcolon(argv[2], &m_mach, &m_dir);
                startprocess(master, m_mach, m_dir, P_EXIT);
        }

        splitcolon(argv[1], &s_mach, &s_dir);
        splitcolon(argv[2], &m_mach, &m_dir);

        /* How difficult can plumbing be? */
        if (pipe(m2s) < 0 || pipe(s2m) < 0) perrx("pipe()");

        if (m_mach == nil) {
                /* synctree [machine:]dir1 dir2 */
                switch (s_pid= fork()) {
                case -1:
                        perrx("fork()");
                case 0:
                        dup2(m2s[0], 0); close(m2s[0]); close(m2s[1]);
                        dup2(s2m[1], 1); close(s2m[0]); close(s2m[1]);
                        arg0= "Slave";
                        startprocess(slave, s_mach, s_dir, P_EXIT|P_SHADOW);
                }
                chan[0]= s2m[0]; close(s2m[1]);
                chan[1]= m2s[1]; close(m2s[0]);
                startprocess(master, m_mach, m_dir, 0);
        } else
        if (s_mach == nil) {
                /* synctree dir1 machine:dir2 */
                switch (m_pid= fork()) {
                case -1:
                        perrx("fork()");
                case 0:
                        dup2(s2m[0], 0); close(s2m[0]); close(s2m[1]);
                        dup2(m2s[1], 1); close(m2s[0]); close(m2s[1]);
                        arg0= "Master";
                        startprocess(master, m_mach, m_dir, P_EXIT|P_SHADOW);
                }
                chan[0]= m2s[0]; close(m2s[1]);
                chan[1]= s2m[1]; close(s2m[0]);
                startprocess(slave, s_mach, s_dir, 0);
        } else {
                /* synctree machine1:dir1 machine2:dir2 */
                if (pipe(m2m) < 0) perrx("pipe");

                switch (s_pid= fork()) {
                case -1:
                        perrx("fork()");
                case 0:
                        dup2(m2s[0], 0); close(m2s[0]); close(m2s[1]);
                        dup2(s2m[1], 1); close(s2m[0]); close(s2m[1]);
                        close(m2m[0]); close(m2m[1]);
                        arg0= "Slave";
                        startprocess(slave, s_mach, s_dir, P_EXIT|P_SHADOW);
                }

                switch (m_pid= fork()) {
                case -1:
                        perrx("fork()");
                case 0:
                        dup2(s2m[0], 0); close(s2m[0]); close(s2m[1]);
                        close(m2s[0]); close(m2s[1]);
                        dup2(m2m[1], 1); close(m2m[0]); close(m2m[1]);
                        arg0= "Master";
                        startprocess(master, m_mach, m_dir, P_EXIT|P_SHADOW);
                }
                close(s2m[0]); close(s2m[1]);
                chan[0]= m2m[0]; close(m2m[1]);
                chan[1]= m2s[1]; close(m2s[0]);
                mediator();
        }
        close(chan[0]);
        close(chan[1]);

        alarm(15); /* Don't wait(2) forever. */

        while (s_pid != 0 || m_pid != 0) {
                if ((r= wait((int *) nil)) < 0) perrx("wait()");
                if (r == s_pid) s_pid= 0;
                if (r == m_pid) m_pid= 0;
        }
        exit(ex);
}