unstack, sort: cleanup and improvement

[minix.git] / commands / cp / cp.c

/*      cp 1.12 - copy files                            Author: Kees J. Bot
 *      mv      - move files                                    20 Jul 1993
 *      rm      - remove files
 *      ln      - make a link
 *      cpdir   - copy a directory tree (cp -psmr)
 *      clone   - make a link farm (ln -fmr)
 */
#define nil 0
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
#include <sys/stat.h>
#include <utime.h>
#include <dirent.h>
#include <errno.h>
#ifndef DEBUG
#define DEBUG   0
#define NDEBUG  1
#endif
#include <assert.h>

/* Copy files in this size chunks: */
#if __minix && !__minix_vmd
#define CHUNK   (8192 * sizeof(char *))
#else
#define CHUNK   (1024 << (sizeof(int) + sizeof(char *)))
#endif


#ifndef CONFORMING
#define CONFORMING      1       /* Precisely POSIX conforming. */
#endif


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

char *prog_name;                /* Call name of this program. */
int ex_code= 0;                 /* Final exit code. */

typedef enum identity { CP, MV, RM, LN, CPDIR, CLONE } identity_t;
typedef enum action { COPY, MOVE, REMOVE, LINK } action_t;

identity_t identity;            /* How did the user call me? */
action_t action;                /* Copying, moving, or linking. */
int pflag= 0;                   /* -p/-s: Make orginal and copy the same. */
int iflag= 0;                   /* -i: Interactive overwriting/deleting. */
int fflag= 0;                   /* -f: Force. */
int sflag= 0;                   /* -s: Make a symbolic link (ln/clone). */
int Sflag= 0;                   /* -S: Make a symlink if across devices. */
int mflag= 0;                   /* -m: Merge trees, no target dir trickery. */
int rflag= 0;                   /* -r/-R: Recursively copy a tree. */
int vflag= 0;                   /* -v: Verbose. */
int xflag= 0;                   /* -x: Don't traverse past mount points. */
int xdev= 0;                    /* Set when moving or linking cross-device. */
int expand= 0;                  /* Expand symlinks, ignore links. */
int conforming= CONFORMING;     /* Sometimes standards are a pain. */

int fc_mask;                    /* File creation mask. */
int uid, gid;                   /* Effective uid & gid. */
int istty;                      /* Can have terminal input. */

#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

void report(const char *label)
{
    if (action == REMOVE && fflag) return;
    fprintf(stderr, "%s: %s: %s\n", prog_name, label, strerror(errno));
    ex_code= 1;
}

void fatal(const char *label)
{
    report(label);
    exit(1);
}

void report2(const char *src, const char *dst)
{
    fprintf(stderr, "%s %s %s: %s\n", prog_name, src, dst, strerror(errno));
    ex_code= 1;
}

#if DEBUG
size_t nchunks= 0;      /* Number of allocated cells. */
#endif

void *allocate(void *mem, size_t size)
/* Like realloc, but with checking of the return value. */
{
#if DEBUG
    if (mem == nil) nchunks++;
#endif
    if ((mem= mem == nil ? malloc(size) : realloc(mem, size)) == nil)
        fatal("malloc()");
    return mem;
}

void deallocate(void *mem)
/* Release a chunk of memory. */
{
    if (mem != nil) {
#if DEBUG
        nchunks--;
#endif
        free(mem);
    }
}

typedef struct pathname {
    char                *path;  /* The actual pathname. */
    size_t              idx;    /* Index for the terminating null byte. */
    size_t              lim;    /* Actual length of the path array. */
} pathname_t;

void path_init(pathname_t *pp)
/* Initialize a pathname to the null string. */
{
    pp->path= allocate(nil, pp->lim= NAME_MAX + 2);
    pp->path[pp->idx= 0]= 0;
}

void path_add(pathname_t *pp, const char *name)
/* Add a component to a pathname. */
{
    size_t lim;
    char *p;

    lim= pp->idx + strlen(name) + 2;

    if (lim > pp->lim) {
        pp->lim= lim += lim/2;  /* add an extra 50% growing space. */

        pp->path= allocate(pp->path, lim);
    }

    p= pp->path + pp->idx;
    if (p > pp->path && p[-1] != '/') *p++ = '/';

    while (*name != 0) {
        if (*name != '/' || p == pp->path || p[-1] != '/') *p++ = *name;
        name++;
    }
    *p = 0;
    pp->idx= p - pp->path;
}

void path_trunc(pathname_t *pp, size_t didx)
/* Delete part of a pathname to a remembered length. */
{
    pp->path[pp->idx= didx]= 0;
}

