/*- * Copyright (c) 1990, 1993, 1994 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #if 0 #ifndef lint static const char copyright[] = "@(#) Copyright (c) 1990, 1993, 1994\n\ The Regents of the University of California. All rights reserved.\n"; #endif /* not lint */ #ifndef lint static char sccsid[] = "@(#)rm.c 8.5 (Berkeley) 4/18/94"; #endif /* not lint */ #include //__FBSDID("$FreeBSD: src/bin/rm/rm.c,v 1.47 2004/04/06 20:06:50 markm Exp $"); #endif #include #ifndef _MSC_VER # include # include #endif #include "err.h" #include #include #include #include #include #include #include #include #include #include #include #include "getopt.h" #ifdef _MSC_VER # include "mscfakes.h" #endif #if defined(__OS2__) || defined(_MSC_VER) # include # include #endif #include "kmkbuiltin.h" #include "kbuild_protection.h" #if defined(__EMX__) || defined(_MSC_VER) # define IS_SLASH(ch) ( (ch) == '/' || (ch) == '\\' ) # define HAVE_DOS_PATHS 1 # define DEFAULT_PROTECTION_DEPTH 1 #else # define IS_SLASH(ch) ( (ch) == '/' ) # undef HAVE_DOS_PATHS # define DEFAULT_PROTECTION_DEPTH 2 #endif #ifdef __EMX__ #undef S_IFWHT #undef S_ISWHT #endif #ifndef S_IFWHT #define S_IFWHT 0 #define S_ISWHT(s) 0 #define undelete(s) (-1) #endif #if !defined(__FreeBSD__) && !defined(__APPLE__) extern void strmode(mode_t mode, char *p); #endif static int dflag, eval, fflag, iflag, Pflag, vflag, Wflag, stdin_ok; static uid_t uid; static char *argv0; static KBUILDPROTECTION g_ProtData; static struct option long_options[] = { { "help", no_argument, 0, 261 }, { "version", no_argument, 0, 262 }, { "disable-protection", no_argument, 0, 263 }, { "enable-protection", no_argument, 0, 264 }, { "enable-full-protection", no_argument, 0, 265 }, { "disable-full-protection", no_argument, 0, 266 }, { "protection-depth", required_argument, 0, 267 }, { 0, 0, 0, 0 }, }; static int check(char *, char *, struct stat *); static void checkdot(char **); static int rm_file(char **); static int rm_overwrite(char *, struct stat *); static int rm_tree(char **); static int count_path_components(const char *); static int usage(FILE *); /* * rm -- * This rm is different from historic rm's, but is expected to match * POSIX 1003.2 behavior. The most visible difference is that -f * has two specific effects now, ignore non-existent files and force * file removal. */ int kmk_builtin_rm(int argc, char *argv[], char **envp) { int ch, rflag; int i; /* reinitialize globals */ argv0 = argv[0]; dflag = eval = fflag = iflag = Pflag = vflag = Wflag = stdin_ok = 0; uid = 0; kBuildProtectionInit(&g_ProtData); /* kmk: reset getopt and set program name. */ g_progname = argv[0]; opterr = 1; optarg = NULL; optopt = 0; optind = 0; /* init */ Pflag = rflag = 0; while ((ch = getopt_long(argc, argv, "dfiPRvW", long_options, NULL)) != -1) switch(ch) { case 'd': dflag = 1; break; case 'f': fflag = 1; iflag = 0; break; case 'i': fflag = 0; iflag = 1; break; case 'P': Pflag = 1; break; case 'R': #if 0 case 'r': /* Compatibility. */ #endif rflag = 1; break; case 'v': vflag = 1; break; #ifdef FTS_WHITEOUT case 'W': Wflag = 1; break; #endif case 261: kBuildProtectionTerm(&g_ProtData); usage(stdout); return 0; case 262: kBuildProtectionTerm(&g_ProtData); return kbuild_version(argv[0]); case 263: kBuildProtectionDisable(&g_ProtData, KBUILDPROTECTIONTYPE_RECURSIVE); break; case 264: kBuildProtectionEnable(&g_ProtData, KBUILDPROTECTIONTYPE_RECURSIVE); break; case 265: kBuildProtectionEnable(&g_ProtData, KBUILDPROTECTIONTYPE_FULL); break; case 266: kBuildProtectionDisable(&g_ProtData, KBUILDPROTECTIONTYPE_FULL); break; case 267: if (kBuildProtectionSetDepth(&g_ProtData, optarg)) { kBuildProtectionTerm(&g_ProtData); return 1; } break; case '?': default: kBuildProtectionTerm(&g_ProtData); return usage(stderr); } argc -= optind; argv += optind; if (argc < 1) { kBuildProtectionTerm(&g_ProtData); if (fflag) return (0); return usage(stderr); } if (!kBuildProtectionScanEnv(&g_ProtData, envp, "KMK_RM_")) { checkdot(argv); uid = geteuid(); if (*argv) { stdin_ok = isatty(STDIN_FILENO); if (rflag) eval |= rm_tree(argv); else eval |= rm_file(argv); } } else { eval = 1; } kBuildProtectionTerm(&g_ProtData); return eval; } static int rm_tree(char **argv) { FTS *fts; FTSENT *p; int needstat; int flags; int rval; /* * Check up front before anything is deleted. This will not catch * everything, but we'll check the individual items later. */ int i; for (i = 0; argv[i]; i++) { if (kBuildProtectionEnforce(&g_ProtData, KBUILDPROTECTIONTYPE_RECURSIVE, argv[i])) { return 1; } } /* * Remove a file hierarchy. If forcing removal (-f), or interactive * (-i) or can't ask anyway (stdin_ok), don't stat the file. */ needstat = !uid || (!fflag && !iflag && stdin_ok); /* * If the -i option is specified, the user can skip on the pre-order * visit. The fts_number field flags skipped directories. */ #define SKIPPED 1 flags = FTS_PHYSICAL; if (!needstat) flags |= FTS_NOSTAT; #ifdef FTS_WHITEOUT if (Wflag) flags |= FTS_WHITEOUT; #endif if (!(fts = fts_open(argv, flags, NULL))) { return err(1, "fts_open"); } while ((p = fts_read(fts)) != NULL) { switch (p->fts_info) { case FTS_DNR: if (!fflag || p->fts_errno != ENOENT) { fprintf(stderr, "%s: %s: %s\n", argv0, p->fts_path, strerror(p->fts_errno)); eval = 1; } continue; case FTS_ERR: fts_close(fts); return errx(1, "%s: %s", p->fts_path, strerror(p->fts_errno)); case FTS_NS: /* * Assume that since fts_read() couldn't stat the * file, it can't be unlinked. */ if (!needstat) break; if (!fflag || p->fts_errno != ENOENT) { fprintf(stderr, "%s: %s: %s\n", argv0, p->fts_path, strerror(p->fts_errno)); eval = 1; } continue; case FTS_D: /* Pre-order: give user chance to skip. */ if (!fflag && !check(p->fts_path, p->fts_accpath, p->fts_statp)) { (void)fts_set(fts, p, FTS_SKIP); p->fts_number = SKIPPED; } #ifdef UF_APPEND else if (!uid && (p->fts_statp->st_flags & (UF_APPEND|UF_IMMUTABLE)) && !(p->fts_statp->st_flags & (SF_APPEND|SF_IMMUTABLE)) && chflags(p->fts_accpath, p->fts_statp->st_flags &= ~(UF_APPEND|UF_IMMUTABLE)) < 0) goto err; #endif continue; case FTS_DP: /* Post-order: see if user skipped. */ if (p->fts_number == SKIPPED) continue; break; default: if (!fflag && !check(p->fts_path, p->fts_accpath, p->fts_statp)) continue; } /* * Protect against deleting root files and directories. */ if (kBuildProtectionEnforce(&g_ProtData, KBUILDPROTECTIONTYPE_RECURSIVE, p->fts_accpath)) { fts_close(fts); return 1; } rval = 0; #ifdef UF_APPEND if (!uid && (p->fts_statp->st_flags & (UF_APPEND|UF_IMMUTABLE)) && !(p->fts_statp->st_flags & (SF_APPEND|SF_IMMUTABLE))) rval = chflags(p->fts_accpath, p->fts_statp->st_flags &= ~(UF_APPEND|UF_IMMUTABLE)); #endif if (rval == 0) { /* * If we can't read or search the directory, may still be * able to remove it. Don't print out the un{read,search}able * message unless the remove fails. */ switch (p->fts_info) { case FTS_DP: case FTS_DNR: rval = rmdir(p->fts_accpath); if (rval == 0 || (fflag && errno == ENOENT)) { if (rval == 0 && vflag) (void)printf("%s\n", p->fts_path); continue; } break; #ifdef FTS_W case FTS_W: rval = undelete(p->fts_accpath); if (rval == 0 && (fflag && errno == ENOENT)) { if (vflag) (void)printf("%s\n", p->fts_path); continue; } break; #endif case FTS_NS: /* * Assume that since fts_read() couldn't stat * the file, it can't be unlinked. */ if (fflag) continue; /* FALLTHROUGH */ default: if (Pflag) if (!rm_overwrite(p->fts_accpath, NULL)) continue; rval = unlink(p->fts_accpath); #ifdef _MSC_VER if (rval != 0) { chmod(p->fts_accpath, 0777); rval = unlink(p->fts_accpath); } #endif if (rval == 0 || (fflag && errno == ENOENT)) { if (rval == 0 && vflag) (void)printf("%s\n", p->fts_path); continue; } } } #ifdef UF_APPEND err: #endif fprintf(stderr, "%s: %s: %s\n", argv0, p->fts_path, strerror(errno)); eval = 1; } if (errno) { fprintf(stderr, "%s: fts_read: %s\n", argv0, strerror(errno)); eval = 1; } fts_close(fts); return eval; } static int rm_file(char **argv) { struct stat sb; int rval; char *f; /* * Check up front before anything is deleted. */ int i; for (i = 0; argv[i]; i++) { if (kBuildProtectionEnforce(&g_ProtData, KBUILDPROTECTIONTYPE_FULL, argv[i])) return 1; } /* * Remove a file. POSIX 1003.2 states that, by default, attempting * to remove a directory is an error, so must always stat the file. */ while ((f = *argv++) != NULL) { /* Assume if can't stat the file, can't unlink it. */ if (lstat(f, &sb)) { #ifdef FTS_WHITEOUT if (Wflag) { sb.st_mode = S_IFWHT|S_IWUSR|S_IRUSR; } else { #else { #endif if (!fflag || errno != ENOENT) { fprintf(stderr, "%s: %s: %s\n", argv0, f, strerror(errno)); eval = 1; } continue; } #ifdef FTS_WHITEOUT } else if (Wflag) { fprintf(stderr, "%s: %s: %s\n", argv0, f, strerror(EEXIST)); eval = 1; continue; #endif } if (S_ISDIR(sb.st_mode) && !dflag) { fprintf(stderr, "%s: %s: is a directory\n", argv0, f); eval = 1; continue; } if (!fflag && !S_ISWHT(sb.st_mode) && !check(f, f, &sb)) continue; rval = 0; #ifdef UF_APPEND if (!uid && (sb.st_flags & (UF_APPEND|UF_IMMUTABLE)) && !(sb.st_flags & (SF_APPEND|SF_IMMUTABLE))) rval = chflags(f, sb.st_flags & ~(UF_APPEND|UF_IMMUTABLE)); #endif if (rval == 0) { if (S_ISWHT(sb.st_mode)) rval = undelete(f); else if (S_ISDIR(sb.st_mode)) rval = rmdir(f); else { if (Pflag) if (!rm_overwrite(f, &sb)) continue; rval = unlink(f); #ifdef _MSC_VER if (rval != 0) { chmod(f, 0777); rval = unlink(f); } #endif } } if (rval && (!fflag || errno != ENOENT)) { fprintf(stderr, "%s: %s: %s\n", argv0, f, strerror(errno)); eval = 1; } if (vflag && rval == 0) (void)printf("%s\n", f); } return eval; } /* * rm_overwrite -- * Overwrite the file 3 times with varying bit patterns. * * XXX * This is a cheap way to *really* delete files. Note that only regular * files are deleted, directories (and therefore names) will remain. * Also, this assumes a fixed-block file system (like FFS, or a V7 or a * System V file system). In a logging file system, you'll have to have * kernel support. */ static int rm_overwrite(char *file, struct stat *sbp) { struct stat sb; #ifdef HAVE_FSTATFS struct statfs fsb; #endif off_t len; int bsize, fd, wlen; char *buf = NULL; fd = -1; if (sbp == NULL) { if (lstat(file, &sb)) goto err; sbp = &sb; } if (!S_ISREG(sbp->st_mode)) return (1); if ((fd = open(file, O_WRONLY, 0)) == -1) goto err; #ifdef HAVE_FSTATFS if (fstatfs(fd, &fsb) == -1) goto err; bsize = MAX(fsb.f_iosize, 1024); #elif defined(HAVE_ST_BLKSIZE) bsize = MAX(sb.st_blksize, 1024); #else bsize = 1024; #endif if ((buf = malloc(bsize)) == NULL) exit(err(1, "%s: malloc", file)); #define PASS(byte) { \ memset(buf, byte, bsize); \ for (len = sbp->st_size; len > 0; len -= wlen) { \ wlen = len < bsize ? len : bsize; \ if (write(fd, buf, wlen) != wlen) \ goto err; \ } \ } PASS(0xff); if (fsync(fd) || lseek(fd, (off_t)0, SEEK_SET)) goto err; PASS(0x00); if (fsync(fd) || lseek(fd, (off_t)0, SEEK_SET)) goto err; PASS(0xff); if (!fsync(fd) && !close(fd)) { free(buf); return (1); } err: eval = 1; if (buf) free(buf); if (fd != -1) close(fd); fprintf(stderr, "%s: %s: %s\n", argv0, file, strerror(errno)); return (0); } static int check(char *path, char *name, struct stat *sp) { int ch, first; char modep[15], *flagsp; /* Check -i first. */ if (iflag) (void)fprintf(stderr, "remove %s? ", path); else { /* * If it's not a symbolic link and it's unwritable and we're * talking to a terminal, ask. Symbolic links are excluded * because their permissions are meaningless. Check stdin_ok * first because we may not have stat'ed the file. * Also skip this check if the -P option was specified because * we will not be able to overwrite file contents and will * barf later. */ if (!stdin_ok || S_ISLNK(sp->st_mode) || Pflag || (!access(name, W_OK) && #ifdef SF_APPEND !(sp->st_flags & (SF_APPEND|SF_IMMUTABLE)) && (!(sp->st_flags & (UF_APPEND|UF_IMMUTABLE)) || !uid)) #else 1) #endif ) return (1); strmode(sp->st_mode, modep); #ifdef SF_APPEND if ((flagsp = fflagstostr(sp->st_flags)) == NULL) exit(err(1, "fflagstostr")); (void)fprintf(stderr, "override %s%s%s/%s %s%sfor %s? ", modep + 1, modep[9] == ' ' ? "" : " ", user_from_uid(sp->st_uid, 0), group_from_gid(sp->st_gid, 0), *flagsp ? flagsp : "", *flagsp ? " " : "", path); free(flagsp); #else (void)flagsp; (void)fprintf(stderr, "override %s%s %d/%d for %s? ", modep + 1, modep[9] == ' ' ? "" : " ", sp->st_uid, sp->st_gid, path); #endif } (void)fflush(stderr); first = ch = getchar(); while (ch != '\n' && ch != EOF) ch = getchar(); return (first == 'y' || first == 'Y'); } #define ISDOT(a) ((a)[0] == '.' && (!(a)[1] || ((a)[1] == '.' && !(a)[2]))) static void checkdot(char **argv) { char *p, **save, **t; int complained; complained = 0; for (t = argv; *t;) { #ifdef HAVE_DOS_PATHS const char *tmp = p = *t; while (*tmp) { switch (*tmp) { case '/': case '\\': case ':': p = (char *)tmp + 1; break; } tmp++; } #else if ((p = strrchr(*t, '/')) != NULL) ++p; else p = *t; #endif if (ISDOT(p)) { if (!complained++) fprintf(stderr, "%s: \".\" and \"..\" may not be removed\n", argv0); eval = 1; for (save = t; (t[0] = t[1]) != NULL; ++t) continue; t = save; } else ++t; } } static int usage(FILE *pf) { fprintf(pf, "usage: %s [options] file ...\n" " or: %s --help\n" " or: %s --version\n" "\n" "Options:\n" " -f\n" " Attempt to remove files without prompting, regardless of the file\n" " permission. Ignore non-existing files. Overrides previous -i's.\n" " -i\n" " Prompt for each file. Always.\n" " -d\n" " Attempt to remove directories as well as other kinds of files.\n" " -P\n" " Overwrite regular files before deleting; three passes: ff,0,ff\n" " -R\n" " Attempt to remove the file hierachy rooted in each file argument.\n" " This option implies -d and file protection.\n" " -v\n" " Be verbose, show files as they are removed.\n" " -W\n" " Undelete without files.\n" " --disable-protection\n" " Will disable the protection file protection applied with -R.\n" " --enable-protection\n" " Will enable the protection file protection applied with -R.\n" " --enable-full-protection\n" " Will enable the protection file protection for all operations.\n" " --disable-full-protection\n" " Will disable the protection file protection for all operations.\n" " --protection-depth\n" " Number or path indicating the file protection depth. Default: %d\n" "\n" "Environment:\n" " KMK_RM_DISABLE_PROTECTION\n" " Same as --disable-protection. Overrides command line.\n" " KMK_RM_ENABLE_PROTECTION\n" " Same as --enable-protection. Overrides everyone else.\n" " KMK_RM_ENABLE_FULL_PROTECTION\n" " Same as --enable-full-protection. Overrides everyone else.\n" " KMK_RM_DISABLE_FULL_PROTECTION\n" " Same as --disable-full-protection. Overrides command line.\n" " KMK_RM_PROTECTION_DEPTH\n" " Same as --protection-depth. Overrides command line.\n" "\n" "The file protection of the top %d layers of the file hierarchy is there\n" "to try prevent makefiles from doing bad things to your system. This\n" "protection is not bulletproof, but should help prevent you from shooting\n" "yourself in the foot.\n" , g_progname, g_progname, g_progname, kBuildProtectionDefaultDepth(), kBuildProtectionDefaultDepth()); return EX_USAGE; }