rm/rm.c

   1 /*-
   2  * Copyright (c) 1990, 1993, 1994
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #ifndef lint
  35 static const char copyright[] =
  36 "@(#) Copyright (c) 1990, 1993, 1994\n\
  37         The Regents of the University of California.  All rights reserved.\n";
  38 #endif /* not lint */
  39
  40 #ifndef lint
  41 #if 0
  42 static char sccsid[] = "@(#)rm.c        8.5 (Berkeley) 4/18/94";
  43 #else
  44 static const char rcsid[] =
  45   "$FreeBSD: src/bin/rm/rm.c,v 1.33 2001/06/13 15:01:25 ru Exp $";
  46 #endif
  47 #endif /* not lint */
  48
  49 #include <sys/stat.h>
  50 #include <sys/param.h>
  51 #include <sys/mount.h>
  52
  53 #include <err.h>
  54 #include <errno.h>
  55 #include <fcntl.h>
  56 #include <fts.h>
  57 #include <stdio.h>
  58 #include <stdlib.h>
  59 #include <string.h>
  60 #include <sysexits.h>
  61 #include <unistd.h>
  62
  63 #ifdef __APPLE__
  64 #include <removefile.h>
  65 #include <pwd.h>
  66 #include <grp.h>
  67 #include "get_compat.h"
  68 #else
  69 #define COMPAT_MODE(func, mode) 1
  70 #endif
  71
  72 int dflag, eval, fflag, iflag, Pflag, vflag, Wflag, stdin_ok;
  73 uid_t uid;
  74
  75 int     check __P((char *, char *, struct stat *));
  76 int checkdir __P((char *));
  77 int             yes_or_no __P((void));
  78 void    checkdot __P((char **));
  79 void    rm_file __P((char **));
  80 void    rm_overwrite __P((char *, struct stat *));
  81 void    rm_tree __P((char **));
  82 void    usage __P((void));
  83
  84 /*
  85  * rm --
  86  *      This rm is different from historic rm's, but is expected to match
  87  *      POSIX 1003.2 behavior.  The most visible difference is that -f
  88  *      has two specific effects now, ignore non-existent files and force
  89  *      file removal.
  90  */
  91 int
  92 main(argc, argv)
  93         int argc;
  94         char *argv[];
  95 {
  96         int ch, rflag;
  97         char *p;
  98
  99         if (argc < 1)
 100                 usage();
 101
 102         /*
 103          * Test for the special case where the utility is called as
 104          * "unlink", for which the functionality provided is greatly
 105          * simplified.
 106          */
 107         if ((p = rindex(argv[0], '/')) == NULL)
 108                 p = argv[0];
 109         else
 110                 ++p;
 111         uid = geteuid();
 112         if (strcmp(p, "unlink") == 0) {
 113                 if (argc == 2) {
 114                         rm_file(&argv[1]);
 115                         exit(eval);
 116                 } else
 117                         usage();
 118         }
 119
 120         Pflag = rflag = 0;
 121         while ((ch = getopt(argc, argv, "dfiPRrvW")) != -1)
 122                 switch(ch) {
 123                 case 'd':
 124                         dflag = 1;
 125                         break;
 126                 case 'f':
 127                         fflag = 1;
 128                         iflag = 0;
 129                         break;
 130                 case 'i':
 131                         fflag = 0;
 132                         iflag = 1;
 133                         break;
 134                 case 'P':
 135                         Pflag = 1;
 136                         break;
 137                 case 'R':
 138                 case 'r':                       /* Compatibility. */
 139                         rflag = 1;
 140                         break;
 141                 case 'v':
 142                         vflag = 1;
 143                         break;
 144                 case 'W':
 145                         Wflag = 1;
 146                         break;
 147                 default:
 148                         usage();
 149                 }
 150         argc -= optind;
 151         argv += optind;
 152
 153         if (argc < 1) {
 154                 if (fflag)
 155                         return 0;
 156                 usage();
 157         }
 158
 159         checkdot(argv);
 160
 161         if (*argv) {
 162                 stdin_ok = isatty(STDIN_FILENO);
 163
 164                 if (rflag)
 165                         rm_tree(argv);
 166                 else
 167                         rm_file(argv);
 168         }
 169
 170         exit (eval);
 171 }
 172
 173 void
 174 rm_tree(argv)
 175         char **argv;
 176 {
 177         FTS *fts;
 178         FTSENT *p;
 179         int needstat;
 180         int flags;
 181         int rval;
 182         int wantConformance = COMPAT_MODE("bin/rm", "unix2003");
 183         /*
 184          * Remove a file hierarchy.  If forcing removal (-f), or interactive
 185          * (-i) or can't ask anyway (stdin_ok), don't stat the file.
 186          */
 187         needstat = !uid || (!fflag && !iflag && stdin_ok);
 188
 189         /*
 190          * If the -i option is specified, the user can skip on the pre-order
 191          * visit.  The fts_number field flags skipped directories.
 192          */
 193 #define SKIPPED 1
 194
 195         flags = FTS_PHYSICAL;
 196         if (!needstat)
 197                 flags |= FTS_NOSTAT;
 198         if (Wflag)
 199                 flags |= FTS_WHITEOUT;
 200         if (!(fts = fts_open(argv, flags, NULL))) {
 201                 if (fflag && errno == ENOENT)
 202                         return;
 203                 err(1, NULL);
 204         }
 205         while ((p = fts_read(fts)) != NULL) {
 206                 switch (p->fts_info) {
 207                 case FTS_DNR:
 208                         if (!fflag || p->fts_errno != ENOENT) {
 209                                 warnx("%s: %s",
 210                                     p->fts_path, strerror(p->fts_errno));
 211                                 eval = 1;
 212                         }
 213                         continue;
 214                 case FTS_ERR:
 215                         errx(1, "%s: %s", p->fts_path, strerror(p->fts_errno));
 216                 case FTS_NS:
 217                         /*
 218                          * FTS_NS: assume that if can't stat the file, it
 219                          * can't be unlinked.
 220                          */
 221                         if (!needstat)
 222                                 break;
 223                         if (!fflag || p->fts_errno != ENOENT) {
 224                                 warnx("%s: %s",
 225                                     p->fts_path, strerror(p->fts_errno));
 226                                 eval = 1;
 227                         }
 228                         continue;
 229                 case FTS_D:
 230                         /* Pre-order: give user chance to skip. */
 231                         /* In conformance mode the user is prompted to skip processing the contents.
 232                          * Then the option to delete the dir is presented post-order */
 233                         if (!fflag &&
 234                                         ( (wantConformance && !checkdir(p->fts_path)) ||
 235                                           (!wantConformance && !check(p->fts_path, p->fts_accpath, p->fts_statp))
 236                                         )
 237                            ){
 238                                 (void)fts_set(fts, p, FTS_SKIP);
 239                                 p->fts_number = SKIPPED;
 240                         }
 241                         else if (!uid &&
 242                                  (p->fts_statp->st_flags & (UF_APPEND|UF_IMMUTABLE)) &&
 243                                  !(p->fts_statp->st_flags & (SF_APPEND|SF_IMMUTABLE)) &&
 244                                  chflags(p->fts_accpath,
 245                                          p->fts_statp->st_flags &= ~(UF_APPEND|UF_IMMUTABLE)) < 0)
 246                                 goto err;
 247                         continue;
 248                 case FTS_DP:
 249                         /* Post-order: see if user skipped. */
 250                         if(p->fts_number == SKIPPED)/*in legacy mode, the user was prompted pre-order */
 251                                 continue;
 252                         else if(wantConformance)
 253                         {
 254                                 /* delete directory if force is on, or if user answers Y to prompt */
 255                                 if(fflag || check(p->fts_path, p->fts_accpath, p->fts_statp))
 256                                         break;
 257                                 else
 258                                         continue;
 259                         }
 260                         break;
 261                 default:
 262                         if (!fflag &&
 263                             !check(p->fts_path, p->fts_accpath, p->fts_statp))
 264                                 continue;
 265                 }
 266
 267                 rval = 0;
 268                 if (!uid &&
 269                     (p->fts_statp->st_flags & (UF_APPEND|UF_IMMUTABLE)) &&
 270                     !(p->fts_statp->st_flags & (SF_APPEND|SF_IMMUTABLE)))
 271                         rval = chflags(p->fts_accpath,
 272                                        p->fts_statp->st_flags &= ~(UF_APPEND|UF_IMMUTABLE));
 273                 if (rval == 0) {
 274                         /*
 275                          * If we can't read or search the directory, may still be
 276                          * able to remove it.  Don't print out the un{read,search}able
 277                          * message unless the remove fails.
 278                          */
 279                         switch (p->fts_info) {
 280                         case FTS_DP:
 281                         case FTS_DNR:
 282                                 rval = rmdir(p->fts_accpath);
 283                                 if (rval == 0 || (fflag && errno == ENOENT)) {
 284                                         if (rval == 0 && vflag)
 285                                                 (void)printf("%s\n",
 286                                                     p->fts_path);
 287                                         continue;
 288                                 }
 289                                 break;
 290
 291                         case FTS_W:
 292                                 rval = undelete(p->fts_accpath);
 293                                 if (rval == 0 && (fflag && errno == ENOENT)) {
 294                                         if (vflag)
 295                                                 (void)printf("%s\n",
 296                                                     p->fts_path);
 297                                         continue;
 298                                 }
 299                                 break;
 300
 301                         default:
 302 #ifdef __APPLE__
 303                                 if (Pflag) {
 304                                         if (removefile(p->fts_accpath, NULL, REMOVEFILE_SECURE_7_PASS)) /* overwrites and unlinks */
 305                                                 eval = rval = 1;
 306                                 } else
 307                                         rval = unlink(p->fts_accpath);
 308 #else  /* !__APPLE_ */
 309                                 if (Pflag)
 310                                         rm_overwrite(p->fts_accpath, NULL);
 311                                 rval = unlink(p->fts_accpath);
 312 #endif  /* __APPLE__ */
 313                                 if (rval == 0 || (fflag && errno == ENOENT)) {
 314                                         if (rval == 0 && vflag)
 315                                                 (void)printf("%s\n",
 316                                                     p->fts_path);
 317                                         continue;
 318                                 }
 319                         }
 320                 }
 321 err:
 322                 warn("%s", p->fts_path);
 323                 eval = 1;
 324         }
 325         if (errno)
 326                 err(1, "fts_read");
 327         fts_close(fts);
 328 }
 329
 330 void
 331 rm_file(argv)
 332         char **argv;
 333 {
 334         struct stat sb;
 335         int rval;
 336         char *f;
 337
 338         /*
 339          * Remove a file.  POSIX 1003.2 states that, by default, attempting
 340          * to remove a directory is an error, so must always stat the file.
 341          */
 342         while ((f = *argv++) != NULL) {
 343                 /* Assume if can't stat the file, can't unlink it. */
 344                 if (lstat(f, &sb)) {
 345                         if (Wflag) {
 346                                 sb.st_mode = S_IFWHT|S_IWUSR|S_IRUSR;
 347                         } else {
 348                                 if (!fflag || errno != ENOENT) {
 349                                         warn("%s", f);
 350                                         eval = 1;
 351                                 }
 352                                 continue;
 353                         }
 354                 } else if (Wflag) {
 355                         warnx("%s: %s", f, strerror(EEXIST));
 356                         eval = 1;
 357                         continue;
 358                 }
 359
 360                 if (S_ISDIR(sb.st_mode) && !dflag) {
 361                         warnx("%s: is a directory", f);
 362                         eval = 1;
 363                         continue;
 364                 }
 365                 if (!fflag && !S_ISWHT(sb.st_mode) && !check(f, f, &sb))
 366                         continue;
 367                 rval = 0;
 368                 if (!uid &&
 369                     (sb.st_flags & (UF_APPEND|UF_IMMUTABLE)) &&
 370                     !(sb.st_flags & (SF_APPEND|SF_IMMUTABLE)))
 371                         rval = chflags(f, sb.st_flags & ~(UF_APPEND|UF_IMMUTABLE));
 372                 if (rval == 0) {
 373                         if (S_ISWHT(sb.st_mode))
 374                                 rval = undelete(f);
 375                         else if (S_ISDIR(sb.st_mode))
 376                                 rval = rmdir(f);
 377                         else {
 378 #ifdef __APPLE__
 379                                 if (Pflag) {
 380                                         if (removefile(f, NULL, REMOVEFILE_SECURE_7_PASS)) /* overwrites and unlinks */
 381                                                 eval = rval = 1;
 382                                 } else
 383                                         rval = unlink(f);
 384 #else  /* !__APPLE__ */
 385                                 if (Pflag)
 386                                         rm_overwrite(f, &sb);
 387                                 rval = unlink(f);
 388 #endif  /* __APPLE__ */
 389                         }
 390                 }
 391                 if (rval && (!fflag || errno != ENOENT)) {
 392                         warn("%s", f);
 393                         eval = 1;
 394                 }
 395                 if (vflag && rval == 0)
 396                         (void)printf("%s\n", f);
 397         }
 398 }
 399
 400 /*
 401  * rm_overwrite --
 402  *      Overwrite the file 3 times with varying bit patterns.
 403  *
 404  * XXX
 405  * This is a cheap way to *really* delete files.  Note that only regular
 406  * files are deleted, directories (and therefore names) will remain.
 407  * Also, this assumes a fixed-block file system (like FFS, or a V7 or a
 408  * System V file system).  In a logging file system, you'll have to have
 409  * kernel support.
 410  */
 411 void
 412 rm_overwrite(file, sbp)
 413         char *file;
 414         struct stat *sbp;
 415 {
 416         struct stat sb;
 417         struct statfs fsb;
 418         off_t len;
 419         int bsize, fd, wlen;
 420         char *buf = NULL;
 421
 422         fd = -1;
 423         if (sbp == NULL) {
 424                 if (lstat(file, &sb))
 425                         goto err;
 426                 sbp = &sb;
 427         }
 428         if (!S_ISREG(sbp->st_mode))
 429                 return;
 430         if ((fd = open(file, O_WRONLY, 0)) == -1)
 431                 goto err;
 432         if (fstatfs(fd, &fsb) == -1)
 433                 goto err;
 434         bsize = MAX(fsb.f_iosize, 1024);
 435         if ((buf = malloc(bsize)) == NULL)
 436                 err(1, "malloc");
 437
 438 #define PASS(byte) {                                                    \
 439         memset(buf, byte, bsize);                                       \
 440         for (len = sbp->st_size; len > 0; len -= wlen) {                \
 441                 wlen = len < bsize ? len : bsize;                       \
 442                 if (write(fd, buf, wlen) != wlen)                       \
 443                         goto err;                                       \
 444         }                                                               \
 445 }
 446         PASS(0xff);
 447         if (fsync(fd) || lseek(fd, (off_t)0, SEEK_SET))
 448                 goto err;
 449         PASS(0x00);
 450         if (fsync(fd) || lseek(fd, (off_t)0, SEEK_SET))
 451                 goto err;
 452         PASS(0xff);
 453         if (!fsync(fd) && !close(fd)) {
 454                 free(buf);
 455                 return;
 456         }
 457
 458 err:    eval = 1;
 459         if (buf)
 460                 free(buf);
 461         warn("%s", file);
 462 }
 463
 464 int
 465 yes_or_no()
 466 {
 467         int ch, first;
 468         (void)fflush(stderr);
 469
 470         first = ch = getchar();
 471         while (ch != '\n' && ch != EOF)
 472                 ch = getchar();
 473         return (first == 'y' || first == 'Y');
 474 }
 475
 476 int
 477 checkdir(path)
 478         char *path;
 479 {
 480         if(!iflag)
 481                 return 1;       //if not interactive, process directory's contents
 482         (void)fprintf(stderr, "examine files in directory %s? ", path);
 483         return yes_or_no();
 484 }
 485
 486 int
 487 check(path, name, sp)
 488         char *path, *name;
 489         struct stat *sp;
 490 {
 491         char modep[15], *flagsp;
 492
 493         /* Check -i first. */
 494         if (iflag)
 495                 (void)fprintf(stderr, "remove %s? ", path);
 496         else {
 497                 /*
 498                  * If it's not a symbolic link and it's unwritable and we're
 499                  * talking to a terminal, ask.  Symbolic links are excluded
 500                  * because their permissions are meaningless.  Check stdin_ok
 501                  * first because we may not have stat'ed the file.
 502                  */
 503                 if (!stdin_ok || S_ISLNK(sp->st_mode) ||
 504                     (!access(name, W_OK) &&
 505                     !(sp->st_flags & (SF_APPEND|SF_IMMUTABLE)) &&
 506                     (!(sp->st_flags & (UF_APPEND|UF_IMMUTABLE)) || !uid)))
 507                         return (1);
 508                 strmode(sp->st_mode, modep);
 509                 if ((flagsp = fflagstostr(sp->st_flags)) == NULL)
 510                         err(1, NULL);
 511                 (void)fprintf(stderr, "override %s%s%s/%s %s%sfor %s? ",
 512                     modep + 1, modep[9] == ' ' ? "" : " ",
 513                     user_from_uid(sp->st_uid, 0),
 514                     group_from_gid(sp->st_gid, 0),
 515                     *flagsp ? flagsp : "", *flagsp ? " " : "",
 516                     path);
 517                 free(flagsp);
 518         }
 519         return yes_or_no();
 520 }
 521
 522
 523 #define ISDOT(a)        ((a)[0] == '.' && (!(a)[1] || ((a)[1] == '.' && !(a)[2])))
 524 void
 525 checkdot(argv)
 526         char **argv;
 527 {
 528         char *p, **save, **t;
 529         int complained;
 530
 531         complained = 0;
 532         for (t = argv; *t;) {
 533                 if ((p = strrchr(*t, '/')) != NULL)
 534                         ++p;
 535                 else
 536                         p = *t;
 537                 if (ISDOT(p)) {
 538                         if (!complained++)
 539                                 warnx("\".\" and \"..\" may not be removed");
 540                         eval = 1;
 541                         for (save = t; (t[0] = t[1]) != NULL; ++t)
 542                                 continue;
 543                         t = save;
 544                 } else
 545                         ++t;
 546         }
 547 }
 548
 549 void
 550 usage()
 551 {
 552
 553         (void)fprintf(stderr, "%s\n%s\n",
 554             "usage: rm [-f | -i] [-dPRrvW] file ...",
 555             "       unlink file");
 556         exit(EX_USAGE);
 557 }