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
));
423 pred_empty (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
428 if (S_ISDIR (stat_buf
->st_mode
))
433 boolean empty
= true;
436 if ((fd
= openat(state
.cwd_dir_fd
, state
.rel_pathname
, O_RDONLY
437 #if defined O_LARGEFILE
442 error (0, errno
, "%s", safely_quote_err_filename(0, pathname
));
443 state
.exit_status
= 1;
449 error (0, errno
, "%s", safely_quote_err_filename(0, pathname
));
450 state
.exit_status
= 1;
453 for (dp
= readdir (d
); dp
; dp
= readdir (d
))
455 if (dp
->d_name
[0] != '.'
456 || (dp
->d_name
[1] != '\0'
457 && (dp
->d_name
[1] != '.' || dp
->d_name
[2] != '\0')))
465 error (0, errno
, "%s", safely_quote_err_filename(0, pathname
));
466 state
.exit_status
= 1;
471 else if (S_ISREG (stat_buf
->st_mode
))
472 return (stat_buf
->st_size
== 0);
478 new_impl_pred_exec (int dirfd
, const char *pathname
,
479 struct stat
*stat_buf
,
480 struct predicate
*pred_ptr
,
481 const char *prefix
, size_t pfxlen
)
483 struct exec_val
*execp
= &pred_ptr
->args
.exec_vec
;
484 size_t len
= strlen(pathname
);
487 execp
->dirfd
= dirfd
;
490 /* Push the argument onto the current list.
491 * The command may or may not be run at this point,
492 * depending on the command line length limits.
494 bc_push_arg(&execp
->ctl
,
500 /* remember that there are pending execdirs. */
501 state
.execdirs_outstanding
= true;
503 /* POSIX: If the primary expression is punctuated by a plus
504 * sign, the primary shall always evaluate as true
512 for (i
=0; i
<execp
->num_args
; ++i
)
514 bc_do_insert(&execp
->ctl
,
516 execp
->replace_vec
[i
],
517 strlen(execp
->replace_vec
[i
]),
523 /* Actually invoke the command. */
524 return execp
->ctl
.exec_callback(&execp
->ctl
,
531 pred_exec (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
533 return new_impl_pred_exec(get_start_dirfd(),
534 pathname
, stat_buf
, pred_ptr
, NULL
, 0);
538 pred_execdir (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
540 const char *prefix
= (state
.rel_pathname
[0] == '/') ? NULL
: "./";
542 return new_impl_pred_exec (get_current_dirfd(),
543 state
.rel_pathname
, stat_buf
, pred_ptr
,
544 prefix
, (prefix
? 2 : 0));
548 pred_false (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
559 pred_fls (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
561 FILE * stream
= pred_ptr
->args
.printf_vec
.stream
;
562 list_file (pathname
, state
.cwd_dir_fd
, state
.rel_pathname
, stat_buf
,
563 options
.start_time
.tv_sec
,
564 options
.output_block_size
,
565 pred_ptr
->literal_control_chars
, stream
);
570 pred_fprint (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
575 print_quoted(pred_ptr
->args
.printf_vec
.stream
,
576 pred_ptr
->args
.printf_vec
.quote_opts
,
577 pred_ptr
->args
.printf_vec
.dest_is_tty
,
584 pred_fprint0 (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
586 FILE * fp
= pred_ptr
->args
.printf_vec
.stream
;
590 fputs (pathname
, fp
);
598 mode_to_filetype(mode_t m
)
600 #define HANDLE_TYPE(t,letter) if (m==t) { return letter; }
602 HANDLE_TYPE(S_IFREG
, "f"); /* regular file */
605 HANDLE_TYPE(S_IFDIR
, "d"); /* directory */
608 HANDLE_TYPE(S_IFLNK
, "l"); /* symbolic link */
611 HANDLE_TYPE(S_IFSOCK
, "s"); /* Unix domain socket */
614 HANDLE_TYPE(S_IFBLK
, "b"); /* block device */
617 HANDLE_TYPE(S_IFCHR
, "c"); /* character device */
620 HANDLE_TYPE(S_IFIFO
, "p"); /* FIFO */
623 HANDLE_TYPE(S_IFDOOR
, "D"); /* Door (e.g. on Solaris) */
625 return "U"; /* Unknown */
629 file_sparseness(const struct stat
*p
)
631 #if defined HAVE_STRUCT_STAT_ST_BLOCKS
634 if (0 == p
->st_blocks
)
637 return p
->st_blocks
< 0 ? -HUGE_VAL
: HUGE_VAL
;
641 double blklen
= file_blocksize(p
) * (double)p
->st_blocks
;
642 return blklen
/ p
->st_size
;
652 checked_fprintf(struct format_val
*dest
, const char *fmt
, ...)
658 rv
= vfprintf(dest
->stream
, fmt
, ap
);
660 nonfatal_file_error(dest
->filename
);
665 checked_print_quoted (struct format_val
*dest
,
666 const char *format
, const char *s
)
668 int rv
= print_quoted(dest
->stream
, dest
->quote_opts
, dest
->dest_is_tty
,
671 nonfatal_file_error(dest
->filename
);
676 checked_fwrite(void *p
, size_t siz
, size_t nmemb
, struct format_val
*dest
)
678 int items_written
= fwrite(p
, siz
, nmemb
, dest
->stream
);
679 if (items_written
< nmemb
)
680 nonfatal_file_error(dest
->filename
);
684 checked_fflush(struct format_val
*dest
)
686 if (0 != fflush(dest
->stream
))
688 nonfatal_file_error(dest
->filename
);
693 do_fprintf(struct format_val
*dest
,
694 struct segment
*segment
,
695 const char *pathname
,
696 const struct stat
*stat_buf
)
698 char hbuf
[LONGEST_HUMAN_READABLE
+ 1];
701 switch (segment
->segkind
)
703 case KIND_PLAIN
: /* Plain text string (no % conversion). */
705 checked_fwrite(segment
->text
, 1, segment
->text_len
, dest
);
708 case KIND_STOP
: /* Terminate argument and flush output. */
710 checked_fwrite(segment
->text
, 1, segment
->text_len
, dest
);
711 checked_fflush(dest
);
715 switch (segment
->format_char
[0])
717 case 'a': /* atime in `ctime' format. */
718 /* UNTRUSTED, probably unexploitable */
719 checked_fprintf (dest
, segment
->text
, ctime_format (get_stat_atime(stat_buf
)));
721 case 'b': /* size in 512-byte blocks */
722 /* UNTRUSTED, probably unexploitable */
723 checked_fprintf (dest
, segment
->text
,
724 human_readable ((uintmax_t) ST_NBLOCKS (*stat_buf
),
726 ST_NBLOCKSIZE
, 512));
728 case 'c': /* ctime in `ctime' format */
729 /* UNTRUSTED, probably unexploitable */
730 checked_fprintf (dest
, segment
->text
, ctime_format (get_stat_ctime(stat_buf
)));
732 case 'd': /* depth in search tree */
733 /* UNTRUSTED, probably unexploitable */
734 checked_fprintf (dest
, segment
->text
, state
.curdepth
);
736 case 'D': /* Device on which file exists (stat.st_dev) */
738 checked_fprintf (dest
, segment
->text
,
739 human_readable ((uintmax_t) stat_buf
->st_dev
, hbuf
,
740 human_ceiling
, 1, 1));
742 case 'f': /* base name of path */
745 char *base
= base_name (pathname
);
746 checked_print_quoted (dest
, segment
->text
, base
);
750 case 'F': /* file system type */
752 checked_print_quoted (dest
, segment
->text
, filesystem_type (stat_buf
, pathname
));
754 case 'g': /* group name */
756 /* (well, the actual group is selected by the user but
757 * its name was selected by the system administrator)
762 g
= getgrgid (stat_buf
->st_gid
);
765 segment
->text
[segment
->text_len
] = 's';
766 checked_fprintf (dest
, segment
->text
, g
->gr_name
);
775 /*FALLTHROUGH*/ /*...sometimes, so 'G' case.*/
777 case 'G': /* GID number */
778 /* UNTRUSTED, probably unexploitable */
779 checked_fprintf (dest
, segment
->text
,
780 human_readable ((uintmax_t) stat_buf
->st_gid
, hbuf
,
781 human_ceiling
, 1, 1));
783 case 'h': /* leading directories part of path */
786 cp
= strrchr (pathname
, '/');
787 if (cp
== NULL
) /* No leading directories. */
789 /* If there is no slash in the pathname, we still
790 * print the string because it contains characters
791 * other than just '%s'. The %h expands to ".".
793 checked_print_quoted (dest
, segment
->text
, ".");
797 char *s
= strdup(pathname
);
798 s
[cp
- pathname
] = 0;
799 checked_print_quoted (dest
, segment
->text
, s
);
805 case 'H': /* ARGV element file was found under */
808 char *s
= xmalloc(state
.starting_path_length
+1);
809 memcpy(s
, pathname
, state
.starting_path_length
);
810 s
[state
.starting_path_length
] = 0;
811 checked_fprintf (dest
, segment
->text
, s
);
816 case 'i': /* inode number */
817 /* UNTRUSTED, but not exploitable I think */
818 checked_fprintf (dest
, segment
->text
,
819 human_readable ((uintmax_t) stat_buf
->st_ino
, hbuf
,
823 case 'k': /* size in 1K blocks */
824 /* UNTRUSTED, but not exploitable I think */
825 checked_fprintf (dest
, segment
->text
,
826 human_readable ((uintmax_t) ST_NBLOCKS (*stat_buf
),
828 ST_NBLOCKSIZE
, 1024));
830 case 'l': /* object of symlink */
836 if (S_ISLNK (stat_buf
->st_mode
))
838 linkname
= get_link_name_at (pathname
, state
.cwd_dir_fd
, state
.rel_pathname
);
840 state
.exit_status
= 1;
844 checked_print_quoted (dest
, segment
->text
, linkname
);
849 /* We still need to honour the field width etc., so this is
852 checked_print_quoted (dest
, segment
->text
, "");
858 case 'M': /* mode as 10 chars (eg., "-rwxr-x--x" */
859 /* UNTRUSTED, probably unexploitable */
861 char modestring
[16] ;
862 filemodestring (stat_buf
, modestring
);
863 modestring
[10] = '\0';
864 checked_fprintf (dest
, segment
->text
, modestring
);
868 case 'm': /* mode as octal number (perms only) */
869 /* UNTRUSTED, probably unexploitable */
871 /* Output the mode portably using the traditional numbers,
872 even if the host unwisely uses some other numbering
873 scheme. But help the compiler in the common case where
874 the host uses the traditional numbering scheme. */
875 mode_t m
= stat_buf
->st_mode
;
876 boolean traditional_numbering_scheme
=
877 (S_ISUID
== 04000 && S_ISGID
== 02000 && S_ISVTX
== 01000
878 && S_IRUSR
== 00400 && S_IWUSR
== 00200 && S_IXUSR
== 00100
879 && S_IRGRP
== 00040 && S_IWGRP
== 00020 && S_IXGRP
== 00010
880 && S_IROTH
== 00004 && S_IWOTH
== 00002 && S_IXOTH
== 00001);
881 checked_fprintf (dest
, segment
->text
,
882 (traditional_numbering_scheme
884 : ((m
& S_ISUID
? 04000 : 0)
885 | (m
& S_ISGID
? 02000 : 0)
886 | (m
& S_ISVTX
? 01000 : 0)
887 | (m
& S_IRUSR
? 00400 : 0)
888 | (m
& S_IWUSR
? 00200 : 0)
889 | (m
& S_IXUSR
? 00100 : 0)
890 | (m
& S_IRGRP
? 00040 : 0)
891 | (m
& S_IWGRP
? 00020 : 0)
892 | (m
& S_IXGRP
? 00010 : 0)
893 | (m
& S_IROTH
? 00004 : 0)
894 | (m
& S_IWOTH
? 00002 : 0)
895 | (m
& S_IXOTH
? 00001 : 0))));
899 case 'n': /* number of links */
900 /* UNTRUSTED, probably unexploitable */
901 checked_fprintf (dest
, segment
->text
,
902 human_readable ((uintmax_t) stat_buf
->st_nlink
,
908 case 'p': /* pathname */
910 checked_print_quoted (dest
, segment
->text
, pathname
);
913 case 'P': /* pathname with ARGV element stripped */
915 if (state
.curdepth
> 0)
917 cp
= pathname
+ state
.starting_path_length
;
919 /* Move past the slash between the ARGV element
920 and the rest of the pathname. But if the ARGV element
921 ends in a slash, we didn't add another, so we've
922 already skipped past it. */
929 checked_print_quoted (dest
, segment
->text
, cp
);
932 case 's': /* size in bytes */
933 /* UNTRUSTED, probably unexploitable */
934 checked_fprintf (dest
, segment
->text
,
935 human_readable ((uintmax_t) stat_buf
->st_size
,
936 hbuf
, human_ceiling
, 1, 1));
939 case 'S': /* sparseness */
940 /* UNTRUSTED, probably unexploitable */
941 checked_fprintf (dest
, segment
->text
, file_sparseness(stat_buf
));;
944 case 't': /* mtime in `ctime' format */
945 /* UNTRUSTED, probably unexploitable */
946 checked_fprintf (dest
, segment
->text
,
947 ctime_format (get_stat_mtime(stat_buf
)));
950 case 'u': /* user name */
952 /* (well, the actual user is selected by the user on systems
953 * where chown is not restricted, but the user name was
954 * selected by the system administrator)
959 p
= getpwuid (stat_buf
->st_uid
);
962 segment
->text
[segment
->text_len
] = 's';
963 checked_fprintf (dest
, segment
->text
, p
->pw_name
);
968 /* FALLTHROUGH*/ /* .. to case U */
970 case 'U': /* UID number */
971 /* UNTRUSTED, probably unexploitable */
972 checked_fprintf (dest
, segment
->text
,
973 human_readable ((uintmax_t) stat_buf
->st_uid
, hbuf
,
974 human_ceiling
, 1, 1));
977 /* %Y: type of file system entry like `ls -l`:
978 * (d,-,l,s,p,b,c,n) n=nonexistent(symlink)
980 case 'Y': /* in case of symlink */
984 if (S_ISLNK (stat_buf
->st_mode
))
987 /* If we would normally follow links, do not do so.
988 * If we would normally not follow links, do so.
990 if ((following_links() ? lstat
: stat
)
991 (state
.rel_pathname
, &sbuf
) != 0)
993 if ( errno
== ENOENT
)
995 checked_fprintf (dest
, segment
->text
, "N");
998 else if ( errno
== ELOOP
)
1000 checked_fprintf (dest
, segment
->text
, "L");
1005 checked_fprintf (dest
, segment
->text
, "?");
1006 error (0, errno
, "%s",
1007 safely_quote_err_filename(0, pathname
));
1013 checked_fprintf (dest
, segment
->text
,
1014 mode_to_filetype(sbuf
.st_mode
& S_IFMT
));
1016 #endif /* S_ISLNK */
1019 checked_fprintf (dest
, segment
->text
,
1020 mode_to_filetype(stat_buf
->st_mode
& S_IFMT
));
1028 checked_fprintf (dest
, segment
->text
,
1029 mode_to_filetype(stat_buf
->st_mode
& S_IFMT
));
1033 /* end of KIND_FORMAT case */
1039 pred_fprintf (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1041 struct format_val
*dest
= &pred_ptr
->args
.printf_vec
;
1042 struct segment
*segment
;
1044 for (segment
= dest
->segment
; segment
; segment
= segment
->next
)
1046 if ( (KIND_FORMAT
== segment
->segkind
) && segment
->format_char
[1]) /* Component of date. */
1051 switch (segment
->format_char
[0])
1054 ts
= get_stat_atime(stat_buf
);
1058 ts
= get_stat_birthtime(stat_buf
);
1059 if ('@' == segment
->format_char
[1])
1062 valid
= (ts
.tv_nsec
>= 0);
1065 ts
= get_stat_ctime(stat_buf
);
1069 ts
= get_stat_mtime(stat_buf
);
1076 /* We trust the output of format_date not to contain
1077 * nasty characters, though the value of the date
1078 * is itself untrusted data.
1083 checked_fprintf (dest
, segment
->text
,
1084 format_date (ts
, segment
->format_char
[1]));
1088 /* The specified timestamp is not available, output
1089 * nothing for the timestamp, but use the rest (so that
1090 * for example find foo -printf '[%Bs] %p\n' can print
1094 checked_fprintf (dest
, segment
->text
, "");
1099 /* Print a segment which is not a date. */
1100 do_fprintf(dest
, segment
, pathname
, stat_buf
);
1107 pred_fstype (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1111 if (strcmp (filesystem_type (stat_buf
, pathname
), pred_ptr
->args
.str
) == 0)
1118 pred_gid (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1122 switch (pred_ptr
->args
.numinfo
.kind
)
1125 if (stat_buf
->st_gid
> pred_ptr
->args
.numinfo
.l_val
)
1129 if (stat_buf
->st_gid
< pred_ptr
->args
.numinfo
.l_val
)
1133 if (stat_buf
->st_gid
== pred_ptr
->args
.numinfo
.l_val
)
1141 pred_group (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1145 if (pred_ptr
->args
.gid
== stat_buf
->st_gid
)
1152 pred_ilname (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1154 return match_lname (pathname
, stat_buf
, pred_ptr
, true);
1157 /* Common code between -name, -iname. PATHNAME is being visited, STR
1158 is name to compare basename against, and FLAGS are passed to
1159 fnmatch. Recall that 'find / -name /' is one of the few times where a '/'
1160 in the -name must actually find something. */
1162 pred_name_common (const char *pathname
, const char *str
, int flags
)
1166 /* We used to use last_component() here, but that would not allow us to modify the
1167 * input string, which is const. We could optimise by duplicating the string only
1168 * if we need to modify it, and I'll do that if there is a measurable
1169 * performance difference on a machine built after 1990...
1171 char *base
= base_name (pathname
);
1172 /* remove trailing slashes, but leave "/" or "//foo" unchanged. */
1173 strip_trailing_slashes(base
);
1175 /* FNM_PERIOD is not used here because POSIX requires that it not be.
1176 * See http://standards.ieee.org/reading/ieee/interp/1003-2-92_int/pasc-1003.2-126.html
1178 b
= fnmatch (str
, base
, flags
) == 0;
1184 pred_iname (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1187 return pred_name_common (pathname
, pred_ptr
->args
.str
, FNM_CASEFOLD
);
1191 pred_inum (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1195 switch (pred_ptr
->args
.numinfo
.kind
)
1198 if (stat_buf
->st_ino
> pred_ptr
->args
.numinfo
.l_val
)
1202 if (stat_buf
->st_ino
< pred_ptr
->args
.numinfo
.l_val
)
1206 if (stat_buf
->st_ino
== pred_ptr
->args
.numinfo
.l_val
)
1214 pred_ipath (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1218 if (fnmatch (pred_ptr
->args
.str
, pathname
, FNM_CASEFOLD
) == 0)
1224 pred_links (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1228 switch (pred_ptr
->args
.numinfo
.kind
)
1231 if (stat_buf
->st_nlink
> pred_ptr
->args
.numinfo
.l_val
)
1235 if (stat_buf
->st_nlink
< pred_ptr
->args
.numinfo
.l_val
)
1239 if (stat_buf
->st_nlink
== pred_ptr
->args
.numinfo
.l_val
)
1247 pred_lname (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1249 return match_lname (pathname
, stat_buf
, pred_ptr
, false);
1253 match_lname (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
, boolean ignore_case
)
1255 boolean ret
= false;
1257 if (S_ISLNK (stat_buf
->st_mode
))
1259 char *linkname
= get_link_name_at (pathname
, state
.cwd_dir_fd
, state
.rel_pathname
);
1262 if (fnmatch (pred_ptr
->args
.str
, linkname
,
1263 ignore_case
? FNM_CASEFOLD
: 0) == 0)
1268 #endif /* S_ISLNK */
1273 pred_ls (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1275 return pred_fls(pathname
, stat_buf
, pred_ptr
);
1279 pred_mmin (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1282 return pred_timewindow(get_stat_mtime(stat_buf
), pred_ptr
, 60);
1286 pred_mtime (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1289 return pred_timewindow(get_stat_mtime(stat_buf
), pred_ptr
, DAYSECS
);
1293 pred_name (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1296 return pred_name_common (pathname
, pred_ptr
->args
.str
, 0);
1300 pred_negate (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1302 return !apply_predicate(pathname
, stat_buf
, pred_ptr
->pred_right
);
1306 pred_newer (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1310 assert (COMP_GT
== pred_ptr
->args
.reftime
.kind
);
1311 return compare_ts(get_stat_mtime(stat_buf
), pred_ptr
->args
.reftime
.ts
) > 0;
1315 pred_newerXY (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1318 boolean collected
= false;
1320 assert (COMP_GT
== pred_ptr
->args
.reftime
.kind
);
1322 switch (pred_ptr
->args
.reftime
.xval
)
1325 assert (pred_ptr
->args
.reftime
.xval
!= XVAL_TIME
);
1329 ts
= get_stat_atime(stat_buf
);
1333 case XVAL_BIRTHTIME
:
1334 ts
= get_stat_birthtime(stat_buf
);
1336 if (ts
.tv_nsec
< 0);
1338 /* XXX: Cannot determine birth time. Warn once. */
1339 error(0, 0, _("Warning: cannot determine birth time of file %s"),
1340 safely_quote_err_filename(0, pathname
));
1346 ts
= get_stat_ctime(stat_buf
);
1351 ts
= get_stat_mtime(stat_buf
);
1357 return compare_ts(ts
, pred_ptr
->args
.reftime
.ts
) > 0;
1361 pred_nogroup (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1367 extern char *gid_unused
;
1369 return gid_unused
[(unsigned) stat_buf
->st_gid
];
1371 return getgrgid (stat_buf
->st_gid
) == NULL
;
1376 pred_nouser (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1379 extern char *uid_unused
;
1386 return uid_unused
[(unsigned) stat_buf
->st_uid
];
1388 return getpwuid (stat_buf
->st_uid
) == NULL
;
1394 is_ok(const char *program
, const char *arg
)
1397 /* The draft open standard requires that, in the POSIX locale,
1398 the last non-blank character of this prompt be '?'.
1399 The exact format is not specified.
1400 This standard does not have requirements for locales other than POSIX
1402 /* XXX: printing UNTRUSTED data here. */
1403 fprintf (stderr
, _("< %s ... %s > ? "), program
, arg
);
1409 pred_ok (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1411 if (is_ok(pred_ptr
->args
.exec_vec
.replace_vec
[0], pathname
))
1412 return new_impl_pred_exec (get_start_dirfd(),
1413 pathname
, stat_buf
, pred_ptr
, NULL
, 0);
1419 pred_okdir (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1421 const char *prefix
= (state
.rel_pathname
[0] == '/') ? NULL
: "./";
1422 if (is_ok(pred_ptr
->args
.exec_vec
.replace_vec
[0], pathname
))
1423 return new_impl_pred_exec (get_current_dirfd(),
1424 state
.rel_pathname
, stat_buf
, pred_ptr
,
1425 prefix
, (prefix
? 2 : 0));
1431 pred_openparen (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1440 pred_or (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1442 if (pred_ptr
->pred_left
== NULL
1443 || !apply_predicate(pathname
, stat_buf
, pred_ptr
->pred_left
))
1445 return apply_predicate(pathname
, stat_buf
, pred_ptr
->pred_right
);
1452 pred_path (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1455 if (fnmatch (pred_ptr
->args
.str
, pathname
, 0) == 0)
1461 pred_perm (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1463 mode_t mode
= stat_buf
->st_mode
;
1464 mode_t perm_val
= pred_ptr
->args
.perm
.val
[S_ISDIR (mode
) != 0];
1466 switch (pred_ptr
->args
.perm
.kind
)
1469 return (mode
& perm_val
) == perm_val
;
1473 /* True if any of the bits set in the mask are also set in the file's mode.
1476 * Otherwise, if onum is prefixed by a hyphen, the primary shall
1477 * evaluate as true if at least all of the bits specified in
1478 * onum that are also set in the octal mask 07777 are set.
1480 * Eric Blake's interpretation is that the mode argument is zero,
1484 return true; /* Savannah bug 14748; we used to return false */
1486 return (mode
& perm_val
) != 0;
1490 return (mode
& MODE_ALL
) == perm_val
;
1500 struct access_check_args
1502 const char *filename
;
1509 access_callback(void *context
)
1512 struct access_check_args
*args
= context
;
1513 if ((rv
= access(args
->filename
, args
->access_type
)) < 0)
1514 args
->cb_errno
= errno
;
1519 can_access(int access_type
)
1521 struct access_check_args args
;
1522 args
.filename
= state
.rel_pathname
;
1523 args
.access_type
= access_type
;
1525 return 0 == run_in_dir(state
.cwd_dir_fd
, access_callback
, &args
);
1530 pred_executable (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1536 return can_access(X_OK
);
1540 pred_readable (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1546 return can_access(R_OK
);
1550 pred_writable (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1556 return can_access(W_OK
);
1560 pred_print (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1565 print_quoted(pred_ptr
->args
.printf_vec
.stream
,
1566 pred_ptr
->args
.printf_vec
.quote_opts
,
1567 pred_ptr
->args
.printf_vec
.dest_is_tty
,
1573 pred_print0 (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1575 return pred_fprint0(pathname
, stat_buf
, pred_ptr
);
1579 pred_prune (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1584 if (options
.do_dir_first
== true && /* no effect with -depth */
1586 S_ISDIR(stat_buf
->st_mode
))
1587 state
.stop_at_current_level
= true;
1589 /* findutils used to return options.do_dir_first here, so that -prune
1590 * returns true only if -depth is not in effect. But POSIX requires
1591 * that -prune always evaluate as true.
1597 pred_quit (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1603 /* Run any cleanups. This includes executing any command lines
1604 * we have partly built but not executed.
1608 /* Since -exec and friends don't leave child processes running in the
1609 * background, there is no need to wait for them here.
1611 exit(state
.exit_status
); /* 0 for success, etc. */
1615 pred_regex (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1617 int len
= strlen (pathname
);
1619 if (re_match (pred_ptr
->args
.regex
, pathname
, len
, 0,
1620 (struct re_registers
*) NULL
) == len
)
1626 pred_size (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1631 f_val
= ((stat_buf
->st_size
/ pred_ptr
->args
.size
.blocksize
)
1632 + (stat_buf
->st_size
% pred_ptr
->args
.size
.blocksize
!= 0));
1633 switch (pred_ptr
->args
.size
.kind
)
1636 if (f_val
> pred_ptr
->args
.size
.size
)
1640 if (f_val
< pred_ptr
->args
.size
.size
)
1644 if (f_val
== pred_ptr
->args
.size
.size
)
1652 pred_samefile (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1654 /* Potential optimisation: because of the loop protection, we always
1655 * know the device of the current directory, hence the device number
1656 * of the file we're currently considering. If -L is not in effect,
1657 * and the device number of the file we're looking for is not the
1658 * same as the device number of the current directory, this
1659 * predicate cannot return true. Hence there would be no need to
1660 * stat the file we're looking at.
1664 /* We will often still have an fd open on the file under consideration,
1665 * but that's just to ensure inode number stability by maintaining
1666 * a reference to it; we don't need the file for anything else.
1668 return stat_buf
->st_ino
== pred_ptr
->args
.samefileid
.ino
1669 && stat_buf
->st_dev
== pred_ptr
->args
.samefileid
.dev
;
1673 pred_true (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1682 pred_type (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1685 mode_t type
= pred_ptr
->args
.type
;
1687 assert (state
.have_type
);
1689 if (0 == state
.type
)
1691 /* This can sometimes happen with broken NFS servers.
1692 * See Savannah bug #16378.
1699 if (state
.have_stat
)
1700 mode
= stat_buf
->st_mode
;
1705 /* POSIX system; check `mode' the slow way. */
1706 if ((S_ISBLK (mode
) && type
== S_IFBLK
)
1707 || (S_ISCHR (mode
) && type
== S_IFCHR
)
1708 || (S_ISDIR (mode
) && type
== S_IFDIR
)
1709 || (S_ISREG (mode
) && type
== S_IFREG
)
1711 || (S_ISLNK (mode
) && type
== S_IFLNK
)
1714 || (S_ISFIFO (mode
) && type
== S_IFIFO
)
1717 || (S_ISSOCK (mode
) && type
== S_IFSOCK
)
1720 || (S_ISDOOR (mode
) && type
== S_IFDOOR
)
1724 /* Unix system; check `mode' the fast way. */
1725 if ((mode
& S_IFMT
) == type
)
1733 pred_uid (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1736 switch (pred_ptr
->args
.numinfo
.kind
)
1739 if (stat_buf
->st_uid
> pred_ptr
->args
.numinfo
.l_val
)
1743 if (stat_buf
->st_uid
< pred_ptr
->args
.numinfo
.l_val
)
1747 if (stat_buf
->st_uid
== pred_ptr
->args
.numinfo
.l_val
)
1755 pred_used (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1757 struct timespec delta
, at
, ct
;
1761 /* TODO: this needs to be retested carefully (manually, if necessary) */
1762 at
= get_stat_atime(stat_buf
);
1763 ct
= get_stat_ctime(stat_buf
);
1764 delta
.tv_sec
= at
.tv_sec
- ct
.tv_sec
;
1765 delta
.tv_nsec
= at
.tv_nsec
- ct
.tv_nsec
;
1766 if (delta
.tv_nsec
< 0)
1768 delta
.tv_nsec
+= 1000000000;
1771 return pred_timewindow(delta
, pred_ptr
, DAYSECS
);
1775 pred_user (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1778 if (pred_ptr
->args
.uid
== stat_buf
->st_uid
)
1785 pred_xtype (const char *pathname
, struct stat
*stat_buf
, struct predicate
*pred_ptr
)
1787 struct stat sbuf
; /* local copy, not stat_buf because we're using a different stat method */
1788 int (*ystat
) (const char*, struct stat
*p
);
1790 /* If we would normally stat the link itself, stat the target instead.
1791 * If we would normally follow the link, stat the link itself instead.
1793 if (following_links())
1794 ystat
= optionp_stat
;
1796 ystat
= optionl_stat
;
1798 set_stat_placeholders(&sbuf
);
1799 if ((*ystat
) (state
.rel_pathname
, &sbuf
) != 0)
1801 if (following_links() && errno
== ENOENT
)
1803 /* If we failed to follow the symlink,
1804 * fall back on looking at the symlink itself.
1806 /* Mimic behavior of ls -lL. */
1807 return (pred_type (pathname
, stat_buf
, pred_ptr
));
1811 error (0, errno
, "%s", safely_quote_err_filename(0, pathname
));
1812 state
.exit_status
= 1;
1816 /* Now that we have our stat() information, query it in the same
1817 * way that -type does.
1819 return (pred_type (pathname
, &sbuf
, pred_ptr
));
1822 /* 1) fork to get a child; parent remembers the child pid
1823 2) child execs the command requested
1824 3) parent waits for child; checks for proper pid of child
1828 ret errno status(h) status(l)
1830 pid x signal# 0177 stopped
1831 pid x exit arg 0 term by _exit
1832 pid x 0 signal # term by signal
1833 -1 EINTR parent got signal
1834 -1 other some other kind of error
1836 Return true only if the pid matches, status(l) is
1837 zero, and the exit arg (status high) is 0.
1838 Otherwise return false, possibly printing an error message. */
1842 prep_child_for_exec (boolean close_stdin
, int dirfd
)
1847 const char inputfile
[] = "/dev/null";
1851 error(0, errno
, _("Cannot close standard input"));
1856 if (open(inputfile
, O_RDONLY
1857 #if defined O_LARGEFILE
1862 /* This is not entirely fatal, since
1863 * executing the child with a closed
1864 * stdin is almost as good as executing it
1865 * with its stdin attached to /dev/null.
1867 error (0, errno
, "%s", safely_quote_err_filename(0, inputfile
));
1868 /* do not set ok=false, it is OK to continue anyway. */
1873 /* Even if DebugSearch is set, don't announce our change of
1874 * directory, since we're not going to emit a subsequent
1875 * announcement of a call to stat() anyway, as we're about to exec
1878 if (dirfd
!= AT_FDCWD
)
1880 assert (dirfd
>= 0);
1881 if (0 != fchdir(dirfd
))
1883 /* If we cannot execute our command in the correct directory,
1884 * we should not execute it at all.
1886 error(0, errno
, _("Failed to change directory"));
1896 launch (const struct buildcmd_control
*ctl
,
1897 struct buildcmd_state
*buildstate
)
1901 static int first_time
= 1;
1902 const struct exec_val
*execp
= buildstate
->usercontext
;
1904 if (!execp
->use_current_dir
)
1906 assert (starting_desc
>= 0);
1907 assert (execp
->dirfd
== starting_desc
);
1911 /* Null terminate the arg list. */
1912 bc_push_arg (ctl
, buildstate
, (char *) NULL
, 0, NULL
, 0, false);
1914 /* Make sure output of command doesn't get mixed with find output. */
1918 /* Make sure to listen for the kids. */
1922 signal (SIGCHLD
, SIG_DFL
);
1925 child_pid
= fork ();
1926 if (child_pid
== -1)
1927 error (1, errno
, _("cannot fork"));
1930 /* We are the child. */
1931 assert (starting_desc
>= 0);
1932 if (!prep_child_for_exec(execp
->close_stdin
, execp
->dirfd
))
1937 execvp (buildstate
->cmd_argv
[0], buildstate
->cmd_argv
);
1938 error (0, errno
, "%s",
1939 safely_quote_err_filename(0, buildstate
->cmd_argv
[0]));
1944 /* In parent; set up for next time. */
1945 bc_clear_args(ctl
, buildstate
);
1948 while (waitpid (child_pid
, &wait_status
, 0) == (pid_t
) -1)
1952 error (0, errno
, _("error waiting for %s"),
1953 safely_quote_err_filename(0, buildstate
->cmd_argv
[0]));
1954 state
.exit_status
= 1;
1955 return 0; /* FAIL */
1959 if (WIFSIGNALED (wait_status
))
1961 error (0, 0, _("%s terminated by signal %d"),
1962 quotearg_n_style(0, options
.err_quoting_style
,
1963 buildstate
->cmd_argv
[0]),
1964 WTERMSIG (wait_status
));
1966 if (execp
->multiple
)
1968 /* -exec \; just returns false if the invoked command fails.
1969 * -exec {} + returns true if the invoked command fails, but
1970 * sets the program exit status.
1972 state
.exit_status
= 1;
1978 if (0 == WEXITSTATUS (wait_status
))
1984 if (execp
->multiple
)
1986 /* -exec \; just returns false if the invoked command fails.
1987 * -exec {} + returns true if the invoked command fails, but
1988 * sets the program exit status.
1990 state
.exit_status
= 1;
1992 return 0; /* FAIL */
1998 /* Return a static string formatting the time WHEN according to the
1999 * strftime format character KIND.
2001 * This function contains a number of assertions. These look like
2002 * runtime checks of the results of computations, which would be a
2003 * problem since external events should not be tested for with
2004 * "assert" (instead you should use "if"). However, they are not
2005 * really runtime checks. The assertions actually exist to verify
2006 * that the various buffers are correctly sized.
2009 format_date (struct timespec ts
, int kind
)
2011 /* In theory, we use an extra 10 characters for 9 digits of
2012 * nanoseconds and 1 for the decimal point. However, the real
2013 * world is more complex than that.
2015 * For example, some systems return junk in the tv_nsec part of
2016 * st_birthtime. An example of this is the NetBSD-4.0-RELENG kernel
2017 * (at Sat Mar 24 18:46:46 2007) running a NetBSD-3.1-RELEASE
2018 * runtime and examining files on an msdos filesytem. So for that
2019 * reason we set NS_BUF_LEN to 32, which is simply "long enough" as
2020 * opposed to "exactly the right size". Note that the behaviour of
2021 * NetBSD appears to be a result of the use of uninitialised data,
2022 * as it's not 100% reproducible (more like 25%).
2026 DATE_LEN_PERCENT_APLUS
=21 /* length of result of %A+ (it's longer than %c)*/
2028 static char buf
[128u+10u + MAX(DATE_LEN_PERCENT_APLUS
,
2029 MAX (LONGEST_HUMAN_READABLE
+ 2, NS_BUF_LEN
+64+200))];
2030 char ns_buf
[NS_BUF_LEN
]; /* -.9999999990 (- sign can happen!)*/
2031 int charsprinted
, need_ns_suffix
;
2035 /* human_readable() assumes we pass a buffer which is at least as
2036 * long as LONGEST_HUMAN_READABLE. We use an assertion here to
2037 * ensure that no nasty unsigned overflow happend in our calculation
2038 * of the size of buf. Do the assertion here rather than in the
2039 * code for %@ so that we find the problem quickly if it exists. If
2040 * you want to submit a patch to move this into the if statement, go
2041 * ahead, I'll apply it. But include performance timings
2042 * demonstrating that the performance difference is actually
2045 verify (sizeof(buf
) >= LONGEST_HUMAN_READABLE
);
2050 /* Format the main part of the time. */
2053 strcpy (fmt
, "%F+%T");
2062 /* %a, %c, and %t are handled in ctime_format() */
2079 /* Format the nanoseconds part. Leave a trailing zero to
2080 * discourage people from writing scripts which extract the
2081 * fractional part of the timestamp by using column offsets.
2082 * The reason for discouraging this is that in the future, the
2083 * granularity may not be nanoseconds.
2086 charsprinted
= snprintf(ns_buf
, NS_BUF_LEN
, ".%09ld0", (long int)ts
.tv_nsec
);
2087 assert (charsprinted
< NS_BUF_LEN
);
2091 && (tm
= localtime (&ts
.tv_sec
))
2092 && strftime (buf
, sizeof buf
, fmt
, tm
))
2094 /* For %AS, %CS, %TS, add the fractional part of the seconds
2099 assert ((sizeof buf
- strlen(buf
)) > strlen(ns_buf
));
2100 strcat(buf
, ns_buf
);
2106 uintmax_t w
= ts
.tv_sec
;
2107 size_t used
, len
, remaining
;
2109 /* XXX: note that we are negating an unsigned type which is the
2110 * widest possible unsigned type.
2112 char *p
= human_readable (ts
.tv_sec
< 0 ? -w
: w
, buf
+ 1,
2113 human_ceiling
, 1, 1);
2115 assert (p
< (buf
+ (sizeof buf
)));
2117 *--p
= '-'; /* XXX: Ugh, relying on internal details of human_readable(). */
2119 /* Add the nanoseconds part. Because we cannot enforce a
2120 * particlar implementation of human_readable, we cannot assume
2121 * any particular value for (p-buf). So we need to be careful
2122 * that there is enough space remaining in the buffer.
2127 used
= (p
-buf
) + len
; /* Offset into buf of current end */
2128 assert (sizeof buf
> used
); /* Ensure we can perform subtraction safely. */
2129 remaining
= sizeof buf
- used
- 1u; /* allow space for NUL */
2131 if (strlen(ns_buf
) >= remaining
)
2134 "charsprinted=%ld but remaining=%lu: ns_buf=%s",
2135 (long)charsprinted
, (unsigned long)remaining
, ns_buf
);
2137 assert (strlen(ns_buf
) < remaining
);
2144 static const char *weekdays
[] =
2146 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
2148 static char * months
[] =
2150 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
2151 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
2156 ctime_format (struct timespec ts
)
2158 const struct tm
* ptm
;
2159 #define TIME_BUF_LEN 1024u
2160 static char resultbuf
[TIME_BUF_LEN
];
2163 ptm
= localtime(&ts
.tv_sec
);
2166 assert (ptm
->tm_wday
>= 0);
2167 assert (ptm
->tm_wday
< 7);
2168 assert (ptm
->tm_mon
>= 0);
2169 assert (ptm
->tm_mon
< 12);
2170 assert (ptm
->tm_hour
>= 0);
2171 assert (ptm
->tm_hour
< 24);
2172 assert (ptm
->tm_min
< 60);
2173 assert (ptm
->tm_sec
<= 61); /* allows 2 leap seconds. */
2175 /* wkday mon mday hh:mm:ss.nnnnnnnnn yyyy */
2176 nout
= snprintf(resultbuf
, TIME_BUF_LEN
,
2177 "%3s %3s %2d %02d:%02d:%02d.%010ld %04d",
2178 weekdays
[ptm
->tm_wday
],
2179 months
[ptm
->tm_mon
],
2184 (long int)ts
.tv_nsec
,
2185 1900 + ptm
->tm_year
);
2187 assert (nout
< TIME_BUF_LEN
);
2192 /* The time cannot be represented as a struct tm.
2193 Output it as an integer. */
2194 return format_date (ts
, '@');
2198 /* Copy STR into BUF and trim blanks from the end of BUF.
2202 blank_rtrim (str
, buf
)
2211 i
= strlen (buf
) - 1;
2212 while ((i
>= 0) && ((buf
[i
] == ' ') || buf
[i
] == '\t'))
2218 /* Print out the predicate list starting at NODE. */
2220 print_list (FILE *fp
, struct predicate
*node
)
2222 struct predicate
*cur
;
2228 fprintf (fp
, "[%s] ", blank_rtrim (cur
->p_name
, name
));
2229 cur
= cur
->pred_next
;
2234 /* Print out the predicate list starting at NODE. */
2236 print_parenthesised(FILE *fp
, struct predicate
*node
)
2242 if ((pred_is(node
, pred_or
) || pred_is(node
, pred_and
))
2243 && node
->pred_left
== NULL
)
2245 /* We print "<nothing> or X" as just "X"
2246 * We print "<nothing> and X" as just "X"
2248 print_parenthesised(fp
, node
->pred_right
);
2252 if (node
->pred_left
|| node
->pred_right
)
2256 fprintf(fp
, "%s", " ( ");
2257 print_optlist(fp
, node
);
2259 fprintf(fp
, "%s", " ) ");
2265 print_optlist (FILE *fp
, const struct predicate
*p
)
2269 print_parenthesised(fp
, p
->pred_left
);
2272 p
->need_stat
? "[call stat] " : "",
2273 p
->need_type
? "[need type] " : "");
2274 print_predicate(fp
, p
);
2275 fprintf(fp
, " [%g] ", p
->est_success_rate
);
2276 if (options
.debug_options
& DebugSuccessRates
)
2278 fprintf(fp
, "[%ld/%ld", p
->perf
.successes
, p
->perf
.visits
);
2281 double real_rate
= (double)p
->perf
.successes
/ (double)p
->perf
.visits
;
2282 fprintf(fp
, "=%g] ", real_rate
);
2286 fprintf(fp
, "=_] ");
2289 print_parenthesised(fp
, p
->pred_right
);
2293 void show_success_rates(const struct predicate
*p
)
2295 if (options
.debug_options
& DebugSuccessRates
)
2297 fprintf(stderr
, "Predicate success rates after completion:\n");
2298 print_optlist(stderr
, p
);
2299 fprintf(stderr
, "\n");
2307 /* If _NDEBUG is defined, the assertions will do nothing. Hence
2308 * there is no point in having a function body for pred_sanity_check()
2309 * if that preprocessor macro is defined.
2312 pred_sanity_check(const struct predicate
*predicates
)
2314 /* Do nothing, since assert is a no-op with _NDEBUG set */
2319 pred_sanity_check(const struct predicate
*predicates
)
2321 const struct predicate
*p
;
2323 for (p
=predicates
; p
!= NULL
; p
=p
->pred_next
)
2325 /* All predicates must do something. */
2326 assert (p
->pred_func
!= NULL
);
2328 /* All predicates must have a parser table entry. */
2329 assert (p
->parser_entry
!= NULL
);
2331 /* If the parser table tells us that just one predicate function is
2332 * possible, verify that that is still the one that is in effect.
2333 * If the parser has NULL for the predicate function, that means that
2334 * the parse_xxx function fills it in, so we can't check it.
2336 if (p
->parser_entry
->pred_func
)
2338 assert (p
->parser_entry
->pred_func
== p
->pred_func
);
2341 switch (p
->parser_entry
->type
)
2343 /* Options all take effect during parsing, so there should
2344 * be no predicate entries corresponding to them. Hence we
2345 * should not see any ARG_OPTION or ARG_POSITIONAL_OPTION
2348 * This is a silly way of coding this test, but it prevents
2349 * a compiler warning (i.e. otherwise it would think that
2350 * there would be case statements missing).
2353 case ARG_POSITIONAL_OPTION
:
2354 assert (p
->parser_entry
->type
!= ARG_OPTION
);
2355 assert (p
->parser_entry
->type
!= ARG_POSITIONAL_OPTION
);
2359 assert(p
->side_effects
); /* actions have side effects. */
2360 if (!pred_is(p
, pred_prune
) && !pred_is(p
, pred_quit
))
2362 /* actions other than -prune and -quit should
2363 * inhibit the default -print
2365 assert (p
->no_default_print
);
2369 /* We happen to know that the only user of ARG_SPECIAL_PARSE
2370 * is a test, so handle it like ARG_TEST.
2372 case ARG_SPECIAL_PARSE
:
2374 case ARG_PUNCTUATION
:
2376 /* Punctuation and tests should have no side
2377 * effects and not inhibit default print.
2379 assert (!p
->no_default_print
);
2380 assert (!p
->side_effects
);