#if DEBUG
const char *path_name(const pathname_t *pp)
/* Return the actual name as a C string. */
{
    return pp->path;
}

size_t path_length(const pathname_t *pp)
/* The length of the pathname. */
{
    return pp->idx;
}

void path_drop(pathname_t *pp)
/* Release the storage occupied by the pathname. */
{
    deallocate(pp->path);
}

#else /* !DEBUG */
#define path_name(pp)           ((const char *) (pp)->path)
#define path_length(pp)         ((pp)->idx)
#define path_drop(pp)           deallocate((void *) (pp)->path)
#endif /* !DEBUG */

char *basename(const char *path)
/* Return the last component of a pathname.  (Note: declassifies a const
 * char * just like strchr.
 */
{
    const char *p= path;

    for (;;) {
        while (*p == '/') p++;                  /* Trailing slashes? */

        if (*p == 0) break;

        path= p;
        while (*p != 0 && *p != '/') p++;       /* Skip component. */
    }
    return (char *) path;
}

int affirmative(void)
/* Get a yes/no answer from the suspecting user. */
{
    int c;
    int ok;

    fflush(stdout);
    fflush(stderr);

    while ((c= getchar()) == ' ') {}
    ok= (c == 'y' || c == 'Y');
    while (c != EOF && c != '\n') c= getchar();

    return ok;
}

int writable(const struct stat *stp)
/* True iff the file with the given attributes allows writing.  (And we have
 * a terminal to ask if ok to overwrite.)
 */
{
    if (!istty || uid == 0) return 1;
    if (stp->st_uid == uid) return stp->st_mode & S_IWUSR;
    if (stp->st_gid == gid) return stp->st_mode & S_IWGRP;
    return stp->st_mode & S_IWOTH;
}

#ifndef PATH_MAX
#define PATH_MAX        1024
#endif

static char *link_islink(const 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;
}

int trylink(const char *src, const char *dst, const struct stat *srcst,
                        const struct stat *dstst)
/* Keep the link structure intact if src has been seen before. */
{
    char *olddst;
    int linked;

    if (action == COPY && expand) return 0;

    if ((olddst= link_islink(srcst, dst)) == nil) {
        /* if (errno != ENOENT) ... */
        return 0;
    }

    /* Try to link the file copied earlier to the new file. */
    if (dstst->st_ino != 0) (void) unlink(dst);

    if ((linked= (link(olddst, dst) == 0)) && vflag)
        printf("ln %s ..\n", olddst);

    return linked;
}

int copy(const char *src, const char *dst, struct stat *srcst,
                        struct stat *dstst)
