git.saurik.com Git - apple/file_cmds.git/blob

1 /*-

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 */

34 #include <sys/cdefs.h>

35 #ifndef lint

36 __used static const char copyright[] =

39 #endif /* not lint */

41 #ifndef lint

42 #if 0

43 static char sccsid[] = "@(#)rm.c 8.5 (Berkeley) 4/18/94";

44 #else

45 __used static const char rcsid[] =

46 "$FreeBSD: src/bin/rm/rm.c,v 1.33 2001/06/13 15:01:25 ru Exp $";

47 #endif

48 #endif /* not lint */

50 #include <sys/stat.h>

51 #include <sys/param.h>

52 #include <sys/mount.h>

54 #include <err.h>

55 #include <errno.h>

56 #include <fcntl.h>

57 #include <fts.h>

58 #include <stdio.h>

59 #include <stdlib.h>

60 #include <string.h>

61 #include <sysexits.h>

62 #include <unistd.h>

63 #include <locale.h>

65 #ifdef __APPLE__

66 #include <removefile.h>

67 #include <pwd.h>

68 #include <grp.h>

69 #include "get_compat.h"

71 #ifndef AT_REMOVEDIR_DATALESS

72 #define AT_REMOVEDIR_DATALESS 0x0100 /* Remove a dataless directory without materializing first */

73 #endif

74 #else

75 #define COMPAT_MODE(func, mode) 1

76 #endif

 int dflag, eval, fflag, iflag, Pflag, vflag, Wflag, stdin_ok;

79 uid_t uid;

 int     check __P((char *, char *, struct stat *));

 int checkdir __P((char *));

 int             yes_or_no __P((void));

 void    checkdot __P((char **));

 void    rm_file __P((char **));

 void    rm_overwrite __P((char *, struct stat *));

 void    rm_tree __P((char **));

 void    usage __P((void));

90 /*

91 * rm --

92 * This rm is different from historic rm's, but is expected to match

93 * POSIX 1003.2 behavior. The most visible difference is that -f

94 * has two specific effects now, ignore non-existent files and force

95 * file removal.

96 */

97 int

98 main(argc, argv)

99 int argc;

100 char *argv[];

101 {

102 int ch, rflag;

103 char *p;

104

         if (argc < 1)

106 usage();

107

108 /*

109 * Test for the special case where the utility is called as

110 * "unlink", for which the functionality provided is greatly

111 * simplified.

112 */

         if ((p = rindex(argv[0], '/')) == NULL)

114 p = argv[0];

115 else

116 ++p;

117 uid = geteuid();

         if (strcmp(p, "unlink") == 0) {

                 if (argc == 2) {

                         rm_file(&argv[1]);

121 exit(eval);

122 } else

123 usage();

124 }

125

126 Pflag = rflag = 0;

         while ((ch = getopt(argc, argv, "dfiPRrvW")) != -1)

128 switch(ch) {

129 case 'd':

130 dflag = 1;

131 break;

132 case 'f':

133 fflag = 1;

134 iflag = 0;

135 break;

136 case 'i':

137 fflag = 0;

138 iflag = 1;

139 break;

140 case 'P':

141 Pflag = 1;

142 break;

143 case 'R':

144 case 'r': /* Compatibility. */

145 rflag = 1;

146 break;

147 case 'v':

148 vflag = 1;

149 break;

150 case 'W':

151 Wflag = 1;

152 break;

153 default:

154 usage();

155 }

156 argc -= optind;

157 argv += optind;

158

         if (argc < 1) {

160 if (fflag)

161 return 0;

162 usage();

163 }

164

165 checkdot(argv);

166

167 if (*argv) {

168 stdin_ok = isatty(STDIN_FILENO);

169

170 if (rflag)

171 rm_tree(argv);

172 else

173 rm_file(argv);

174 }

175

176 exit (eval);

177 }

178

179 void

180 rm_tree(argv)

181 char **argv;

