1 /* pred.c -- execute the expression tree.
2 Copyright (C) 1990, 1991, 1992, 1993, 1994, 2000, 2003,
3 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
27 #include <sys/types.h>
41 #include "printquoted.h"
45 #include "stat-time.h"
46 #include "dircallback.h"
52 # define _(Text) gettext (Text)
57 # define N_(String) gettext_noop (String)
59 /* See locate.c for explanation as to why not use (String) */
60 # define N_(String) String
63 #if !defined(SIGCHLD) && defined(SIGCLD)
64 #define SIGCHLD SIGCLD
71 # define NAMLEN(dirent) strlen((dirent)->d_name)
73 # define dirent direct
74 # define NAMLEN(dirent) (dirent)->d_namlen
76 # include <sys/ndir.h>
87 /* Fake a return value. */
88 #define CLOSEDIR(d) (closedir (d), 0)
90 #define CLOSEDIR(d) closedir (d)
96 /* Get or fake the disk device blocksize.
97 Usually defined by sys/param.h (if at all). */
100 # define DEV_BSIZE BSIZE
102 # define DEV_BSIZE 4096
104 #endif /* !DEV_BSIZE */
106 /* Extract or fake data from a `struct stat'.
107 ST_BLKSIZE: Preferred I/O blocksize for the file, in bytes.
108 ST_NBLOCKS: Number of blocks in the file, including indirect blocks.
109 ST_NBLOCKSIZE: Size of blocks used when calculating ST_NBLOCKS. */
110 #ifndef HAVE_STRUCT_STAT_ST_BLOCKS
111 # define ST_BLKSIZE(statbuf) DEV_BSIZE
112 # if defined _POSIX_SOURCE || !defined BSIZE /* fileblocks.c uses BSIZE. */
113 # define ST_NBLOCKS(statbuf) \
114 (S_ISREG ((statbuf).st_mode) \
115 || S_ISDIR ((statbuf).st_mode) \
116 ? (statbuf).st_size / ST_NBLOCKSIZE + ((statbuf).st_size % ST_NBLOCKSIZE != 0) : 0)
117 # else /* !_POSIX_SOURCE && BSIZE */
118 # define ST_NBLOCKS(statbuf) \
119 (S_ISREG ((statbuf).st_mode) \
120 || S_ISDIR ((statbuf).st_mode) \
121 ? st_blocks ((statbuf).st_size) : 0)
122 # endif /* !_POSIX_SOURCE && BSIZE */
123 #else /* HAVE_STRUCT_STAT_ST_BLOCKS */
124 /* Some systems, like Sequents, return st_blksize of 0 on pipes. */
125 # define ST_BLKSIZE(statbuf) ((statbuf).st_blksize > 0 \
126 ? (statbuf).st_blksize : DEV_BSIZE)
127 # if defined hpux || defined __hpux__ || defined __hpux
128 /* HP-UX counts st_blocks in 1024-byte units.
129 This loses when mixing HP-UX and BSD file systems with NFS. */
130 # define ST_NBLOCKSIZE 1024
132 # if defined _AIX && defined _I386
133 /* AIX PS/2 counts st_blocks in 4K units. */
134 # define ST_NBLOCKSIZE (4 * 1024)
135 # else /* not AIX PS/2 */
137 # define ST_NBLOCKS(statbuf) \
138 (S_ISREG ((statbuf).st_mode) \
139 || S_ISDIR ((statbuf).st_mode) \
140 ? (statbuf).st_blocks * ST_BLKSIZE(statbuf)/ST_NBLOCKSIZE : 0)
142 # endif /* not AIX PS/2 */
144 #endif /* HAVE_STRUCT_STAT_ST_BLOCKS */
147 # define ST_NBLOCKS(statbuf) \
148 (S_ISREG ((statbuf).st_mode) \
149 || S_ISDIR ((statbuf).st_mode) \
150 ? (statbuf).st_blocks : 0)
153 #ifndef ST_NBLOCKSIZE
154 # define ST_NBLOCKSIZE 512
159 #define MAX(a, b) ((a) > (b) ? (a) : (b))
161 static boolean match_lname
PARAMS((const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
, boolean ignore_case
));
163 static char *format_date
PARAMS((struct timespec ts
, int kind
));
164 static char *ctime_format
PARAMS((struct timespec ts
));
173 struct pred_assoc pred_table
[] =
175 {pred_amin
, "amin "},
177 {pred_anewer
, "anewer "},
178 {pred_atime
, "atime "},
179 {pred_closeparen
, ") "},
180 {pred_cmin
, "cmin "},
181 {pred_cnewer
, "cnewer "},
183 {pred_ctime
, "ctime "},
184 {pred_delete
, "delete "},
185 {pred_empty
, "empty "},
186 {pred_exec
, "exec "},
187 {pred_execdir
, "execdir "},
188 {pred_executable
, "executable "},
189 {pred_false
, "false "},
190 {pred_fprint
, "fprint "},
191 {pred_fprint0
, "fprint0 "},
192 {pred_fprintf
, "fprintf "},
193 {pred_fstype
, "fstype "},
195 {pred_group
, "group "},
196 {pred_ilname
, "ilname "},
197 {pred_iname
, "iname "},
198 {pred_inum
, "inum "},
199 {pred_ipath
, "ipath "},
200 {pred_links
, "links "},
201 {pred_lname
, "lname "},
203 {pred_mmin
, "mmin "},
204 {pred_mtime
, "mtime "},
205 {pred_name
, "name "},
206 {pred_negate
, "not "},
207 {pred_newer
, "newer "},
208 {pred_newerXY
, "newerXY "},
209 {pred_nogroup
, "nogroup "},
210 {pred_nouser
, "nouser "},
212 {pred_okdir
, "okdir "},
213 {pred_openparen
, "( "},
215 {pred_path
, "path "},
216 {pred_perm
, "perm "},
217 {pred_print
, "print "},
218 {pred_print0
, "print0 "},
219 {pred_prune
, "prune "},
220 {pred_quit
, "quit "},
221 {pred_readable
, "readable "},
222 {pred_regex
, "regex "},
223 {pred_samefile
,"samefile "},
224 {pred_size
, "size "},
225 {pred_true
, "true "},
226 {pred_type
, "type "},
228 {pred_used
, "used "},
229 {pred_user
, "user "},
230 {pred_writable
, "writable "},
231 {pred_xtype
, "xtype "},
236 /* Returns ts1 - ts2 */
237 static double ts_difference(struct timespec ts1
,
240 double d
= difftime(ts1
.tv_sec
, ts2
.tv_sec
)
241 + (1.0e-9 * (ts1
.tv_nsec
- ts2
.tv_nsec
));
247 compare_ts(struct timespec ts1
,
250 if ((ts1
.tv_sec
== ts2
.tv_sec
) &&
251 (ts1
.tv_nsec
== ts2
.tv_nsec
))
257 double diff
= ts_difference(ts1
, ts2
);
258 return diff
< 0.0 ? -1 : +1;
262 /* Predicate processing routines.
264 PATHNAME is the full pathname of the file being checked.
265 *STAT_BUF contains information about PATHNAME.
266 *PRED_PTR contains information for applying the predicate.
268 Return true if the file passes this predicate, false if not. */
273 * Returns true if THE_TIME is
274 * COMP_GT: after the specified time
275 * COMP_LT: before the specified time
276 * COMP_EQ: less than WINDOW seconds after the specified time.
279 pred_timewindow(struct timespec ts
, struct predicate
const *pred_ptr
, int window
)
281 switch (pred_ptr
->args
.reftime
.kind
)
284 return compare_ts(ts
, pred_ptr
->args
.reftime
.ts
) > 0;
287 return compare_ts(ts
, pred_ptr
->args
.reftime
.ts
) < 0;
291 double delta
= ts_difference(ts
, pred_ptr
->args
.reftime
.ts
);
292 return (delta
>= 0.0 && delta
< window
);
301 pred_amin (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
304 return pred_timewindow(get_stat_atime(stat_buf
), pred_ptr
, 60);
308 pred_and (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
310 if (pred_ptr
->pred_left
== NULL
311 || apply_predicate(pathname
, stat_buf
, pred_ptr
->pred_left
))
313 return apply_predicate(pathname
, stat_buf
, pred_ptr
->pred_right
);
320 pred_anewer (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
323 assert (COMP_GT
== pred_ptr
->args
.reftime
.kind
);
324 return compare_ts(get_stat_atime(stat_buf
), pred_ptr
->args
.reftime
.ts
) > 0;
328 pred_atime (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
331 return pred_timewindow(get_stat_atime(stat_buf
), pred_ptr
, DAYSECS
);
335 pred_closeparen (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
345 pred_cmin (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
348 return pred_timewindow(get_stat_ctime(stat_buf
), pred_ptr
, 60);
352 pred_cnewer (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
356 assert (COMP_GT
== pred_ptr
->args
.reftime
.kind
);
357 return compare_ts(get_stat_ctime(stat_buf
), pred_ptr
->args
.reftime
.ts
) > 0;
361 pred_comma (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
363 if (pred_ptr
->pred_left
!= NULL
)
365 apply_predicate(pathname
, stat_buf
,pred_ptr
->pred_left
);
367 return apply_predicate(pathname
, stat_buf
, pred_ptr
->pred_right
);
371 pred_ctime (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
374 return pred_timewindow(get_stat_ctime(stat_buf
), pred_ptr
, DAYSECS
);
378 perform_delete(int flags
)
380 return 0 == unlinkat(state
.cwd_dir_fd
, state
.rel_pathname
, flags
);
385 pred_delete (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
389 if (strcmp (state
.rel_pathname
, "."))
392 if (state
.have_stat
&& S_ISDIR(stat_buf
->st_mode
))
393 flags
|= AT_REMOVEDIR
;
394 if (perform_delete(flags
))
402 if ((flags
& AT_REMOVEDIR
) == 0)
404 /* unlink() operation failed because we should have done rmdir(). */
405 flags
|= AT_REMOVEDIR
;
406 if (perform_delete(flags
))
411 error (0, errno
, _("cannot delete %s"),
412 safely_quote_err_filename(0, pathname
));
413 /* Previously I had believed that having the -delete action
414 * return false provided the user with control over whether an
415 * error message is issued. While this is true, the policy of
416 * not affecting the exit status is contrary to the POSIX
417 * requirement that diagnostic messages are accompanied by a
418 * nonzero exit status. While -delete is not a POSIX option and
419 * we can therefore opt not to follow POSIX in this case, that
420 * seems somewhat arbitrary and confusing. So, as of
421 * findutils-4.3.11, we also set the exit status in this case.
423 state
.exit_status
= 1;
434 pred_empty (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
439 if (S_ISDIR (stat_buf
->st_mode
))
444 boolean empty
= true;
447 if ((fd
= openat(state
.cwd_dir_fd
, state
.rel_pathname
, O_RDONLY
448 #if defined O_LARGEFILE
453 error (0, errno
, "%s", safely_quote_err_filename(0, pathname
));
454 state
.exit_status
= 1;
460 error (0, errno
, "%s", safely_quote_err_filename(0, pathname
));
461 state
.exit_status
= 1;
464 for (dp
= readdir (d
); dp
; dp
= readdir (d
))
466 if (dp
->d_name
[0] != '.'
467 || (dp
->d_name
[1] != '\0'
468 && (dp
->d_name
[1] != '.' || dp
->d_name
[2] != '\0')))
476 error (0, errno
, "%s", safely_quote_err_filename(0, pathname
));
477 state
.exit_status
= 1;
482 else if (S_ISREG (stat_buf
->st_mode
))
483 return (stat_buf
->st_size
== 0);
489 new_impl_pred_exec (int dirfd
, const char *pathname
,
490 struct stat
*stat_buf
,
491 struct predicate
*pred_ptr
,
492 const char *prefix
, size_t pfxlen
)
494 struct exec_val
*execp
= &pred_ptr
->args
.exec_vec
;
495 size_t len
= strlen(pathname
);
498 execp
->dirfd
= dirfd
;
501 /* Push the argument onto the current list.
502 * The command may or may not be run at this point,
503 * depending on the command line length limits.
505 bc_push_arg(&execp
->ctl
,
511 /* remember that there are pending execdirs. */
512 state
.execdirs_outstanding
= true;
514 /* POSIX: If the primary expression is punctuated by a plus
515 * sign, the primary shall always evaluate as true
523 for (i
=0; i
<execp
->num_args
; ++i
)
525 bc_do_insert(&execp
->ctl
,
527 execp
->replace_vec
[i
],
528 strlen(execp
->replace_vec
[i
]),
534 /* Actually invoke the command. */
535 return execp
->ctl
.exec_callback(&execp
->ctl
,
542 pred_exec (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
544 return new_impl_pred_exec(get_start_dirfd(),
545 pathname
, stat_buf
, pred_ptr
, NULL
, 0);
549 pred_execdir (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
551 const char *prefix
= (state
.rel_pathname
[0] == '/') ? NULL
: "./";
553 return new_impl_pred_exec (get_current_dirfd(),
554 state
.rel_pathname
, stat_buf
, pred_ptr
,
555 prefix
, (prefix
? 2 : 0));
559 pred_false (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
570 pred_fls (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
572 FILE * stream
= pred_ptr
->args
.printf_vec
.stream
;
573 list_file (pathname
, state
.cwd_dir_fd
, state
.rel_pathname
, stat_buf
,
574 options
.start_time
.tv_sec
,
575 options
.output_block_size
,
576 pred_ptr
->literal_control_chars
, stream
);
581 pred_fprint (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
586 print_quoted(pred_ptr
->args
.printf_vec
.stream
,
587 pred_ptr
->args
.printf_vec
.quote_opts
,
588 pred_ptr
->args
.printf_vec
.dest_is_tty
,
595 pred_fprint0 (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
597 FILE * fp
= pred_ptr
->args
.printf_vec
.stream
;
601 fputs (pathname
, fp
);
609 mode_to_filetype(mode_t m
)
611 #define HANDLE_TYPE(t,letter) if (m==t) { return letter; }
613 HANDLE_TYPE(S_IFREG
, "f"); /* regular file */
616 HANDLE_TYPE(S_IFDIR
, "d"); /* directory */
619 HANDLE_TYPE(S_IFLNK
, "l"); /* symbolic link */
622 HANDLE_TYPE(S_IFSOCK
, "s"); /* Unix domain socket */
625 HANDLE_TYPE(S_IFBLK
, "b"); /* block device */
628 HANDLE_TYPE(S_IFCHR
, "c"); /* character device */
631 HANDLE_TYPE(S_IFIFO
, "p"); /* FIFO */
634 HANDLE_TYPE(S_IFDOOR
, "D"); /* Door (e.g. on Solaris) */
636 return "U"; /* Unknown */
640 file_sparseness(const struct stat
*p
)
642 #if defined HAVE_STRUCT_STAT_ST_BLOCKS
645 if (0 == p
->st_blocks
)
648 return p
->st_blocks
< 0 ? -HUGE_VAL
: HUGE_VAL
;
652 double blklen
= file_blocksize(p
) * (double)p
->st_blocks
;
653 return blklen
/ p
->st_size
;
663 checked_fprintf(struct format_val
*dest
, const char *fmt
, ...)
669 rv
= vfprintf(dest
->stream
, fmt
, ap
);
671 nonfatal_file_error(dest
->filename
);
676 checked_print_quoted (struct format_val
*dest
,
677 const char *format
, const char *s
)
679 int rv
= print_quoted(dest
->stream
, dest
->quote_opts
, dest
->dest_is_tty
,
682 nonfatal_file_error(dest
->filename
);
687 checked_fwrite(void *p
, size_t siz
, size_t nmemb
, struct format_val
*dest
)
689 int items_written
= fwrite(p
, siz
, nmemb
, dest
->stream
);
690 if (items_written
< nmemb
)
691 nonfatal_file_error(dest
->filename
);
695 checked_fflush(struct format_val
*dest
)
697 if (0 != fflush(dest
->stream
))
699 nonfatal_file_error(dest
->filename
);
704 do_fprintf(struct format_val
*dest
,
705 struct segment
*segment
,
706 const char *pathname
,
707 const struct stat
*stat_buf
)
709 char hbuf
[LONGEST_HUMAN_READABLE
+ 1];
712 switch (segment
->segkind
)
714 case KIND_PLAIN
: /* Plain text string (no % conversion). */
716 checked_fwrite(segment
->text
, 1, segment
->text_len
, dest
);
719 case KIND_STOP
: /* Terminate argument and flush output. */
721 checked_fwrite(segment
->text
, 1, segment
->text_len
, dest
);
722 checked_fflush(dest
);
726 switch (segment
->format_char
[0])
728 case 'a': /* atime in `ctime' format. */
729 /* UNTRUSTED, probably unexploitable */
730 checked_fprintf (dest
, segment
->text
, ctime_format (get_stat_atime(stat_buf
)));
732 case 'b': /* size in 512-byte blocks */
733 /* UNTRUSTED, probably unexploitable */
734 checked_fprintf (dest
, segment
->text
,
735 human_readable ((uintmax_t) ST_NBLOCKS (*stat_buf
),
737 ST_NBLOCKSIZE
, 512));
739 case 'c': /* ctime in `ctime' format */
740 /* UNTRUSTED, probably unexploitable */
741 checked_fprintf (dest
, segment
->text
, ctime_format (get_stat_ctime(stat_buf
)));
743 case 'd': /* depth in search tree */
744 /* UNTRUSTED, probably unexploitable */
745 checked_fprintf (dest
, segment
->text
, state
.curdepth
);
747 case 'D': /* Device on which file exists (stat.st_dev) */
749 checked_fprintf (dest
, segment
->text
,
750 human_readable ((uintmax_t) stat_buf
->st_dev
, hbuf
,
751 human_ceiling
, 1, 1));
753 case 'f': /* base name of path */
756 char *base
= base_name (pathname
);
757 checked_print_quoted (dest
, segment
->text
, base
);
761 case 'F': /* file system type */
763 checked_print_quoted (dest
, segment
->text
, filesystem_type (stat_buf
, pathname
));
765 case 'g': /* group name */
767 /* (well, the actual group is selected by the user but
768 * its name was selected by the system administrator)
773 g
= getgrgid (stat_buf
->st_gid
);
776 segment
->text
[segment
->text_len
] = 's';
777 checked_fprintf (dest
, segment
->text
, g
->gr_name
);
786 /*FALLTHROUGH*/ /*...sometimes, so 'G' case.*/
788 case 'G': /* GID number */
789 /* UNTRUSTED, probably unexploitable */
790 checked_fprintf (dest
, segment
->text
,
791 human_readable ((uintmax_t) stat_buf
->st_gid
, hbuf
,
792 human_ceiling
, 1, 1));
794 case 'h': /* leading directories part of path */
797 cp
= strrchr (pathname
, '/');
798 if (cp
== NULL
) /* No leading directories. */
800 /* If there is no slash in the pathname, we still
801 * print the string because it contains characters
802 * other than just '%s'. The %h expands to ".".
804 checked_print_quoted (dest
, segment
->text
, ".");
808 char *s
= strdup(pathname
);
809 s
[cp
- pathname
] = 0;
810 checked_print_quoted (dest
, segment
->text
, s
);
816 case 'H': /* ARGV element file was found under */
819 char *s
= xmalloc(state
.starting_path_length
+1);
820 memcpy(s
, pathname
, state
.starting_path_length
);
821 s
[state
.starting_path_length
] = 0;
822 checked_fprintf (dest
, segment
->text
, s
);
827 case 'i': /* inode number */
828 /* UNTRUSTED, but not exploitable I think */
829 checked_fprintf (dest
, segment
->text
,
830 human_readable ((uintmax_t) stat_buf
->st_ino
, hbuf
,
834 case 'k': /* size in 1K blocks */
835 /* UNTRUSTED, but not exploitable I think */
836 checked_fprintf (dest
, segment
->text
,
837 human_readable ((uintmax_t) ST_NBLOCKS (*stat_buf
),
839 ST_NBLOCKSIZE
, 1024));
841 case 'l': /* object of symlink */
847 if (S_ISLNK (stat_buf
->st_mode
))
849 linkname
= get_link_name_at (pathname
, state
.cwd_dir_fd
, state
.rel_pathname
);
851 state
.exit_status
= 1;
855 checked_print_quoted (dest
, segment
->text
, linkname
);
860 /* We still need to honour the field width etc., so this is
863 checked_print_quoted (dest
, segment
->text
, "");
869 case 'M': /* mode as 10 chars (eg., "-rwxr-x--x" */
870 /* UNTRUSTED, probably unexploitable */
872 char modestring
[16] ;
873 filemodestring (stat_buf
, modestring
);
874 modestring
[10] = '\0';
875 checked_fprintf (dest
, segment
->text
, modestring
);
879 case 'm': /* mode as octal number (perms only) */
880 /* UNTRUSTED, probably unexploitable */
882 /* Output the mode portably using the traditional numbers,
883 even if the host unwisely uses some other numbering
884 scheme. But help the compiler in the common case where
885 the host uses the traditional numbering scheme. */
886 mode_t m
= stat_buf
->st_mode
;
887 boolean traditional_numbering_scheme
=
888 (S_ISUID
== 04000 && S_ISGID
== 02000 && S_ISVTX
== 01000
889 && S_IRUSR
== 00400 && S_IWUSR
== 00200 && S_IXUSR
== 00100
890 && S_IRGRP
== 00040 && S_IWGRP
== 00020 && S_IXGRP
== 00010
891 && S_IROTH
== 00004 && S_IWOTH
== 00002 && S_IXOTH
== 00001);
892 checked_fprintf (dest
, segment
->text
,
893 (traditional_numbering_scheme
895 : ((m
& S_ISUID
? 04000 : 0)
896 | (m
& S_ISGID
? 02000 : 0)
897 | (m
& S_ISVTX
? 01000 : 0)
898 | (m
& S_IRUSR
? 00400 : 0)
899 | (m
& S_IWUSR
? 00200 : 0)
900 | (m
& S_IXUSR
? 00100 : 0)
901 | (m
& S_IRGRP
? 00040 : 0)
902 | (m
& S_IWGRP
? 00020 : 0)
903 | (m
& S_IXGRP
? 00010 : 0)
904 | (m
& S_IROTH
? 00004 : 0)
905 | (m
& S_IWOTH
? 00002 : 0)
906 | (m
& S_IXOTH
? 00001 : 0))));
910 case 'n': /* number of links */
911 /* UNTRUSTED, probably unexploitable */
912 checked_fprintf (dest
, segment
->text
,
913 human_readable ((uintmax_t) stat_buf
->st_nlink
,
919 case 'p': /* pathname */
921 checked_print_quoted (dest
, segment
->text
, pathname
);
924 case 'P': /* pathname with ARGV element stripped */
926 if (state
.curdepth
> 0)
928 cp
= pathname
+ state
.starting_path_length
;
930 /* Move past the slash between the ARGV element
931 and the rest of the pathname. But if the ARGV element
932 ends in a slash, we didn't add another, so we've
933 already skipped past it. */
940 checked_print_quoted (dest
, segment
->text
, cp
);
943 case 's': /* size in bytes */
944 /* UNTRUSTED, probably unexploitable */
945 checked_fprintf (dest
, segment
->text
,
946 human_readable ((uintmax_t) stat_buf
->st_size
,
947 hbuf
, human_ceiling
, 1, 1));
950 case 'S': /* sparseness */
951 /* UNTRUSTED, probably unexploitable */
952 checked_fprintf (dest
, segment
->text
, file_sparseness(stat_buf
));;
955 case 't': /* mtime in `ctime' format */
956 /* UNTRUSTED, probably unexploitable */
957 checked_fprintf (dest
, segment
->text
,
958 ctime_format (get_stat_mtime(stat_buf
)));
961 case 'u': /* user name */
963 /* (well, the actual user is selected by the user on systems
964 * where chown is not restricted, but the user name was
965 * selected by the system administrator)
970 p
= getpwuid (stat_buf
->st_uid
);
973 segment
->text
[segment
->text_len
] = 's';
974 checked_fprintf (dest
, segment
->text
, p
->pw_name
);
979 /* FALLTHROUGH*/ /* .. to case U */
981 case 'U': /* UID number */
982 /* UNTRUSTED, probably unexploitable */
983 checked_fprintf (dest
, segment
->text
,
984 human_readable ((uintmax_t) stat_buf
->st_uid
, hbuf
,
985 human_ceiling
, 1, 1));
988 /* %Y: type of file system entry like `ls -l`:
989 * (d,-,l,s,p,b,c,n) n=nonexistent(symlink)
991 case 'Y': /* in case of symlink */
995 if (S_ISLNK (stat_buf
->st_mode
))
998 /* If we would normally follow links, do not do so.
999 * If we would normally not follow links, do so.
1001 if ((following_links() ? lstat
: stat
)
1002 (state
.rel_pathname
, &sbuf
) != 0)
1004 if ( errno
== ENOENT
)
1006 checked_fprintf (dest
, segment
->text
, "N");
1009 else if ( errno
== ELOOP
)
1011 checked_fprintf (dest
, segment
->text
, "L");
1016 checked_fprintf (dest
, segment
->text
, "?");
1017 error (0, errno
, "%s",
1018 safely_quote_err_filename(0, pathname
));
1024 checked_fprintf (dest
, segment
->text
,
1025 mode_to_filetype(sbuf
.st_mode
& S_IFMT
));
1027 #endif /* S_ISLNK */
1030 checked_fprintf (dest
, segment
->text
,
1031 mode_to_filetype(stat_buf
->st_mode
& S_IFMT
));
1039 checked_fprintf (dest
, segment
->text
,
1040 mode_to_filetype(stat_buf
->st_mode
& S_IFMT
));
1044 /* end of KIND_FORMAT case */
1050 pred_fprintf (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1052 struct format_val
*dest
= &pred_ptr
->args
.printf_vec
;
1053 struct segment
*segment
;
1055 for (segment
= dest
->segment
; segment
; segment
= segment
->next
)
1057 if ( (KIND_FORMAT
== segment
->segkind
) && segment
->format_char
[1]) /* Component of date. */
1062 switch (segment
->format_char
[0])
1065 ts
= get_stat_atime(stat_buf
);
1069 ts
= get_stat_birthtime(stat_buf
);
1070 if ('@' == segment
->format_char
[1])
1073 valid
= (ts
.tv_nsec
>= 0);
1076 ts
= get_stat_ctime(stat_buf
);
1080 ts
= get_stat_mtime(stat_buf
);
1087 /* We trust the output of format_date not to contain
1088 * nasty characters, though the value of the date
1089 * is itself untrusted data.
1094 checked_fprintf (dest
, segment
->text
,
1095 format_date (ts
, segment
->format_char
[1]));
1099 /* The specified timestamp is not available, output
1100 * nothing for the timestamp, but use the rest (so that
1101 * for example find foo -printf '[%Bs] %p\n' can print
1105 checked_fprintf (dest
, segment
->text
, "");
1110 /* Print a segment which is not a date. */
1111 do_fprintf(dest
, segment
, pathname
, stat_buf
);
1118 pred_fstype (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1122 if (strcmp (filesystem_type (stat_buf
, pathname
), pred_ptr
->args
.str
) == 0)
1129 pred_gid (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1133 switch (pred_ptr
->args
.numinfo
.kind
)
1136 if (stat_buf
->st_gid
> pred_ptr
->args
.numinfo
.l_val
)
1140 if (stat_buf
->st_gid
< pred_ptr
->args
.numinfo
.l_val
)
1144 if (stat_buf
->st_gid
== pred_ptr
->args
.numinfo
.l_val
)
1152 pred_group (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1156 if (pred_ptr
->args
.gid
== stat_buf
->st_gid
)
1163 pred_ilname (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1165 return match_lname (pathname
, stat_buf
, pred_ptr
, true);
1168 /* Common code between -name, -iname. PATHNAME is being visited, STR
1169 is name to compare basename against, and FLAGS are passed to
1170 fnmatch. Recall that 'find / -name /' is one of the few times where a '/'
1171 in the -name must actually find something. */
1173 pred_name_common (const char *pathname
, const char *str
, int flags
)
1177 /* We used to use last_component() here, but that would not allow us to modify the
1178 * input string, which is const. We could optimise by duplicating the string only
1179 * if we need to modify it, and I'll do that if there is a measurable
1180 * performance difference on a machine built after 1990...
1182 char *base
= base_name (pathname
);
1183 /* remove trailing slashes, but leave "/" or "//foo" unchanged. */
1184 strip_trailing_slashes(base
);
1186 /* FNM_PERIOD is not used here because POSIX requires that it not be.
1187 * See http://standards.ieee.org/reading/ieee/interp/1003-2-92_int/pasc-1003.2-126.html
1189 b
= fnmatch (str
, base
, flags
) == 0;
1195 pred_iname (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1198 return pred_name_common (pathname
, pred_ptr
->args
.str
, FNM_CASEFOLD
);
1202 pred_inum (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1206 switch (pred_ptr
->args
.numinfo
.kind
)
1209 if (stat_buf
->st_ino
> pred_ptr
->args
.numinfo
.l_val
)
1213 if (stat_buf
->st_ino
< pred_ptr
->args
.numinfo
.l_val
)
1217 if (stat_buf
->st_ino
== pred_ptr
->args
.numinfo
.l_val
)
1225 pred_ipath (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1229 if (fnmatch (pred_ptr
->args
.str
, pathname
, FNM_CASEFOLD
) == 0)
1235 pred_links (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1239 switch (pred_ptr
->args
.numinfo
.kind
)
1242 if (stat_buf
->st_nlink
> pred_ptr
->args
.numinfo
.l_val
)
1246 if (stat_buf
->st_nlink
< pred_ptr
->args
.numinfo
.l_val
)
1250 if (stat_buf
->st_nlink
== pred_ptr
->args
.numinfo
.l_val
)
1258 pred_lname (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1260 return match_lname (pathname
, stat_buf
, pred_ptr
, false);
1264 match_lname (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
, boolean ignore_case
)
1266 boolean ret
= false;
1268 if (S_ISLNK (stat_buf
->st_mode
))
1270 char *linkname
= get_link_name_at (pathname
, state
.cwd_dir_fd
, state
.rel_pathname
);
1273 if (fnmatch (pred_ptr
->args
.str
, linkname
,
1274 ignore_case
? FNM_CASEFOLD
: 0) == 0)
1279 #endif /* S_ISLNK */
1284 pred_ls (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1286 return pred_fls(pathname
, stat_buf
, pred_ptr
);
1290 pred_mmin (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1293 return pred_timewindow(get_stat_mtime(stat_buf
), pred_ptr
, 60);
1297 pred_mtime (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1300 return pred_timewindow(get_stat_mtime(stat_buf
), pred_ptr
, DAYSECS
);
1304 pred_name (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1307 return pred_name_common (pathname
, pred_ptr
->args
.str
, 0);
1311 pred_negate (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1313 return !apply_predicate(pathname
, stat_buf
, pred_ptr
->pred_right
);
1317 pred_newer (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1321 assert (COMP_GT
== pred_ptr
->args
.reftime
.kind
);
1322 return compare_ts(get_stat_mtime(stat_buf
), pred_ptr
->args
.reftime
.ts
) > 0;
1326 pred_newerXY (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1329 boolean collected
= false;
1331 assert (COMP_GT
== pred_ptr
->args
.reftime
.kind
);
1333 switch (pred_ptr
->args
.reftime
.xval
)
1336 assert (pred_ptr
->args
.reftime
.xval
!= XVAL_TIME
);
1340 ts
= get_stat_atime(stat_buf
);
1344 case XVAL_BIRTHTIME
:
1345 ts
= get_stat_birthtime(stat_buf
);
1347 if (ts
.tv_nsec
< 0);
1349 /* XXX: Cannot determine birth time. Warn once. */
1350 error(0, 0, _("Warning: cannot determine birth time of file %s"),
1351 safely_quote_err_filename(0, pathname
));
1357 ts
= get_stat_ctime(stat_buf
);
1362 ts
= get_stat_mtime(stat_buf
);
1368 return compare_ts(ts
, pred_ptr
->args
.reftime
.ts
) > 0;
1372 pred_nogroup (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1378 extern char *gid_unused
;
1380 return gid_unused
[(unsigned) stat_buf
->st_gid
];
1382 return getgrgid (stat_buf
->st_gid
) == NULL
;
1387 pred_nouser (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1390 extern char *uid_unused
;
1397 return uid_unused
[(unsigned) stat_buf
->st_uid
];
1399 return getpwuid (stat_buf
->st_uid
) == NULL
;
1405 is_ok(const char *program
, const char *arg
)
1408 /* The draft open standard requires that, in the POSIX locale,
1409 the last non-blank character of this prompt be '?'.
1410 The exact format is not specified.
1411 This standard does not have requirements for locales other than POSIX
1413 /* XXX: printing UNTRUSTED data here. */
1414 fprintf (stderr
, _("< %s ... %s > ? "), program
, arg
);
1420 pred_ok (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1422 if (is_ok(pred_ptr
->args
.exec_vec
.replace_vec
[0], pathname
))
1423 return new_impl_pred_exec (get_start_dirfd(),
1424 pathname
, stat_buf
, pred_ptr
, NULL
, 0);
1430 pred_okdir (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1432 const char *prefix
= (state
.rel_pathname
[0] == '/') ? NULL
: "./";
1433 if (is_ok(pred_ptr
->args
.exec_vec
.replace_vec
[0], pathname
))
1434 return new_impl_pred_exec (get_current_dirfd(),
1435 state
.rel_pathname
, stat_buf
, pred_ptr
,
1436 prefix
, (prefix
? 2 : 0));
1442 pred_openparen (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1451 pred_or (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1453 if (pred_ptr
->pred_left
== NULL
1454 || !apply_predicate(pathname
, stat_buf
, pred_ptr
->pred_left
))
1456 return apply_predicate(pathname
, stat_buf
, pred_ptr
->pred_right
);
1463 pred_path (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1466 if (fnmatch (pred_ptr
->args
.str
, pathname
, 0) == 0)
1472 pred_perm (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1474 mode_t mode
= stat_buf
->st_mode
;
1475 mode_t perm_val
= pred_ptr
->args
.perm
.val
[S_ISDIR (mode
) != 0];
1477 switch (pred_ptr
->args
.perm
.kind
)
1480 return (mode
& perm_val
) == perm_val
;
1484 /* True if any of the bits set in the mask are also set in the file's mode.
1487 * Otherwise, if onum is prefixed by a hyphen, the primary shall
1488 * evaluate as true if at least all of the bits specified in
1489 * onum that are also set in the octal mask 07777 are set.
1491 * Eric Blake's interpretation is that the mode argument is zero,
1495 return true; /* Savannah bug 14748; we used to return false */
1497 return (mode
& perm_val
) != 0;
1501 return (mode
& MODE_ALL
) == perm_val
;
1511 struct access_check_args
1513 const char *filename
;
1520 access_callback(void *context
)
1523 struct access_check_args
*args
= context
;
1524 if ((rv
= access(args
->filename
, args
->access_type
)) < 0)
1525 args
->cb_errno
= errno
;
1530 can_access(int access_type
)
1532 struct access_check_args args
;
1533 args
.filename
= state
.rel_pathname
;
1534 args
.access_type
= access_type
;
1536 return 0 == run_in_dir(state
.cwd_dir_fd
, access_callback
, &args
);
1541 pred_executable (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1547 return can_access(X_OK
);
1551 pred_readable (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1557 return can_access(R_OK
);
1561 pred_writable (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1567 return can_access(W_OK
);
1571 pred_print (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1576 print_quoted(pred_ptr
->args
.printf_vec
.stream
,
1577 pred_ptr
->args
.printf_vec
.quote_opts
,
1578 pred_ptr
->args
.printf_vec
.dest_is_tty
,
1584 pred_print0 (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1586 return pred_fprint0(pathname
, stat_buf
, pred_ptr
);
1590 pred_prune (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1595 if (options
.do_dir_first
== true && /* no effect with -depth */
1597 S_ISDIR(stat_buf
->st_mode
))
1598 state
.stop_at_current_level
= true;
1600 /* findutils used to return options.do_dir_first here, so that -prune
1601 * returns true only if -depth is not in effect. But POSIX requires
1602 * that -prune always evaluate as true.
1608 pred_quit (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1614 /* Run any cleanups. This includes executing any command lines
1615 * we have partly built but not executed.
1619 /* Since -exec and friends don't leave child processes running in the
1620 * background, there is no need to wait for them here.
1622 exit(state
.exit_status
); /* 0 for success, etc. */
1626 pred_regex (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1628 int len
= strlen (pathname
);
1630 if (re_match (pred_ptr
->args
.regex
, pathname
, len
, 0,
1631 (struct re_registers
*) NULL
) == len
)
1637 pred_size (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1642 f_val
= ((stat_buf
->st_size
/ pred_ptr
->args
.size
.blocksize
)
1643 + (stat_buf
->st_size
% pred_ptr
->args
.size
.blocksize
!= 0));
1644 switch (pred_ptr
->args
.size
.kind
)
1647 if (f_val
> pred_ptr
->args
.size
.size
)
1651 if (f_val
< pred_ptr
->args
.size
.size
)
1655 if (f_val
== pred_ptr
->args
.size
.size
)
1663 pred_samefile (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1665 /* Potential optimisation: because of the loop protection, we always
1666 * know the device of the current directory, hence the device number
1667 * of the file we're currently considering. If -L is not in effect,
1668 * and the device number of the file we're looking for is not the
1669 * same as the device number of the current directory, this
1670 * predicate cannot return true. Hence there would be no need to
1671 * stat the file we're looking at.
1675 /* We will often still have an fd open on the file under consideration,
1676 * but that's just to ensure inode number stability by maintaining
1677 * a reference to it; we don't need the file for anything else.
1679 return stat_buf
->st_ino
== pred_ptr
->args
.samefileid
.ino
1680 && stat_buf
->st_dev
== pred_ptr
->args
.samefileid
.dev
;
1684 pred_true (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1693 pred_type (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1696 mode_t type
= pred_ptr
->args
.type
;
1698 assert (state
.have_type
);
1700 if (0 == state
.type
)
1702 /* This can sometimes happen with broken NFS servers.
1703 * See Savannah bug #16378.
1710 if (state
.have_stat
)
1711 mode
= stat_buf
->st_mode
;
1716 /* POSIX system; check `mode' the slow way. */
1717 if ((S_ISBLK (mode
) && type
== S_IFBLK
)
1718 || (S_ISCHR (mode
) && type
== S_IFCHR
)
1719 || (S_ISDIR (mode
) && type
== S_IFDIR
)
1720 || (S_ISREG (mode
) && type
== S_IFREG
)
1722 || (S_ISLNK (mode
) && type
== S_IFLNK
)
1725 || (S_ISFIFO (mode
) && type
== S_IFIFO
)
1728 || (S_ISSOCK (mode
) && type
== S_IFSOCK
)
1731 || (S_ISDOOR (mode
) && type
== S_IFDOOR
)
1735 /* Unix system; check `mode' the fast way. */
1736 if ((mode
& S_IFMT
) == type
)
1744 pred_uid (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1747 switch (pred_ptr
->args
.numinfo
.kind
)
1750 if (stat_buf
->st_uid
> pred_ptr
->args
.numinfo
.l_val
)
1754 if (stat_buf
->st_uid
< pred_ptr
->args
.numinfo
.l_val
)
1758 if (stat_buf
->st_uid
== pred_ptr
->args
.numinfo
.l_val
)
1766 pred_used (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1768 struct timespec delta
, at
, ct
;
1772 /* TODO: this needs to be retested carefully (manually, if necessary) */
1773 at
= get_stat_atime(stat_buf
);
1774 ct
= get_stat_ctime(stat_buf
);
1775 delta
.tv_sec
= at
.tv_sec
- ct
.tv_sec
;
1776 delta
.tv_nsec
= at
.tv_nsec
- ct
.tv_nsec
;
1777 if (delta
.tv_nsec
< 0)
1779 delta
.tv_nsec
+= 1000000000;
1782 return pred_timewindow(delta
, pred_ptr
, DAYSECS
);
1786 pred_user (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1789 if (pred_ptr
->args
.uid
== stat_buf
->st_uid
)
1796 pred_xtype (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1798 struct stat sbuf
; /* local copy, not stat_buf because we're using a different stat method */
1799 int (*ystat
) (const char*, struct stat
*p
);
1801 /* If we would normally stat the link itself, stat the target instead.
1802 * If we would normally follow the link, stat the link itself instead.
1804 if (following_links())
1805 ystat
= optionp_stat
;
1807 ystat
= optionl_stat
;
1809 set_stat_placeholders(&sbuf
);
1810 if ((*ystat
) (state
.rel_pathname
, &sbuf
) != 0)
1812 if (following_links() && errno
== ENOENT
)
1814 /* If we failed to follow the symlink,
1815 * fall back on looking at the symlink itself.
1817 /* Mimic behavior of ls -lL. */
1818 return (pred_type (pathname
, stat_buf
, pred_ptr
));
1822 error (0, errno
, "%s", safely_quote_err_filename(0, pathname
));
1823 state
.exit_status
= 1;
1827 /* Now that we have our stat() information, query it in the same
1828 * way that -type does.
1830 return (pred_type (pathname
, &sbuf
, pred_ptr
));
1833 /* 1) fork to get a child; parent remembers the child pid
1834 2) child execs the command requested
1835 3) parent waits for child; checks for proper pid of child
1839 ret errno status(h) status(l)
1841 pid x signal# 0177 stopped
1842 pid x exit arg 0 term by _exit
1843 pid x 0 signal # term by signal
1844 -1 EINTR parent got signal
1845 -1 other some other kind of error
1847 Return true only if the pid matches, status(l) is
1848 zero, and the exit arg (status high) is 0.
1849 Otherwise return false, possibly printing an error message. */
1853 prep_child_for_exec (boolean close_stdin
, int dirfd
)
1858 const char inputfile
[] = "/dev/null";
1862 error(0, errno
, _("Cannot close standard input"));
1867 if (open(inputfile
, O_RDONLY
1868 #if defined O_LARGEFILE
1873 /* This is not entirely fatal, since
1874 * executing the child with a closed
1875 * stdin is almost as good as executing it
1876 * with its stdin attached to /dev/null.
1878 error (0, errno
, "%s", safely_quote_err_filename(0, inputfile
));
1879 /* do not set ok=false, it is OK to continue anyway. */
1884 /* Even if DebugSearch is set, don't announce our change of
1885 * directory, since we're not going to emit a subsequent
1886 * announcement of a call to stat() anyway, as we're about to exec
1889 if (dirfd
!= AT_FDCWD
)
1891 assert (dirfd
>= 0);
1892 if (0 != fchdir(dirfd
))
1894 /* If we cannot execute our command in the correct directory,
1895 * we should not execute it at all.
1897 error(0, errno
, _("Failed to change directory"));
1907 launch (const struct buildcmd_control
*ctl
,
1908 struct buildcmd_state
*buildstate
)
1912 static int first_time
= 1;
1913 const struct exec_val
*execp
= buildstate
->usercontext
;
1915 if (!execp
->use_current_dir
)
1917 assert (starting_desc
>= 0);
1918 assert (execp
->dirfd
== starting_desc
);
1922 /* Null terminate the arg list. */
1923 bc_push_arg (ctl
, buildstate
, (char *) NULL
, 0, NULL
, 0, false);
1925 /* Make sure output of command doesn't get mixed with find output. */
1929 /* Make sure to listen for the kids. */
1933 signal (SIGCHLD
, SIG_DFL
);
1936 child_pid
= fork ();
1937 if (child_pid
== -1)
1938 error (1, errno
, _("cannot fork"));
1941 /* We are the child. */
1942 assert (starting_desc
>= 0);
1943 if (!prep_child_for_exec(execp
->close_stdin
, execp
->dirfd
))
1948 execvp (buildstate
->cmd_argv
[0], buildstate
->cmd_argv
);
1949 error (0, errno
, "%s",
1950 safely_quote_err_filename(0, buildstate
->cmd_argv
[0]));
1955 /* In parent; set up for next time. */
1956 bc_clear_args(ctl
, buildstate
);
1959 while (waitpid (child_pid
, &wait_status
, 0) == (pid_t
) -1)
1963 error (0, errno
, _("error waiting for %s"),
1964 safely_quote_err_filename(0, buildstate
->cmd_argv
[0]));
1965 state
.exit_status
= 1;
1966 return 0; /* FAIL */
1970 if (WIFSIGNALED (wait_status
))
1972 error (0, 0, _("%s terminated by signal %d"),
1973 quotearg_n_style(0, options
.err_quoting_style
,
1974 buildstate
->cmd_argv
[0]),
1975 WTERMSIG (wait_status
));
1977 if (execp
->multiple
)
1979 /* -exec \; just returns false if the invoked command fails.
1980 * -exec {} + returns true if the invoked command fails, but
1981 * sets the program exit status.
1983 state
.exit_status
= 1;
1989 if (0 == WEXITSTATUS (wait_status
))
1995 if (execp
->multiple
)
1997 /* -exec \; just returns false if the invoked command fails.
1998 * -exec {} + returns true if the invoked command fails, but
1999 * sets the program exit status.
2001 state
.exit_status
= 1;
2003 return 0; /* FAIL */
2009 /* Return a static string formatting the time WHEN according to the
2010 * strftime format character KIND.
2012 * This function contains a number of assertions. These look like
2013 * runtime checks of the results of computations, which would be a
2014 * problem since external events should not be tested for with
2015 * "assert" (instead you should use "if"). However, they are not
2016 * really runtime checks. The assertions actually exist to verify
2017 * that the various buffers are correctly sized.
2020 format_date (struct timespec ts
, int kind
)
2022 /* In theory, we use an extra 10 characters for 9 digits of
2023 * nanoseconds and 1 for the decimal point. However, the real
2024 * world is more complex than that.
2026 * For example, some systems return junk in the tv_nsec part of
2027 * st_birthtime. An example of this is the NetBSD-4.0-RELENG kernel
2028 * (at Sat Mar 24 18:46:46 2007) running a NetBSD-3.1-RELEASE
2029 * runtime and examining files on an msdos filesytem. So for that
2030 * reason we set NS_BUF_LEN to 32, which is simply "long enough" as
2031 * opposed to "exactly the right size". Note that the behaviour of
2032 * NetBSD appears to be a result of the use of uninitialised data,
2033 * as it's not 100% reproducible (more like 25%).
2037 DATE_LEN_PERCENT_APLUS
=21 /* length of result of %A+ (it's longer than %c)*/
2039 static char buf
[128u+10u + MAX(DATE_LEN_PERCENT_APLUS
,
2040 MAX (LONGEST_HUMAN_READABLE
+ 2, NS_BUF_LEN
+64+200))];
2041 char ns_buf
[NS_BUF_LEN
]; /* -.9999999990 (- sign can happen!)*/
2042 int charsprinted
, need_ns_suffix
;
2046 /* human_readable() assumes we pass a buffer which is at least as
2047 * long as LONGEST_HUMAN_READABLE. We use an assertion here to
2048 * ensure that no nasty unsigned overflow happend in our calculation
2049 * of the size of buf. Do the assertion here rather than in the
2050 * code for %@ so that we find the problem quickly if it exists. If
2051 * you want to submit a patch to move this into the if statement, go
2052 * ahead, I'll apply it. But include performance timings
2053 * demonstrating that the performance difference is actually
2056 verify (sizeof(buf
) >= LONGEST_HUMAN_READABLE
);
2061 /* Format the main part of the time. */
2064 strcpy (fmt
, "%F+%T");
2073 /* %a, %c, and %t are handled in ctime_format() */
2090 /* Format the nanoseconds part. Leave a trailing zero to
2091 * discourage people from writing scripts which extract the
2092 * fractional part of the timestamp by using column offsets.
2093 * The reason for discouraging this is that in the future, the
2094 * granularity may not be nanoseconds.
2097 charsprinted
= snprintf(ns_buf
, NS_BUF_LEN
, ".%09ld0", (long int)ts
.tv_nsec
);
2098 assert (charsprinted
< NS_BUF_LEN
);
2102 && (tm
= localtime (&ts
.tv_sec
))
2103 && strftime (buf
, sizeof buf
, fmt
, tm
))
2105 /* For %AS, %CS, %TS, add the fractional part of the seconds
2110 assert ((sizeof buf
- strlen(buf
)) > strlen(ns_buf
));
2111 strcat(buf
, ns_buf
);
2117 uintmax_t w
= ts
.tv_sec
;
2118 size_t used
, len
, remaining
;
2120 /* XXX: note that we are negating an unsigned type which is the
2121 * widest possible unsigned type.
2123 char *p
= human_readable (ts
.tv_sec
< 0 ? -w
: w
, buf
+ 1,
2124 human_ceiling
, 1, 1);
2126 assert (p
< (buf
+ (sizeof buf
)));
2128 *--p
= '-'; /* XXX: Ugh, relying on internal details of human_readable(). */
2130 /* Add the nanoseconds part. Because we cannot enforce a
2131 * particlar implementation of human_readable, we cannot assume
2132 * any particular value for (p-buf). So we need to be careful
2133 * that there is enough space remaining in the buffer.
2138 used
= (p
-buf
) + len
; /* Offset into buf of current end */
2139 assert (sizeof buf
> used
); /* Ensure we can perform subtraction safely. */
2140 remaining
= sizeof buf
- used
- 1u; /* allow space for NUL */
2142 if (strlen(ns_buf
) >= remaining
)
2145 "charsprinted=%ld but remaining=%lu: ns_buf=%s",
2146 (long)charsprinted
, (unsigned long)remaining
, ns_buf
);
2148 assert (strlen(ns_buf
) < remaining
);
2155 static const char *weekdays
[] =
2157 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
2159 static char * months
[] =
2161 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
2162 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
2167 ctime_format (struct timespec ts
)
2169 const struct tm
* ptm
;
2170 #define TIME_BUF_LEN 1024u
2171 static char resultbuf
[TIME_BUF_LEN
];
2174 ptm
= localtime(&ts
.tv_sec
);
2177 assert (ptm
->tm_wday
>= 0);
2178 assert (ptm
->tm_wday
< 7);
2179 assert (ptm
->tm_mon
>= 0);
2180 assert (ptm
->tm_mon
< 12);
2181 assert (ptm
->tm_hour
>= 0);
2182 assert (ptm
->tm_hour
< 24);
2183 assert (ptm
->tm_min
< 60);
2184 assert (ptm
->tm_sec
<= 61); /* allows 2 leap seconds. */
2186 /* wkday mon mday hh:mm:ss.nnnnnnnnn yyyy */
2187 nout
= snprintf(resultbuf
, TIME_BUF_LEN
,
2188 "%3s %3s %2d %02d:%02d:%02d.%010ld %04d",
2189 weekdays
[ptm
->tm_wday
],
2190 months
[ptm
->tm_mon
],
2195 (long int)ts
.tv_nsec
,
2196 1900 + ptm
->tm_year
);
2198 assert (nout
< TIME_BUF_LEN
);
2203 /* The time cannot be represented as a struct tm.
2204 Output it as an integer. */
2205 return format_date (ts
, '@');
2209 /* Copy STR into BUF and trim blanks from the end of BUF.
2213 blank_rtrim (str
, buf
)
2222 i
= strlen (buf
) - 1;
2223 while ((i
>= 0) && ((buf
[i
] == ' ') || buf
[i
] == '\t'))
2229 /* Print out the predicate list starting at NODE. */
2231 print_list (FILE *fp
, struct predicate
*node
)
2233 struct predicate
*cur
;
2239 fprintf (fp
, "[%s] ", blank_rtrim (cur
->p_name
, name
));
2240 cur
= cur
->pred_next
;
2245 /* Print out the predicate list starting at NODE. */
2247 print_parenthesised(FILE *fp
, struct predicate
*node
)
2253 if ((pred_is(node
, pred_or
) || pred_is(node
, pred_and
))
2254 && node
->pred_left
== NULL
)
2256 /* We print "<nothing> or X" as just "X"
2257 * We print "<nothing> and X" as just "X"
2259 print_parenthesised(fp
, node
->pred_right
);
2263 if (node
->pred_left
|| node
->pred_right
)
2267 fprintf(fp
, "%s", " ( ");
2268 print_optlist(fp
, node
);
2270 fprintf(fp
, "%s", " ) ");
2276 print_optlist (FILE *fp
, const struct predicate
*p
)
2280 print_parenthesised(fp
, p
->pred_left
);
2283 p
->need_stat
? "[call stat] " : "",
2284 p
->need_type
? "[need type] " : "");
2285 print_predicate(fp
, p
);
2286 fprintf(fp
, " [%g] ", p
->est_success_rate
);
2287 if (options
.debug_options
& DebugSuccessRates
)
2289 fprintf(fp
, "[%ld/%ld", p
->perf
.successes
, p
->perf
.visits
);
2292 double real_rate
= (double)p
->perf
.successes
/ (double)p
->perf
.visits
;
2293 fprintf(fp
, "=%g] ", real_rate
);
2297 fprintf(fp
, "=_] ");
2300 print_parenthesised(fp
, p
->pred_right
);
2304 void show_success_rates(const struct predicate
*p
)
2306 if (options
.debug_options
& DebugSuccessRates
)
2308 fprintf(stderr
, "Predicate success rates after completion:\n");
2309 print_optlist(stderr
, p
);
2310 fprintf(stderr
, "\n");
2318 /* If _NDEBUG is defined, the assertions will do nothing. Hence
2319 * there is no point in having a function body for pred_sanity_check()
2320 * if that preprocessor macro is defined.
2323 pred_sanity_check(const struct predicate
*predicates
)
2325 /* Do nothing, since assert is a no-op with _NDEBUG set */
2330 pred_sanity_check(const struct predicate
*predicates
)
2332 const struct predicate
*p
;
2334 for (p
=predicates
; p
!= NULL
; p
=p
->pred_next
)
2336 /* All predicates must do something. */
2337 assert (p
->pred_func
!= NULL
);
2339 /* All predicates must have a parser table entry. */
2340 assert (p
->parser_entry
!= NULL
);
2342 /* If the parser table tells us that just one predicate function is
2343 * possible, verify that that is still the one that is in effect.
2344 * If the parser has NULL for the predicate function, that means that
2345 * the parse_xxx function fills it in, so we can't check it.
2347 if (p
->parser_entry
->pred_func
)
2349 assert (p
->parser_entry
->pred_func
== p
->pred_func
);
2352 switch (p
->parser_entry
->type
)
2354 /* Options all take effect during parsing, so there should
2355 * be no predicate entries corresponding to them. Hence we
2356 * should not see any ARG_OPTION or ARG_POSITIONAL_OPTION
2359 * This is a silly way of coding this test, but it prevents
2360 * a compiler warning (i.e. otherwise it would think that
2361 * there would be case statements missing).
2364 case ARG_POSITIONAL_OPTION
:
2365 assert (p
->parser_entry
->type
!= ARG_OPTION
);
2366 assert (p
->parser_entry
->type
!= ARG_POSITIONAL_OPTION
);
2370 assert(p
->side_effects
); /* actions have side effects. */
2371 if (!pred_is(p
, pred_prune
) && !pred_is(p
, pred_quit
))
2373 /* actions other than -prune and -quit should
2374 * inhibit the default -print
2376 assert (p
->no_default_print
);
2380 /* We happen to know that the only user of ARG_SPECIAL_PARSE
2381 * is a test, so handle it like ARG_TEST.
2383 case ARG_SPECIAL_PARSE
:
2385 case ARG_PUNCTUATION
:
2387 /* Punctuation and tests should have no side
2388 * effects and not inhibit default print.
2390 assert (!p
->no_default_print
);
2391 assert (!p
->side_effects
);