minix/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 <sys/syslimits.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;
}