182 {

183 FTS *fts;

184 FTSENT *p;

185 int needstat;

186 int flags;

187 int rval;

         int wantConformance = COMPAT_MODE("bin/rm", "unix2003");

189 /*

190 * Remove a file hierarchy. If forcing removal (-f), or interactive

191 * (-i) or can't ask anyway (stdin_ok), don't stat the file.

192 */

         needstat = !uid || (!fflag && !iflag && stdin_ok);

194

195 /*

196 * If the -i option is specified, the user can skip on the pre-order

197 * visit. The fts_number field flags skipped directories.

198 */

199 #define SKIPPED 1

200

201 flags = FTS_PHYSICAL;

202 if (!needstat)

203 flags |= FTS_NOSTAT;

204 if (Wflag)

205 flags |= FTS_WHITEOUT;

         if (!(fts = fts_open(argv, flags, NULL))) {

                 if (fflag && errno == ENOENT)

208 return;

                 err(1, NULL);

210 }

         while ((p = fts_read(fts)) != NULL) {

212 switch (p->fts_info) {

213 case FTS_DNR:

                         if (!fflag || p->fts_errno != ENOENT) {

                                 warnx("%s: %s",

                                     p->fts_path, strerror(p->fts_errno));

217 eval = 1;

218 }

219 continue;

220 case FTS_ERR:

                         errx(1, "%s: %s", p->fts_path, strerror(p->fts_errno));

222 case FTS_NS:

223 /*

224 * FTS_NS: assume that if can't stat the file, it

225 * can't be unlinked.

226 */

227 if (!needstat)

228 break;

                         if (!fflag || p->fts_errno != ENOENT) {

                                 warnx("%s: %s",

                                     p->fts_path, strerror(p->fts_errno));

232 eval = 1;

233 }

234 continue;

235 case FTS_D:

236 /* Pre-order: give user chance to skip. */

237 /* In conformance mode the user is prompted to skip processing the contents.

238 * Then the option to delete the dir is presented post-order */

239 if (!fflag &&

                                         ( (wantConformance && !checkdir(p->fts_path)) ||

                                           (!wantConformance && !check(p->fts_path, p->fts_accpath, p->fts_statp))

242 )

243 ){

                                 (void)fts_set(fts, p, FTS_SKIP);

245 p->fts_number = SKIPPED;

246 }

247 else if (!uid &&

                                  (p->fts_statp->st_flags & (UF_APPEND|UF_IMMUTABLE)) &&

                                  !(p->fts_statp->st_flags & (SF_APPEND|SF_IMMUTABLE)) &&

250 chflags(p->fts_accpath,

                                          p->fts_statp->st_flags &= ~(UF_APPEND|UF_IMMUTABLE)) < 0)

252 goto err;

253 continue;

254 case FTS_DP:

255 /* Post-order: see if user skipped. */

                         if(p->fts_number == SKIPPED)/*in legacy mode, the user was prompted pre-order */

257 continue;

258 else if(wantConformance)

259 {

260 /* delete directory if force is on, or if user answers Y to prompt */

                                 if(fflag || check(p->fts_path, p->fts_accpath, p->fts_statp)) 

262 break;

263 else

264 continue;

265 }

266 break;

267 default:

268 if (!fflag &&

                             !check(p->fts_path, p->fts_accpath, p->fts_statp))

270 continue;

271 }

272

273 rval = 0;

274 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));

                 if (rval == 0) {

280 /*

281 * If we can't read or search the directory, may still be

282 * able to remove it. Don't print out the un{read,search}able

283 * message unless the remove fails.

284 */

285 switch (p->fts_info) {

286 case FTS_DP:

287 case FTS_DNR:

288 #if __APPLE__

                                 rval = unlinkat(AT_FDCWD, p->fts_accpath, AT_REMOVEDIR_DATALESS);

                                 if (rval == -1 && errno == EINVAL) {

291 /*

292 * Kernel rejected AT_REMOVEDIR_DATALESS?

293 * I guess we fall back on the painful

294 * route (but it's better than failing).

295 */

                                         rval = rmdir(p->fts_accpath);

297 }

298 #else

                                 rval = rmdir(p->fts_accpath);

300 #endif

                                 if (rval == 0 || (fflag && errno == ENOENT)) {

                                         if (rval == 0 && vflag)

                                                 (void)printf("%s\n",

304 p->fts_path);

305 continue;

306 }

307 break;

308

309 case FTS_W:

                                 rval = undelete(p->fts_accpath);

                                 if (rval == 0 && (fflag && errno == ENOENT)) {

312 if (vflag)

                                                 (void)printf("%s\n",

314 p->fts_path);

315 continue;

316 }

317 break;

318

319 default:

320 #ifdef __APPLE__

321 if (Pflag) {

                                         if (removefile(p->fts_accpath, NULL, REMOVEFILE_SECURE_7_PASS)) /* overwrites and unlinks */

323 eval = rval = 1;

324 } else

                                         rval = unlink(p->fts_accpath);

326 #else /* !__APPLE_ */

327 if (Pflag)

                                         rm_overwrite(p->fts_accpath, NULL);

                                 rval = unlink(p->fts_accpath);

330 #endif /* __APPLE__ */

                                 if (rval == 0 || (fflag && errno == ENOENT)) {

                                         if (rval == 0 && vflag)

                                                 (void)printf("%s\n",

334 p->fts_path);

335 continue;

336 }

337 }

338 }

