From 55c64fc9cd8ddd7a3d4b3207b9c9c698c7a9ec4b Mon Sep 17 00:00:00 2001 From: Chris Johns Date: Fri, 11 Apr 2008 22:57:54 +0000 Subject: 2008-04-12 Chris Johns * libmisc/shell/shell.c, libmisc/shell/shell.h, libmisc/shell/shell_script.c: Add support to echo the commands to stdout. This is useful with the -v script option to show commands as the run. Also added support to chdir to the directory the task invoking the script is in. * libmisc/shell/extern-cp.h, libmisc/shell/main_cp.c, libmisc/shell/utils-cp.c: Update tro the latest FreeBSD version. * libcsupport/Makefile.am, libcsupport/src/fchown.c: Add fchown support. --- cpukit/libmisc/shell/utils-cp.c | 383 ++++++++++++++++++++++++++-------------- 1 file changed, 254 insertions(+), 129 deletions(-) (limited to 'cpukit/libmisc/shell/utils-cp.c') diff --git a/cpukit/libmisc/shell/utils-cp.c b/cpukit/libmisc/shell/utils-cp.c index 52cbc63470..defd5dd021 100644 --- a/cpukit/libmisc/shell/utils-cp.c +++ b/cpukit/libmisc/shell/utils-cp.c @@ -52,6 +52,7 @@ __RCSID("$NetBSD: utils.c,v 1.29 2005/10/15 18:22:18 christos Exp $"); #include #include #include +#include #include #include #include @@ -62,6 +63,8 @@ __RCSID("$NetBSD: utils.c,v 1.29 2005/10/15 18:22:18 christos Exp $"); #define lchmod chmod #define lchown chown +#define cp_pct(x, y) ((y == 0) ? 0 : (int)(100.0 * (x) / (y))) + int set_utimes(const char *file, struct stat *fs) { @@ -81,9 +84,16 @@ int copy_file(rtems_shell_cp_globals* cp_globals, FTSENT *entp, int dne) { static char buf[MAXBSIZE]; - struct stat to_stat, *fs; - int ch, checkch, from_fd, rcount, rval, to_fd, wcount; - + struct stat *fs; + ssize_t wcount; + size_t wresid; + off_t wtotal; + int ch, checkch, from_fd = 0, rcount, rval, to_fd = 0; + char *bufp; +#ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED + char *p; +#endif + if ((from_fd = open(entp->fts_path, O_RDONLY, 0)) == -1) { warn("%s", entp->fts_path); return (1); @@ -100,30 +110,41 @@ copy_file(rtems_shell_cp_globals* cp_globals, FTSENT *entp, int dne) * modified by the umask.) */ if (!dne) { - if (iflag) { - (void)fprintf(stderr, "overwrite %s? ", to.p_path); +#define YESNO "(y/n [n]) " + if (nflag) { + if (vflag) + printf("%s not overwritten\n", to.p_path); + (void)close(from_fd); + return (0); + } else if (iflag) { + (void)fprintf(stderr, "overwrite %s? %s", + to.p_path, YESNO); checkch = ch = getchar(); while (ch != '\n' && ch != EOF) ch = getchar(); if (checkch != 'y' && checkch != 'Y') { (void)close(from_fd); - return (0); + (void)fprintf(stderr, "not overwritten\n"); + return (1); } } - /* overwrite existing destination file name */ - to_fd = open(to.p_path, O_WRONLY | O_TRUNC, 0); - } else - to_fd = open(to.p_path, O_WRONLY | O_TRUNC | O_CREAT, - fs->st_mode & ~(S_ISUID | S_ISGID)); - - if (to_fd == -1 && fflag) { - /* - * attempt to remove existing destination file name and - * create a new file - */ - (void)unlink(to.p_path); - to_fd = open(to.p_path, O_WRONLY | O_TRUNC | O_CREAT, - fs->st_mode & ~(S_ISUID | S_ISGID)); + + if (fflag) { + /* remove existing destination file name, + * create a new file */ + (void)unlink(to.p_path); + if (!lflag) + to_fd = open(to.p_path, O_WRONLY | O_TRUNC | O_CREAT, + fs->st_mode & ~(S_ISUID | S_ISGID)); + } else { + if (!lflag) + /* overwrite existing destination file name */ + to_fd = open(to.p_path, O_WRONLY | O_TRUNC, 0); + } + } else { + if (!lflag) + to_fd = open(to.p_path, O_WRONLY | O_TRUNC | O_CREAT, + fs->st_mode & ~(S_ISUID | S_ISGID)); } if (to_fd == -1) { @@ -134,45 +155,69 @@ copy_file(rtems_shell_cp_globals* cp_globals, FTSENT *entp, int dne) rval = 0; - /* - * There's no reason to do anything other than close the file - * now if it's empty, so let's not bother. - */ - - if (fs->st_size) { - + if (!lflag) { /* - * Mmap and write if less than 8M (the limit is so - * we don't totally trash memory on big files). - * This is really a minor hack, but it wins some CPU back. + * Mmap and write if less than 8M (the limit is so we don't totally + * trash memory on big files. This is really a minor hack, but it + * wins some CPU back. */ -#if 0 - if (fs->st_size <= 8 * 1048576) { - size_t fsize = (size_t)fs->st_size; - p = mmap(NULL, fsize, PROT_READ, MAP_FILE|MAP_SHARED, - from_fd, (off_t)0); - if (p == MAP_FAILED) { - goto mmap_failed; +#ifdef CCJ_REMOVED_VM_AND_BUFFER_CACHE_SYNCHRONIZED + if (S_ISREG(fs->st_mode) && fs->st_size > 0 && + fs->st_size <= 8 * 1048576) { + if ((p = mmap(NULL, (size_t)fs->st_size, PROT_READ, + MAP_SHARED, from_fd, (off_t)0)) == MAP_FAILED) { + warn("%s", entp->fts_path); + rval = 1; } else { - (void) madvise(p, (size_t)fs->st_size, - MADV_SEQUENTIAL); - if (write(to_fd, p, fsize) != - fs->st_size) { + wtotal = 0; + for (bufp = p, wresid = fs->st_size; ; + bufp += wcount, wresid -= (size_t)wcount) { + wcount = write(to_fd, bufp, wresid); + if (wcount <= 0) + break; + wtotal += wcount; + if (info) { + info = 0; + (void)fprintf(stderr, + "%s -> %s %3d%%\n", + entp->fts_path, to.p_path, + cp_pct(wtotal, fs->st_size)); + } + if (wcount >= (ssize_t)wresid) + break; + } + if (wcount != (ssize_t)wresid) { warn("%s", to.p_path); rval = 1; } - if (munmap(p, fsize) < 0) { + /* Some systems don't unmap on close(2). */ + if (munmap(p, fs->st_size) < 0) { warn("%s", entp->fts_path); rval = 1; } } - } else { -mmap_failed: + } else #endif { + wtotal = 0; while ((rcount = read(from_fd, buf, MAXBSIZE)) > 0) { - wcount = write(to_fd, buf, (size_t)rcount); - if (rcount != wcount || wcount == -1) { + for (bufp = buf, wresid = rcount; ; + bufp += wcount, wresid -= wcount) { + wcount = write(to_fd, bufp, wresid); + if (wcount <= 0) + break; + wtotal += wcount; + if (info) { + info = 0; + (void)fprintf(stderr, + "%s -> %s %3d%%\n", + entp->fts_path, to.p_path, + cp_pct(wtotal, fs->st_size)); + } + if (wcount >= (ssize_t)wresid) + break; + } + if (wcount != (ssize_t)wresid) { warn("%s", to.p_path); rval = 1; break; @@ -183,41 +228,32 @@ mmap_failed: rval = 1; } } + } else { + if (link(entp->fts_path, to.p_path)) { + warn("%s", to.p_path); + rval = 1; + } } - - if (rval == 1) { - (void)close(from_fd); - (void)close(to_fd); - return (1); - } - - if (pflag && setfile(cp_globals, fs, to_fd)) - rval = 1; + (void)close(from_fd); + /* - * If the source was setuid or setgid, lose the bits unless the - * copy is owned by the same user and group. + * Don't remove the target even after an error. The target might + * not be a regular file, or its attributes might be important, + * or its contents might be irreplaceable. It would only be safe + * to remove it if we created it and its length is 0. */ -#define RETAINBITS \ - (S_ISUID | S_ISGID | S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO) - else if (fs->st_mode & (S_ISUID | S_ISGID) && fs->st_uid == myuid) { - if (fstat(to_fd, &to_stat)) { - warn("%s", to.p_path); + + if (!lflag) { + if (pflag && setfile(cp_globals, fs, to_fd)) rval = 1; - } else if (fs->st_gid == to_stat.st_gid && - fchmod(to_fd, fs->st_mode & RETAINBITS & ~myumask)) { + if (pflag && preserve_fd_acls(from_fd, to_fd) != 0) + rval = 1; + (void)close(from_fd); + if (close(to_fd)) { warn("%s", to.p_path); rval = 1; } } - (void)close(from_fd); - if (close(to_fd)) { - warn("%s", to.p_path); - rval = 1; - } - /* set the mod/access times now after close of the fd */ - if (pflag && set_utimes(to.p_path, fs)) { - rval = 1; - } return (rval); } @@ -225,22 +261,22 @@ int copy_link(rtems_shell_cp_globals* cp_globals, FTSENT *p, int exists) { int len; - char target[MAXPATHLEN]; + char llink[PATH_MAX]; - if ((len = readlink(p->fts_path, target, sizeof(target)-1)) == -1) { + if ((len = readlink(p->fts_path, llink, sizeof(llink) - 1)) == -1) { warn("readlink: %s", p->fts_path); return (1); } - target[len] = '\0'; + llink[len] = '\0'; if (exists && unlink(to.p_path)) { warn("unlink: %s", to.p_path); return (1); } - if (symlink(target, to.p_path)) { - warn("symlink: %s", target); + if (symlink(llink, to.p_path)) { + warn("symlink: %s", llink); return (1); } - return (pflag ? setfile(cp_globals, p->fts_statp, 0) : 0); + return (pflag ? setfile(cp_globals, p->fts_statp, -1) : 0); } int @@ -254,7 +290,7 @@ copy_fifo(rtems_shell_cp_globals* cp_globals, struct stat *from_stat, int exists warn("mkfifo: %s", to.p_path); return (1); } - return (pflag ? setfile(cp_globals, from_stat, 0) : 0); + return (pflag ? setfile(cp_globals, from_stat, -1) : 0); } int @@ -268,83 +304,172 @@ copy_special(rtems_shell_cp_globals* cp_globals, struct stat *from_stat, int exi warn("mknod: %s", to.p_path); return (1); } - return (pflag ? setfile(cp_globals, from_stat, 0) : 0); + return (pflag ? setfile(cp_globals, from_stat, -1) : 0); } +#define TIMESPEC_TO_TIMEVAL(tv, ts) { \ + (tv)->tv_sec = *(ts); \ + (tv)->tv_usec = 0; \ +} -/* - * Function: setfile - * - * Purpose: - * Set the owner/group/permissions for the "to" file to the information - * in the stat structure. If fd is zero, also call set_utimes() to set - * the mod/access times. If fd is non-zero, the caller must do a utimes - * itself after close(fd). - */ -#define st_flags st_mode +#define st_atimespec st_atime +#define st_mtimespec st_mtime +#define lutimes utimes int setfile(rtems_shell_cp_globals* cp_globals, struct stat *fs, int fd) { - int rval, islink; + static struct timeval tv[2]; + struct stat ts; + int rval, gotstat, islink, fdval; rval = 0; - islink = S_ISLNK(fs->st_mode); - fs->st_mode &= S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO; + fdval = fd != -1; + islink = !fdval && S_ISLNK(fs->st_mode); + fs->st_mode &= S_ISUID | S_ISGID | S_ISVTX | + S_IRWXU | S_IRWXG | S_IRWXO; + TIMESPEC_TO_TIMEVAL(&tv[0], &fs->st_atimespec); + TIMESPEC_TO_TIMEVAL(&tv[1], &fs->st_mtimespec); +#if 0 + if (islink ? lutimes(to.p_path, tv) : utimes(to.p_path, tv)) { + warn("%sutimes: %s", islink ? "l" : "", to.p_path); + rval = 1; + } +#endif + if (fdval ? fstat(fd, &ts) : + (islink ? lstat(to.p_path, &ts) : stat(to.p_path, &ts))) + gotstat = 0; + else { + gotstat = 1; + ts.st_mode &= S_ISUID | S_ISGID | S_ISVTX | + S_IRWXU | S_IRWXG | S_IRWXO; + } /* * Changing the ownership probably won't succeed, unless we're root * or POSIX_CHOWN_RESTRICTED is not set. Set uid/gid before setting * the mode; current BSD behavior is to remove all setuid bits on * chown. If chown fails, lose setuid/setgid bits. */ + if (!gotstat || fs->st_uid != ts.st_uid || fs->st_gid != ts.st_gid) + if (fdval ? fchown(fd, fs->st_uid, fs->st_gid) : + (islink ? lchown(to.p_path, fs->st_uid, fs->st_gid) : + chown(to.p_path, fs->st_uid, fs->st_gid))) { + if (errno != EPERM) { + warn("chown: %s", to.p_path); + rval = 1; + } + fs->st_mode &= ~(S_ISUID | S_ISGID); + } + + if (!gotstat || fs->st_mode != ts.st_mode) + if (fdval ? fchmod(fd, fs->st_mode) : + (islink ? lchmod(to.p_path, fs->st_mode) : + chmod(to.p_path, fs->st_mode))) { + warn("chmod: %s", to.p_path); + rval = 1; + } + #if 0 - if (fd ? fchown(fd, fs->st_uid, fs->st_gid) : - lchown(to.p_path, fs->st_uid, fs->st_gid)) { -#endif - if (lchown(to.p_path, fs->st_uid, fs->st_gid)) { - if (errno != EPERM) { - warn("chown: %s", to.p_path); + if (!gotstat || fs->st_flags != ts.st_flags) + if (fdval ? + fchflags(fd, fs->st_flags) : + (islink ? (errno = ENOSYS) : + chflags(to.p_path, fs->st_flags))) { + warn("chflags: %s", to.p_path); rval = 1; } - fs->st_mode &= ~(S_ISUID | S_ISGID); +#endif + + return (rval); +} + +int +preserve_fd_acls(int source_fd, int dest_fd) +{ +#if 0 + struct acl *aclp; + acl_t acl; + + if (fpathconf(source_fd, _PC_ACL_EXTENDED) != 1 || + fpathconf(dest_fd, _PC_ACL_EXTENDED) != 1) + return (0); + acl = acl_get_fd(source_fd); + if (acl == NULL) { + warn("failed to get acl entries while setting %s", to.p_path); + return (1); } - if (fd ? fchmod(fd, fs->st_mode) : lchmod(to.p_path, fs->st_mode)) { - warn("chmod: %s", to.p_path); - rval = 1; + aclp = &acl->ats_acl; + if (aclp->acl_cnt == 3) + return (0); + if (acl_set_fd(dest_fd, acl) < 0) { + warn("failed to set acl entries for %s", to.p_path); + return (1); } +#endif + return (0); +} +int +preserve_dir_acls(struct stat *fs, char *source_dir, char *dest_dir) +{ #if 0 - if (!islink && !Nflag) { - unsigned long fflags = fs->st_flags; - /* - * XXX - * NFS doesn't support chflags; ignore errors unless - * there's reason to believe we're losing bits. - * (Note, this still won't be right if the server - * supports flags and we were trying to *remove* flags - * on a file that we copied, i.e., that we didn't create.) - */ - errno = 0; - if ((fd ? fchflags(fd, fflags) : - chflags(to.p_path, fflags)) == -1) - if (errno != EOPNOTSUPP || fs->st_flags != 0) { - warn("chflags: %s", to.p_path); - rval = 1; - } + acl_t (*aclgetf)(const char *, acl_type_t); + int (*aclsetf)(const char *, acl_type_t, acl_t); + struct acl *aclp; + acl_t acl; + + if (pathconf(source_dir, _PC_ACL_EXTENDED) != 1 || + pathconf(dest_dir, _PC_ACL_EXTENDED) != 1) + return (0); + /* + * If the file is a link we will not follow it + */ + if (S_ISLNK(fs->st_mode)) { + aclgetf = acl_get_link_np; + aclsetf = acl_set_link_np; + } else { + aclgetf = acl_get_file; + aclsetf = acl_set_file; + } + /* + * Even if there is no ACL_TYPE_DEFAULT entry here, a zero + * size ACL will be returned. So it is not safe to simply + * check the pointer to see if the default ACL is present. + */ + acl = aclgetf(source_dir, ACL_TYPE_DEFAULT); + if (acl == NULL) { + warn("failed to get default acl entries on %s", + source_dir); + return (1); + } + aclp = &acl->ats_acl; + if (aclp->acl_cnt != 0 && aclsetf(dest_dir, + ACL_TYPE_DEFAULT, acl) < 0) { + warn("failed to set default acl entries on %s", + dest_dir); + return (1); + } + acl = aclgetf(source_dir, ACL_TYPE_ACCESS); + if (acl == NULL) { + warn("failed to get acl entries on %s", source_dir); + return (1); + } + aclp = &acl->ats_acl; + if (aclsetf(dest_dir, ACL_TYPE_ACCESS, acl) < 0) { + warn("failed to set acl entries on %s", dest_dir); + return (1); } #endif - /* if fd is non-zero, caller must call set_utimes() after close() */ - if (fd == 0 && set_utimes(to.p_path, fs)) - rval = 1; - return (rval); + return (0); } void usage(void) { - (void)fprintf(stderr, - "usage: %s [-R [-H | -L | -P]] [-f | -i] [-pv] src target\n" - " %s [-R [-H | -L | -P]] [-f | -i] [-pv] src1 ... srcN directory\n", - "cp", "cp"); + + (void)fprintf(stderr, "%s\n%s\n", +"usage: cp [-R [-H | -L | -P]] [-f | -i | -n] [-alpv] source_file target_file", +" cp [-R [-H | -L | -P]] [-f | -i | -n] [-alpv] source_file ... " +"target_directory"); } -- cgit v1.2.3