/* Copy one file to another and copy (some of) the attributes. */
{
    char buf[CHUNK];
    int srcfd, dstfd;
    ssize_t n;

    assert(srcst->st_ino != 0);

    if (dstst->st_ino == 0) {
        /* The file doesn't exist yet. */

        if (!S_ISREG(srcst->st_mode)) {
            /* Making a new mode 666 regular file. */
            srcst->st_mode= (S_IFREG | 0666) & fc_mask;
        } else
        if (!pflag && conforming) {
            /* Making a new file copying mode with umask applied. */
            srcst->st_mode &= fc_mask;
        }
    } else {
        /* File exists, ask if ok to overwrite if '-i'. */

        if (iflag || (action == MOVE && !fflag && !writable(dstst))) {
            fprintf(stderr, "Overwrite %s? (mode = %03o) ",
                        dst, dstst->st_mode & 07777);
            if (!affirmative()) return 0;
        }

        if (action == MOVE) {
            /* Don't overwrite, remove first. */
            if (unlink(dst) < 0 && errno != ENOENT) {
                report(dst);
                return 0;
            }
        } else {
            /* Overwrite. */
            if (!pflag) {
                /* Keep the existing mode and ownership. */
                srcst->st_mode= dstst->st_mode;
                srcst->st_uid= dstst->st_uid;
                srcst->st_gid= dstst->st_gid;
            }
        }
    }

    /* Keep the link structure if possible. */
    if (trylink(src, dst, srcst, dstst)) return 1;

    if ((srcfd= open(src, O_RDONLY)) < 0) {
        report(src);
        return 0;
    }

    dstfd= open(dst, O_WRONLY|O_CREAT|O_TRUNC, srcst->st_mode & 0777);
    if (dstfd < 0 && fflag && errno == EACCES) {
        /* Retry adding a "w" bit. */
        (void) chmod(dst, dstst->st_mode | S_IWUSR);
        dstfd= open(dst, O_WRONLY|O_CREAT|O_TRUNC, 0);
    }
    if (dstfd < 0 && fflag && errno == EACCES) {
        /* Retry after trying to delete. */
        (void) unlink(dst);
        dstfd= open(dst, O_WRONLY|O_CREAT|O_TRUNC, 0);
    }
    if (dstfd < 0) {
        report(dst);
        close(srcfd);
        return 0;
    }

    /* Get current parameters. */
    if (fstat(dstfd, dstst) < 0) {
        report(dst);
        close(srcfd);
        close(dstfd);
        return 0;
    }

    /* Copy the little bytes themselves. */
    while ((n= read(srcfd, buf, sizeof(buf))) > 0) {
        char *bp = buf;
        ssize_t r;

        while (n > 0 && (r= write(dstfd, bp, n)) > 0) {
            bp += r;
            n -= r;
        }
        if (r <= 0) {
            if (r == 0) {
                fprintf(stderr,
                    "%s: Warning: EOF writing to %s\n",
                    prog_name, dst);
                break;
            }
            fatal(dst);
        }
    }

    if (n < 0) {
        report(src);
        close(srcfd);
        close(dstfd);
        return 0;
    }

    close(srcfd);
    close(dstfd);

    /* Copy the ownership. */
    if ((pflag || !conforming)
        && S_ISREG(dstst->st_mode)
        && (dstst->st_uid != srcst->st_uid
                || dstst->st_gid != srcst->st_gid)
    ) {
        if (chmod(dst, 0) == 0) dstst->st_mode&= ~07777;
        if (chown(dst, srcst->st_uid, srcst->st_gid) < 0) {
            if (errno != EPERM) {
                report(dst);
                return 0;
            }
        } else {
            dstst->st_uid= srcst->st_uid;
            dstst->st_gid= srcst->st_gid;
        }
    }

    if (conforming && S_ISREG(dstst->st_mode)
        && (dstst->st_uid != srcst->st_uid
                || dstst->st_gid != srcst->st_gid)
    ) {
        /* Suid bits must be cleared in the holy name of
         * security (and the assumed user stupidity).
         */
        srcst->st_mode&= ~06000;
    }

    /* Copy the mode. */
    if (S_ISREG(dstst->st_mode) && dstst->st_mode != srcst->st_mode) {
        if (chmod(dst, srcst->st_mode) < 0) {
            if (errno != EPERM) {
                report(dst);
                return 0;
            }
            fprintf(stderr, "%s: Can't change the mode of %s\n",
                prog_name, dst);
        }
    }

    /* Copy the file modification time. */
    if ((pflag || !conforming) && S_ISREG(dstst->st_mode)) {
        struct utimbuf ut;

        ut.actime= action == MOVE ? srcst->st_atime : time(nil);
        ut.modtime= srcst->st_mtime;
        if (utime(dst, &ut) < 0) {
            if (errno != EPERM) {
                report(dst);
                return 0;
            }
            if (pflag) {
                fprintf(stderr,
                    "%s: Can't set the time of %s\n",
                    prog_name, dst);
            }
        }
    }
    if (vflag) {
        printf(action == COPY ? "cp %s ..\n" : "mv %s ..\n", src);
    }
    return 1;
}

void copy1(const char *src, const char *dst, struct stat *srcst,
                            struct stat *dstst)