339 err:

                 warn("%s", p->fts_path);

341 eval = 1;

342 }

343 if (errno)

                 err(1, "fts_read");

345 fts_close(fts);

346 }

347

348 void

349 rm_file(argv)

350 char **argv;

351 {

352 struct stat sb;

353 int rval;

354 char *f;

355

356 /*

357 * Remove a file. POSIX 1003.2 states that, by default, attempting

358 * to remove a directory is an error, so must always stat the file.

359 */

         while ((f = *argv++) != NULL) {

361 /* Assume if can't stat the file, can't unlink it. */

                 if (lstat(f, &sb)) {

363 if (Wflag) {

                                 sb.st_mode = S_IFWHT|S_IWUSR|S_IRUSR;

365 } else {

                                 if (!fflag || errno != ENOENT) {

                                         warn("%s", f);

368 eval = 1;

369 }

370 continue;

371 }

372 } else if (Wflag) {

                         warnx("%s: %s", f, strerror(EEXIST));

374 eval = 1;

375 continue;

376 }

377

                 if (S_ISDIR(sb.st_mode) && !dflag) {

                         warnx("%s: is a directory", f);

380 eval = 1;

381 continue;

382 }

                 if (!fflag && !S_ISWHT(sb.st_mode) && !check(f, f, &sb))

384 continue;

385 rval = 0;

386 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));

                 if (rval == 0) {

                         if (S_ISWHT(sb.st_mode))

392 rval = undelete(f);

                         else if (S_ISDIR(sb.st_mode))

394 rval = rmdir(f);

395 else {

396 #ifdef __APPLE__

397 if (Pflag) {

                                         if (removefile(f, NULL, REMOVEFILE_SECURE_7_PASS)) /* overwrites and unlinks */

399 eval = rval = 1;

400 } else

401 rval = unlink(f);

402 #else /* !__APPLE__ */

403 if (Pflag)

404 rm_overwrite(f, &sb);

405 rval = unlink(f);

406 #endif /* __APPLE__ */

407 }

408 }

                 if (rval && (!fflag || errno != ENOENT)) {

                         warn("%s", f);

411 eval = 1;

412 }

                 if (vflag && rval == 0)

                         (void)printf("%s\n", f);

415 }

416 }

417

418 /*

419 * rm_overwrite --

420 * Overwrite the file 3 times with varying bit patterns.

421 *

422 * XXX

423 * This is a cheap way to *really* delete files. Note that only regular

424 * files are deleted, directories (and therefore names) will remain.

425 * Also, this assumes a fixed-block file system (like FFS, or a V7 or a

426 * System V file system). In a logging file system, you'll have to have

427 * kernel support.

428 */

429 void

430 rm_overwrite(file, sbp)

431 char *file;

432 struct stat *sbp;

433 {

434 struct stat sb;

435 struct statfs fsb;

436 off_t len;

437 int bsize, fd, wlen;

438 char *buf = NULL;

439

440 if (sbp == NULL) {

                 if (lstat(file, &sb))

442 goto err;

443 sbp = &sb;

444 }

         if (!S_ISREG(sbp->st_mode))

446 return;

         if ((fd = open(file, O_WRONLY, 0)) == -1)

448 goto err;

         if (fstatfs(fd, &fsb) == -1)

450 goto err;

         bsize = MAX(fsb.f_iosize, 1024);

         if ((buf = malloc(bsize)) == NULL)

                 err(1, "malloc");

454

455 #define PASS(byte) { \

456 memset(buf, byte, bsize); \

457 for (len = sbp->st_size; len > 0; len -= wlen) { \

458 wlen = len < bsize ? (int)len : bsize; \

459 if (write(fd, buf, wlen) != wlen) \

460 goto err; \

461 } \

462 }

