bin/cp/cp.c

   1 /* $NetBSD: cp.c,v 1.52 2009/09/29 13:30:17 pooka Exp $ */
   2
   3 /*
   4  * Copyright (c) 1988, 1993, 1994
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * David Hitz of Auspex Systems Inc.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include <sys/cdefs.h>
  36 #ifndef lint
  37 __COPYRIGHT(
  38 "@(#) Copyright (c) 1988, 1993, 1994\
  39  The Regents of the University of California.  All rights reserved.");
  40 #endif /* not lint */
  41
  42 #ifndef lint
  43 #if 0
  44 static char sccsid[] = "@(#)cp.c        8.5 (Berkeley) 4/29/95";
  45 #else
  46 __RCSID("$NetBSD: cp.c,v 1.52 2009/09/29 13:30:17 pooka Exp $");
  47 #endif
  48 #endif /* not lint */
  49
  50 /*
  51  * Cp copies source files to target files.
  52  *
  53  * The global PATH_T structure "to" always contains the path to the
  54  * current target file.  Since fts(3) does not change directories,
  55  * this path can be either absolute or dot-relative.
  56  *
  57  * The basic algorithm is to initialize "to" and use fts(3) to traverse
  58  * the file hierarchy rooted in the argument list.  A trivial case is the
  59  * case of 'cp file1 file2'.  The more interesting case is the case of
  60  * 'cp file1 file2 ... fileN dir' where the hierarchy is traversed and the
  61  * path (relative to the root of the traversal) is appended to dir (stored
  62  * in "to") to form the final target path.
  63  */
  64
  65 #include <sys/param.h>
  66 #include <sys/stat.h>
  67
  68 #include <assert.h>
  69 #include <err.h>
  70 #include <errno.h>
  71 #include <fts.h>
  72 #include <locale.h>
  73 #include <stdlib.h>
  74 #include <stdio.h>
  75 #include <string.h>
  76 #include <unistd.h>
  77
  78 #include "extern.h"
  79
  80 #define STRIP_TRAILING_SLASH(p) {                                       \
  81         while ((p).p_end > (p).p_path + 1 && (p).p_end[-1] == '/')      \
  82                 *--(p).p_end = '\0';                                    \
  83 }
  84
  85 static char empty[] = "";
  86 PATH_T to = { .p_end = to.p_path, .target_end = empty  };
  87
  88 uid_t myuid;
  89 int Hflag, Lflag, Rflag, Pflag, fflag, iflag, pflag, rflag, vflag, Nflag;
  90 mode_t myumask;
  91
  92 enum op { FILE_TO_FILE, FILE_TO_DIR, DIR_TO_DNE };
  93
  94 int     main(int, char *[]);
  95 int     copy(char *[], enum op, int);
  96
  97 int
  98 main(int argc, char *argv[])
  99 {
 100         struct stat to_stat, tmp_stat;
 101         enum op type;
 102         int ch, fts_options, r, have_trailing_slash;
 103         char *target, **src;
 104
 105         setprogname(argv[0]);
 106         (void)setlocale(LC_ALL, "");
 107
 108         Hflag = Lflag = Pflag = Rflag = 0;
 109         while ((ch = getopt(argc, argv, "HLNPRfiprv")) != -1)
 110                 switch (ch) {
 111                 case 'H':
 112                         Hflag = 1;
 113                         Lflag = Pflag = 0;
 114                         break;
 115                 case 'L':
 116                         Lflag = 1;
 117                         Hflag = Pflag = 0;
 118                         break;
 119                 case 'N':
 120                         Nflag = 1;
 121                         break;
 122                 case 'P':
 123                         Pflag = 1;
 124                         Hflag = Lflag = 0;
 125                         break;
 126                 case 'R':
 127                         Rflag = 1;
 128                         break;
 129                 case 'f':
 130                         fflag = 1;
 131                         iflag = 0;
 132                         break;
 133                 case 'i':
 134                         iflag = isatty(fileno(stdin));
 135                         fflag = 0;
 136                         break;
 137                 case 'p':
 138                         pflag = 1;
 139                         break;
 140                 case 'r':
 141                         rflag = 1;
 142                         break;
 143                 case 'v':
 144                         vflag = 1;
 145                         break;
 146                 case '?':
 147                 default:
 148                         usage();
 149                         /* NOTREACHED */
 150                 }
 151         argc -= optind;
 152         argv += optind;
 153
 154         if (argc < 2)
 155                 usage();
 156
 157         fts_options = FTS_NOCHDIR | FTS_PHYSICAL;
 158         if (rflag) {
 159                 if (Rflag) {
 160                         errx(EXIT_FAILURE,
 161                     "the -R and -r options may not be specified together.");
 162                         /* NOTREACHED */
 163                 }
 164                 if (Hflag || Lflag || Pflag) {
 165                         errx(EXIT_FAILURE,
 166         "the -H, -L, and -P options may not be specified with the -r option.");
 167                         /* NOTREACHED */
 168                 }
 169                 fts_options &= ~FTS_PHYSICAL;
 170                 fts_options |= FTS_LOGICAL;
 171         }
 172
 173         if (Rflag) {
 174                 if (Hflag)
 175                         fts_options |= FTS_COMFOLLOW;
 176                 if (Lflag) {
 177                         fts_options &= ~FTS_PHYSICAL;
 178                         fts_options |= FTS_LOGICAL;
 179                 }
 180         } else if (!Pflag) {
 181                 fts_options &= ~FTS_PHYSICAL;
 182                 fts_options |= FTS_LOGICAL | FTS_COMFOLLOW;
 183         }
 184
 185         myuid = getuid();
 186
 187         /* Copy the umask for explicit mode setting. */
 188         myumask = umask(0);
 189         (void)umask(myumask);
 190
 191         /* Save the target base in "to". */
 192         target = argv[--argc];
 193         if (strlcpy(to.p_path, target, sizeof(to.p_path)) >= sizeof(to.p_path))
 194                 errx(EXIT_FAILURE, "%s: name too long", target);
 195         to.p_end = to.p_path + strlen(to.p_path);
 196         have_trailing_slash = (to.p_end[-1] == '/');
 197         if (have_trailing_slash)
 198                 STRIP_TRAILING_SLASH(to);
 199         to.target_end = to.p_end;
 200
 201         /* Set end of argument list for fts(3). */
 202         argv[argc] = NULL;
 203
 204         /*
 205          * Cp has two distinct cases:
 206          *
 207          * cp [-R] source target
 208          * cp [-R] source1 ... sourceN directory
 209          *
 210          * In both cases, source can be either a file or a directory.
 211          *
 212          * In (1), the target becomes a copy of the source. That is, if the
 213          * source is a file, the target will be a file, and likewise for
 214          * directories.
 215          *
 216          * In (2), the real target is not directory, but "directory/source".
 217          */
 218         if (Pflag)
 219                 r = lstat(to.p_path, &to_stat);
 220         else
 221                 r = stat(to.p_path, &to_stat);
 222         if (r == -1 && errno != ENOENT) {
 223                 err(EXIT_FAILURE, "%s", to.p_path);
 224                 /* NOTREACHED */
 225         }
 226         if (r == -1 || !S_ISDIR(to_stat.st_mode)) {
 227                 /*
 228                  * Case (1).  Target is not a directory.
 229                  */
 230                 if (argc > 1)
 231                         usage();
 232                 /*
 233                  * Need to detect the case:
 234                  *      cp -R dir foo
 235                  * Where dir is a directory and foo does not exist, where
 236                  * we want pathname concatenations turned on but not for
 237                  * the initial mkdir().
 238                  */
 239                 if (r == -1) {
 240                         if (rflag || (Rflag && (Lflag || Hflag)))
 241                                 r = stat(*argv, &tmp_stat);
 242                         else
 243                                 r = lstat(*argv, &tmp_stat);
 244                         if (r == -1) {
 245                                 err(EXIT_FAILURE, "%s", *argv);
 246                                 /* NOTREACHED */
 247                         }
 248
 249                         if (S_ISDIR(tmp_stat.st_mode) && (Rflag || rflag))
 250                                 type = DIR_TO_DNE;
 251                         else
 252                                 type = FILE_TO_FILE;
 253                 } else
 254                         type = FILE_TO_FILE;
 255
 256                 if (have_trailing_slash && type == FILE_TO_FILE) {
 257                         if (r == -1)
 258                                 errx(1, "directory %s does not exist",
 259                                      to.p_path);
 260                         else
 261                                 errx(1, "%s is not a directory", to.p_path);
 262                 }
 263         } else {
 264                 /*
 265                  * Case (2).  Target is a directory.
 266                  */
 267                 type = FILE_TO_DIR;
 268         }
 269
 270         /*
 271          * make "cp -rp src/ dst" behave like "cp -rp src dst" not
 272          * like "cp -rp src/. dst"
 273          */
 274         for (src = argv; *src; src++) {
 275                 size_t len = strlen(*src);
 276                 while (len-- > 1 && (*src)[len] == '/')
 277                         (*src)[len] = '\0';
 278         }
 279
 280         exit(copy(argv, type, fts_options));
 281         /* NOTREACHED */
 282 }
 283
 284 static int dnestack[MAXPATHLEN]; /* unlikely we'll have more nested dirs */
 285 static ssize_t dnesp;
 286 static void
 287 pushdne(int dne)
 288 {
 289
 290         dnestack[dnesp++] = dne;
 291         assert(dnesp < MAXPATHLEN);
 292 }
 293
 294 static int
 295 popdne(void)
 296 {
 297         int rv;
 298
 299         rv = dnestack[--dnesp];
 300         assert(dnesp >= 0);
 301         return rv;
 302 }
 303
 304 int
 305 copy(char *argv[], enum op type, int fts_options)
 306 {
 307         struct stat to_stat;
 308         FTS *ftsp;
 309         FTSENT *curr;
 310         int base, dne, sval;
 311         int this_failed, any_failed;
 312         size_t nlen;
 313         char *p, *target_mid;
 314
 315         base = 0;       /* XXX gcc -Wuninitialized (see comment below) */
 316
 317         if ((ftsp = fts_open(argv, fts_options, NULL)) == NULL)
 318                 err(EXIT_FAILURE, "%s", argv[0]);
 319                 /* NOTREACHED */
 320         for (any_failed = 0; (curr = fts_read(ftsp)) != NULL;) {
 321                 this_failed = 0;
 322                 switch (curr->fts_info) {
 323                 case FTS_NS:
 324                 case FTS_DNR:
 325                 case FTS_ERR:
 326                         warnx("%s: %s", curr->fts_path,
 327                                         strerror(curr->fts_errno));
 328                         this_failed = any_failed = 1;
 329                         continue;
 330                 case FTS_DC:                    /* Warn, continue. */
 331                         warnx("%s: directory causes a cycle", curr->fts_path);
 332                         this_failed = any_failed = 1;
 333                         continue;
 334                 }
 335
 336                 /*
 337                  * If we are in case (2) or (3) above, we need to append the
 338                  * source name to the target name.
 339                  */
 340                 if (type != FILE_TO_FILE) {
 341                         if ((curr->fts_namelen +
 342                             to.target_end - to.p_path + 1) > MAXPATHLEN) {
 343                                 warnx("%s/%s: name too long (not copied)",
 344                                                 to.p_path, curr->fts_name);
 345                                 this_failed = any_failed = 1;
 346                                 continue;
 347                         }
 348
 349                         /*
 350                          * Need to remember the roots of traversals to create
 351                          * correct pathnames.  If there's a directory being
 352                          * copied to a non-existent directory, e.g.
 353                          *      cp -R a/dir noexist
 354                          * the resulting path name should be noexist/foo, not
 355                          * noexist/dir/foo (where foo is a file in dir), which
 356                          * is the case where the target exists.
 357                          *
 358                          * Also, check for "..".  This is for correct path
 359                          * concatentation for paths ending in "..", e.g.
 360                          *      cp -R .. /tmp
 361                          * Paths ending in ".." are changed to ".".  This is
 362                          * tricky, but seems the easiest way to fix the problem.
 363                          *
 364                          * XXX
 365                          * Since the first level MUST be FTS_ROOTLEVEL, base
 366                          * is always initialized.
 367                          */
 368                         if (curr->fts_level == FTS_ROOTLEVEL) {
 369                                 if (type != DIR_TO_DNE) {
 370                                         p = strrchr(curr->fts_path, '/');
 371                                         base = (p == NULL) ? 0 :
 372                                             (int)(p - curr->fts_path + 1);
 373
 374                                         if (!strcmp(&curr->fts_path[base],
 375                                             ".."))
 376                                                 base += 1;
 377                                 } else
 378                                         base = curr->fts_pathlen;
 379                         }
 380
 381                         p = &curr->fts_path[base];
 382                         nlen = curr->fts_pathlen - base;
 383                         target_mid = to.target_end;
 384                         if (*p != '/' && target_mid[-1] != '/')
 385                                 *target_mid++ = '/';
 386                         *target_mid = 0;
 387
 388                         if (target_mid - to.p_path + nlen >= PATH_MAX) {
 389                                 warnx("%s%s: name too long (not copied)",
 390                                     to.p_path, p);
 391                                 this_failed = any_failed = 1;
 392                                 continue;
 393                         }
 394                         (void)strncat(target_mid, p, nlen);
 395                         to.p_end = target_mid + nlen;
 396                         *to.p_end = 0;
 397                         STRIP_TRAILING_SLASH(to);
 398                 }
 399
 400                 sval = Pflag ? lstat(to.p_path, &to_stat) : stat(to.p_path, &to_stat);
 401                 /* Not an error but need to remember it happened */
 402                 if (sval == -1)
 403                         dne = 1;
 404                 else {
 405                         if (to_stat.st_dev == curr->fts_statp->st_dev &&
 406                             to_stat.st_ino == curr->fts_statp->st_ino) {
 407                                 warnx("%s and %s are identical (not copied).",
 408                                     to.p_path, curr->fts_path);
 409                                 this_failed = any_failed = 1;
 410                                 if (S_ISDIR(curr->fts_statp->st_mode))
 411                                         (void)fts_set(ftsp, curr, FTS_SKIP);
 412                                 continue;
 413                         }
 414                         if (!S_ISDIR(curr->fts_statp->st_mode) &&
 415                             S_ISDIR(to_stat.st_mode)) {
 416                 warnx("cannot overwrite directory %s with non-directory %s",
 417                                     to.p_path, curr->fts_path);
 418                                 this_failed = any_failed = 1;
 419                                 continue;
 420                         }
 421                         dne = 0;
 422                 }
 423
 424                 switch (curr->fts_statp->st_mode & S_IFMT) {
 425                 case S_IFLNK:
 426                         /* Catch special case of a non dangling symlink */
 427                         if((fts_options & FTS_LOGICAL) ||
 428                            ((fts_options & FTS_COMFOLLOW) && curr->fts_level == 0)) {
 429                                 if (copy_file(curr, dne))
 430                                         this_failed = any_failed = 1;
 431                         } else {
 432                                 if (copy_link(curr, !dne))
 433                                         this_failed = any_failed = 1;
 434                         }
 435                         break;
 436                 case S_IFDIR:
 437                         if (!Rflag && !rflag) {
 438                                 if (curr->fts_info == FTS_D)
 439                                         warnx("%s is a directory (not copied).",
 440                                             curr->fts_path);
 441                                 (void)fts_set(ftsp, curr, FTS_SKIP);
 442                                 this_failed = any_failed = 1;
 443                                 break;
 444                         }
 445
 446                         /*
 447                          * Directories get noticed twice:
 448                          *  In the first pass, create it if needed.
 449                          *  In the second pass, after the children have been copied, set the permissions.
 450                          */
 451                         if (curr->fts_info == FTS_D) /* First pass */
 452                         {
 453                                 /*
 454                                  * If the directory doesn't exist, create the new
 455                                  * one with the from file mode plus owner RWX bits,
 456                                  * modified by the umask.  Trade-off between being
 457                                  * able to write the directory (if from directory is
 458                                  * 555) and not causing a permissions race.  If the
 459                                  * umask blocks owner writes, we fail..
 460                                  */
 461                                 pushdne(dne);
 462                                 if (dne) {
 463                                         if (mkdir(to.p_path,
 464                                             curr->fts_statp->st_mode | S_IRWXU) < 0)
 465                                                 err(EXIT_FAILURE, "%s",
 466                                                     to.p_path);
 467                                                 /* NOTREACHED */
 468                                 } else if (!S_ISDIR(to_stat.st_mode)) {
 469                                         errno = ENOTDIR;
 470                                         err(EXIT_FAILURE, "%s",
 471                                                 to.p_path);
 472                                         /* NOTREACHED */
 473                                 }
 474                         }
 475                         else if (curr->fts_info == FTS_DP) /* Second pass */
 476                         {
 477                                 /*
 478                                  * If not -p and directory didn't exist, set it to be
 479                                  * the same as the from directory, umodified by the
 480                                  * umask; arguably wrong, but it's been that way
 481                                  * forever.
 482                                  */
 483                                 if (pflag && setfile(curr->fts_statp, 0))
 484                                         this_failed = any_failed = 1;
 485                                 else if ((dne = popdne()))
 486                                         (void)chmod(to.p_path,
 487                                             curr->fts_statp->st_mode);
 488                         }
 489                         else
 490                         {
 491                                 warnx("directory %s encountered when not expected.",
 492                                     curr->fts_path);
 493                                 this_failed = any_failed = 1;
 494                                 break;
 495                         }
 496
 497                         break;
 498                 case S_IFBLK:
 499                 case S_IFCHR:
 500                         if (Rflag) {
 501                                 if (copy_special(curr->fts_statp, !dne))
 502                                         this_failed = any_failed = 1;
 503                         } else
 504                                 if (copy_file(curr, dne))
 505                                         this_failed = any_failed = 1;
 506                         break;
 507                 case S_IFIFO:
 508                         if (Rflag) {
 509                                 if (copy_fifo(curr->fts_statp, !dne))
 510                                         this_failed = any_failed = 1;
 511                         } else
 512                                 if (copy_file(curr, dne))
 513                                         this_failed = any_failed = 1;
 514                         break;
 515                 default:
 516                         if (copy_file(curr, dne))
 517                                 this_failed = any_failed = 1;
 518                         break;
 519                 }
 520                 if (vflag && !this_failed)
 521                         (void)printf("%s -> %s\n", curr->fts_path, to.p_path);
 522         }
 523         if (errno) {
 524                 err(EXIT_FAILURE, "fts_read");
 525                 /* NOTREACHED */
 526         }
 527         (void)fts_close(ftsp);
 528         return (any_failed);
 529 }