/*- * 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 /********************************************************************************************************************************* * Header Files * *********************************************************************************************************************************/ #define FAKES_NO_GETOPT_H /* bird */ #include "config.h" #include #if !defined(_MSC_VER) && !defined(__HAIKU__) # include # ifndef __gnu_hurd__ # include # endif #endif #include "err.h" #include #include #include "fts.h" #include #include #include #include #include #ifndef __HAIKU__ # include #endif #include #include #include "getopt_r.h" #ifdef __HAIKU__ # include "haikufakes.h" #endif #ifdef __NetBSD__ # include # define fflagstostr(flags) flags_to_string(flags, "") #endif #ifdef KBUILD_OS_WINDOWS # ifdef _MSC_VER # include "mscfakes.h" # endif # include "nt/ntunlink.h" /* Use the special unlink implementation to do rmdir too. */ # undef rmdir # define rmdir(a_pszPath) birdUnlinkForced(a_pszPath) #endif #if defined(__OS2__) || defined(_MSC_VER) # include # include #endif #include "kmkbuiltin.h" #include "kbuild_protection.h" #include "k/kDefs.h" /* for K_OS */ /********************************************************************************************************************************* * Defined Constants And Macros * *********************************************************************************************************************************/ #if defined(__EMX__) || defined(KBUILD_OS_WINDOWS) # 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 1 #define CUR_LINE_H2(x) "[line " #x "]" #define CUR_LINE_H1(x) CUR_LINE_H2(x) #define CUR_LINE() CUR_LINE_H1(__LINE__) #else # define CUR_LINE() #endif /********************************************************************************************************************************* * Structures and Typedefs * *********************************************************************************************************************************/ typedef struct RMINSTANCE { PKMKBUILTINCTX pCtx; int dflag, eval, fflag, iflag, Pflag, vflag, Wflag, stdin_ok; #ifdef KBUILD_OS_WINDOWS int fUseNtDeleteFile; #endif uid_t uid; KBUILDPROTECTION g_ProtData; } RMINSTANCE; typedef RMINSTANCE *PRMINSTANCE; /********************************************************************************************************************************* * Global Variables * *********************************************************************************************************************************/ 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 }, #ifdef KBUILD_OS_WINDOWS { "nt-delete-file", no_argument, 0, 268 }, #endif { 0, 0, 0, 0 }, }; /********************************************************************************************************************************* * Internal Functions * *********************************************************************************************************************************/ extern void bsd_strmode(mode_t mode, char *p); /* strmode.c */ static int check(PRMINSTANCE, char *, char *, struct stat *); static void checkdot(PRMINSTANCE, char **); static int rm_file(PRMINSTANCE, char **); static int rm_overwrite(PRMINSTANCE, char *, struct stat *); static int rm_tree(PRMINSTANCE, char **); static int usage(PKMKBUILTINCTX, int); /* * 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, PKMKBUILTINCTX pCtx) { RMINSTANCE This; struct getopt_state_r gos; int ch, rflag; /* Init global instance data */ This.pCtx = pCtx; This.dflag = 0; This.eval = 0; This.fflag = 0; This.iflag = 0; This.Pflag = 0; This.vflag = 0; This.Wflag = 0; This.stdin_ok = 0; #ifdef KBUILD_OS_WINDOWS This.fUseNtDeleteFile = 0; #endif This.uid = 0; kBuildProtectionInit(&This.g_ProtData, pCtx); rflag = 0; getopt_initialize_r(&gos, argc, argv, "dfiPRvW", long_options, envp, pCtx); while ((ch = getopt_long_r(&gos, NULL)) != -1) switch (ch) { case 'd': This.dflag = 1; break; case 'f': This.fflag = 1; This.iflag = 0; break; case 'i': This.fflag = 0; This.iflag = 1; break; case 'P': This.Pflag = 1; break; case 'R': #if 0 case 'r': /* Compatibility. */ #endif rflag = 1; break; case 'v': This.vflag = 1; break; #ifdef FTS_WHITEOUT case 'W': This.Wflag = 1; break; #endif case 261: kBuildProtectionTerm(&This.g_ProtData); usage(pCtx, 0); return 0; case 262: kBuildProtectionTerm(&This.g_ProtData); return kbuild_version(argv[0]); case 263: kBuildProtectionDisable(&This.g_ProtData, KBUILDPROTECTIONTYPE_RECURSIVE); break; case 264: kBuildProtectionEnable(&This.g_ProtData, KBUILDPROTECTIONTYPE_RECURSIVE); break; case 265: kBuildProtectionEnable(&This.g_ProtData, KBUILDPROTECTIONTYPE_FULL); break; case 266: kBuildProtectionDisable(&This.g_ProtData, KBUILDPROTECTIONTYPE_FULL); break; case 267: if (kBuildProtectionSetDepth(&This.g_ProtData, gos.optarg)) { kBuildProtectionTerm(&This.g_ProtData); return 1; } break; #ifdef KBUILD_OS_WINDOWS case 268: This.fUseNtDeleteFile = 1; break; #endif case '?': default: kBuildProtectionTerm(&This.g_ProtData); return usage(pCtx, 1); } argc -= gos.optind; argv += gos.optind; if (argc < 1) { kBuildProtectionTerm(&This.g_ProtData); if (This.fflag) return (0); return usage(pCtx, 1); } if (!kBuildProtectionScanEnv(&This.g_ProtData, envp, "KMK_RM_")) { checkdot(&This, argv); This.uid = geteuid(); if (*argv) { This.stdin_ok = isatty(STDIN_FILENO); if (rflag) This.eval |= rm_tree(&This, argv); else This.eval |= rm_file(&This, argv); } } else { This.eval = 1; } kBuildProtectionTerm(&This.g_ProtData); return This.eval; } #ifdef KMK_BUILTIN_STANDALONE int main(int argc, char **argv, char **envp) { KMKBUILTINCTX Ctx = { "kmk_rm", NULL }; return kmk_builtin_rm(argc, argv, envp, &Ctx); } #endif static int rm_tree(PRMINSTANCE pThis, 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(&pThis->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 = !pThis->uid || (!pThis->fflag && !pThis->iflag && pThis->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; #ifndef KMK_BUILTIN_STANDALONE flags |= FTS_NOCHDIR; /* Must not change the directory from inside kmk! */ #endif if (!needstat) flags |= FTS_NOSTAT; #ifdef FTS_WHITEOUT if (pThis->Wflag) flags |= FTS_WHITEOUT; #endif if (!(fts = fts_open(argv, flags, NULL))) { return err(pThis->pCtx, 1, "fts_open"); } while ((p = fts_read(fts)) != NULL) { const char *operation = "chflags"; switch (p->fts_info) { case FTS_DNR: if (!pThis->fflag || p->fts_errno != ENOENT) pThis->eval = errx(pThis->pCtx, 1, "fts: %s: %s" CUR_LINE() "\n", p->fts_path, strerror(p->fts_errno)); continue; case FTS_ERR: fts_close(fts); return errx(pThis->pCtx, 1, "fts: %s: %s " CUR_LINE(), 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 (!pThis->fflag || p->fts_errno != ENOENT) pThis->eval = errx(pThis->pCtx, 1, "fts: %s: %s " CUR_LINE() "\n", p->fts_path, strerror(p->fts_errno)); continue; case FTS_D: /* Pre-order: give user chance to skip. */ if (!pThis->fflag && !check(pThis, 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 (!pThis->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 (!pThis->fflag && !check(pThis, p->fts_path, p->fts_accpath, p->fts_statp)) continue; } /* * Protect against deleting root files and directories. */ if (kBuildProtectionEnforce(&pThis->g_ProtData, KBUILDPROTECTIONTYPE_RECURSIVE, p->fts_accpath)) { fts_close(fts); return 1; } rval = 0; #ifdef UF_APPEND if (!pThis->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: #ifdef KBUILD_OS_WINDOWS if (p->fts_parent->fts_dirfd != NT_FTS_INVALID_HANDLE_VALUE) { rval = birdUnlinkForcedEx(p->fts_parent->fts_dirfd, p->fts_name); } else { rval = birdUnlinkForced(p->fts_accpath); } #else rval = rmdir(p->fts_accpath); #endif if (rval == 0 || (pThis->fflag && errno == ENOENT)) { if (rval == 0 && pThis->vflag) kmk_builtin_ctx_printf(pThis->pCtx, 0, "%s\n", p->fts_path); #if defined(KMK) && defined(KBUILD_OS_WINDOWS) if (rval == 0) { extern int dir_cache_deleted_directory(const char *pszDir); dir_cache_deleted_directory(p->fts_accpath); } #endif continue; } operation = "rmdir"; break; #ifdef FTS_W case FTS_W: rval = undelete(p->fts_accpath); if (rval == 0 && (pThis->fflag && errno == ENOENT)) { if (pThis->vflag) kmk_builtin_ctx_printf(pThis->pCtx, 0, "%s\n", p->fts_path); continue; } operation = "undelete"; break; #endif case FTS_NS: /* * Assume that since fts_read() couldn't stat * the file, it can't be unlinked. */ if (pThis->fflag) continue; /* FALLTHROUGH */ default: if (pThis->Pflag) if (!rm_overwrite(pThis, p->fts_accpath, NULL)) continue; #ifdef KBUILD_OS_WINDOWS if (p->fts_parent->fts_dirfd != NT_FTS_INVALID_HANDLE_VALUE) { if (p->fts_info != FTS_SL && p->fts_info != FTS_SLNONE) { rval = birdUnlinkForcedFastEx(p->fts_parent->fts_dirfd, p->fts_name); } else { /* NtDeleteFile doesn't work on directory links, so slow symlink deletion: */ rval = birdUnlinkForcedEx(p->fts_parent->fts_dirfd, p->fts_name); } } else { if (p->fts_info != FTS_SL && p->fts_info != FTS_SLNONE) { rval = birdUnlinkForcedFast(p->fts_accpath); } else { /* NtDeleteFile doesn't work on directory links, so slow symlink deletion: */ rval = birdUnlinkForced(p->fts_accpath); } } #else rval = unlink(p->fts_accpath); #endif if (rval == 0 || (pThis->fflag && errno == ENOENT)) { if (rval == 0 && pThis->vflag) kmk_builtin_ctx_printf(pThis->pCtx, 0, "%s\n", p->fts_path); continue; } operation = "unlink"; break; } } #ifdef UF_APPEND err: #endif pThis->eval = errx(pThis->pCtx, 1, "%s: %s failed: %s " CUR_LINE() "\n", p->fts_path, operation, strerror(errno)); } if (errno) { pThis->eval = errx(pThis->pCtx, 1, "fts_read: %s " CUR_LINE() "\n", strerror(errno)); } fts_close(fts); return pThis->eval; } static int rm_file(PRMINSTANCE pThis, 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(&pThis->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) { const char *operation = "?"; /* Assume if can't stat the file, can't unlink it. */ if (lstat(f, &sb)) { #ifdef FTS_WHITEOUT if (pThis->Wflag) { sb.st_mode = S_IFWHT|S_IWUSR|S_IRUSR; } else { #else { #endif if (!pThis->fflag || errno != ENOENT) pThis->eval = errx(pThis->pCtx, 1, "%s: lstat failed: %s " CUR_LINE() "\n", f, strerror(errno)); continue; } #ifdef FTS_WHITEOUT } else if (pThis->Wflag) { errx(pThis->pCtx, 1, "%s: %s\n", f, strerror(EEXIST)); pThis->eval = 1; continue; #endif } if (S_ISDIR(sb.st_mode) && !pThis->dflag) { pThis->eval = errx(pThis->pCtx, 1, "%s: is a directory\n", f); continue; } if (!pThis->fflag && !S_ISWHT(sb.st_mode) && !check(pThis, f, f, &sb)) continue; rval = 0; #ifdef UF_APPEND if (!pThis->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); operation = "undelete"; } else if (S_ISDIR(sb.st_mode)) { rval = rmdir(f); operation = "rmdir"; } else { if (pThis->Pflag) if (!rm_overwrite(pThis, f, &sb)) continue; #ifndef KBUILD_OS_WINDOWS rval = unlink(f); operation = "unlink"; #else if (pThis->fUseNtDeleteFile) { rval = birdUnlinkForcedFast(f); operation = "NtDeleteFile"; } else { rval = birdUnlinkForced(f); operation = "unlink"; } #endif } } if (rval && (!pThis->fflag || errno != ENOENT)) pThis->eval = errx(pThis->pCtx, 1, "%s: %s failed: %s" CUR_LINE() "\n", f, operation, strerror(errno)); if (pThis->vflag && rval == 0) kmk_builtin_ctx_printf(pThis->pCtx, 0, "%s\n", f); } return pThis->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(PRMINSTANCE pThis, 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; const char *operation = "lstat"; int error; fd = -1; if (sbp == NULL) { if (lstat(file, &sb)) goto err; sbp = &sb; } if (!S_ISREG(sbp->st_mode)) return (1); operation = "open"; if ((fd = open(file, O_WRONLY | KMK_OPEN_NO_INHERIT, 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) { err(pThis->pCtx, 1, "%s: malloc", file); close(fd); return 1; } #define PASS(byte) { \ operation = "write"; \ 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); operation = "fsync/lseek"; if (fsync(fd) || lseek(fd, (off_t)0, SEEK_SET)) goto err; PASS(0x00); operation = "fsync/lseek"; if (fsync(fd) || lseek(fd, (off_t)0, SEEK_SET)) goto err; PASS(0xff); if (!fsync(fd) && !close(fd)) { free(buf); return (1); } operation = "fsync/close"; err: pThis->eval = 1; error = errno; if (buf) free(buf); if (fd != -1) close(fd); errx(pThis->pCtx, 1, "%s: %s: %s: %s" CUR_LINE() "\n", operation, pThis->pCtx->pszProgName, file, strerror(error)); return (0); } static int check(PRMINSTANCE pThis, char *path, char *name, struct stat *sp) { int ch, first; char modep[15], *flagsp; /* Check -i first. */ if (pThis->iflag) (void)fprintf(stderr, "%s: remove %s? ", pThis->pCtx->pszProgName, 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 (!pThis->stdin_ok || S_ISLNK(sp->st_mode) || pThis->Pflag || (!access(name, W_OK) && #ifdef SF_APPEND !(sp->st_flags & (SF_APPEND|SF_IMMUTABLE)) && (!(sp->st_flags & (UF_APPEND|UF_IMMUTABLE)) || !pThis->uid)) #else 1) #endif ) return (1); bsd_strmode(sp->st_mode, modep); #if defined(SF_APPEND) && K_OS != K_OS_GNU_KFBSD && K_OS != K_OS_GNU_HURD if ((flagsp = fflagstostr(sp->st_flags)) == NULL) { err(pThis->pCtx, 1, "fflagstostr"); flagsp = ""; } (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(PRMINSTANCE pThis, 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++) warnx(pThis->pCtx, "\".\" and \"..\" may not be removed\n"); pThis->eval = 1; for (save = t; (t[0] = t[1]) != NULL; ++t) continue; t = save; } else ++t; } } static int usage(PKMKBUILTINCTX pCtx, int fIsErr) { kmk_builtin_ctx_printf(pCtx, fIsErr, "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" , pCtx->pszProgName, pCtx->pszProgName, pCtx->pszProgName, kBuildProtectionDefaultDepth(), kBuildProtectionDefaultDepth()); return EX_USAGE; }