/* Inspect the source file and then copy it.  Treatment of symlinks and
 * special files is a bit complicated.  The filetype and link-structure are
 * ignored if (expand && !rflag), symlinks and link-structure are ignored
 * if (expand && rflag), everything is copied precisely if !expand.
 */
{
    int r, linked;

    assert(srcst->st_ino != 0);

    if (srcst->st_ino == dstst->st_ino && srcst->st_dev == dstst->st_dev) {
        fprintf(stderr, "%s: can't copy %s onto itself\n",
            prog_name, src);
        ex_code= 1;
        return;
    }

    /* You can forget it if the destination is a directory. */
    if (dstst->st_ino != 0 && S_ISDIR(dstst->st_mode)) {
        errno= EISDIR;
        report(dst);
        return;
    }

    if (S_ISREG(srcst->st_mode) || (expand && !rflag)) {
        if (!copy(src, dst, srcst, dstst)) return;

        if (action == MOVE && unlink(src) < 0) {
            report(src);
            return;
        }
        return;
    }

    if (dstst->st_ino != 0) {
        if (iflag || (action == MOVE && !fflag && !writable(dstst))) {
            fprintf(stderr, "Replace %s? (mode = %03o) ",
                dst, dstst->st_mode & 07777);
            if (!affirmative()) return;
        }
        if (unlink(dst) < 0) {
            report(dst);
            return;
        }
        dstst->st_ino= 0;
    }

    /* Apply the file creation mask if so required. */
    if (!pflag && conforming) srcst->st_mode &= fc_mask;

    linked= 0;

    if (S_ISLNK(srcst->st_mode)) {
        char buf[1024+1];

        if ((r= readlink(src, buf, sizeof(buf)-1)) < 0) {
            report(src);
            return;
        }
        buf[r]= 0;
        r= symlink(buf, dst);
        if (vflag && r == 0)
            printf("ln -s %s %s\n", buf, dst);
    } else
    if (trylink(src, dst, srcst, dstst)) {
        linked= 1;
        r= 0;
    } else
    if (S_ISFIFO(srcst->st_mode)) {
        r= mkfifo(dst, srcst->st_mode);
        if (vflag && r == 0)
            printf("mkfifo %s\n", dst);
    } else
    if (S_ISBLK(srcst->st_mode) || S_ISCHR(srcst->st_mode)) {
        r= mknod(dst, srcst->st_mode, srcst->st_rdev);
        if (vflag && r == 0) {
            printf("mknod %s %c %d %d\n",
                dst,
                S_ISBLK(srcst->st_mode) ? 'b' : 'c',
                (srcst->st_rdev >> 8) & 0xFF,
                (srcst->st_rdev >> 0) & 0xFF);
        }
    } else {
        fprintf(stderr, "%s: %s: odd filetype %5o (not copied)\n",
            prog_name, src, srcst->st_mode);
        ex_code= 1;
        return;
    }

    if (r < 0 || lstat(dst, dstst) < 0) {
        report(dst);
        return;
    }

    if (action == MOVE && unlink(src) < 0) {
        report(src);
        (void) unlink(dst);     /* Don't want it twice. */
        return;
    }

    if (linked) return;

    if (S_ISLNK(srcst->st_mode)) return;

    /* Copy the ownership. */
    if ((pflag || !conforming)
        && (dstst->st_uid != srcst->st_uid
                || dstst->st_gid != srcst->st_gid)
    ) {
        if (chown(dst, srcst->st_uid, srcst->st_gid) < 0) {
            if (errno != EPERM) {
                report(dst);
                return;
            }
        }
    }

    /* Copy the file modification time. */
    if (pflag || !conforming) {
        struct utimbuf ut;

        ut.actime= action == MOVE ? srcst->st_atime : time(nil);
        ut.modtime= srcst->st_mtime;
        if (utime(dst, &ut) < 0) {
            if (errno != EPERM) {
                report(dst);
                return;
            }
            fprintf(stderr, "%s: Can't set the time of %s\n",
                prog_name, dst);
        }
    }
}

void remove1(const char *src, const struct stat *srcst)
{
    if (iflag || (!fflag && !writable(srcst))) {
        fprintf(stderr, "Remove %s? (mode = %03o) ", src,
                        srcst->st_mode & 07777);
        if (!affirmative()) return;
    }
    if (unlink(src) < 0) {
        report(src);
    } else {
        if (vflag) printf("rm %s\n", src);
    }
}

