int
copy(rtems_shell_cp_globals* cp_globals,
char *argv[], enum op type, int fts_options)
{
struct stat to_stat;
FTS *ftsp;
FTSENT *curr;
int base = 0, dne, badcp, rval;
size_t nlen;
char *p, *target_mid;
mode_t mask, mode;
/*
* Keep an inverted copy of the umask, for use in correcting
* permissions on created directories when not using -p.
*/
mask = ~umask(0777);
umask(~mask);
if ((ftsp = fts_open(argv, fts_options, mastercmp)) == NULL)
err(exit_jump, 1, "fts_open");
for (badcp = rval = 0; (curr = fts_read(ftsp)) != NULL; badcp = 0) {
switch (curr->fts_info) {
case FTS_NS:
case FTS_DNR:
case FTS_ERR:
warnx("%s: %s",
curr->fts_path, strerror(curr->fts_errno));
badcp = rval = 1;
continue;
case FTS_DC: /* Warn, continue. */
warnx("%s: directory causes a cycle", curr->fts_path);
badcp = rval = 1;
continue;
default:
;
}
/*
* If we are in case (2) or (3) above, we need to append the
* source name to the target name.
*/
if (type != FILE_TO_FILE) {
/*
* Need to remember the roots of traversals to create
* correct pathnames. If there's a directory being
* copied to a non-existent directory, e.g.
* cp -R a/dir noexist
* the resulting path name should be noexist/foo, not
* noexist/dir/foo (where foo is a file in dir), which
* is the case where the target exists.
*
* Also, check for "..". This is for correct path
* concatenation for paths ending in "..", e.g.
* cp -R .. /tmp
* Paths ending in ".." are changed to ".". This is
* tricky, but seems the easiest way to fix the problem.
*
* XXX
* Since the first level MUST be FTS_ROOTLEVEL, base
* is always initialized.
*/
if (curr->fts_level == FTS_ROOTLEVEL) {
if (type != DIR_TO_DNE) {
p = strrchr(curr->fts_path, '/');
base = (p == NULL) ? 0 :
(int)(p - curr->fts_path + 1);
if (!strcmp(&curr->fts_path[base],
".."))
base += 1;
} else
base = curr->fts_pathlen;
}
p = &curr->fts_path[base];
nlen = curr->fts_pathlen - base;
target_mid = to.target_end;
if (*p != '/' && target_mid[-1] != '/')
*target_mid++ = '/';
*target_mid = 0;
if (target_mid - to.p_path + nlen >= PATH_MAX) {
warnx("%s%s: name too long (not copied)",
to.p_path, p);
badcp = rval = 1;
continue;
}
(void)strncat(target_mid, p, nlen);
to.p_end = target_mid + nlen;
*to.p_end = 0;
STRIP_TRAILING_SLASH(to);
}
if (curr->fts_info == FTS_DP) {
/*
* We are nearly finished with this directory. If we
* didn't actually copy it, or otherwise don't need to
* change its attributes, then we are done.
*/
if (!curr->fts_number)
continue;
/*
* If -p is in effect, set all the attributes.
* Otherwise, set the correct permissions, limited
* by the umask. Optimise by avoiding a chmod()
* if possible (which is usually the case if we
* made the directory). Note that mkdir() does not
* honour setuid, setgid and sticky bits, but we
* normally want to preserve them on directories.
*/
if (pflag) {
if (setfile(cp_globals, curr->fts_statp, -1))
rval = 1;
if (preserve_dir_acls(curr->fts_statp,
curr->fts_accpath, to.p_path) != 0)
rval = 1;
} else {
mode = curr->fts_statp->st_mode;
if ((mode & (S_ISUID | S_ISGID | S_ISTXT)) ||
((mode | S_IRWXU) & mask) != (mode & mask))
if (chmod(to.p_path, mode & mask) != 0){
warn("chmod: %s", to.p_path);
rval = 1;
}
}
continue;
}
/* Not an error but need to remember it happened */
if (stat(to.p_path, &to_stat) == -1)
dne = 1;
else {
if (to_stat.st_dev == curr->fts_statp->st_dev &&
to_stat.st_ino == curr->fts_statp->st_ino) {
warnx("%s and %s are identical (not copied).",
to.p_path, curr->fts_path);
badcp = rval = 1;
if (S_ISDIR(curr->fts_statp->st_mode))
(void)fts_set(ftsp, curr, FTS_SKIP);
continue;
}
if (!S_ISDIR(curr->fts_statp->st_mode) &&
S_ISDIR(to_stat.st_mode)) {
warnx("cannot overwrite directory %s with "
"non-directory %s",
to.p_path, curr->fts_path);
badcp = rval = 1;
continue;
}
dne = 0;
}
switch (curr->fts_statp->st_mode & S_IFMT) {
case S_IFLNK:
/* Catch special case of a non-dangling symlink */
if ((fts_options & FTS_LOGICAL) ||
((fts_options & FTS_COMFOLLOW) &&
curr->fts_level == 0)) {
if (copy_file(cp_globals, curr, dne))
badcp = rval = 1;
} else {
if (copy_link(cp_globals, curr, !dne))
badcp = rval = 1;
}
break;
case S_IFDIR:
if (!Rflag) {
warnx("%s is a directory (not copied).",
curr->fts_path);
(void)fts_set(ftsp, curr, FTS_SKIP);
badcp = rval = 1;
break;
}
/*
* If the directory doesn't exist, create the new
* one with the from file mode plus owner RWX bits,
* modified by the umask. Trade-off between being
* able to write the directory (if from directory is
* 555) and not causing a permissions race. If the
* umask blocks owner writes, we fail..
*/
if (dne) {
if (mkdir(to.p_path,
curr->fts_statp->st_mode | S_IRWXU) < 0)
err(exit_jump, 1, "%s", to.p_path);
} else if (!S_ISDIR(to_stat.st_mode)) {
errno = ENOTDIR;
err(exit_jump, 1, "%s", to.p_path);
}
/*
* Arrange to correct directory attributes later
* (in the post-order phase) if this is a new
* directory, or if the -p flag is in effect.
*/
curr->fts_number = pflag || dne;
break;
case S_IFBLK:
case S_IFCHR:
if (Rflag) {
if (copy_special(cp_globals, curr->fts_statp, !dne))
badcp = rval = 1;
} else {
if (copy_file(cp_globals, curr, dne))
badcp = rval = 1;
}
break;
case S_IFSOCK:
warnx("%s is a socket (not copied).",
curr->fts_path);
case S_IFIFO:
if (Rflag) {
if (copy_fifo(cp_globals, curr->fts_statp, !dne))
badcp = rval = 1;
} else {
if (copy_file(cp_globals, curr, dne))
badcp = rval = 1;
}
break;
default:
if (copy_file(cp_globals, curr, dne))
badcp = rval = 1;
break;
}
if (vflag && !badcp)
(void)printf("%s -> %s\n", curr->fts_path, to.p_path);
}
if (errno)
err(exit_jump, 1, "fts_read");
fts_close(ftsp);
return (rval);
}
static int copy(const char *path,
const struct stat *statp,
int tflag,
struct FTW *ftw)
{
static int base = 0;
struct stat to_stat;
int dne;
size_t nlen;
const char *p;
char *target_mid;
if (alarmed)
return -1;
/* This currently doesn't work with "." */
if (strcmp(path, ".") == 0) {
ERROR("\".\" not supported");
}
const char *dir = strrchr(path, '/');
if (dir == NULL)
dir = path;
else
dir++;
if (check_netatalk_dirs(dir) != NULL)
return FTW_SKIP_SUBTREE;
/*
* If we are in case (2) above, we need to append the
* source name to the target name.
*/
if (type != FILE_TO_FILE) {
/*
* Need to remember the roots of traversals to create
* correct pathnames. If there's a directory being
* copied to a non-existent directory, e.g.
* cp -R a/dir noexist
* the resulting path name should be noexist/foo, not
* noexist/dir/foo (where foo is a file in dir), which
* is the case where the target exists.
*
* Also, check for "..". This is for correct path
* concatenation for paths ending in "..", e.g.
* cp -R .. /tmp
* Paths ending in ".." are changed to ".". This is
* tricky, but seems the easiest way to fix the problem.
*
* XXX
* Since the first level MUST be FTS_ROOTLEVEL, base
* is always initialized.
*/
if (ftw->level == 0) {
if (type != DIR_TO_DNE) {
base = ftw->base;
if (strcmp(&path[base], "..") == 0)
base += 1;
} else
base = strlen(path);
}
p = &path[base];
nlen = strlen(path) - base;
target_mid = to.target_end;
if (*p != '/' && target_mid[-1] != '/')
*target_mid++ = '/';
*target_mid = 0;
if (target_mid - to.p_path + nlen >= PATH_MAX) {
SLOG("%s%s: name too long (not copied)", to.p_path, p);
badcp = rval = 1;
return 0;
}
(void)strncat(target_mid, p, nlen);
to.p_end = target_mid + nlen;
*to.p_end = 0;
STRIP_TRAILING_SLASH(to);
}
/* Not an error but need to remember it happened */
if (stat(to.p_path, &to_stat) == -1)
dne = 1;
else {
if (to_stat.st_dev == statp->st_dev &&
to_stat.st_ino == statp->st_ino) {
SLOG("%s and %s are identical (not copied).", to.p_path, path);
badcp = rval = 1;
if (S_ISDIR(statp->st_mode))
/* without using glibc extension FTW_ACTIONRETVAL cant handle this */
return FTW_SKIP_SUBTREE;
return 0;
}
if (!S_ISDIR(statp->st_mode) &&
S_ISDIR(to_stat.st_mode)) {
SLOG("cannot overwrite directory %s with "
"non-directory %s",
to.p_path, path);
badcp = rval = 1;
return 0;
}
dne = 0;
}
/* Convert basename to appropiate volume encoding */
if (dvolume.volinfo.v_path) {
if ((convert_dots_encoding(&svolume, &dvolume, to.p_path, MAXPATHLEN)) == -1) {
SLOG("Error converting name for %s", to.p_path);
badcp = rval = 1;
return -1;
}
}
switch (statp->st_mode & S_IFMT) {
case S_IFLNK:
if (ftw_copy_link(ftw, path, statp, !dne))
badcp = rval = 1;
break;
case S_IFDIR:
if (!Rflag) {
SLOG("%s is a directory", path);
badcp = rval = 1;
return -1;
}
/*
* If the directory doesn't exist, create the new
* one with the from file mode plus owner RWX bits,
* modified by the umask. Trade-off between being
* able to write the directory (if from directory is
* 555) and not causing a permissions race. If the
* umask blocks owner writes, we fail..
*/
if (dne) {
if (mkdir(to.p_path, statp->st_mode | S_IRWXU) < 0)
ERROR("mkdir: %s: %s", to.p_path, strerror(errno));
} else if (!S_ISDIR(to_stat.st_mode)) {
errno = ENOTDIR;
ERROR("%s", to.p_path);
}
/* Create ad dir and copy ".Parent" */
if (dvolume.volinfo.v_path && dvolume.volinfo.v_adouble == AD_VERSION2) {
/* Create ".AppleDouble" dir */
mode_t omask = umask(0);
bstring addir = bfromcstr(to.p_path);
bcatcstr(addir, "/.AppleDouble");
mkdir(cfrombstr(addir), 02777);
bdestroy(addir);
if (svolume.volinfo.v_path && svolume.volinfo.v_adouble == AD_VERSION2) {
/* copy ".Parent" file */
if (dvolume.volume.vfs->vfs_copyfile(&dvolume.volume, -1, path, to.p_path)) {
SLOG("Error copying adouble for %s -> %s", path, to.p_path);
badcp = rval = 1;
break;
}
}
/* Get CNID of Parent and add new childir to CNID database */
ppdid = pdid;
if ((did = cnid_for_path(&dvolume, to.p_path, &pdid)) == CNID_INVALID) {
SLOG("Error resolving CNID for %s", to.p_path);
badcp = rval = 1;
return -1;
}
struct adouble ad;
struct stat st;
if (lstat(to.p_path, &st) != 0) {
badcp = rval = 1;
break;
}
ad_init(&ad, dvolume.volinfo.v_adouble, dvolume.volinfo.v_ad_options);
if (ad_open_metadata(to.p_path, ADFLAGS_DIR, O_RDWR | O_CREAT, &ad) != 0) {
ERROR("Error opening adouble for: %s", to.p_path);
}
ad_setid( &ad, st.st_dev, st.st_ino, did, pdid, dvolume.db_stamp);
ad_setname(&ad, utompath(&dvolume.volinfo, basename(to.p_path)));
ad_setdate(&ad, AD_DATE_CREATE | AD_DATE_UNIX, st.st_mtime);
ad_setdate(&ad, AD_DATE_MODIFY | AD_DATE_UNIX, st.st_mtime);
ad_setdate(&ad, AD_DATE_ACCESS | AD_DATE_UNIX, st.st_mtime);
ad_setdate(&ad, AD_DATE_BACKUP, AD_DATE_START);
ad_flush(&ad);
ad_close_metadata(&ad);
umask(omask);
}
if (pflag) {
if (setfile(statp, -1))
rval = 1;
#if 0
if (preserve_dir_acls(statp, curr->fts_accpath, to.p_path) != 0)
rval = 1;
#endif
}
break;
case S_IFBLK:
case S_IFCHR:
SLOG("%s is a device file (not copied).", path);
break;
case S_IFSOCK:
SLOG("%s is a socket (not copied).", path);
break;
case S_IFIFO:
SLOG("%s is a FIFO (not copied).", path);
break;
default:
if (ftw_copy_file(ftw, path, statp, dne))
badcp = rval = 1;
if (dvolume.volinfo.v_path && dvolume.volinfo.v_adouble == AD_VERSION2) {
mode_t omask = umask(0);
if (svolume.volinfo.v_path && svolume.volinfo.v_adouble == AD_VERSION2) {
/* copy ad-file */
if (dvolume.volume.vfs->vfs_copyfile(&dvolume.volume, -1, path, to.p_path)) {
SLOG("Error copying adouble for %s -> %s", path, to.p_path);
badcp = rval = 1;
break;
}
}
/* Get CNID of Parent and add new childir to CNID database */
pdid = did;
cnid_t cnid;
if ((cnid = cnid_for_path(&dvolume, to.p_path, &did)) == CNID_INVALID) {
SLOG("Error resolving CNID for %s", to.p_path);
badcp = rval = 1;
return -1;
}
struct adouble ad;
struct stat st;
if (lstat(to.p_path, &st) != 0) {
badcp = rval = 1;
break;
}
ad_init(&ad, dvolume.volinfo.v_adouble, dvolume.volinfo.v_ad_options);
if (ad_open_metadata(to.p_path, 0, O_RDWR | O_CREAT, &ad) != 0) {
ERROR("Error opening adouble for: %s", to.p_path);
}
ad_setid( &ad, st.st_dev, st.st_ino, cnid, did, dvolume.db_stamp);
ad_setname(&ad, utompath(&dvolume.volinfo, basename(to.p_path)));
ad_setdate(&ad, AD_DATE_CREATE | AD_DATE_UNIX, st.st_mtime);
ad_setdate(&ad, AD_DATE_MODIFY | AD_DATE_UNIX, st.st_mtime);
ad_setdate(&ad, AD_DATE_ACCESS | AD_DATE_UNIX, st.st_mtime);
ad_setdate(&ad, AD_DATE_BACKUP, AD_DATE_START);
ad_flush(&ad);
ad_close_metadata(&ad);
umask(omask);
}
break;
}
if (vflag && !badcp)
(void)printf("%s -> %s\n", path, to.p_path);
return 0;
}