463 PASS(0xff);

         if (fsync(fd) || lseek(fd, (off_t)0, SEEK_SET))

465 goto err;

466 PASS(0x00);

         if (fsync(fd) || lseek(fd, (off_t)0, SEEK_SET))

468 goto err;

469 PASS(0xff);

         if (!fsync(fd) && !close(fd)) {

471 free(buf);

472 return;

473 }

474

475 err: eval = 1;

476 if (buf)

477 free(buf);

         warn("%s", file);

479 }

480

481 int

482 yes_or_no()

483 {

484 int ch, first;

         char resp[] = {'\0', '\0'};

486

         (void)fflush(stderr);

488

489 /* Load user specified locale */

         setlocale(LC_MESSAGES, "");

491

492 first = ch = getchar();

         while (ch != '\n' && ch != EOF)

494 ch = getchar();

495

496 /* only care about the first character */

497 resp[0] = first;

498

         return (rpmatch(resp) == 1);

500 }

501

502 int

503 checkdir(path)

504 char *path;

505 {

506 if(!iflag)

507 return 1; //if not interactive, process directory's contents

         (void)fprintf(stderr, "examine files in directory %s? ", path);

509 return yes_or_no();

510 }

511

512 int

 check(path, name, sp)

514 char *path, *name;

515 struct stat *sp;

516 {

         char modep[15], *flagsp;

518

519 /* Check -i first. */

520 if (iflag)

                 (void)fprintf(stderr, "remove %s? ", path);

522 else {

523 /*

524 * If it's not a symbolic link and it's unwritable and we're

525 * talking to a terminal, ask. Symbolic links are excluded

526 * because their permissions are meaningless. Check stdin_ok

527 * first because we may not have stat'ed the file.

528 */

                 if (!stdin_ok || S_ISLNK(sp->st_mode) ||

                     (!access(name, W_OK) &&

                     !(sp->st_flags & (SF_APPEND|SF_IMMUTABLE)) &&

                     (!(sp->st_flags & (UF_APPEND|UF_IMMUTABLE)) || !uid)))

533 return (1);

                 strmode(sp->st_mode, modep);

                 if ((flagsp = fflagstostr(sp->st_flags)) == NULL)

                         err(1, NULL);

                 (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 ? " " : "", 

542 path);

543 free(flagsp);

544 }

545 return yes_or_no();

546 }

547

548

 #define ISDOT(a)        ((a)[0] == '.' && (!(a)[1] || ((a)[1] == '.' && !(a)[2])))

550 void

551 checkdot(argv)

552 char **argv;

553 {

         char *p, **save, **t;

555 int complained;

556

557 complained = 0;

         for (t = argv; *t;) {

                 size_t len = strlen(*t);

560 char truncated[len];

561

                 if ((p = strrchr(*t, '/')) != NULL) {

                         if (p[1] == '\0') { // one or more trailing / -- treat as if not present

                                 for (; (p > *t) && (p[-1] == '/');) {

565 len--;

566 p--;

567 }

                                 strlcpy(truncated, *t, len);

                                 p = strrchr(truncated, '/');

570 if (p) {

571 ++p;

572 } else {

573 p = truncated;

574 }

575 } else {

576 ++p;

577 }

578 } else {

579 p = *t;

580 }

                 if (ISDOT(p)) {

582 if (!complained++)

                                 warnx("\".\" and \"..\" may not be removed");

584 eval = 1;

                         for (save = t; (t[0] = t[1]) != NULL; ++t)

586 continue;

587 t = save;

588 } else

589 ++t;

590 }

591 }

592

593 void

594 usage()

595 {

596

         (void)fprintf(stderr, "%s\n%s\n",

598 "usage: rm [-f | -i] [-dPRrvW] file ...",

599 " unlink file");

600 exit(EX_USAGE);

601 }