void link1(const char *src, const char *dst, const struct stat *srcst,
                            const struct stat *dstst)
{
    pathname_t sym;
    const char *p;

    if (dstst->st_ino != 0 && (iflag || fflag)) {
        if (srcst->st_ino == dstst->st_ino) {
            if (fflag) return;
            fprintf(stderr, "%s: Can't link %s onto itself\n",
                prog_name, src);
            ex_code= 1;
            return;
        }
        if (iflag) {
            fprintf(stderr, "Remove %s? ", dst);
            if (!affirmative()) return;
        }
        errno= EISDIR;
        if (S_ISDIR(dstst->st_mode) || unlink(dst) < 0) {
            report(dst);
            return;
        }
    }

    if (!sflag && !(rflag && S_ISLNK(srcst->st_mode)) && !(Sflag && xdev)) {
        /* A normal link. */
        if (link(src, dst) < 0) {
            if (!Sflag || errno != EXDEV) {
                report2(src, dst);
                return;
            }
            /* Can't do a cross-device link, we have to symlink. */
            xdev= 1;
        } else {
            if (vflag) printf("ln %s..\n", src);
            return;
        }
    }

    /* Do a symlink. */
    if (!rflag && !Sflag) {
        /* We can get away with a "don't care if it works" symlink. */
        if (symlink(src, dst) < 0) {
            report(dst);
            return;
        }
        if (vflag) printf("ln -s %s %s\n", src, dst);
        return;
    }

    /* If the source is a symlink then it is simply copied. */
    if (S_ISLNK(srcst->st_mode)) {
        int r;
        char buf[1024+1];

        if ((r= readlink(src, buf, sizeof(buf)-1)) < 0) {
            report(src);
            return;
        }
        buf[r]= 0;
        if (symlink(buf, dst) < 0) {
            report(dst);
            return;
        }
        if (vflag) printf("ln -s %s %s\n", buf, dst);
        return;
    }

    /* Make a symlink that has to work, i.e. we must be able to access the
     * source now, and the link must work.
     */
    if (dst[0] == '/' && src[0] != '/') {
        /* ln -[rsS] relative/path /full/path. */
        fprintf(stderr,
            "%s: Symlinking %s to %s is too difficult for me to figure out\n",
            prog_name, src, dst);
        exit(1);
    }

    /* Count the number of subdirectories in the destination file and
     * add one '..' for each.
     */
    path_init(&sym);
    if (src[0] != '/') {
        p= dst;
        while (*p != 0) {
            if (p[0] == '.') {
                if (p[1] == '/' || p[1] == 0) {
                    /* A "." component; skip. */
                    do p++; while (*p == '/');
                    continue;
                } else
                if (p[1] == '.' && (p[2] == '/' || p[2] == 0)) {
                    /* A ".." component; oops. */
                    switch (path_length(&sym)) {
                    case 0:
                        fprintf(stderr,
            "%s: Symlinking %s to %s is too difficult for me to figure out\n",
                            prog_name, src, dst);
                        exit(1);
                    case 2:
                        path_trunc(&sym, 0);
                        break;
                    default:
                        path_trunc(&sym, path_length(&sym) - 3);
                    }
                    p++;
                    do p++; while (*p == '/');
                    continue;
                }
            }
            while (*p != 0 && *p != '/') p++;
            while (*p == '/') p++;
            if (*p == 0) break;
            path_add(&sym, "..");
        }
    }
    path_add(&sym, src);

    if (symlink(path_name(&sym), dst) < 0) {
        report(dst);
    } else {
        if (vflag) printf("ln -s %s %s\n", path_name(&sym), dst);
    }
    path_drop(&sym);
}

typedef struct entrylist {
    struct entrylist    *next;
    char                        *name;
} entrylist_t;

int eat_dir(const char *dir, entrylist_t **dlist)
/* Make a linked list of all the names in a directory. */
{
    DIR *dp;
    struct dirent *entry;

    if ((dp= opendir(dir)) == nil) return 0;

    while ((entry= readdir(dp)) != nil) {
        if (strcmp(entry->d_name, ".") == 0) continue;
        if (strcmp(entry->d_name, "..") == 0) continue;

        *dlist= allocate(nil, sizeof(**dlist));
        (*dlist)->name= allocate(nil, strlen(entry->d_name)+1);
        strcpy((*dlist)->name, entry->d_name);
        dlist= &(*dlist)->next;
    }
    closedir(dp);
    *dlist= nil;
    return 1;
}

void chop_dlist(entrylist_t **dlist)
/* Chop an entry of a name list. */
{
    entrylist_t *junk= *dlist;

    *dlist= junk->next;
    deallocate(junk->name);
    deallocate(junk);
}

void drop_dlist(entrylist_t *dlist)
/* Get rid of a whole list. */
{
    while (dlist != nil) chop_dlist(&dlist);
}

