source: trunk/src/kmk/kmkbuiltin/rm.c@ 1750

Last change on this file since 1750 was 1710, checked in by bird, 17 years ago

kmk: Made chmod build on windows. Some cleanup of the bsdisms.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 18.1 KB
Line 
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 * 4. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30#if 0
31#ifndef lint
32static const char copyright[] =
33"@(#) Copyright (c) 1990, 1993, 1994\n\
34 The Regents of the University of California. All rights reserved.\n";
35#endif /* not lint */
36
37#ifndef lint
38static char sccsid[] = "@(#)rm.c 8.5 (Berkeley) 4/18/94";
39#endif /* not lint */
40#include <sys/cdefs.h>
41//__FBSDID("$FreeBSD: src/bin/rm/rm.c,v 1.47 2004/04/06 20:06:50 markm Exp $");
42#endif
43
44#include <sys/stat.h>
45#ifndef _MSC_VER
46# include <sys/param.h>
47# include <sys/mount.h>
48#endif
49
50#include "err.h"
51#include <errno.h>
52#include <fcntl.h>
53#include <fts.h>
54#include <grp.h>
55#include <pwd.h>
56#include <stdio.h>
57#include <stdlib.h>
58#include <string.h>
59#include <sysexits.h>
60#include <unistd.h>
61#include <ctype.h>
62#include "getopt.h"
63#ifdef _MSC_VER
64# include "mscfakes.h"
65#endif
66#if defined(__OS2__) || defined(_MSC_VER)
67# include <direct.h>
68# include <limits.h>
69#endif
70#include "kmkbuiltin.h"
71#include "kbuild_protection.h"
72
73#if defined(__EMX__) || defined(_MSC_VER)
74# define IS_SLASH(ch) ( (ch) == '/' || (ch) == '\\' )
75# define HAVE_DOS_PATHS 1
76# define DEFAULT_PROTECTION_DEPTH 1
77#else
78# define IS_SLASH(ch) ( (ch) == '/' )
79# undef HAVE_DOS_PATHS
80# define DEFAULT_PROTECTION_DEPTH 2
81#endif
82
83#ifdef __EMX__
84#undef S_IFWHT
85#undef S_ISWHT
86#endif
87#ifndef S_IFWHT
88#define S_IFWHT 0
89#define S_ISWHT(s) 0
90#define undelete(s) (-1)
91#endif
92
93extern void bsd_strmode(mode_t mode, char *p);
94
95static int dflag, eval, fflag, iflag, Pflag, vflag, Wflag, stdin_ok;
96static uid_t uid;
97
98static char *argv0;
99static KBUILDPROTECTION g_ProtData;
100
101static struct option long_options[] =
102{
103 { "help", no_argument, 0, 261 },
104 { "version", no_argument, 0, 262 },
105 { "disable-protection", no_argument, 0, 263 },
106 { "enable-protection", no_argument, 0, 264 },
107 { "enable-full-protection", no_argument, 0, 265 },
108 { "disable-full-protection", no_argument, 0, 266 },
109 { "protection-depth", required_argument, 0, 267 },
110 { 0, 0, 0, 0 },
111};
112
113
114static int check(char *, char *, struct stat *);
115static void checkdot(char **);
116static int rm_file(char **);
117static int rm_overwrite(char *, struct stat *);
118static int rm_tree(char **);
119static int count_path_components(const char *);
120static int usage(FILE *);
121
122
123
124/*
125 * rm --
126 * This rm is different from historic rm's, but is expected to match
127 * POSIX 1003.2 behavior. The most visible difference is that -f
128 * has two specific effects now, ignore non-existent files and force
129 * file removal.
130 */
131int
132kmk_builtin_rm(int argc, char *argv[], char **envp)
133{
134 int ch, rflag;
135
136 /* reinitialize globals */
137 argv0 = argv[0];
138 dflag = eval = fflag = iflag = Pflag = vflag = Wflag = stdin_ok = 0;
139 uid = 0;
140 kBuildProtectionInit(&g_ProtData);
141
142 /* kmk: reset getopt and set program name. */
143 g_progname = argv[0];
144 opterr = 1;
145 optarg = NULL;
146 optopt = 0;
147 optind = 0; /* init */
148
149 Pflag = rflag = 0;
150 while ((ch = getopt_long(argc, argv, "dfiPRvW", long_options, NULL)) != -1)
151 switch(ch) {
152 case 'd':
153 dflag = 1;
154 break;
155 case 'f':
156 fflag = 1;
157 iflag = 0;
158 break;
159 case 'i':
160 fflag = 0;
161 iflag = 1;
162 break;
163 case 'P':
164 Pflag = 1;
165 break;
166 case 'R':
167#if 0
168 case 'r': /* Compatibility. */
169#endif
170 rflag = 1;
171 break;
172 case 'v':
173 vflag = 1;
174 break;
175#ifdef FTS_WHITEOUT
176 case 'W':
177 Wflag = 1;
178 break;
179#endif
180 case 261:
181 kBuildProtectionTerm(&g_ProtData);
182 usage(stdout);
183 return 0;
184 case 262:
185 kBuildProtectionTerm(&g_ProtData);
186 return kbuild_version(argv[0]);
187 case 263:
188 kBuildProtectionDisable(&g_ProtData, KBUILDPROTECTIONTYPE_RECURSIVE);
189 break;
190 case 264:
191 kBuildProtectionEnable(&g_ProtData, KBUILDPROTECTIONTYPE_RECURSIVE);
192 break;
193 case 265:
194 kBuildProtectionEnable(&g_ProtData, KBUILDPROTECTIONTYPE_FULL);
195 break;
196 case 266:
197 kBuildProtectionDisable(&g_ProtData, KBUILDPROTECTIONTYPE_FULL);
198 break;
199 case 267:
200 if (kBuildProtectionSetDepth(&g_ProtData, optarg)) {
201 kBuildProtectionTerm(&g_ProtData);
202 return 1;
203 }
204 break;
205 case '?':
206 default:
207 kBuildProtectionTerm(&g_ProtData);
208 return usage(stderr);
209 }
210 argc -= optind;
211 argv += optind;
212
213 if (argc < 1) {
214 kBuildProtectionTerm(&g_ProtData);
215 if (fflag)
216 return (0);
217 return usage(stderr);
218 }
219
220 if (!kBuildProtectionScanEnv(&g_ProtData, envp, "KMK_RM_")) {
221 checkdot(argv);
222 uid = geteuid();
223
224 if (*argv) {
225 stdin_ok = isatty(STDIN_FILENO);
226 if (rflag)
227 eval |= rm_tree(argv);
228 else
229 eval |= rm_file(argv);
230 }
231 } else {
232 eval = 1;
233 }
234
235 kBuildProtectionTerm(&g_ProtData);
236 return eval;
237}
238
239static int
240rm_tree(char **argv)
241{
242 FTS *fts;
243 FTSENT *p;
244 int needstat;
245 int flags;
246 int rval;
247
248 /*
249 * Check up front before anything is deleted. This will not catch
250 * everything, but we'll check the individual items later.
251 */
252 int i;
253 for (i = 0; argv[i]; i++) {
254 if (kBuildProtectionEnforce(&g_ProtData, KBUILDPROTECTIONTYPE_RECURSIVE, argv[i])) {
255 return 1;
256 }
257 }
258
259 /*
260 * Remove a file hierarchy. If forcing removal (-f), or interactive
261 * (-i) or can't ask anyway (stdin_ok), don't stat the file.
262 */
263 needstat = !uid || (!fflag && !iflag && stdin_ok);
264
265 /*
266 * If the -i option is specified, the user can skip on the pre-order
267 * visit. The fts_number field flags skipped directories.
268 */
269#define SKIPPED 1
270
271 flags = FTS_PHYSICAL;
272 if (!needstat)
273 flags |= FTS_NOSTAT;
274#ifdef FTS_WHITEOUT
275 if (Wflag)
276 flags |= FTS_WHITEOUT;
277#endif
278 if (!(fts = fts_open(argv, flags, NULL))) {
279 return err(1, "fts_open");
280 }
281 while ((p = fts_read(fts)) != NULL) {
282 switch (p->fts_info) {
283 case FTS_DNR:
284 if (!fflag || p->fts_errno != ENOENT) {
285 fprintf(stderr, "%s: %s: %s\n",
286 argv0, p->fts_path, strerror(p->fts_errno));
287 eval = 1;
288 }
289 continue;
290 case FTS_ERR:
291 fts_close(fts);
292 return errx(1, "%s: %s", p->fts_path, strerror(p->fts_errno));
293 case FTS_NS:
294 /*
295 * Assume that since fts_read() couldn't stat the
296 * file, it can't be unlinked.
297 */
298 if (!needstat)
299 break;
300 if (!fflag || p->fts_errno != ENOENT) {
301 fprintf(stderr, "%s: %s: %s\n",
302 argv0, p->fts_path, strerror(p->fts_errno));
303 eval = 1;
304 }
305 continue;
306 case FTS_D:
307 /* Pre-order: give user chance to skip. */
308 if (!fflag && !check(p->fts_path, p->fts_accpath,
309 p->fts_statp)) {
310 (void)fts_set(fts, p, FTS_SKIP);
311 p->fts_number = SKIPPED;
312 }
313#ifdef UF_APPEND
314 else if (!uid &&
315 (p->fts_statp->st_flags & (UF_APPEND|UF_IMMUTABLE)) &&
316 !(p->fts_statp->st_flags & (SF_APPEND|SF_IMMUTABLE)) &&
317 chflags(p->fts_accpath,
318 p->fts_statp->st_flags &= ~(UF_APPEND|UF_IMMUTABLE)) < 0)
319 goto err;
320#endif
321 continue;
322 case FTS_DP:
323 /* Post-order: see if user skipped. */
324 if (p->fts_number == SKIPPED)
325 continue;
326 break;
327 default:
328 if (!fflag &&
329 !check(p->fts_path, p->fts_accpath, p->fts_statp))
330 continue;
331 }
332
333 /*
334 * Protect against deleting root files and directories.
335 */
336 if (kBuildProtectionEnforce(&g_ProtData, KBUILDPROTECTIONTYPE_RECURSIVE, p->fts_accpath)) {
337 fts_close(fts);
338 return 1;
339 }
340
341 rval = 0;
342#ifdef UF_APPEND
343 if (!uid &&
344 (p->fts_statp->st_flags & (UF_APPEND|UF_IMMUTABLE)) &&
345 !(p->fts_statp->st_flags & (SF_APPEND|SF_IMMUTABLE)))
346 rval = chflags(p->fts_accpath,
347 p->fts_statp->st_flags &= ~(UF_APPEND|UF_IMMUTABLE));
348#endif
349 if (rval == 0) {
350 /*
351 * If we can't read or search the directory, may still be
352 * able to remove it. Don't print out the un{read,search}able
353 * message unless the remove fails.
354 */
355 switch (p->fts_info) {
356 case FTS_DP:
357 case FTS_DNR:
358 rval = rmdir(p->fts_accpath);
359 if (rval == 0 || (fflag && errno == ENOENT)) {
360 if (rval == 0 && vflag)
361 (void)printf("%s\n",
362 p->fts_path);
363 continue;
364 }
365 break;
366
367#ifdef FTS_W
368 case FTS_W:
369 rval = undelete(p->fts_accpath);
370 if (rval == 0 && (fflag && errno == ENOENT)) {
371 if (vflag)
372 (void)printf("%s\n",
373 p->fts_path);
374 continue;
375 }
376 break;
377#endif
378
379 case FTS_NS:
380 /*
381 * Assume that since fts_read() couldn't stat
382 * the file, it can't be unlinked.
383 */
384 if (fflag)
385 continue;
386 /* FALLTHROUGH */
387 default:
388 if (Pflag)
389 if (!rm_overwrite(p->fts_accpath, NULL))
390 continue;
391 rval = unlink(p->fts_accpath);
392#ifdef _MSC_VER
393 if (rval != 0) {
394 chmod(p->fts_accpath, 0777);
395 rval = unlink(p->fts_accpath);
396 }
397#endif
398
399 if (rval == 0 || (fflag && errno == ENOENT)) {
400 if (rval == 0 && vflag)
401 (void)printf("%s\n",
402 p->fts_path);
403 continue;
404 }
405 }
406 }
407#ifdef UF_APPEND
408err:
409#endif
410 fprintf(stderr, "%s: %s: %s\n", argv0, p->fts_path, strerror(errno));
411 eval = 1;
412 }
413 if (errno) {
414 fprintf(stderr, "%s: fts_read: %s\n", argv0, strerror(errno));
415 eval = 1;
416 }
417 fts_close(fts);
418 return eval;
419}
420
421static int
422rm_file(char **argv)
423{
424 struct stat sb;
425 int rval;
426 char *f;
427
428 /*
429 * Check up front before anything is deleted.
430 */
431 int i;
432 for (i = 0; argv[i]; i++) {
433 if (kBuildProtectionEnforce(&g_ProtData, KBUILDPROTECTIONTYPE_FULL, argv[i]))
434 return 1;
435 }
436
437 /*
438 * Remove a file. POSIX 1003.2 states that, by default, attempting
439 * to remove a directory is an error, so must always stat the file.
440 */
441 while ((f = *argv++) != NULL) {
442 /* Assume if can't stat the file, can't unlink it. */
443 if (lstat(f, &sb)) {
444#ifdef FTS_WHITEOUT
445 if (Wflag) {
446 sb.st_mode = S_IFWHT|S_IWUSR|S_IRUSR;
447 } else {
448#else
449 {
450#endif
451 if (!fflag || errno != ENOENT) {
452 fprintf(stderr, "%s: %s: %s\n", argv0, f, strerror(errno));
453 eval = 1;
454 }
455 continue;
456 }
457#ifdef FTS_WHITEOUT
458 } else if (Wflag) {
459 fprintf(stderr, "%s: %s: %s\n", argv0, f, strerror(EEXIST));
460 eval = 1;
461 continue;
462#endif
463 }
464
465 if (S_ISDIR(sb.st_mode) && !dflag) {
466 fprintf(stderr, "%s: %s: is a directory\n", argv0, f);
467 eval = 1;
468 continue;
469 }
470 if (!fflag && !S_ISWHT(sb.st_mode) && !check(f, f, &sb))
471 continue;
472 rval = 0;
473#ifdef UF_APPEND
474 if (!uid &&
475 (sb.st_flags & (UF_APPEND|UF_IMMUTABLE)) &&
476 !(sb.st_flags & (SF_APPEND|SF_IMMUTABLE)))
477 rval = chflags(f, sb.st_flags & ~(UF_APPEND|UF_IMMUTABLE));
478#endif
479 if (rval == 0) {
480 if (S_ISWHT(sb.st_mode))
481 rval = undelete(f);
482 else if (S_ISDIR(sb.st_mode))
483 rval = rmdir(f);
484 else {
485 if (Pflag)
486 if (!rm_overwrite(f, &sb))
487 continue;
488 rval = unlink(f);
489#ifdef _MSC_VER
490 if (rval != 0) {
491 chmod(f, 0777);
492 rval = unlink(f);
493 }
494#endif
495 }
496 }
497 if (rval && (!fflag || errno != ENOENT)) {
498 fprintf(stderr, "%s: %s: %s\n", argv0, f, strerror(errno));
499 eval = 1;
500 }
501 if (vflag && rval == 0)
502 (void)printf("%s\n", f);
503 }
504 return eval;
505}
506
507/*
508 * rm_overwrite --
509 * Overwrite the file 3 times with varying bit patterns.
510 *
511 * XXX
512 * This is a cheap way to *really* delete files. Note that only regular
513 * files are deleted, directories (and therefore names) will remain.
514 * Also, this assumes a fixed-block file system (like FFS, or a V7 or a
515 * System V file system). In a logging file system, you'll have to have
516 * kernel support.
517 */
518static int
519rm_overwrite(char *file, struct stat *sbp)
520{
521 struct stat sb;
522#ifdef HAVE_FSTATFS
523 struct statfs fsb;
524#endif
525 off_t len;
526 int bsize, fd, wlen;
527 char *buf = NULL;
528
529 fd = -1;
530 if (sbp == NULL) {
531 if (lstat(file, &sb))
532 goto err;
533 sbp = &sb;
534 }
535 if (!S_ISREG(sbp->st_mode))
536 return (1);
537 if ((fd = open(file, O_WRONLY, 0)) == -1)
538 goto err;
539#ifdef HAVE_FSTATFS
540 if (fstatfs(fd, &fsb) == -1)
541 goto err;
542 bsize = MAX(fsb.f_iosize, 1024);
543#elif defined(HAVE_ST_BLKSIZE)
544 bsize = MAX(sb.st_blksize, 1024);
545#else
546 bsize = 1024;
547#endif
548 if ((buf = malloc(bsize)) == NULL)
549 exit(err(1, "%s: malloc", file));
550
551#define PASS(byte) { \
552 memset(buf, byte, bsize); \
553 for (len = sbp->st_size; len > 0; len -= wlen) { \
554 wlen = len < bsize ? len : bsize; \
555 if (write(fd, buf, wlen) != wlen) \
556 goto err; \
557 } \
558}
559 PASS(0xff);
560 if (fsync(fd) || lseek(fd, (off_t)0, SEEK_SET))
561 goto err;
562 PASS(0x00);
563 if (fsync(fd) || lseek(fd, (off_t)0, SEEK_SET))
564 goto err;
565 PASS(0xff);
566 if (!fsync(fd) && !close(fd)) {
567 free(buf);
568 return (1);
569 }
570
571err: eval = 1;
572 if (buf)
573 free(buf);
574 if (fd != -1)
575 close(fd);
576 fprintf(stderr, "%s: %s: %s\n", argv0, file, strerror(errno));
577 return (0);
578}
579
580
581static int
582check(char *path, char *name, struct stat *sp)
583{
584 int ch, first;
585 char modep[15], *flagsp;
586
587 /* Check -i first. */
588 if (iflag)
589 (void)fprintf(stderr, "remove %s? ", path);
590 else {
591 /*
592 * If it's not a symbolic link and it's unwritable and we're
593 * talking to a terminal, ask. Symbolic links are excluded
594 * because their permissions are meaningless. Check stdin_ok
595 * first because we may not have stat'ed the file.
596 * Also skip this check if the -P option was specified because
597 * we will not be able to overwrite file contents and will
598 * barf later.
599 */
600 if (!stdin_ok || S_ISLNK(sp->st_mode) || Pflag ||
601 (!access(name, W_OK) &&
602#ifdef SF_APPEND
603 !(sp->st_flags & (SF_APPEND|SF_IMMUTABLE)) &&
604 (!(sp->st_flags & (UF_APPEND|UF_IMMUTABLE)) || !uid))
605#else
606 1)
607#endif
608 )
609 return (1);
610 bsd_strmode(sp->st_mode, modep);
611#ifdef SF_APPEND
612 if ((flagsp = fflagstostr(sp->st_flags)) == NULL)
613 exit(err(1, "fflagstostr"));
614 (void)fprintf(stderr, "override %s%s%s/%s %s%sfor %s? ",
615 modep + 1, modep[9] == ' ' ? "" : " ",
616 user_from_uid(sp->st_uid, 0),
617 group_from_gid(sp->st_gid, 0),
618 *flagsp ? flagsp : "", *flagsp ? " " : "",
619 path);
620 free(flagsp);
621#else
622 (void)flagsp;
623 (void)fprintf(stderr, "override %s%s %d/%d for %s? ",
624 modep + 1, modep[9] == ' ' ? "" : " ",
625 sp->st_uid, sp->st_gid, path);
626#endif
627 }
628 (void)fflush(stderr);
629
630 first = ch = getchar();
631 while (ch != '\n' && ch != EOF)
632 ch = getchar();
633 return (first == 'y' || first == 'Y');
634}
635
636#define ISDOT(a) ((a)[0] == '.' && (!(a)[1] || ((a)[1] == '.' && !(a)[2])))
637static void
638checkdot(char **argv)
639{
640 char *p, **save, **t;
641 int complained;
642
643 complained = 0;
644 for (t = argv; *t;) {
645#ifdef HAVE_DOS_PATHS
646 const char *tmp = p = *t;
647 while (*tmp) {
648 switch (*tmp) {
649 case '/':
650 case '\\':
651 case ':':
652 p = (char *)tmp + 1;
653 break;
654 }
655 tmp++;
656 }
657#else
658 if ((p = strrchr(*t, '/')) != NULL)
659 ++p;
660 else
661 p = *t;
662#endif
663 if (ISDOT(p)) {
664 if (!complained++)
665 fprintf(stderr, "%s: \".\" and \"..\" may not be removed\n", argv0);
666 eval = 1;
667 for (save = t; (t[0] = t[1]) != NULL; ++t)
668 continue;
669 t = save;
670 } else
671 ++t;
672 }
673}
674
675static int
676usage(FILE *pf)
677{
678 fprintf(pf,
679 "usage: %s [options] file ...\n"
680 " or: %s --help\n"
681 " or: %s --version\n"
682 "\n"
683 "Options:\n"
684 " -f\n"
685 " Attempt to remove files without prompting, regardless of the file\n"
686 " permission. Ignore non-existing files. Overrides previous -i's.\n"
687 " -i\n"
688 " Prompt for each file. Always.\n"
689 " -d\n"
690 " Attempt to remove directories as well as other kinds of files.\n"
691 " -P\n"
692 " Overwrite regular files before deleting; three passes: ff,0,ff\n"
693 " -R\n"
694 " Attempt to remove the file hierachy rooted in each file argument.\n"
695 " This option implies -d and file protection.\n"
696 " -v\n"
697 " Be verbose, show files as they are removed.\n"
698 " -W\n"
699 " Undelete without files.\n"
700 " --disable-protection\n"
701 " Will disable the protection file protection applied with -R.\n"
702 " --enable-protection\n"
703 " Will enable the protection file protection applied with -R.\n"
704 " --enable-full-protection\n"
705 " Will enable the protection file protection for all operations.\n"
706 " --disable-full-protection\n"
707 " Will disable the protection file protection for all operations.\n"
708 " --protection-depth\n"
709 " Number or path indicating the file protection depth. Default: %d\n"
710 "\n"
711 "Environment:\n"
712 " KMK_RM_DISABLE_PROTECTION\n"
713 " Same as --disable-protection. Overrides command line.\n"
714 " KMK_RM_ENABLE_PROTECTION\n"
715 " Same as --enable-protection. Overrides everyone else.\n"
716 " KMK_RM_ENABLE_FULL_PROTECTION\n"
717 " Same as --enable-full-protection. Overrides everyone else.\n"
718 " KMK_RM_DISABLE_FULL_PROTECTION\n"
719 " Same as --disable-full-protection. Overrides command line.\n"
720 " KMK_RM_PROTECTION_DEPTH\n"
721 " Same as --protection-depth. Overrides command line.\n"
722 "\n"
723 "The file protection of the top %d layers of the file hierarchy is there\n"
724 "to try prevent makefiles from doing bad things to your system. This\n"
725 "protection is not bulletproof, but should help prevent you from shooting\n"
726 "yourself in the foot.\n"
727 ,
728 g_progname, g_progname, g_progname,
729 kBuildProtectionDefaultDepth(), kBuildProtectionDefaultDepth());
730 return EX_USAGE;
731}
Note: See TracBrowser for help on using the repository browser.