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 <pwd.h>
  65 #include <grp.h>
  66 #include "get_compat.h"
  67 #else
  68 #define COMPAT_MODE(func, mode) 1
  69 #endif
  70
  71 int dflag, eval, fflag, iflag, Pflag, vflag, Wflag, stdin_ok;
  72 uid_t uid;
  73
  74 int     check __P((char *, char *, struct stat *));
  75 int checkdir __P((char *));
  76 int             yes_or_no __P((void));
  77 void    checkdot __P((char **));
  78 void    rm_file __P((char **));
  79 void    rm_overwrite __P((char *, struct stat *));
  80 void    rm_tree __P((char **));
  81 void    usage __P((void));
  82
  83 /*
  84  * rm --
  85  *      This rm is different from historic rm's, but is expected to match
  86  *      POSIX 1003.2 behavior.  The most visible difference is that -f
  87  *      has two specific effects now, ignore non-existent files and force
  88  *      file removal.
  89  */
  90 int
  91 main(argc, argv)
  92         int argc;
  93         char *argv[];
  94 {
  95         int ch, rflag;
  96         char *p;
  97
  98         if (argc < 1)
  99                 usage();
 100
 101         /*
 102          * Test for the special case where the utility is called as
 103          * "unlink", for which the functionality provided is greatly
 104          * simplified.
 105          */
 106         if ((p = rindex(argv[0], '/')) == NULL)
 107                 p = argv[0];
 108         else
 109                 ++p;
 110         if (strcmp(p, "unlink") == 0) {
 111                 if (argc == 2) {
 112                         rm_file(&argv[1]);
 113                         exit(eval);
 114                 } else
 115                         usage();
 116         }
 117
 118         Pflag = rflag = 0;
 119         while ((ch = getopt(argc, argv, "dfiPRrvW")) != -1)
 120                 switch(ch) {
 121                 case 'd':
 122                         dflag = 1;
 123                         break;
 124                 case 'f':
 125                         fflag = 1;
 126                         iflag = 0;
 127                         break;
 128                 case 'i':
 129                         fflag = 0;
 130                         iflag = 1;
 131                         break;
 132                 case 'P':
 133                         Pflag = 1;
 134                         break;
 135                 case 'R':
 136                 case 'r':                       /* Compatibility. */
 137                         rflag = 1;
 138                         break;
 139                 case 'v':
 140                         vflag = 1;
 141                         break;
 142                 case 'W':
 143                         Wflag = 1;
 144                         break;
 145                 default:
 146                         usage();
 147                 }
 148         argc -= optind;
 149         argv += optind;
 150
 151         if (argc < 1) {
 152                 if (fflag)
 153                         return 0;
 154                 usage();
 155         }
 156
 157         checkdot(argv);
 158         uid = geteuid();
 159
 160         if (*argv) {
 161                 stdin_ok = isatty(STDIN_FILENO);
 162
 163                 if (rflag)
 164                         rm_tree(argv);
 165                 else
 166                         rm_file(argv);
 167         }
 168
 169         exit (eval);
 170 }
 171
 172 void
 173 rm_tree(argv)
 174         char **argv;
 175 {
 176         FTS *fts;
 177         FTSENT *p;
 178         int needstat;
 179         int flags;
 180         int rval;
 181         int wantConformance = COMPAT_MODE("bin/rm", "unix2003");
 182         /*
 183          * Remove a file hierarchy.  If forcing removal (-f), or interactive
 184          * (-i) or can't ask anyway (stdin_ok), don't stat the file.
 185          */
 186         needstat = !uid || (!fflag && !iflag && stdin_ok);
 187
 188         /*
 189          * If the -i option is specified, the user can skip on the pre-order
 190          * visit.  The fts_number field flags skipped directories.
 191          */
 192 #define SKIPPED 1
 193
 194         flags = FTS_PHYSICAL;
 195         if (!needstat)
 196                 flags |= FTS_NOSTAT;
 197         if (Wflag)
 198                 flags |= FTS_WHITEOUT;
 199         if (!(fts = fts_open(argv, flags, NULL))) {
 200                 if (fflag && errno == ENOENT)
 201                         return;
 202                 err(1, NULL);
 203         }
 204         while ((p = fts_read(fts)) != NULL) {
 205                 switch (p->fts_info) {
 206                 case FTS_DNR:
 207                         if (!fflag || p->fts_errno != ENOENT) {
 208                                 warnx("%s: %s",
 209                                     p->fts_path, strerror(p->fts_errno));
 210                                 eval = 1;
 211                         }
 212                         continue;
 213                 case FTS_ERR:
 214                         errx(1, "%s: %s", p->fts_path, strerror(p->fts_errno));
 215                 case FTS_NS:
 216                         /*
 217                          * FTS_NS: assume that if can't stat the file, it
 218                          * can't be unlinked.
 219                          */
 220                         if (!needstat)
 221                                 break;
 222                         if (!fflag || p->fts_errno != ENOENT) {
 223                                 warnx("%s: %s",
 224                                     p->fts_path, strerror(p->fts_errno));
 225                                 eval = 1;
 226                         }
 227                         continue;
 228                 case FTS_D:
 229                         /* Pre-order: give user chance to skip. */
 230                         /* In conformance mode the user is prompted to skip processing the contents.
 231                          * Then the option to delete the dir is presented post-order */
 232                         if (!fflag &&
 233                                         ( (wantConformance && !checkdir(p->fts_path)) ||
 234                                           (!wantConformance && !check(p->fts_path, p->fts_accpath, p->fts_statp))
 235                                         )
 236                            ){
 237                                 (void)fts_set(fts, p, FTS_SKIP);
 238                                 p->fts_number = SKIPPED;
 239                         }
 240                         else if (!uid &&
 241                                  (p->fts_statp->st_flags & (UF_APPEND|UF_IMMUTABLE)) &&
 242                                  !(p->fts_statp->st_flags & (SF_APPEND|SF_IMMUTABLE)) &&
 243                                  chflags(p->fts_accpath,
 244                                          p->fts_statp->st_flags &= ~(UF_APPEND|UF_IMMUTABLE)) < 0)
 245                                 goto err;
 246                         continue;
 247                 case FTS_DP:
 248                         /* Post-order: see if user skipped. */
 249                         if(p->fts_number == SKIPPED)/*in legacy mode, the user was prompted pre-order */
 250                                 continue;
 251                         else if(wantConformance)
 252                         {
 253                                 /* delete directory if force is on, or if user answers Y to prompt */
 254                                 if(fflag || check(p->fts_path, p->fts_accpath, p->fts_statp))
 255                                         break;
 256                                 else
 257                                         continue;
 258                         }
 259                         break;
 260                 default:
 261                         if (!fflag &&
 262                             !check(p->fts_path, p->fts_accpath, p->fts_statp))
 263                                 continue;
 264                 }
 265
 266                 rval = 0;
 267                 if (!uid &&
 268                     (p->fts_statp->st_flags & (UF_APPEND|UF_IMMUTABLE)) &&
 269                     !(p->fts_statp->st_flags & (SF_APPEND|SF_IMMUTABLE)))
 270                         rval = chflags(p->fts_accpath,
 271                                        p->fts_statp->st_flags &= ~(UF_APPEND|UF_IMMUTABLE));
 272                 if (rval == 0) {
 273                         /*
 274                          * If we can't read or search the directory, may still be
 275                          * able to remove it.  Don't print out the un{read,search}able
 276                          * message unless the remove fails.
 277                          */
 278                         switch (p->fts_info) {
 279                         case FTS_DP:
 280                         case FTS_DNR:
 281                                 rval = rmdir(p->fts_accpath);
 282                                 if (rval == 0 || (fflag && errno == ENOENT)) {
 283                                         if (rval == 0 && vflag)
 284                                                 (void)printf("%s\n",
 285                                                     p->fts_path);
 286                                         continue;
 287                                 }
 288                                 break;
 289
 290                         case FTS_W:
 291                                 rval = undelete(p->fts_accpath);
 292                                 if (rval == 0 && (fflag && errno == ENOENT)) {
 293                                         if (vflag)
 294                                                 (void)printf("%s\n",
 295                                                     p->fts_path);
 296                                         continue;
 297                                 }
 298                                 break;
 299
 300                         default:
 301                                 if (Pflag)
 302                                         rm_overwrite(p->fts_accpath, NULL);
 303                                 rval = unlink(p->fts_accpath);
 304                                 if (rval == 0 || (fflag && errno == ENOENT)) {
 305                                         if (rval == 0 && vflag)
 306                                                 (void)printf("%s\n",
 307                                                     p->fts_path);
 308                                         continue;
 309                                 }
 310                         }
 311                 }
 312 err:
 313                 warn("%s", p->fts_path);
 314                 eval = 1;
 315         }
 316         if (errno)
 317                 err(1, "fts_read");
 318         fts_close(fts);
 319 }
 320
 321 void
 322 rm_file(argv)
 323         char **argv;
 324 {
 325         struct stat sb;
 326         int rval;
 327         char *f;
 328
 329         /*
 330          * Remove a file.  POSIX 1003.2 states that, by default, attempting
 331          * to remove a directory is an error, so must always stat the file.
 332          */
 333         while ((f = *argv++) != NULL) {
 334                 /* Assume if can't stat the file, can't unlink it. */
 335                 if (lstat(f, &sb)) {
 336                         if (Wflag) {
 337                                 sb.st_mode = S_IFWHT|S_IWUSR|S_IRUSR;
 338                         } else {
 339                                 if (!fflag || errno != ENOENT) {
 340                                         warn("%s", f);
 341                                         eval = 1;
 342                                 }
 343                                 continue;
 344                         }
 345                 } else if (Wflag) {
 346                         warnx("%s: %s", f, strerror(EEXIST));
 347                         eval = 1;
 348                         continue;
 349                 }
 350
 351                 if (S_ISDIR(sb.st_mode) && !dflag) {
 352                         warnx("%s: is a directory", f);
 353                         eval = 1;
 354                         continue;
 355                 }
 356                 if (!fflag && !S_ISWHT(sb.st_mode) && !check(f, f, &sb))
 357                         continue;
 358                 rval = 0;
 359                 if (!uid &&
 360                     (sb.st_flags & (UF_APPEND|UF_IMMUTABLE)) &&
 361                     !(sb.st_flags & (SF_APPEND|SF_IMMUTABLE)))
 362                         rval = chflags(f, sb.st_flags & ~(UF_APPEND|UF_IMMUTABLE));
 363                 if (rval == 0) {
 364                         if (S_ISWHT(sb.st_mode))
 365                                 rval = undelete(f);
 366                         else if (S_ISDIR(sb.st_mode))
 367                                 rval = rmdir(f);
 368                         else {
 369                                 if (Pflag)
 370                                         rm_overwrite(f, &sb);
 371                                 rval = unlink(f);
 372                         }
 373                 }
 374                 if (rval && (!fflag || errno != ENOENT)) {
 375                         warn("%s", f);
 376                         eval = 1;
 377                 }
 378                 if (vflag && rval == 0)
 379                         (void)printf("%s\n", f);
 380         }
 381 }
 382
 383 /*
 384  * rm_overwrite --
 385  *      Overwrite the file 3 times with varying bit patterns.
 386  *
 387  * XXX
 388  * This is a cheap way to *really* delete files.  Note that only regular
 389  * files are deleted, directories (and therefore names) will remain.
 390  * Also, this assumes a fixed-block file system (like FFS, or a V7 or a
 391  * System V file system).  In a logging file system, you'll have to have
 392  * kernel support.
 393  */
 394 void
 395 rm_overwrite(file, sbp)
 396         char *file;
 397         struct stat *sbp;
 398 {
 399         struct stat sb;
 400         struct statfs fsb;
 401         off_t len;
 402         int bsize, fd, wlen;
 403         char *buf = NULL;
 404
 405         fd = -1;
 406         if (sbp == NULL) {
 407                 if (lstat(file, &sb))
 408                         goto err;
 409                 sbp = &sb;
 410         }
 411         if (!S_ISREG(sbp->st_mode))
 412                 return;
 413         if ((fd = open(file, O_WRONLY, 0)) == -1)
 414                 goto err;
 415         if (fstatfs(fd, &fsb) == -1)
 416                 goto err;
 417         bsize = MAX(fsb.f_iosize, 1024);
 418         if ((buf = malloc(bsize)) == NULL)
 419                 err(1, "malloc");
 420
 421 #define PASS(byte) {                                                    \
 422         memset(buf, byte, bsize);                                       \
 423         for (len = sbp->st_size; len > 0; len -= wlen) {                \
 424                 wlen = len < bsize ? len : bsize;                       \
 425                 if (write(fd, buf, wlen) != wlen)                       \
 426                         goto err;                                       \
 427         }                                                               \
 428 }
 429         PASS(0xff);
 430         if (fsync(fd) || lseek(fd, (off_t)0, SEEK_SET))
 431                 goto err;
 432         PASS(0x00);
 433         if (fsync(fd) || lseek(fd, (off_t)0, SEEK_SET))
 434                 goto err;
 435         PASS(0xff);
 436         if (!fsync(fd) && !close(fd)) {
 437                 free(buf);
 438                 return;
 439         }
 440
 441 err:    eval = 1;
 442         if (buf)
 443                 free(buf);
 444         warn("%s", file);
 445 }
 446
 447 int
 448 yes_or_no()
 449 {
 450         int ch, first;
 451         (void)fflush(stderr);
 452
 453         first = ch = getchar();
 454         while (ch != '\n' && ch != EOF)
 455                 ch = getchar();
 456         return (first == 'y' || first == 'Y');
 457 }
 458
 459 int
 460 checkdir(path)
 461         char *path;
 462 {
 463         if(!iflag)
 464                 return 1;       //if not interactive, process directory's contents
 465         (void)fprintf(stderr, "examine files in directory %s? ", path);
 466         return yes_or_no();
 467 }
 468
 469 int
 470 check(path, name, sp)
 471         char *path, *name;
 472         struct stat *sp;
 473 {
 474         char modep[15], *flagsp;
 475
 476         /* Check -i first. */
 477         if (iflag)
 478                 (void)fprintf(stderr, "remove %s? ", path);
 479         else {
 480                 /*
 481                  * If it's not a symbolic link and it's unwritable and we're
 482                  * talking to a terminal, ask.  Symbolic links are excluded
 483                  * because their permissions are meaningless.  Check stdin_ok
 484                  * first because we may not have stat'ed the file.
 485                  */
 486                 if (!stdin_ok || S_ISLNK(sp->st_mode) ||
 487                     (!access(name, W_OK) &&
 488                     !(sp->st_flags & (SF_APPEND|SF_IMMUTABLE)) &&
 489                     (!(sp->st_flags & (UF_APPEND|UF_IMMUTABLE)) || !uid)))
 490                         return (1);
 491                 strmode(sp->st_mode, modep);
 492                 if ((flagsp = fflagstostr(sp->st_flags)) == NULL)
 493                         err(1, NULL);
 494                 (void)fprintf(stderr, "override %s%s%s/%s %s%sfor %s? ",
 495                     modep + 1, modep[9] == ' ' ? "" : " ",
 496                     user_from_uid(sp->st_uid, 0),
 497                     group_from_gid(sp->st_gid, 0),
 498                     *flagsp ? flagsp : "", *flagsp ? " " : "",
 499                     path);
 500                 free(flagsp);
 501         }
 502         return yes_or_no();
 503 }
 504
 505
 506 #define ISDOT(a)        ((a)[0] == '.' && (!(a)[1] || ((a)[1] == '.' && !(a)[2])))
 507 void
 508 checkdot(argv)
 509         char **argv;
 510 {
 511         char *p, **save, **t;
 512         int complained;
 513
 514         complained = 0;
 515         for (t = argv; *t;) {
 516                 if ((p = strrchr(*t, '/')) != NULL)
 517                         ++p;
 518                 else
 519                         p = *t;
 520                 if (ISDOT(p)) {
 521                         if (!complained++)
 522                                 warnx("\".\" and \"..\" may not be removed");
 523                         eval = 1;
 524                         for (save = t; (t[0] = t[1]) != NULL; ++t)
 525                                 continue;
 526                         t = save;
 527                 } else
 528                         ++t;
 529         }
 530 }
 531
 532 void
 533 usage()
 534 {
 535
 536         (void)fprintf(stderr, "%s\n%s\n",
 537             "usage: rm [-f | -i] [-dPRrvW] file ...",
 538             "       unlink file");
 539         exit(EX_USAGE);
 540 }