void do1(pathname_t *src, pathname_t *dst, int depth)
/* Perform the appropriate action on a source and destination file. */
{
    size_t slashsrc, slashdst;
    struct stat srcst, dstst;
    entrylist_t *dlist;
    static ino_t topdst_ino;
    static dev_t topdst_dev;
    static dev_t topsrc_dev;

#if DEBUG
    if (vflag && depth == 0) {
        char flags[100], *pf= flags;

        if (pflag) *pf++= 'p';
        if (iflag) *pf++= 'i';
        if (fflag) *pf++= 'f';
        if (sflag) *pf++= 's';
        if (Sflag) *pf++= 'S';
        if (mflag) *pf++= 'm';
        if (rflag) *pf++= 'r';
        if (vflag) *pf++= 'v';
        if (xflag) *pf++= 'x';
        if (expand) *pf++= 'L';
        if (conforming) *pf++= 'C';
        *pf= 0;
        printf(": %s -%s %s %s\n", prog_name, flags,
                    path_name(src), path_name(dst));
    }
#endif

    /* st_ino == 0 if not stat()'ed yet, or nonexistent. */
    srcst.st_ino= 0;
    dstst.st_ino= 0;

    if (action != LINK || !sflag || rflag) {
        /* Source must exist unless symlinking. */
        if ((expand ? stat : lstat)(path_name(src), &srcst) < 0) {
            report(path_name(src));
            return;
        }
    }

    if (depth == 0) {
        /* First call: Not cross-device yet, first dst not seen yet,
         * remember top device number.
         */
        xdev= 0;
        topdst_ino= 0;
        topsrc_dev= srcst.st_dev;
    }

    /* Inspect the intended destination unless removing. */
    if (action != REMOVE) {
        if ((expand ? stat : lstat)(path_name(dst), &dstst) < 0) {
            if (errno != ENOENT) {
                report(path_name(dst));
                return;
            }
        }
    }

    if (action == MOVE && !xdev) {
        if (dstst.st_ino != 0 && srcst.st_dev != dstst.st_dev) {
            /* It's a cross-device rename, i.e. copy and remove. */
            xdev= 1;
        } else
        if (!mflag || dstst.st_ino == 0 || !S_ISDIR(dstst.st_mode)) {
            /* Try to simply rename the file (not merging trees). */

            if (srcst.st_ino == dstst.st_ino) {
                fprintf(stderr,
                    "%s: Can't move %s onto itself\n",
                    prog_name, path_name(src));
                ex_code= 1;
                return;
            }

            if (dstst.st_ino != 0) {
                if (iflag || (!fflag && !writable(&dstst))) {
                    fprintf(stderr,
                        "Replace %s? (mode = %03o) ",
                        path_name(dst),
                        dstst.st_mode & 07777);
                    if (!affirmative()) return;
                }
                if (!S_ISDIR(dstst.st_mode))
                    (void) unlink(path_name(dst));
            }

            if (rename(path_name(src), path_name(dst)) == 0) {
                /* Success. */
                if (vflag) {
                    printf("mv %s %s\n", path_name(src),
                            path_name(dst));
                }
                return;
            }
            if (errno == EXDEV) {
                xdev= 1;
            } else {
                report2(path_name(src), path_name(dst));
                return;
            }
        }
    }

    if (srcst.st_ino == 0 || !S_ISDIR(srcst.st_mode)) {
        /* Copy/move/remove/link a single file. */
        switch (action) {
        case COPY:
        case MOVE:
            copy1(path_name(src), path_name(dst), &srcst, &dstst);
            break;
        case REMOVE:
            remove1(path_name(src), &srcst);
            break;
        case LINK:
            link1(path_name(src), path_name(dst), &srcst, &dstst);
            break;
        }
        return;
    }

    /* Recursively copy/move/remove/link a directory if -r or -R. */
    if (!rflag) {
        errno= EISDIR;
        report(path_name(src));
        return;
    }

    /* Ok to remove contents of dir? */
    if (action == REMOVE) {
        if (xflag && topsrc_dev != srcst.st_dev) {
            /* Don't recurse past a mount point. */
            return;
        }
        if (iflag) {
            fprintf(stderr, "Remove contents of %s? ", path_name(src));
            if (!affirmative()) return;
        }
    }

    /* Gather the names in the source directory. */
    if (!eat_dir(path_name(src), &dlist)) {
        report(path_name(src));
        return;
    }

    /* Check/create the target directory. */
    if (action != REMOVE && dstst.st_ino != 0 && !S_ISDIR(dstst.st_mode)) {
        if (action != MOVE && !fflag) {
            errno= ENOTDIR;
            report(path_name(dst));
            return;
        }
        if (iflag) {
            fprintf(stderr, "Replace %s? ", path_name(dst));
            if (!affirmative()) {
                drop_dlist(dlist);
                return;
            }
        }
        if (unlink(path_name(dst)) < 0) {
            report(path_name(dst));
            drop_dlist(dlist);
            return;
        }
        dstst.st_ino= 0;
    }

    if (action != REMOVE) {
        if (dstst.st_ino == 0) {
            /* Create a new target directory. */
            if (!pflag && conforming) srcst.st_mode&= fc_mask;

            if (mkdir(path_name(dst), srcst.st_mode | S_IRWXU) < 0
                    || stat(path_name(dst), &dstst) < 0) {
                report(path_name(dst));
                drop_dlist(dlist);
                return;
            }
            if (vflag) printf("mkdir %s\n", path_name(dst));
        } else {
            /* Target directory already exists. */
            if (action == MOVE && !mflag) {
                errno= EEXIST;
                report(path_name(dst));
                drop_dlist(dlist);
                return;
            }
            if (!pflag) {
                /* Keep the existing attributes. */
                srcst.st_mode= dstst.st_mode;
                srcst.st_uid= dstst.st_uid;
                srcst.st_gid= dstst.st_gid;
                srcst.st_mtime= dstst.st_mtime;
            }
        }

        if (topdst_ino == 0) {
            /* Remember the top destination. */
            topdst_dev= dstst.st_dev;
            topdst_ino= dstst.st_ino;
        }

        if (srcst.st_ino == topdst_ino && srcst.st_dev == topdst_dev) {
            /* E.g. cp -r /shallow /shallow/deep. */
            fprintf(stderr,
                "%s%s %s/ %s/: infinite recursion avoided\n",
                prog_name, action != MOVE ? " -r" : "",
                path_name(src), path_name(dst));
            drop_dlist(dlist);
            return;
        }

        if (xflag && topsrc_dev != srcst.st_dev) {
            /* Don't recurse past a mount point. */
            drop_dlist(dlist);
            return;
        }
    }

    /* Go down. */
    slashsrc= path_length(src);
    slashdst= path_length(dst);

    while (dlist != nil) {
        path_add(src, dlist->name);
        if (action != REMOVE) path_add(dst, dlist->name);

        do1(src, dst, depth+1);

        path_trunc(src, slashsrc);
        path_trunc(dst, slashdst);
        chop_dlist(&dlist);
    }

    if (action == MOVE || action == REMOVE) {
        /* The contents of the source directory should have
         * been (re)moved above.  Get rid of the empty dir.
         */
        if (action == REMOVE && iflag) {
            fprintf(stderr, "Remove directory %s? ",
                            path_name(src));
            if (!affirmative()) return;
        }
        if (rmdir(path_name(src)) < 0) {
            if (errno != ENOTEMPTY) report(path_name(src));
            return;
        }
        if (vflag) printf("rmdir %s\n", path_name(src));
    }

    if (action != REMOVE) {
        /* Set the attributes of a new directory. */
        struct utimbuf ut;

        /* Copy the ownership. */
        if ((pflag || !conforming)
            && (dstst.st_uid != srcst.st_uid
                || dstst.st_gid != srcst.st_gid)
        ) {
            if (chown(path_name(dst), srcst.st_uid,
                            srcst.st_gid) < 0) {
                if (errno != EPERM) {
                    report(path_name(dst));
                    return;
                }
            }
        }

        /* Copy the mode. */
        if (dstst.st_mode != srcst.st_mode) {
            if (chmod(path_name(dst), srcst.st_mode) < 0) {
                report(path_name(dst));
                return;
            }
        }

        /* Copy the file modification time. */
        if (dstst.st_mtime != srcst.st_mtime) {
            ut.actime= action == MOVE ? srcst.st_atime : time(nil);
            ut.modtime= srcst.st_mtime;
            if (utime(path_name(dst), &ut) < 0) {
                if (errno != EPERM) {
                    report(path_name(dst));
                    return;
                }
                fprintf(stderr,
                    "%s: Can't set the time of %s\n",
                    prog_name, path_name(dst));
            }
        }
    }
}

void usage(void)
{
    char *flags1, *flags2;

    switch (identity) {
    case CP:
        flags1= "pifsmrRvx";
        flags2= "pifsrRvx";
        break;
    case MV:
        flags1= "ifsmvx";
        flags2= "ifsvx";
        break;
    case RM:
        fprintf(stderr, "Usage: rm [-ifrRvx] file ...\n");
        exit(1);
    case LN:
        flags1= "ifsSmrRvx";
        flags2= "ifsSrRvx";
        break;
    case CPDIR:
        flags1= "ifvx";
        flags2= nil;
        break;
    case CLONE:
        flags1= "ifsSvx";
        flags2= nil;
        break;
    }
    fprintf(stderr, "Usage: %s [-%s] file1 file2\n", prog_name, flags1);
  if (flags2 != nil)
    fprintf(stderr, "       %s [-%s] file ... dir\n", prog_name, flags2);
    exit(1);
}

int main(int argc, char **argv)
{
    int i;
    char *flags;
    struct stat st;
    pathname_t src, dst;
    size_t slash;

#if DEBUG >= 3
    /* The first argument is the call name while debugging. */
    if (argc < 2) exit(-1);
    argv++;
    argc--;
#endif
#if DEBUG
    vflag= isatty(1);
#endif

    /* Call name of this program. */
    prog_name= basename(argv[0]);

    /* Required action. */
    if (strcmp(prog_name, "cp") == 0) {
        identity= CP;
        action= COPY;
        flags= "pifsmrRvx";
        expand= 1;
    } else
    if (strcmp(prog_name, "mv") == 0) {
        identity= MV;
        action= MOVE;
        flags= "ifsmvx";
        rflag= pflag= 1;
    } else
    if (strcmp(prog_name, "rm") == 0) {
        identity= RM;
        action= REMOVE;
        flags= "ifrRvx";
    } else
    if (strcmp(prog_name, "ln") == 0) {
        identity= LN;
        action= LINK;
        flags= "ifsSmrRvx";
    } else
    if (strcmp(prog_name, "cpdir") == 0) {
        identity= CPDIR;
        action= COPY;
        flags= "pifsmrRvx";
        rflag= mflag= pflag= 1;
        conforming= 0;
    } else
    if (strcmp(prog_name, "clone") == 0) {
        identity= CLONE;
        action= LINK;
        flags= "ifsSmrRvx";
        rflag= mflag= fflag= 1;
    } else {
        fprintf(stderr,
            "%s: Identity crisis, not called cp, mv, rm, ln, cpdir, or clone\n",
            prog_name);
        exit(1);
    }

    /* Who am I?, where am I?, how protective am I? */
    uid= geteuid();
    gid= getegid();
    istty= isatty(0);
    fc_mask= ~umask(0);

    /* Gather flags. */
    i= 1;
    while (i < argc && argv[i][0] == '-') {
        char *opt= argv[i++] + 1;

        if (opt[0] == '-' && opt[1] == 0) break;        /* -- */

        while (*opt != 0) {
            /* Flag supported? */
            if (strchr(flags, *opt) == nil) usage();

            switch (*opt++) {
            case 'p':
                pflag= 1;
                break;
            case 'i':
                iflag= 1;
                if (action == MOVE) fflag= 0;
                break;
            case 'f':
                fflag= 1;
                if (action == MOVE) iflag= 0;
                break;
            case 's':
                if (action == LINK) {
                    sflag= 1;
                } else {
                    /* Forget about POSIX, do it right. */
                    conforming= 0;
                }
                break;
            case 'S':
                Sflag= 1;
                break;
            case 'm':
                mflag= 1;
                break;
            case 'r':
                expand= 0;
                /*FALL THROUGH*/
            case 'R':
                rflag= 1;
                break;
            case 'v':
                vflag= 1;
                break;
            case 'x':
                xflag= 1;
                break;
            default:
                assert(0);
            }
        }
    }

    switch (action) {
    case REMOVE:
        if (i == argc) {
            if (fflag)
                exit(0);
            usage();
        }
        break;
    case LINK:
        /* 'ln dir/file' is to be read as 'ln dir/file .'. */
        if ((argc - i) == 1 && action == LINK) argv[argc++]= ".";
        /*FALL THROUGH*/
    default:
        if ((argc - i) < 2) usage();
    }

    path_init(&src);
    path_init(&dst);

    if (action != REMOVE && !mflag
        && stat(argv[argc-1], &st) >= 0 && S_ISDIR(st.st_mode)
    ) {
        /* The last argument is a directory, this means we have to
         * throw the whole lot into this directory.  This is the
         * Right Thing unless you use -r.
         */
        path_add(&dst, argv[argc-1]);
        slash= path_length(&dst);

        do {
            path_add(&src, argv[i]);
            path_add(&dst, basename(argv[i]));

            do1(&src, &dst, 0);

            path_trunc(&src, 0);
            path_trunc(&dst, slash);
        } while (++i < argc-1);
    } else
    if (action == REMOVE || (argc - i) == 2) {
        /* Just two files (or many files for rm). */
        do {
            path_add(&src, argv[i]);
            if (action != REMOVE) path_add(&dst, argv[i+1]);

            do1(&src, &dst, 0);
            path_trunc(&src, 0);
        } while (action == REMOVE && ++i < argc);
    } else {
        usage();
    }
    path_drop(&src);
    path_drop(&dst);

#if DEBUG
    if (nchunks != 0) {
        fprintf(stderr, "(%ld chunks of memory not freed)\n",
            (long) nchunks);
    }
#endif
    exit(ex_code);
    return ex_code;
}