pax_global_header00006660000000000000000000000064141725437000014515gustar00rootroot0000000000000052 comment=8199f5c1c599a39ba0a9c4ace0bacde95b4bb483 bfs-2.3.1/000077500000000000000000000000001417254370000122725ustar00rootroot00000000000000bfs-2.3.1/LICENSE000066400000000000000000000012421417254370000132760ustar00rootroot00000000000000Copyright (C) 2015-2021 Tavian Barnes Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. bfs-2.3.1/Makefile000066400000000000000000000135341417254370000137400ustar00rootroot00000000000000############################################################################ # bfs # # Copyright (C) 2015-2021 Tavian Barnes # # # # Permission to use, copy, modify, and/or distribute this software for any # # purpose with or without fee is hereby granted. # # # # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES # # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF # # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR # # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES # # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN # # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF # # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. # ############################################################################ ifeq ($(wildcard .git),) VERSION := 2.3.1 else VERSION := $(shell git describe --always) endif ifndef OS OS := $(shell uname) endif ifndef ARCH ARCH := $(shell uname -m) endif CC ?= gcc INSTALL ?= install MKDIR ?= mkdir -p RM ?= rm -f DEFAULT_CFLAGS := \ -g \ -Wall \ -Wmissing-declarations \ -Wshadow \ -Wsign-compare \ -Wstrict-prototypes \ -Wimplicit-fallthrough CFLAGS ?= $(DEFAULT_CFLAGS) LDFLAGS ?= DEPFLAGS ?= -MD -MP -MF $(@:.o=.d) DESTDIR ?= PREFIX ?= /usr MANDIR ?= $(PREFIX)/share/man LOCAL_CPPFLAGS := \ -D__EXTENSIONS__ \ -D_ATFILE_SOURCE \ -D_BSD_SOURCE \ -D_DARWIN_C_SOURCE \ -D_DEFAULT_SOURCE \ -D_FILE_OFFSET_BITS=64 \ -D_GNU_SOURCE \ -DBFS_VERSION=\"$(VERSION)\" LOCAL_CFLAGS := -std=c99 LOCAL_LDFLAGS := LOCAL_LDLIBS := ASAN_CFLAGS := -fsanitize=address MSAN_CFLAGS := -fsanitize=memory -fsanitize-memory-track-origins UBSAN_CFLAGS := -fsanitize=undefined ifeq ($(OS),Linux) LOCAL_LDFLAGS += -Wl,--as-needed LOCAL_LDLIBS += -lacl -lcap -lattr -lrt # These libraries are not built with msan, so disable them MSAN_CFLAGS += -DBFS_HAS_SYS_ACL=0 -DBFS_HAS_SYS_CAPABILITY=0 -DBFS_HAS_SYS_XATTR=0 DISTCHECK_FLAGS := TEST_FLAGS="--verbose --all --sudo" else DISTCHECK_FLAGS := TEST_FLAGS="--verbose" endif ifeq ($(OS),NetBSD) LOCAL_LDLIBS += -lutil endif ifneq ($(filter asan,$(MAKECMDGOALS)),) LOCAL_CFLAGS += $(ASAN_CFLAGS) SANITIZE := y endif ifneq ($(filter msan,$(MAKECMDGOALS)),) LOCAL_CFLAGS += $(MSAN_CFLAGS) SANITIZE := y endif ifneq ($(filter ubsan,$(MAKECMDGOALS)),) LOCAL_CFLAGS += $(UBSAN_CFLAGS) SANITIZE := y endif ifdef SANITIZE LOCAL_CFLAGS += -fno-sanitize-recover=all endif ifneq ($(filter gcov,$(MAKECMDGOALS)),) LOCAL_CFLAGS += --coverage endif ifneq ($(filter release,$(MAKECMDGOALS)),) CFLAGS := $(DEFAULT_CFLAGS) -O3 -flto -DNDEBUG endif ALL_CPPFLAGS = $(LOCAL_CPPFLAGS) $(CPPFLAGS) ALL_CFLAGS = $(ALL_CPPFLAGS) $(LOCAL_CFLAGS) $(CFLAGS) $(DEPFLAGS) ALL_LDFLAGS = $(ALL_CFLAGS) $(LOCAL_LDFLAGS) $(LDFLAGS) ALL_LDLIBS = $(LOCAL_LDLIBS) $(LDLIBS) # Save the full set of flags to rebuild everything when they change ALL_FLAGS := $(CC) : $(ALL_CFLAGS) : $(ALL_LDFLAGS) : $(ALL_LDLIBS) $(shell ./flags.sh $(ALL_FLAGS)) # Goals that make binaries BIN_GOALS := bfs tests/mksock tests/trie tests/xtimegm # Goals that are treated like flags by this Makefile FLAG_GOALS := asan msan ubsan gcov release # These are the remaining non-flag goals GOALS := $(filter-out $(FLAG_GOALS),$(MAKECMDGOALS)) # Build the default goal if only flag goals are specified FLAG_PREREQS := ifndef GOALS FLAG_PREREQS += default endif # The different search strategies that we test STRATEGIES := bfs dfs ids eds STRATEGY_CHECKS := $(STRATEGIES:%=check-%) # All the different checks we run CHECKS := $(STRATEGY_CHECKS) check-trie check-xtimegm default: bfs all: $(BIN_GOALS) bfs: \ bar.o \ bftw.o \ color.o \ ctx.o \ darray.o \ diag.o \ dir.o \ dstring.o \ eval.o \ exec.o \ fsade.o \ main.o \ mtab.o \ opt.o \ parse.o \ printf.o \ pwcache.o \ spawn.o \ stat.o \ time.o \ trie.o \ typo.o \ util.o tests/mksock: tests/mksock.o tests/trie: trie.o tests/trie.o tests/xtimegm: time.o tests/xtimegm.o $(BIN_GOALS): +$(CC) $(ALL_LDFLAGS) $^ $(ALL_LDLIBS) -o $@ %.o: %.c .flags $(CC) $(ALL_CFLAGS) -c $< -o $@ # Need a rule for .flags to convince make to apply the above pattern rule if # .flags didn't exist when make was run .flags: # Make sure that "make release" builds everything, but "make release main.o" doesn't $(FLAG_GOALS): $(FLAG_PREREQS) @: check: $(CHECKS) $(STRATEGY_CHECKS): check-%: bfs tests/mksock ./tests.sh --bfs="$(CURDIR)/bfs -S $*" $(TEST_FLAGS) check-trie check-xtimegm: check-%: tests/% $< distcheck: +$(MAKE) -B asan ubsan check $(DISTCHECK_FLAGS) ifneq ($(OS),Darwin) +$(MAKE) -B msan check CC=clang $(DISTCHECK_FLAGS) ifeq ($(ARCH),x86_64) +$(MAKE) -B check CFLAGS="-m32" $(DISTCHECK_FLAGS) endif endif +$(MAKE) -B release check $(DISTCHECK_FLAGS) +$(MAKE) -B check $(DISTCHECK_FLAGS) clean: $(RM) $(BIN_GOALS) .flags *.[od] *.gcda *.gcno tests/*.[od] tests/*.gcda tests/*.gcno install: $(MKDIR) $(DESTDIR)$(PREFIX)/bin $(INSTALL) -m755 bfs $(DESTDIR)$(PREFIX)/bin/bfs $(MKDIR) $(DESTDIR)$(MANDIR)/man1 $(INSTALL) -m644 bfs.1 $(DESTDIR)$(MANDIR)/man1/bfs.1 $(MKDIR) $(DESTDIR)$(PREFIX)/share/bash-completion/completions $(INSTALL) -m644 completions/bfs.bash $(DESTDIR)$(PREFIX)/share/bash-completion/completions/bfs uninstall: $(RM) $(DESTDIR)$(PREFIX)/share/bash-completion/completions/bfs $(RM) $(DESTDIR)$(MANDIR)/man1/bfs.1 $(RM) $(DESTDIR)$(PREFIX)/bin/bfs .PHONY: default all $(FLAG_GOALS) check $(CHECKS) distcheck clean install uninstall .SUFFIXES: -include $(wildcard *.d) bfs-2.3.1/README.md000066400000000000000000000107451417254370000135600ustar00rootroot00000000000000`bfs` ===== [![License](http://img.shields.io/badge/license-0BSD-blue.svg)](https://github.com/tavianator/bfs/blob/main/LICENSE) [![Version](https://img.shields.io/github/v/tag/tavianator/bfs?label=version)](https://github.com/tavianator/bfs/releases) [![Linux CI Status](https://github.com/tavianator/bfs/actions/workflows/linux.yml/badge.svg?branch=main)](https://github.com/tavianator/bfs/actions/workflows/linux.yml) [![macOS CI Status](https://github.com/tavianator/bfs/actions/workflows/macos.yml/badge.svg?branch=main)](https://github.com/tavianator/bfs/actions/workflows/macos.yml) [![FreeBSD CI Status](https://github.com/tavianator/bfs/actions/workflows/freebsd.yml/badge.svg?branch=main)](https://github.com/tavianator/bfs/actions/workflows/freebsd.yml) Breadth-first search for your files. Screenshot `bfs` is a variant of the UNIX `find` command that operates [breadth-first](https://en.wikipedia.org/wiki/Breadth-first_search) rather than [depth-first](https://en.wikipedia.org/wiki/Depth-first_search). It is otherwise compatible with many versions of `find`, including - [POSIX `find`](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/find.html) - [GNU `find`](https://www.gnu.org/software/findutils/) - {[Free](https://www.freebsd.org/cgi/man.cgi?find(1)),[Open](https://man.openbsd.org/find.1),[Net](https://man.netbsd.org/find.1)}BSD `find` - [macOS `find`](https://ss64.com/osx/find.html) If you're not familiar with `find`, the [GNU find manual](https://www.gnu.org/software/findutils/manual/html_mono/find.html) provides a good introduction. Breadth vs. depth ----------------- The advantage of breadth-first over depth first search is that it usually finds the file(s) you're looking for faster. Imagine the following directory tree: 
haystack
├── deep
│   └── 1
│       └── 2
│           └── 3
│               └── 4
│                   └── ...
└── shallow
    └── needle
`find` will explore the entire `deep` directory tree before it ever gets to the `shallow` one that contains what you're looking for. 
$ find haystack
haystack
haystack/deep
haystack/deep/1
haystack/deep/1/2
haystack/deep/1/2/3
haystack/deep/1/2/3/4
...
haystack/shallow
haystack/shallow/needle
On the other hand, `bfs` lists files from shallowest to deepest, so you never have to wait for it to explore an entire unrelated subtree. 
$ bfs haystack
haystack
haystack/deep
haystack/shallow
haystack/deep/1
haystack/shallow/needle
haystack/deep/1/2
haystack/deep/1/2/3
haystack/deep/1/2/3/4
...
Easy ---- `bfs` tries to be easier to use than `find`, while remaining compatible. For example, `bfs` is less picky about where you put its arguments: 
$ find -L -name 'needle' haystack
find: paths must precede expression: haystack
$ bfs -L -name 'needle' haystack
haystack/needle

$ find haystack -L -name 'needle'
find: unknown predicate `-L'
$ bfs haystack -L -name 'needle'
haystack/needle

$ find -L haystack -name 'needle'
haystack/needle
$ bfs -L haystack -name 'needle'
haystack/needle
`bfs` also adds some extra options that make some common tasks easier. Compare bfs -name config -exclude -name .git vs. find ! \( -name .git -prune \) -name config Try it! ------- `bfs` may already be packaged for your distribution of choice. For example: 
Alpine Linux
# apk add bfs

Debian/Ubuntu
# apt install bfs

NixOS
# nix-env -i bfs

Void Linux
# xbps-install -S bfs

FreeBSD
# pkg install bfs

MacPorts
# port install bfs

Homebrew
$ brew install tavianator/tap/bfs
To install `bfs` from source, download one of the [releases](https://github.com/tavianator/bfs/releases) or clone the [git repo](https://github.com/tavianator/bfs). Then run $ make This will build the `bfs` binary in the current directory. You can test it out: $ ./bfs -nohidden If you're interested in speed, you may want to build the release version instead: $ make release Finally, if you want to install it globally, run $ sudo make install bfs-2.3.1/RELEASES.md000066400000000000000000000365271417254370000140340ustar00rootroot000000000000002.* === 2.3.1 ----- **January 21, 2022** - Fixed the build on Debian kFreeBSD - Fixed a crash on GNU Hurd when piping bfs's output - Fixed a double-`close()` on non-Linux platforms if `fdopendir()` fails - Reduced memory allocations on startup 2.3 --- **November 25, 2021** - More tweaks to `PAGER` and `LESS` handling for `bfs -help` ([#76]) - Use 512-byte blocks for `-ls` when `POSIXLY_CORRECT` is set ([#77]) - Implemented `-files0-from FILE` to take a list of `'\0'`-separated starting paths. GNU find will implement the same feature in an upcoming release. - Added colors to `-printf` output ([#62]) - Faster recovery from `E2BIG` during `-exec` [#76]: https://github.com/tavianator/bfs/issues/76 [#77]: https://github.com/tavianator/bfs/issues/77 [#62]: https://github.com/tavianator/bfs/issues/62 2.2.1 ----- **June 2, 2021** - Fixed some incorrect coloring of broken links when links are being followed (`-L`) - Made the tests work when run as root by dropping privileges. This may be helpful for certain packaging or CI environments, but is not recommended. - Treat empty `PAGER` and `LESS` environment variables like they're unset, for `bfs -help` ([#71]). Thanks @markus-oberhumer! - The soft `RLIMIT_NOFILE` is now raised automatically to a fairly large value when possible. This provides a minor performance benefit for large directory trees. - Implemented time units for `-mtime` as found in FreeBSD find ([#75]) [#71]: https://github.com/tavianator/bfs/issues/71 [#75]: https://github.com/tavianator/bfs/issues/75 2.2 --- **March 6, 2021** - Fixed `-hidden` on hidden start paths - Added a Bash completion script. Thanks @bmundt6! - Fixed rounding in `-used`. Corresponding fixes were made to GNU find in version 4.8.0. - Optimized the open directory representation. On Linux, much libc overhead is bypassed by issuing syscalls directly. On all platforms, a few fewer syscalls and open file descriptors will be used. - Implemented `-flags` from BSD find 2.1 --- **November 11, 2020** - Added a new `-status` option that displays the search progress in a bar at the bottom of the terminal - Fixed an optimizer bug introduced in version 2.0 that affected some combinations of `-user`/`-group` and `-nouser`/`-nogroup` 2.0 --- **October 14, 2020** - [#8]: New `-exclude ` syntax to more easily and reliably filter out paths. For example: bfs -name config -exclude -name .git will find all files named `config`, without searching any directories (or files) named `.git`. In this case, the same effect could have been achieved (more awkwardly) with `-prune`: bfs ! \( -name .git -prune \) -name config But `-exclude` will work in more cases: # -exclude works with -depth, while -prune doesn't: bfs -depth -name config -exclude -name .git # -exclude applies even to paths below the minimum depth: bfs -mindepth 3 -name config -exclude -name .git - [#30]: `-nohidden` is now equivalent to `-exclude -hidden`. This changes the behavior of command lines like bfs -type f -nohidden to do what was intended. - Optimized the iterative deepening (`-S ids`) implementation - Added a new search strategy: exponential deepening search (`-S eds`). This strategy provides many of the benefits of iterative deepening, but much faster due to fewer re-traversals. - Fixed an optimizer bug that could skip `-empty`/`-xtype` if they didn't always lead to an action - Implemented `-xattrname` to find files with a particular extended attribute (from macOS find) - Made `-printf %l` still respect the width specifier (e.g. `%10l`) for non-links, to match GNU find - Made `bfs` fail if `-color` is given explicitly and `LS_COLORS` can't be parsed, rather than falling back to non-colored output [#8]: https://github.com/tavianator/bfs/issues/8 [#30]: https://github.com/tavianator/bfs/issues/30 1.* === 1.7 --- **April 22, 2020** - Fixed `-ls` printing numeric IDs instead of user/group names in large directory trees - Cached the user and group tables for a performance boost - Fixed interpretation of "default" ACLs - Implemented `-s` flag to sort results 1.6 --- **February 25, 2020** - Implemented `-newerXt` (explicit reference times), `-since`, `-asince`, etc. - Fixed `-empty` to skip special files (pipes, devices, sockets, etc.) 1.5.2 ----- **January 9, 2020** - Fixed the build on NetBSD - Added support for NFSv4 ACLs on FreeBSD - Added a `+` after the file mode for files with ACLs in `-ls` - Supported more file types (whiteouts, doors) in symbolic modes for `-ls`/`-printf %M` - Implemented `-xattr` on FreeBSD 1.5.1 ----- **September 14, 2019** - Added a warning to `-mount`, since it will change behaviour in the next POSIX revision - Added a workaround for environments that block `statx()` with `seccomp()`, like older Docker - Fixed coloring of nonexistent leading directories - Avoided calling `stat()` on all mount points at startup 1.5 --- **June 27, 2019** - New `-xattr` predicate to find files with extended attributes - Fixed the `-acl` implementation on macOS - Implemented depth-first (`-S dfs`) and iterative deepening search (`-S ids`) - Piped `-help` output into `$PAGER` by default - Fixed crashes on some invalid `LS_COLORS` values 1.4.1 ----- **April 5, 2019** - Added a nicer error message when the tests are run as root - Fixed detection of comparison expressions with signs, to match GNU find for things like `-uid ++10` - Added support for https://no-color.org/ - Decreased the number of `stat()` calls necessary in some cases 1.4 --- **April 15, 2019** - New `-unique` option that filters out duplicate files ([#48]) - Optimized the file coloring implementation - Fixed the coloring implementation to match GNU ls more closely in many corner cases - Implemented escape sequence parsing for `LS_COLORS` - Implemented `ln=target` for coloring links like their targets - Fixed the order of fallbacks used when some color keys are unset - Add a workaround for incorrect file types for bind-mounted files on Linux ([#37]) [#48]: https://github.com/tavianator/bfs/issues/48 [#37]: https://github.com/tavianator/bfs/issues/37 1.3.3 ----- **February 10, 2019** - Fixed unpredictable behaviour for empty responses to `-ok`/`-okdir` caused by an uninitialized string - Writing to standard output now causes `bfs` to fail if the descriptor was closed - Fixed incomplete file coloring in error messages - Added some data flow optimizations - Fixed `-nogroup`/`-nouser` in big directory trees - Added `-type w` for whiteouts, as supported by FreeBSD `find` - Re-wrote the `-help` message and manual page 1.3.2 ----- **January 11, 2019** - Fixed an out-of-bounds read if LS_COLORS doesn't end with a `:` - Allowed multiple debug flags to be specified like `-D opt,tree` 1.3.1 ----- **January 3, 2019** - Fixed some portability problems affecting FreeBSD 1.3 --- **January 2, 2019** New features: - `-acl` finds files with non-trivial Access Control Lists (from FreeBSD) - `-capable` finds files with capabilities set - `-D all` turns on all debugging flags at once Fixes: - `LS_COLORS` handling has been improved: - Extension colors are now case-insensitive like GNU `ls` - `or` (orphan) and `mi` (missing) files are now treated differently - Default colors can be unset with `di=00` or similar - Specific colors fall back to more general colors when unspecified in more places - `LS_COLORS` no longer needs a trailing colon - `-ls`/`-fls` now prints the major/minor numbers for device nodes - `-exec ;` is rejected rather than segfaulting - `bfs` now builds on old Linux versions that require `-lrt` for POSIX timers - For files whose access/change/modification times can't be read, `bfs` no longer fails unless those times are needed for tests - The testsuite is now more correct and portable 1.2.4 ----- **September 24, 2018** - GNU find compatibility fixes for `-printf`: - `%Y` now prints `?` if an error occurs resolving the link - `%B` is now supported for birth/creation time (as well as `%W`/`%w`) - All standard `strftime()` formats are supported, not just the ones from the GNU find manual - Optimizations are now re-run if any expressions are reordered - `-exec` and friends no longer leave zombie processes around when `exec()` fails 1.2.3 ----- **July 15, 2018** - Fixed `test_depth_error` on filesystems that don't fill in `d_type` - Fixed the build on Linux architectures that don't have the `statx()` syscall (ia64, sh4) - Fixed use of AT_EMPTY_PATH for fstatat on systems that don't support it (Hurd) - Fixed `ARG_MAX` accounting on architectures with large pages (ppc64le) - Fixed the build against the upcoming glibc 2.28 release that includes its own `statx()` wrapper 1.2.2 ----- **June 23, 2018** - Minor bug fixes: - Fixed `-exec ... '{}' +` argument size tracking after recovering from `E2BIG` - Fixed `-fstype` if `/proc` is available but `/etc/mtab` is not - Fixed an uninitialized variable when given `-perm +rw...` - Fixed some potential "error: 'path': Success" messages - Reduced reliance on GNU coreutils in the testsuite - Refactored and simplified the internals of `bftw()` 1.2.1 ----- **February 8, 2018** - Performance optimizations 1.2 --- **January 20, 2018** - Added support for the `-perm +7777` syntax deprecated by GNU find (equivalent to `-perm /7777`), for compatibility with BSD finds - Added support for file birth/creation times on platforms that report it - `-Bmin`/`-Btime`/`-Bnewer` - `B` flag for `-newerXY` - `%w` and `%Wk` directives for `-printf` - Uses the `statx(2)` system call on new enough Linux kernels - More robustness to `E2BIG` added to the `-exec` implementation 1.1.4 ----- **October 27, 2017** - Added a man page - Fixed cases where multiple actions write to the same file - Report errors that occur when closing files/flushing streams - Fixed "argument list too long" errors with `-exec ... '{}' +` 1.1.3 ----- **October 4, 2017** - Refactored the optimizer - Implemented data flow optimizations 1.1.2 ----- **September 10, 2017** - Fixed `-samefile` and similar predicates when passed broken symbolic links - Implemented `-fstype` on Solaris - Fixed `-fstype` under musl - Implemented `-D search` - Implemented a cost-based optimizer 1.1.1 ----- **August 10, 2017** - Re-licensed under the BSD Zero Clause License - Fixed some corner cases with `-exec` and `-ok` parsing 1.1 --- **July 22, 2017** - Implemented some primaries from NetBSD `find`: - `-exit [STATUS]` (like `-quit`, but with an optional explicit exit status) - `-printx` (escape special characters for `xargs`) - `-rm` (alias for `-delete`) - Warn if `-prune` will have no effect due to `-depth` - Handle y/n prompts according to the user's locale - Prompt the user to correct typos without having to re-run `bfs` - Fixed handling of paths longer than `PATH_MAX` - Fixed spurious "Inappropriate ioctl for device" errors when redirecting `-exec ... +` output - Fixed the handling of paths that treat a file as a directory (e.g. `a/b/c` where `a/b` is a regular file) - Fixed an expression optimizer bug that broke command lines like `bfs -name '*' -o -print` 1.0.2 ----- **June 15, 2017** Bugfix release. - Fixed handling of \0 inside -printf format strings - Fixed `-perm` interpretation of permcopy actions (e.g. `u=rw,g=r`) 1.0.1 ----- **May 17, 2017** Bugfix release. - Portability fixes that mostly affect GNU Hurd - Implemented `-D exec` - Made `-quit` not disable the implicit `-print` 1.0 --- **April 24, 2017** This is the first release of bfs with support for all of GNU find's primitives. Changes since 0.96: - Implemented `-fstype` - Implemented `-exec/-execdir ... +` - Implemented BSD's `-X` - Fixed the tests under Bash 3 (mostly for macOS) - Some minor optimizations and fixes 0.* === 0.96 ---- **March 11, 2017** 73/76 GNU find features supported. - Implemented -nouser and -nogroup - Implemented -printf and -fprintf - Implemented -ls and -fls - Implemented -type with multiple types at once (e.g. -type f,d,l) - Fixed 32-bit builds - Fixed -lname on "symlinks" in Linux /proc - Fixed -quit to take effect as soon as it's reached - Stopped redirecting standard input from /dev/null for -ok and -okdir, as that violates POSIX - Many test suite improvements 0.88 ---- **December 20, 2016** 67/76 GNU find features supported. - Fixed the build on macOS, and some other UNIXes - Implemented `-regex`, `-iregex`, `-regextype`, and BSD's `-E` - Implemented `-x` (same as `-mount`/`-xdev`) from BSD - Implemented `-mnewer` (same as `-newer`) from BSD - Implemented `-depth N` from BSD - Implemented `-sparse` from FreeBSD - Implemented the `T` and `P` suffices for `-size`, for BSD compatibility - Added support for `-gid NAME` and `-uid NAME` as in BSD 0.84.1 ------ **November 24, 2016** Bugfix release. - Fixed [#7] again - Like GNU find, don't print warnings by default if standard input is not a terminal - Redirect standard input from /dev/null for -ok and -okdir - Skip . when -delete'ing - Fixed -execdir when the root path has no slashes - Fixed -execdir in / - Support -perm +MODE for symbolic modes - Fixed the build on FreeBSD [#7]: https://github.com/tavianator/bfs/issues/7 0.84 ---- **October 29, 2016** 64/76 GNU find features supported. - Spelling suggestion improvements - Handle `--` - (Untested) support for exotic file types like doors, ports, and whiteouts - Improved robustness in the face of closed std{in,out,err} - Fixed the build on macOS - Implement `-ignore_readdir_race`, `-noignore_readdir_race` - Implement `-perm` 0.82 ---- **September 4, 2016** 62/76 GNU find features supported. - Rework optimization levels - `-O1` - Simple boolean simplification - `-O2` - Purity-based optimizations, allowing side-effect-free tests like `-name` or `-type` to be moved or removed - `-O3` (**default**): - Re-order tests to reduce the expected cost (TODO) - `-O4` - Aggressive optimizations that may have surprising effects on warning/error messages and runtime, but should not otherwise affect the results - `-Ofast`: - Always the highest level, currently the same as `-O4` - Color files with multiple hard links correctly - Treat `-`, `)`, and `,` as paths when required to by POSIX - `)` and `,` are only supported before the expression begins - Implement `-D opt` - Implement `-D rates` - Implement `-fprint` - Implement `-fprint0` - Implement BSD's `-f` - Suggest fixes for typo'd arguments 0.79 ---- **May 27, 2016** 60/76 GNU find features supported. - Remove an errant debug `printf()` from `-used` - Implement the `{} ;` variants of `-exec`, `-execdir`, `-ok`, and `-okdir` 0.74 ---- **March 12, 2016** 56/76 GNU find features supported. - Color broken symlinks correctly - Fix [#7] - Fix `-daystart`'s rounding of midnight - Implement (most of) `-newerXY` - Implement `-used` - Implement `-size` [#7]: https://github.com/tavianator/bfs/issues/7 0.70 ---- **February 23, 2016** 53/76 GNU find features supported. - New `make install` and `make uninstall` targets - Squelch non-positional warnings for `-follow` - Reduce memory footprint by as much as 64% by closing `DIR*`s earlier - Speed up `bfs` by ~5% by using a better FD cache eviction policy - Fix infinite recursion when evaluating `! expr` - Optimize unused pure expressions (e.g. `-empty -a -false`) - Optimize double-negation (e.g. `! ! -name foo`) - Implement `-D stat` and `-D tree` - Implement `-O` 0.67 ---- **February 14, 2016** Initial release. 51/76 GNU find features supported. bfs-2.3.1/bar.c000066400000000000000000000135251417254370000132100ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2020-2022 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "bar.h" #include "dstring.h" #include "util.h" #include #include #include #include #include #include #include #include #include struct bfs_bar { int fd; volatile sig_atomic_t width; volatile sig_atomic_t height; }; /** The global status bar instance. */ static struct bfs_bar the_bar = { .fd = -1, }; /** Get the terminal size, if possible. */ static int bfs_bar_getsize(struct bfs_bar *bar) { #ifdef TIOCGWINSZ struct winsize ws; if (ioctl(bar->fd, TIOCGWINSZ, &ws) != 0) { return -1; } bar->width = ws.ws_col; bar->height = ws.ws_row; return 0; #else errno = ENOTSUP; return -1; #endif } /** Async Signal Safe puts(). */ static int ass_puts(int fd, const char *str) { size_t len = strlen(str); return xwrite(fd, str, len) == len ? 0 : -1; } /** Number of decimal digits needed for terminal sizes. */ #define ITOA_DIGITS ((sizeof(unsigned short) * CHAR_BIT + 2) / 3) /** Async Signal Safe itoa(). */ static char *ass_itoa(char *str, unsigned int n) { char *end = str + ITOA_DIGITS; *end = '\0'; char *c = end; do { *--c = '0' + (n % 10); n /= 10; } while (n); size_t len = end - c; memmove(str, c, len + 1); return str + len; } /** Update the size of the scrollable region. */ static int bfs_bar_resize(struct bfs_bar *bar) { char esc_seq[12 + ITOA_DIGITS] = "\0337" // DECSC: Save cursor "\033[;"; // DECSTBM: Set scrollable region // DECSTBM takes the height as the second argument char *ptr = esc_seq + strlen(esc_seq); ptr = ass_itoa(ptr, bar->height - 1); strcpy(ptr, "r" // DECSTBM "\0338" // DECRC: Restore the cursor "\033[J" // ED: Erase display from cursor to end ); return ass_puts(bar->fd, esc_seq); } #ifdef SIGWINCH /** SIGWINCH handler. */ static void sighand_winch(int sig) { int error = errno; bfs_bar_getsize(&the_bar); bfs_bar_resize(&the_bar); errno = error; } #endif /** Reset the scrollable region and hide the bar. */ static int bfs_bar_reset(struct bfs_bar *bar) { return ass_puts(bar->fd, "\0337" // DECSC: Save cursor "\033[r" // DECSTBM: Reset scrollable region "\0338" // DECRC: Restore cursor "\033[J" // ED: Erase display from cursor to end ); } /** Signal handler for process-terminating signals. */ static void sighand_reset(int sig) { bfs_bar_reset(&the_bar); raise(sig); } /** Register sighand_reset() for a signal. */ static void reset_before_death_by(int sig) { struct sigaction sa = { .sa_handler = sighand_reset, .sa_flags = SA_RESETHAND, }; sigemptyset(&sa.sa_mask); sigaction(sig, &sa, NULL); } /** printf() to the status bar with a single write(). */ BFS_FORMATTER(2, 3) static int bfs_bar_printf(struct bfs_bar *bar, const char *format, ...) { va_list args; va_start(args, format); char *str = dstrvprintf(format, args); va_end(args); if (!str) { return -1; } int ret = ass_puts(bar->fd, str); dstrfree(str); return ret; } struct bfs_bar *bfs_bar_show(void) { if (the_bar.fd >= 0) { errno = EBUSY; goto fail; } char term[L_ctermid]; ctermid(term); if (strlen(term) == 0) { errno = ENOTTY; goto fail; } the_bar.fd = open(term, O_RDWR | O_CLOEXEC); if (the_bar.fd < 0) { goto fail; } if (bfs_bar_getsize(&the_bar) != 0) { goto fail_close; } reset_before_death_by(SIGABRT); reset_before_death_by(SIGINT); reset_before_death_by(SIGPIPE); reset_before_death_by(SIGQUIT); reset_before_death_by(SIGTERM); #ifdef SIGWINCH struct sigaction sa = { .sa_handler = sighand_winch, .sa_flags = SA_RESTART, }; sigemptyset(&sa.sa_mask); sigaction(SIGWINCH, &sa, NULL); #endif bfs_bar_printf(&the_bar, "\n" // Make space for the bar "\0337" // DECSC: Save cursor "\033[;%ur" // DECSTBM: Set scrollable region "\0338" // DECRC: Restore cursor "\033[1A", // CUU: Move cursor up 1 row (unsigned int)(the_bar.height - 1) ); return &the_bar; fail_close: close_quietly(the_bar.fd); the_bar.fd = -1; fail: return NULL; } unsigned int bfs_bar_width(const struct bfs_bar *bar) { return bar->width; } int bfs_bar_update(struct bfs_bar *bar, const char *str) { return bfs_bar_printf(bar, "\0337" // DECSC: Save cursor "\033[%u;0f" // HVP: Move cursor to row, column "\033[K" // EL: Erase line "\033[7m" // SGR reverse video "%s" "\033[27m" // SGR reverse video off "\0338", // DECRC: Restore cursor (unsigned int)bar->height, str ); } void bfs_bar_hide(struct bfs_bar *bar) { if (!bar) { return; } signal(SIGABRT, SIG_DFL); signal(SIGINT, SIG_DFL); signal(SIGPIPE, SIG_DFL); signal(SIGQUIT, SIG_DFL); signal(SIGTERM, SIG_DFL); #ifdef SIGWINCH signal(SIGWINCH, SIG_DFL); #endif bfs_bar_reset(bar); xclose(bar->fd); bar->fd = -1; } bfs-2.3.1/bar.h000066400000000000000000000036261417254370000132160ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2020 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * A terminal status bar. */ #ifndef BFS_BAR_H #define BFS_BAR_H /** A terminal status bar. */ struct bfs_bar; /** * Create a terminal status bar. Only one status bar is supported at a time. * * @return * A pointer to the new status bar, or NULL on failure. */ struct bfs_bar *bfs_bar_show(void); /** * Get the width of the status bar. */ unsigned int bfs_bar_width(const struct bfs_bar *bar); /** * Update the status bar message. * * @param bar * The status bar to update. * @param str * The string to display. * @return * 0 on success, -1 on failure. */ int bfs_bar_update(struct bfs_bar *bar, const char *str); /** * Hide the status bar. */ void bfs_bar_hide(struct bfs_bar *status); #endif // BFS_BAR_H bfs-2.3.1/bfs.1000066400000000000000000000350571417254370000131400ustar00rootroot00000000000000.TH BFS 1 .SH NAME bfs \- breadth-first search for your files .SH SYNOPSIS .B bfs .RB [ flags ...] .RI [ paths ...] .RB [ expression ...] .PP flags .RB ( \-H / \-L / \-P etc.), .IR paths , and .B expressions may be freely mixed in any order. .SH DESCRIPTION .B bfs is a breadth-first version of the UNIX .BR find (1) command. .PP .B bfs supports almost every feature from every major .BR find (1) implementation, so your existing command lines should work as-is. It also adds some features of its own, such as a more forgiving command line parser and some additional options. .PP Each .I path specified on the command line is treated as a starting path to search through. If no paths are specified, the current directory .RI ( . ) is searched by default. .PP Like .BR find (1), .B bfs interprets its arguments as a short-circuiting Boolean expression. For example, .PP .nf .RS .B bfs \\\( \-name '*.txt' \-or \-lname '*.txt' \\\\) \-and \-print .RE .fi .PP will print the all the paths that are either .txt files or symbolic links to .txt files. .B \-and is implied between two consecutive expressions, so this is equivalent: .PP .nf .RS .B bfs \\\( \-name '*.txt' \-or \-lname '*.txt' \\\\) \-print .RE .fi .PP Finally, .B \-print is implied if no actions are specified, so this too is equivalent: .PP .nf .RS .B bfs \-name '*.txt' \-or \-lname '*.txt' .RE .fi .PP Most options that take a numeric argument .I N will also accept .I \-N or .IR +N . .IR \-N means "less than .IR N ," and .I +N means "greater than .IR N ." .SH FLAGS .TP .B \-H Follow symbolic links on the command line, but not while searching. .TP .B \-L Follow all symbolic links. .TP .B \-P Never follow symbolic links (the default). .TP .B \-E Use extended regular expressions (same as \fB\-regextype posix-extended\fR). .TP .B \-X Filter out files with .RB non- xargs (1)-safe names. .TP .B \-d Search in post-order (same as .BR \-depth ). .TP .B \-s Visit directory entries in sorted order. The sorting takes place within each directory separately, which makes it different from .B bfs ... | .BR sort , but still provides a deterministic ordering. .TP .B \-x Don't descend into other mount points (same as \fB\-xdev\fR). .TP \fB\-f \fIPATH\fR Treat .I PATH as a path to search (useful if it begins with a dash). .PP .TP \fB\-D \fIFLAG\fR Turn on a debugging flag (see .B \-D .IR help ). .PP \fB\-O\fIN\fR .RS Enable optimization level .I N (default: .IR 3 ). .TP .BI \-O 0 Disable all optimizations. .TP .BI \-O 1 Basic logical simplifications. .TP .BI \-O 2 All .BI \-O 1 optimizations, plus dead code elimination and data flow analysis. .TP .BI \-O 3 All .BI \-O 2 optimizations, plus re-order expressions to reduce expected cost. .TP \fB\-O\fI4\fR/\fB\-O\fIfast\fR All optimizations, including aggressive optimizations that may alter the observed behavior in corner cases. .RE .PP \fB\-S \fIbfs\fR|\fIdfs\fR|\fIids\fR|\fIeds\fR .RS Choose the search strategy. .TP .I bfs Breadth-first search (the default). .TP .I dfs Depth-first search. Uses less memory than breadth-first search, but is typically slower to return relevant results. .TP .I ids Iterative deepening search. Performs repeated depth-first searches with increasing depth limits. This gives results in the same order as breadth-first search, but with the reduced memory consumption of depth-first search. Tends to be very slow in practice, so use it only if you absolutely need breadth-first ordering, but .B \-S .I bfs consumes too much memory. .TP .I eds Exponential deepening search. A compromise between breadth- and depth-first search, which searches exponentially increasing depth ranges (e.g 0-1, 1-2, 2-4, 4-8, etc.). Provides many of the benefits of breadth-first search with depth-first's reduced memory consumption. Typically far faster than .B \-S .IR ids . .RE .SH OPERATORS .TP \fB( \fIexpression \fB)\fR Parentheses are used for grouping expressions together. You'll probably have to write .B \\\\( .I expression .B \\\\) to avoid the parentheses being interpreted by the shell. .PP \fB! \fIexpression\fR .br \fB\-not \fIexpression\fR .RS The "not" operator: returns the negation of the truth value of the .IR expression . You may have to write \fB\\! \fIexpression\fR to avoid \fB!\fR being interpreted by the shell. .RE .PP \fIexpression\fR \fIexpression\fR .br \fIexpression \fB\-a \fIexpression\fR .br \fIexpression \fB\-and \fIexpression\fR .RS Short-circuiting "and" operator: if the left-hand .I expression is .BR true , returns the right-hand .IR expression ; otherwise, returns .BR false . .RE .PP \fIexpression \fB\-o \fIexpression\fR .br \fIexpression \fB\-or \fIexpression\fR .RS Short-circuiting "or" operator: if the left-hand .I expression is .BR false , returns the right-hand .IR expression ; otherwise, returns .BR true . .RE .TP \fIexpression \fB, \fIexpression\fR The "comma" operator: evaluates the left-hand .I expression but discards the result, returning the right-hand .IR expression . .SH SPECIAL FORMS .TP \fB\-exclude \fIexpression\fR Exclude all paths matching the .I expression from the search. This is more powerful than .BR \-prune , because it applies even when the expression wouldn't otherwise be evaluated, due to .B \-depth or .B \-mindepth for example. Exclusions are always applied before other expressions, so it may be least confusing to put them first on the command line. .SH OPTIONS .PP .B \-color .br .B \-nocolor .RS Turn colors on or off (default: .B \-color if outputting to a terminal, .B \-nocolor otherwise). .RE .TP .B \-daystart Measure time relative to the start of today. .TP .B \-depth Search in post-order (descendents first). .TP .B \-follow Follow all symbolic links (same as .BR \-L ). .TP \fB\-files0\-from \fIFILE\fR Treat the NUL ('\\0')-separated paths in .I FILE as starting points for the search. Pass .B \-files0\-from .I \- to read the paths from standard input. .PP \fB\-ignore_readdir_race\fR .br \fB\-noignore_readdir_race\fR .RS Whether to report an error if .B bfs detects that the file tree is modified during the search (default: .BR \-noignore_readdir_race ). .RE .PP \fB\-maxdepth \fIN\fR .br \fB\-mindepth \fIN\fR .RS Ignore files deeper/shallower than .IR N . .RE .TP .B \-mount Don't descend into other mount points (same as .B \-xdev for now, but will skip mount points entirely in the future). .TP .B \-nohidden Exclude hidden files and directories. .TP .B \-noleaf Ignored; for compatibility with GNU find. .TP \fB\-regextype \fITYPE\fR Use .IR TYPE -flavored regexes (default: .IR posix-basic ; see .B \-regextype .IR help ). .TP .B \-status Display a status bar while searching. .TP .B \-unique Skip any files that have already been seen. Particularly useful along with .BR \-L . .PP .B \-warn .br .B \-nowarn .RS Turn on or off warnings about the command line. .RE .TP .B \-xdev Don't descend into other mount points. .SH TESTS .TP .B \-acl Find files with a non-trivial Access Control List .RB ( acl (5)). .PP \fB\-amin\fR [\fI\-+\fR]\fIN\fR .br \fB\-Bmin\fR [\fI\-+\fR]\fIN\fR .br \fB\-cmin\fR [\fI\-+\fR]\fIN\fR .br \fB\-mmin\fR [\fI\-+\fR]\fIN\fR .RS Find files .BR a ccessed/ B irthed/ c hanged/ m odified .I N minutes ago. .RE .PP \fB\-anewer \fIFILE\fR .br \fB\-Bnewer \fIFILE\fR .br \fB\-cnewer \fIFILE\fR .br \fB\-mnewer \fIFILE\fR .RS Find files .BR a ccessed/ B irthed/ c hanged/ m odified more recently than .I FILE was modified. .RE .PP \fB\-asince \fITIME\fR .br \fB\-Bsince \fITIME\fR .br \fB\-csince \fITIME\fR .br \fB\-msince \fITIME\fR .RS Find files .BR a ccessed/ B irthed/ c hanged/ m odified more recently than the ISO 8601-style timestamp .IR TIME . See .BI \-newer XY for examples of the timestamp format. .RE .PP \fB\-atime\fR [\fI\-+\fR]\fIN\fR .br \fB\-Btime\fR [\fI\-+\fR]\fIN\fR .br \fB\-ctime\fR [\fI\-+\fR]\fIN\fR .br \fB\-mtime\fR [\fI\-+\fR]\fIN\fR .RS Find files .BR a ccessed/ B irthed/ c hanged/ m odified .I N days ago. .RE .TP .B \-capable Find files with POSIX.1e .BR capabilities (7) set. .TP \fB\-depth\fR [\fI\-+\fR]\fIN\fR Find files with depth .IR N . .TP .B \-empty Find empty files/directories. .PP .B \-executable .br .B \-readable .br .B \-writable .RS Find files the current user can execute/read/write. .RE .PP .B \-false .br .B \-true .RS Always false/true. .RE .TP .B \-fstype TYPE Find files on file systems with the given .BR TYPE . .PP \fB\-gid\fR [\fI\-+\fR]\fIN\fR .br \fB\-uid\fR [\fI\-+\fR]\fIN\fR .RS Find files owned by group/user ID .IR N . .RE .PP \fB\-group \fINAME\fR .br \fB\-user \fINAME\fR .RS Find files owned by the group/user .IR NAME . .RE .TP .B \-hidden Find hidden files (those beginning with .IR . ). .PP \fB\-ilname \fIGLOB\fR .br \fB\-iname \fIGLOB\fR .br \fB\-ipath \fIGLOB\fR .br \fB\-iregex \fIREGEX\fR .br \fB\-iwholename \fIGLOB\fR .RS Case-insensitive versions of .BR \-lname / \-name / \-path / \-regex / \-wholename . .RE .TP \fB\-inum\fR [\fI\-+\fR]\fIN\fR Find files with inode number .IR N . .TP \fB\-links\fR [\fI\-+\fR]\fIN\fR Find files with .I N hard links. .TP \fB\-lname \fIGLOB\fR Find symbolic links whose target matches the .IR GLOB . .TP \fB\-name \fIGLOB\fR Find files whose name matches the .IR GLOB . .TP \fB\-newer \fIFILE\fR Find files newer than .IR FILE . .TP \fB\-newer\fIXY \fIREFERENCE\fR Find files whose .I X time is newer than the .I Y time of .IR REFERENCE . .I X and .I Y can be any of .RI [ aBcm ] .RI ( a ccess/ B irth/ c hange/ m odification). .I Y may also be .I t to parse .I REFERENCE as an ISO 8601-style timestamp. For example: .PP .RS 1991-12-14 .br 1991-12-14T03:00 .br 1991-12-14T03:00-07:00 .br 1991-12-14T10:00Z .RE .PP .B \-nogroup .br .B \-nouser .RS Find files owned by nonexistent groups/users. .RE .PP \fB\-path \fIGLOB\fR .br \fB\-wholename \fIGLOB\fR .RS Find files whose entire path matches the .IR GLOB . .RE .TP \fB\-perm\fR [\fI\-\fR]\fIMODE\fR Find files with a matching mode. .TP \fB\-regex \fIREGEX\fR Find files whose entire path matches the regular expression .IR REGEX . .TP \fB\-samefile \fIFILE\fR Find hard links to .IR FILE . .TP \fB\-since \fITIME\fR Find files modified since the ISO 8601-style timestamp .IR TIME . See .BI \-newer XY for examples of the timestamp format. .TP \fB\-size\fR [\fI\-+\fR]\fIN\fR[\fIcwbkMGTP\fR] Find files with the given size, in 1-byte .IR c haracters, 2-byte .IR w ords, 512-byte .IR b locks, (default) or .IR k iB/ M iB/ G iB/ T iB/ P iB. .TP .B \-sparse Find files that occupy fewer disk blocks than expected. .TP \fB\-type\fR [\fIbcdlpfswD\fR] Find files of the given type. Possible types are .IR b lock device, .IR c haracter device, .IR d irectory, symbolic .IR l ink, .IR p ipe, regular .IR f ile, .IR s ocket, .IR w hiteout, and .IR D oor. .TP \fB\-used\fR [\fI\-+\fR]\fIN\fR Find files last accessed .I N days after they were changed. .TP .B \-xattr Find files with extended attributes .RB ( xattr (7)). .TP \fB\-xattrname\fR \fINAME\fR Find files with the extended attribute .IR NAME . .TP \fB\-xtype\fR [\fIbcdlpfswD\fR] Find files of the given type, following links when .B \-type would not, and vice versa. .SH ACTIONS .PP .B \-delete .br .B \-rm .RS Delete any found files (implies \fB-depth\fR). .RE .TP \fB\-exec \fIcommand ... {} ;\fR Execute a command. .TP \fB\-exec \fIcommand ... {} +\fR Execute a command with multiple files at once. .TP \fB\-ok \fIcommand ... {} ;\fR Prompt the user whether to execute a command. .PP \fB\-execdir \fIcommand ... {} ;\fR .br \fB\-execdir \fIcommand ... {} +\fR .br \fB\-okdir \fIcommand ... {} ;\fR .RS Like .BR \-exec / \-ok , but run the command in the same directory as the found file(s). .RE .TP \fB\-exit\fR [\fISTATUS\fR] Exit immediately with the given status (0 if unspecified). .PP \fB\-fls \fIFILE\fR .br \fB\-fprint \fIFILE\fR .br \fB\-fprint0 \fIFILE\fR .br \fB\-fprintf \fIFILE FORMAT\fR .RS Like .BR \-ls / \-print / \-print0 / \-printf , but write to .I FILE instead of standard output. .RE .TP .B \-ls List files like .B ls .IR \-dils . .TP .B \-print Print the path to the found file. .TP .B \-print0 Like .BR \-print , but use the null character ('\\0') as a separator rather than newlines. Useful in conjunction with .B xargs .IR \-0 . .TP \fB\-printf \fIFORMAT\fR Print according to a format string (see .BR find (1)). These additional format directives are supported: .RS .TP %w The file's birth time, in the same format as %a/%c/%t. .TP .RI %W k Field .I k of the file's birth time, in the same format as .RI %A k /%C k /%T k . .RE .TP .B \-printx Like .BR \-print , but escape whitespace and quotation characters, to make the output safe for .BR xargs (1). Consider using .B \-print0 and .B xargs .I \-0 instead. .TP .B \-prune Don't descend into this directory. .TP .B \-quit Quit immediately. .TP .B \-version Print version information. .TP .B \-help Print usage information. .SH ENVIRONMENT Certain environment variables affect the behavior of .BR bfs . .PP .B LANG .br .B LC_* .RS Specifies the .BR locale (7) in use for various things. .B bfs is not (yet) translated to any languages except English, but the locale will still affect the format of printed values. Yes/no prompts (e.g. from .BR \-ok ) will also be interpreted according to the current locale. .RE .TP .B LS_COLORS Controls the colors used when displaying file paths if .B \-color is enabled. .B bfs interprets this environment variable is interpreted the same way GNU .BR ls (1) does (see .BR dir_colors (5)). .TP .B NO_COLOR Causes .B bfs to default to .B \-nocolor if it is set (see https://no-color.org/). .TP .B PAGER Specifies the pager used for .B \-help output. Defaults to .BR more (1). .TP .B POSIXLY_CORRECT Makes .B bfs conform more strictly to the POSIX.1-2017 specification for .BR find (1). Currently this just disables warnings by default. It does not disable .BR bfs 's various extensions to the base POSIX functionality. .SH EXAMPLES .TP .B bfs With no arguments, .B bfs prints all files under the current directory in breadth-first order. .TP .B bfs \-name '*.txt' Prints all the .txt files under the current directory. .B *.txt is quoted to ensure the glob is processed by .B bfs rather than the shell. .TP \fBbfs \-name access_log \-L \fI/var\fR Finds all files named .B access_log under .IR /var , following symbolic links. .B bfs allows flags and paths to appear anywhere on the command line. .TP \fBbfs \fI~ \fB\-not \-user $USER\fR Prints all files in your home directory not owned by you. .TP .B bfs \-xtype l Finds broken symbolic links. .TP .B bfs \-name config \-exclude \-name .git Finds all files named .BR config, skipping every .B .git directory. .TP .B bfs \-type f \-executable \-exec strip '{}' + Runs .BR strip (1) on all executable files it finds, passing it multiple files at a time. .SH BUGS https://github.com/tavianator/bfs/issues .SH AUTHOR Tavian Barnes .PP https://tavianator.com/projects/bfs.html .SH SEE ALSO .BR find (1), .BR locate (1), .BR xargs (1) bfs-2.3.1/bfs.h000066400000000000000000000026141417254370000132200ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2015-2021 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * Constants about the bfs program itself. */ #ifndef BFS_H #define BFS_H #ifndef BFS_VERSION # define BFS_VERSION "2.3.1" #endif #ifndef BFS_HOMEPAGE # define BFS_HOMEPAGE "https://tavianator.com/projects/bfs.html" #endif #endif // BFS_H bfs-2.3.1/bftw.c000066400000000000000000001071431417254370000134060ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2015-2022 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * The bftw() implementation consists of the following components: * * - struct bftw_file: A file that has been encountered during the traversal. * They have reference-counted links to their parents in the directory tree. * * - struct bftw_cache: Holds bftw_file's with open file descriptors, used for * openat() to minimize the amount of path re-traversals that need to happen. * Currently implemented as a priority queue based on depth and reference * count. * * - struct bftw_queue: The queue of bftw_file's left to explore. Implemented * as a simple circular buffer. * * - struct bftw_state: Represents the current state of the traversal, allowing * various helper functions to take fewer parameters. */ #include "bftw.h" #include "dir.h" #include "darray.h" #include "dstring.h" #include "mtab.h" #include "stat.h" #include "trie.h" #include "util.h" #include #include #include #include #include #include #include #include /** * A file. */ struct bftw_file { /** The parent directory, if any. */ struct bftw_file *parent; /** The root under which this file was found. */ struct bftw_file *root; /** The next file in the queue, if any. */ struct bftw_file *next; /** This file's depth in the walk. */ size_t depth; /** Reference count. */ size_t refcount; /** Index in the bftw_cache priority queue. */ size_t heap_index; /** An open descriptor to this file, or -1. */ int fd; /** This file's type, if known. */ enum bfs_type type; /** The device number, for cycle detection. */ dev_t dev; /** The inode number, for cycle detection. */ ino_t ino; /** The offset of this file in the full path. */ size_t nameoff; /** The length of the file's name. */ size_t namelen; /** The file's name. */ char name[]; }; /** * A cache of open directories. */ struct bftw_cache { /** A min-heap of open directories. */ struct bftw_file **heap; /** Maximum heap size. */ size_t capacity; }; /** Initialize a cache. */ static void bftw_cache_init(struct bftw_cache *cache, size_t capacity) { cache->heap = NULL; cache->capacity = capacity; } /** Destroy a cache. */ static void bftw_cache_destroy(struct bftw_cache *cache) { assert(darray_length(cache->heap) == 0); darray_free(cache->heap); } /** Check if two heap entries are in heap order. */ static bool bftw_heap_check(const struct bftw_file *parent, const struct bftw_file *child) { if (parent->depth > child->depth) { return true; } else if (parent->depth < child->depth) { return false; } else { return parent->refcount <= child->refcount; } } /** Move a bftw_file to a particular place in the heap. */ static void bftw_heap_move(struct bftw_cache *cache, struct bftw_file *file, size_t i) { cache->heap[i] = file; file->heap_index = i; } /** Bubble an entry up the heap. */ static void bftw_heap_bubble_up(struct bftw_cache *cache, struct bftw_file *file) { size_t i = file->heap_index; while (i > 0) { size_t pi = (i - 1)/2; struct bftw_file *parent = cache->heap[pi]; if (bftw_heap_check(parent, file)) { break; } bftw_heap_move(cache, parent, i); i = pi; } bftw_heap_move(cache, file, i); } /** Bubble an entry down the heap. */ static void bftw_heap_bubble_down(struct bftw_cache *cache, struct bftw_file *file) { size_t i = file->heap_index; size_t size = darray_length(cache->heap); while (true) { size_t ci = 2*i + 1; if (ci >= size) { break; } struct bftw_file *child = cache->heap[ci]; size_t ri = ci + 1; if (ri < size) { struct bftw_file *right = cache->heap[ri]; if (!bftw_heap_check(child, right)) { ci = ri; child = right; } } if (bftw_heap_check(file, child)) { break; } bftw_heap_move(cache, child, i); i = ci; } bftw_heap_move(cache, file, i); } /** Bubble an entry up or down the heap. */ static void bftw_heap_bubble(struct bftw_cache *cache, struct bftw_file *file) { size_t i = file->heap_index; if (i > 0) { size_t pi = (i - 1)/2; struct bftw_file *parent = cache->heap[pi]; if (!bftw_heap_check(parent, file)) { bftw_heap_bubble_up(cache, file); return; } } bftw_heap_bubble_down(cache, file); } /** Increment a bftw_file's reference count. */ static size_t bftw_file_incref(struct bftw_cache *cache, struct bftw_file *file) { size_t ret = ++file->refcount; if (file->fd >= 0) { bftw_heap_bubble_down(cache, file); } return ret; } /** Decrement a bftw_file's reference count. */ static size_t bftw_file_decref(struct bftw_cache *cache, struct bftw_file *file) { size_t ret = --file->refcount; if (file->fd >= 0) { bftw_heap_bubble_up(cache, file); } return ret; } /** Check if the cache is full. */ static bool bftw_cache_full(const struct bftw_cache *cache) { return darray_length(cache->heap) == cache->capacity; } /** Add a bftw_file to the cache. */ static int bftw_cache_add(struct bftw_cache *cache, struct bftw_file *file) { assert(!bftw_cache_full(cache)); assert(file->fd >= 0); size_t size = darray_length(cache->heap); if (DARRAY_PUSH(&cache->heap, &file) != 0) { return -1; } file->heap_index = size; bftw_heap_bubble_up(cache, file); return 0; } /** Remove a bftw_file from the cache. */ static void bftw_cache_remove(struct bftw_cache *cache, struct bftw_file *file) { struct bftw_file *last = DARRAY_POP(cache->heap); if (last != file) { last->heap_index = file->heap_index; bftw_heap_bubble(cache, last); } } /** Close a bftw_file. */ static void bftw_file_close(struct bftw_cache *cache, struct bftw_file *file) { assert(file->fd >= 0); bftw_cache_remove(cache, file); xclose(file->fd); file->fd = -1; } /** Pop a directory from the cache. */ static void bftw_cache_pop(struct bftw_cache *cache) { bftw_file_close(cache, cache->heap[0]); } /** * Shrink the cache, to recover from EMFILE. * * @param cache * The cache in question. * @param saved * A bftw_file that must be preserved. * @return * 0 if successfully shrunk, otherwise -1. */ static int bftw_cache_shrink(struct bftw_cache *cache, const struct bftw_file *saved) { int ret = -1; struct bftw_file *file = NULL; size_t size = darray_length(cache->heap); if (size >= 1) { file = cache->heap[0]; if (file == saved && size >= 2) { file = cache->heap[1]; } } if (file && file != saved) { bftw_file_close(cache, file); ret = 0; } cache->capacity = darray_length(cache->heap); return ret; } /** Compute the name offset of a child path. */ static size_t bftw_child_nameoff(const struct bftw_file *parent) { size_t ret = parent->nameoff + parent->namelen; if (parent->name[parent->namelen - 1] != '/') { ++ret; } return ret; } /** Create a new bftw_file. */ static struct bftw_file *bftw_file_new(struct bftw_cache *cache, struct bftw_file *parent, const char *name) { size_t namelen = strlen(name); size_t size = BFS_FLEX_SIZEOF(struct bftw_file, name, namelen + 1); struct bftw_file *file = malloc(size); if (!file) { return NULL; } file->parent = parent; if (parent) { file->root = parent->root; file->depth = parent->depth + 1; file->nameoff = bftw_child_nameoff(parent); bftw_file_incref(cache, parent); } else { file->root = file; file->depth = 0; file->nameoff = 0; } file->next = NULL; file->refcount = 1; file->fd = -1; file->type = BFS_UNKNOWN; file->dev = -1; file->ino = -1; file->namelen = namelen; memcpy(file->name, name, namelen + 1); return file; } /** * Open a bftw_file relative to another one. * * @param cache * The cache to hold the file. * @param file * The file to open. * @param base * The base directory for the relative path (may be NULL). * @param at_fd * The base file descriptor, AT_FDCWD if base == NULL. * @param at_path * The relative path to the file. * @return * The opened file descriptor, or negative on error. */ static int bftw_file_openat(struct bftw_cache *cache, struct bftw_file *file, const struct bftw_file *base, const char *at_path) { assert(file->fd < 0); int at_fd = AT_FDCWD; if (base) { at_fd = base->fd; assert(at_fd >= 0); } int flags = O_RDONLY | O_CLOEXEC | O_DIRECTORY; int fd = openat(at_fd, at_path, flags); if (fd < 0 && errno == EMFILE) { if (bftw_cache_shrink(cache, base) == 0) { fd = openat(at_fd, at_path, flags); } } if (fd >= 0) { if (bftw_cache_full(cache)) { bftw_cache_pop(cache); } file->fd = fd; if (bftw_cache_add(cache, file) != 0) { close_quietly(fd); file->fd = -1; return -1; } } return fd; } /** * Open a bftw_file. * * @param cache * The cache to hold the file. * @param file * The file to open. * @param path * The full path to the file. * @return * The opened file descriptor, or negative on error. */ static int bftw_file_open(struct bftw_cache *cache, struct bftw_file *file, const char *path) { // Find the nearest open ancestor struct bftw_file *base = file; do { base = base->parent; } while (base && base->fd < 0); const char *at_path = path; if (base) { at_path += bftw_child_nameoff(base); } int fd = bftw_file_openat(cache, file, base, at_path); if (fd >= 0 || errno != ENAMETOOLONG) { return fd; } // Handle ENAMETOOLONG by manually traversing the path component-by-component // Use the ->next linked list to temporarily hold the reversed parent // chain between base and file struct bftw_file *cur; for (cur = file; cur->parent != base; cur = cur->parent) { cur->parent->next = cur; } // Open the files in the chain one by one for (base = cur; base; base = base->next) { fd = bftw_file_openat(cache, base, base->parent, base->name); if (fd < 0 || base == file) { break; } } // Clear out the linked list for (struct bftw_file *next = cur->next; cur != file; cur = next, next = next->next) { cur->next = NULL; } return fd; } /** * Open a bftw_file as a directory. * * @param cache * The cache to hold the file. * @param file * The directory to open. * @param path * The full path to the directory. * @return * The opened directory, or NULL on error. */ static struct bfs_dir *bftw_file_opendir(struct bftw_cache *cache, struct bftw_file *file, const char *path) { int fd = bftw_file_open(cache, file, path); if (fd < 0) { return NULL; } return bfs_opendir(fd, NULL); } /** Free a bftw_file. */ static void bftw_file_free(struct bftw_cache *cache, struct bftw_file *file) { assert(file->refcount == 0); if (file->fd >= 0) { bftw_file_close(cache, file); } free(file); } /** * A queue of bftw_file's to examine. */ struct bftw_queue { /** The head of the queue. */ struct bftw_file *head; /** The insertion target. */ struct bftw_file **target; }; /** Initialize a bftw_queue. */ static void bftw_queue_init(struct bftw_queue *queue) { queue->head = NULL; queue->target = &queue->head; } /** Add a file to a bftw_queue. */ static void bftw_queue_push(struct bftw_queue *queue, struct bftw_file *file) { assert(file->next == NULL); file->next = *queue->target; *queue->target = file; queue->target = &file->next; } /** Pop the next file from the head of the queue. */ static struct bftw_file *bftw_queue_pop(struct bftw_queue *queue) { struct bftw_file *file = queue->head; queue->head = file->next; file->next = NULL; if (queue->target == &file->next) { queue->target = &queue->head; } return file; } /** The split phase of mergesort. */ static struct bftw_file **bftw_sort_split(struct bftw_file **head, struct bftw_file **tail) { struct bftw_file **tortoise = head, **hare = head; while (*hare != *tail) { tortoise = &(*tortoise)->next; hare = &(*hare)->next; if (*hare != *tail) { hare = &(*hare)->next; } } return tortoise; } /** The merge phase of mergesort. */ static struct bftw_file **bftw_sort_merge(struct bftw_file **head, struct bftw_file **mid, struct bftw_file **tail) { struct bftw_file *left = *head, *right = *mid, *end = *tail; *mid = NULL; *tail = NULL; while (left || right) { struct bftw_file *next; if (left && (!right || strcoll(left->name, right->name) <= 0)) { next = left; left = left->next; } else { next = right; right = right->next; } *head = next; head = &next->next; } *head = end; return head; } /** * Sort a (sub-)list of files. * * @param head * The head of the (sub-)list to sort. * @param tail * The tail of the (sub-)list to sort. * @return * The new tail of the (sub-)list. */ static struct bftw_file **bftw_sort_files(struct bftw_file **head, struct bftw_file **tail) { struct bftw_file **mid = bftw_sort_split(head, tail); if (*mid == *head || *mid == *tail) { return tail; } mid = bftw_sort_files(head, mid); tail = bftw_sort_files(mid, tail); return bftw_sort_merge(head, mid, tail); } /** * Holds the current state of the bftw() traversal. */ struct bftw_state { /** bftw() callback. */ bftw_callback *callback; /** bftw() callback data. */ void *ptr; /** bftw() flags. */ enum bftw_flags flags; /** Search strategy. */ enum bftw_strategy strategy; /** The mount table. */ const struct bfs_mtab *mtab; /** The appropriate errno value, if any. */ int error; /** The cache of open directories. */ struct bftw_cache cache; /** The queue of directories left to explore. */ struct bftw_queue queue; /** The start of the current batch of files. */ struct bftw_file **batch; /** The current path. */ char *path; /** The current file. */ struct bftw_file *file; /** The previous file. */ struct bftw_file *previous; /** The currently open directory. */ struct bfs_dir *dir; /** The current directory entry. */ struct bfs_dirent *de; /** Storage for the directory entry. */ struct bfs_dirent de_storage; /** Any error encountered while reading the directory. */ int direrror; /** Extra data about the current file. */ struct BFTW ftwbuf; }; /** * Initialize the bftw() state. */ static int bftw_state_init(struct bftw_state *state, const struct bftw_args *args) { state->callback = args->callback; state->ptr = args->ptr; state->flags = args->flags; state->strategy = args->strategy; state->mtab = args->mtab; state->error = 0; if (args->nopenfd < 2) { errno = EMFILE; return -1; } state->path = dstralloc(0); if (!state->path) { return -1; } // Reserve 1 fd for the open bfs_dir bftw_cache_init(&state->cache, args->nopenfd - 1); bftw_queue_init(&state->queue); state->batch = NULL; state->file = NULL; state->previous = NULL; state->dir = NULL; state->de = NULL; state->direrror = 0; return 0; } /** Cached bfs_stat(). */ static const struct bfs_stat *bftw_stat_impl(struct BFTW *ftwbuf, struct bftw_stat *cache, enum bfs_stat_flags flags) { if (!cache->buf) { if (cache->error) { errno = cache->error; } else if (bfs_stat(ftwbuf->at_fd, ftwbuf->at_path, flags, &cache->storage) == 0) { cache->buf = &cache->storage; } else { cache->error = errno; } } return cache->buf; } const struct bfs_stat *bftw_stat(const struct BFTW *ftwbuf, enum bfs_stat_flags flags) { struct BFTW *mutbuf = (struct BFTW *)ftwbuf; const struct bfs_stat *ret; if (flags & BFS_STAT_NOFOLLOW) { ret = bftw_stat_impl(mutbuf, &mutbuf->lstat_cache, BFS_STAT_NOFOLLOW); if (ret && !S_ISLNK(ret->mode) && !mutbuf->stat_cache.buf) { // Non-link, so share stat info mutbuf->stat_cache.buf = ret; } } else { ret = bftw_stat_impl(mutbuf, &mutbuf->stat_cache, BFS_STAT_FOLLOW); if (!ret && (flags & BFS_STAT_TRYFOLLOW) && is_nonexistence_error(errno)) { ret = bftw_stat_impl(mutbuf, &mutbuf->lstat_cache, BFS_STAT_NOFOLLOW); } } return ret; } const struct bfs_stat *bftw_cached_stat(const struct BFTW *ftwbuf, enum bfs_stat_flags flags) { if (flags & BFS_STAT_NOFOLLOW) { return ftwbuf->lstat_cache.buf; } else if (ftwbuf->stat_cache.buf) { return ftwbuf->stat_cache.buf; } else if ((flags & BFS_STAT_TRYFOLLOW) && is_nonexistence_error(ftwbuf->stat_cache.error)) { return ftwbuf->lstat_cache.buf; } else { return NULL; } } enum bfs_type bftw_type(const struct BFTW *ftwbuf, enum bfs_stat_flags flags) { if (flags & BFS_STAT_NOFOLLOW) { if (ftwbuf->type == BFS_LNK || (ftwbuf->stat_flags & BFS_STAT_NOFOLLOW)) { return ftwbuf->type; } } else if (flags & BFS_STAT_TRYFOLLOW) { if (ftwbuf->type != BFS_LNK || (ftwbuf->stat_flags & BFS_STAT_TRYFOLLOW)) { return ftwbuf->type; } } else { if (ftwbuf->type != BFS_LNK) { return ftwbuf->type; } else if (ftwbuf->stat_flags & BFS_STAT_TRYFOLLOW) { return BFS_ERROR; } } const struct bfs_stat *statbuf = bftw_stat(ftwbuf, flags); if (statbuf) { return bfs_mode_to_type(statbuf->mode); } else { return BFS_ERROR; } } /** * Update the path for the current file. */ static int bftw_update_path(struct bftw_state *state, const char *name) { const struct bftw_file *file = state->file; size_t length = file ? file->nameoff + file->namelen : 0; assert(dstrlen(state->path) >= length); dstresize(&state->path, length); if (name) { if (length > 0 && state->path[length - 1] != '/') { if (dstrapp(&state->path, '/') != 0) { return -1; } } if (dstrcat(&state->path, name) != 0) { return -1; } } return 0; } /** Check if a stat() call is needed for this visit. */ static bool bftw_need_stat(const struct bftw_state *state) { if (state->flags & BFTW_STAT) { return true; } const struct BFTW *ftwbuf = &state->ftwbuf; if (ftwbuf->type == BFS_UNKNOWN) { return true; } if (ftwbuf->type == BFS_LNK && !(ftwbuf->stat_flags & BFS_STAT_NOFOLLOW)) { return true; } if (ftwbuf->type == BFS_DIR) { if (state->flags & (BFTW_DETECT_CYCLES | BFTW_SKIP_MOUNTS | BFTW_PRUNE_MOUNTS)) { return true; } #if __linux__ } else if (state->mtab) { // Linux fills in d_type from the underlying inode, even when // the directory entry is a bind mount point. In that case, we // need to stat() to get the correct type. We don't need to // check for directories because they can only be mounted over // by other directories. if (bfs_might_be_mount(state->mtab, ftwbuf->path)) { return true; } #endif } return false; } /** Initialize bftw_stat cache. */ static void bftw_stat_init(struct bftw_stat *cache) { cache->buf = NULL; cache->error = 0; } /** * Open a file if necessary. * * @param file * The file to open. * @param path * The path to that file or one of its descendants. * @return * The opened file descriptor, or -1 on error. */ static int bftw_ensure_open(struct bftw_cache *cache, struct bftw_file *file, const char *path) { int ret = file->fd; if (ret < 0) { char *copy = strndup(path, file->nameoff + file->namelen); if (!copy) { return -1; } ret = bftw_file_open(cache, file, copy); free(copy); } return ret; } /** * Initialize the buffers with data about the current path. */ static void bftw_init_ftwbuf(struct bftw_state *state, enum bftw_visit visit) { struct bftw_file *file = state->file; const struct bfs_dirent *de = state->de; struct BFTW *ftwbuf = &state->ftwbuf; ftwbuf->path = state->path; ftwbuf->root = file ? file->root->name : ftwbuf->path; ftwbuf->depth = 0; ftwbuf->visit = visit; ftwbuf->type = BFS_UNKNOWN; ftwbuf->error = state->direrror; ftwbuf->at_fd = AT_FDCWD; ftwbuf->at_path = ftwbuf->path; ftwbuf->stat_flags = BFS_STAT_NOFOLLOW; bftw_stat_init(&ftwbuf->lstat_cache); bftw_stat_init(&ftwbuf->stat_cache); struct bftw_file *parent = NULL; if (de) { parent = file; ftwbuf->depth = file->depth + 1; ftwbuf->type = de->type; ftwbuf->nameoff = bftw_child_nameoff(file); } else if (file) { parent = file->parent; ftwbuf->depth = file->depth; ftwbuf->type = file->type; ftwbuf->nameoff = file->nameoff; } if (parent) { // Try to ensure the immediate parent is open, to avoid ENAMETOOLONG if (bftw_ensure_open(&state->cache, parent, state->path) >= 0) { ftwbuf->at_fd = parent->fd; ftwbuf->at_path += ftwbuf->nameoff; } else { ftwbuf->error = errno; } } if (ftwbuf->depth == 0) { // Compute the name offset for root paths like "foo/bar" ftwbuf->nameoff = xbasename(ftwbuf->path) - ftwbuf->path; } if (ftwbuf->error != 0) { ftwbuf->type = BFS_ERROR; return; } int follow_flags = BFTW_FOLLOW_ALL; if (ftwbuf->depth == 0) { follow_flags |= BFTW_FOLLOW_ROOTS; } bool follow = state->flags & follow_flags; if (follow) { ftwbuf->stat_flags = BFS_STAT_TRYFOLLOW; } const struct bfs_stat *statbuf = NULL; if (bftw_need_stat(state)) { statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (statbuf) { ftwbuf->type = bfs_mode_to_type(statbuf->mode); } else { ftwbuf->type = BFS_ERROR; ftwbuf->error = errno; return; } } if (ftwbuf->type == BFS_DIR && (state->flags & BFTW_DETECT_CYCLES)) { for (const struct bftw_file *ancestor = parent; ancestor; ancestor = ancestor->parent) { if (ancestor->dev == statbuf->dev && ancestor->ino == statbuf->ino) { ftwbuf->type = BFS_ERROR; ftwbuf->error = ELOOP; return; } } } } /** Check if the current file is a mount point. */ static bool bftw_is_mount(struct bftw_state *state, const char *name) { const struct bftw_file *file = state->file; if (!file) { return false; } const struct bftw_file *parent = name ? file : file->parent; if (!parent) { return false; } const struct BFTW *ftwbuf = &state->ftwbuf; const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); return statbuf && statbuf->dev != parent->dev; } /** Fill file identity information from an ftwbuf. */ static void bftw_fill_id(struct bftw_file *file, const struct BFTW *ftwbuf) { const struct bfs_stat *statbuf = ftwbuf->stat_cache.buf; if (!statbuf || (ftwbuf->stat_flags & BFS_STAT_NOFOLLOW)) { statbuf = ftwbuf->lstat_cache.buf; } if (statbuf) { file->dev = statbuf->dev; file->ino = statbuf->ino; } } /** * Visit a path, invoking the callback. */ static enum bftw_action bftw_visit(struct bftw_state *state, const char *name, enum bftw_visit visit) { if (bftw_update_path(state, name) != 0) { state->error = errno; return BFTW_STOP; } const struct BFTW *ftwbuf = &state->ftwbuf; bftw_init_ftwbuf(state, visit); // Never give the callback BFS_ERROR unless BFTW_RECOVER is specified if (ftwbuf->type == BFS_ERROR && !(state->flags & BFTW_RECOVER)) { state->error = ftwbuf->error; return BFTW_STOP; } if ((state->flags & BFTW_SKIP_MOUNTS) && bftw_is_mount(state, name)) { return BFTW_PRUNE; } enum bftw_action ret = state->callback(ftwbuf, state->ptr); switch (ret) { case BFTW_CONTINUE: break; case BFTW_PRUNE: case BFTW_STOP: goto done; default: state->error = EINVAL; return BFTW_STOP; } if (visit != BFTW_PRE || ftwbuf->type != BFS_DIR) { ret = BFTW_PRUNE; goto done; } if ((state->flags & BFTW_PRUNE_MOUNTS) && bftw_is_mount(state, name)) { ret = BFTW_PRUNE; goto done; } done: if (state->file && !name) { bftw_fill_id(state->file, ftwbuf); } return ret; } /** * Push a new file onto the queue. */ static int bftw_push(struct bftw_state *state, const char *name, bool fill_id) { struct bftw_file *parent = state->file; struct bftw_file *file = bftw_file_new(&state->cache, parent, name); if (!file) { state->error = errno; return -1; } if (state->de) { file->type = state->de->type; } if (fill_id) { bftw_fill_id(file, &state->ftwbuf); } bftw_queue_push(&state->queue, file); return 0; } /** * Build the path to the current file. */ static int bftw_build_path(struct bftw_state *state) { const struct bftw_file *file = state->file; size_t pathlen = file->nameoff + file->namelen; if (dstresize(&state->path, pathlen) != 0) { state->error = errno; return -1; } // Try to find a common ancestor with the existing path const struct bftw_file *ancestor = state->previous; while (ancestor && ancestor->depth > file->depth) { ancestor = ancestor->parent; } // Build the path backwards while (file && file != ancestor) { if (file->nameoff > 0) { state->path[file->nameoff - 1] = '/'; } memcpy(state->path + file->nameoff, file->name, file->namelen); if (ancestor && ancestor->depth == file->depth) { ancestor = ancestor->parent; } file = file->parent; } state->previous = state->file; return 0; } /** * Pop the next file from the queue. */ static int bftw_pop(struct bftw_state *state) { if (!state->queue.head) { return 0; } state->file = bftw_queue_pop(&state->queue); if (bftw_build_path(state) != 0) { return -1; } return 1; } /** * Open the current directory. */ static void bftw_opendir(struct bftw_state *state) { assert(!state->dir); assert(!state->de); state->direrror = 0; state->dir = bftw_file_opendir(&state->cache, state->file, state->path); if (!state->dir) { state->direrror = errno; } } /** * Read an entry from the current directory. */ static int bftw_readdir(struct bftw_state *state) { if (!state->dir) { return -1; } int ret = bfs_readdir(state->dir, &state->de_storage); if (ret > 0) { state->de = &state->de_storage; } else if (ret == 0) { state->de = NULL; } else { state->de = NULL; state->direrror = errno; } return ret; } /** * Flags controlling which files get visited when done with a directory. */ enum bftw_gc_flags { /** Don't visit anything. */ BFTW_VISIT_NONE = 0, /** Visit the file itself. */ BFTW_VISIT_FILE = 1 << 0, /** Visit the file's ancestors. */ BFTW_VISIT_PARENTS = 1 << 1, /** Visit both the file and its ancestors. */ BFTW_VISIT_ALL = BFTW_VISIT_FILE | BFTW_VISIT_PARENTS, }; /** * Close the current directory. */ static enum bftw_action bftw_closedir(struct bftw_state *state, enum bftw_gc_flags flags) { struct bftw_file *file = state->file; enum bftw_action ret = BFTW_CONTINUE; if (state->dir) { assert(file->fd >= 0); if (file->refcount > 1) { // Keep the fd around if any subdirectories exist file->fd = bfs_freedir(state->dir); } else { bfs_closedir(state->dir); file->fd = -1; } if (file->fd < 0) { bftw_cache_remove(&state->cache, file); } } state->de = NULL; state->dir = NULL; if (state->direrror != 0) { if (flags & BFTW_VISIT_FILE) { ret = bftw_visit(state, NULL, BFTW_PRE); } else { state->error = state->direrror; } state->direrror = 0; } return ret; } /** * Finalize and free a file we're done with. */ static enum bftw_action bftw_gc_file(struct bftw_state *state, enum bftw_gc_flags flags) { enum bftw_action ret = BFTW_CONTINUE; if (!(state->flags & BFTW_POST_ORDER)) { flags = 0; } bool visit = flags & BFTW_VISIT_FILE; while (state->file) { if (bftw_file_decref(&state->cache, state->file) > 0) { state->file = NULL; break; } if (visit && bftw_visit(state, NULL, BFTW_POST) == BFTW_STOP) { ret = BFTW_STOP; flags &= ~BFTW_VISIT_PARENTS; } visit = flags & BFTW_VISIT_PARENTS; struct bftw_file *parent = state->file->parent; if (state->previous == state->file) { state->previous = parent; } bftw_file_free(&state->cache, state->file); state->file = parent; } return ret; } /** * Drain all the entries from a bftw_queue. */ static void bftw_drain_queue(struct bftw_state *state, struct bftw_queue *queue) { while (queue->head) { state->file = bftw_queue_pop(queue); bftw_gc_file(state, BFTW_VISIT_NONE); } } /** * Dispose of the bftw() state. * * @return * The bftw() return value. */ static int bftw_state_destroy(struct bftw_state *state) { dstrfree(state->path); bftw_closedir(state, BFTW_VISIT_NONE); bftw_gc_file(state, BFTW_VISIT_NONE); bftw_drain_queue(state, &state->queue); bftw_cache_destroy(&state->cache); errno = state->error; return state->error ? -1 : 0; } /** Start a batch of files. */ static void bftw_batch_start(struct bftw_state *state) { if (state->strategy == BFTW_DFS) { state->queue.target = &state->queue.head; } state->batch = state->queue.target; } /** Finish adding a batch of files. */ static void bftw_batch_finish(struct bftw_state *state) { if (state->flags & BFTW_SORT) { state->queue.target = bftw_sort_files(state->batch, state->queue.target); } } /** * Streaming mode: visit files as they are encountered. */ static int bftw_stream(const struct bftw_args *args) { struct bftw_state state; if (bftw_state_init(&state, args) != 0) { return -1; } assert(!(state.flags & BFTW_SORT)); bftw_batch_start(&state); for (size_t i = 0; i < args->npaths; ++i) { const char *path = args->paths[i]; switch (bftw_visit(&state, path, BFTW_PRE)) { case BFTW_CONTINUE: break; case BFTW_PRUNE: continue; case BFTW_STOP: goto done; } if (bftw_push(&state, path, true) != 0) { goto done; } } bftw_batch_finish(&state); while (bftw_pop(&state) > 0) { bftw_opendir(&state); bftw_batch_start(&state); while (bftw_readdir(&state) > 0) { const char *name = state.de->name; switch (bftw_visit(&state, name, BFTW_PRE)) { case BFTW_CONTINUE: break; case BFTW_PRUNE: continue; case BFTW_STOP: goto done; } if (bftw_push(&state, name, true) != 0) { goto done; } } bftw_batch_finish(&state); if (bftw_closedir(&state, BFTW_VISIT_ALL) == BFTW_STOP) { goto done; } if (bftw_gc_file(&state, BFTW_VISIT_ALL) == BFTW_STOP) { goto done; } } done: return bftw_state_destroy(&state); } /** * Batching mode: queue up all children before visiting them. */ static int bftw_batch(const struct bftw_args *args) { struct bftw_state state; if (bftw_state_init(&state, args) != 0) { return -1; } bftw_batch_start(&state); for (size_t i = 0; i < args->npaths; ++i) { if (bftw_push(&state, args->paths[i], false) != 0) { goto done; } } bftw_batch_finish(&state); while (bftw_pop(&state) > 0) { enum bftw_gc_flags gcflags = BFTW_VISIT_ALL; switch (bftw_visit(&state, NULL, BFTW_PRE)) { case BFTW_CONTINUE: break; case BFTW_PRUNE: gcflags &= ~BFTW_VISIT_FILE; goto next; case BFTW_STOP: goto done; } bftw_opendir(&state); bftw_batch_start(&state); while (bftw_readdir(&state) > 0) { if (bftw_push(&state, state.de->name, false) != 0) { goto done; } } bftw_batch_finish(&state); if (bftw_closedir(&state, gcflags) == BFTW_STOP) { goto done; } next: if (bftw_gc_file(&state, gcflags) == BFTW_STOP) { goto done; } } done: return bftw_state_destroy(&state); } /** Select bftw_stream() or bftw_batch() appropriately. */ static int bftw_auto(const struct bftw_args *args) { if (args->flags & BFTW_SORT) { return bftw_batch(args); } else { return bftw_stream(args); } } /** * Iterative deepening search state. */ struct bftw_ids_state { /** The wrapped callback. */ bftw_callback *delegate; /** The wrapped callback arguments. */ void *ptr; /** Which visit this search corresponds to. */ enum bftw_visit visit; /** Whether to override the bftw_visit. */ bool force_visit; /** The current minimum depth (inclusive). */ size_t min_depth; /** The current maximum depth (exclusive). */ size_t max_depth; /** The set of pruned paths. */ struct trie pruned; /** An error code to report. */ int error; /** Whether the bottom has been found. */ bool bottom; /** Whether to quit the search. */ bool quit; }; /** Iterative deepening callback function. */ static enum bftw_action bftw_ids_callback(const struct BFTW *ftwbuf, void *ptr) { struct bftw_ids_state *state = ptr; if (state->force_visit) { struct BFTW *mutbuf = (struct BFTW *)ftwbuf; mutbuf->visit = state->visit; } if (ftwbuf->type == BFS_ERROR) { if (ftwbuf->depth + 1 >= state->min_depth) { return state->delegate(ftwbuf, state->ptr); } else { return BFTW_PRUNE; } } if (ftwbuf->depth < state->min_depth) { if (trie_find_str(&state->pruned, ftwbuf->path)) { return BFTW_PRUNE; } else { return BFTW_CONTINUE; } } else if (state->visit == BFTW_POST) { if (trie_find_str(&state->pruned, ftwbuf->path)) { return BFTW_PRUNE; } } enum bftw_action ret = BFTW_CONTINUE; if (ftwbuf->visit == state->visit) { ret = state->delegate(ftwbuf, state->ptr); } switch (ret) { case BFTW_CONTINUE: if (ftwbuf->type == BFS_DIR && ftwbuf->depth + 1 >= state->max_depth) { state->bottom = false; ret = BFTW_PRUNE; } break; case BFTW_PRUNE: if (ftwbuf->type == BFS_DIR) { if (!trie_insert_str(&state->pruned, ftwbuf->path)) { state->error = errno; state->quit = true; ret = BFTW_STOP; } } break; case BFTW_STOP: state->quit = true; break; } return ret; } /** Initialize iterative deepening state. */ static void bftw_ids_init(const struct bftw_args *args, struct bftw_ids_state *state, struct bftw_args *ids_args) { state->delegate = args->callback; state->ptr = args->ptr; state->visit = BFTW_PRE; state->force_visit = false; state->min_depth = 0; state->max_depth = 1; trie_init(&state->pruned); state->error = 0; state->bottom = false; state->quit = false; *ids_args = *args; ids_args->callback = bftw_ids_callback; ids_args->ptr = state; ids_args->flags &= ~BFTW_POST_ORDER; ids_args->strategy = BFTW_DFS; } /** Finish an iterative deepening search. */ static int bftw_ids_finish(struct bftw_ids_state *state) { int ret = 0; if (state->error) { ret = -1; } else { state->error = errno; } trie_destroy(&state->pruned); errno = state->error; return ret; } /** * Iterative deepening bftw() wrapper. */ static int bftw_ids(const struct bftw_args *args) { struct bftw_ids_state state; struct bftw_args ids_args; bftw_ids_init(args, &state, &ids_args); while (!state.quit && !state.bottom) { state.bottom = true; if (bftw_auto(&ids_args) != 0) { state.error = errno; state.quit = true; } ++state.min_depth; ++state.max_depth; } if (args->flags & BFTW_POST_ORDER) { state.visit = BFTW_POST; state.force_visit = true; while (!state.quit && state.min_depth > 0) { --state.max_depth; --state.min_depth; if (bftw_auto(&ids_args) != 0) { state.error = errno; state.quit = true; } } } return bftw_ids_finish(&state); } /** * Exponential deepening bftw() wrapper. */ static int bftw_eds(const struct bftw_args *args) { struct bftw_ids_state state; struct bftw_args ids_args; bftw_ids_init(args, &state, &ids_args); while (!state.quit && !state.bottom) { state.bottom = true; if (bftw_auto(&ids_args) != 0) { state.error = errno; state.quit = true; } state.min_depth = state.max_depth; state.max_depth *= 2; } if (!state.quit && (args->flags & BFTW_POST_ORDER)) { state.visit = BFTW_POST; state.min_depth = 0; ids_args.flags |= BFTW_POST_ORDER; if (bftw_auto(&ids_args) != 0) { state.error = errno; } } return bftw_ids_finish(&state); } int bftw(const struct bftw_args *args) { switch (args->strategy) { case BFTW_BFS: return bftw_auto(args); case BFTW_DFS: return bftw_batch(args); case BFTW_IDS: return bftw_ids(args); case BFTW_EDS: return bftw_eds(args); } errno = EINVAL; return -1; } bfs-2.3.1/bftw.h000066400000000000000000000145271417254370000134160ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2015-2021 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * A file-walking API based on nftw(). */ #ifndef BFS_BFTW_H #define BFS_BFTW_H #include "dir.h" #include "stat.h" #include /** * Possible visit occurrences. */ enum bftw_visit { /** Pre-order visit. */ BFTW_PRE, /** Post-order visit. */ BFTW_POST, }; /** * Cached bfs_stat() info for a file. */ struct bftw_stat { /** A pointer to the bfs_stat() buffer, if available. */ const struct bfs_stat *buf; /** Storage for the bfs_stat() buffer, if needed. */ struct bfs_stat storage; /** The cached error code, if any. */ int error; }; /** * Data about the current file for the bftw() callback. */ struct BFTW { /** The path to the file. */ const char *path; /** The string offset of the filename. */ size_t nameoff; /** The root path passed to bftw(). */ const char *root; /** The depth of this file in the traversal. */ size_t depth; /** Which visit this is. */ enum bftw_visit visit; /** The file type. */ enum bfs_type type; /** The errno that occurred, if type == BFTW_ERROR. */ int error; /** A parent file descriptor for the *at() family of calls. */ int at_fd; /** The path relative to at_fd for the *at() family of calls. */ const char *at_path; /** Flags for bfs_stat(). */ enum bfs_stat_flags stat_flags; /** Cached bfs_stat() info for BFS_STAT_NOFOLLOW. */ struct bftw_stat lstat_cache; /** Cached bfs_stat() info for BFS_STAT_FOLLOW. */ struct bftw_stat stat_cache; }; /** * Get bfs_stat() info for a file encountered during bftw(), caching the result * whenever possible. * * @param ftwbuf * bftw() data for the file to stat. * @param flags * flags for bfs_stat(). Pass ftwbuf->stat_flags for the default flags. * @return * A pointer to a bfs_stat() buffer, or NULL if the call failed. */ const struct bfs_stat *bftw_stat(const struct BFTW *ftwbuf, enum bfs_stat_flags flags); /** * Get bfs_stat() info for a file encountered during bftw(), if it has already * been cached. * * @param ftwbuf * bftw() data for the file to stat. * @param flags * flags for bfs_stat(). Pass ftwbuf->stat_flags for the default flags. * @return * A pointer to a bfs_stat() buffer, or NULL if no stat info is cached. */ const struct bfs_stat *bftw_cached_stat(const struct BFTW *ftwbuf, enum bfs_stat_flags flags); /** * Get the type of a file encountered during bftw(), with flags controlling * whether to follow links. This function will avoid calling bfs_stat() if * possible. * * @param ftwbuf * bftw() data for the file to check. * @param flags * flags for bfs_stat(). Pass ftwbuf->stat_flags for the default flags. * @return * The type of the file, or BFTW_ERROR if an error occurred. */ enum bfs_type bftw_type(const struct BFTW *ftwbuf, enum bfs_stat_flags flags); /** * Walk actions returned by the bftw() callback. */ enum bftw_action { /** Keep walking. */ BFTW_CONTINUE, /** Skip this path's children. */ BFTW_PRUNE, /** Stop walking. */ BFTW_STOP, }; /** * Callback function type for bftw(). * * @param ftwbuf * Data about the current file. * @param ptr * The pointer passed to bftw(). * @return * An action value. */ typedef enum bftw_action bftw_callback(const struct BFTW *ftwbuf, void *ptr); /** * Flags that control bftw() behavior. */ enum bftw_flags { /** stat() each encountered file. */ BFTW_STAT = 1 << 0, /** Attempt to recover from encountered errors. */ BFTW_RECOVER = 1 << 1, /** Visit directories in post-order as well as pre-order. */ BFTW_POST_ORDER = 1 << 2, /** If the initial path is a symbolic link, follow it. */ BFTW_FOLLOW_ROOTS = 1 << 3, /** Follow all symbolic links. */ BFTW_FOLLOW_ALL = 1 << 4, /** Detect directory cycles. */ BFTW_DETECT_CYCLES = 1 << 5, /** Skip mount points and their descendents. */ BFTW_SKIP_MOUNTS = 1 << 6, /** Skip the descendents of mount points. */ BFTW_PRUNE_MOUNTS = 1 << 7, /** Sort directory entries before processing them. */ BFTW_SORT = 1 << 8, }; /** * Tree search strategies for bftw(). */ enum bftw_strategy { /** Breadth-first search. */ BFTW_BFS, /** Depth-first search. */ BFTW_DFS, /** Iterative deepening search. */ BFTW_IDS, /** Exponential deepening search. */ BFTW_EDS, }; /** * Structure for holding the arguments passed to bftw(). */ struct bftw_args { /** The path(s) to start from. */ const char **paths; /** The number of starting paths. */ size_t npaths; /** The callback to invoke. */ bftw_callback *callback; /** A pointer which is passed to the callback. */ void *ptr; /** The maximum number of file descriptors to keep open. */ int nopenfd; /** Flags that control bftw() behaviour. */ enum bftw_flags flags; /** The search strategy to use. */ enum bftw_strategy strategy; /** The parsed mount table, if available. */ const struct bfs_mtab *mtab; }; /** * Breadth First Tree Walk (or Better File Tree Walk). * * Like ftw(3) and nftw(3), this function walks a directory tree recursively, * and invokes a callback for each path it encounters. * * @param args * The arguments that control the walk. * @return * 0 on success, or -1 on failure. */ int bftw(const struct bftw_args *args); #endif // BFS_BFTW_H bfs-2.3.1/color.c000066400000000000000000000570221417254370000135620ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2015-2021 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "color.h" #include "bftw.h" #include "dir.h" #include "dstring.h" #include "expr.h" #include "fsade.h" #include "stat.h" #include "trie.h" #include "util.h" #include #include #include #include #include #include #include #include #include #include /** * The parsed form of LS_COLORS. */ struct colors { char *reset; char *leftcode; char *rightcode; char *endcode; char *clear_to_eol; char *bold; char *gray; char *red; char *green; char *yellow; char *blue; char *magenta; char *cyan; char *white; char *warning; char *error; char *normal; char *file; char *multi_hard; char *executable; char *capable; char *setgid; char *setuid; char *directory; char *sticky; char *other_writable; char *sticky_other_writable; char *link; char *orphan; char *missing; bool link_as_target; char *blockdev; char *chardev; char *door; char *pipe; char *socket; /** A mapping from color names (fi, di, ln, etc.) to struct fields. */ struct trie names; /** A mapping from file extensions to colors. */ struct trie ext_colors; }; /** Initialize a color in the table. */ static int init_color(struct colors *colors, const char *name, const char *value, char **field) { if (value) { *field = dstrdup(value); if (!*field) { return -1; } } else { *field = NULL; } struct trie_leaf *leaf = trie_insert_str(&colors->names, name); if (leaf) { leaf->value = field; return 0; } else { return -1; } } /** Get a color from the table. */ static char **get_color(const struct colors *colors, const char *name) { const struct trie_leaf *leaf = trie_find_str(&colors->names, name); if (leaf) { return (char **)leaf->value; } else { return NULL; } } /** Set the value of a color. */ static int set_color(struct colors *colors, const char *name, char *value) { char **color = get_color(colors, name); if (color) { dstrfree(*color); *color = value; return 0; } else { return -1; } } /** * Transform a file extension for fast lookups, by reversing and lowercasing it. */ static void extxfrm(char *ext) { size_t len = strlen(ext); for (size_t i = 0; i < len - i; ++i) { char a = ext[i]; char b = ext[len - i - 1]; // What's internationalization? Doesn't matter, this is what // GNU ls does. Luckily, since there's no standard C way to // casefold. Not using tolower() here since it respects the // current locale, which GNU ls doesn't do. if (a >= 'A' && a <= 'Z') { a += 'a' - 'A'; } if (b >= 'A' && b <= 'Z') { b += 'a' - 'A'; } ext[i] = b; ext[len - i - 1] = a; } } /** * Set the color for an extension. */ static int set_ext_color(struct colors *colors, char *key, const char *value) { extxfrm(key); // A later *.x should override any earlier *.x, *.y.x, etc. struct trie_leaf *match; while ((match = trie_find_postfix(&colors->ext_colors, key))) { dstrfree(match->value); trie_remove(&colors->ext_colors, match); } struct trie_leaf *leaf = trie_insert_str(&colors->ext_colors, key); if (leaf) { leaf->value = (char *)value; return 0; } else { return -1; } } /** * Find a color by an extension. */ static const char *get_ext_color(const struct colors *colors, const char *filename) { char *xfrm = strdup(filename); if (!xfrm) { return NULL; } extxfrm(xfrm); const struct trie_leaf *leaf = trie_find_prefix(&colors->ext_colors, xfrm); free(xfrm); if (leaf) { return leaf->value; } else { return NULL; } } /** * Parse a chunk of LS_COLORS that may have escape sequences. The supported * escapes are: * * \a, \b, \f, \n, \r, \t, \v: * As in C * \e: * ESC (\033) * \?: * DEL (\177) * \_: * ' ' (space) * \NNN: * Octal * \xNN: * Hex * ^C: * Control character. * * See man dir_colors. * * @param value * The value to parse. * @param end * The character that marks the end of the chunk. * @param[out] next * Will be set to the next chunk. * @return * The parsed chunk as a dstring. */ static char *unescape(const char *value, char end, const char **next) { if (!value) { goto fail; } char *str = dstralloc(0); if (!str) { goto fail_str; } const char *i; for (i = value; *i && *i != end; ++i) { unsigned char c = 0; switch (*i) { case '\\': switch (*++i) { case 'a': c = '\a'; break; case 'b': c = '\b'; break; case 'e': c = '\033'; break; case 'f': c = '\f'; break; case 'n': c = '\n'; break; case 'r': c = '\r'; break; case 't': c = '\t'; break; case 'v': c = '\v'; break; case '?': c = '\177'; break; case '_': c = ' '; break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': while (i[1] >= '0' && i[1] <= '7') { c <<= 3; c |= *i++ - '0'; } c <<= 3; c |= *i - '0'; break; case 'X': case 'x': while (true) { if (i[1] >= '0' && i[1] <= '9') { c <<= 4; c |= i[1] - '0'; } else if (i[1] >= 'A' && i[1] <= 'F') { c <<= 4; c |= i[1] - 'A' + 0xA; } else if (i[1] >= 'a' && i[1] <= 'f') { c <<= 4; c |= i[1] - 'a' + 0xA; } else { break; } ++i; } break; case '\0': goto fail_str; default: c = *i; break; } break; case '^': switch (*++i) { case '?': c = '\177'; break; case '\0': goto fail_str; default: // CTRL masks bits 6 and 7 c = *i & 0x1F; break; } break; default: c = *i; break; } if (dstrapp(&str, c) != 0) { goto fail_str; } } if (*i) { *next = i + 1; } else { *next = NULL; } return str; fail_str: dstrfree(str); fail: *next = NULL; return NULL; } struct colors *parse_colors(const char *ls_colors) { struct colors *colors = malloc(sizeof(struct colors)); if (!colors) { return NULL; } trie_init(&colors->names); trie_init(&colors->ext_colors); int ret = 0; // From man console_codes ret |= init_color(colors, "rs", "0", &colors->reset); ret |= init_color(colors, "lc", "\033[", &colors->leftcode); ret |= init_color(colors, "rc", "m", &colors->rightcode); ret |= init_color(colors, "ec", NULL, &colors->endcode); ret |= init_color(colors, "cl", "\033[K", &colors->clear_to_eol); ret |= init_color(colors, "bld", "01;39", &colors->bold); ret |= init_color(colors, "gry", "01;30", &colors->gray); ret |= init_color(colors, "red", "01;31", &colors->red); ret |= init_color(colors, "grn", "01;32", &colors->green); ret |= init_color(colors, "ylw", "01;33", &colors->yellow); ret |= init_color(colors, "blu", "01;34", &colors->blue); ret |= init_color(colors, "mag", "01;35", &colors->magenta); ret |= init_color(colors, "cyn", "01;36", &colors->cyan); ret |= init_color(colors, "wht", "01;37", &colors->white); ret |= init_color(colors, "wr", "01;33", &colors->warning); ret |= init_color(colors, "er", "01;31", &colors->error); // Defaults from man dir_colors ret |= init_color(colors, "no", NULL, &colors->normal); ret |= init_color(colors, "fi", NULL, &colors->file); ret |= init_color(colors, "mh", NULL, &colors->multi_hard); ret |= init_color(colors, "ex", "01;32", &colors->executable); ret |= init_color(colors, "ca", "30;41", &colors->capable); ret |= init_color(colors, "sg", "30;43", &colors->setgid); ret |= init_color(colors, "su", "37;41", &colors->setuid); ret |= init_color(colors, "di", "01;34", &colors->directory); ret |= init_color(colors, "st", "37;44", &colors->sticky); ret |= init_color(colors, "ow", "34;42", &colors->other_writable); ret |= init_color(colors, "tw", "30;42", &colors->sticky_other_writable); ret |= init_color(colors, "ln", "01;36", &colors->link); ret |= init_color(colors, "or", NULL, &colors->orphan); ret |= init_color(colors, "mi", NULL, &colors->missing); colors->link_as_target = false; ret |= init_color(colors, "bd", "01;33", &colors->blockdev); ret |= init_color(colors, "cd", "01;33", &colors->chardev); ret |= init_color(colors, "do", "01;35", &colors->door); ret |= init_color(colors, "pi", "33", &colors->pipe); ret |= init_color(colors, "so", "01;35", &colors->socket); if (ret) { free_colors(colors); return NULL; } for (const char *chunk = ls_colors, *next; chunk; chunk = next) { if (chunk[0] == '*') { char *key = unescape(chunk + 1, '=', &next); if (!key) { continue; } char *value = unescape(next, ':', &next); if (value) { if (set_ext_color(colors, key, value) != 0) { dstrfree(value); } } dstrfree(key); } else { const char *equals = strchr(chunk, '='); if (!equals) { break; } char *value = unescape(equals + 1, ':', &next); if (!value) { continue; } char *key = strndup(chunk, equals - chunk); if (!key) { dstrfree(value); continue; } // All-zero values should be treated like NULL, to fall // back on any other relevant coloring for that file if (strspn(value, "0") == strlen(value) && strcmp(key, "rs") != 0 && strcmp(key, "lc") != 0 && strcmp(key, "rc") != 0 && strcmp(key, "ec") != 0) { dstrfree(value); value = NULL; } if (set_color(colors, key, value) != 0) { dstrfree(value); } free(key); } } if (colors->link && strcmp(colors->link, "target") == 0) { colors->link_as_target = true; dstrfree(colors->link); colors->link = NULL; } return colors; } void free_colors(struct colors *colors) { if (colors) { struct trie_leaf *leaf; while ((leaf = trie_first_leaf(&colors->ext_colors))) { dstrfree(leaf->value); trie_remove(&colors->ext_colors, leaf); } trie_destroy(&colors->ext_colors); while ((leaf = trie_first_leaf(&colors->names))) { char **field = leaf->value; dstrfree(*field); trie_remove(&colors->names, leaf); } trie_destroy(&colors->names); free(colors); } } CFILE *cfwrap(FILE *file, const struct colors *colors, bool close) { CFILE *cfile = malloc(sizeof(*cfile)); if (!cfile) { return NULL; } cfile->buffer = dstralloc(128); if (!cfile->buffer) { free(cfile); return NULL; } cfile->file = file; cfile->close = close; if (isatty(fileno(file))) { cfile->colors = colors; } else { cfile->colors = NULL; } return cfile; } int cfclose(CFILE *cfile) { int ret = 0; if (cfile) { dstrfree(cfile->buffer); if (cfile->close) { ret = fclose(cfile->file); } free(cfile); } return ret; } /** Check if a symlink is broken. */ static bool is_link_broken(const struct BFTW *ftwbuf) { if (ftwbuf->stat_flags & BFS_STAT_NOFOLLOW) { return xfaccessat(ftwbuf->at_fd, ftwbuf->at_path, F_OK) != 0; } else { return true; } } /** Get the color for a file. */ static const char *file_color(const struct colors *colors, const char *filename, const struct BFTW *ftwbuf, enum bfs_stat_flags flags) { enum bfs_type type = bftw_type(ftwbuf, flags); if (type == BFS_ERROR) { goto error; } const struct bfs_stat *statbuf = NULL; const char *color = NULL; switch (type) { case BFS_REG: if (colors->setuid || colors->setgid || colors->executable || colors->multi_hard) { statbuf = bftw_stat(ftwbuf, flags); if (!statbuf) { goto error; } } if (colors->setuid && (statbuf->mode & 04000)) { color = colors->setuid; } else if (colors->setgid && (statbuf->mode & 02000)) { color = colors->setgid; } else if (colors->capable && bfs_check_capabilities(ftwbuf) > 0) { color = colors->capable; } else if (colors->executable && (statbuf->mode & 00111)) { color = colors->executable; } else if (colors->multi_hard && statbuf->nlink > 1) { color = colors->multi_hard; } if (!color) { color = get_ext_color(colors, filename); } if (!color) { color = colors->file; } break; case BFS_DIR: if (colors->sticky_other_writable || colors->other_writable || colors->sticky) { statbuf = bftw_stat(ftwbuf, flags); if (!statbuf) { goto error; } } if (colors->sticky_other_writable && (statbuf->mode & 01002) == 01002) { color = colors->sticky_other_writable; } else if (colors->other_writable && (statbuf->mode & 00002)) { color = colors->other_writable; } else if (colors->sticky && (statbuf->mode & 01000)) { color = colors->sticky; } else { color = colors->directory; } break; case BFS_LNK: if (colors->orphan && is_link_broken(ftwbuf)) { color = colors->orphan; } else { color = colors->link; } break; case BFS_BLK: color = colors->blockdev; break; case BFS_CHR: color = colors->chardev; break; case BFS_FIFO: color = colors->pipe; break; case BFS_SOCK: color = colors->socket; break; case BFS_DOOR: color = colors->door; break; default: break; } if (!color) { color = colors->normal; } return color; error: if (colors->missing) { return colors->missing; } else { return colors->orphan; } } /** Print an ANSI escape sequence. */ static int print_esc(CFILE *cfile, const char *esc) { const struct colors *colors = cfile->colors; if (dstrdcat(&cfile->buffer, colors->leftcode) != 0) { return -1; } if (dstrdcat(&cfile->buffer, esc) != 0) { return -1; } if (dstrdcat(&cfile->buffer, colors->rightcode) != 0) { return -1; } return 0; } /** Reset after an ANSI escape sequence. */ static int print_reset(CFILE *cfile) { const struct colors *colors = cfile->colors; if (colors->endcode) { return dstrdcat(&cfile->buffer, colors->endcode); } else { return print_esc(cfile, colors->reset); } } /** Print a string with an optional color. */ static int print_colored(CFILE *cfile, const char *esc, const char *str, size_t len) { if (esc) { if (print_esc(cfile, esc) != 0) { return -1; } } if (dstrncat(&cfile->buffer, str, len) != 0) { return -1; } if (esc) { if (print_reset(cfile) != 0) { return -1; } } return 0; } /** Find the offset of the first broken path component. */ static ssize_t first_broken_offset(const char *path, const struct BFTW *ftwbuf, enum bfs_stat_flags flags, size_t max) { ssize_t ret = max; assert(ret >= 0); if (bftw_type(ftwbuf, flags) != BFS_ERROR) { goto out; } char *at_path; int at_fd; if (path == ftwbuf->path) { if (ftwbuf->depth == 0) { at_fd = AT_FDCWD; at_path = dstrndup(path, max); } else { // The parent must have existed to get here goto out; } } else { // We're in print_link_target(), so resolve relative to the link's parent directory at_fd = ftwbuf->at_fd; if (at_fd == AT_FDCWD && path[0] != '/') { at_path = dstrndup(ftwbuf->path, ftwbuf->nameoff); if (at_path && dstrncat(&at_path, path, max) != 0) { ret = -1; goto out_path; } } else { at_path = dstrndup(path, max); } } if (!at_path) { ret = -1; goto out; } while (ret > 0) { if (xfaccessat(at_fd, at_path, F_OK) == 0) { break; } size_t len = dstrlen(at_path); while (ret && at_path[len - 1] == '/') { --len, --ret; } while (ret && at_path[len - 1] != '/') { --len, --ret; } dstresize(&at_path, len); } out_path: dstrfree(at_path); out: return ret; } /** Print the directories leading up to a file. */ static int print_dirs_colored(CFILE *cfile, const char *path, const struct BFTW *ftwbuf, enum bfs_stat_flags flags, size_t nameoff) { const struct colors *colors = cfile->colors; ssize_t broken = first_broken_offset(path, ftwbuf, flags, nameoff); if (broken < 0) { return -1; } if (broken > 0) { if (print_colored(cfile, colors->directory, path, broken) != 0) { return -1; } } if ((size_t)broken < nameoff) { const char *color = colors->missing; if (!color) { color = colors->orphan; } if (print_colored(cfile, color, path + broken, nameoff - broken) != 0) { return -1; } } return 0; } /** Print a file name with colors. */ static int print_name_colored(CFILE *cfile, const char *name, const struct BFTW *ftwbuf, enum bfs_stat_flags flags) { const char *color = file_color(cfile->colors, name, ftwbuf, flags); return print_colored(cfile, color, name, strlen(name)); } /** Print a path with colors. */ static int print_path_colored(CFILE *cfile, const char *path, const struct BFTW *ftwbuf, enum bfs_stat_flags flags) { size_t nameoff; if (path == ftwbuf->path) { nameoff = ftwbuf->nameoff; } else { nameoff = xbasename(path) - path; } if (print_dirs_colored(cfile, path, ftwbuf, flags, nameoff) != 0) { return -1; } return print_name_colored(cfile, path + nameoff, ftwbuf, flags); } /** Print the name of a file with the appropriate colors. */ static int print_name(CFILE *cfile, const struct BFTW *ftwbuf) { const char *name = ftwbuf->path + ftwbuf->nameoff; const struct colors *colors = cfile->colors; if (!colors) { return dstrcat(&cfile->buffer, name); } enum bfs_stat_flags flags = ftwbuf->stat_flags; if (colors->link_as_target && ftwbuf->type == BFS_LNK) { flags = BFS_STAT_TRYFOLLOW; } return print_name_colored(cfile, name, ftwbuf, flags); } /** Print the path to a file with the appropriate colors. */ static int print_path(CFILE *cfile, const struct BFTW *ftwbuf) { const struct colors *colors = cfile->colors; if (!colors) { return dstrcat(&cfile->buffer, ftwbuf->path); } enum bfs_stat_flags flags = ftwbuf->stat_flags; if (colors->link_as_target && ftwbuf->type == BFS_LNK) { flags = BFS_STAT_TRYFOLLOW; } return print_path_colored(cfile, ftwbuf->path, ftwbuf, flags); } /** Print a link target with the appropriate colors. */ static int print_link_target(CFILE *cfile, const struct BFTW *ftwbuf) { const struct bfs_stat *statbuf = bftw_cached_stat(ftwbuf, BFS_STAT_NOFOLLOW); size_t len = statbuf ? statbuf->size : 0; char *target = xreadlinkat(ftwbuf->at_fd, ftwbuf->at_path, len); if (!target) { return -1; } int ret; if (cfile->colors) { ret = print_path_colored(cfile, target, ftwbuf, BFS_STAT_FOLLOW); } else { ret = dstrcat(&cfile->buffer, target); } free(target); return ret; } /** Format some colored output to the buffer. */ BFS_FORMATTER(2, 3) static int cbuff(CFILE *cfile, const char *format, ...); /** Dump a parsed expression tree, for debugging. */ static int print_expr(CFILE *cfile, const struct expr *expr, bool verbose) { if (dstrcat(&cfile->buffer, "(") != 0) { return -1; } if (expr->lhs || expr->rhs) { if (cbuff(cfile, "${red}%s${rs}", expr->argv[0]) < 0) { return -1; } } else { if (cbuff(cfile, "${blu}%s${rs}", expr->argv[0]) < 0) { return -1; } } for (size_t i = 1; i < expr->argc; ++i) { if (cbuff(cfile, " ${bld}%s${rs}", expr->argv[i]) < 0) { return -1; } } if (verbose) { double rate = 0.0, time = 0.0; if (expr->evaluations) { rate = 100.0*expr->successes/expr->evaluations; time = (1.0e9*expr->elapsed.tv_sec + expr->elapsed.tv_nsec)/expr->evaluations; } if (cbuff(cfile, " [${ylw}%zu${rs}/${ylw}%zu${rs}=${ylw}%g%%${rs}; ${ylw}%gns${rs}]", expr->successes, expr->evaluations, rate, time)) { return -1; } } if (expr->lhs) { if (dstrcat(&cfile->buffer, " ") != 0) { return -1; } if (print_expr(cfile, expr->lhs, verbose) != 0) { return -1; } } if (expr->rhs) { if (dstrcat(&cfile->buffer, " ") != 0) { return -1; } if (print_expr(cfile, expr->rhs, verbose) != 0) { return -1; } } if (dstrcat(&cfile->buffer, ")") != 0) { return -1; } return 0; } static int cvbuff(CFILE *cfile, const char *format, va_list args) { const struct colors *colors = cfile->colors; int error = errno; for (const char *i = format; *i; ++i) { size_t verbatim = strcspn(i, "%$"); if (dstrncat(&cfile->buffer, i, verbatim) != 0) { return -1; } i += verbatim; switch (*i) { case '%': switch (*++i) { case '%': if (dstrapp(&cfile->buffer, '%') != 0) { return -1; } break; case 'c': if (dstrapp(&cfile->buffer, va_arg(args, int)) != 0) { return -1; } break; case 'd': if (dstrcatf(&cfile->buffer, "%d", va_arg(args, int)) != 0) { return -1; } break; case 'g': if (dstrcatf(&cfile->buffer, "%g", va_arg(args, double)) != 0) { return -1; } break; case 's': if (dstrcat(&cfile->buffer, va_arg(args, const char *)) != 0) { return -1; } break; case 'z': ++i; if (*i != 'u') { goto invalid; } if (dstrcatf(&cfile->buffer, "%zu", va_arg(args, size_t)) != 0) { return -1; } break; case 'm': if (dstrcat(&cfile->buffer, strerror(error)) != 0) { return -1; } break; case 'p': switch (*++i) { case 'F': if (print_name(cfile, va_arg(args, const struct BFTW *)) != 0) { return -1; } break; case 'P': if (print_path(cfile, va_arg(args, const struct BFTW *)) != 0) { return -1; } break; case 'L': if (print_link_target(cfile, va_arg(args, const struct BFTW *)) != 0) { return -1; } break; case 'e': if (print_expr(cfile, va_arg(args, const struct expr *), false) != 0) { return -1; } break; case 'E': if (print_expr(cfile, va_arg(args, const struct expr *), true) != 0) { return -1; } break; default: goto invalid; } break; default: goto invalid; } break; case '$': switch (*++i) { case '$': if (dstrapp(&cfile->buffer, '$') != 0) { return -1; } break; case '{': { ++i; const char *end = strchr(i, '}'); if (!end) { goto invalid; } if (!colors) { i = end; break; } size_t len = end - i; char name[len + 1]; memcpy(name, i, len); name[len] = '\0'; char **esc = get_color(colors, name); if (!esc) { goto invalid; } if (*esc) { if (print_esc(cfile, *esc) != 0) { return -1; } } i = end; break; } default: goto invalid; } break; default: return 0; } } return 0; invalid: assert(!"Invalid format string"); errno = EINVAL; return -1; } static int cbuff(CFILE *cfile, const char *format, ...) { va_list args; va_start(args, format); int ret = cvbuff(cfile, format, args); va_end(args); return ret; } int cvfprintf(CFILE *cfile, const char *format, va_list args) { assert(dstrlen(cfile->buffer) == 0); int ret = -1; if (cvbuff(cfile, format, args) == 0) { size_t len = dstrlen(cfile->buffer); if (fwrite(cfile->buffer, 1, len, cfile->file) == len) { ret = 0; } } dstresize(&cfile->buffer, 0); return ret; } int cfprintf(CFILE *cfile, const char *format, ...) { va_list args; va_start(args, format); int ret = cvfprintf(cfile, format, args); va_end(args); return ret; } bfs-2.3.1/color.h000066400000000000000000000071751417254370000135730ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2015-2021 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * Utilities for colored output on ANSI terminals. */ #ifndef BFS_COLOR_H #define BFS_COLOR_H #include "util.h" #include #include #include /** * A lookup table for colors. */ struct colors; /** * Parse a color table. * * @param ls_colors * A color table in the LS_COLORS environment variable format. * @return The parsed color table. */ struct colors *parse_colors(const char *ls_colors); /** * Free a color table. * * @param colors * The color table to free. */ void free_colors(struct colors *colors); /** * A file/stream with associated colors. */ typedef struct CFILE { /** The underlying file/stream. */ FILE *file; /** The color table to use, if any. */ const struct colors *colors; /** A buffer for colored formatting. */ char *buffer; /** Whether to close the underlying stream. */ bool close; } CFILE; /** * Wrap an existing file into a colored stream. * * @param file * The underlying file. * @param colors * The color table to use if file is a TTY. * @param close * Whether to close the underlying stream when this stream is closed. * @return * A colored wrapper around file. */ CFILE *cfwrap(FILE *file, const struct colors *colors, bool close); /** * Close a colored file. * * @param cfile * The colored file to close. * @return * 0 on success, -1 on failure. */ int cfclose(CFILE *cfile); /** * Colored, formatted output. * * @param cfile * The colored stream to print to. * @param format * A printf()-style format string, supporting these format specifiers: * * %c: A single character * %d: An integer * %g: A double * %s: A string * %zu: A size_t * %m: strerror(errno) * %pF: A colored file name, from a const struct BFTW * argument * %pP: A colored file path, from a const struct BFTW * argument * %pL: A colored link target, from a const struct BFTW * argument * %pe: Dump a const struct expr *, for debugging. * %pE: Dump a const struct expr * in verbose form, for debugging. * %%: A literal '%' * ${cc}: Change the color to 'cc' * $$: A literal '$' * @return * 0 on success, -1 on failure. */ BFS_FORMATTER(2, 3) int cfprintf(CFILE *cfile, const char *format, ...); /** * cfprintf() variant that takes a va_list. */ int cvfprintf(CFILE *cfile, const char *format, va_list args); #endif // BFS_COLOR_H bfs-2.3.1/completions/000077500000000000000000000000001417254370000146265ustar00rootroot00000000000000bfs-2.3.1/completions/bfs.bash000066400000000000000000000165211417254370000162440ustar00rootroot00000000000000# bash completion script for bfs ############################################################################ # bfs # # Copyright (C) 2020 Benjamin Mundt # # Copyright (C) 2021 Tavian Barnes # # # # Permission to use, copy, modify, and/or distribute this software for any # # purpose with or without fee is hereby granted. # # # # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES # # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF # # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR # # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES # # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN # # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF # # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. # ############################################################################ _bfs() { local cur prev words cword _init_completion || return # Options with a special completion procedure local special=( -D -S -exec -execdir -fprintf -fstype -gid -group -ok -okdir -regextype -type -uid -user -xtype ) # Options whose values should not be completed # (e.g. because they are numeric, glob, regexp, time, etc.) local nocomp=( -{a,B,c,m}{min,since,time} -ilname -iname -inum -ipath -iregex -iwholename -links -lname -maxdepth -mindepth -name -newer{a,B,c,m}t -path -perm -printf -regex -since -size -used -wholename -xattrname ) # Options whose value is a filename local filecomp=( -{a,B,c,m}newer -f -fls -fprint -fprint0 -newer -newer{a,B,c,m}{a,B,c,m} -samefile ) local operators=( -a -and -exclude -not -o -or ) # Flags that take no arguments local nullary_flags=( -E -H -L -O{0,1,2,3,4,fast} -P -X -d -x ) # Options that take no arguments local nullary_options=( -color -daystart -depth -follow -ignore_readdir_race -maxdepth -mindepth -mount -nocolor -noignore_readdir_race -noleaf -nowarn -status -unique -warn -xdev ) # Tests that take no arguments local nullary_tests=( -capable -empty -executable -false -hidden -nogroup -nohidden -nouser -readable -sparse -true -writable -xattr -xattrname ) # Actions that take no arguments local nullary_actions=( --help --version -delete -exit -help -ls -print -print0 -printx -prune -quit -rm -version ) local everything=( "${special[@]}" "${nocomp[@]}" "${filecomp[@]}" "${operators[@]}" "${nullary_flags[@]}" "${nullary_options[@]}" "${nullary_tests[@]}" "${nullary_actions[@]}" ) # Completing -exec requires matching the whole command line local i offset for i in "${!words[@]}"; do if ((i >= cword)); then break fi case "${words[i]}" in -exec|-execdir|-ok|-okdir) offset=$((i + 1)) ;; \\\;|+) offset= ;; esac done if [[ -n "$offset" ]]; then _command_offset "$offset" COMPREPLY+=($(compgen -W "{} + '\\;'" -- "$cur")) return fi # Completions with 2-word lookbehind if ((cword > 1)); then case "${words[cword-2]}" in -fprintf) # -fprintf FORMAT FILE # Like -ls/-print/-print0/-printf, but write to FILE instead of standard # output # when -fprintf is prev2, current word is FILE; perform file completion _filedir return ;; esac fi # No completion for numbers, globs, regexes, times, etc. if [[ " ${nocomp[@]} " =~ " $prev " ]]; then COMPREPLY=() return fi # Complete filenames if [[ " ${filecomp[@]} " =~ " $prev " ]]; then _filedir return fi # Special completions with 1-word lookbehind case "$prev" in -D) # -D FLAG # Turn on a debugging flag (see -D help) COMPREPLY=($(compgen -W 'help cost exec opt rates search stat tree all' -- "$cur")) return ;; -S) # -S bfs|dfs|ids|eds # Use breadth-first/depth-first/iterative/exponential deepening search # (default: -S bfs) COMPREPLY=($(compgen -W 'bfs dfs ids eds' -- "$cur")) return ;; -fstype) # -fstype TYPE # Find files on file systems with the given TYPE _fstypes return ;; -gid) # -gid [-+]N # Find files owned by group ID N _gids return ;; -group) # -group NAME # Find files owned by the group NAME COMPREPLY=($(compgen -g -- "$cur")) return ;; -uid) # -uid [-+]N # Find files owned by auser ID N _uids return ;; -user) # -user NAME # Find files owned by the user NAME COMPREPLY=($(compgen -u -- "$cur")) return ;; -regextype) # -regextype TYPE # Use TYPE-flavored regexes (default: posix-basic; see -regextype help) COMPREPLY=($(compgen -W 'help posix-basic posix-extended' -- "$cur")) return ;; -type|-xtype) # -type [bcdlpfswD] # Find files of the given type # -xtype [bcdlpfswD] # Find files of the given type, following links when -type would not, and # vice versa COMPREPLY=() if [[ -n $cur ]] && ! [[ $cur =~ ,$ ]]; then COMPREPLY+=("$cur") cur+=, fi COMPREPLY+=("$cur"{b,c,d,l,p,f,s,w,D}) return ;; esac # Completions with no lookbehind if [[ "$cur" == -* ]]; then # complete all options COMPREPLY=($(compgen -W "${everything[*]}" -- "$cur")) return fi # default completion _filedir COMPREPLY+=($(compgen -W "- ! , '\\(' '\\)'" -- "$cur")) } && complete -F _bfs bfs bfs-2.3.1/ctx.c000066400000000000000000000141411417254370000132350ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2015-2021 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "ctx.h" #include "color.h" #include "darray.h" #include "diag.h" #include "expr.h" #include "mtab.h" #include "pwcache.h" #include "stat.h" #include "trie.h" #include #include #include #include #include const char *debug_flag_name(enum debug_flags flag) { switch (flag) { case DEBUG_COST: return "cost"; case DEBUG_EXEC: return "exec"; case DEBUG_OPT: return "opt"; case DEBUG_RATES: return "rates"; case DEBUG_SEARCH: return "search"; case DEBUG_STAT: return "stat"; case DEBUG_TREE: return "tree"; case DEBUG_ALL: break; } assert(!"Unrecognized debug flag"); return "???"; } struct bfs_ctx *bfs_ctx_new(void) { struct bfs_ctx *ctx = malloc(sizeof(*ctx)); if (!ctx) { return NULL; } ctx->argv = NULL; ctx->paths = NULL; ctx->expr = NULL; ctx->exclude = NULL; ctx->mindepth = 0; ctx->maxdepth = INT_MAX; ctx->flags = BFTW_RECOVER; ctx->strategy = BFTW_BFS; ctx->optlevel = 3; ctx->debug = 0; ctx->ignore_races = false; ctx->posixly_correct = false; ctx->status = false; ctx->unique = false; ctx->warn = false; ctx->xargs_safe = false; ctx->colors = NULL; ctx->colors_error = 0; ctx->cout = NULL; ctx->cerr = NULL; ctx->users = NULL; ctx->users_error = 0; ctx->groups = NULL; ctx->groups_error = 0; ctx->mtab = NULL; ctx->mtab_error = 0; trie_init(&ctx->files); ctx->nfiles = 0; struct rlimit rl; if (getrlimit(RLIMIT_NOFILE, &rl) == 0) { ctx->nofile_soft = rl.rlim_cur; ctx->nofile_hard = rl.rlim_max; } else { ctx->nofile_soft = 1024; ctx->nofile_hard = RLIM_INFINITY; } return ctx; } const struct bfs_users *bfs_ctx_users(const struct bfs_ctx *ctx) { struct bfs_ctx *mut = (struct bfs_ctx *)ctx; if (mut->users_error) { errno = mut->users_error; } else if (!mut->users) { mut->users = bfs_users_parse(); if (!mut->users) { mut->users_error = errno; } } return mut->users; } const struct bfs_groups *bfs_ctx_groups(const struct bfs_ctx *ctx) { struct bfs_ctx *mut = (struct bfs_ctx *)ctx; if (mut->groups_error) { errno = mut->groups_error; } else if (!mut->groups) { mut->groups = bfs_groups_parse(); if (!mut->groups) { mut->groups_error = errno; } } return mut->groups; } const struct bfs_mtab *bfs_ctx_mtab(const struct bfs_ctx *ctx) { struct bfs_ctx *mut = (struct bfs_ctx *)ctx; if (mut->mtab_error) { errno = mut->mtab_error; } else if (!mut->mtab) { mut->mtab = bfs_mtab_parse(); if (!mut->mtab) { mut->mtab_error = errno; } } return mut->mtab; } /** * An open file tracked by the bfs context. */ struct bfs_ctx_file { /** The file itself. */ CFILE *cfile; /** The path to the file (for diagnostics). */ const char *path; }; CFILE *bfs_ctx_dedup(struct bfs_ctx *ctx, CFILE *cfile, const char *path) { struct bfs_stat sb; if (bfs_stat(fileno(cfile->file), NULL, 0, &sb) != 0) { return NULL; } bfs_file_id id; bfs_stat_id(&sb, &id); struct trie_leaf *leaf = trie_insert_mem(&ctx->files, id, sizeof(id)); if (!leaf) { return NULL; } struct bfs_ctx_file *ctx_file = leaf->value; if (ctx_file) { ctx_file->path = path; return ctx_file->cfile; } leaf->value = ctx_file = malloc(sizeof(*ctx_file)); if (!ctx_file) { trie_remove(&ctx->files, leaf); return NULL; } ctx_file->cfile = cfile; ctx_file->path = path; ++ctx->nfiles; return cfile; } /** Close a file tracked by the bfs context. */ static int bfs_ctx_close(struct bfs_ctx *ctx, struct bfs_ctx_file *ctx_file) { CFILE *cfile = ctx_file->cfile; if (cfile == ctx->cout) { // Will be checked later return 0; } else if (cfile == ctx->cerr && !ctx_file->path) { // Writes to stderr are allowed to fail silently, unless the same file was used by // -fprint, -fls, etc. return 0; } int ret = 0, error = 0; if (ferror(cfile->file)) { ret = -1; error = EIO; } if (cfile == ctx->cerr) { if (fflush(cfile->file) != 0) { ret = -1; error = errno; } } else { if (cfclose(cfile) != 0) { ret = -1; error = errno; } } errno = error; return ret; } int bfs_ctx_free(struct bfs_ctx *ctx) { int ret = 0; if (ctx) { CFILE *cout = ctx->cout; CFILE *cerr = ctx->cerr; free_expr(ctx->expr); free_expr(ctx->exclude); bfs_mtab_free(ctx->mtab); bfs_groups_free(ctx->groups); bfs_users_free(ctx->users); struct trie_leaf *leaf; while ((leaf = trie_first_leaf(&ctx->files))) { struct bfs_ctx_file *ctx_file = leaf->value; if (bfs_ctx_close(ctx, ctx_file) != 0) { if (cerr) { bfs_error(ctx, "'%s': %m.\n", ctx_file->path); } ret = -1; } free(ctx_file); trie_remove(&ctx->files, leaf); } trie_destroy(&ctx->files); if (cout && fflush(cout->file) != 0) { if (cerr) { bfs_error(ctx, "standard output: %m.\n"); } ret = -1; } cfclose(cout); cfclose(cerr); free_colors(ctx->colors); for (size_t i = 0; i < darray_length(ctx->paths); ++i) { free((char *)ctx->paths[i]); } darray_free(ctx->paths); free(ctx->argv); free(ctx); } return ret; } bfs-2.3.1/ctx.h000066400000000000000000000126631417254370000132510ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2015-2021 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * bfs execution context. */ #ifndef BFS_CTX_H #define BFS_CTX_H #include "bftw.h" #include "trie.h" #include #include /** * Various debugging flags. */ enum debug_flags { /** Print cost estimates. */ DEBUG_COST = 1 << 0, /** Print executed command details. */ DEBUG_EXEC = 1 << 1, /** Print optimization details. */ DEBUG_OPT = 1 << 2, /** Print rate information. */ DEBUG_RATES = 1 << 3, /** Trace the filesystem traversal. */ DEBUG_SEARCH = 1 << 4, /** Trace all stat() calls. */ DEBUG_STAT = 1 << 5, /** Print the parse tree. */ DEBUG_TREE = 1 << 6, /** All debug flags. */ DEBUG_ALL = (1 << 7) - 1, }; /** * Convert a debug flag to a string. */ const char *debug_flag_name(enum debug_flags flag); /** * The execution context for bfs. */ struct bfs_ctx { /** The unparsed command line arguments. */ char **argv; /** The root paths. */ const char **paths; /** The main command line expression. */ struct expr *expr; /** An expression for files to filter out. */ struct expr *exclude; /** -mindepth option. */ int mindepth; /** -maxdepth option. */ int maxdepth; /** bftw() flags. */ enum bftw_flags flags; /** bftw() search strategy. */ enum bftw_strategy strategy; /** Optimization level (-O). */ int optlevel; /** Debugging flags (-D). */ enum debug_flags debug; /** Whether to ignore deletions that race with bfs (-ignore_readdir_race). */ bool ignore_races; /** Whether to follow POSIXisms more closely ($POSIXLY_CORRECT). */ bool posixly_correct; /** Whether to show a status bar (-status). */ bool status; /** Whether to only return unique files (-unique). */ bool unique; /** Whether to print warnings (-warn/-nowarn). */ bool warn; /** Whether to only handle paths with xargs-safe characters (-X). */ bool xargs_safe; /** Color data. */ struct colors *colors; /** The error that occurred parsing the color table, if any. */ int colors_error; /** Colored stdout. */ struct CFILE *cout; /** Colored stderr. */ struct CFILE *cerr; /** User table. */ struct bfs_users *users; /** The error that occurred parsing the user table, if any. */ int users_error; /** Group table. */ struct bfs_groups *groups; /** The error that occurred parsing the group table, if any. */ int groups_error; /** Table of mounted file systems. */ struct bfs_mtab *mtab; /** The error that occurred parsing the mount table, if any. */ int mtab_error; /** All the files owned by the context. */ struct trie files; /** The number of files owned by the context. */ int nfiles; /** The initial RLIMIT_NOFILE soft limit. */ rlim_t nofile_soft; /** The initial RLIMIT_NOFILE hard limit. */ rlim_t nofile_hard; }; /** * @return * A new bfs context, or NULL on failure. */ struct bfs_ctx *bfs_ctx_new(void); /** * Get the users table. * * @param ctx * The bfs context. * @return * The cached users table, or NULL on failure. */ const struct bfs_users *bfs_ctx_users(const struct bfs_ctx *ctx); /** * Get the groups table. * * @param ctx * The bfs context. * @return * The cached groups table, or NULL on failure. */ const struct bfs_groups *bfs_ctx_groups(const struct bfs_ctx *ctx); /** * Get the mount table. * * @param ctx * The bfs context. * @return * The cached mount table, or NULL on failure. */ const struct bfs_mtab *bfs_ctx_mtab(const struct bfs_ctx *ctx); /** * Deduplicate an opened file. * * @param ctx * The bfs context. * @param cfile * The opened file. * @param path * The path to the opened file (or NULL for standard streams). * @return * If the same file was opened previously, that file is returned. If cfile is a new file, * cfile itself is returned. If an error occurs, NULL is returned. */ struct CFILE *bfs_ctx_dedup(struct bfs_ctx *ctx, struct CFILE *cfile, const char *path); /** * Dump the parsed command line. * * @param ctx * The bfs context. * @param flag * The -D flag that triggered the dump. */ void bfs_ctx_dump(const struct bfs_ctx *ctx, enum debug_flags flag); /** * Free a bfs context. * * @param ctx * The context to free. * @return * 0 on success, -1 if any errors occurred. */ int bfs_ctx_free(struct bfs_ctx *ctx); #endif // BFS_CTX_H bfs-2.3.1/darray.c000066400000000000000000000062401417254370000137220ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2019-2022 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "darray.h" #include #include #include /** * The darray header. */ struct darray { /** The current capacity of the array, as a count of elements. */ size_t capacity; /** The current length of the array. */ size_t length; // The array elements are stored after this header in memory. Not using // a flexible array member to avoid worrying about strict aliasing. We // assume that 2*sizeof(size_t) keeps any memory allocation suitably // aligned for the element type. }; /** Get the header for a darray. */ static struct darray *darray_header(const void *da) { return (struct darray *)da - 1; } /** Get the array from a darray header. */ static char *darray_data(struct darray *header) { return (char *)(header + 1); } size_t darray_length(const void *da) { if (da) { return darray_header(da)->length; } else { return 0; } } void *darray_push(void *da, const void *item, size_t size) { struct darray *header; if (da) { header = darray_header(da); } else { header = malloc(sizeof(*header) + size); if (!header) { return NULL; } header->capacity = 1; header->length = 0; } size_t capacity = header->capacity; size_t i = header->length++; if (i >= capacity) { capacity *= 2; header = realloc(header, sizeof(*header) + capacity*size); if (!header) { // This failure will be detected by darray_check() return da; } header->capacity = capacity; } char *data = darray_data(header); memcpy(data + i*size, item, size); return data; } int darray_check(void *da) { if (!da) { return -1; } struct darray *header = darray_header(da); if (header->length <= header->capacity) { return 0; } else { // realloc() failed in darray_push(), so reset the length and report the failure header->length = header->capacity; return -1; } } size_t darray_pop(void *da) { assert(da); struct darray *header = darray_header(da); assert(header->length > 0); return --header->length; } void darray_free(void *da) { if (da) { free(darray_header(da)); } } bfs-2.3.1/darray.h000066400000000000000000000070021417254370000137240ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2019-2022 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * A dynamic array library. * * darrays are represented by a simple pointer to the array element type, like * any other array. Behind the scenes, the capacity and current length of the * array are stored along with it. NULL is a valid way to initialize an empty * darray: * * int *darray = NULL; * * To append an element to a darray, use the DARRAY_PUSH macro: * * int e = 42; * if (DARRAY_PUSH(&darray, &e) != 0) { * // Report the error... * } * * The length can be retrieved by darray_length(). Iterating over the array * works like normal arrays: * * for (size_t i = 0; i < darray_length(darray); ++i) { * printf("%d\n", darray[i]); * } * * To free a darray, use darray_free(): * * darray_free(darray); */ #ifndef BFS_DARRAY_H #define BFS_DARRAY_H #include /** * Get the length of a darray. * * @param da * The array in question. * @return * The length of the array. */ size_t darray_length(const void *da); /** * @internal Use DARRAY_PUSH(). * * Push an element into a darray. * * @param da * The array to append to. * @param item * The item to append. * @param size * The size of the item. * @return * The (new) location of the array. */ void *darray_push(void *da, const void *item, size_t size); /** * @internal Use DARRAY_PUSH(). * * Check if the last darray_push() call failed. * * @param da * The darray to check. * @return * 0 on success, -1 on failure. */ int darray_check(void *da); /** * @internal Use DARRAY_POP(). * * Pop an element from an array. * * @param da * The array in question. * @return * The (new) length of the array. */ size_t darray_pop(void *da); /** * Free a darray. * * @param da * The darray to free. */ void darray_free(void *da); /** * Push an item into a darray. * * @param da * The array to append to. * @param item * A pointer to the item to append. * @return * 0 on success, -1 on failure. */ #define DARRAY_PUSH(da, item) \ (darray_check(*(da) = darray_push(*(da), (item), sizeof(**(da) = *(item))))) /** * Pop an item from a darray. * * @param da * The array to pop from. * @return * The popped item. */ #define DARRAY_POP(da) \ ((da)[darray_pop((da))]) #endif // BFS_DARRAY_H bfs-2.3.1/diag.c000066400000000000000000000062221417254370000133440ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2019 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "diag.h" #include "ctx.h" #include "color.h" #include "util.h" #include #include void bfs_perror(const struct bfs_ctx *ctx, const char *str) { bfs_error(ctx, "%s: %m.\n", str); } void bfs_error(const struct bfs_ctx *ctx, const char *format, ...) { va_list args; va_start(args, format); bfs_verror(ctx, format, args); va_end(args); } bool bfs_warning(const struct bfs_ctx *ctx, const char *format, ...) { va_list args; va_start(args, format); bool ret = bfs_vwarning(ctx, format, args); va_end(args); return ret; } bool bfs_debug(const struct bfs_ctx *ctx, enum debug_flags flag, const char *format, ...) { va_list args; va_start(args, format); bool ret = bfs_vdebug(ctx, flag, format, args); va_end(args); return ret; } void bfs_verror(const struct bfs_ctx *ctx, const char *format, va_list args) { int error = errno; bfs_error_prefix(ctx); errno = error; cvfprintf(ctx->cerr, format, args); } bool bfs_vwarning(const struct bfs_ctx *ctx, const char *format, va_list args) { int error = errno; if (bfs_warning_prefix(ctx)) { errno = error; cvfprintf(ctx->cerr, format, args); return true; } else { return false; } } bool bfs_vdebug(const struct bfs_ctx *ctx, enum debug_flags flag, const char *format, va_list args) { int error = errno; if (bfs_debug_prefix(ctx, flag)) { errno = error; cvfprintf(ctx->cerr, format, args); return true; } else { return false; } } void bfs_error_prefix(const struct bfs_ctx *ctx) { cfprintf(ctx->cerr, "${bld}%s:${rs} ${er}error:${rs} ", xbasename(ctx->argv[0])); } bool bfs_warning_prefix(const struct bfs_ctx *ctx) { if (ctx->warn) { cfprintf(ctx->cerr, "${bld}%s:${rs} ${wr}warning:${rs} ", xbasename(ctx->argv[0])); return true; } else { return false; } } bool bfs_debug_prefix(const struct bfs_ctx *ctx, enum debug_flags flag) { if (ctx->debug & flag) { cfprintf(ctx->cerr, "${bld}%s:${rs} ${cyn}-D %s${rs}: ", xbasename(ctx->argv[0]), debug_flag_name(flag)); return true; } else { return false; } } bfs-2.3.1/diag.h000066400000000000000000000052751417254370000133600ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2019 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * Formatters for diagnostic messages. */ #ifndef BFS_DIAG_H #define BFS_DIAG_H #include "ctx.h" #include "util.h" #include #include /** * Like perror(), but decorated like bfs_error(). */ void bfs_perror(const struct bfs_ctx *ctx, const char *str); /** * Shorthand for printing error messages. */ BFS_FORMATTER(2, 3) void bfs_error(const struct bfs_ctx *ctx, const char *format, ...); /** * Shorthand for printing warning messages. * * @return Whether a warning was printed. */ BFS_FORMATTER(2, 3) bool bfs_warning(const struct bfs_ctx *ctx, const char *format, ...); /** * Shorthand for printing debug messages. * * @return Whether a debug message was printed. */ BFS_FORMATTER(3, 4) bool bfs_debug(const struct bfs_ctx *ctx, enum debug_flags flag, const char *format, ...); /** * bfs_error() variant that takes a va_list. */ void bfs_verror(const struct bfs_ctx *ctx, const char *format, va_list args); /** * bfs_warning() variant that takes a va_list. */ bool bfs_vwarning(const struct bfs_ctx *ctx, const char *format, va_list args); /** * bfs_debug() variant that takes a va_list. */ bool bfs_vdebug(const struct bfs_ctx *ctx, enum debug_flags flag, const char *format, va_list args); /** * Print the error message prefix. */ void bfs_error_prefix(const struct bfs_ctx *ctx); /** * Print the warning message prefix. */ bool bfs_warning_prefix(const struct bfs_ctx *ctx); /** * Print the debug message prefix. */ bool bfs_debug_prefix(const struct bfs_ctx *ctx, enum debug_flags flag); #endif // BFS_DIAG_H bfs-2.3.1/dir.c000066400000000000000000000134501417254370000132170ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2021-2022 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "dir.h" #include "util.h" #include #include #include #include #include #include #include #include #if __linux__ # include #endif // __linux__ enum bfs_type bfs_mode_to_type(mode_t mode) { switch (mode & S_IFMT) { #ifdef S_IFBLK case S_IFBLK: return BFS_BLK; #endif #ifdef S_IFCHR case S_IFCHR: return BFS_CHR; #endif #ifdef S_IFDIR case S_IFDIR: return BFS_DIR; #endif #ifdef S_IFDOOR case S_IFDOOR: return BFS_DOOR; #endif #ifdef S_IFIFO case S_IFIFO: return BFS_FIFO; #endif #ifdef S_IFLNK case S_IFLNK: return BFS_LNK; #endif #ifdef S_IFPORT case S_IFPORT: return BFS_PORT; #endif #ifdef S_IFREG case S_IFREG: return BFS_REG; #endif #ifdef S_IFSOCK case S_IFSOCK: return BFS_SOCK; #endif #ifdef S_IFWHT case S_IFWHT: return BFS_WHT; #endif default: return BFS_UNKNOWN; } } #if __linux__ /** * This is not defined in the kernel headers for some reason, callers have to * define it themselves. */ struct linux_dirent64 { ino64_t d_ino; off64_t d_off; unsigned short d_reclen; unsigned char d_type; char d_name[]; }; // Make the whole allocation 64k #define BUF_SIZE ((64 << 10) - 8) #endif struct bfs_dir { #if __linux__ int fd; unsigned short pos; unsigned short size; #else DIR *dir; struct dirent *de; #endif }; struct bfs_dir *bfs_opendir(int at_fd, const char *at_path) { #if __linux__ struct bfs_dir *dir = malloc(sizeof(*dir) + BUF_SIZE); #else struct bfs_dir *dir = malloc(sizeof(*dir)); #endif if (!dir) { return NULL; } int fd; if (at_path) { fd = openat(at_fd, at_path, O_RDONLY | O_CLOEXEC | O_DIRECTORY); } else if (at_fd >= 0) { fd = at_fd; } else { free(dir); errno = EBADF; return NULL; } if (fd < 0) { free(dir); return NULL; } #if __linux__ dir->fd = fd; dir->pos = 0; dir->size = 0; #else dir->dir = fdopendir(fd); if (!dir->dir) { if (at_path) { close_quietly(fd); } free(dir); return NULL; } dir->de = NULL; #endif // __linux__ return dir; } int bfs_dirfd(const struct bfs_dir *dir) { #if __linux__ return dir->fd; #else return dirfd(dir->dir); #endif } /** Convert a dirent type to a bfs_type. */ static enum bfs_type translate_type(int d_type) { switch (d_type) { #ifdef DT_BLK case DT_BLK: return BFS_BLK; #endif #ifdef DT_CHR case DT_CHR: return BFS_CHR; #endif #ifdef DT_DIR case DT_DIR: return BFS_DIR; #endif #ifdef DT_DOOR case DT_DOOR: return BFS_DOOR; #endif #ifdef DT_FIFO case DT_FIFO: return BFS_FIFO; #endif #ifdef DT_LNK case DT_LNK: return BFS_LNK; #endif #ifdef DT_PORT case DT_PORT: return BFS_PORT; #endif #ifdef DT_REG case DT_REG: return BFS_REG; #endif #ifdef DT_SOCK case DT_SOCK: return BFS_SOCK; #endif #ifdef DT_WHT case DT_WHT: return BFS_WHT; #endif } return BFS_UNKNOWN; } #if !__linux__ /** Get the type from a struct dirent if it exists, and convert it. */ static enum bfs_type dirent_type(const struct dirent *de) { #if defined(_DIRENT_HAVE_D_TYPE) || defined(DT_UNKNOWN) return translate_type(de->d_type); #else return BFS_UNKNOWN; #endif } #endif /** Check if a name is . or .. */ static bool is_dot(const char *name) { return name[0] == '.' && (name[1] == '\0' || (name[1] == '.' && name[2] == '\0')); } int bfs_readdir(struct bfs_dir *dir, struct bfs_dirent *de) { while (true) { #if __linux__ char *buf = (char *)(dir + 1); if (dir->pos >= dir->size) { #if BFS_HAS_FEATURE(memory_sanitizer, false) // Make sure msan knows the buffer is initialized memset(buf, 0, BUF_SIZE); #endif ssize_t size = syscall(__NR_getdents64, dir->fd, buf, BUF_SIZE); if (size <= 0) { return size; } dir->pos = 0; dir->size = size; } const struct linux_dirent64 *lde = (void *)(buf + dir->pos); dir->pos += lde->d_reclen; if (is_dot(lde->d_name)) { continue; } if (de) { de->type = translate_type(lde->d_type); de->name = lde->d_name; } return 1; #else // !__linux__ errno = 0; dir->de = readdir(dir->dir); if (dir->de) { if (is_dot(dir->de->d_name)) { continue; } if (de) { de->type = dirent_type(dir->de); de->name = dir->de->d_name; } return 1; } else if (errno != 0) { return -1; } else { return 0; } #endif // !__linux__ } } int bfs_closedir(struct bfs_dir *dir) { #if __linux__ int ret = xclose(dir->fd); #else int ret = closedir(dir->dir); #endif free(dir); return ret; } int bfs_freedir(struct bfs_dir *dir) { #if __linux__ int ret = dir->fd; free(dir); return ret; #elif __FreeBSD__ int ret = fdclosedir(dir->dir); free(dir); return ret; #else int ret = dup_cloexec(dirfd(dir->dir)); bfs_closedir(dir); return ret; #endif } bfs-2.3.1/dir.h000066400000000000000000000061111417254370000132200ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2021 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * Directories and their contents. */ #ifndef BFS_DIR_H #define BFS_DIR_H #include /** * A directory. */ struct bfs_dir; /** * File types. */ enum bfs_type { /** An error occurred for this file. */ BFS_ERROR = -1, /** Unknown type. */ BFS_UNKNOWN, /** Block device. */ BFS_BLK, /** Character device. */ BFS_CHR, /** Directory. */ BFS_DIR, /** Solaris door. */ BFS_DOOR, /** Pipe. */ BFS_FIFO, /** Symbolic link. */ BFS_LNK, /** Solaris event port. */ BFS_PORT, /** Regular file. */ BFS_REG, /** Socket. */ BFS_SOCK, /** BSD whiteout. */ BFS_WHT, }; /** * Convert a bfs_stat() mode to a bfs_type. */ enum bfs_type bfs_mode_to_type(mode_t mode); /** * A directory entry. */ struct bfs_dirent { /** The type of this file (possibly unknown). */ enum bfs_type type; /** The name of this file. */ const char *name; }; /** * Open a directory. * * @param at_fd * The base directory for path resolution. * @param at_path * The path of the directory to open, relative to at_fd. Pass NULL to * open at_fd itself. * @return * The opened directory, or NULL on failure. */ struct bfs_dir *bfs_opendir(int at_fd, const char *at_path); /** * Get the file descriptor for a directory. */ int bfs_dirfd(const struct bfs_dir *dir); /** * Read a directory entry. * * @param dir * The directory to read. * @param[out] dirent * The directory entry to populate. * @return * 1 on success, 0 on EOF, or -1 on failure. */ int bfs_readdir(struct bfs_dir *dir, struct bfs_dirent *de); /** * Close a directory. * * @return * 0 on success, -1 on failure. */ int bfs_closedir(struct bfs_dir *dir); /** * Free a directory, keeping an open file descriptor to it. * * @param dir * The directory to free. * @return * The file descriptor on success, or -1 on failure. */ int bfs_freedir(struct bfs_dir *dir); #endif // BFS_DIR_H bfs-2.3.1/dstring.c000066400000000000000000000123221417254370000141100ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2016-2022 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "dstring.h" #include #include #include #include #include /** * The memory representation of a dynamic string. Users get a pointer to data. */ struct dstring { size_t capacity; size_t length; char data[]; }; /** Get the string header from the string data pointer. */ static struct dstring *dstrheader(const char *dstr) { return (struct dstring *)(dstr - offsetof(struct dstring, data)); } /** Get the correct size for a dstring with the given capacity. */ static size_t dstrsize(size_t capacity) { return BFS_FLEX_SIZEOF(struct dstring, data, capacity + 1); } /** Allocate a dstring with the given contents. */ static char *dstralloc_impl(size_t capacity, size_t length, const char *data) { // Avoid reallocations for small strings if (capacity < 7) { capacity = 7; } struct dstring *header = malloc(dstrsize(capacity)); if (!header) { return NULL; } header->capacity = capacity; header->length = length; memcpy(header->data, data, length); header->data[length] = '\0'; return header->data; } char *dstralloc(size_t capacity) { return dstralloc_impl(capacity, 0, ""); } char *dstrdup(const char *str) { size_t len = strlen(str); return dstralloc_impl(len, len, str); } char *dstrndup(const char *str, size_t n) { size_t len = strnlen(str, n); return dstralloc_impl(len, len, str); } size_t dstrlen(const char *dstr) { return dstrheader(dstr)->length; } int dstreserve(char **dstr, size_t capacity) { struct dstring *header = dstrheader(*dstr); if (capacity > header->capacity) { capacity *= 2; header = realloc(header, dstrsize(capacity)); if (!header) { return -1; } header->capacity = capacity; *dstr = header->data; } return 0; } int dstresize(char **dstr, size_t length) { if (dstreserve(dstr, length) != 0) { return -1; } struct dstring *header = dstrheader(*dstr); header->length = length; header->data[length] = '\0'; return 0; } /** Common implementation of dstr{cat,ncat,app}. */ static int dstrcat_impl(char **dest, const char *src, size_t srclen) { size_t oldlen = dstrlen(*dest); size_t newlen = oldlen + srclen; if (dstresize(dest, newlen) != 0) { return -1; } memcpy(*dest + oldlen, src, srclen); return 0; } int dstrcat(char **dest, const char *src) { return dstrcat_impl(dest, src, strlen(src)); } int dstrncat(char **dest, const char *src, size_t n) { return dstrcat_impl(dest, src, strnlen(src, n)); } int dstrdcat(char **dest, const char *src) { return dstrcat_impl(dest, src, dstrlen(src)); } int dstrapp(char **str, char c) { return dstrcat_impl(str, &c, 1); } char *dstrprintf(const char *format, ...) { va_list args; va_start(args, format); char *str = dstrvprintf(format, args); va_end(args); return str; } char *dstrvprintf(const char *format, va_list args) { // Guess a capacity to try to avoid reallocating char *str = dstralloc(2*strlen(format)); if (!str) { return NULL; } if (dstrvcatf(&str, format, args) != 0) { dstrfree(str); return NULL; } return str; } int dstrcatf(char **str, const char *format, ...) { va_list args; va_start(args, format); int ret = dstrvcatf(str, format, args); va_end(args); return ret; } int dstrvcatf(char **str, const char *format, va_list args) { // Guess a capacity to try to avoid calling vsnprintf() twice size_t len = dstrlen(*str); dstreserve(str, len + 2*strlen(format)); size_t cap = dstrheader(*str)->capacity; va_list copy; va_copy(copy, args); char *tail = *str + len; int ret = vsnprintf(tail, cap - len + 1, format, args); if (ret < 0) { goto fail; } size_t tail_len = ret; if (tail_len > cap - len) { cap = len + tail_len; if (dstreserve(str, cap) != 0) { goto fail; } tail = *str + len; ret = vsnprintf(tail, tail_len + 1, format, copy); if (ret < 0 || (size_t)ret != tail_len) { assert(!"Length of formatted string changed"); goto fail; } } va_end(copy); struct dstring *header = dstrheader(*str); header->length += tail_len; return 0; fail: *tail = '\0'; return -1; } void dstrfree(char *dstr) { if (dstr) { free(dstrheader(dstr)); } } bfs-2.3.1/dstring.h000066400000000000000000000116611417254370000141220ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2016-2020 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * A dynamic string library. */ #ifndef BFS_DSTRING_H #define BFS_DSTRING_H #include "util.h" #include #include /** * Allocate a dynamic string. * * @param capacity * The initial capacity of the string. */ char *dstralloc(size_t capacity); /** * Create a dynamic copy of a string. * * @param str * The NUL-terminated string to copy. */ char *dstrdup(const char *str); /** * Create a length-limited dynamic copy of a string. * * @param str * The string to copy. * @param n * The maximum number of characters to copy from str. */ char *dstrndup(const char *str, size_t n); /** * Get a dynamic string's length. * * @param dstr * The string to measure. * @return The length of dstr. */ size_t dstrlen(const char *dstr); /** * Reserve some capacity in a dynamic string. * * @param dstr * The dynamic string to preallocate. * @param capacity * The new capacity for the string. * @return 0 on success, -1 on failure. */ int dstreserve(char **dstr, size_t capacity); /** * Resize a dynamic string. * * @param dstr * The dynamic string to resize. * @param length * The new length for the dynamic string. * @return 0 on success, -1 on failure. */ int dstresize(char **dstr, size_t length); /** * Append to a dynamic string. * * @param dest * The destination dynamic string. * @param src * The string to append. * @return 0 on success, -1 on failure. */ int dstrcat(char **dest, const char *src); /** * Append to a dynamic string. * * @param dest * The destination dynamic string. * @param src * The string to append. * @param n * The maximum number of characters to take from src. * @return 0 on success, -1 on failure. */ int dstrncat(char **dest, const char *src, size_t n); /** * Append a dynamic string to another dynamic string. * * @param dest * The destination dynamic string. * @param src * The dynamic string to append. * @return * 0 on success, -1 on failure. */ int dstrdcat(char **dest, const char *src); /** * Append a single character to a dynamic string. * * @param str * The string to append to. * @param c * The character to append. * @return 0 on success, -1 on failure. */ int dstrapp(char **str, char c); /** * Create a dynamic string from a format string. * * @param format * The format string to fill in. * @param ... * Any arguments for the format string. * @return * The created string, or NULL on failure. */ BFS_FORMATTER(1, 2) char *dstrprintf(const char *format, ...); /** * Create a dynamic string from a format string and a va_list. * * @param format * The format string to fill in. * @param args * The arguments for the format string. * @return * The created string, or NULL on failure. */ char *dstrvprintf(const char *format, va_list args); /** * Format some text onto the end of a dynamic string. * * @param str * The destination dynamic string. * @param format * The format string to fill in. * @param ... * Any arguments for the format string. * @return * 0 on success, -1 on failure. */ BFS_FORMATTER(2, 3) int dstrcatf(char **str, const char *format, ...); /** * Format some text from a va_list onto the end of a dynamic string. * * @param str * The destination dynamic string. * @param format * The format string to fill in. * @param args * The arguments for the format string. * @return * 0 on success, -1 on failure. */ int dstrvcatf(char **str, const char *format, va_list args); /** * Free a dynamic string. * * @param dstr * The string to free. */ void dstrfree(char *dstr); #endif // BFS_DSTRING_H bfs-2.3.1/eval.c000066400000000000000000001052331417254370000133710ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2015-2021 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * Implementation of all the literal expressions. */ #include "eval.h" #include "bar.h" #include "bftw.h" #include "color.h" #include "ctx.h" #include "darray.h" #include "diag.h" #include "dir.h" #include "dstring.h" #include "exec.h" #include "expr.h" #include "fsade.h" #include "mtab.h" #include "printf.h" #include "pwcache.h" #include "stat.h" #include "time.h" #include "trie.h" #include "util.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include struct eval_state { /** Data about the current file. */ const struct BFTW *ftwbuf; /** The bfs context. */ const struct bfs_ctx *ctx; /** The bftw() callback return value. */ enum bftw_action action; /** The bfs_eval() return value. */ int *ret; /** Whether to quit immediately. */ bool quit; }; /** * Print an error message. */ BFS_FORMATTER(2, 3) static void eval_error(struct eval_state *state, const char *format, ...) { // By POSIX, any errors should be accompanied by a non-zero exit status *state->ret = EXIT_FAILURE; int error = errno; const struct bfs_ctx *ctx = state->ctx; CFILE *cerr = ctx->cerr; bfs_error(ctx, "%pP: ", state->ftwbuf); va_list args; va_start(args, format); errno = error; cvfprintf(cerr, format, args); va_end(args); } /** * Check if an error should be ignored. */ static bool eval_should_ignore(const struct eval_state *state, int error) { return state->ctx->ignore_races && is_nonexistence_error(error) && state->ftwbuf->depth > 0; } /** * Report an error that occurs during evaluation. */ static void eval_report_error(struct eval_state *state) { if (!eval_should_ignore(state, errno)) { eval_error(state, "%m.\n"); } } /** * Perform a bfs_stat() call if necessary. */ static const struct bfs_stat *eval_stat(struct eval_state *state) { const struct BFTW *ftwbuf = state->ftwbuf; const struct bfs_stat *ret = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (!ret) { eval_report_error(state); } return ret; } /** * Get the difference (in seconds) between two struct timespecs. */ static time_t timespec_diff(const struct timespec *lhs, const struct timespec *rhs) { time_t ret = lhs->tv_sec - rhs->tv_sec; if (lhs->tv_nsec < rhs->tv_nsec) { --ret; } return ret; } bool expr_cmp(const struct expr *expr, long long n) { switch (expr->cmp_flag) { case CMP_EXACT: return n == expr->idata; case CMP_LESS: return n < expr->idata; case CMP_GREATER: return n > expr->idata; } return false; } /** * -true test. */ bool eval_true(const struct expr *expr, struct eval_state *state) { return true; } /** * -false test. */ bool eval_false(const struct expr *expr, struct eval_state *state) { return false; } /** * -executable, -readable, -writable tests. */ bool eval_access(const struct expr *expr, struct eval_state *state) { const struct BFTW *ftwbuf = state->ftwbuf; return xfaccessat(ftwbuf->at_fd, ftwbuf->at_path, expr->idata) == 0; } /** * -acl test. */ bool eval_acl(const struct expr *expr, struct eval_state *state) { int ret = bfs_check_acl(state->ftwbuf); if (ret >= 0) { return ret; } else { eval_report_error(state); return false; } } /** * -capable test. */ bool eval_capable(const struct expr *expr, struct eval_state *state) { int ret = bfs_check_capabilities(state->ftwbuf); if (ret >= 0) { return ret; } else { eval_report_error(state); return false; } } /** * Get the given timespec field out of a stat buffer. */ static const struct timespec *eval_stat_time(const struct bfs_stat *statbuf, enum bfs_stat_field field, struct eval_state *state) { const struct timespec *ret = bfs_stat_time(statbuf, field); if (!ret) { eval_error(state, "Couldn't get file %s: %m.\n", bfs_stat_field_name(field)); } return ret; } /** * -[aBcm]?newer tests. */ bool eval_newer(const struct expr *expr, struct eval_state *state) { const struct bfs_stat *statbuf = eval_stat(state); if (!statbuf) { return false; } const struct timespec *time = eval_stat_time(statbuf, expr->stat_field, state); if (!time) { return false; } return time->tv_sec > expr->reftime.tv_sec || (time->tv_sec == expr->reftime.tv_sec && time->tv_nsec > expr->reftime.tv_nsec); } /** * -[aBcm]{min,time} tests. */ bool eval_time(const struct expr *expr, struct eval_state *state) { const struct bfs_stat *statbuf = eval_stat(state); if (!statbuf) { return false; } const struct timespec *time = eval_stat_time(statbuf, expr->stat_field, state); if (!time) { return false; } time_t diff = timespec_diff(&expr->reftime, time); switch (expr->time_unit) { case DAYS: diff /= 60*24; BFS_FALLTHROUGH; case MINUTES: diff /= 60; BFS_FALLTHROUGH; case SECONDS: break; } return expr_cmp(expr, diff); } /** * -used test. */ bool eval_used(const struct expr *expr, struct eval_state *state) { const struct bfs_stat *statbuf = eval_stat(state); if (!statbuf) { return false; } const struct timespec *atime = eval_stat_time(statbuf, BFS_STAT_ATIME, state); const struct timespec *ctime = eval_stat_time(statbuf, BFS_STAT_CTIME, state); if (!atime || !ctime) { return false; } long long diff = timespec_diff(atime, ctime); if (diff < 0) { return false; } long long day_seconds = 60*60*24; diff = (diff + day_seconds - 1) / day_seconds; return expr_cmp(expr, diff); } /** * -gid test. */ bool eval_gid(const struct expr *expr, struct eval_state *state) { const struct bfs_stat *statbuf = eval_stat(state); if (!statbuf) { return false; } return expr_cmp(expr, statbuf->gid); } /** * -uid test. */ bool eval_uid(const struct expr *expr, struct eval_state *state) { const struct bfs_stat *statbuf = eval_stat(state); if (!statbuf) { return false; } return expr_cmp(expr, statbuf->uid); } /** * -nogroup test. */ bool eval_nogroup(const struct expr *expr, struct eval_state *state) { const struct bfs_stat *statbuf = eval_stat(state); if (!statbuf) { return false; } const struct bfs_groups *groups = bfs_ctx_groups(state->ctx); if (!groups) { eval_report_error(state); return false; } return bfs_getgrgid(groups, statbuf->gid) == NULL; } /** * -nouser test. */ bool eval_nouser(const struct expr *expr, struct eval_state *state) { const struct bfs_stat *statbuf = eval_stat(state); if (!statbuf) { return false; } const struct bfs_users *users = bfs_ctx_users(state->ctx); if (!users) { eval_report_error(state); return false; } return bfs_getpwuid(users, statbuf->uid) == NULL; } /** * -delete action. */ bool eval_delete(const struct expr *expr, struct eval_state *state) { const struct BFTW *ftwbuf = state->ftwbuf; // Don't try to delete the current directory if (strcmp(ftwbuf->path, ".") == 0) { return true; } int flag = 0; // We need to know the actual type of the path, not what it points to enum bfs_type type = bftw_type(ftwbuf, BFS_STAT_NOFOLLOW); if (type == BFS_DIR) { flag |= AT_REMOVEDIR; } else if (type == BFS_ERROR) { eval_report_error(state); return false; } if (unlinkat(ftwbuf->at_fd, ftwbuf->at_path, flag) != 0) { eval_report_error(state); return false; } return true; } /** Finish any pending -exec ... + operations. */ static int eval_exec_finish(const struct expr *expr, const struct bfs_ctx *ctx) { int ret = 0; if (expr->execbuf && bfs_exec_finish(expr->execbuf) != 0) { if (errno != 0) { bfs_error(ctx, "%s %s: %m.\n", expr->argv[0], expr->argv[1]); } ret = -1; } if (expr->lhs && eval_exec_finish(expr->lhs, ctx) != 0) { ret = -1; } if (expr->rhs && eval_exec_finish(expr->rhs, ctx) != 0) { ret = -1; } return ret; } /** * -exec[dir]/-ok[dir] actions. */ bool eval_exec(const struct expr *expr, struct eval_state *state) { bool ret = bfs_exec(expr->execbuf, state->ftwbuf) == 0; if (errno != 0) { eval_error(state, "%s %s: %m.\n", expr->argv[0], expr->argv[1]); } return ret; } /** * -exit action. */ bool eval_exit(const struct expr *expr, struct eval_state *state) { state->action = BFTW_STOP; *state->ret = expr->idata; state->quit = true; return true; } /** * -depth N test. */ bool eval_depth(const struct expr *expr, struct eval_state *state) { return expr_cmp(expr, state->ftwbuf->depth); } /** * -empty test. */ bool eval_empty(const struct expr *expr, struct eval_state *state) { bool ret = false; const struct BFTW *ftwbuf = state->ftwbuf; if (ftwbuf->type == BFS_DIR) { struct bfs_dir *dir = bfs_opendir(ftwbuf->at_fd, ftwbuf->at_path); if (!dir) { eval_report_error(state); goto done; } int did_read = bfs_readdir(dir, NULL); if (did_read < 0) { eval_report_error(state); } else { ret = !did_read; } bfs_closedir(dir); } else if (ftwbuf->type == BFS_REG) { const struct bfs_stat *statbuf = eval_stat(state); if (statbuf) { ret = statbuf->size == 0; } } done: return ret; } /** * -flags test. */ bool eval_flags(const struct expr *expr, struct eval_state *state) { const struct bfs_stat *statbuf = eval_stat(state); if (!statbuf) { return false; } if (!(statbuf->mask & BFS_STAT_ATTRS)) { eval_error(state, "Couldn't get file %s.\n", bfs_stat_field_name(BFS_STAT_ATTRS)); return false; } unsigned long flags = statbuf->attrs; unsigned long set = expr->set_flags; unsigned long clear = expr->clear_flags; switch (expr->mode_cmp) { case MODE_EXACT: return flags == set && !(flags & clear); case MODE_ALL: return (flags & set) == set && !(flags & clear); case MODE_ANY: return (flags & set) || (flags & clear) != clear; } assert(!"Invalid comparison mode"); return false; } /** * -fstype test. */ bool eval_fstype(const struct expr *expr, struct eval_state *state) { const struct bfs_stat *statbuf = eval_stat(state); if (!statbuf) { return false; } const struct bfs_mtab *mtab = bfs_ctx_mtab(state->ctx); if (!mtab) { eval_report_error(state); return false; } const char *type = bfs_fstype(mtab, statbuf); return strcmp(type, expr->sdata) == 0; } /** * -hidden test. */ bool eval_hidden(const struct expr *expr, struct eval_state *state) { const struct BFTW *ftwbuf = state->ftwbuf; const char *name = ftwbuf->path + ftwbuf->nameoff; // Don't treat "." or ".." as hidden directories. Otherwise we'd filter // out everything when given // // $ bfs . -nohidden // $ bfs .. -nohidden return name[0] == '.' && strcmp(name, ".") != 0 && strcmp(name, "..") != 0; } /** * -inum test. */ bool eval_inum(const struct expr *expr, struct eval_state *state) { const struct bfs_stat *statbuf = eval_stat(state); if (!statbuf) { return false; } return expr_cmp(expr, statbuf->ino); } /** * -links test. */ bool eval_links(const struct expr *expr, struct eval_state *state) { const struct bfs_stat *statbuf = eval_stat(state); if (!statbuf) { return false; } return expr_cmp(expr, statbuf->nlink); } /** * -i?lname test. */ bool eval_lname(const struct expr *expr, struct eval_state *state) { bool ret = false; char *name = NULL; const struct BFTW *ftwbuf = state->ftwbuf; if (ftwbuf->type != BFS_LNK) { goto done; } const struct bfs_stat *statbuf = bftw_cached_stat(ftwbuf, BFS_STAT_NOFOLLOW); size_t len = statbuf ? statbuf->size : 0; name = xreadlinkat(ftwbuf->at_fd, ftwbuf->at_path, len); if (!name) { eval_report_error(state); goto done; } ret = fnmatch(expr->sdata, name, expr->idata) == 0; done: free(name); return ret; } /** * -i?name test. */ bool eval_name(const struct expr *expr, struct eval_state *state) { const struct BFTW *ftwbuf = state->ftwbuf; const char *name = ftwbuf->path + ftwbuf->nameoff; char *copy = NULL; if (ftwbuf->depth == 0) { // Any trailing slashes are not part of the name. This can only // happen for the root path. const char *slash = strchr(name, '/'); if (slash && slash > name) { copy = strndup(name, slash - name); if (!copy) { eval_report_error(state); return false; } name = copy; } } bool ret = fnmatch(expr->sdata, name, expr->idata) == 0; free(copy); return ret; } /** * -i?path test. */ bool eval_path(const struct expr *expr, struct eval_state *state) { const struct BFTW *ftwbuf = state->ftwbuf; return fnmatch(expr->sdata, ftwbuf->path, expr->idata) == 0; } /** * -perm test. */ bool eval_perm(const struct expr *expr, struct eval_state *state) { const struct bfs_stat *statbuf = eval_stat(state); if (!statbuf) { return false; } mode_t mode = statbuf->mode; mode_t target; if (state->ftwbuf->type == BFS_DIR) { target = expr->dir_mode; } else { target = expr->file_mode; } switch (expr->mode_cmp) { case MODE_EXACT: return (mode & 07777) == target; case MODE_ALL: return (mode & target) == target; case MODE_ANY: return !(mode & target) == !target; } assert(!"Invalid comparison mode"); return false; } /** * -f?ls action. */ bool eval_fls(const struct expr *expr, struct eval_state *state) { CFILE *cfile = expr->cfile; FILE *file = cfile->file; const struct bfs_users *users = bfs_ctx_users(state->ctx); const struct bfs_groups *groups = bfs_ctx_groups(state->ctx); const struct BFTW *ftwbuf = state->ftwbuf; const struct bfs_stat *statbuf = eval_stat(state); if (!statbuf) { goto done; } uintmax_t ino = statbuf->ino; uintmax_t block_size = state->ctx->posixly_correct ? 512 : 1024; uintmax_t blocks = ((uintmax_t)statbuf->blocks*BFS_STAT_BLKSIZE + block_size - 1)/block_size; char mode[11]; xstrmode(statbuf->mode, mode); char acl = bfs_check_acl(ftwbuf) > 0 ? '+' : ' '; uintmax_t nlink = statbuf->nlink; if (fprintf(file, "%9ju %6ju %s%c %2ju", ino, blocks, mode, acl, nlink) < 0) { goto error; } uintmax_t uid = statbuf->uid; const struct passwd *pwd = users ? bfs_getpwuid(users, uid) : NULL; if (pwd) { if (fprintf(file, " %-8s", pwd->pw_name) < 0) { goto error; } } else { if (fprintf(file, " %-8ju", uid) < 0) { goto error; } } uintmax_t gid = statbuf->gid; const struct group *grp = groups ? bfs_getgrgid(groups, gid) : NULL; if (grp) { if (fprintf(file, " %-8s", grp->gr_name) < 0) { goto error; } } else { if (fprintf(file, " %-8ju", gid) < 0) { goto error; } } if (ftwbuf->type == BFS_BLK || ftwbuf->type == BFS_CHR) { int ma = bfs_major(statbuf->rdev); int mi = bfs_minor(statbuf->rdev); if (fprintf(file, " %3d, %3d", ma, mi) < 0) { goto error; } } else { uintmax_t size = statbuf->size; if (fprintf(file, " %8ju", size) < 0) { goto error; } } time_t time = statbuf->mtime.tv_sec; time_t now = expr->reftime.tv_sec; time_t six_months_ago = now - 6*30*24*60*60; time_t tomorrow = now + 24*60*60; struct tm tm; if (xlocaltime(&time, &tm) != 0) { goto error; } char time_str[256]; const char *time_format = "%b %e %H:%M"; if (time <= six_months_ago || time >= tomorrow) { time_format = "%b %e %Y"; } if (!strftime(time_str, sizeof(time_str), time_format, &tm)) { errno = EOVERFLOW; goto error; } if (fprintf(file, " %s", time_str) < 0) { goto error; } if (cfprintf(cfile, " %pP", ftwbuf) < 0) { goto error; } if (ftwbuf->type == BFS_LNK) { if (cfprintf(cfile, " -> %pL", ftwbuf) < 0) { goto error; } } if (fputc('\n', file) == EOF) { goto error; } done: return true; error: eval_report_error(state); return true; } /** * -f?print action. */ bool eval_fprint(const struct expr *expr, struct eval_state *state) { if (cfprintf(expr->cfile, "%pP\n", state->ftwbuf) < 0) { eval_report_error(state); } return true; } /** * -f?print0 action. */ bool eval_fprint0(const struct expr *expr, struct eval_state *state) { const char *path = state->ftwbuf->path; size_t length = strlen(path) + 1; if (fwrite(path, 1, length, expr->cfile->file) != length) { eval_report_error(state); } return true; } /** * -f?printf action. */ bool eval_fprintf(const struct expr *expr, struct eval_state *state) { if (bfs_printf(expr->cfile, expr->printf, state->ftwbuf) != 0) { eval_report_error(state); } return true; } /** * -printx action. */ bool eval_fprintx(const struct expr *expr, struct eval_state *state) { FILE *file = expr->cfile->file; const char *path = state->ftwbuf->path; while (true) { size_t span = strcspn(path, " \t\n\\$'\"`"); if (fwrite(path, 1, span, file) != span) { goto error; } path += span; char c = path[0]; if (!c) { break; } char escaped[] = {'\\', c}; if (fwrite(escaped, 1, sizeof(escaped), file) != sizeof(escaped)) { goto error; } ++path; } if (fputc('\n', file) == EOF) { goto error; } return true; error: eval_report_error(state); return true; } /** * -prune action. */ bool eval_prune(const struct expr *expr, struct eval_state *state) { state->action = BFTW_PRUNE; return true; } /** * -quit action. */ bool eval_quit(const struct expr *expr, struct eval_state *state) { state->action = BFTW_STOP; state->quit = true; return true; } /** * -i?regex test. */ bool eval_regex(const struct expr *expr, struct eval_state *state) { const char *path = state->ftwbuf->path; size_t len = strlen(path); regmatch_t match = { .rm_so = 0, .rm_eo = len, }; int flags = 0; #ifdef REG_STARTEND flags |= REG_STARTEND; #endif int err = regexec(expr->regex, path, 1, &match, flags); if (err == 0) { return match.rm_so == 0 && (size_t)match.rm_eo == len; } else if (err != REG_NOMATCH) { char *str = xregerror(err, expr->regex); if (str) { eval_error(state, "%s.\n", str); free(str); } else { eval_error(state, "xregerror(): %m.\n"); } *state->ret = EXIT_FAILURE; } return false; } /** * -samefile test. */ bool eval_samefile(const struct expr *expr, struct eval_state *state) { const struct bfs_stat *statbuf = eval_stat(state); if (!statbuf) { return false; } return statbuf->dev == expr->dev && statbuf->ino == expr->ino; } /** * -size test. */ bool eval_size(const struct expr *expr, struct eval_state *state) { const struct bfs_stat *statbuf = eval_stat(state); if (!statbuf) { return false; } static const off_t scales[] = { [SIZE_BLOCKS] = 512, [SIZE_BYTES] = 1, [SIZE_WORDS] = 2, [SIZE_KB] = 1LL << 10, [SIZE_MB] = 1LL << 20, [SIZE_GB] = 1LL << 30, [SIZE_TB] = 1LL << 40, [SIZE_PB] = 1LL << 50, }; off_t scale = scales[expr->size_unit]; off_t size = (statbuf->size + scale - 1)/scale; // Round up return expr_cmp(expr, size); } /** * -sparse test. */ bool eval_sparse(const struct expr *expr, struct eval_state *state) { const struct bfs_stat *statbuf = eval_stat(state); if (!statbuf) { return false; } blkcnt_t expected = (statbuf->size + BFS_STAT_BLKSIZE - 1)/BFS_STAT_BLKSIZE; return statbuf->blocks < expected; } /** * -type test. */ bool eval_type(const struct expr *expr, struct eval_state *state) { return (1 << state->ftwbuf->type) & expr->idata; } /** * -xattr test. */ bool eval_xattr(const struct expr *expr, struct eval_state *state) { int ret = bfs_check_xattrs(state->ftwbuf); if (ret >= 0) { return ret; } else { eval_report_error(state); return false; } } /** * -xattr test. */ bool eval_xattrname(const struct expr *expr, struct eval_state *state) { int ret = bfs_check_xattr_named(state->ftwbuf, expr->sdata); if (ret >= 0) { return ret; } else { eval_report_error(state); return false; } } /** * -xtype test. */ bool eval_xtype(const struct expr *expr, struct eval_state *state) { const struct BFTW *ftwbuf = state->ftwbuf; enum bfs_stat_flags flags = ftwbuf->stat_flags ^ (BFS_STAT_NOFOLLOW | BFS_STAT_TRYFOLLOW); enum bfs_type type = bftw_type(ftwbuf, flags); if (type == BFS_ERROR) { eval_report_error(state); return false; } else { return (1 << type) & expr->idata; } } #if _POSIX_MONOTONIC_CLOCK > 0 # define BFS_CLOCK CLOCK_MONOTONIC #elif _POSIX_TIMERS > 0 # define BFS_CLOCK CLOCK_REALTIME #endif /** * Call clock_gettime(), if available. */ static int eval_gettime(struct eval_state *state, struct timespec *ts) { #ifdef BFS_CLOCK int ret = clock_gettime(BFS_CLOCK, ts); if (ret != 0) { bfs_warning(state->ctx, "%pP: clock_gettime(): %m.\n", state->ftwbuf); } return ret; #else return -1; #endif } /** * Record an elapsed time. */ static void timespec_elapsed(struct timespec *elapsed, const struct timespec *start, const struct timespec *end) { elapsed->tv_sec += end->tv_sec - start->tv_sec; elapsed->tv_nsec += end->tv_nsec - start->tv_nsec; if (elapsed->tv_nsec < 0) { elapsed->tv_nsec += 1000000000L; --elapsed->tv_sec; } else if (elapsed->tv_nsec >= 1000000000L) { elapsed->tv_nsec -= 1000000000L; ++elapsed->tv_sec; } } /** * Evaluate an expression. */ static bool eval_expr(struct expr *expr, struct eval_state *state) { struct timespec start, end; bool time = state->ctx->debug & DEBUG_RATES; if (time) { if (eval_gettime(state, &start) != 0) { time = false; } } assert(!state->quit); bool ret = expr->eval(expr, state); if (time) { if (eval_gettime(state, &end) == 0) { timespec_elapsed(&expr->elapsed, &start, &end); } } ++expr->evaluations; if (ret) { ++expr->successes; } if (expr_never_returns(expr)) { assert(state->quit); } else if (!state->quit) { assert(!expr->always_true || ret); assert(!expr->always_false || !ret); } return ret; } /** * Evaluate a negation. */ bool eval_not(const struct expr *expr, struct eval_state *state) { return !eval_expr(expr->rhs, state); } /** * Evaluate a conjunction. */ bool eval_and(const struct expr *expr, struct eval_state *state) { if (!eval_expr(expr->lhs, state)) { return false; } if (state->quit) { return false; } return eval_expr(expr->rhs, state); } /** * Evaluate a disjunction. */ bool eval_or(const struct expr *expr, struct eval_state *state) { if (eval_expr(expr->lhs, state)) { return true; } if (state->quit) { return false; } return eval_expr(expr->rhs, state); } /** * Evaluate the comma operator. */ bool eval_comma(const struct expr *expr, struct eval_state *state) { eval_expr(expr->lhs, state); if (state->quit) { return false; } return eval_expr(expr->rhs, state); } /** Update the status bar. */ static void eval_status(struct eval_state *state, struct bfs_bar *bar, struct timespec *last_status, size_t count) { struct timespec now; if (eval_gettime(state, &now) == 0) { struct timespec elapsed = {0}; timespec_elapsed(&elapsed, last_status, &now); // Update every 0.1s if (elapsed.tv_sec > 0 || elapsed.tv_nsec >= 100000000L) { *last_status = now; } else { return; } } size_t width = bfs_bar_width(bar); if (width < 3) { return; } const struct BFTW *ftwbuf = state->ftwbuf; char *rhs = dstrprintf(" (visited: %zu, depth: %2zu)", count, ftwbuf->depth); if (!rhs) { return; } size_t rhslen = dstrlen(rhs); if (3 + rhslen > width) { dstresize(&rhs, 0); rhslen = 0; } char *status = dstralloc(0); if (!status) { goto out_rhs; } const char *path = ftwbuf->path; size_t pathlen = ftwbuf->nameoff; if (ftwbuf->depth == 0) { pathlen = strlen(path); } // Try to make sure even wide characters fit in the status bar size_t pathmax = width - rhslen - 3; size_t pathwidth = 0; mbstate_t mb; memset(&mb, 0, sizeof(mb)); while (pathlen > 0) { wchar_t wc; size_t len = mbrtowc(&wc, path, pathlen, &mb); int cwidth; if (len == (size_t)-1) { // Invalid byte sequence, assume a single-width '?' len = 1; cwidth = 1; memset(&mb, 0, sizeof(mb)); } else if (len == (size_t)-2) { // Incomplete byte sequence, assume a single-width '?' len = pathlen; cwidth = 1; } else { cwidth = wcwidth(wc); if (cwidth < 0) { cwidth = 0; } } if (pathwidth + cwidth > pathmax) { break; } if (dstrncat(&status, path, len) != 0) { goto out_rhs; } path += len; pathlen -= len; pathwidth += cwidth; } if (dstrcat(&status, "...") != 0) { goto out_rhs; } while (pathwidth < pathmax) { if (dstrapp(&status, ' ') != 0) { goto out_rhs; } ++pathwidth; } if (dstrcat(&status, rhs) != 0) { goto out_rhs; } bfs_bar_update(bar, status); dstrfree(status); out_rhs: dstrfree(rhs); } /** Check if we've seen a file before. */ static bool eval_file_unique(struct eval_state *state, struct trie *seen) { const struct bfs_stat *statbuf = eval_stat(state); if (!statbuf) { return false; } bfs_file_id id; bfs_stat_id(statbuf, &id); struct trie_leaf *leaf = trie_insert_mem(seen, id, sizeof(id)); if (!leaf) { eval_report_error(state); return false; } if (leaf->value) { state->action = BFTW_PRUNE; return false; } else { leaf->value = leaf; return true; } } #define DEBUG_FLAG(flags, flag) \ do { \ if ((flags & flag) || flags == flag) { \ fputs(#flag, stderr); \ flags ^= flag; \ if (flags) { \ fputs(" | ", stderr); \ } \ } \ } while (0) /** * Log a stat() call. */ static void debug_stat(const struct bfs_ctx *ctx, const struct BFTW *ftwbuf, const struct bftw_stat *cache, enum bfs_stat_flags flags) { bfs_debug_prefix(ctx, DEBUG_STAT); fprintf(stderr, "bfs_stat("); if (ftwbuf->at_fd == AT_FDCWD) { fprintf(stderr, "AT_FDCWD"); } else { size_t baselen = strlen(ftwbuf->path) - strlen(ftwbuf->at_path); fprintf(stderr, "\""); fwrite(ftwbuf->path, 1, baselen, stderr); fprintf(stderr, "\""); } fprintf(stderr, ", \"%s\", ", ftwbuf->at_path); DEBUG_FLAG(flags, BFS_STAT_FOLLOW); DEBUG_FLAG(flags, BFS_STAT_NOFOLLOW); DEBUG_FLAG(flags, BFS_STAT_TRYFOLLOW); fprintf(stderr, ") == %d", cache->buf ? 0 : -1); if (cache->error) { fprintf(stderr, " [%d]", cache->error); } fprintf(stderr, "\n"); } /** * Log any stat() calls that happened. */ static void debug_stats(const struct bfs_ctx *ctx, const struct BFTW *ftwbuf) { if (!(ctx->debug & DEBUG_STAT)) { return; } const struct bfs_stat *statbuf = ftwbuf->stat_cache.buf; if (statbuf || ftwbuf->stat_cache.error) { debug_stat(ctx, ftwbuf, &ftwbuf->stat_cache, BFS_STAT_FOLLOW); } const struct bfs_stat *lstatbuf = ftwbuf->lstat_cache.buf; if ((lstatbuf && lstatbuf != statbuf) || ftwbuf->lstat_cache.error) { debug_stat(ctx, ftwbuf, &ftwbuf->lstat_cache, BFS_STAT_NOFOLLOW); } } #define DUMP_MAP(value) [value] = #value /** * Dump the bfs_type for -D search. */ static const char *dump_bfs_type(enum bfs_type type) { static const char *types[] = { DUMP_MAP(BFS_UNKNOWN), DUMP_MAP(BFS_BLK), DUMP_MAP(BFS_CHR), DUMP_MAP(BFS_DIR), DUMP_MAP(BFS_DOOR), DUMP_MAP(BFS_FIFO), DUMP_MAP(BFS_LNK), DUMP_MAP(BFS_PORT), DUMP_MAP(BFS_REG), DUMP_MAP(BFS_SOCK), DUMP_MAP(BFS_WHT), }; if (type == BFS_ERROR) { return "BFS_ERROR"; } else { return types[type]; } } /** * Dump the bftw_visit for -D search. */ static const char *dump_bftw_visit(enum bftw_visit visit) { static const char *visits[] = { DUMP_MAP(BFTW_PRE), DUMP_MAP(BFTW_POST), }; return visits[visit]; } /** * Dump the bftw_action for -D search. */ static const char *dump_bftw_action(enum bftw_action action) { static const char *actions[] = { DUMP_MAP(BFTW_CONTINUE), DUMP_MAP(BFTW_PRUNE), DUMP_MAP(BFTW_STOP), }; return actions[action]; } /** * Type passed as the argument to the bftw() callback. */ struct callback_args { /** The bfs context. */ const struct bfs_ctx *ctx; /** The status bar. */ struct bfs_bar *bar; /** The time of the last status update. */ struct timespec last_status; /** The number of files visited so far. */ size_t count; /** The set of seen files. */ struct trie *seen; /** Eventual return value from bfs_eval(). */ int ret; }; /** * bftw() callback. */ static enum bftw_action eval_callback(const struct BFTW *ftwbuf, void *ptr) { struct callback_args *args = ptr; ++args->count; const struct bfs_ctx *ctx = args->ctx; struct eval_state state; state.ftwbuf = ftwbuf; state.ctx = ctx; state.action = BFTW_CONTINUE; state.ret = &args->ret; state.quit = false; if (args->bar) { eval_status(&state, args->bar, &args->last_status, args->count); } if (ftwbuf->type == BFS_ERROR) { if (!eval_should_ignore(&state, ftwbuf->error)) { eval_error(&state, "%s.\n", strerror(ftwbuf->error)); } state.action = BFTW_PRUNE; goto done; } if (ctx->unique && ftwbuf->visit == BFTW_PRE) { if (!eval_file_unique(&state, args->seen)) { goto done; } } if (eval_expr(ctx->exclude, &state)) { state.action = BFTW_PRUNE; goto done; } if (ctx->xargs_safe && strpbrk(ftwbuf->path, " \t\n\'\"\\")) { eval_error(&state, "Path is not safe for xargs.\n"); state.action = BFTW_PRUNE; goto done; } if (ctx->maxdepth < 0 || ftwbuf->depth >= (size_t)ctx->maxdepth) { state.action = BFTW_PRUNE; } // In -depth mode, only handle directories on the BFTW_POST visit enum bftw_visit expected_visit = BFTW_PRE; if ((ctx->flags & BFTW_POST_ORDER) && (ctx->strategy == BFTW_IDS || ftwbuf->type == BFS_DIR) && ftwbuf->depth < (size_t)ctx->maxdepth) { expected_visit = BFTW_POST; } if (ftwbuf->visit == expected_visit && ftwbuf->depth >= (size_t)ctx->mindepth && ftwbuf->depth <= (size_t)ctx->maxdepth) { eval_expr(ctx->expr, &state); } done: debug_stats(ctx, ftwbuf); if (bfs_debug(ctx, DEBUG_SEARCH, "eval_callback({\n")) { fprintf(stderr, "\t.path = \"%s\",\n", ftwbuf->path); fprintf(stderr, "\t.root = \"%s\",\n", ftwbuf->root); fprintf(stderr, "\t.depth = %zu,\n", ftwbuf->depth); fprintf(stderr, "\t.visit = %s,\n", dump_bftw_visit(ftwbuf->visit)); fprintf(stderr, "\t.type = %s,\n", dump_bfs_type(ftwbuf->type)); fprintf(stderr, "\t.error = %d,\n", ftwbuf->error); fprintf(stderr, "}) == %s\n", dump_bftw_action(state.action)); } return state.action; } /** Check if an rlimit value is infinite. */ static bool rlim_isinf(rlim_t r) { // Consider RLIM_{INFINITY,SAVED_{CUR,MAX}} all equally infinite if (r == RLIM_INFINITY) { return true; } #ifdef RLIM_SAVED_CUR if (r == RLIM_SAVED_CUR) { return true; } #endif #ifdef RLIM_SAVED_MAX if (r == RLIM_SAVED_MAX) { return true; } #endif return false; } /** Compare two rlimit values, accounting for RLIM_INFINITY etc. */ static int rlim_cmp(rlim_t a, rlim_t b) { bool a_inf = rlim_isinf(a); bool b_inf = rlim_isinf(b); if (a_inf || b_inf) { return a_inf - b_inf; } return (a > b) - (a < b); } /** Raise RLIMIT_NOFILE if possible, and return the new limit. */ static int raise_fdlimit(const struct bfs_ctx *ctx) { rlim_t target = 64 << 10; if (rlim_cmp(target, ctx->nofile_hard) > 0) { target = ctx->nofile_hard; } int ret = target; if (rlim_cmp(target, ctx->nofile_soft) > 0) { const struct rlimit rl = { .rlim_cur = target, .rlim_max = ctx->nofile_hard, }; if (setrlimit(RLIMIT_NOFILE, &rl) != 0) { ret = ctx->nofile_soft; } } return ret; } /** Infer the number of file descriptors available to bftw(). */ static int infer_fdlimit(const struct bfs_ctx *ctx, int limit) { // 3 for std{in,out,err} int nopen = 3 + ctx->nfiles; // Check /proc/self/fd for the current number of open fds, if possible // (we may have inherited more than just the standard ones) struct bfs_dir *dir = bfs_opendir(AT_FDCWD, "/proc/self/fd"); if (!dir) { dir = bfs_opendir(AT_FDCWD, "/dev/fd"); } if (dir) { // Account for 'dir' itself nopen = -1; while (bfs_readdir(dir, NULL) > 0) { ++nopen; } bfs_closedir(dir); } int ret = limit - nopen; ret -= ctx->expr->persistent_fds; ret -= ctx->expr->ephemeral_fds; // bftw() needs at least 2 available fds if (ret < 2) { ret = 2; } return ret; } /** * Dump the bftw() flags for -D search. */ static void dump_bftw_flags(enum bftw_flags flags) { DEBUG_FLAG(flags, 0); DEBUG_FLAG(flags, BFTW_STAT); DEBUG_FLAG(flags, BFTW_RECOVER); DEBUG_FLAG(flags, BFTW_POST_ORDER); DEBUG_FLAG(flags, BFTW_FOLLOW_ROOTS); DEBUG_FLAG(flags, BFTW_FOLLOW_ALL); DEBUG_FLAG(flags, BFTW_DETECT_CYCLES); DEBUG_FLAG(flags, BFTW_SKIP_MOUNTS); DEBUG_FLAG(flags, BFTW_PRUNE_MOUNTS); DEBUG_FLAG(flags, BFTW_SORT); assert(!flags); } /** * Dump the bftw_strategy for -D search. */ static const char *dump_bftw_strategy(enum bftw_strategy strategy) { static const char *strategies[] = { DUMP_MAP(BFTW_BFS), DUMP_MAP(BFTW_DFS), DUMP_MAP(BFTW_IDS), DUMP_MAP(BFTW_EDS), }; return strategies[strategy]; } int bfs_eval(const struct bfs_ctx *ctx) { if (!ctx->expr) { return EXIT_SUCCESS; } struct callback_args args = { .ctx = ctx, .ret = EXIT_SUCCESS, }; if (ctx->status) { args.bar = bfs_bar_show(); if (!args.bar) { bfs_warning(ctx, "Couldn't show status bar: %m.\n\n"); } } struct trie seen; if (ctx->unique) { trie_init(&seen); args.seen = &seen; } int fdlimit = raise_fdlimit(ctx); fdlimit = infer_fdlimit(ctx, fdlimit); struct bftw_args bftw_args = { .paths = ctx->paths, .npaths = darray_length(ctx->paths), .callback = eval_callback, .ptr = &args, .nopenfd = fdlimit, .flags = ctx->flags, .strategy = ctx->strategy, .mtab = bfs_ctx_mtab(ctx), }; if (bfs_debug(ctx, DEBUG_SEARCH, "bftw({\n")) { fprintf(stderr, "\t.paths = {\n"); for (size_t i = 0; i < bftw_args.npaths; ++i) { fprintf(stderr, "\t\t\"%s\",\n", bftw_args.paths[i]); } fprintf(stderr, "\t},\n"); fprintf(stderr, "\t.npaths = %zu,\n", bftw_args.npaths); fprintf(stderr, "\t.callback = eval_callback,\n"); fprintf(stderr, "\t.ptr = &args,\n"); fprintf(stderr, "\t.nopenfd = %d,\n", bftw_args.nopenfd); fprintf(stderr, "\t.flags = "); dump_bftw_flags(bftw_args.flags); fprintf(stderr, ",\n\t.strategy = %s,\n", dump_bftw_strategy(bftw_args.strategy)); fprintf(stderr, "\t.mtab = "); if (bftw_args.mtab) { fprintf(stderr, "ctx->mtab"); } else { fprintf(stderr, "NULL"); } fprintf(stderr, ",\n})\n"); } if (bftw(&bftw_args) != 0) { args.ret = EXIT_FAILURE; bfs_perror(ctx, "bftw()"); } if (eval_exec_finish(ctx->expr, ctx) != 0) { args.ret = EXIT_FAILURE; } bfs_ctx_dump(ctx, DEBUG_RATES); if (ctx->unique) { trie_destroy(&seen); } bfs_bar_hide(args.bar); return args.ret; } bfs-2.3.1/eval.h000066400000000000000000000117211417254370000133740ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2015-2018 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * The evaluation functions that implement literal expressions like -name, * -print, etc. */ #ifndef BFS_EVAL_H #define BFS_EVAL_H #include struct bfs_ctx; struct expr; /** * Ephemeral state for evaluating an expression. */ struct eval_state; /** * Expression evaluation function. * * @param expr * The current expression. * @param state * The current evaluation state. * @return * The result of the test. */ typedef bool eval_fn(const struct expr *expr, struct eval_state *state); /** * Evaluate the command line. * * @param ctx * The bfs context to evaluate. * @return * EXIT_SUCCESS on success, otherwise on failure. */ int bfs_eval(const struct bfs_ctx *ctx); // Predicate evaluation functions bool eval_true(const struct expr *expr, struct eval_state *state); bool eval_false(const struct expr *expr, struct eval_state *state); bool eval_access(const struct expr *expr, struct eval_state *state); bool eval_acl(const struct expr *expr, struct eval_state *state); bool eval_capable(const struct expr *expr, struct eval_state *state); bool eval_perm(const struct expr *expr, struct eval_state *state); bool eval_xattr(const struct expr *expr, struct eval_state *state); bool eval_xattrname(const struct expr *expr, struct eval_state *state); bool eval_newer(const struct expr *expr, struct eval_state *state); bool eval_time(const struct expr *expr, struct eval_state *state); bool eval_used(const struct expr *expr, struct eval_state *state); bool eval_gid(const struct expr *expr, struct eval_state *state); bool eval_uid(const struct expr *expr, struct eval_state *state); bool eval_nogroup(const struct expr *expr, struct eval_state *state); bool eval_nouser(const struct expr *expr, struct eval_state *state); bool eval_depth(const struct expr *expr, struct eval_state *state); bool eval_empty(const struct expr *expr, struct eval_state *state); bool eval_flags(const struct expr *expr, struct eval_state *state); bool eval_fstype(const struct expr *expr, struct eval_state *state); bool eval_hidden(const struct expr *expr, struct eval_state *state); bool eval_inum(const struct expr *expr, struct eval_state *state); bool eval_links(const struct expr *expr, struct eval_state *state); bool eval_samefile(const struct expr *expr, struct eval_state *state); bool eval_size(const struct expr *expr, struct eval_state *state); bool eval_sparse(const struct expr *expr, struct eval_state *state); bool eval_type(const struct expr *expr, struct eval_state *state); bool eval_xtype(const struct expr *expr, struct eval_state *state); bool eval_lname(const struct expr *expr, struct eval_state *state); bool eval_name(const struct expr *expr, struct eval_state *state); bool eval_path(const struct expr *expr, struct eval_state *state); bool eval_regex(const struct expr *expr, struct eval_state *state); bool eval_delete(const struct expr *expr, struct eval_state *state); bool eval_exec(const struct expr *expr, struct eval_state *state); bool eval_exit(const struct expr *expr, struct eval_state *state); bool eval_fls(const struct expr *expr, struct eval_state *state); bool eval_fprint(const struct expr *expr, struct eval_state *state); bool eval_fprint0(const struct expr *expr, struct eval_state *state); bool eval_fprintf(const struct expr *expr, struct eval_state *state); bool eval_fprintx(const struct expr *expr, struct eval_state *state); bool eval_prune(const struct expr *expr, struct eval_state *state); bool eval_quit(const struct expr *expr, struct eval_state *state); // Operator evaluation functions bool eval_not(const struct expr *expr, struct eval_state *state); bool eval_and(const struct expr *expr, struct eval_state *state); bool eval_or(const struct expr *expr, struct eval_state *state); bool eval_comma(const struct expr *expr, struct eval_state *state); #endif // BFS_EVAL_H bfs-2.3.1/exec.c000066400000000000000000000424261417254370000133720ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2017-2022 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "exec.h" #include "bftw.h" #include "ctx.h" #include "color.h" #include "diag.h" #include "dstring.h" #include "spawn.h" #include "util.h" #include #include #include #include #include #include #include #include #include #include #include /** Print some debugging info. */ BFS_FORMATTER(2, 3) static void bfs_exec_debug(const struct bfs_exec *execbuf, const char *format, ...) { const struct bfs_ctx *ctx = execbuf->ctx; if (!bfs_debug(ctx, DEBUG_EXEC, "${blu}")) { return; } if (execbuf->flags & BFS_EXEC_CONFIRM) { fputs("-ok", stderr); } else { fputs("-exec", stderr); } if (execbuf->flags & BFS_EXEC_CHDIR) { fputs("dir", stderr); } cfprintf(ctx->cerr, "${rs}: "); va_list args; va_start(args, format); vfprintf(stderr, format, args); va_end(args); } /** Determine the size of a single argument, for comparison to arg_max. */ static size_t bfs_exec_arg_size(const char *arg) { return sizeof(arg) + strlen(arg) + 1; } /** Even if we can pass a bigger argument list, cap it here. */ #define BFS_EXEC_ARG_MAX (16 << 20) /** Determine the maximum argv size. */ static size_t bfs_exec_arg_max(const struct bfs_exec *execbuf) { long arg_max = sysconf(_SC_ARG_MAX); bfs_exec_debug(execbuf, "ARG_MAX: %ld according to sysconf()\n", arg_max); if (arg_max < 0) { arg_max = BFS_EXEC_ARG_MAX; bfs_exec_debug(execbuf, "ARG_MAX: %ld assumed\n", arg_max); } // We have to share space with the environment variables extern char **environ; for (char **envp = environ; *envp; ++envp) { arg_max -= bfs_exec_arg_size(*envp); } // Account for the terminating NULL entry arg_max -= sizeof(char *); bfs_exec_debug(execbuf, "ARG_MAX: %ld remaining after environment variables\n", arg_max); // Account for the fixed arguments for (size_t i = 0; i < execbuf->tmpl_argc - 1; ++i) { arg_max -= bfs_exec_arg_size(execbuf->tmpl_argv[i]); } // Account for the terminating NULL entry arg_max -= sizeof(char *); bfs_exec_debug(execbuf, "ARG_MAX: %ld remaining after fixed arguments\n", arg_max); // Assume arguments are counted with the granularity of a single page, // so allow a one page cushion to account for rounding up long page_size = sysconf(_SC_PAGESIZE); if (page_size < 4096) { page_size = 4096; } arg_max -= page_size; bfs_exec_debug(execbuf, "ARG_MAX: %ld remaining after page cushion\n", arg_max); // POSIX recommends an additional 2048 bytes of headroom arg_max -= 2048; bfs_exec_debug(execbuf, "ARG_MAX: %ld remaining after headroom\n", arg_max); if (arg_max < 0) { arg_max = 0; } else if (arg_max > BFS_EXEC_ARG_MAX) { arg_max = BFS_EXEC_ARG_MAX; } bfs_exec_debug(execbuf, "ARG_MAX: %ld final value\n", arg_max); return arg_max; } struct bfs_exec *bfs_exec_parse(const struct bfs_ctx *ctx, char **argv, enum bfs_exec_flags flags) { struct bfs_exec *execbuf = malloc(sizeof(*execbuf)); if (!execbuf) { bfs_perror(ctx, "malloc()"); goto fail; } execbuf->flags = flags; execbuf->ctx = ctx; execbuf->argv = NULL; execbuf->argc = 0; execbuf->argv_cap = 0; execbuf->arg_size = 0; execbuf->arg_max = 0; execbuf->arg_min = 0; execbuf->wd_fd = -1; execbuf->wd_path = NULL; execbuf->wd_len = 0; execbuf->ret = 0; size_t i; for (i = 1; ; ++i) { const char *arg = argv[i]; if (!arg) { if (execbuf->flags & BFS_EXEC_CONFIRM) { bfs_error(ctx, "%s: Expected '... ;'.\n", argv[0]); } else { bfs_error(ctx, "%s: Expected '... ;' or '... {} +'.\n", argv[0]); } goto fail; } else if (strcmp(arg, ";") == 0) { break; } else if (strcmp(arg, "+") == 0) { if (!(execbuf->flags & BFS_EXEC_CONFIRM) && strcmp(argv[i - 1], "{}") == 0) { execbuf->flags |= BFS_EXEC_MULTI; break; } } } execbuf->tmpl_argv = argv + 1; execbuf->tmpl_argc = i - 1; if (execbuf->tmpl_argc == 0) { bfs_error(ctx, "%s: Missing command.\n", argv[0]); goto fail; } execbuf->argv_cap = execbuf->tmpl_argc + 1; execbuf->argv = malloc(execbuf->argv_cap*sizeof(*execbuf->argv)); if (!execbuf->argv) { bfs_perror(ctx, "malloc()"); goto fail; } if (execbuf->flags & BFS_EXEC_MULTI) { for (i = 0; i < execbuf->tmpl_argc - 1; ++i) { char *arg = execbuf->tmpl_argv[i]; if (strstr(arg, "{}")) { bfs_error(ctx, "%s ... +: Only one '{}' is supported.\n", argv[0]); goto fail; } execbuf->argv[i] = arg; } execbuf->argc = execbuf->tmpl_argc - 1; execbuf->arg_max = bfs_exec_arg_max(execbuf); execbuf->arg_min = execbuf->arg_max; } return execbuf; fail: bfs_exec_free(execbuf); return NULL; } /** Format the current path for use as a command line argument. */ static char *bfs_exec_format_path(const struct bfs_exec *execbuf, const struct BFTW *ftwbuf) { if (!(execbuf->flags & BFS_EXEC_CHDIR)) { return strdup(ftwbuf->path); } const char *name = ftwbuf->path + ftwbuf->nameoff; if (name[0] == '/') { // Must be a root path ("/", "//", etc.) return strdup(name); } // For compatibility with GNU find, use './name' instead of just 'name' char *path = malloc(2 + strlen(name) + 1); if (!path) { return NULL; } strcpy(path, "./"); strcpy(path + 2, name); return path; } /** Format an argument, expanding "{}" to the current path. */ static char *bfs_exec_format_arg(char *arg, const char *path) { char *match = strstr(arg, "{}"); if (!match) { return arg; } char *ret = dstralloc(0); if (!ret) { return NULL; } char *last = arg; do { if (dstrncat(&ret, last, match - last) != 0) { goto err; } if (dstrcat(&ret, path) != 0) { goto err; } last = match + 2; match = strstr(last, "{}"); } while (match); if (dstrcat(&ret, last) != 0) { goto err; } return ret; err: dstrfree(ret); return NULL; } /** Free a formatted argument. */ static void bfs_exec_free_arg(char *arg, const char *tmpl) { if (arg != tmpl) { dstrfree(arg); } } /** Open a file to use as the working directory. */ static int bfs_exec_openwd(struct bfs_exec *execbuf, const struct BFTW *ftwbuf) { assert(execbuf->wd_fd < 0); assert(!execbuf->wd_path); if (ftwbuf->at_fd != AT_FDCWD) { // Rely on at_fd being the immediate parent assert(ftwbuf->at_path == xbasename(ftwbuf->at_path)); execbuf->wd_fd = ftwbuf->at_fd; if (!(execbuf->flags & BFS_EXEC_MULTI)) { return 0; } execbuf->wd_fd = dup_cloexec(execbuf->wd_fd); if (execbuf->wd_fd < 0) { return -1; } } execbuf->wd_len = ftwbuf->nameoff; if (execbuf->wd_len == 0) { if (ftwbuf->path[0] == '/') { ++execbuf->wd_len; } else { // The path is something like "foo", so we're already in the right directory return 0; } } execbuf->wd_path = strndup(ftwbuf->path, execbuf->wd_len); if (!execbuf->wd_path) { return -1; } if (execbuf->wd_fd < 0) { execbuf->wd_fd = open(execbuf->wd_path, O_RDONLY | O_CLOEXEC | O_DIRECTORY); } if (execbuf->wd_fd < 0) { return -1; } return 0; } /** Close the working directory. */ static void bfs_exec_closewd(struct bfs_exec *execbuf, const struct BFTW *ftwbuf) { if (execbuf->wd_fd >= 0) { if (!ftwbuf || execbuf->wd_fd != ftwbuf->at_fd) { xclose(execbuf->wd_fd); } execbuf->wd_fd = -1; } if (execbuf->wd_path) { free(execbuf->wd_path); execbuf->wd_path = NULL; execbuf->wd_len = 0; } } /** Actually spawn the process. */ static int bfs_exec_spawn(const struct bfs_exec *execbuf) { if (execbuf->flags & BFS_EXEC_CONFIRM) { for (size_t i = 0; i < execbuf->argc; ++i) { fprintf(stderr, "%s ", execbuf->argv[i]); } fprintf(stderr, "? "); if (ynprompt() <= 0) { errno = 0; return -1; } } if (execbuf->flags & BFS_EXEC_MULTI) { bfs_exec_debug(execbuf, "Executing '%s' ... [%zu arguments] (size %zu)\n", execbuf->argv[0], execbuf->argc - 1, execbuf->arg_size); } else { bfs_exec_debug(execbuf, "Executing '%s' ... [%zu arguments]\n", execbuf->argv[0], execbuf->argc - 1); } pid_t pid = -1; int error; struct bfs_spawn ctx; if (bfs_spawn_init(&ctx) != 0) { return -1; } if (bfs_spawn_setflags(&ctx, BFS_SPAWN_USEPATH) != 0) { goto fail; } // Reset RLIMIT_NOFILE, to avoid breaking applications that use select() struct rlimit rl = { .rlim_cur = execbuf->ctx->nofile_soft, .rlim_max = execbuf->ctx->nofile_hard, }; if (bfs_spawn_addsetrlimit(&ctx, RLIMIT_NOFILE, &rl) != 0) { goto fail; } if (execbuf->wd_fd >= 0) { if (bfs_spawn_addfchdir(&ctx, execbuf->wd_fd) != 0) { goto fail; } } pid = bfs_spawn(execbuf->argv[0], &ctx, execbuf->argv, NULL); fail: error = errno; bfs_spawn_destroy(&ctx); if (pid < 0) { errno = error; return -1; } int wstatus; if (waitpid(pid, &wstatus, 0) < 0) { return -1; } int ret = -1; if (WIFEXITED(wstatus)) { int status = WEXITSTATUS(wstatus); if (status == EXIT_SUCCESS) { ret = 0; } else { bfs_exec_debug(execbuf, "Command '%s' failed with status %d\n", execbuf->argv[0], status); } } else if (WIFSIGNALED(wstatus)) { int sig = WTERMSIG(wstatus); const char *str = strsignal(sig); if (!str) { str = "unknown"; } bfs_warning(execbuf->ctx, "Command '${ex}%s${rs}' terminated by signal %d (%s)\n", execbuf->argv[0], sig, str); } else { bfs_warning(execbuf->ctx, "Command '${ex}%s${rs}' terminated abnormally\n", execbuf->argv[0]); } errno = 0; return ret; } /** exec() a command for a single file. */ static int bfs_exec_single(struct bfs_exec *execbuf, const struct BFTW *ftwbuf) { int ret = -1, error = 0; char *path = bfs_exec_format_path(execbuf, ftwbuf); if (!path) { goto out; } size_t i; for (i = 0; i < execbuf->tmpl_argc; ++i) { execbuf->argv[i] = bfs_exec_format_arg(execbuf->tmpl_argv[i], path); if (!execbuf->argv[i]) { goto out_free; } } execbuf->argv[i] = NULL; execbuf->argc = i; if (execbuf->flags & BFS_EXEC_CHDIR) { if (bfs_exec_openwd(execbuf, ftwbuf) != 0) { goto out_free; } } ret = bfs_exec_spawn(execbuf); out_free: error = errno; bfs_exec_closewd(execbuf, ftwbuf); for (size_t j = 0; j < i; ++j) { bfs_exec_free_arg(execbuf->argv[j], execbuf->tmpl_argv[j]); } free(path); errno = error; out: return ret; } /** Check if any arguments remain in the buffer. */ static bool bfs_exec_args_remain(const struct bfs_exec *execbuf) { return execbuf->argc >= execbuf->tmpl_argc; } /** Compute the current ARG_MAX estimate for binary search. */ static size_t bfs_exec_estimate_max(const struct bfs_exec *execbuf) { size_t min = execbuf->arg_min; size_t max = execbuf->arg_max; return min + (max - min)/2; } /** Update the ARG_MAX lower bound from a successful execution. */ static void bfs_exec_update_min(struct bfs_exec *execbuf) { if (execbuf->arg_size > execbuf->arg_min) { execbuf->arg_min = execbuf->arg_size; // Don't let min exceed max if (execbuf->arg_min > execbuf->arg_max) { execbuf->arg_min = execbuf->arg_max; } size_t estimate = bfs_exec_estimate_max(execbuf); bfs_exec_debug(execbuf, "ARG_MAX between [%zu, %zu], trying %zu\n", execbuf->arg_min, execbuf->arg_max, estimate); } } /** Update the ARG_MAX upper bound from a failed execution. */ static size_t bfs_exec_update_max(struct bfs_exec *execbuf) { bfs_exec_debug(execbuf, "Got E2BIG, shrinking argument list...\n"); size_t size = execbuf->arg_size; if (size <= execbuf->arg_min) { // Lower bound was wrong, restart binary search. execbuf->arg_min = 0; } // Trim a fraction off the max size to avoid repeated failures near the // top end of the working range size -= size/16; if (size < execbuf->arg_max) { execbuf->arg_max = size; // Don't let min exceed max if (execbuf->arg_min > execbuf->arg_max) { execbuf->arg_min = execbuf->arg_max; } } // Binary search for a more precise bound size_t estimate = bfs_exec_estimate_max(execbuf); bfs_exec_debug(execbuf, "ARG_MAX between [%zu, %zu], trying %zu\n", execbuf->arg_min, execbuf->arg_max, estimate); return estimate; } /** Execute the pending command from a BFS_EXEC_MULTI execbuf. */ static int bfs_exec_flush(struct bfs_exec *execbuf) { int ret = 0, error = 0; size_t orig_argc = execbuf->argc; while (bfs_exec_args_remain(execbuf)) { execbuf->argv[execbuf->argc] = NULL; ret = bfs_exec_spawn(execbuf); error = errno; if (ret == 0) { bfs_exec_update_min(execbuf); break; } else if (error != E2BIG) { break; } // Try to recover from E2BIG by trying fewer and fewer arguments // until they fit size_t new_max = bfs_exec_update_max(execbuf); while (execbuf->arg_size > new_max) { execbuf->argv[execbuf->argc] = execbuf->argv[execbuf->argc - 1]; execbuf->arg_size -= bfs_exec_arg_size(execbuf->argv[execbuf->argc]); --execbuf->argc; } } size_t new_argc = execbuf->argc; for (size_t i = execbuf->tmpl_argc - 1; i < new_argc; ++i) { free(execbuf->argv[i]); } execbuf->argc = execbuf->tmpl_argc - 1; execbuf->arg_size = 0; if (new_argc < orig_argc) { // If we recovered from E2BIG, there are unused arguments at the // end of the list for (size_t i = new_argc + 1; i <= orig_argc; ++i) { if (error == 0) { execbuf->argv[execbuf->argc] = execbuf->argv[i]; execbuf->arg_size += bfs_exec_arg_size(execbuf->argv[execbuf->argc]); ++execbuf->argc; } else { free(execbuf->argv[i]); } } } errno = error; return ret; } /** Check if we need to flush the execbuf because we're changing directories. */ static bool bfs_exec_changed_dirs(const struct bfs_exec *execbuf, const struct BFTW *ftwbuf) { if (execbuf->flags & BFS_EXEC_CHDIR) { if (ftwbuf->nameoff > execbuf->wd_len || (execbuf->wd_path && strncmp(ftwbuf->path, execbuf->wd_path, execbuf->wd_len) != 0)) { bfs_exec_debug(execbuf, "Changed directories, executing buffered command\n"); return true; } } return false; } /** Check if we need to flush the execbuf because we're too big. */ static bool bfs_exec_would_overflow(const struct bfs_exec *execbuf, const char *arg) { size_t arg_max = bfs_exec_estimate_max(execbuf); size_t next_size = execbuf->arg_size + bfs_exec_arg_size(arg); if (next_size > arg_max) { bfs_exec_debug(execbuf, "Command size (%zu) would exceed maximum (%zu), executing buffered command\n", next_size, arg_max); return true; } return false; } /** Push a new argument to a BFS_EXEC_MULTI execbuf. */ static int bfs_exec_push(struct bfs_exec *execbuf, char *arg) { execbuf->argv[execbuf->argc] = arg; if (execbuf->argc + 1 >= execbuf->argv_cap) { size_t cap = 2*execbuf->argv_cap; char **argv = realloc(execbuf->argv, cap*sizeof(*argv)); if (!argv) { return -1; } execbuf->argv = argv; execbuf->argv_cap = cap; } ++execbuf->argc; execbuf->arg_size += bfs_exec_arg_size(arg); return 0; } /** Handle a new path for a BFS_EXEC_MULTI execbuf. */ static int bfs_exec_multi(struct bfs_exec *execbuf, const struct BFTW *ftwbuf) { int ret = 0; char *arg = bfs_exec_format_path(execbuf, ftwbuf); if (!arg) { ret = -1; goto out; } if (bfs_exec_changed_dirs(execbuf, ftwbuf)) { while (bfs_exec_args_remain(execbuf)) { ret |= bfs_exec_flush(execbuf); } bfs_exec_closewd(execbuf, ftwbuf); } else if (bfs_exec_would_overflow(execbuf, arg)) { ret |= bfs_exec_flush(execbuf); } if ((execbuf->flags & BFS_EXEC_CHDIR) && execbuf->wd_fd < 0) { if (bfs_exec_openwd(execbuf, ftwbuf) != 0) { ret = -1; goto out_arg; } } if (bfs_exec_push(execbuf, arg) != 0) { ret = -1; goto out_arg; } // arg will get cleaned up later by bfs_exec_flush() goto out; out_arg: free(arg); out: return ret; } int bfs_exec(struct bfs_exec *execbuf, const struct BFTW *ftwbuf) { if (execbuf->flags & BFS_EXEC_MULTI) { if (bfs_exec_multi(execbuf, ftwbuf) == 0) { errno = 0; } else { execbuf->ret = -1; } // -exec ... + never returns false return 0; } else { return bfs_exec_single(execbuf, ftwbuf); } } int bfs_exec_finish(struct bfs_exec *execbuf) { if (execbuf->flags & BFS_EXEC_MULTI) { bfs_exec_debug(execbuf, "Finishing execution, executing buffered command\n"); while (bfs_exec_args_remain(execbuf)) { execbuf->ret |= bfs_exec_flush(execbuf); } if (execbuf->ret != 0) { bfs_exec_debug(execbuf, "One or more executions of '%s' failed\n", execbuf->argv[0]); } } return execbuf->ret; } void bfs_exec_free(struct bfs_exec *execbuf) { if (execbuf) { bfs_exec_closewd(execbuf, NULL); free(execbuf->argv); free(execbuf); } } bfs-2.3.1/exec.h000066400000000000000000000072111417254370000133700ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2017-2020 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * Implementation of -exec/-execdir/-ok/-okdir. */ #ifndef BFS_EXEC_H #define BFS_EXEC_H #include struct BFTW; struct bfs_ctx; /** * Flags for the -exec actions. */ enum bfs_exec_flags { /** Prompt the user before executing (-ok, -okdir). */ BFS_EXEC_CONFIRM = 1 << 0, /** Run the command in the file's parent directory (-execdir, -okdir). */ BFS_EXEC_CHDIR = 1 << 1, /** Pass multiple files at once to the command (-exec ... {} +). */ BFS_EXEC_MULTI = 1 << 2, }; /** * Buffer for a command line to be executed. */ struct bfs_exec { /** Flags for this exec buffer. */ enum bfs_exec_flags flags; /** The bfs context. */ const struct bfs_ctx *ctx; /** Command line template. */ char **tmpl_argv; /** Command line template size. */ size_t tmpl_argc; /** The built command line. */ char **argv; /** Number of command line arguments. */ size_t argc; /** Capacity of argv. */ size_t argv_cap; /** Current size of all arguments. */ size_t arg_size; /** Maximum arg_size before E2BIG. */ size_t arg_max; /** Lower bound for arg_max. */ size_t arg_min; /** A file descriptor for the working directory, for BFS_EXEC_CHDIR. */ int wd_fd; /** The path to the working directory, for BFS_EXEC_CHDIR. */ char *wd_path; /** Length of the working directory path. */ size_t wd_len; /** The ultimate return value for bfs_exec_finish(). */ int ret; }; /** * Parse an exec action. * * @param argv * The (bfs) command line argument to parse. * @param flags * Any flags for this exec action. * @param ctx * The bfs context. * @return * The parsed exec action, or NULL on failure. */ struct bfs_exec *bfs_exec_parse(const struct bfs_ctx *ctx, char **argv, enum bfs_exec_flags flags); /** * Execute the command for a file. * * @param execbuf * The parsed exec action. * @param ftwbuf * The bftw() data for the current file. * @return 0 if the command succeeded, -1 if it failed. If the command could * be executed, -1 is returned, and errno will be non-zero. For * BFS_EXEC_MULTI, errors will not be reported until bfs_exec_finish(). */ int bfs_exec(struct bfs_exec *execbuf, const struct BFTW *ftwbuf); /** * Finish executing any commands. * * @param execbuf * The parsed exec action. * @return 0 on success, -1 if any errors were encountered. */ int bfs_exec_finish(struct bfs_exec *execbuf); /** * Free a parsed exec action. */ void bfs_exec_free(struct bfs_exec *execbuf); #endif // BFS_EXEC_H bfs-2.3.1/expr.h000066400000000000000000000120201417254370000134140ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2015-2018 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * The expression tree representation. */ #ifndef BFS_EXPR_H #define BFS_EXPR_H #include "color.h" #include "eval.h" #include "exec.h" #include "printf.h" #include "stat.h" #include #include #include #include #include /** * Possible types of numeric comparison. */ enum cmp_flag { /** Exactly n. */ CMP_EXACT, /** Less than n. */ CMP_LESS, /** Greater than n. */ CMP_GREATER, }; /** * Possible types of mode comparison. */ enum mode_cmp { /** Mode is an exact match (MODE). */ MODE_EXACT, /** Mode has all these bits (-MODE). */ MODE_ALL, /** Mode has any of these bits (/MODE). */ MODE_ANY, }; /** * Possible time units. */ enum time_unit { /** Seconds. */ SECONDS, /** Minutes. */ MINUTES, /** Days. */ DAYS, }; /** * Possible file size units. */ enum size_unit { /** 512-byte blocks. */ SIZE_BLOCKS, /** Single bytes. */ SIZE_BYTES, /** Two-byte words. */ SIZE_WORDS, /** Kibibytes. */ SIZE_KB, /** Mebibytes. */ SIZE_MB, /** Gibibytes. */ SIZE_GB, /** Tebibytes. */ SIZE_TB, /** Pebibytes. */ SIZE_PB, }; /** * A command line expression. */ struct expr { /** The function that evaluates this expression. */ eval_fn *eval; /** The left hand side of the expression. */ struct expr *lhs; /** The right hand side of the expression. */ struct expr *rhs; /** Whether this expression has no side effects. */ bool pure; /** Whether this expression always evaluates to true. */ bool always_true; /** Whether this expression always evaluates to false. */ bool always_false; /** Estimated cost. */ double cost; /** Estimated probability of success. */ double probability; /** Number of times this predicate was executed. */ size_t evaluations; /** Number of times this predicate succeeded. */ size_t successes; /** Total time spent running this predicate. */ struct timespec elapsed; /** The number of command line arguments for this expression. */ size_t argc; /** The command line arguments comprising this expression. */ char **argv; /** The optional comparison flag. */ enum cmp_flag cmp_flag; /** The mode comparison flag. */ enum mode_cmp mode_cmp; /** Mode to use for files. */ mode_t file_mode; /** Mode to use for directories (different due to X). */ mode_t dir_mode; /** Flags that should be set. */ unsigned long long set_flags; /** Flags that should be cleared. */ unsigned long long clear_flags; /** The optional stat field to look at. */ enum bfs_stat_field stat_field; /** The optional reference time. */ struct timespec reftime; /** The optional time unit. */ enum time_unit time_unit; /** The optional size unit. */ enum size_unit size_unit; /** Optional device number for a target file. */ dev_t dev; /** Optional inode number for a target file. */ ino_t ino; /** File to output to. */ CFILE *cfile; /** Optional compiled regex. */ regex_t *regex; /** Optional exec command. */ struct bfs_exec *execbuf; /** Optional printf command. */ struct bfs_printf *printf; /** Optional integer data for this expression. */ long long idata; /** Optional string data for this expression. */ const char *sdata; /** The number of files this expression keeps open between evaluations. */ int persistent_fds; /** The number of files this expression opens during evaluation. */ int ephemeral_fds; }; /** Singleton true expression instance. */ extern struct expr expr_true; /** Singleton false expression instance. */ extern struct expr expr_false; /** * Create a new expression. */ struct expr *new_expr(eval_fn *eval, size_t argc, char **argv); /** * @return Whether expr is known to always quit. */ bool expr_never_returns(const struct expr *expr); /** * @return The result of the comparison for this expression. */ bool expr_cmp(const struct expr *expr, long long n); /** * Free an expression tree. */ void free_expr(struct expr *expr); #endif // BFS_EXPR_H bfs-2.3.1/flags.sh000077500000000000000000000002261417254370000137250ustar00rootroot00000000000000#!/usr/bin/env bash set -e echo "$@" >.newflags if [ -e .flags ] && cmp -s .flags .newflags; then rm .newflags else mv .newflags .flags fi bfs-2.3.1/fsade.c000066400000000000000000000213311417254370000135200ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2019-2021 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "fsade.h" #include "bftw.h" #include "dir.h" #include "dstring.h" #include "util.h" #include #include #include #include #if BFS_CAN_CHECK_ACL # include #endif #if BFS_CAN_CHECK_CAPABILITIES # include #endif #if BFS_HAS_SYS_EXTATTR # include #elif BFS_HAS_SYS_XATTR # include #endif #if BFS_CAN_CHECK_ACL || BFS_CAN_CHECK_CAPABILITIES || BFS_CAN_CHECK_XATTRS /** * Many of the APIs used here don't have *at() variants, but we can try to * emulate something similar if /proc/self/fd is available. */ static const char *fake_at(const struct BFTW *ftwbuf) { static bool proc_works = true; static bool proc_checked = false; char *path = NULL; if (!proc_works || ftwbuf->at_fd == AT_FDCWD) { goto fail; } path = dstrprintf("/proc/self/fd/%d/", ftwbuf->at_fd); if (!path) { goto fail; } if (!proc_checked) { proc_checked = true; if (xfaccessat(AT_FDCWD, path, F_OK) != 0) { proc_works = false; goto fail; } } if (dstrcat(&path, ftwbuf->at_path) != 0) { goto fail; } return path; fail: dstrfree(path); return ftwbuf->path; } static void free_fake_at(const struct BFTW *ftwbuf, const char *path) { if (path != ftwbuf->path) { dstrfree((char *)path); } } /** * Check if an error was caused by the absence of support or data for a feature. */ static bool is_absence_error(int error) { // If the OS doesn't support the feature, it's obviously not enabled for // any files if (error == ENOTSUP) { return true; } // On Linux, ACLs and capabilities are implemented in terms of extended // attributes, which report ENODATA/ENOATTR when missing #ifdef ENODATA if (error == ENODATA) { return true; } #endif #if defined(ENOATTR) && ENOATTR != ENODATA if (error == ENOATTR) { return true; } #endif // On at least FreeBSD and macOS, EINVAL is returned when the requested // ACL type is not supported for that file if (error == EINVAL) { return true; } #if __APPLE__ // On macOS, ENOENT can also signal that a file has no ACLs if (error == ENOENT) { return true; } #endif return false; } #endif // BFS_CAN_CHECK_ACL || BFS_CAN_CHECK_CAPABILITIES || BFS_CAN_CHECK_XATTRS #if BFS_CAN_CHECK_ACL /** Check if a POSIX.1e ACL is non-trivial. */ static int bfs_check_posix1e_acl(acl_t acl, bool ignore_required) { int ret = 0; acl_entry_t entry; for (int status = acl_get_entry(acl, ACL_FIRST_ENTRY, &entry); #if __APPLE__ // POSIX.1e specifies a return value of 1 for success, but macOS // returns 0 instead status == 0; #else status > 0; #endif status = acl_get_entry(acl, ACL_NEXT_ENTRY, &entry)) { #if defined(ACL_USER_OBJ) && defined(ACL_GROUP_OBJ) && defined(ACL_OTHER) if (ignore_required) { acl_tag_t tag; if (acl_get_tag_type(entry, &tag) != 0) { ret = -1; continue; } if (tag == ACL_USER_OBJ || tag == ACL_GROUP_OBJ || tag == ACL_OTHER) { continue; } } #endif ret = 1; break; } return ret; } /** Check if an ACL of the given type is non-trivial. */ static int bfs_check_acl_type(acl_t acl, acl_type_t type) { if (type == ACL_TYPE_DEFAULT) { // For directory default ACLs, any entries make them non-trivial return bfs_check_posix1e_acl(acl, false); } #if __FreeBSD__ int trivial; #if BFS_HAS_FEATURE(memory_sanitizer, false) // msan seems to be missing an interceptor for acl_is_trivial_np() trivial = 0; #endif if (acl_is_trivial_np(acl, &trivial) < 0) { return -1; } else if (trivial) { return 0; } else { return 1; } #else // !__FreeBSD__ return bfs_check_posix1e_acl(acl, true); #endif } int bfs_check_acl(const struct BFTW *ftwbuf) { static const acl_type_t acl_types[] = { #if __APPLE__ // macOS gives EINVAL for either of the two standard ACL types, // supporting only ACL_TYPE_EXTENDED ACL_TYPE_EXTENDED, #else // The two standard POSIX.1e ACL types ACL_TYPE_ACCESS, ACL_TYPE_DEFAULT, #endif #ifdef ACL_TYPE_NFS4 ACL_TYPE_NFS4, #endif }; static const size_t n_acl_types = sizeof(acl_types)/sizeof(acl_types[0]); if (ftwbuf->type == BFS_LNK) { return 0; } const char *path = fake_at(ftwbuf); int ret = -1, error = 0; for (size_t i = 0; i < n_acl_types && ret <= 0; ++i) { acl_type_t type = acl_types[i]; if (type == ACL_TYPE_DEFAULT && ftwbuf->type != BFS_DIR) { // ACL_TYPE_DEFAULT is supported only for directories, // otherwise acl_get_file() gives EACCESS continue; } acl_t acl = acl_get_file(path, type); if (!acl) { error = errno; if (is_absence_error(error)) { ret = 0; } continue; } ret = bfs_check_acl_type(acl, type); error = errno; acl_free(acl); } free_fake_at(ftwbuf, path); errno = error; return ret; } #else // !BFS_CAN_CHECK_ACL int bfs_check_acl(const struct BFTW *ftwbuf) { errno = ENOTSUP; return -1; } #endif #if BFS_CAN_CHECK_CAPABILITIES int bfs_check_capabilities(const struct BFTW *ftwbuf) { if (ftwbuf->type == BFS_LNK) { return 0; } int ret = -1, error; const char *path = fake_at(ftwbuf); cap_t caps = cap_get_file(path); if (!caps) { error = errno; if (is_absence_error(error)) { ret = 0; } goto out_path; } // TODO: Any better way to check for a non-empty capability set? char *text = cap_to_text(caps, NULL); if (!text) { error = errno; goto out_caps; } ret = text[0] ? 1 : 0; error = errno; cap_free(text); out_caps: cap_free(caps); out_path: free_fake_at(ftwbuf, path); errno = error; return ret; } #else // !BFS_CAN_CHECK_CAPABILITIES int bfs_check_capabilities(const struct BFTW *ftwbuf) { errno = ENOTSUP; return -1; } #endif #if BFS_CAN_CHECK_XATTRS int bfs_check_xattrs(const struct BFTW *ftwbuf) { const char *path = fake_at(ftwbuf); ssize_t len; #if BFS_HAS_SYS_EXTATTR ssize_t (*extattr_list)(const char *, int, void*, size_t) = ftwbuf->type == BFS_LNK ? extattr_list_link : extattr_list_file; len = extattr_list(path, EXTATTR_NAMESPACE_SYSTEM, NULL, 0); if (len <= 0) { len = extattr_list(path, EXTATTR_NAMESPACE_USER, NULL, 0); } #elif __APPLE__ int options = ftwbuf->type == BFS_LNK ? XATTR_NOFOLLOW : 0; len = listxattr(path, NULL, 0, options); #else if (ftwbuf->type == BFS_LNK) { len = llistxattr(path, NULL, 0); } else { len = listxattr(path, NULL, 0); } #endif int error = errno; free_fake_at(ftwbuf, path); if (len > 0) { return 1; } else if (len == 0 || is_absence_error(error)) { return 0; } else if (error == E2BIG) { return 1; } else { errno = error; return -1; } } int bfs_check_xattr_named(const struct BFTW *ftwbuf, const char *name) { const char *path = fake_at(ftwbuf); ssize_t len; #if BFS_HAS_SYS_EXTATTR ssize_t (*extattr_get)(const char *, int, const char *, void*, size_t) = ftwbuf->type == BFS_LNK ? extattr_get_link : extattr_get_file; len = extattr_get(path, EXTATTR_NAMESPACE_SYSTEM, name, NULL, 0); if (len < 0) { len = extattr_get(path, EXTATTR_NAMESPACE_USER, name, NULL, 0); } #elif __APPLE__ int options = ftwbuf->type == BFS_LNK ? XATTR_NOFOLLOW : 0; len = getxattr(path, name, NULL, 0, 0, options); #else if (ftwbuf->type == BFS_LNK) { len = lgetxattr(path, name, NULL, 0); } else { len = getxattr(path, name, NULL, 0); } #endif int error = errno; free_fake_at(ftwbuf, path); if (len >= 0) { return 1; } else if (is_absence_error(error)) { return 0; } else if (error == E2BIG) { return 1; } else { errno = error; return -1; } } #else // !BFS_CAN_CHECK_XATTRS int bfs_check_xattrs(const struct BFTW *ftwbuf) { errno = ENOTSUP; return -1; } int bfs_check_xattr_named(const struct BFTW *ftwbuf, const char *name) { errno = ENOTSUP; return -1; } #endif bfs-2.3.1/fsade.h000066400000000000000000000053211417254370000135260ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2019-2020 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * A facade over (file)system features that are (un)implemented differently * between platforms. */ #ifndef BFS_FSADE_H #define BFS_FSADE_H #include "util.h" #include #define BFS_CAN_CHECK_ACL BFS_HAS_SYS_ACL #if !defined(BFS_CAN_CHECK_CAPABILITIES) && BFS_HAS_SYS_CAPABILITY && !__FreeBSD__ # include # ifdef CAP_CHOWN # define BFS_CAN_CHECK_CAPABILITIES true # endif #endif #define BFS_CAN_CHECK_XATTRS (BFS_HAS_SYS_EXTATTR || BFS_HAS_SYS_XATTR) struct BFTW; /** * Check if a file has a non-trivial Access Control List. * * @param ftwbuf * The file to check. * @return * 1 if it does, 0 if it doesn't, or -1 if an error occurred. */ int bfs_check_acl(const struct BFTW *ftwbuf); /** * Check if a file has a non-trivial capability set. * * @param ftwbuf * The file to check. * @return * 1 if it does, 0 if it doesn't, or -1 if an error occurred. */ int bfs_check_capabilities(const struct BFTW *ftwbuf); /** * Check if a file has any extended attributes set. * * @param ftwbuf * The file to check. * @return * 1 if it does, 0 if it doesn't, or -1 if an error occurred. */ int bfs_check_xattrs(const struct BFTW *ftwbuf); /** * Check if a file has an extended attribute with the given name. * * @param ftwbuf * The file to check. * @param name * The name of the xattr to check. * @return * 1 if it does, 0 if it doesn't, or -1 if an error occurred. */ int bfs_check_xattr_named(const struct BFTW *ftwbuf, const char *name); #endif // BFS_FSADE_H bfs-2.3.1/main.c000066400000000000000000000110341417254370000133610ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2015-2022 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * - main(): the entry point for bfs(1), a breadth-first version of find(1) * - main.c (this file) * * - bfs_parse_cmdline(): parses the command line into an expression tree * - ctx.[ch] (struct bfs_ctx, the overall bfs context) * - expr.h (declares the expression tree nodes) * - parse.[ch] (the parser itself) * - opt.[ch] (the optimizer) * * - bfs_eval(): runs the expression on every file it sees * - eval.[ch] (the main evaluation functions) * - exec.[ch] (implements -exec[dir]/-ok[dir]) * - printf.[ch] (implements -[f]printf) * * - bftw(): used by bfs_eval() to walk the directory tree(s) * - bftw.[ch] (an extended version of nftw(3)) * * - Utilities: * - bfs.h (constants about bfs itself) * - bar.[ch] (a terminal status bar) * - color.[ch] (for pretty terminal colors) * - darray.[ch] (a dynamic array library) * - diag.[ch] (formats diagnostic messages) * - dir.[ch] (a directory API facade) * - dstring.[ch] (a dynamic string library) * - fsade.[ch] (a facade over non-standard filesystem features) * - mtab.[ch] (parses the system's mount table) * - pwcache.[ch] (a cache for the user/group tables) * - spawn.[ch] (spawns processes) * - stat.[ch] (wraps stat(), or statx() on Linux) * - time.[ch] (date/time handling utilities) * - trie.[ch] (a trie set/map implementation) * - typo.[ch] (fuzzy matching for typos) * - util.[ch] (everything else) */ #include "ctx.h" #include "eval.h" #include "parse.h" #include "util.h" #include #include #include #include #include #include #include /** * Check if a file descriptor is open. */ static bool isopen(int fd) { return fcntl(fd, F_GETFD) >= 0 || errno != EBADF; } /** * Open a file and redirect it to a particular descriptor. */ static int redirect(int fd, const char *path, int flags) { int newfd = open(path, flags); if (newfd < 0 || newfd == fd) { return newfd; } int ret = dup2(newfd, fd); close_quietly(newfd); return ret; } /** * Make sure the standard streams std{in,out,err} are open. If they are not, * future open() calls may use those file descriptors, and std{in,out,err} will * use them unintentionally. */ static int open_std_streams(void) { #ifdef O_PATH const int inflags = O_PATH, outflags = O_PATH; #else // These are intentionally backwards so that bfs >&- still fails with EBADF const int inflags = O_WRONLY, outflags = O_RDONLY; #endif if (!isopen(STDERR_FILENO) && redirect(STDERR_FILENO, "/dev/null", outflags) < 0) { return -1; } if (!isopen(STDOUT_FILENO) && redirect(STDOUT_FILENO, "/dev/null", outflags) < 0) { perror("redirect()"); return -1; } if (!isopen(STDIN_FILENO) && redirect(STDIN_FILENO, "/dev/null", inflags) < 0) { perror("redirect()"); return -1; } return 0; } /** * bfs entry point. */ int main(int argc, char *argv[]) { int ret = EXIT_FAILURE; // Make sure the standard streams are open if (open_std_streams() != 0) { goto done; } // Use the system locale instead of "C" setlocale(LC_ALL, ""); struct bfs_ctx *ctx = bfs_parse_cmdline(argc, argv); if (ctx) { ret = bfs_eval(ctx); } if (bfs_ctx_free(ctx) != 0 && ret == EXIT_SUCCESS) { ret = EXIT_FAILURE; } done: return ret; } bfs-2.3.1/mtab.c000066400000000000000000000126041417254370000133640ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2017-2020 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "mtab.h" #include "darray.h" #include "stat.h" #include "trie.h" #include "util.h" #include #include #include #include #include #include #if BFS_HAS_SYS_PARAM # include #endif #if BFS_HAS_MNTENT # define BFS_MNTENT 1 #elif BSD # define BFS_MNTINFO 1 #elif __SVR4 # define BFS_MNTTAB 1 #endif #if BFS_MNTENT # include # include # include #elif BFS_MNTINFO # include # include #elif BFS_MNTTAB # include # include #endif /** * A mount point in the table. */ struct bfs_mtab_entry { /** The path to the mount point. */ char *path; /** The filesystem type. */ char *type; }; struct bfs_mtab { /** The list of mount points. */ struct bfs_mtab_entry *entries; /** The basenames of every mount point. */ struct trie names; /** A map from device ID to fstype (populated lazily). */ struct trie types; /** Whether the types map has been populated. */ bool types_filled; }; /** * Add an entry to the mount table. */ static int bfs_mtab_add(struct bfs_mtab *mtab, const char *path, const char *type) { struct bfs_mtab_entry entry = { .path = strdup(path), .type = strdup(type), }; if (!entry.path || !entry.type) { goto fail_entry; } if (DARRAY_PUSH(&mtab->entries, &entry) != 0) { goto fail_entry; } if (!trie_insert_str(&mtab->names, xbasename(path))) { goto fail; } return 0; fail_entry: free(entry.type); free(entry.path); fail: return -1; } struct bfs_mtab *bfs_mtab_parse(void) { struct bfs_mtab *mtab = malloc(sizeof(*mtab)); if (!mtab) { return NULL; } mtab->entries = NULL; trie_init(&mtab->names); trie_init(&mtab->types); mtab->types_filled = false; int error = 0; #if BFS_MNTENT FILE *file = setmntent(_PATH_MOUNTED, "r"); if (!file) { // In case we're in a chroot or something with /proc but no /etc/mtab error = errno; file = setmntent("/proc/mounts", "r"); } if (!file) { goto fail; } struct mntent *mnt; while ((mnt = getmntent(file))) { if (bfs_mtab_add(mtab, mnt->mnt_dir, mnt->mnt_type) != 0) { error = errno; endmntent(file); goto fail; } } endmntent(file); #elif BFS_MNTINFO #if __NetBSD__ typedef struct statvfs bfs_statfs; #else typedef struct statfs bfs_statfs; #endif bfs_statfs *mntbuf; int size = getmntinfo(&mntbuf, MNT_WAIT); if (size < 0) { error = errno; goto fail; } for (bfs_statfs *mnt = mntbuf; mnt < mntbuf + size; ++mnt) { if (bfs_mtab_add(mtab, mnt->f_mntonname, mnt->f_fstypename) != 0) { error = errno; goto fail; } } #elif BFS_MNTTAB FILE *file = xfopen(MNTTAB, O_RDONLY | O_CLOEXEC); if (!file) { error = errno; goto fail; } struct mnttab mnt; while (getmntent(file, &mnt) == 0) { if (bfs_mtab_add(mtab, mnt.mnt_mountp, mnt.mnt_fstype) != 0) { error = errno; fclose(file); goto fail; } } fclose(file); #else error = ENOTSUP; goto fail; #endif return mtab; fail: bfs_mtab_free(mtab); errno = error; return NULL; } static void bfs_mtab_fill_types(struct bfs_mtab *mtab) { for (size_t i = 0; i < darray_length(mtab->entries); ++i) { struct bfs_mtab_entry *entry = mtab->entries + i; struct bfs_stat sb; if (bfs_stat(AT_FDCWD, entry->path, BFS_STAT_NOFOLLOW | BFS_STAT_NOSYNC, &sb) != 0) { continue; } struct trie_leaf *leaf = trie_insert_mem(&mtab->types, &sb.dev, sizeof(sb.dev)); if (leaf) { leaf->value = entry->type; } } mtab->types_filled = true; } const char *bfs_fstype(const struct bfs_mtab *mtab, const struct bfs_stat *statbuf) { if (!mtab->types_filled) { bfs_mtab_fill_types((struct bfs_mtab *)mtab); } const struct trie_leaf *leaf = trie_find_mem(&mtab->types, &statbuf->dev, sizeof(statbuf->dev)); if (leaf) { return leaf->value; } else { return "unknown"; } } bool bfs_might_be_mount(const struct bfs_mtab *mtab, const char *path) { const char *name = xbasename(path); return trie_find_str(&mtab->names, name); } void bfs_mtab_free(struct bfs_mtab *mtab) { if (mtab) { trie_destroy(&mtab->types); trie_destroy(&mtab->names); for (size_t i = 0; i < darray_length(mtab->entries); ++i) { free(mtab->entries[i].type); free(mtab->entries[i].path); } darray_free(mtab->entries); free(mtab); } } bfs-2.3.1/mtab.h000066400000000000000000000044211417254370000133670ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2017-2020 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * A facade over platform-specific APIs for enumerating mounted filesystems. */ #ifndef BFS_MTAB_H #define BFS_MTAB_H #include struct bfs_stat; /** * A file system mount table. */ struct bfs_mtab; /** * Parse the mount table. * * @return * The parsed mount table, or NULL on error. */ struct bfs_mtab *bfs_mtab_parse(void); /** * Determine the file system type that a file is on. * * @param mtab * The current mount table. * @param statbuf * The bfs_stat() buffer for the file in question. * @return * The type of file system containing this file, "unknown" if not known, * or NULL on error. */ const char *bfs_fstype(const struct bfs_mtab *mtab, const struct bfs_stat *statbuf); /** * Check if a file could be a mount point. * * @param mtab * The current mount table. * @param path * The path to check. * @return * Whether the named file could be a mount point. */ bool bfs_might_be_mount(const struct bfs_mtab *mtab, const char *path); /** * Free a mount table. */ void bfs_mtab_free(struct bfs_mtab *mtab); #endif // BFS_MTAB_H bfs-2.3.1/opt.c000066400000000000000000000733661417254370000132570ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2017-2020 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * The expression optimizer. Different optimization levels are supported: * * -O1: basic logical simplifications, like folding (-true -and -foo) to -foo. * * -O2: dead code elimination and data flow analysis. struct opt_facts is used * to record data flow facts that are true at various points of evaluation. * Specifically, struct opt_facts records the facts that must be true before an * expression is evaluated (state->facts), and those that must be true after the * expression is evaluated, given that it returns true (state->facts_when_true) * or false (state->facts_when_true). Additionally, state->facts_when_impure * records the possible data flow facts before any expressions with side effects * are evaluated. * * -O3: expression re-ordering to reduce expected cost. In an expression like * (-foo -and -bar), if both -foo and -bar are pure (no side effects), they can * be re-ordered to (-bar -and -foo). This is profitable if the expected cost * is lower for the re-ordered expression, for example if -foo is very slow or * -bar is likely to return false. * * -O4/-Ofast: aggressive optimizations that may affect correctness in corner * cases. The main effect is to use facts_when_impure to determine if any side- * effects are reachable at all, and skipping the traversal if not. */ #include "opt.h" #include "color.h" #include "ctx.h" #include "diag.h" #include "eval.h" #include "expr.h" #include "pwcache.h" #include "util.h" #include #include #include #include #include #include static char *fake_and_arg = "-a"; static char *fake_or_arg = "-o"; static char *fake_not_arg = "!"; /** * A contrained integer range. */ struct range { /** The (inclusive) minimum value. */ long long min; /** The (inclusive) maximum value. */ long long max; }; /** Compute the minimum of two values. */ static long long min_value(long long a, long long b) { if (a < b) { return a; } else { return b; } } /** Compute the maximum of two values. */ static long long max_value(long long a, long long b) { if (a > b) { return a; } else { return b; } } /** Constrain the minimum of a range. */ static void constrain_min(struct range *range, long long value) { range->min = max_value(range->min, value); } /** Contrain the maximum of a range. */ static void constrain_max(struct range *range, long long value) { range->max = min_value(range->max, value); } /** Remove a single value from a range. */ static void range_remove(struct range *range, long long value) { if (range->min == value) { if (range->min == LLONG_MAX) { range->max = LLONG_MIN; } else { ++range->min; } } if (range->max == value) { if (range->max == LLONG_MIN) { range->min = LLONG_MAX; } else { --range->max; } } } /** Compute the union of two ranges. */ static void range_union(struct range *result, const struct range *lhs, const struct range *rhs) { result->min = min_value(lhs->min, rhs->min); result->max = max_value(lhs->max, rhs->max); } /** Check if a range contains no values. */ static bool range_is_impossible(const struct range *range) { return range->min > range->max; } /** Set a range to contain no values. */ static void set_range_impossible(struct range *range) { range->min = LLONG_MAX; range->max = LLONG_MIN; } /** * Types of ranges we track. */ enum range_type { /** Search tree depth. */ DEPTH_RANGE, /** Group ID. */ GID_RANGE, /** Inode number. */ INUM_RANGE, /** Hard link count. */ LINKS_RANGE, /** File size. */ SIZE_RANGE, /** User ID. */ UID_RANGE, /** The number of range_types. */ RANGE_TYPES, }; /** * A possibly-known value of a predicate. */ enum known_pred { /** The state is impossible to reach. */ PRED_IMPOSSIBLE = -2, /** The value of the predicate is not known. */ PRED_UNKNOWN = -1, /** The predicate is known to be false. */ PRED_FALSE = false, /** The predicate is known to be true. */ PRED_TRUE = true, }; /** Make a predicate known. */ static void constrain_pred(enum known_pred *pred, bool value) { if (*pred == PRED_UNKNOWN) { *pred = value; } else if (*pred == !value) { *pred = PRED_IMPOSSIBLE; } } /** Compute the union of two known predicates. */ static enum known_pred pred_union(enum known_pred lhs, enum known_pred rhs) { if (lhs == PRED_IMPOSSIBLE) { return rhs; } else if (rhs == PRED_IMPOSSIBLE) { return lhs; } else if (lhs == rhs) { return lhs; } else { return PRED_UNKNOWN; } } /** * Types of predicates we track. */ enum pred_type { /** -readable */ READABLE_PRED, /** -writable */ WRITABLE_PRED, /** -executable */ EXECUTABLE_PRED, /** -acl */ ACL_PRED, /** -capable */ CAPABLE_PRED, /** -empty */ EMPTY_PRED, /** -hidden */ HIDDEN_PRED, /** -nogroup */ NOGROUP_PRED, /** -nouser */ NOUSER_PRED, /** -sparse */ SPARSE_PRED, /** -xattr */ XATTR_PRED, /** The number of pred_types. */ PRED_TYPES, }; /** * Data flow facts about an evaluation point. */ struct opt_facts { /** The value ranges we track. */ struct range ranges[RANGE_TYPES]; /** The predicates we track. */ enum known_pred preds[PRED_TYPES]; /** Bitmask of possible file types. */ unsigned int types; /** Bitmask of possible link target types. */ unsigned int xtypes; }; /** Initialize some data flow facts. */ static void facts_init(struct opt_facts *facts) { for (int i = 0; i < RANGE_TYPES; ++i) { struct range *range = &facts->ranges[i]; range->min = 0; // All ranges we currently track are non-negative range->max = LLONG_MAX; } for (int i = 0; i < PRED_TYPES; ++i) { facts->preds[i] = PRED_UNKNOWN; } facts->types = ~0; facts->xtypes = ~0; } /** Compute the union of two fact sets. */ static void facts_union(struct opt_facts *result, const struct opt_facts *lhs, const struct opt_facts *rhs) { for (int i = 0; i < RANGE_TYPES; ++i) { range_union(&result->ranges[i], &lhs->ranges[i], &rhs->ranges[i]); } for (int i = 0; i < PRED_TYPES; ++i) { result->preds[i] = pred_union(lhs->preds[i], rhs->preds[i]); } result->types = lhs->types | rhs->types; result->xtypes = lhs->xtypes | rhs->xtypes; } /** Determine whether a fact set is impossible. */ static bool facts_are_impossible(const struct opt_facts *facts) { for (int i = 0; i < RANGE_TYPES; ++i) { if (range_is_impossible(&facts->ranges[i])) { return true; } } for (int i = 0; i < PRED_TYPES; ++i) { if (facts->preds[i] == PRED_IMPOSSIBLE) { return true; } } if (!facts->types || !facts->xtypes) { return true; } return false; } /** Set some facts to be impossible. */ static void set_facts_impossible(struct opt_facts *facts) { for (int i = 0; i < RANGE_TYPES; ++i) { set_range_impossible(&facts->ranges[i]); } for (int i = 0; i < PRED_TYPES; ++i) { facts->preds[i] = PRED_IMPOSSIBLE; } facts->types = 0; facts->xtypes = 0; } /** * Optimizer state. */ struct opt_state { /** The context we're optimizing. */ const struct bfs_ctx *ctx; /** Data flow facts before this expression is evaluated. */ struct opt_facts facts; /** Data flow facts after this expression returns true. */ struct opt_facts facts_when_true; /** Data flow facts after this expression returns false. */ struct opt_facts facts_when_false; /** Data flow facts before any side-effecting expressions are evaluated. */ struct opt_facts *facts_when_impure; }; /** Log an optimization. */ BFS_FORMATTER(3, 4) static bool debug_opt(const struct opt_state *state, int level, const char *format, ...) { assert(state->ctx->optlevel >= level); if (bfs_debug(state->ctx, DEBUG_OPT, "${cyn}-O%d${rs}: ", level)) { va_list args; va_start(args, format); cvfprintf(state->ctx->cerr, format, args); va_end(args); return true; } else { return false; } } /** Extract a child expression, freeing the outer expression. */ static struct expr *extract_child_expr(struct expr *expr, struct expr **child) { struct expr *ret = *child; *child = NULL; free_expr(expr); return ret; } /** * Negate an expression. */ static struct expr *negate_expr(struct expr *rhs, char **argv) { if (rhs->eval == eval_not) { return extract_child_expr(rhs, &rhs->rhs); } struct expr *expr = new_expr(eval_not, 1, argv); if (!expr) { free_expr(rhs); return NULL; } expr->rhs = rhs; return expr; } static struct expr *optimize_not_expr(const struct opt_state *state, struct expr *expr); static struct expr *optimize_and_expr(const struct opt_state *state, struct expr *expr); static struct expr *optimize_or_expr(const struct opt_state *state, struct expr *expr); /** * Apply De Morgan's laws. */ static struct expr *de_morgan(const struct opt_state *state, struct expr *expr, char **argv) { bool debug = debug_opt(state, 1, "De Morgan's laws: %pe ", expr); struct expr *parent = negate_expr(expr, argv); if (!parent) { return NULL; } bool has_parent = true; if (parent->eval != eval_not) { expr = parent; has_parent = false; } assert(expr->eval == eval_and || expr->eval == eval_or); if (expr->eval == eval_and) { expr->eval = eval_or; expr->argv = &fake_or_arg; } else { expr->eval = eval_and; expr->argv = &fake_and_arg; } expr->lhs = negate_expr(expr->lhs, argv); expr->rhs = negate_expr(expr->rhs, argv); if (!expr->lhs || !expr->rhs) { free_expr(parent); return NULL; } if (debug) { cfprintf(state->ctx->cerr, "<==> %pe\n", parent); } if (expr->lhs->eval == eval_not) { expr->lhs = optimize_not_expr(state, expr->lhs); } if (expr->rhs->eval == eval_not) { expr->rhs = optimize_not_expr(state, expr->rhs); } if (!expr->lhs || !expr->rhs) { free_expr(parent); return NULL; } if (expr->eval == eval_and) { expr = optimize_and_expr(state, expr); } else { expr = optimize_or_expr(state, expr); } if (has_parent) { parent->rhs = expr; } else { parent = expr; } if (!expr) { free_expr(parent); return NULL; } if (has_parent) { parent = optimize_not_expr(state, parent); } return parent; } /** Optimize an expression recursively. */ static struct expr *optimize_expr_recursive(struct opt_state *state, struct expr *expr); /** * Optimize a negation. */ static struct expr *optimize_not_expr(const struct opt_state *state, struct expr *expr) { assert(expr->eval == eval_not); struct expr *rhs = expr->rhs; int optlevel = state->ctx->optlevel; if (optlevel >= 1) { if (rhs == &expr_true) { debug_opt(state, 1, "constant propagation: %pe <==> %pe\n", expr, &expr_false); free_expr(expr); return &expr_false; } else if (rhs == &expr_false) { debug_opt(state, 1, "constant propagation: %pe <==> %pe\n", expr, &expr_true); free_expr(expr); return &expr_true; } else if (rhs->eval == eval_not) { debug_opt(state, 1, "double negation: %pe <==> %pe\n", expr, rhs->rhs); return extract_child_expr(expr, &rhs->rhs); } else if (expr_never_returns(rhs)) { debug_opt(state, 1, "reachability: %pe <==> %pe\n", expr, rhs); return extract_child_expr(expr, &expr->rhs); } else if ((rhs->eval == eval_and || rhs->eval == eval_or) && (rhs->lhs->eval == eval_not || rhs->rhs->eval == eval_not)) { return de_morgan(state, expr, expr->argv); } } expr->pure = rhs->pure; expr->always_true = rhs->always_false; expr->always_false = rhs->always_true; expr->cost = rhs->cost; expr->probability = 1.0 - rhs->probability; return expr; } /** Optimize a negation recursively. */ static struct expr *optimize_not_expr_recursive(struct opt_state *state, struct expr *expr) { struct opt_state rhs_state = *state; expr->rhs = optimize_expr_recursive(&rhs_state, expr->rhs); if (!expr->rhs) { goto fail; } state->facts_when_true = rhs_state.facts_when_false; state->facts_when_false = rhs_state.facts_when_true; return optimize_not_expr(state, expr); fail: free_expr(expr); return NULL; } /** Optimize a conjunction. */ static struct expr *optimize_and_expr(const struct opt_state *state, struct expr *expr) { assert(expr->eval == eval_and); struct expr *lhs = expr->lhs; struct expr *rhs = expr->rhs; const struct bfs_ctx *ctx = state->ctx; int optlevel = ctx->optlevel; if (optlevel >= 1) { if (lhs == &expr_true) { debug_opt(state, 1, "conjunction elimination: %pe <==> %pe\n", expr, rhs); return extract_child_expr(expr, &expr->rhs); } else if (rhs == &expr_true) { debug_opt(state, 1, "conjunction elimination: %pe <==> %pe\n", expr, lhs); return extract_child_expr(expr, &expr->lhs); } else if (lhs->always_false) { debug_opt(state, 1, "short-circuit: %pe <==> %pe\n", expr, lhs); return extract_child_expr(expr, &expr->lhs); } else if (lhs->always_true && rhs == &expr_false) { bool debug = debug_opt(state, 1, "strength reduction: %pe <==> ", expr); struct expr *ret = extract_child_expr(expr, &expr->lhs); ret = negate_expr(ret, &fake_not_arg); if (debug && ret) { cfprintf(ctx->cerr, "%pe\n", ret); } return ret; } else if (optlevel >= 2 && lhs->pure && rhs == &expr_false) { debug_opt(state, 2, "purity: %pe <==> %pe\n", expr, rhs); return extract_child_expr(expr, &expr->rhs); } else if (lhs->eval == eval_not && rhs->eval == eval_not) { return de_morgan(state, expr, expr->lhs->argv); } } expr->pure = lhs->pure && rhs->pure; expr->always_true = lhs->always_true && rhs->always_true; expr->always_false = lhs->always_false || rhs->always_false; expr->cost = lhs->cost + lhs->probability*rhs->cost; expr->probability = lhs->probability*rhs->probability; return expr; } /** Optimize a conjunction recursively. */ static struct expr *optimize_and_expr_recursive(struct opt_state *state, struct expr *expr) { struct opt_state lhs_state = *state; expr->lhs = optimize_expr_recursive(&lhs_state, expr->lhs); if (!expr->lhs) { goto fail; } struct opt_state rhs_state = *state; rhs_state.facts = lhs_state.facts_when_true; expr->rhs = optimize_expr_recursive(&rhs_state, expr->rhs); if (!expr->rhs) { goto fail; } state->facts_when_true = rhs_state.facts_when_true; facts_union(&state->facts_when_false, &lhs_state.facts_when_false, &rhs_state.facts_when_false); return optimize_and_expr(state, expr); fail: free_expr(expr); return NULL; } /** Optimize a disjunction. */ static struct expr *optimize_or_expr(const struct opt_state *state, struct expr *expr) { assert(expr->eval == eval_or); struct expr *lhs = expr->lhs; struct expr *rhs = expr->rhs; const struct bfs_ctx *ctx = state->ctx; int optlevel = ctx->optlevel; if (optlevel >= 1) { if (lhs->always_true) { debug_opt(state, 1, "short-circuit: %pe <==> %pe\n", expr, lhs); return extract_child_expr(expr, &expr->lhs); } else if (lhs == &expr_false) { debug_opt(state, 1, "disjunctive syllogism: %pe <==> %pe\n", expr, rhs); return extract_child_expr(expr, &expr->rhs); } else if (rhs == &expr_false) { debug_opt(state, 1, "disjunctive syllogism: %pe <==> %pe\n", expr, lhs); return extract_child_expr(expr, &expr->lhs); } else if (lhs->always_false && rhs == &expr_true) { bool debug = debug_opt(state, 1, "strength reduction: %pe <==> ", expr); struct expr *ret = extract_child_expr(expr, &expr->lhs); ret = negate_expr(ret, &fake_not_arg); if (debug && ret) { cfprintf(ctx->cerr, "%pe\n", ret); } return ret; } else if (optlevel >= 2 && lhs->pure && rhs == &expr_true) { debug_opt(state, 2, "purity: %pe <==> %pe\n", expr, rhs); return extract_child_expr(expr, &expr->rhs); } else if (lhs->eval == eval_not && rhs->eval == eval_not) { return de_morgan(state, expr, expr->lhs->argv); } } expr->pure = lhs->pure && rhs->pure; expr->always_true = lhs->always_true || rhs->always_true; expr->always_false = lhs->always_false && rhs->always_false; expr->cost = lhs->cost + (1 - lhs->probability)*rhs->cost; expr->probability = lhs->probability + rhs->probability - lhs->probability*rhs->probability; return expr; } /** Optimize a disjunction recursively. */ static struct expr *optimize_or_expr_recursive(struct opt_state *state, struct expr *expr) { struct opt_state lhs_state = *state; expr->lhs = optimize_expr_recursive(&lhs_state, expr->lhs); if (!expr->lhs) { goto fail; } struct opt_state rhs_state = *state; rhs_state.facts = lhs_state.facts_when_false; expr->rhs = optimize_expr_recursive(&rhs_state, expr->rhs); if (!expr->rhs) { goto fail; } facts_union(&state->facts_when_true, &lhs_state.facts_when_true, &rhs_state.facts_when_true); state->facts_when_false = rhs_state.facts_when_false; return optimize_or_expr(state, expr); fail: free_expr(expr); return NULL; } /** Optimize an expression in an ignored-result context. */ static struct expr *ignore_result(const struct opt_state *state, struct expr *expr) { int optlevel = state->ctx->optlevel; if (optlevel >= 1) { while (true) { if (expr->eval == eval_not) { debug_opt(state, 1, "ignored result: %pe --> %pe\n", expr, expr->rhs); expr = extract_child_expr(expr, &expr->rhs); } else if (optlevel >= 2 && (expr->eval == eval_and || expr->eval == eval_or || expr->eval == eval_comma) && expr->rhs->pure) { debug_opt(state, 2, "ignored result: %pe --> %pe\n", expr, expr->lhs); expr = extract_child_expr(expr, &expr->lhs); } else { break; } } if (optlevel >= 2 && expr->pure && expr != &expr_false) { debug_opt(state, 2, "ignored result: %pe --> %pe\n", expr, &expr_false); free_expr(expr); expr = &expr_false; } } return expr; } /** Optimize a comma expression. */ static struct expr *optimize_comma_expr(const struct opt_state *state, struct expr *expr) { assert(expr->eval == eval_comma); struct expr *lhs = expr->lhs; struct expr *rhs = expr->rhs; int optlevel = state->ctx->optlevel; if (optlevel >= 1) { lhs = expr->lhs = ignore_result(state, lhs); if (expr_never_returns(lhs)) { debug_opt(state, 1, "reachability: %pe <==> %pe\n", expr, lhs); return extract_child_expr(expr, &expr->lhs); } else if ((lhs->always_true && rhs == &expr_true) || (lhs->always_false && rhs == &expr_false)) { debug_opt(state, 1, "redundancy elimination: %pe <==> %pe\n", expr, lhs); return extract_child_expr(expr, &expr->lhs); } else if (optlevel >= 2 && lhs->pure) { debug_opt(state, 2, "purity: %pe <==> %pe\n", expr, rhs); return extract_child_expr(expr, &expr->rhs); } } expr->pure = lhs->pure && rhs->pure; expr->always_true = expr_never_returns(lhs) || rhs->always_true; expr->always_false = expr_never_returns(lhs) || rhs->always_false; expr->cost = lhs->cost + rhs->cost; expr->probability = rhs->probability; return expr; } /** Optimize a comma expression recursively. */ static struct expr *optimize_comma_expr_recursive(struct opt_state *state, struct expr *expr) { struct opt_state lhs_state = *state; expr->lhs = optimize_expr_recursive(&lhs_state, expr->lhs); if (!expr->lhs) { goto fail; } struct opt_state rhs_state = *state; facts_union(&rhs_state.facts, &lhs_state.facts_when_true, &lhs_state.facts_when_false); expr->rhs = optimize_expr_recursive(&rhs_state, expr->rhs); if (!expr->rhs) { goto fail; } return optimize_comma_expr(state, expr); fail: free_expr(expr); return NULL; } /** Infer data flow facts about a predicate. */ static void infer_pred_facts(struct opt_state *state, enum pred_type pred) { constrain_pred(&state->facts_when_true.preds[pred], true); constrain_pred(&state->facts_when_false.preds[pred], false); } /** Infer data flow facts about an -{execut,read,writ}able expression. */ static void infer_access_facts(struct opt_state *state, const struct expr *expr) { if (expr->idata & R_OK) { infer_pred_facts(state, READABLE_PRED); } if (expr->idata & W_OK) { infer_pred_facts(state, WRITABLE_PRED); } if (expr->idata & X_OK) { infer_pred_facts(state, EXECUTABLE_PRED); } } /** Infer data flow facts about an icmp-style ([+-]N) expression. */ static void infer_icmp_facts(struct opt_state *state, const struct expr *expr, enum range_type type) { struct range *range_when_true = &state->facts_when_true.ranges[type]; struct range *range_when_false =& state->facts_when_false.ranges[type]; long long value = expr->idata; switch (expr->cmp_flag) { case CMP_EXACT: constrain_min(range_when_true, value); constrain_max(range_when_true, value); range_remove(range_when_false, value); break; case CMP_LESS: constrain_min(range_when_false, value); constrain_max(range_when_true, value); range_remove(range_when_true, value); break; case CMP_GREATER: constrain_max(range_when_false, value); constrain_min(range_when_true, value); range_remove(range_when_true, value); break; } } /** Infer data flow facts about a -gid expression. */ static void infer_gid_facts(struct opt_state *state, const struct expr *expr) { infer_icmp_facts(state, expr, GID_RANGE); const struct bfs_groups *groups = bfs_ctx_groups(state->ctx); struct range *range = &state->facts_when_true.ranges[GID_RANGE]; if (groups && range->min == range->max) { gid_t gid = range->min; bool nogroup = !bfs_getgrgid(groups, gid); constrain_pred(&state->facts_when_true.preds[NOGROUP_PRED], nogroup); } } /** Infer data flow facts about a -uid expression. */ static void infer_uid_facts(struct opt_state *state, const struct expr *expr) { infer_icmp_facts(state, expr, UID_RANGE); const struct bfs_users *users = bfs_ctx_users(state->ctx); struct range *range = &state->facts_when_true.ranges[UID_RANGE]; if (users && range->min == range->max) { uid_t uid = range->min; bool nouser = !bfs_getpwuid(users, uid); constrain_pred(&state->facts_when_true.preds[NOUSER_PRED], nouser); } } /** Infer data flow facts about a -samefile expression. */ static void infer_samefile_facts(struct opt_state *state, const struct expr *expr) { struct range *range_when_true = &state->facts_when_true.ranges[INUM_RANGE]; constrain_min(range_when_true, expr->ino); constrain_max(range_when_true, expr->ino); } /** Infer data flow facts about a -type expression. */ static void infer_type_facts(struct opt_state *state, const struct expr *expr) { state->facts_when_true.types &= expr->idata; state->facts_when_false.types &= ~expr->idata; } /** Infer data flow facts about an -xtype expression. */ static void infer_xtype_facts(struct opt_state *state, const struct expr *expr) { state->facts_when_true.xtypes &= expr->idata; state->facts_when_false.xtypes &= ~expr->idata; } static struct expr *optimize_expr_recursive(struct opt_state *state, struct expr *expr) { int optlevel = state->ctx->optlevel; state->facts_when_true = state->facts; state->facts_when_false = state->facts; if (optlevel >= 2 && facts_are_impossible(&state->facts)) { debug_opt(state, 2, "reachability: %pe --> %pe\n", expr, &expr_false); free_expr(expr); expr = &expr_false; goto done; } if (!expr->rhs && !expr->pure) { facts_union(state->facts_when_impure, state->facts_when_impure, &state->facts); } if (expr->eval == eval_access) { infer_access_facts(state, expr); } else if (expr->eval == eval_acl) { infer_pred_facts(state, ACL_PRED); } else if (expr->eval == eval_capable) { infer_pred_facts(state, CAPABLE_PRED); } else if (expr->eval == eval_depth) { infer_icmp_facts(state, expr, DEPTH_RANGE); } else if (expr->eval == eval_empty) { infer_pred_facts(state, EMPTY_PRED); } else if (expr->eval == eval_gid) { infer_gid_facts(state, expr); } else if (expr->eval == eval_hidden) { infer_pred_facts(state, HIDDEN_PRED); } else if (expr->eval == eval_inum) { infer_icmp_facts(state, expr, INUM_RANGE); } else if (expr->eval == eval_links) { infer_icmp_facts(state, expr, LINKS_RANGE); } else if (expr->eval == eval_nogroup) { infer_pred_facts(state, NOGROUP_PRED); } else if (expr->eval == eval_nouser) { infer_pred_facts(state, NOUSER_PRED); } else if (expr->eval == eval_samefile) { infer_samefile_facts(state, expr); } else if (expr->eval == eval_size) { infer_icmp_facts(state, expr, SIZE_RANGE); } else if (expr->eval == eval_sparse) { infer_pred_facts(state, SPARSE_PRED); } else if (expr->eval == eval_type) { infer_type_facts(state, expr); } else if (expr->eval == eval_uid) { infer_uid_facts(state, expr); } else if (expr->eval == eval_xattr) { infer_pred_facts(state, XATTR_PRED); } else if (expr->eval == eval_xtype) { infer_xtype_facts(state, expr); } else if (expr->eval == eval_not) { expr = optimize_not_expr_recursive(state, expr); } else if (expr->eval == eval_and) { expr = optimize_and_expr_recursive(state, expr); } else if (expr->eval == eval_or) { expr = optimize_or_expr_recursive(state, expr); } else if (expr->eval == eval_comma) { expr = optimize_comma_expr_recursive(state, expr); } if (!expr) { goto done; } struct expr *lhs = expr->lhs; struct expr *rhs = expr->rhs; if (rhs) { expr->persistent_fds = rhs->persistent_fds; expr->ephemeral_fds = rhs->ephemeral_fds; } if (lhs) { expr->persistent_fds += lhs->persistent_fds; if (lhs->ephemeral_fds > expr->ephemeral_fds) { expr->ephemeral_fds = lhs->ephemeral_fds; } } if (expr->always_true) { set_facts_impossible(&state->facts_when_false); } if (expr->always_false) { set_facts_impossible(&state->facts_when_true); } if (optlevel < 2 || expr == &expr_true || expr == &expr_false) { goto done; } if (facts_are_impossible(&state->facts_when_true)) { if (expr->pure) { debug_opt(state, 2, "data flow: %pe --> %pe\n", expr, &expr_false); free_expr(expr); expr = &expr_false; } else { expr->always_false = true; expr->probability = 0.0; } } else if (facts_are_impossible(&state->facts_when_false)) { if (expr->pure) { debug_opt(state, 2, "data flow: %pe --> %pe\n", expr, &expr_true); free_expr(expr); expr = &expr_true; } else { expr->always_true = true; expr->probability = 1.0; } } done: return expr; } /** Swap the children of a binary expression if it would reduce the cost. */ static bool reorder_expr(const struct opt_state *state, struct expr *expr, double swapped_cost) { if (swapped_cost < expr->cost) { bool debug = debug_opt(state, 3, "cost: %pe <==> ", expr); struct expr *lhs = expr->lhs; expr->lhs = expr->rhs; expr->rhs = lhs; if (debug) { cfprintf(state->ctx->cerr, "%pe (~${ylw}%g${rs} --> ~${ylw}%g${rs})\n", expr, expr->cost, swapped_cost); } expr->cost = swapped_cost; return true; } else { return false; } } /** * Recursively reorder sub-expressions to reduce the overall cost. * * @param expr * The expression to optimize. * @return * Whether any subexpression was reordered. */ static bool reorder_expr_recursive(const struct opt_state *state, struct expr *expr) { bool ret = false; struct expr *lhs = expr->lhs; struct expr *rhs = expr->rhs; if (lhs) { ret |= reorder_expr_recursive(state, lhs); } if (rhs) { ret |= reorder_expr_recursive(state, rhs); } if (expr->eval == eval_and || expr->eval == eval_or) { if (lhs->pure && rhs->pure) { double rhs_prob = expr->eval == eval_and ? rhs->probability : 1.0 - rhs->probability; double swapped_cost = rhs->cost + rhs_prob*lhs->cost; ret |= reorder_expr(state, expr, swapped_cost); } } return ret; } /** * Optimize a top-level expression. */ static struct expr *optimize_expr(struct opt_state *state, struct expr *expr) { struct opt_facts saved_impure = *state->facts_when_impure; expr = optimize_expr_recursive(state, expr); if (!expr) { return NULL; } if (state->ctx->optlevel >= 3 && reorder_expr_recursive(state, expr)) { // Re-do optimizations to account for the new ordering *state->facts_when_impure = saved_impure; expr = optimize_expr_recursive(state, expr); if (!expr) { return NULL; } } return expr; } int bfs_optimize(struct bfs_ctx *ctx) { bfs_ctx_dump(ctx, DEBUG_OPT); struct opt_facts facts_when_impure; set_facts_impossible(&facts_when_impure); struct opt_state state = { .ctx = ctx, .facts_when_impure = &facts_when_impure, }; facts_init(&state.facts); ctx->exclude = optimize_expr(&state, ctx->exclude); if (!ctx->exclude) { return -1; } // Only non-excluded files are evaluated state.facts = state.facts_when_false; struct range *depth = &state.facts.ranges[DEPTH_RANGE]; constrain_min(depth, ctx->mindepth); constrain_max(depth, ctx->maxdepth); ctx->expr = optimize_expr(&state, ctx->expr); if (!ctx->expr) { return -1; } ctx->expr = ignore_result(&state, ctx->expr); if (facts_are_impossible(&facts_when_impure)) { bfs_warning(ctx, "This command won't do anything.\n\n"); } const struct range *depth_when_impure = &facts_when_impure.ranges[DEPTH_RANGE]; long long mindepth = depth_when_impure->min; long long maxdepth = depth_when_impure->max; int optlevel = ctx->optlevel; if (optlevel >= 2 && mindepth > ctx->mindepth) { if (mindepth > INT_MAX) { mindepth = INT_MAX; } ctx->mindepth = mindepth; debug_opt(&state, 2, "data flow: mindepth --> %d\n", ctx->mindepth); } if (optlevel >= 4 && maxdepth < ctx->maxdepth) { if (maxdepth < INT_MIN) { maxdepth = INT_MIN; } ctx->maxdepth = maxdepth; debug_opt(&state, 4, "data flow: maxdepth --> %d\n", ctx->maxdepth); } return 0; } bfs-2.3.1/opt.h000066400000000000000000000027021417254370000132460ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2020 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * Optimization. */ #ifndef BFS_OPT_H #define BFS_OPT_H struct bfs_ctx; /** * Apply optimizations to the command line. * * @param ctx * The bfs context to optimize. * @return * 0 if successful, -1 on error. */ int bfs_optimize(struct bfs_ctx *ctx); #endif // BFS_OPT_H bfs-2.3.1/parse.c000066400000000000000000002674461417254370000135730ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2015-2022 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * The command line parser. Expressions are parsed by recursive descent, with a * grammar described in the comments of the parse_*() functions. The parser * also accepts flags and paths at any point in the expression, by treating * flags like always-true options, and skipping over paths wherever they appear. */ #include "parse.h" #include "bfs.h" #include "bftw.h" #include "color.h" #include "ctx.h" #include "darray.h" #include "diag.h" #include "dir.h" #include "eval.h" #include "exec.h" #include "expr.h" #include "fsade.h" #include "opt.h" #include "printf.h" #include "pwcache.h" #include "spawn.h" #include "stat.h" #include "time.h" #include "typo.h" #include "util.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // Strings printed by -D tree for "fake" expressions static char *fake_and_arg = "-a"; static char *fake_false_arg = "-false"; static char *fake_hidden_arg = "-hidden"; static char *fake_or_arg = "-o"; static char *fake_print_arg = "-print"; static char *fake_true_arg = "-true"; // Cost estimation constants #define FAST_COST 40.0 #define STAT_COST 1000.0 #define PRINT_COST 20000.0 struct expr expr_true = { .eval = eval_true, .lhs = NULL, .rhs = NULL, .pure = true, .always_true = true, .cost = FAST_COST, .probability = 1.0, .argc = 1, .argv = &fake_true_arg, }; struct expr expr_false = { .eval = eval_false, .lhs = NULL, .rhs = NULL, .pure = true, .always_false = true, .cost = FAST_COST, .probability = 0.0, .argc = 1, .argv = &fake_false_arg, }; /** * Free an expression. */ void free_expr(struct expr *expr) { if (!expr || expr == &expr_true || expr == &expr_false) { return; } if (expr->regex) { regfree(expr->regex); free(expr->regex); } bfs_printf_free(expr->printf); bfs_exec_free(expr->execbuf); free_expr(expr->lhs); free_expr(expr->rhs); free(expr); } struct expr *new_expr(eval_fn *eval, size_t argc, char **argv) { struct expr *expr = malloc(sizeof(*expr)); if (!expr) { perror("malloc()"); return NULL; } expr->eval = eval; expr->lhs = NULL; expr->rhs = NULL; expr->pure = false; expr->always_true = false; expr->always_false = false; expr->cost = FAST_COST; expr->probability = 0.5; expr->evaluations = 0; expr->successes = 0; expr->elapsed.tv_sec = 0; expr->elapsed.tv_nsec = 0; expr->argc = argc; expr->argv = argv; expr->cfile = NULL; expr->regex = NULL; expr->execbuf = NULL; expr->printf = NULL; expr->persistent_fds = 0; expr->ephemeral_fds = 0; return expr; } /** * Create a new unary expression. */ static struct expr *new_unary_expr(eval_fn *eval, struct expr *rhs, char **argv) { struct expr *expr = new_expr(eval, 1, argv); if (!expr) { free_expr(rhs); return NULL; } expr->rhs = rhs; expr->persistent_fds = rhs->persistent_fds; expr->ephemeral_fds = rhs->ephemeral_fds; return expr; } /** * Create a new binary expression. */ static struct expr *new_binary_expr(eval_fn *eval, struct expr *lhs, struct expr *rhs, char **argv) { struct expr *expr = new_expr(eval, 1, argv); if (!expr) { free_expr(rhs); free_expr(lhs); return NULL; } expr->lhs = lhs; expr->rhs = rhs; expr->persistent_fds = lhs->persistent_fds + rhs->persistent_fds; if (lhs->ephemeral_fds > rhs->ephemeral_fds) { expr->ephemeral_fds = lhs->ephemeral_fds; } else { expr->ephemeral_fds = rhs->ephemeral_fds; } return expr; } /** * Check if an expression never returns. */ bool expr_never_returns(const struct expr *expr) { // Expressions that never return are vacuously both always true and always false return expr->always_true && expr->always_false; } /** * Set an expression to always return true. */ static void expr_set_always_true(struct expr *expr) { expr->always_true = true; expr->probability = 1.0; } /** * Set an expression to never return. */ static void expr_set_never_returns(struct expr *expr) { expr->always_true = expr->always_false = true; } /** * Color use flags. */ enum use_color { COLOR_NEVER, COLOR_AUTO, COLOR_ALWAYS, }; /** * Ephemeral state for parsing the command line. */ struct parser_state { /** The command line being constructed. */ struct bfs_ctx *ctx; /** The command line arguments being parsed. */ char **argv; /** The name of this program. */ const char *command; /** The current regex flags to use. */ int regex_flags; /** Whether stdout is a terminal. */ bool stdout_tty; /** Whether this session is interactive (stdin and stderr are each a terminal). */ bool interactive; /** Whether stdin has been consumed by -files0-from -. */ bool stdin_consumed; /** Whether -color or -nocolor has been passed. */ enum use_color use_color; /** Whether a -print action is implied. */ bool implicit_print; /** Whether the default root "." should be used. */ bool implicit_root; /** Whether the expression has started. */ bool expr_started; /** Whether any non-option arguments have been encountered. */ bool non_option_seen; /** Whether an information option like -help or -version was passed. */ bool just_info; /** Whether we are currently parsing an -exclude expression. */ bool excluding; /** The last non-path argument. */ const char *last_arg; /** A "-depth"-type argument if any. */ const char *depth_arg; /** A "-prune"-type argument if any. */ const char *prune_arg; /** A "-mount"-type argument if any. */ const char *mount_arg; /** An "-xdev"-type argument if any. */ const char *xdev_arg; /** An "-ok"-type argument if any. */ const char *ok_arg; /** The current time. */ struct timespec now; }; /** * Possible token types. */ enum token_type { /** A flag. */ T_FLAG, /** A root path. */ T_PATH, /** An option. */ T_OPTION, /** A test. */ T_TEST, /** An action. */ T_ACTION, /** An operator. */ T_OPERATOR, }; /** * Print an error message during parsing. */ BFS_FORMATTER(2, 3) static void parse_error(const struct parser_state *state, const char *format, ...) { va_list args; va_start(args, format); bfs_verror(state->ctx, format, args); va_end(args); } /** * Print a low-level error message during parsing. */ static void parse_perror(const struct parser_state *state, const char *str) { bfs_perror(state->ctx, str); } /** * Print a warning message during parsing. */ BFS_FORMATTER(2, 3) static bool parse_warning(const struct parser_state *state, const char *format, ...) { va_list args; va_start(args, format); bool ret = bfs_vwarning(state->ctx, format, args); va_end(args); return ret; } /** * Fill in a "-print"-type expression. */ static void init_print_expr(struct parser_state *state, struct expr *expr) { expr_set_always_true(expr); expr->cost = PRINT_COST; expr->cfile = state->ctx->cout; } /** * Open a file for an expression. */ static int expr_open(struct parser_state *state, struct expr *expr, const char *path) { struct bfs_ctx *ctx = state->ctx; FILE *file = NULL; CFILE *cfile = NULL; file = xfopen(path, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC); if (!file) { goto fail; } cfile = cfwrap(file, state->use_color ? ctx->colors : NULL, true); if (!cfile) { goto fail; } CFILE *dedup = bfs_ctx_dedup(ctx, cfile, path); if (!dedup) { goto fail; } if (dedup != cfile) { cfclose(cfile); } expr->cfile = dedup; return 0; fail: parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: %m.\n", expr->argv[0], path); if (cfile) { cfclose(cfile); } else if (file) { fclose(file); } return -1; } /** * Invoke bfs_stat() on an argument. */ static int stat_arg(const struct parser_state *state, struct expr *expr, struct bfs_stat *sb) { const struct bfs_ctx *ctx = state->ctx; bool follow = ctx->flags & (BFTW_FOLLOW_ROOTS | BFTW_FOLLOW_ALL); enum bfs_stat_flags flags = follow ? BFS_STAT_TRYFOLLOW : BFS_STAT_NOFOLLOW; int ret = bfs_stat(AT_FDCWD, expr->sdata, flags, sb); if (ret != 0) { parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: %m.\n", expr->argv[0], expr->sdata); } return ret; } /** * Parse the expression specified on the command line. */ static struct expr *parse_expr(struct parser_state *state); /** * Advance by a single token. */ static char **parser_advance(struct parser_state *state, enum token_type type, size_t argc) { if (type != T_FLAG && type != T_PATH) { state->expr_started = true; if (type != T_OPTION) { state->non_option_seen = true; } } if (type != T_PATH) { state->last_arg = *state->argv; } char **argv = state->argv; state->argv += argc; return argv; } /** * Parse a root path. */ static int parse_root(struct parser_state *state, const char *path) { char *copy = strdup(path); if (!copy) { parse_perror(state, "strdup()"); return -1; } struct bfs_ctx *ctx = state->ctx; if (DARRAY_PUSH(&ctx->paths, ©) != 0) { parse_perror(state, "DARRAY_PUSH()"); free(copy); return -1; } state->implicit_root = false; return 0; } /** * While parsing an expression, skip any paths and add them to ctx->paths. */ static int skip_paths(struct parser_state *state) { while (true) { const char *arg = state->argv[0]; if (!arg) { return 0; } if (arg[0] == '-') { if (strcmp(arg, "--") == 0) { // find uses -- to separate flags from the rest // of the command line. We allow mixing flags // and paths/predicates, so we just ignore --. parser_advance(state, T_FLAG, 1); continue; } if (strcmp(arg, "-") != 0) { // - by itself is a file name. Anything else // starting with - is a flag/predicate. return 0; } } // By POSIX, these are always options if (strcmp(arg, "(") == 0 || strcmp(arg, "!") == 0) { return 0; } if (state->expr_started) { // By POSIX, these can be paths. We only treat them as // such at the beginning of the command line. if (strcmp(arg, ")") == 0 || strcmp(arg, ",") == 0) { return 0; } } if (parse_root(state, arg) != 0) { return -1; } parser_advance(state, T_PATH, 1); } } /** Integer parsing flags. */ enum int_flags { IF_BASE_MASK = 0x03F, IF_INT = 0x040, IF_LONG = 0x080, IF_LONG_LONG = 0x0C0, IF_SIZE_MASK = 0x0C0, IF_UNSIGNED = 0x100, IF_PARTIAL_OK = 0x200, IF_QUIET = 0x400, }; /** * Parse an integer. */ static const char *parse_int(const struct parser_state *state, const char *str, void *result, enum int_flags flags) { char *endptr; int base = flags & IF_BASE_MASK; if (base == 0) { base = 10; } errno = 0; long long value = strtoll(str, &endptr, base); if (errno != 0) { if (errno == ERANGE) { goto range; } else { goto bad; } } if (endptr == str) { goto bad; } if (!(flags & IF_PARTIAL_OK) && *endptr != '\0') { goto bad; } if ((flags & IF_UNSIGNED) && value < 0) { goto negative; } switch (flags & IF_SIZE_MASK) { case IF_INT: if (value < INT_MIN || value > INT_MAX) { goto range; } *(int *)result = value; break; case IF_LONG: if (value < LONG_MIN || value > LONG_MAX) { goto range; } *(long *)result = value; break; case IF_LONG_LONG: *(long long *)result = value; break; default: assert(!"Invalid int size"); goto bad; } return endptr; bad: if (!(flags & IF_QUIET)) { parse_error(state, "${bld}%s${rs} is not a valid integer.\n", str); } return NULL; negative: if (!(flags & IF_QUIET)) { parse_error(state, "Negative integer ${bld}%s${rs} is not allowed here.\n", str); } return NULL; range: if (!(flags & IF_QUIET)) { parse_error(state, "${bld}%s${rs} is too large an integer.\n", str); } return NULL; } /** * Parse an integer and a comparison flag. */ static const char *parse_icmp(const struct parser_state *state, const char *str, struct expr *expr, enum int_flags flags) { switch (str[0]) { case '-': expr->cmp_flag = CMP_LESS; ++str; break; case '+': expr->cmp_flag = CMP_GREATER; ++str; break; default: expr->cmp_flag = CMP_EXACT; break; } return parse_int(state, str, &expr->idata, flags | IF_LONG_LONG | IF_UNSIGNED); } /** * Check if a string could be an integer comparison. */ static bool looks_like_icmp(const char *str) { int i; // One +/- for the comparison flag, one for the sign for (i = 0; i < 2; ++i) { if (str[i] != '-' && str[i] != '+') { break; } } return str[i] >= '0' && str[i] <= '9'; } /** * Parse a single flag. */ static struct expr *parse_flag(struct parser_state *state, size_t argc) { parser_advance(state, T_FLAG, argc); return &expr_true; } /** * Parse a flag that doesn't take a value. */ static struct expr *parse_nullary_flag(struct parser_state *state) { return parse_flag(state, 1); } /** * Parse a flag that takes a single value. */ static struct expr *parse_unary_flag(struct parser_state *state) { return parse_flag(state, 2); } /** * Parse a single option. */ static struct expr *parse_option(struct parser_state *state, size_t argc) { const char *arg = *parser_advance(state, T_OPTION, argc); if (state->non_option_seen) { parse_warning(state, "The ${blu}%s${rs} option applies to the entire command line. For clarity, place\n" "it before any non-option arguments.\n\n", arg); } return &expr_true; } /** * Parse an option that doesn't take a value. */ static struct expr *parse_nullary_option(struct parser_state *state) { return parse_option(state, 1); } /** * Parse an option that takes a value. */ static struct expr *parse_unary_option(struct parser_state *state) { return parse_option(state, 2); } /** * Parse a single positional option. */ static struct expr *parse_positional_option(struct parser_state *state, size_t argc) { parser_advance(state, T_OPTION, argc); return &expr_true; } /** * Parse a positional option that doesn't take a value. */ static struct expr *parse_nullary_positional_option(struct parser_state *state) { return parse_positional_option(state, 1); } /** * Parse a positional option that takes a single value. */ static struct expr *parse_unary_positional_option(struct parser_state *state) { return parse_positional_option(state, 2); } /** * Parse a single test. */ static struct expr *parse_test(struct parser_state *state, eval_fn *eval, size_t argc) { char **argv = parser_advance(state, T_TEST, argc); struct expr *expr = new_expr(eval, argc, argv); if (expr) { expr->pure = true; } return expr; } /** * Parse a test that doesn't take a value. */ static struct expr *parse_nullary_test(struct parser_state *state, eval_fn *eval) { return parse_test(state, eval, 1); } /** * Parse a test that takes a value. */ static struct expr *parse_unary_test(struct parser_state *state, eval_fn *eval) { const char *arg = state->argv[0]; const char *value = state->argv[1]; if (!value) { parse_error(state, "${blu}%s${rs} needs a value.\n", arg); return NULL; } struct expr *expr = parse_test(state, eval, 2); if (expr) { expr->sdata = value; } return expr; } /** * Parse a single action. */ static struct expr *parse_action(struct parser_state *state, eval_fn *eval, size_t argc) { char **argv = state->argv; if (state->excluding) { parse_error(state, "The ${blu}%s${rs} action is not supported within ${red}-exclude${rs}.\n", argv[0]); return NULL; } if (eval != eval_prune && eval != eval_quit) { state->implicit_print = false; } parser_advance(state, T_ACTION, argc); return new_expr(eval, argc, argv); } /** * Parse an action that takes no arguments. */ static struct expr *parse_nullary_action(struct parser_state *state, eval_fn *eval) { return parse_action(state, eval, 1); } /** * Parse an action that takes one argument. */ static struct expr *parse_unary_action(struct parser_state *state, eval_fn *eval) { const char *arg = state->argv[0]; const char *value = state->argv[1]; if (!value) { parse_error(state, "${blu}%s${rs} needs a value.\n", arg); return NULL; } struct expr *expr = parse_action(state, eval, 2); if (expr) { expr->sdata = value; } return expr; } /** * Parse a test expression with integer data and a comparison flag. */ static struct expr *parse_test_icmp(struct parser_state *state, eval_fn *eval) { struct expr *expr = parse_unary_test(state, eval); if (!expr) { return NULL; } if (!parse_icmp(state, expr->sdata, expr, 0)) { free_expr(expr); return NULL; } return expr; } /** * Print usage information for -D. */ static void debug_help(CFILE *cfile) { cfprintf(cfile, "Supported debug flags:\n\n"); cfprintf(cfile, " ${bld}help${rs}: This message.\n"); cfprintf(cfile, " ${bld}cost${rs}: Show cost estimates.\n"); cfprintf(cfile, " ${bld}exec${rs}: Print executed command details.\n"); cfprintf(cfile, " ${bld}opt${rs}: Print optimization details.\n"); cfprintf(cfile, " ${bld}rates${rs}: Print predicate success rates.\n"); cfprintf(cfile, " ${bld}search${rs}: Trace the filesystem traversal.\n"); cfprintf(cfile, " ${bld}stat${rs}: Trace all stat() calls.\n"); cfprintf(cfile, " ${bld}tree${rs}: Print the parse tree.\n"); cfprintf(cfile, " ${bld}all${rs}: All debug flags at once.\n"); } /** Check if a substring matches a debug flag. */ static bool parse_debug_flag(const char *flag, size_t len, const char *expected) { if (len == strlen(expected)) { return strncmp(flag, expected, len) == 0; } else { return false; } } /** * Parse -D FLAG. */ static struct expr *parse_debug(struct parser_state *state, int arg1, int arg2) { struct bfs_ctx *ctx = state->ctx; const char *arg = state->argv[0]; const char *flags = state->argv[1]; if (!flags) { parse_error(state, "${cyn}%s${rs} needs a flag.\n\n", arg); debug_help(ctx->cerr); return NULL; } bool unrecognized = false; for (const char *flag = flags, *next; flag; flag = next) { size_t len = strcspn(flag, ","); if (flag[len]) { next = flag + len + 1; } else { next = NULL; } if (parse_debug_flag(flag, len, "help")) { debug_help(ctx->cout); state->just_info = true; return NULL; } else if (parse_debug_flag(flag, len, "all")) { ctx->debug = DEBUG_ALL; continue; } enum debug_flags i; for (i = 1; DEBUG_ALL & i; i <<= 1) { const char *name = debug_flag_name(i); if (parse_debug_flag(flag, len, name)) { break; } } if (DEBUG_ALL & i) { ctx->debug |= i; } else { if (parse_warning(state, "Unrecognized debug flag ${bld}")) { fwrite(flag, 1, len, stderr); cfprintf(ctx->cerr, "${rs}.\n\n"); unrecognized = true; } } } if (unrecognized) { debug_help(ctx->cerr); cfprintf(ctx->cerr, "\n"); } return parse_unary_flag(state); } /** * Parse -On. */ static struct expr *parse_optlevel(struct parser_state *state, int arg1, int arg2) { int *optlevel = &state->ctx->optlevel; if (strcmp(state->argv[0], "-Ofast") == 0) { *optlevel = 4; } else if (!parse_int(state, state->argv[0] + 2, optlevel, IF_INT | IF_UNSIGNED)) { return NULL; } if (*optlevel > 4) { parse_warning(state, "${cyn}-O${bld}%s${rs} is the same as ${cyn}-O${bld}4${rs}.\n\n", state->argv[0] + 2); } return parse_nullary_flag(state); } /** * Parse -[PHL], -(no)?follow. */ static struct expr *parse_follow(struct parser_state *state, int flags, int option) { struct bfs_ctx *ctx = state->ctx; ctx->flags &= ~(BFTW_FOLLOW_ROOTS | BFTW_FOLLOW_ALL); ctx->flags |= flags; if (option) { return parse_nullary_positional_option(state); } else { return parse_nullary_flag(state); } } /** * Parse -X. */ static struct expr *parse_xargs_safe(struct parser_state *state, int arg1, int arg2) { state->ctx->xargs_safe = true; return parse_nullary_flag(state); } /** * Parse -executable, -readable, -writable */ static struct expr *parse_access(struct parser_state *state, int flag, int arg2) { struct expr *expr = parse_nullary_test(state, eval_access); if (!expr) { return NULL; } expr->idata = flag; expr->cost = STAT_COST; switch (flag) { case R_OK: expr->probability = 0.99; break; case W_OK: expr->probability = 0.8; break; case X_OK: expr->probability = 0.2; break; } return expr; } /** * Parse -acl. */ static struct expr *parse_acl(struct parser_state *state, int flag, int arg2) { #if BFS_CAN_CHECK_ACL struct expr *expr = parse_nullary_test(state, eval_acl); if (expr) { expr->cost = STAT_COST; expr->probability = 0.00002; } return expr; #else parse_error(state, "${blu}%s${rs} is missing platform support.\n", state->argv[0]); return NULL; #endif } /** * Parse -[aBcm]?newer. */ static struct expr *parse_newer(struct parser_state *state, int field, int arg2) { struct expr *expr = parse_unary_test(state, eval_newer); if (!expr) { return NULL; } struct bfs_stat sb; if (stat_arg(state, expr, &sb) != 0) { goto fail; } expr->cost = STAT_COST; expr->reftime = sb.mtime; expr->stat_field = field; return expr; fail: free_expr(expr); return NULL; } /** * Parse -[aBcm]min. */ static struct expr *parse_min(struct parser_state *state, int field, int arg2) { struct expr *expr = parse_test_icmp(state, eval_time); if (!expr) { return NULL; } expr->cost = STAT_COST; expr->reftime = state->now; expr->stat_field = field; expr->time_unit = MINUTES; return expr; } /** * Parse -[aBcm]time. */ static struct expr *parse_time(struct parser_state *state, int field, int arg2) { struct expr *expr = parse_unary_test(state, eval_time); if (!expr) { return NULL; } expr->cost = STAT_COST; expr->reftime = state->now; expr->stat_field = field; const char *tail = parse_icmp(state, expr->sdata, expr, IF_PARTIAL_OK); if (!tail) { goto fail; } if (!*tail) { expr->time_unit = DAYS; return expr; } unsigned long long time = expr->idata; expr->idata = 0; while (true) { switch (*tail) { case 'w': time *= 7; BFS_FALLTHROUGH; case 'd': time *= 24; BFS_FALLTHROUGH; case 'h': time *= 60; BFS_FALLTHROUGH; case 'm': time *= 60; BFS_FALLTHROUGH; case 's': break; default: parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Unknown time unit ${bld}%c${rs}.\n", expr->argv[0], expr->argv[1], *tail); goto fail; } expr->idata += time; if (!*++tail) { break; } tail = parse_int(state, tail, &time, IF_PARTIAL_OK | IF_LONG_LONG | IF_UNSIGNED); if (!tail) { goto fail; } if (!*tail) { parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Missing time unit.\n", expr->argv[0], expr->argv[1]); goto fail; } } expr->time_unit = SECONDS; return expr; fail: free_expr(expr); return NULL; } /** * Parse -capable. */ static struct expr *parse_capable(struct parser_state *state, int flag, int arg2) { #if BFS_CAN_CHECK_CAPABILITIES struct expr *expr = parse_nullary_test(state, eval_capable); if (expr) { expr->cost = STAT_COST; expr->probability = 0.000002; } return expr; #else parse_error(state, "${blu}%s${rs} is missing platform support.\n", state->argv[0]); return NULL; #endif } /** * Parse -(no)?color. */ static struct expr *parse_color(struct parser_state *state, int color, int arg2) { struct bfs_ctx *ctx = state->ctx; struct colors *colors = ctx->colors; if (color) { if (!colors) { parse_error(state, "${blu}%s${rs}: %s.\n", state->argv[0], strerror(ctx->colors_error)); return NULL; } state->use_color = COLOR_ALWAYS; ctx->cout->colors = colors; ctx->cerr->colors = colors; } else { state->use_color = COLOR_NEVER; ctx->cout->colors = NULL; ctx->cerr->colors = NULL; } return parse_nullary_option(state); } /** * Parse -{false,true}. */ static struct expr *parse_const(struct parser_state *state, int value, int arg2) { parser_advance(state, T_TEST, 1); return value ? &expr_true : &expr_false; } /** * Parse -daystart. */ static struct expr *parse_daystart(struct parser_state *state, int arg1, int arg2) { struct tm tm; if (xlocaltime(&state->now.tv_sec, &tm) != 0) { parse_perror(state, "xlocaltime()"); return NULL; } if (tm.tm_hour || tm.tm_min || tm.tm_sec || state->now.tv_nsec) { ++tm.tm_mday; } tm.tm_hour = 0; tm.tm_min = 0; tm.tm_sec = 0; time_t time; if (xmktime(&tm, &time) != 0) { parse_perror(state, "xmktime()"); return NULL; } state->now.tv_sec = time; state->now.tv_nsec = 0; return parse_nullary_positional_option(state); } /** * Parse -delete. */ static struct expr *parse_delete(struct parser_state *state, int arg1, int arg2) { state->ctx->flags |= BFTW_POST_ORDER; state->depth_arg = state->argv[0]; return parse_nullary_action(state, eval_delete); } /** * Parse -d. */ static struct expr *parse_depth(struct parser_state *state, int arg1, int arg2) { state->ctx->flags |= BFTW_POST_ORDER; state->depth_arg = state->argv[0]; return parse_nullary_flag(state); } /** * Parse -depth [N]. */ static struct expr *parse_depth_n(struct parser_state *state, int arg1, int arg2) { const char *arg = state->argv[1]; if (arg && looks_like_icmp(arg)) { return parse_test_icmp(state, eval_depth); } else { return parse_depth(state, arg1, arg2); } } /** * Parse -{min,max}depth N. */ static struct expr *parse_depth_limit(struct parser_state *state, int is_min, int arg2) { struct bfs_ctx *ctx = state->ctx; const char *arg = state->argv[0]; const char *value = state->argv[1]; if (!value) { parse_error(state, "${blu}%s${rs} needs a value.\n", arg); return NULL; } int *depth = is_min ? &ctx->mindepth : &ctx->maxdepth; if (!parse_int(state, value, depth, IF_INT | IF_UNSIGNED)) { return NULL; } return parse_unary_option(state); } /** * Parse -empty. */ static struct expr *parse_empty(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_nullary_test(state, eval_empty); if (!expr) { return NULL; } expr->cost = 2000.0; expr->probability = 0.01; if (state->ctx->optlevel < 4) { // Since -empty attempts to open and read directories, it may // have side effects such as reporting permission errors, and // thus shouldn't be re-ordered without aggressive optimizations expr->pure = false; } expr->ephemeral_fds = 1; return expr; } /** * Parse -exec(dir)?/-ok(dir)?. */ static struct expr *parse_exec(struct parser_state *state, int flags, int arg2) { struct bfs_exec *execbuf = bfs_exec_parse(state->ctx, state->argv, flags); if (!execbuf) { return NULL; } struct expr *expr = parse_action(state, eval_exec, execbuf->tmpl_argc + 2); if (!expr) { bfs_exec_free(execbuf); return NULL; } expr->execbuf = execbuf; if (execbuf->flags & BFS_EXEC_MULTI) { expr_set_always_true(expr); } else { expr->cost = 1000000.0; } expr->ephemeral_fds = 2; if (execbuf->flags & BFS_EXEC_CHDIR) { if (execbuf->flags & BFS_EXEC_MULTI) { expr->persistent_fds = 1; } else { ++expr->ephemeral_fds; } } if (execbuf->flags & BFS_EXEC_CONFIRM) { state->ok_arg = expr->argv[0]; } return expr; } /** * Parse -exit [STATUS]. */ static struct expr *parse_exit(struct parser_state *state, int arg1, int arg2) { size_t argc = 1; const char *value = state->argv[1]; int status = EXIT_SUCCESS; if (value && parse_int(state, value, &status, IF_INT | IF_UNSIGNED | IF_QUIET)) { argc = 2; } struct expr *expr = parse_action(state, eval_exit, argc); if (expr) { expr_set_never_returns(expr); expr->idata = status; } return expr; } /** * Parse -f PATH. */ static struct expr *parse_f(struct parser_state *state, int arg1, int arg2) { parser_advance(state, T_FLAG, 1); const char *path = state->argv[0]; if (!path) { parse_error(state, "${cyn}-f${rs} requires a path.\n"); return NULL; } if (parse_root(state, path) != 0) { return NULL; } parser_advance(state, T_PATH, 1); return &expr_true; } /** * Parse -files0-from PATH. */ static struct expr *parse_files0_from(struct parser_state *state, int arg1, int arg2) { const char *arg = state->argv[0]; const char *from = state->argv[1]; if (!from) { parse_error(state, "${blu}%s${rs} requires a path.\n", arg); return NULL; } FILE *file; if (strcmp(from, "-") == 0) { file = stdin; } else { file = xfopen(from, O_RDONLY | O_CLOEXEC); } if (!file) { parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: %m.\n", arg, from); return NULL; } struct expr *expr = parse_unary_positional_option(state); while (true) { char *path = xgetdelim(file, '\0'); if (!path) { if (errno) { parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: %m.\n", arg, from); expr = NULL; } break; } int ret = parse_root(state, path); free(path); if (ret != 0) { expr = NULL; break; } } if (file == stdin) { state->stdin_consumed = true; } else { fclose(file); } state->implicit_root = false; return expr; } /** * Parse -flags FLAGS. */ static struct expr *parse_flags(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_unary_test(state, eval_flags); if (!expr) { return NULL; } const char *flags = expr->sdata; switch (flags[0]) { case '-': expr->mode_cmp = MODE_ALL; ++flags; break; case '+': expr->mode_cmp = MODE_ANY; ++flags; break; default: expr->mode_cmp = MODE_EXACT; break; } if (xstrtofflags(&flags, &expr->set_flags, &expr->clear_flags) != 0) { if (errno == ENOTSUP) { parse_error(state, "${blu}%s${rs} is missing platform support.\n", expr->argv[0]); } else { parse_error(state, "${blu}%s${rs}: Invalid flags ${bld}%s${rs}.\n", expr->argv[0], flags); } free_expr(expr); return NULL; } return expr; } /** * Parse -fls FILE. */ static struct expr *parse_fls(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_unary_action(state, eval_fls); if (!expr) { goto fail; } if (expr_open(state, expr, expr->sdata) != 0) { goto fail; } expr_set_always_true(expr); expr->cost = PRINT_COST; expr->reftime = state->now; // We'll need these for user/group names, so initialize them now to // avoid EMFILE later bfs_ctx_users(state->ctx); bfs_ctx_groups(state->ctx); return expr; fail: free_expr(expr); return NULL; } /** * Parse -fprint FILE. */ static struct expr *parse_fprint(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_unary_action(state, eval_fprint); if (expr) { expr_set_always_true(expr); expr->cost = PRINT_COST; if (expr_open(state, expr, expr->sdata) != 0) { goto fail; } } return expr; fail: free_expr(expr); return NULL; } /** * Parse -fprint0 FILE. */ static struct expr *parse_fprint0(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_unary_action(state, eval_fprint0); if (expr) { expr_set_always_true(expr); expr->cost = PRINT_COST; if (expr_open(state, expr, expr->sdata) != 0) { goto fail; } } return expr; fail: free_expr(expr); return NULL; } /** * Parse -fprintf FILE FORMAT. */ static struct expr *parse_fprintf(struct parser_state *state, int arg1, int arg2) { const char *arg = state->argv[0]; const char *file = state->argv[1]; if (!file) { parse_error(state, "${blu}%s${rs} needs a file.\n", arg); return NULL; } const char *format = state->argv[2]; if (!format) { parse_error(state, "${blu}%s${rs} needs a format string.\n", arg); return NULL; } struct expr *expr = parse_action(state, eval_fprintf, 3); if (!expr) { return NULL; } expr_set_always_true(expr); expr->cost = PRINT_COST; if (expr_open(state, expr, file) != 0) { goto fail; } expr->printf = bfs_printf_parse(state->ctx, format); if (!expr->printf) { goto fail; } return expr; fail: free_expr(expr); return NULL; } /** * Parse -fstype TYPE. */ static struct expr *parse_fstype(struct parser_state *state, int arg1, int arg2) { if (!bfs_ctx_mtab(state->ctx)) { parse_error(state, "Couldn't parse the mount table: %m.\n"); return NULL; } struct expr *expr = parse_unary_test(state, eval_fstype); if (expr) { expr->cost = STAT_COST; } return expr; } /** * Parse -gid/-group. */ static struct expr *parse_group(struct parser_state *state, int arg1, int arg2) { const struct bfs_groups *groups = bfs_ctx_groups(state->ctx); if (!groups) { parse_error(state, "Couldn't parse the group table: %m.\n"); return NULL; } const char *arg = state->argv[0]; struct expr *expr = parse_unary_test(state, eval_gid); if (!expr) { return NULL; } const struct group *grp = bfs_getgrnam(groups, expr->sdata); if (grp) { expr->idata = grp->gr_gid; expr->cmp_flag = CMP_EXACT; } else if (looks_like_icmp(expr->sdata)) { if (!parse_icmp(state, expr->sdata, expr, 0)) { goto fail; } } else { parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: No such group.\n", arg, expr->sdata); goto fail; } expr->cost = STAT_COST; return expr; fail: free_expr(expr); return NULL; } /** * Parse -unique. */ static struct expr *parse_unique(struct parser_state *state, int arg1, int arg2) { state->ctx->unique = true; return parse_nullary_option(state); } /** * Parse -used N. */ static struct expr *parse_used(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_test_icmp(state, eval_used); if (expr) { expr->cost = STAT_COST; } return expr; } /** * Parse -uid/-user. */ static struct expr *parse_user(struct parser_state *state, int arg1, int arg2) { const struct bfs_users *users = bfs_ctx_users(state->ctx); if (!users) { parse_error(state, "Couldn't parse the user table: %m.\n"); return NULL; } const char *arg = state->argv[0]; struct expr *expr = parse_unary_test(state, eval_uid); if (!expr) { return NULL; } const struct passwd *pwd = bfs_getpwnam(users, expr->sdata); if (pwd) { expr->idata = pwd->pw_uid; expr->cmp_flag = CMP_EXACT; } else if (looks_like_icmp(expr->sdata)) { if (!parse_icmp(state, expr->sdata, expr, 0)) { goto fail; } } else { parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: No such user.\n", arg, expr->sdata); goto fail; } expr->cost = STAT_COST; return expr; fail: free_expr(expr); return NULL; } /** * Parse -hidden. */ static struct expr *parse_hidden(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_nullary_test(state, eval_hidden); if (expr) { expr->probability = 0.01; } return expr; } /** * Parse -(no)?ignore_readdir_race. */ static struct expr *parse_ignore_races(struct parser_state *state, int ignore, int arg2) { state->ctx->ignore_races = ignore; return parse_nullary_option(state); } /** * Parse -inum N. */ static struct expr *parse_inum(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_test_icmp(state, eval_inum); if (expr) { expr->cost = STAT_COST; expr->probability = expr->cmp_flag == CMP_EXACT ? 0.01 : 0.50; } return expr; } /** * Parse -links N. */ static struct expr *parse_links(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_test_icmp(state, eval_links); if (expr) { expr->cost = STAT_COST; expr->probability = expr_cmp(expr, 1) ? 0.99 : 0.01; } return expr; } /** * Parse -ls. */ static struct expr *parse_ls(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_nullary_action(state, eval_fls); if (!expr) { return NULL; } init_print_expr(state, expr); expr->reftime = state->now; // We'll need these for user/group names, so initialize them now to // avoid EMFILE later bfs_ctx_users(state->ctx); bfs_ctx_groups(state->ctx); return expr; } /** * Parse -mount. */ static struct expr *parse_mount(struct parser_state *state, int arg1, int arg2) { parse_warning(state, "In the future, ${blu}%s${rs} will skip mount points entirely, unlike\n" "${blu}-xdev${rs}, due to http://austingroupbugs.net/view.php?id=1133.\n\n", state->argv[0]); state->ctx->flags |= BFTW_PRUNE_MOUNTS; state->mount_arg = state->argv[0]; return parse_nullary_option(state); } /** * Common code for fnmatch() tests. */ static struct expr *parse_fnmatch(const struct parser_state *state, struct expr *expr, bool casefold) { if (!expr) { return NULL; } if (casefold) { #ifdef FNM_CASEFOLD expr->idata = FNM_CASEFOLD; #else parse_error(state, "${blu}%s${rs} is missing platform support.\n", expr->argv[0]); free_expr(expr); return NULL; #endif } else { expr->idata = 0; } expr->cost = 400.0; if (strchr(expr->sdata, '*')) { expr->probability = 0.5; } else { expr->probability = 0.1; } return expr; } /** * Parse -i?name. */ static struct expr *parse_name(struct parser_state *state, int casefold, int arg2) { struct expr *expr = parse_unary_test(state, eval_name); return parse_fnmatch(state, expr, casefold); } /** * Parse -i?path, -i?wholename. */ static struct expr *parse_path(struct parser_state *state, int casefold, int arg2) { struct expr *expr = parse_unary_test(state, eval_path); return parse_fnmatch(state, expr, casefold); } /** * Parse -i?lname. */ static struct expr *parse_lname(struct parser_state *state, int casefold, int arg2) { struct expr *expr = parse_unary_test(state, eval_lname); return parse_fnmatch(state, expr, casefold); } /** Get the bfs_stat_field for X/Y in -newerXY. */ static enum bfs_stat_field parse_newerxy_field(char c) { switch (c) { case 'a': return BFS_STAT_ATIME; case 'B': return BFS_STAT_BTIME; case 'c': return BFS_STAT_CTIME; case 'm': return BFS_STAT_MTIME; default: return 0; } } /** Parse an explicit reference timestamp for -newerXt and -*since. */ static int parse_reftime(const struct parser_state *state, struct expr *expr) { if (parse_timestamp(expr->sdata, &expr->reftime) == 0) { return 0; } else if (errno != EINVAL) { parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: %m.\n", expr->argv[0], expr->argv[1]); return -1; } parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Invalid timestamp.\n\n", expr->argv[0], expr->argv[1]); fprintf(stderr, "Supported timestamp formats are ISO 8601-like, e.g.\n\n"); struct tm tm; if (xlocaltime(&state->now.tv_sec, &tm) != 0) { parse_perror(state, "xlocaltime()"); return -1; } int year = tm.tm_year + 1900; int month = tm.tm_mon + 1; fprintf(stderr, " - %04d-%02d-%02d\n", year, month, tm.tm_mday); fprintf(stderr, " - %04d-%02d-%02dT%02d:%02d:%02d\n", year, month, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec); #if __FreeBSD__ int gmtoff = tm.tm_gmtoff; #else int gmtoff = -timezone; #endif int tz_hour = gmtoff/3600; int tz_min = (labs(gmtoff)/60)%60; fprintf(stderr, " - %04d-%02d-%02dT%02d:%02d:%02d%+03d:%02d\n", year, month, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, tz_hour, tz_min); if (xgmtime(&state->now.tv_sec, &tm) != 0) { parse_perror(state, "xgmtime()"); return -1; } year = tm.tm_year + 1900; month = tm.tm_mon + 1; fprintf(stderr, " - %04d-%02d-%02dT%02d:%02d:%02dZ\n", year, month, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec); return -1; } /** * Parse -newerXY. */ static struct expr *parse_newerxy(struct parser_state *state, int arg1, int arg2) { const char *arg = state->argv[0]; if (strlen(arg) != 8) { parse_error(state, "Expected ${blu}-newer${bld}XY${rs}; found ${blu}-newer${bld}%s${rs}.\n", arg + 6); return NULL; } struct expr *expr = parse_unary_test(state, eval_newer); if (!expr) { goto fail; } expr->stat_field = parse_newerxy_field(arg[6]); if (!expr->stat_field) { parse_error(state, "${blu}%s${rs}: For ${blu}-newer${bld}XY${rs}, ${bld}X${rs} should be ${bld}a${rs}, ${bld}c${rs}, ${bld}m${rs}, or ${bld}B${rs}, not ${er}%c${rs}.\n", arg, arg[6]); goto fail; } if (arg[7] == 't') { if (parse_reftime(state, expr) != 0) { goto fail; } } else { enum bfs_stat_field field = parse_newerxy_field(arg[7]); if (!field) { parse_error(state, "${blu}%s${rs}: For ${blu}-newer${bld}XY${rs}, ${bld}Y${rs} should be ${bld}a${rs}, ${bld}c${rs}, ${bld}m${rs}, ${bld}B${rs}, or ${bld}t${rs}, not ${er}%c${rs}.\n", arg, arg[7]); goto fail; } struct bfs_stat sb; if (stat_arg(state, expr, &sb) != 0) { goto fail; } const struct timespec *reftime = bfs_stat_time(&sb, field); if (!reftime) { parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Couldn't get file %s.\n", arg, expr->sdata, bfs_stat_field_name(field)); goto fail; } expr->reftime = *reftime; } expr->cost = STAT_COST; return expr; fail: free_expr(expr); return NULL; } /** * Parse -nogroup. */ static struct expr *parse_nogroup(struct parser_state *state, int arg1, int arg2) { if (!bfs_ctx_groups(state->ctx)) { parse_error(state, "Couldn't parse the group table: %m.\n"); return NULL; } struct expr *expr = parse_nullary_test(state, eval_nogroup); if (expr) { expr->cost = STAT_COST; expr->probability = 0.01; } return expr; } /** * Parse -nohidden. */ static struct expr *parse_nohidden(struct parser_state *state, int arg1, int arg2) { struct expr *hidden = new_expr(eval_hidden, 1, &fake_hidden_arg); if (!hidden) { return NULL; } hidden->probability = 0.01; hidden->pure = true; struct bfs_ctx *ctx = state->ctx; ctx->exclude = new_binary_expr(eval_or, ctx->exclude, hidden, &fake_or_arg); if (!ctx->exclude) { return NULL; } parser_advance(state, T_OPTION, 1); return &expr_true; } /** * Parse -noleaf. */ static struct expr *parse_noleaf(struct parser_state *state, int arg1, int arg2) { parse_warning(state, "${ex}bfs${rs} does not apply the optimization that ${blu}%s${rs} inhibits.\n\n", state->argv[0]); return parse_nullary_option(state); } /** * Parse -nouser. */ static struct expr *parse_nouser(struct parser_state *state, int arg1, int arg2) { if (!bfs_ctx_users(state->ctx)) { parse_error(state, "Couldn't parse the user table: %m.\n"); return NULL; } struct expr *expr = parse_nullary_test(state, eval_nouser); if (expr) { expr->cost = STAT_COST; expr->probability = 0.01; } return expr; } /** * Parse a permission mode like chmod(1). */ static int parse_mode(const struct parser_state *state, const char *mode, struct expr *expr) { if (mode[0] >= '0' && mode[0] <= '9') { unsigned int parsed; if (!parse_int(state, mode, &parsed, 8 | IF_INT | IF_UNSIGNED | IF_QUIET)) { goto fail; } if (parsed > 07777) { goto fail; } expr->file_mode = parsed; expr->dir_mode = parsed; return 0; } expr->file_mode = 0; expr->dir_mode = 0; // Parse the same grammar as chmod(1), which looks like this: // // MODE : CLAUSE ["," CLAUSE]* // // CLAUSE : WHO* ACTION+ // // WHO : "u" | "g" | "o" | "a" // // ACTION : OP PERM* // | OP PERMCOPY // // OP : "+" | "-" | "=" // // PERM : "r" | "w" | "x" | "X" | "s" | "t" // // PERMCOPY : "u" | "g" | "o" // State machine state enum { MODE_CLAUSE, MODE_WHO, MODE_ACTION, MODE_ACTION_APPLY, MODE_OP, MODE_PERM, } mstate = MODE_CLAUSE; enum { MODE_PLUS, MODE_MINUS, MODE_EQUALS, } op; mode_t who; mode_t file_change; mode_t dir_change; const char *i = mode; while (true) { switch (mstate) { case MODE_CLAUSE: who = 0; mstate = MODE_WHO; BFS_FALLTHROUGH; case MODE_WHO: switch (*i) { case 'u': who |= 0700; break; case 'g': who |= 0070; break; case 'o': who |= 0007; break; case 'a': who |= 0777; break; default: mstate = MODE_ACTION; continue; } break; case MODE_ACTION_APPLY: switch (op) { case MODE_EQUALS: expr->file_mode &= ~who; expr->dir_mode &= ~who; BFS_FALLTHROUGH; case MODE_PLUS: expr->file_mode |= file_change; expr->dir_mode |= dir_change; break; case MODE_MINUS: expr->file_mode &= ~file_change; expr->dir_mode &= ~dir_change; break; } BFS_FALLTHROUGH; case MODE_ACTION: if (who == 0) { who = 0777; } switch (*i) { case '+': op = MODE_PLUS; mstate = MODE_OP; break; case '-': op = MODE_MINUS; mstate = MODE_OP; break; case '=': op = MODE_EQUALS; mstate = MODE_OP; break; case ',': if (mstate == MODE_ACTION_APPLY) { mstate = MODE_CLAUSE; } else { goto fail; } break; case '\0': if (mstate == MODE_ACTION_APPLY) { goto done; } else { goto fail; } default: goto fail; } break; case MODE_OP: switch (*i) { case 'u': file_change = (expr->file_mode >> 6) & 07; dir_change = (expr->dir_mode >> 6) & 07; break; case 'g': file_change = (expr->file_mode >> 3) & 07; dir_change = (expr->dir_mode >> 3) & 07; break; case 'o': file_change = expr->file_mode & 07; dir_change = expr->dir_mode & 07; break; default: file_change = 0; dir_change = 0; mstate = MODE_PERM; continue; } file_change |= (file_change << 6) | (file_change << 3); file_change &= who; dir_change |= (dir_change << 6) | (dir_change << 3); dir_change &= who; mstate = MODE_ACTION_APPLY; break; case MODE_PERM: switch (*i) { case 'r': file_change |= who & 0444; dir_change |= who & 0444; break; case 'w': file_change |= who & 0222; dir_change |= who & 0222; break; case 'x': file_change |= who & 0111; BFS_FALLTHROUGH; case 'X': dir_change |= who & 0111; break; case 's': if (who & 0700) { file_change |= S_ISUID; dir_change |= S_ISUID; } if (who & 0070) { file_change |= S_ISGID; dir_change |= S_ISGID; } break; case 't': if (who & 0007) { file_change |= S_ISVTX; dir_change |= S_ISVTX; } break; default: mstate = MODE_ACTION_APPLY; continue; } break; } ++i; } done: return 0; fail: parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Invalid mode.\n", expr->argv[0], mode); return -1; } /** * Parse -perm MODE. */ static struct expr *parse_perm(struct parser_state *state, int field, int arg2) { struct expr *expr = parse_unary_test(state, eval_perm); if (!expr) { return NULL; } const char *mode = expr->sdata; switch (mode[0]) { case '-': expr->mode_cmp = MODE_ALL; ++mode; break; case '/': expr->mode_cmp = MODE_ANY; ++mode; break; case '+': if (mode[1] >= '0' && mode[1] <= '9') { expr->mode_cmp = MODE_ANY; ++mode; break; } BFS_FALLTHROUGH; default: expr->mode_cmp = MODE_EXACT; break; } if (parse_mode(state, mode, expr) != 0) { goto fail; } expr->cost = STAT_COST; return expr; fail: free_expr(expr); return NULL; } /** * Parse -print. */ static struct expr *parse_print(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_nullary_action(state, eval_fprint); if (expr) { init_print_expr(state, expr); } return expr; } /** * Parse -print0. */ static struct expr *parse_print0(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_nullary_action(state, eval_fprint0); if (expr) { init_print_expr(state, expr); } return expr; } /** * Parse -printf FORMAT. */ static struct expr *parse_printf(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_unary_action(state, eval_fprintf); if (!expr) { return NULL; } init_print_expr(state, expr); expr->printf = bfs_printf_parse(state->ctx, expr->sdata); if (!expr->printf) { free_expr(expr); return NULL; } return expr; } /** * Parse -printx. */ static struct expr *parse_printx(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_nullary_action(state, eval_fprintx); if (expr) { init_print_expr(state, expr); } return expr; } /** * Parse -prune. */ static struct expr *parse_prune(struct parser_state *state, int arg1, int arg2) { state->prune_arg = state->argv[0]; struct expr *expr = parse_nullary_action(state, eval_prune); if (expr) { expr_set_always_true(expr); } return expr; } /** * Parse -quit. */ static struct expr *parse_quit(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_nullary_action(state, eval_quit); if (expr) { expr_set_never_returns(expr); } return expr; } /** * Parse -i?regex. */ static struct expr *parse_regex(struct parser_state *state, int flags, int arg2) { struct expr *expr = parse_unary_test(state, eval_regex); if (!expr) { goto fail; } expr->regex = malloc(sizeof(regex_t)); if (!expr->regex) { parse_perror(state, "malloc()"); goto fail; } int err = regcomp(expr->regex, expr->sdata, state->regex_flags | flags); if (err != 0) { char *str = xregerror(err, NULL); if (str) { parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: %s.\n", expr->argv[0], expr->argv[1], str); free(str); } else { parse_perror(state, "xregerror()"); } goto fail_regex; } return expr; fail_regex: free(expr->regex); expr->regex = NULL; fail: free_expr(expr); return NULL; } /** * Parse -E. */ static struct expr *parse_regex_extended(struct parser_state *state, int arg1, int arg2) { state->regex_flags = REG_EXTENDED; return parse_nullary_flag(state); } /** * Parse -regextype TYPE. */ static struct expr *parse_regextype(struct parser_state *state, int arg1, int arg2) { struct bfs_ctx *ctx = state->ctx; CFILE *cfile = ctx->cerr; const char *arg = state->argv[0]; const char *type = state->argv[1]; if (!type) { parse_error(state, "${blu}%s${rs} needs a value.\n\n", arg); goto list_types; } if (strcmp(type, "posix-basic") == 0) { state->regex_flags = 0; } else if (strcmp(type, "posix-extended") == 0) { state->regex_flags = REG_EXTENDED; } else if (strcmp(type, "help") == 0) { state->just_info = true; cfile = ctx->cout; goto list_types; } else { parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Unsupported regex type.\n\n", arg, type); goto list_types; } return parse_unary_positional_option(state); list_types: cfprintf(cfile, "Supported types are:\n\n"); cfprintf(cfile, " ${bld}posix-basic${rs}: POSIX basic regular expressions (BRE)\n"); cfprintf(cfile, " ${bld}posix-extended${rs}: POSIX extended regular expressions (ERE)\n"); return NULL; } /** * Parse -s. */ static struct expr *parse_s(struct parser_state *state, int arg1, int arg2) { state->ctx->flags |= BFTW_SORT; return parse_nullary_flag(state); } /** * Parse -samefile FILE. */ static struct expr *parse_samefile(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_unary_test(state, eval_samefile); if (!expr) { return NULL; } struct bfs_stat sb; if (stat_arg(state, expr, &sb) != 0) { free_expr(expr); return NULL; } expr->dev = sb.dev; expr->ino = sb.ino; expr->cost = STAT_COST; expr->probability = 0.01; return expr; } /** * Parse -S STRATEGY. */ static struct expr *parse_search_strategy(struct parser_state *state, int arg1, int arg2) { struct bfs_ctx *ctx = state->ctx; CFILE *cfile = ctx->cerr; const char *flag = state->argv[0]; const char *arg = state->argv[1]; if (!arg) { parse_error(state, "${cyn}%s${rs} needs an argument.\n\n", flag); goto list_strategies; } if (strcmp(arg, "bfs") == 0) { ctx->strategy = BFTW_BFS; } else if (strcmp(arg, "dfs") == 0) { ctx->strategy = BFTW_DFS; } else if (strcmp(arg, "ids") == 0) { ctx->strategy = BFTW_IDS; } else if (strcmp(arg, "eds") == 0) { ctx->strategy = BFTW_EDS; } else if (strcmp(arg, "help") == 0) { state->just_info = true; cfile = ctx->cout; goto list_strategies; } else { parse_error(state, "${cyn}%s${rs} ${bld}%s${rs}: Unrecognized search strategy.\n\n", flag, arg); goto list_strategies; } return parse_unary_flag(state); list_strategies: cfprintf(cfile, "Supported search strategies:\n\n"); cfprintf(cfile, " ${bld}bfs${rs}: breadth-first search\n"); cfprintf(cfile, " ${bld}dfs${rs}: depth-first search\n"); cfprintf(cfile, " ${bld}ids${rs}: iterative deepening search\n"); cfprintf(cfile, " ${bld}eds${rs}: exponential deepening search\n"); return NULL; } /** * Parse -[aBcm]?since. */ static struct expr *parse_since(struct parser_state *state, int field, int arg2) { struct expr *expr = parse_unary_test(state, eval_newer); if (!expr) { return NULL; } if (parse_reftime(state, expr) != 0) { goto fail; } expr->cost = STAT_COST; expr->stat_field = field; return expr; fail: free_expr(expr); return NULL; } /** * Parse -size N[cwbkMGTP]?. */ static struct expr *parse_size(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_unary_test(state, eval_size); if (!expr) { return NULL; } const char *unit = parse_icmp(state, expr->sdata, expr, IF_PARTIAL_OK); if (!unit) { goto fail; } if (strlen(unit) > 1) { goto bad_unit; } switch (*unit) { case '\0': case 'b': expr->size_unit = SIZE_BLOCKS; break; case 'c': expr->size_unit = SIZE_BYTES; break; case 'w': expr->size_unit = SIZE_WORDS; break; case 'k': expr->size_unit = SIZE_KB; break; case 'M': expr->size_unit = SIZE_MB; break; case 'G': expr->size_unit = SIZE_GB; break; case 'T': expr->size_unit = SIZE_TB; break; case 'P': expr->size_unit = SIZE_PB; break; default: goto bad_unit; } expr->cost = STAT_COST; expr->probability = expr->cmp_flag == CMP_EXACT ? 0.01 : 0.50; return expr; bad_unit: parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Expected a size unit (one of ${bld}cwbkMGTP${rs}); found ${er}%s${rs}.\n", expr->argv[0], expr->argv[1], unit); fail: free_expr(expr); return NULL; } /** * Parse -sparse. */ static struct expr *parse_sparse(struct parser_state *state, int arg1, int arg2) { struct expr *expr = parse_nullary_test(state, eval_sparse); if (expr) { expr->cost = STAT_COST; } return expr; } /** * Parse -status. */ static struct expr *parse_status(struct parser_state *state, int arg1, int arg2) { state->ctx->status = true; return parse_nullary_option(state); } /** * Parse -x?type [bcdpflsD]. */ static struct expr *parse_type(struct parser_state *state, int x, int arg2) { eval_fn *eval = x ? eval_xtype : eval_type; struct expr *expr = parse_unary_test(state, eval); if (!expr) { return NULL; } unsigned int types = 0; double probability = 0.0; const char *c = expr->sdata; while (true) { enum bfs_type type; double type_prob; switch (*c) { case 'b': type = BFS_BLK; type_prob = 0.00000721183; break; case 'c': type = BFS_CHR; type_prob = 0.0000499855; break; case 'd': type = BFS_DIR; type_prob = 0.114475; break; case 'D': type = BFS_DOOR; type_prob = 0.000001; break; case 'p': type = BFS_FIFO; type_prob = 0.00000248684; break; case 'f': type = BFS_REG; type_prob = 0.859772; break; case 'l': type = BFS_LNK; type_prob = 0.0256816; break; case 's': type = BFS_SOCK; type_prob = 0.0000116881; break; case 'w': type = BFS_WHT; type_prob = 0.000001; break; case '\0': parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Expected a type flag.\n", expr->argv[0], expr->argv[1]); goto fail; default: parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Unknown type flag ${er}%c${rs} (expected one of [${bld}bcdpflsD${rs}]).\n", expr->argv[0], expr->argv[1], *c); goto fail; } unsigned int flag = 1 << type; if (!(types & flag)) { types |= flag; probability += type_prob; } ++c; if (*c == '\0') { break; } else if (*c == ',') { ++c; continue; } else { parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Types must be comma-separated.\n", expr->argv[0], expr->argv[1]); goto fail; } } expr->idata = types; expr->probability = probability; if (x && state->ctx->optlevel < 4) { // Since -xtype dereferences symbolic links, it may have side // effects such as reporting permission errors, and thus // shouldn't be re-ordered without aggressive optimizations expr->pure = false; } return expr; fail: free_expr(expr); return NULL; } /** * Parse -(no)?warn. */ static struct expr *parse_warn(struct parser_state *state, int warn, int arg2) { state->ctx->warn = warn; return parse_nullary_positional_option(state); } /** * Parse -xattr. */ static struct expr *parse_xattr(struct parser_state *state, int arg1, int arg2) { #if BFS_CAN_CHECK_XATTRS struct expr *expr = parse_nullary_test(state, eval_xattr); if (expr) { expr->cost = STAT_COST; expr->probability = 0.01; } return expr; #else parse_error(state, "${blu}%s${rs} is missing platform support.\n", state->argv[0]); return NULL; #endif } /** * Parse -xattrname. */ static struct expr *parse_xattrname(struct parser_state *state, int arg1, int arg2) { #if BFS_CAN_CHECK_XATTRS struct expr *expr = parse_unary_test(state, eval_xattrname); if (expr) { expr->cost = STAT_COST; expr->probability = 0.01; } return expr; #else parse_error(state, "${blu}%s${rs} is missing platform support.\n", state->argv[0]); return NULL; #endif } /** * Parse -xdev. */ static struct expr *parse_xdev(struct parser_state *state, int arg1, int arg2) { state->ctx->flags |= BFTW_PRUNE_MOUNTS; state->xdev_arg = state->argv[0]; return parse_nullary_option(state); } /** * Launch a pager for the help output. */ static CFILE *launch_pager(pid_t *pid, CFILE *cout) { char *pager = getenv("PAGER"); char *exe; if (pager && pager[0]) { exe = bfs_spawn_resolve(pager); } else { exe = bfs_spawn_resolve("less"); if (!exe) { exe = bfs_spawn_resolve("more"); } } if (!exe) { goto fail; } int pipefd[2]; if (pipe(pipefd) != 0) { goto fail_exe; } FILE *file = fdopen(pipefd[1], "w"); if (!file) { goto fail_pipe; } pipefd[1] = -1; CFILE *ret = cfwrap(file, NULL, true); if (!ret) { goto fail_file; } file = NULL; struct bfs_spawn ctx; if (bfs_spawn_init(&ctx) != 0) { goto fail_ret; } if (bfs_spawn_addclose(&ctx, fileno(ret->file)) != 0) { goto fail_ctx; } if (bfs_spawn_adddup2(&ctx, pipefd[0], STDIN_FILENO) != 0) { goto fail_ctx; } if (bfs_spawn_addclose(&ctx, pipefd[0]) != 0) { goto fail_ctx; } char *argv[] = { exe, NULL, NULL, }; if (strcmp(xbasename(exe), "less") == 0) { // We know less supports colors, other pagers may not ret->colors = cout->colors; argv[1] = "-FKRX"; } *pid = bfs_spawn(exe, &ctx, argv, NULL); if (*pid < 0) { goto fail_ctx; } xclose(pipefd[0]); bfs_spawn_destroy(&ctx); free(exe); return ret; fail_ctx: bfs_spawn_destroy(&ctx); fail_ret: cfclose(ret); fail_file: if (file) { fclose(file); } fail_pipe: if (pipefd[1] >= 0) { xclose(pipefd[1]); } if (pipefd[0] >= 0) { xclose(pipefd[0]); } fail_exe: free(exe); fail: return cout; } /** * "Parse" -help. */ static struct expr *parse_help(struct parser_state *state, int arg1, int arg2) { CFILE *cout = state->ctx->cout; pid_t pager = -1; if (state->stdout_tty) { cout = launch_pager(&pager, cout); } cfprintf(cout, "Usage: ${ex}%s${rs} [${cyn}flags${rs}...] [${mag}paths${rs}...] [${blu}expression${rs}...]\n\n", state->command); cfprintf(cout, "${ex}bfs${rs} is compatible with ${ex}find${rs}, with some extensions. " "${cyn}Flags${rs} (${cyn}-H${rs}/${cyn}-L${rs}/${cyn}-P${rs} etc.), ${mag}paths${rs},\n" "and ${blu}expressions${rs} may be freely mixed in any order.\n\n"); cfprintf(cout, "${bld}Flags:${rs}\n\n"); cfprintf(cout, " ${cyn}-H${rs}\n"); cfprintf(cout, " Follow symbolic links on the command line, but not while searching\n"); cfprintf(cout, " ${cyn}-L${rs}\n"); cfprintf(cout, " Follow all symbolic links\n"); cfprintf(cout, " ${cyn}-P${rs}\n"); cfprintf(cout, " Never follow symbolic links (the default)\n"); cfprintf(cout, " ${cyn}-E${rs}\n"); cfprintf(cout, " Use extended regular expressions (same as ${blu}-regextype${rs} ${bld}posix-extended${rs})\n"); cfprintf(cout, " ${cyn}-X${rs}\n"); cfprintf(cout, " Filter out files with non-${ex}xargs${rs}-safe names\n"); cfprintf(cout, " ${cyn}-d${rs}\n"); cfprintf(cout, " Search in post-order (same as ${blu}-depth${rs})\n"); cfprintf(cout, " ${cyn}-s${rs}\n"); cfprintf(cout, " Visit directory entries in sorted order\n"); cfprintf(cout, " ${cyn}-x${rs}\n"); cfprintf(cout, " Don't descend into other mount points (same as ${blu}-xdev${rs})\n"); cfprintf(cout, " ${cyn}-f${rs} ${mag}PATH${rs}\n"); cfprintf(cout, " Treat ${mag}PATH${rs} as a path to search (useful if begins with a dash)\n"); cfprintf(cout, " ${cyn}-D${rs} ${bld}FLAG${rs}\n"); cfprintf(cout, " Turn on a debugging flag (see ${cyn}-D${rs} ${bld}help${rs})\n"); cfprintf(cout, " ${cyn}-O${bld}N${rs}\n"); cfprintf(cout, " Enable optimization level ${bld}N${rs} (default: ${bld}3${rs})\n"); cfprintf(cout, " ${cyn}-S${rs} ${bld}bfs${rs}|${bld}dfs${rs}|${bld}ids${rs}|${bld}eds${rs}\n"); cfprintf(cout, " Use ${bld}b${rs}readth-${bld}f${rs}irst/${bld}d${rs}epth-${bld}f${rs}irst/${bld}i${rs}terative/${bld}e${rs}xponential ${bld}d${rs}eepening ${bld}s${rs}earch\n"); cfprintf(cout, " (default: ${cyn}-S${rs} ${bld}bfs${rs})\n\n"); cfprintf(cout, "${bld}Operators:${rs}\n\n"); cfprintf(cout, " ${red}(${rs} ${blu}expression${rs} ${red})${rs}\n\n"); cfprintf(cout, " ${red}!${rs} ${blu}expression${rs}\n"); cfprintf(cout, " ${red}-not${rs} ${blu}expression${rs}\n\n"); cfprintf(cout, " ${blu}expression${rs} ${blu}expression${rs}\n"); cfprintf(cout, " ${blu}expression${rs} ${red}-a${rs} ${blu}expression${rs}\n"); cfprintf(cout, " ${blu}expression${rs} ${red}-and${rs} ${blu}expression${rs}\n\n"); cfprintf(cout, " ${blu}expression${rs} ${red}-o${rs} ${blu}expression${rs}\n"); cfprintf(cout, " ${blu}expression${rs} ${red}-or${rs} ${blu}expression${rs}\n\n"); cfprintf(cout, " ${blu}expression${rs} ${red},${rs} ${blu}expression${rs}\n\n"); cfprintf(cout, "${bld}Special forms:${rs}\n\n"); cfprintf(cout, " ${red}-exclude${rs} ${blu}expression${rs}\n"); cfprintf(cout, " Exclude all paths matching the ${blu}expression${rs} from the search.\n\n"); cfprintf(cout, "${bld}Options:${rs}\n\n"); cfprintf(cout, " ${blu}-color${rs}\n"); cfprintf(cout, " ${blu}-nocolor${rs}\n"); cfprintf(cout, " Turn colors on or off (default: ${blu}-color${rs} if outputting to a terminal,\n"); cfprintf(cout, " ${blu}-nocolor${rs} otherwise)\n"); cfprintf(cout, " ${blu}-daystart${rs}\n"); cfprintf(cout, " Measure times relative to the start of today\n"); cfprintf(cout, " ${blu}-depth${rs}\n"); cfprintf(cout, " Search in post-order (descendents first)\n"); cfprintf(cout, " ${blu}-files0-from${rs} ${bld}FILE${rs}\n"); cfprintf(cout, " Search the NUL ('\\0')-separated paths from ${bld}FILE${rs} (${bld}-${rs} for standard input).\n"); cfprintf(cout, " ${blu}-follow${rs}\n"); cfprintf(cout, " Follow all symbolic links (same as ${cyn}-L${rs})\n"); cfprintf(cout, " ${blu}-ignore_readdir_race${rs}\n"); cfprintf(cout, " ${blu}-noignore_readdir_race${rs}\n"); cfprintf(cout, " Whether to report an error if ${ex}bfs${rs} detects that the file tree is modified\n"); cfprintf(cout, " during the search (default: ${blu}-noignore_readdir_race${rs})\n"); cfprintf(cout, " ${blu}-maxdepth${rs} ${bld}N${rs}\n"); cfprintf(cout, " ${blu}-mindepth${rs} ${bld}N${rs}\n"); cfprintf(cout, " Ignore files deeper/shallower than ${bld}N${rs}\n"); cfprintf(cout, " ${blu}-mount${rs}\n"); cfprintf(cout, " Don't descend into other mount points (same as ${blu}-xdev${rs} for now, but will\n"); cfprintf(cout, " skip mount points entirely in the future)\n"); cfprintf(cout, " ${blu}-nohidden${rs}\n"); cfprintf(cout, " Exclude hidden files\n"); cfprintf(cout, " ${blu}-noleaf${rs}\n"); cfprintf(cout, " Ignored; for compatibility with GNU find\n"); cfprintf(cout, " ${blu}-regextype${rs} ${bld}TYPE${rs}\n"); cfprintf(cout, " Use ${bld}TYPE${rs}-flavored regexes (default: ${bld}posix-basic${rs}; see ${blu}-regextype${rs} ${bld}help${rs})\n"); cfprintf(cout, " ${blu}-status${rs}\n"); cfprintf(cout, " Display a status bar while searching\n"); cfprintf(cout, " ${blu}-unique${rs}\n"); cfprintf(cout, " Skip any files that have already been seen\n"); cfprintf(cout, " ${blu}-warn${rs}\n"); cfprintf(cout, " ${blu}-nowarn${rs}\n"); cfprintf(cout, " Turn on or off warnings about the command line\n"); cfprintf(cout, " ${blu}-xdev${rs}\n"); cfprintf(cout, " Don't descend into other mount points\n\n"); cfprintf(cout, "${bld}Tests:${rs}\n\n"); #if BFS_CAN_CHECK_ACL cfprintf(cout, " ${blu}-acl${rs}\n"); cfprintf(cout, " Find files with a non-trivial Access Control List\n"); #endif cfprintf(cout, " ${blu}-${rs}[${blu}aBcm${rs}]${blu}min${rs} ${bld}[-+]N${rs}\n"); cfprintf(cout, " Find files ${blu}a${rs}ccessed/${blu}B${rs}irthed/${blu}c${rs}hanged/${blu}m${rs}odified ${bld}N${rs} minutes ago\n"); cfprintf(cout, " ${blu}-${rs}[${blu}aBcm${rs}]${blu}newer${rs} ${bld}FILE${rs}\n"); cfprintf(cout, " Find files ${blu}a${rs}ccessed/${blu}B${rs}irthed/${blu}c${rs}hanged/${blu}m${rs}odified more recently than ${bld}FILE${rs} was\n" " modified\n"); cfprintf(cout, " ${blu}-${rs}[${blu}aBcm${rs}]${blu}since${rs} ${bld}TIME${rs}\n"); cfprintf(cout, " Find files ${blu}a${rs}ccessed/${blu}B${rs}irthed/${blu}c${rs}hanged/${blu}m${rs}odified more recently than ${bld}TIME${rs}\n"); cfprintf(cout, " ${blu}-${rs}[${blu}aBcm${rs}]${blu}time${rs} ${bld}[-+]N${rs}\n"); cfprintf(cout, " Find files ${blu}a${rs}ccessed/${blu}B${rs}irthed/${blu}c${rs}hanged/${blu}m${rs}odified ${bld}N${rs} days ago\n"); #if BFS_CAN_CHECK_CAPABILITIES cfprintf(cout, " ${blu}-capable${rs}\n"); cfprintf(cout, " Find files with POSIX.1e capabilities set\n"); #endif cfprintf(cout, " ${blu}-depth${rs} ${bld}[-+]N${rs}\n"); cfprintf(cout, " Find files with depth ${bld}N${rs}\n"); cfprintf(cout, " ${blu}-empty${rs}\n"); cfprintf(cout, " Find empty files/directories\n"); cfprintf(cout, " ${blu}-executable${rs}\n"); cfprintf(cout, " ${blu}-readable${rs}\n"); cfprintf(cout, " ${blu}-writable${rs}\n"); cfprintf(cout, " Find files the current user can execute/read/write\n"); cfprintf(cout, " ${blu}-false${rs}\n"); cfprintf(cout, " ${blu}-true${rs}\n"); cfprintf(cout, " Always false/true\n"); cfprintf(cout, " ${blu}-fstype${rs} ${bld}TYPE${rs}\n"); cfprintf(cout, " Find files on file systems with the given ${bld}TYPE${rs}\n"); cfprintf(cout, " ${blu}-gid${rs} ${bld}[-+]N${rs}\n"); cfprintf(cout, " ${blu}-uid${rs} ${bld}[-+]N${rs}\n"); cfprintf(cout, " Find files owned by group/user ID ${bld}N${rs}\n"); cfprintf(cout, " ${blu}-group${rs} ${bld}NAME${rs}\n"); cfprintf(cout, " ${blu}-user${rs} ${bld}NAME${rs}\n"); cfprintf(cout, " Find files owned by the group/user ${bld}NAME${rs}\n"); cfprintf(cout, " ${blu}-hidden${rs}\n"); cfprintf(cout, " Find hidden files\n"); #ifdef FNM_CASEFOLD cfprintf(cout, " ${blu}-ilname${rs} ${bld}GLOB${rs}\n"); cfprintf(cout, " ${blu}-iname${rs} ${bld}GLOB${rs}\n"); cfprintf(cout, " ${blu}-ipath${rs} ${bld}GLOB${rs}\n"); cfprintf(cout, " ${blu}-iregex${rs} ${bld}REGEX${rs}\n"); cfprintf(cout, " ${blu}-iwholename${rs} ${bld}GLOB${rs}\n"); cfprintf(cout, " Case-insensitive versions of ${blu}-lname${rs}/${blu}-name${rs}/${blu}-path${rs}" "/${blu}-regex${rs}/${blu}-wholename${rs}\n"); #endif cfprintf(cout, " ${blu}-inum${rs} ${bld}[-+]N${rs}\n"); cfprintf(cout, " Find files with inode number ${bld}N${rs}\n"); cfprintf(cout, " ${blu}-links${rs} ${bld}[-+]N${rs}\n"); cfprintf(cout, " Find files with ${bld}N${rs} hard links\n"); cfprintf(cout, " ${blu}-lname${rs} ${bld}GLOB${rs}\n"); cfprintf(cout, " Find symbolic links whose target matches the ${bld}GLOB${rs}\n"); cfprintf(cout, " ${blu}-name${rs} ${bld}GLOB${rs}\n"); cfprintf(cout, " Find files whose name matches the ${bld}GLOB${rs}\n"); cfprintf(cout, " ${blu}-newer${rs} ${bld}FILE${rs}\n"); cfprintf(cout, " Find files newer than ${bld}FILE${rs}\n"); cfprintf(cout, " ${blu}-newer${bld}XY${rs} ${bld}REFERENCE${rs}\n"); cfprintf(cout, " Find files whose ${bld}X${rs} time is newer than the ${bld}Y${rs} time of" " ${bld}REFERENCE${rs}. ${bld}X${rs} and ${bld}Y${rs}\n"); cfprintf(cout, " can be any of [${bld}aBcm${rs}]. ${bld}Y${rs} may also be ${bld}t${rs} to parse ${bld}REFERENCE${rs} an explicit\n"); cfprintf(cout, " timestamp.\n"); cfprintf(cout, " ${blu}-nogroup${rs}\n"); cfprintf(cout, " ${blu}-nouser${rs}\n"); cfprintf(cout, " Find files owned by nonexistent groups/users\n"); cfprintf(cout, " ${blu}-path${rs} ${bld}GLOB${rs}\n"); cfprintf(cout, " ${blu}-wholename${rs} ${bld}GLOB${rs}\n"); cfprintf(cout, " Find files whose entire path matches the ${bld}GLOB${rs}\n"); cfprintf(cout, " ${blu}-perm${rs} ${bld}[-]MODE${rs}\n"); cfprintf(cout, " Find files with a matching mode\n"); cfprintf(cout, " ${blu}-regex${rs} ${bld}REGEX${rs}\n"); cfprintf(cout, " Find files whose entire path matches the regular expression ${bld}REGEX${rs}\n"); cfprintf(cout, " ${blu}-samefile${rs} ${bld}FILE${rs}\n"); cfprintf(cout, " Find hard links to ${bld}FILE${rs}\n"); cfprintf(cout, " ${blu}-since${rs} ${bld}TIME${rs}\n"); cfprintf(cout, " Find files modified since ${bld}TIME${rs}\n"); cfprintf(cout, " ${blu}-size${rs} ${bld}[-+]N[cwbkMGTP]${rs}\n"); cfprintf(cout, " Find files with the given size, in 1-byte ${bld}c${rs}haracters, 2-byte ${bld}w${rs}ords,\n"); cfprintf(cout, " 512-byte ${bld}b${rs}locks (default), or ${bld}k${rs}iB/${bld}M${rs}iB/${bld}G${rs}iB/${bld}T${rs}iB/${bld}P${rs}iB\n"); cfprintf(cout, " ${blu}-sparse${rs}\n"); cfprintf(cout, " Find files that occupy fewer disk blocks than expected\n"); cfprintf(cout, " ${blu}-type${rs} ${bld}[bcdlpfswD]${rs}\n"); cfprintf(cout, " Find files of the given type\n"); cfprintf(cout, " ${blu}-used${rs} ${bld}[-+]N${rs}\n"); cfprintf(cout, " Find files last accessed ${bld}N${rs} days after they were changed\n"); #if BFS_CAN_CHECK_XATTRS cfprintf(cout, " ${blu}-xattr${rs}\n"); cfprintf(cout, " Find files with extended attributes\n"); cfprintf(cout, " ${blu}-xattrname${rs} ${bld}NAME${rs}\n"); cfprintf(cout, " Find files with the extended attribute ${bld}NAME${rs}\n"); #endif cfprintf(cout, " ${blu}-xtype${rs} ${bld}[bcdlpfswD]${rs}\n"); cfprintf(cout, " Find files of the given type, following links when ${blu}-type${rs} would not, and\n"); cfprintf(cout, " vice versa\n\n"); cfprintf(cout, "${bld}Actions:${rs}\n\n"); cfprintf(cout, " ${blu}-delete${rs}\n"); cfprintf(cout, " ${blu}-rm${rs}\n"); cfprintf(cout, " Delete any found files (implies ${blu}-depth${rs})\n"); cfprintf(cout, " ${blu}-exec${rs} ${bld}command ... {} ;${rs}\n"); cfprintf(cout, " Execute a command\n"); cfprintf(cout, " ${blu}-exec${rs} ${bld}command ... {} +${rs}\n"); cfprintf(cout, " Execute a command with multiple files at once\n"); cfprintf(cout, " ${blu}-ok${rs} ${bld}command ... {} ;${rs}\n"); cfprintf(cout, " Prompt the user whether to execute a command\n"); cfprintf(cout, " ${blu}-execdir${rs} ${bld}command ... {} ;${rs}\n"); cfprintf(cout, " ${blu}-execdir${rs} ${bld}command ... {} +${rs}\n"); cfprintf(cout, " ${blu}-okdir${rs} ${bld}command ... {} ;${rs}\n"); cfprintf(cout, " Like ${blu}-exec${rs}/${blu}-ok${rs}, but run the command in the same directory as the found\n"); cfprintf(cout, " file(s)\n"); cfprintf(cout, " ${blu}-exit${rs} [${bld}STATUS${rs}]\n"); cfprintf(cout, " Exit immediately with the given status (%d if unspecified)\n", EXIT_SUCCESS); cfprintf(cout, " ${blu}-fls${rs} ${bld}FILE${rs}\n"); cfprintf(cout, " ${blu}-fprint${rs} ${bld}FILE${rs}\n"); cfprintf(cout, " ${blu}-fprint0${rs} ${bld}FILE${rs}\n"); cfprintf(cout, " ${blu}-fprintf${rs} ${bld}FILE${rs} ${bld}FORMAT${rs}\n"); cfprintf(cout, " Like ${blu}-ls${rs}/${blu}-print${rs}/${blu}-print0${rs}/${blu}-printf${rs}, but write to ${bld}FILE${rs} instead of standard\n" " output\n"); cfprintf(cout, " ${blu}-ls${rs}\n"); cfprintf(cout, " List files like ${ex}ls${rs} ${bld}-dils${rs}\n"); cfprintf(cout, " ${blu}-print${rs}\n"); cfprintf(cout, " Print the path to the found file\n"); cfprintf(cout, " ${blu}-print0${rs}\n"); cfprintf(cout, " Like ${blu}-print${rs}, but use the null character ('\\0') as a separator rather than\n"); cfprintf(cout, " newlines\n"); cfprintf(cout, " ${blu}-printf${rs} ${bld}FORMAT${rs}\n"); cfprintf(cout, " Print according to a format string (see ${ex}man${rs} ${bld}find${rs}). The additional format\n"); cfprintf(cout, " directives %%w and %%W${bld}k${rs} for printing file birth times are supported.\n"); cfprintf(cout, " ${blu}-printx${rs}\n"); cfprintf(cout, " Like ${blu}-print${rs}, but escape whitespace and quotation characters, to make the\n"); cfprintf(cout, " output safe for ${ex}xargs${rs}. Consider using ${blu}-print0${rs} and ${ex}xargs${rs} ${bld}-0${rs} instead.\n"); cfprintf(cout, " ${blu}-prune${rs}\n"); cfprintf(cout, " Don't descend into this directory\n"); cfprintf(cout, " ${blu}-quit${rs}\n"); cfprintf(cout, " Quit immediately\n"); cfprintf(cout, " ${blu}-version${rs}\n"); cfprintf(cout, " Print version information\n"); cfprintf(cout, " ${blu}-help${rs}\n"); cfprintf(cout, " Print this help message\n\n"); cfprintf(cout, "%s\n", BFS_HOMEPAGE); if (pager > 0) { cfclose(cout); waitpid(pager, NULL, 0); } state->just_info = true; return NULL; } /** * "Parse" -version. */ static struct expr *parse_version(struct parser_state *state, int arg1, int arg2) { cfprintf(state->ctx->cout, "${ex}bfs${rs} ${bld}%s${rs}\n\n", BFS_VERSION); printf("%s\n", BFS_HOMEPAGE); state->just_info = true; return NULL; } typedef struct expr *parse_fn(struct parser_state *state, int arg1, int arg2); /** * An entry in the parse table for literals. */ struct table_entry { char *arg; enum token_type type; parse_fn *parse; int arg1; int arg2; bool prefix; }; /** * The parse table for literals. */ static const struct table_entry parse_table[] = { {"--", T_FLAG}, {"--help", T_ACTION, parse_help}, {"--version", T_ACTION, parse_version}, {"-Bmin", T_TEST, parse_min, BFS_STAT_BTIME}, {"-Bnewer", T_TEST, parse_newer, BFS_STAT_BTIME}, {"-Bsince", T_TEST, parse_since, BFS_STAT_BTIME}, {"-Btime", T_TEST, parse_time, BFS_STAT_BTIME}, {"-D", T_FLAG, parse_debug}, {"-E", T_FLAG, parse_regex_extended}, {"-H", T_FLAG, parse_follow, BFTW_FOLLOW_ROOTS, false}, {"-L", T_FLAG, parse_follow, BFTW_FOLLOW_ALL, false}, {"-O", T_FLAG, parse_optlevel, 0, 0, true}, {"-P", T_FLAG, parse_follow, 0, false}, {"-S", T_FLAG, parse_search_strategy}, {"-X", T_FLAG, parse_xargs_safe}, {"-a", T_OPERATOR}, {"-acl", T_TEST, parse_acl}, {"-amin", T_TEST, parse_min, BFS_STAT_ATIME}, {"-and", T_OPERATOR}, {"-anewer", T_TEST, parse_newer, BFS_STAT_ATIME}, {"-asince", T_TEST, parse_since, BFS_STAT_ATIME}, {"-atime", T_TEST, parse_time, BFS_STAT_ATIME}, {"-capable", T_TEST, parse_capable}, {"-cmin", T_TEST, parse_min, BFS_STAT_CTIME}, {"-cnewer", T_TEST, parse_newer, BFS_STAT_CTIME}, {"-color", T_OPTION, parse_color, true}, {"-csince", T_TEST, parse_since, BFS_STAT_CTIME}, {"-ctime", T_TEST, parse_time, BFS_STAT_CTIME}, {"-d", T_FLAG, parse_depth}, {"-daystart", T_OPTION, parse_daystart}, {"-delete", T_ACTION, parse_delete}, {"-depth", T_OPTION, parse_depth_n}, {"-empty", T_TEST, parse_empty}, {"-exclude", T_OPERATOR}, {"-exec", T_ACTION, parse_exec, 0}, {"-execdir", T_ACTION, parse_exec, BFS_EXEC_CHDIR}, {"-executable", T_TEST, parse_access, X_OK}, {"-exit", T_ACTION, parse_exit}, {"-f", T_FLAG, parse_f}, {"-false", T_TEST, parse_const, false}, {"-files0-from", T_OPTION, parse_files0_from}, {"-flags", T_TEST, parse_flags}, {"-fls", T_ACTION, parse_fls}, {"-follow", T_OPTION, parse_follow, BFTW_FOLLOW_ALL, true}, {"-fprint", T_ACTION, parse_fprint}, {"-fprint0", T_ACTION, parse_fprint0}, {"-fprintf", T_ACTION, parse_fprintf}, {"-fstype", T_TEST, parse_fstype}, {"-gid", T_TEST, parse_group}, {"-group", T_TEST, parse_group}, {"-help", T_ACTION, parse_help}, {"-hidden", T_TEST, parse_hidden}, {"-ignore_readdir_race", T_OPTION, parse_ignore_races, true}, {"-ilname", T_TEST, parse_lname, true}, {"-iname", T_TEST, parse_name, true}, {"-inum", T_TEST, parse_inum}, {"-ipath", T_TEST, parse_path, true}, {"-iregex", T_TEST, parse_regex, REG_ICASE}, {"-iwholename", T_TEST, parse_path, true}, {"-links", T_TEST, parse_links}, {"-lname", T_TEST, parse_lname, false}, {"-ls", T_ACTION, parse_ls}, {"-maxdepth", T_OPTION, parse_depth_limit, false}, {"-mindepth", T_OPTION, parse_depth_limit, true}, {"-mmin", T_TEST, parse_min, BFS_STAT_MTIME}, {"-mnewer", T_TEST, parse_newer, BFS_STAT_MTIME}, {"-mount", T_OPTION, parse_mount}, {"-msince", T_TEST, parse_since, BFS_STAT_MTIME}, {"-mtime", T_TEST, parse_time, BFS_STAT_MTIME}, {"-name", T_TEST, parse_name, false}, {"-newer", T_TEST, parse_newer, BFS_STAT_MTIME}, {"-newer", T_TEST, parse_newerxy, 0, 0, true}, {"-nocolor", T_OPTION, parse_color, false}, {"-nogroup", T_TEST, parse_nogroup}, {"-nohidden", T_TEST, parse_nohidden}, {"-noignore_readdir_race", T_OPTION, parse_ignore_races, false}, {"-noleaf", T_OPTION, parse_noleaf}, {"-not", T_OPERATOR}, {"-nouser", T_TEST, parse_nouser}, {"-nowarn", T_OPTION, parse_warn, false}, {"-o", T_OPERATOR}, {"-ok", T_ACTION, parse_exec, BFS_EXEC_CONFIRM}, {"-okdir", T_ACTION, parse_exec, BFS_EXEC_CONFIRM | BFS_EXEC_CHDIR}, {"-or", T_OPERATOR}, {"-path", T_TEST, parse_path, false}, {"-perm", T_TEST, parse_perm}, {"-print", T_ACTION, parse_print}, {"-print0", T_ACTION, parse_print0}, {"-printf", T_ACTION, parse_printf}, {"-printx", T_ACTION, parse_printx}, {"-prune", T_ACTION, parse_prune}, {"-quit", T_ACTION, parse_quit}, {"-readable", T_TEST, parse_access, R_OK}, {"-regex", T_TEST, parse_regex, 0}, {"-regextype", T_OPTION, parse_regextype}, {"-rm", T_ACTION, parse_delete}, {"-s", T_FLAG, parse_s}, {"-samefile", T_TEST, parse_samefile}, {"-since", T_TEST, parse_since, BFS_STAT_MTIME}, {"-size", T_TEST, parse_size}, {"-sparse", T_TEST, parse_sparse}, {"-status", T_OPTION, parse_status}, {"-true", T_TEST, parse_const, true}, {"-type", T_TEST, parse_type, false}, {"-uid", T_TEST, parse_user}, {"-unique", T_OPTION, parse_unique}, {"-used", T_TEST, parse_used}, {"-user", T_TEST, parse_user}, {"-version", T_ACTION, parse_version}, {"-warn", T_OPTION, parse_warn, true}, {"-wholename", T_TEST, parse_path, false}, {"-writable", T_TEST, parse_access, W_OK}, {"-x", T_FLAG, parse_xdev}, {"-xattr", T_TEST, parse_xattr}, {"-xattrname", T_TEST, parse_xattrname}, {"-xdev", T_OPTION, parse_xdev}, {"-xtype", T_TEST, parse_type, true}, {0}, }; /** Look up an argument in the parse table. */ static const struct table_entry *table_lookup(const char *arg) { for (const struct table_entry *entry = parse_table; entry->arg; ++entry) { bool match; if (entry->prefix) { match = strncmp(arg, entry->arg, strlen(entry->arg)) == 0; } else { match = strcmp(arg, entry->arg) == 0; } if (match) { return entry; } } return NULL; } /** Search for a fuzzy match in the parse table. */ static const struct table_entry *table_lookup_fuzzy(const char *arg) { const struct table_entry *best = NULL; int best_dist; for (const struct table_entry *entry = parse_table; entry->arg; ++entry) { int dist = typo_distance(arg, entry->arg); if (!best || dist < best_dist) { best = entry; best_dist = dist; } } return best; } /** * LITERAL : OPTION * | TEST * | ACTION */ static struct expr *parse_literal(struct parser_state *state) { // Paths are already skipped at this point const char *arg = state->argv[0]; if (arg[0] != '-') { goto unexpected; } const struct table_entry *match = table_lookup(arg); if (match) { if (match->parse) { goto matched; } else { goto unexpected; } } match = table_lookup_fuzzy(arg); CFILE *cerr = state->ctx->cerr; parse_error(state, "Unknown argument ${er}%s${rs}; did you mean ", arg); switch (match->type) { case T_FLAG: cfprintf(cerr, "${cyn}%s${rs}?", match->arg); break; case T_OPERATOR: cfprintf(cerr, "${red}%s${rs}?", match->arg); break; default: cfprintf(cerr, "${blu}%s${rs}?", match->arg); break; } if (!state->interactive || !match->parse) { fprintf(stderr, "\n"); goto unmatched; } fprintf(stderr, " "); if (ynprompt() <= 0) { goto unmatched; } fprintf(stderr, "\n"); state->argv[0] = match->arg; matched: return match->parse(state, match->arg1, match->arg2); unmatched: return NULL; unexpected: parse_error(state, "Expected a predicate; found ${er}%s${rs}.\n", arg); return NULL; } /** * FACTOR : "(" EXPR ")" * | "!" FACTOR | "-not" FACTOR * | "-exclude" FACTOR * | LITERAL */ static struct expr *parse_factor(struct parser_state *state) { if (skip_paths(state) != 0) { return NULL; } const char *arg = state->argv[0]; if (!arg) { parse_error(state, "Expression terminated prematurely after ${red}%s${rs}.\n", state->last_arg); return NULL; } if (strcmp(arg, "(") == 0) { parser_advance(state, T_OPERATOR, 1); struct expr *expr = parse_expr(state); if (!expr) { return NULL; } if (skip_paths(state) != 0) { free_expr(expr); return NULL; } arg = state->argv[0]; if (!arg || strcmp(arg, ")") != 0) { parse_error(state, "Expected a ${red})${rs} after ${blu}%s${rs}.\n", state->argv[-1]); free_expr(expr); return NULL; } parser_advance(state, T_OPERATOR, 1); return expr; } else if (strcmp(arg, "-exclude") == 0) { parser_advance(state, T_OPERATOR, 1); if (state->excluding) { parse_error(state, "${er}%s${rs} is not supported within ${red}-exclude${rs}.\n", arg); return NULL; } state->excluding = true; struct expr *factor = parse_factor(state); if (!factor) { return NULL; } state->excluding = false; struct bfs_ctx *ctx = state->ctx; ctx->exclude = new_binary_expr(eval_or, ctx->exclude, factor, &fake_or_arg); if (!ctx->exclude) { return NULL; } return &expr_true; } else if (strcmp(arg, "!") == 0 || strcmp(arg, "-not") == 0) { char **argv = parser_advance(state, T_OPERATOR, 1); struct expr *factor = parse_factor(state); if (!factor) { return NULL; } return new_unary_expr(eval_not, factor, argv); } else { return parse_literal(state); } } /** * TERM : FACTOR * | TERM FACTOR * | TERM "-a" FACTOR * | TERM "-and" FACTOR */ static struct expr *parse_term(struct parser_state *state) { struct expr *term = parse_factor(state); while (term) { if (skip_paths(state) != 0) { free_expr(term); return NULL; } const char *arg = state->argv[0]; if (!arg) { break; } if (strcmp(arg, "-o") == 0 || strcmp(arg, "-or") == 0 || strcmp(arg, ",") == 0 || strcmp(arg, ")") == 0) { break; } char **argv = &fake_and_arg; if (strcmp(arg, "-a") == 0 || strcmp(arg, "-and") == 0) { argv = parser_advance(state, T_OPERATOR, 1); } struct expr *lhs = term; struct expr *rhs = parse_factor(state); if (!rhs) { free_expr(lhs); return NULL; } term = new_binary_expr(eval_and, lhs, rhs, argv); } return term; } /** * CLAUSE : TERM * | CLAUSE "-o" TERM * | CLAUSE "-or" TERM */ static struct expr *parse_clause(struct parser_state *state) { struct expr *clause = parse_term(state); while (clause) { if (skip_paths(state) != 0) { free_expr(clause); return NULL; } const char *arg = state->argv[0]; if (!arg) { break; } if (strcmp(arg, "-o") != 0 && strcmp(arg, "-or") != 0) { break; } char **argv = parser_advance(state, T_OPERATOR, 1); struct expr *lhs = clause; struct expr *rhs = parse_term(state); if (!rhs) { free_expr(lhs); return NULL; } clause = new_binary_expr(eval_or, lhs, rhs, argv); } return clause; } /** * EXPR : CLAUSE * | EXPR "," CLAUSE */ static struct expr *parse_expr(struct parser_state *state) { struct expr *expr = parse_clause(state); while (expr) { if (skip_paths(state) != 0) { free_expr(expr); return NULL; } const char *arg = state->argv[0]; if (!arg) { break; } if (strcmp(arg, ",") != 0) { break; } char **argv = parser_advance(state, T_OPERATOR, 1); struct expr *lhs = expr; struct expr *rhs = parse_clause(state); if (!rhs) { free_expr(lhs); return NULL; } expr = new_binary_expr(eval_comma, lhs, rhs, argv); } return expr; } /** * Parse the top-level expression. */ static struct expr *parse_whole_expr(struct parser_state *state) { if (skip_paths(state) != 0) { return NULL; } struct expr *expr = &expr_true; if (state->argv[0]) { expr = parse_expr(state); if (!expr) { return NULL; } } if (state->argv[0]) { parse_error(state, "Unexpected argument ${er}%s${rs}.\n", state->argv[0]); goto fail; } if (state->implicit_print) { struct expr *print = new_expr(eval_fprint, 1, &fake_print_arg); if (!print) { goto fail; } init_print_expr(state, print); expr = new_binary_expr(eval_and, expr, print, &fake_and_arg); if (!expr) { goto fail; } } if (state->mount_arg && state->xdev_arg) { parse_warning(state, "${blu}%s${rs} is redundant in the presence of ${blu}%s${rs}.\n\n", state->xdev_arg, state->mount_arg); } if (state->ctx->warn && state->depth_arg && state->prune_arg) { parse_warning(state, "${blu}%s${rs} does not work in the presence of ${blu}%s${rs}.\n", state->prune_arg, state->depth_arg); if (state->interactive) { fprintf(stderr, "Do you want to continue? "); if (ynprompt() == 0) { goto fail; } } fprintf(stderr, "\n"); } if (state->ok_arg && state->stdin_consumed) { parse_error(state, "${blu}%s${rs} conflicts with ${blu}-files0-from${rs} ${bld}-${rs}.\n", state->ok_arg); goto fail; } return expr; fail: free_expr(expr); return NULL; } void bfs_ctx_dump(const struct bfs_ctx *ctx, enum debug_flags flag) { if (!bfs_debug_prefix(ctx, flag)) { return; } CFILE *cerr = ctx->cerr; cfprintf(cerr, "${ex}%s${rs} ", ctx->argv[0]); if (ctx->flags & BFTW_FOLLOW_ALL) { cfprintf(cerr, "${cyn}-L${rs} "); } else if (ctx->flags & BFTW_FOLLOW_ROOTS) { cfprintf(cerr, "${cyn}-H${rs} "); } else { cfprintf(cerr, "${cyn}-P${rs} "); } if (ctx->xargs_safe) { cfprintf(cerr, "${cyn}-X${rs} "); } if (ctx->flags & BFTW_SORT) { cfprintf(cerr, "${cyn}-s${rs} "); } if (ctx->optlevel != 3) { cfprintf(cerr, "${cyn}-O${bld}%d${rs} ", ctx->optlevel); } const char *strategy = NULL; switch (ctx->strategy) { case BFTW_BFS: strategy = "bfs"; break; case BFTW_DFS: strategy = "dfs"; break; case BFTW_IDS: strategy = "ids"; break; case BFTW_EDS: strategy = "eds"; break; } assert(strategy); cfprintf(cerr, "${cyn}-S${rs} ${bld}%s${rs} ", strategy); enum debug_flags debug = ctx->debug; if (debug == DEBUG_ALL) { cfprintf(cerr, "${cyn}-D${rs} ${bld}all${rs} "); } else if (debug) { cfprintf(cerr, "${cyn}-D${rs} "); for (enum debug_flags i = 1; DEBUG_ALL & i; i <<= 1) { if (debug & i) { cfprintf(cerr, "${bld}%s${rs}", debug_flag_name(i)); debug ^= i; if (debug) { cfprintf(cerr, ","); } } } cfprintf(cerr, " "); } for (size_t i = 0; i < darray_length(ctx->paths); ++i) { const char *path = ctx->paths[i]; char c = path[0]; if (c == '-' || c == '(' || c == ')' || c == '!' || c == ',') { cfprintf(cerr, "${cyn}-f${rs} "); } cfprintf(cerr, "${mag}%s${rs} ", path); } if (ctx->cout->colors) { cfprintf(cerr, "${blu}-color${rs} "); } else { cfprintf(cerr, "${blu}-nocolor${rs} "); } if (ctx->flags & BFTW_POST_ORDER) { cfprintf(cerr, "${blu}-depth${rs} "); } if (ctx->ignore_races) { cfprintf(cerr, "${blu}-ignore_readdir_race${rs} "); } if (ctx->mindepth != 0) { cfprintf(cerr, "${blu}-mindepth${rs} ${bld}%d${rs} ", ctx->mindepth); } if (ctx->maxdepth != INT_MAX) { cfprintf(cerr, "${blu}-maxdepth${rs} ${bld}%d${rs} ", ctx->maxdepth); } if (ctx->flags & BFTW_SKIP_MOUNTS) { cfprintf(cerr, "${blu}-mount${rs} "); } if (ctx->status) { cfprintf(cerr, "${blu}-status${rs} "); } if (ctx->unique) { cfprintf(cerr, "${blu}-unique${rs} "); } if ((ctx->flags & (BFTW_SKIP_MOUNTS | BFTW_PRUNE_MOUNTS)) == BFTW_PRUNE_MOUNTS) { cfprintf(cerr, "${blu}-xdev${rs} "); } if (flag == DEBUG_RATES) { if (ctx->exclude != &expr_false) { cfprintf(cerr, "(${red}-exclude${rs} %pE) ", ctx->exclude); } cfprintf(cerr, "%pE", ctx->expr); } else { if (ctx->exclude != &expr_false) { cfprintf(cerr, "(${red}-exclude${rs} %pe) ", ctx->exclude); } cfprintf(cerr, "%pe", ctx->expr); } fputs("\n", stderr); } /** * Dump the estimated costs. */ static void dump_costs(const struct bfs_ctx *ctx) { const struct expr *expr = ctx->expr; bfs_debug(ctx, DEBUG_COST, " Cost: ~${ylw}%g${rs}\n", expr->cost); bfs_debug(ctx, DEBUG_COST, "Probability: ~${ylw}%g%%${rs}\n", 100.0*expr->probability); } /** * Get the current time. */ static int parse_gettime(const struct bfs_ctx *ctx, struct timespec *ts) { #if _POSIX_TIMERS > 0 int ret = clock_gettime(CLOCK_REALTIME, ts); if (ret != 0) { bfs_perror(ctx, "clock_gettime()"); } return ret; #else struct timeval tv; int ret = gettimeofday(&tv, NULL); if (ret == 0) { ts->tv_sec = tv.tv_sec; ts->tv_nsec = tv.tv_usec * 1000L; } else { bfs_perror(ctx, "gettimeofday()"); } return ret; #endif } struct bfs_ctx *bfs_parse_cmdline(int argc, char *argv[]) { struct bfs_ctx *ctx = bfs_ctx_new(); if (!ctx) { perror("bfs_new_ctx()"); goto fail; } static char* default_argv[] = {"bfs", NULL}; if (argc < 1) { argc = 1; argv = default_argv; } ctx->argv = malloc((argc + 1)*sizeof(*ctx->argv)); if (!ctx->argv) { perror("malloc()"); goto fail; } for (int i = 0; i <= argc; ++i) { ctx->argv[i] = argv[i]; } enum use_color use_color = COLOR_AUTO; if (getenv("NO_COLOR")) { // https://no-color.org/ use_color = COLOR_NEVER; } ctx->colors = parse_colors(getenv("LS_COLORS")); if (!ctx->colors) { ctx->colors_error = errno; } ctx->cerr = cfwrap(stderr, use_color ? ctx->colors : NULL, false); if (!ctx->cerr) { perror("cfwrap()"); goto fail; } ctx->cout = cfwrap(stdout, use_color ? ctx->colors : NULL, false); if (!ctx->cout) { bfs_perror(ctx, "cfwrap()"); goto fail; } if (!bfs_ctx_dedup(ctx, ctx->cout, NULL) || !bfs_ctx_dedup(ctx, ctx->cerr, NULL)) { bfs_perror(ctx, "bfs_ctx_dedup()"); goto fail; } bool stdin_tty = isatty(STDIN_FILENO); bool stdout_tty = isatty(STDOUT_FILENO); bool stderr_tty = isatty(STDERR_FILENO); if (getenv("POSIXLY_CORRECT")) { ctx->posixly_correct = true; } else { ctx->warn = stdin_tty; } struct parser_state state = { .ctx = ctx, .argv = ctx->argv + 1, .command = ctx->argv[0], .regex_flags = 0, .stdout_tty = stdout_tty, .interactive = stdin_tty && stderr_tty, .stdin_consumed = false, .use_color = use_color, .implicit_print = true, .implicit_root = true, .non_option_seen = false, .just_info = false, .excluding = false, .last_arg = NULL, .depth_arg = NULL, .prune_arg = NULL, .mount_arg = NULL, .xdev_arg = NULL, .ok_arg = NULL, }; if (strcmp(xbasename(state.command), "find") == 0) { // Operate depth-first when invoked as "find" ctx->strategy = BFTW_DFS; } if (parse_gettime(ctx, &state.now) != 0) { goto fail; } ctx->exclude = &expr_false; ctx->expr = parse_whole_expr(&state); if (!ctx->expr) { if (state.just_info) { goto done; } else { goto fail; } } if (bfs_optimize(ctx) != 0) { goto fail; } if (darray_length(ctx->paths) == 0) { if (!state.implicit_root) { parse_error(&state, "No root paths specified.\n"); goto fail; } else if (parse_root(&state, ".") != 0) { goto fail; } } if ((ctx->flags & BFTW_FOLLOW_ALL) && !ctx->unique) { // We need bftw() to detect cycles unless -unique does it for us ctx->flags |= BFTW_DETECT_CYCLES; } bfs_ctx_dump(ctx, DEBUG_TREE); dump_costs(ctx); done: return ctx; fail: bfs_ctx_free(ctx); return NULL; } bfs-2.3.1/parse.h000066400000000000000000000027751417254370000135700ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2020 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * bfs command line parsing. */ #ifndef BFS_PARSE_H #define BFS_PARSE_H /** * Parse the command line. * * @param argc * The number of arguments. * @param argv * The arguments to parse. * @return * A new bfs context, or NULL on failure. */ struct bfs_ctx *bfs_parse_cmdline(int argc, char *argv[]); #endif // BFS_PARSE_H bfs-2.3.1/printf.c000066400000000000000000000563741417254370000137570ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2017-2021 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "printf.h" #include "bftw.h" #include "color.h" #include "ctx.h" #include "diag.h" #include "dir.h" #include "dstring.h" #include "mtab.h" #include "pwcache.h" #include "stat.h" #include "time.h" #include "util.h" #include #include #include #include #include #include #include #include #include #include typedef int bfs_printf_fn(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf); struct bfs_printf { /** The printing function to invoke. */ bfs_printf_fn *fn; /** String data associated with this directive. */ char *str; /** The stat field to print. */ enum bfs_stat_field stat_field; /** Character data associated with this directive. */ char c; /** Some data used by the directive. */ const void *ptr; /** The next printf directive in the chain. */ struct bfs_printf *next; }; /** Print some text as-is. */ static int bfs_printf_literal(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { size_t len = dstrlen(directive->str); if (fwrite(directive->str, 1, len, cfile->file) == len) { return 0; } else { return -1; } } /** \c: flush */ static int bfs_printf_flush(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { return fflush(cfile->file); } /** Check if we can safely colorize this directive. */ static bool should_color(CFILE *cfile, const struct bfs_printf *directive) { return cfile->colors && strcmp(directive->str, "%s") == 0; } /** * Print a value to a temporary buffer before formatting it. */ #define BFS_PRINTF_BUF(buf, format, ...) \ char buf[256]; \ int ret = snprintf(buf, sizeof(buf), format, __VA_ARGS__); \ assert(ret >= 0 && (size_t)ret < sizeof(buf)); \ (void)ret /** %a, %c, %t: ctime() */ static int bfs_printf_ctime(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { // Not using ctime() itself because GNU find adds nanoseconds static const char *days[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; static const char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (!statbuf) { return -1; } const struct timespec *ts = bfs_stat_time(statbuf, directive->stat_field); if (!ts) { return -1; } struct tm tm; if (xlocaltime(&ts->tv_sec, &tm) != 0) { return -1; } BFS_PRINTF_BUF(buf, "%s %s %2d %.2d:%.2d:%.2d.%09ld0 %4d", days[tm.tm_wday], months[tm.tm_mon], tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, (long)ts->tv_nsec, 1900 + tm.tm_year); return fprintf(cfile->file, directive->str, buf); } /** %A, %B/%W, %C, %T: strftime() */ static int bfs_printf_strftime(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (!statbuf) { return -1; } const struct timespec *ts = bfs_stat_time(statbuf, directive->stat_field); if (!ts) { return -1; } struct tm tm; if (xlocaltime(&ts->tv_sec, &tm) != 0) { return -1; } int ret; char buf[256]; char format[] = "% "; switch (directive->c) { // Non-POSIX strftime() features case '@': ret = snprintf(buf, sizeof(buf), "%lld.%09ld0", (long long)ts->tv_sec, (long)ts->tv_nsec); break; case '+': ret = snprintf(buf, sizeof(buf), "%4d-%.2d-%.2d+%.2d:%.2d:%.2d.%09ld0", 1900 + tm.tm_year, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, (long)ts->tv_nsec); break; case 'k': ret = snprintf(buf, sizeof(buf), "%2d", tm.tm_hour); break; case 'l': ret = snprintf(buf, sizeof(buf), "%2d", (tm.tm_hour + 11)%12 + 1); break; case 's': ret = snprintf(buf, sizeof(buf), "%lld", (long long)ts->tv_sec); break; case 'S': ret = snprintf(buf, sizeof(buf), "%.2d.%09ld0", tm.tm_sec, (long)ts->tv_nsec); break; case 'T': ret = snprintf(buf, sizeof(buf), "%.2d:%.2d:%.2d.%09ld0", tm.tm_hour, tm.tm_min, tm.tm_sec, (long)ts->tv_nsec); break; // POSIX strftime() features default: format[1] = directive->c; ret = strftime(buf, sizeof(buf), format, &tm); break; } assert(ret >= 0 && (size_t)ret < sizeof(buf)); (void)ret; return fprintf(cfile->file, directive->str, buf); } /** %b: blocks */ static int bfs_printf_b(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (!statbuf) { return -1; } uintmax_t blocks = ((uintmax_t)statbuf->blocks*BFS_STAT_BLKSIZE + 511)/512; BFS_PRINTF_BUF(buf, "%ju", blocks); return fprintf(cfile->file, directive->str, buf); } /** %d: depth */ static int bfs_printf_d(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { return fprintf(cfile->file, directive->str, (intmax_t)ftwbuf->depth); } /** %D: device */ static int bfs_printf_D(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (!statbuf) { return -1; } BFS_PRINTF_BUF(buf, "%ju", (uintmax_t)statbuf->dev); return fprintf(cfile->file, directive->str, buf); } /** %f: file name */ static int bfs_printf_f(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { if (should_color(cfile, directive)) { return cfprintf(cfile, "%pF", ftwbuf); } else { return fprintf(cfile->file, directive->str, ftwbuf->path + ftwbuf->nameoff); } } /** %F: file system type */ static int bfs_printf_F(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (!statbuf) { return -1; } const char *type = bfs_fstype(directive->ptr, statbuf); return fprintf(cfile->file, directive->str, type); } /** %G: gid */ static int bfs_printf_G(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (!statbuf) { return -1; } BFS_PRINTF_BUF(buf, "%ju", (uintmax_t)statbuf->gid); return fprintf(cfile->file, directive->str, buf); } /** %g: group name */ static int bfs_printf_g(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (!statbuf) { return -1; } const struct bfs_groups *groups = directive->ptr; const struct group *grp = groups ? bfs_getgrgid(groups, statbuf->gid) : NULL; if (!grp) { return bfs_printf_G(cfile, directive, ftwbuf); } return fprintf(cfile->file, directive->str, grp->gr_name); } /** %h: leading directories */ static int bfs_printf_h(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { char *copy = NULL; const char *buf; if (ftwbuf->nameoff > 0) { size_t len = ftwbuf->nameoff; if (len > 1) { --len; } buf = copy = strndup(ftwbuf->path, len); } else if (ftwbuf->path[0] == '/') { buf = "/"; } else { buf = "."; } if (!buf) { return -1; } int ret; if (should_color(cfile, directive)) { ret = cfprintf(cfile, "${di}%s${rs}", buf); } else { ret = fprintf(cfile->file, directive->str, buf); } free(copy); return ret; } /** %H: current root */ static int bfs_printf_H(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { if (should_color(cfile, directive)) { if (ftwbuf->depth == 0) { return cfprintf(cfile, "%pP", ftwbuf); } else { return cfprintf(cfile, "${di}%s${rs}", ftwbuf->root); } } else { return fprintf(cfile->file, directive->str, ftwbuf->root); } } /** %i: inode */ static int bfs_printf_i(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (!statbuf) { return -1; } BFS_PRINTF_BUF(buf, "%ju", (uintmax_t)statbuf->ino); return fprintf(cfile->file, directive->str, buf); } /** %k: 1K blocks */ static int bfs_printf_k(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (!statbuf) { return -1; } uintmax_t blocks = ((uintmax_t)statbuf->blocks*BFS_STAT_BLKSIZE + 1023)/1024; BFS_PRINTF_BUF(buf, "%ju", blocks); return fprintf(cfile->file, directive->str, buf); } /** %l: link target */ static int bfs_printf_l(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { char *buf = NULL; const char *target = ""; if (ftwbuf->type == BFS_LNK) { if (should_color(cfile, directive)) { return cfprintf(cfile, "%pL", ftwbuf); } const struct bfs_stat *statbuf = bftw_cached_stat(ftwbuf, BFS_STAT_NOFOLLOW); size_t len = statbuf ? statbuf->size : 0; target = buf = xreadlinkat(ftwbuf->at_fd, ftwbuf->at_path, len); if (!target) { return -1; } } int ret = fprintf(cfile->file, directive->str, target); free(buf); return ret; } /** %m: mode */ static int bfs_printf_m(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (!statbuf) { return -1; } return fprintf(cfile->file, directive->str, (unsigned int)(statbuf->mode & 07777)); } /** %M: symbolic mode */ static int bfs_printf_M(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (!statbuf) { return -1; } char buf[11]; xstrmode(statbuf->mode, buf); return fprintf(cfile->file, directive->str, buf); } /** %n: link count */ static int bfs_printf_n(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (!statbuf) { return -1; } BFS_PRINTF_BUF(buf, "%ju", (uintmax_t)statbuf->nlink); return fprintf(cfile->file, directive->str, buf); } /** %p: full path */ static int bfs_printf_p(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { if (should_color(cfile, directive)) { return cfprintf(cfile, "%pP", ftwbuf); } else { return fprintf(cfile->file, directive->str, ftwbuf->path); } } /** %P: path after root */ static int bfs_printf_P(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { size_t offset = strlen(ftwbuf->root); if (ftwbuf->path[offset] == '/') { ++offset; } if (should_color(cfile, directive)) { if (ftwbuf->depth == 0) { return 0; } struct BFTW copybuf = *ftwbuf; copybuf.path += offset; copybuf.nameoff -= offset; return cfprintf(cfile, "%pP", ©buf); } else { return fprintf(cfile->file, directive->str, ftwbuf->path + offset); } } /** %s: size */ static int bfs_printf_s(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (!statbuf) { return -1; } BFS_PRINTF_BUF(buf, "%ju", (uintmax_t)statbuf->size); return fprintf(cfile->file, directive->str, buf); } /** %S: sparseness */ static int bfs_printf_S(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (!statbuf) { return -1; } double sparsity; if (statbuf->size == 0 && statbuf->blocks == 0) { sparsity = 1.0; } else { sparsity = (double)BFS_STAT_BLKSIZE*statbuf->blocks/statbuf->size; } return fprintf(cfile->file, directive->str, sparsity); } /** %U: uid */ static int bfs_printf_U(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (!statbuf) { return -1; } BFS_PRINTF_BUF(buf, "%ju", (uintmax_t)statbuf->uid); return fprintf(cfile->file, directive->str, buf); } /** %u: user name */ static int bfs_printf_u(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags); if (!statbuf) { return -1; } const struct bfs_users *users = directive->ptr; const struct passwd *pwd = users ? bfs_getpwuid(users, statbuf->uid) : NULL; if (!pwd) { return bfs_printf_U(cfile, directive, ftwbuf); } return fprintf(cfile->file, directive->str, pwd->pw_name); } static const char *bfs_printf_type(enum bfs_type type) { switch (type) { case BFS_BLK: return "b"; case BFS_CHR: return "c"; case BFS_DIR: return "d"; case BFS_DOOR: return "D"; case BFS_FIFO: return "p"; case BFS_LNK: return "l"; case BFS_REG: return "f"; case BFS_SOCK: return "s"; default: return "U"; } } /** %y: type */ static int bfs_printf_y(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { const char *type = bfs_printf_type(ftwbuf->type); return fprintf(cfile->file, directive->str, type); } /** %Y: target type */ static int bfs_printf_Y(CFILE *cfile, const struct bfs_printf *directive, const struct BFTW *ftwbuf) { int error = 0; if (ftwbuf->type != BFS_LNK) { return bfs_printf_y(cfile, directive, ftwbuf); } const char *type = "U"; const struct bfs_stat *statbuf = bftw_stat(ftwbuf, BFS_STAT_FOLLOW); if (statbuf) { type = bfs_printf_type(bfs_mode_to_type(statbuf->mode)); } else { switch (errno) { case ELOOP: type = "L"; break; case ENOENT: case ENOTDIR: type = "N"; break; default: type = "?"; error = errno; break; } } int ret = fprintf(cfile->file, directive->str, type); if (error != 0) { ret = -1; errno = error; } return ret; } /** * Free a printf directive. */ static void free_directive(struct bfs_printf *directive) { if (directive) { dstrfree(directive->str); free(directive); } } /** * Create a new printf directive. */ static struct bfs_printf *new_directive(const struct bfs_ctx *ctx, bfs_printf_fn *fn) { struct bfs_printf *directive = malloc(sizeof(*directive)); if (!directive) { bfs_perror(ctx, "malloc()"); goto error; } directive->fn = fn; directive->str = dstralloc(2); if (!directive->str) { bfs_perror(ctx, "dstralloc()"); goto error; } directive->stat_field = 0; directive->c = 0; directive->ptr = NULL; directive->next = NULL; return directive; error: free_directive(directive); return NULL; } /** * Append a printf directive to the chain. */ static struct bfs_printf **append_directive(struct bfs_printf **tail, struct bfs_printf *directive) { assert(directive); *tail = directive; return &directive->next; } /** * Append a literal string to the chain. */ static struct bfs_printf **append_literal(struct bfs_printf **tail, struct bfs_printf **literal) { struct bfs_printf *directive = *literal; if (directive && dstrlen(directive->str) > 0) { *literal = NULL; return append_directive(tail, directive); } else { return tail; } } struct bfs_printf *bfs_printf_parse(const struct bfs_ctx *ctx, const char *format) { struct bfs_printf *head = NULL; struct bfs_printf **tail = &head; struct bfs_printf *literal = new_directive(ctx, bfs_printf_literal); if (!literal) { goto error; } for (const char *i = format; *i; ++i) { char c = *i; if (c == '\\') { c = *++i; if (c >= '0' && c < '8') { c = 0; for (int j = 0; j < 3 && *i >= '0' && *i < '8'; ++i, ++j) { c *= 8; c += *i - '0'; } --i; goto one_char; } switch (c) { case 'a': c = '\a'; break; case 'b': c = '\b'; break; case 'f': c = '\f'; break; case 'n': c = '\n'; break; case 'r': c = '\r'; break; case 't': c = '\t'; break; case 'v': c = '\v'; break; case '\\': c = '\\'; break; case 'c': tail = append_literal(tail, &literal); struct bfs_printf *directive = new_directive(ctx, bfs_printf_flush); if (!directive) { goto error; } tail = append_directive(tail, directive); goto done; case '\0': bfs_error(ctx, "'%s': Incomplete escape sequence '\\'.\n", format); goto error; default: bfs_error(ctx, "'%s': Unrecognized escape sequence '\\%c'.\n", format, c); goto error; } } else if (c == '%') { if (i[1] == '%') { c = *++i; goto one_char; } struct bfs_printf *directive = new_directive(ctx, NULL); if (!directive) { goto directive_error; } if (dstrapp(&directive->str, c) != 0) { bfs_perror(ctx, "dstrapp()"); goto directive_error; } const char *specifier = "s"; // Parse any flags bool must_be_numeric = false; while (true) { c = *++i; switch (c) { case '#': case '0': case '+': must_be_numeric = true; BFS_FALLTHROUGH; case ' ': case '-': if (strchr(directive->str, c)) { bfs_error(ctx, "'%s': Duplicate flag '%c'.\n", format, c); goto directive_error; } if (dstrapp(&directive->str, c) != 0) { bfs_perror(ctx, "dstrapp()"); goto directive_error; } continue; } break; } // Parse the field width while (c >= '0' && c <= '9') { if (dstrapp(&directive->str, c) != 0) { bfs_perror(ctx, "dstrapp()"); goto directive_error; } c = *++i; } // Parse the precision if (c == '.') { do { if (dstrapp(&directive->str, c) != 0) { bfs_perror(ctx, "dstrapp()"); goto directive_error; } c = *++i; } while (c >= '0' && c <= '9'); } switch (c) { case 'a': directive->fn = bfs_printf_ctime; directive->stat_field = BFS_STAT_ATIME; break; case 'b': directive->fn = bfs_printf_b; break; case 'c': directive->fn = bfs_printf_ctime; directive->stat_field = BFS_STAT_CTIME; break; case 'd': directive->fn = bfs_printf_d; specifier = "jd"; break; case 'D': directive->fn = bfs_printf_D; break; case 'f': directive->fn = bfs_printf_f; break; case 'F': directive->ptr = bfs_ctx_mtab(ctx); if (!directive->ptr) { bfs_error(ctx, "Couldn't parse the mount table: %m.\n"); goto directive_error; } directive->fn = bfs_printf_F; break; case 'g': directive->ptr = bfs_ctx_groups(ctx); if (!directive->ptr) { bfs_error(ctx, "Couldn't parse the group table: %m.\n"); goto directive_error; } directive->fn = bfs_printf_g; break; case 'G': directive->fn = bfs_printf_G; break; case 'h': directive->fn = bfs_printf_h; break; case 'H': directive->fn = bfs_printf_H; break; case 'i': directive->fn = bfs_printf_i; break; case 'k': directive->fn = bfs_printf_k; break; case 'l': directive->fn = bfs_printf_l; break; case 'm': directive->fn = bfs_printf_m; specifier = "o"; break; case 'M': directive->fn = bfs_printf_M; break; case 'n': directive->fn = bfs_printf_n; break; case 'p': directive->fn = bfs_printf_p; break; case 'P': directive->fn = bfs_printf_P; break; case 's': directive->fn = bfs_printf_s; break; case 'S': directive->fn = bfs_printf_S; specifier = "g"; break; case 't': directive->fn = bfs_printf_ctime; directive->stat_field = BFS_STAT_MTIME; break; case 'u': directive->ptr = bfs_ctx_users(ctx); if (!directive->ptr) { bfs_error(ctx, "Couldn't parse the user table: %m.\n"); goto directive_error; } directive->fn = bfs_printf_u; break; case 'U': directive->fn = bfs_printf_U; break; case 'w': directive->fn = bfs_printf_ctime; directive->stat_field = BFS_STAT_BTIME; break; case 'y': directive->fn = bfs_printf_y; break; case 'Y': directive->fn = bfs_printf_Y; break; case 'A': directive->stat_field = BFS_STAT_ATIME; goto directive_strftime; case 'B': case 'W': directive->stat_field = BFS_STAT_BTIME; goto directive_strftime; case 'C': directive->stat_field = BFS_STAT_CTIME; goto directive_strftime; case 'T': directive->stat_field = BFS_STAT_MTIME; goto directive_strftime; directive_strftime: directive->fn = bfs_printf_strftime; c = *++i; if (!c) { bfs_error(ctx, "'%s': Incomplete time specifier '%s%c'.\n", format, directive->str, i[-1]); goto directive_error; } else if (strchr("%+@aAbBcCdDeFgGhHIjklmMnprRsStTuUVwWxXyYzZ", c)) { directive->c = c; } else { bfs_error(ctx, "'%s': Unrecognized time specifier '%%%c%c'.\n", format, i[-1], c); goto directive_error; } break; case '\0': bfs_error(ctx, "'%s': Incomplete format specifier '%s'.\n", format, directive->str); goto directive_error; default: bfs_error(ctx, "'%s': Unrecognized format specifier '%%%c'.\n", format, c); goto directive_error; } if (must_be_numeric && strcmp(specifier, "s") == 0) { bfs_error(ctx, "'%s': Invalid flags '%s' for string format '%%%c'.\n", format, directive->str + 1, c); goto directive_error; } if (dstrcat(&directive->str, specifier) != 0) { bfs_perror(ctx, "dstrcat()"); goto directive_error; } tail = append_literal(tail, &literal); tail = append_directive(tail, directive); if (!literal) { literal = new_directive(ctx, bfs_printf_literal); if (!literal) { goto error; } } continue; directive_error: free_directive(directive); goto error; } one_char: if (dstrapp(&literal->str, c) != 0) { bfs_perror(ctx, "dstrapp()"); goto error; } } done: tail = append_literal(tail, &literal); if (head) { free_directive(literal); return head; } else { return literal; } error: free_directive(literal); bfs_printf_free(head); return NULL; } int bfs_printf(CFILE *cfile, const struct bfs_printf *format, const struct BFTW *ftwbuf) { int ret = 0, error = 0; for (const struct bfs_printf *directive = format; directive; directive = directive->next) { if (directive->fn(cfile, directive, ftwbuf) < 0) { ret = -1; error = errno; } } errno = error; return ret; } void bfs_printf_free(struct bfs_printf *format) { while (format) { struct bfs_printf *next = format->next; free_directive(format); format = next; } } bfs-2.3.1/printf.h000066400000000000000000000042011417254370000137420ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2017-2020 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * Implementation of -printf/-fprintf. */ #ifndef BFS_PRINTF_H #define BFS_PRINTF_H #include "color.h" struct BFTW; struct bfs_ctx; /** * A printf command, the result of parsing a single format string. */ struct bfs_printf; /** * Parse a -printf format string. * * @param ctx * The bfs context. * @param format * The format string to parse. * @return * The parsed printf command, or NULL on failure. */ struct bfs_printf *bfs_printf_parse(const struct bfs_ctx *ctx, const char *format); /** * Evaluate a parsed format string. * * @param cfile * The CFILE to print to. * @param format * The parsed printf format. * @param ftwbuf * The bftw() data for the current file. * @return * 0 on success, -1 on failure. */ int bfs_printf(CFILE *cfile, const struct bfs_printf *format, const struct BFTW *ftwbuf); /** * Free a parsed format string. */ void bfs_printf_free(struct bfs_printf *format); #endif // BFS_PRINTF_H bfs-2.3.1/pwcache.c000066400000000000000000000151451417254370000140560ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2020 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "pwcache.h" #include "darray.h" #include "trie.h" #include #include #include #include #include #include struct bfs_users { /** The array of passwd entries. */ struct passwd *entries; /** A map from usernames to entries. */ struct trie by_name; /** A map from UIDs to entries. */ struct trie by_uid; }; struct bfs_users *bfs_users_parse(void) { int error; struct bfs_users *users = malloc(sizeof(*users)); if (!users) { return NULL; } users->entries = NULL; trie_init(&users->by_name); trie_init(&users->by_uid); setpwent(); while (true) { errno = 0; struct passwd *ent = getpwent(); if (!ent) { if (errno) { error = errno; goto fail_end; } else { break; } } if (DARRAY_PUSH(&users->entries, ent) != 0) { error = errno; goto fail_end; } ent = users->entries + darray_length(users->entries) - 1; ent->pw_name = strdup(ent->pw_name); ent->pw_dir = strdup(ent->pw_dir); ent->pw_shell = strdup(ent->pw_shell); if (!ent->pw_name || !ent->pw_dir || !ent->pw_shell) { error = ENOMEM; goto fail_end; } } endpwent(); for (size_t i = 0; i < darray_length(users->entries); ++i) { struct passwd *entry = users->entries + i; struct trie_leaf *leaf = trie_insert_str(&users->by_name, entry->pw_name); if (leaf) { if (!leaf->value) { leaf->value = entry; } } else { error = errno; goto fail_free; } leaf = trie_insert_mem(&users->by_uid, &entry->pw_uid, sizeof(entry->pw_uid)); if (leaf) { if (!leaf->value) { leaf->value = entry; } } else { error = errno; goto fail_free; } } return users; fail_end: endpwent(); fail_free: bfs_users_free(users); errno = error; return NULL; } const struct passwd *bfs_getpwnam(const struct bfs_users *users, const char *name) { const struct trie_leaf *leaf = trie_find_str(&users->by_name, name); if (leaf) { return leaf->value; } else { return NULL; } } const struct passwd *bfs_getpwuid(const struct bfs_users *users, uid_t uid) { const struct trie_leaf *leaf = trie_find_mem(&users->by_uid, &uid, sizeof(uid)); if (leaf) { return leaf->value; } else { return NULL; } } void bfs_users_free(struct bfs_users *users) { if (users) { trie_destroy(&users->by_uid); trie_destroy(&users->by_name); for (size_t i = 0; i < darray_length(users->entries); ++i) { struct passwd *entry = users->entries + i; free(entry->pw_shell); free(entry->pw_dir); free(entry->pw_name); } darray_free(users->entries); free(users); } } struct bfs_groups { /** The array of group entries. */ struct group *entries; /** A map from group names to entries. */ struct trie by_name; /** A map from GIDs to entries. */ struct trie by_gid; }; /** * struct group::gr_mem isn't properly aligned on macOS, so do this to avoid * ASAN warnings. */ static char *next_gr_mem(void **gr_mem) { char *mem; memcpy(&mem, *gr_mem, sizeof(mem)); *gr_mem = (char *)*gr_mem + sizeof(mem); return mem; } struct bfs_groups *bfs_groups_parse(void) { int error; struct bfs_groups *groups = malloc(sizeof(*groups)); if (!groups) { return NULL; } groups->entries = NULL; trie_init(&groups->by_name); trie_init(&groups->by_gid); setgrent(); while (true) { errno = 0; struct group *ent = getgrent(); if (!ent) { if (errno) { error = errno; goto fail_end; } else { break; } } if (DARRAY_PUSH(&groups->entries, ent) != 0) { error = errno; goto fail_end; } ent = groups->entries + darray_length(groups->entries) - 1; void *members = ent->gr_mem; ent->gr_mem = NULL; ent->gr_name = strdup(ent->gr_name); if (!ent->gr_name) { error = errno; goto fail_end; } for (char *mem = next_gr_mem(&members); mem; mem = next_gr_mem(&members)) { char *dup = strdup(mem); if (!dup) { error = errno; goto fail_end; } if (DARRAY_PUSH(&ent->gr_mem, &dup) != 0) { error = errno; free(dup); goto fail_end; } } } endgrent(); for (size_t i = 0; i < darray_length(groups->entries); ++i) { struct group *entry = groups->entries + i; struct trie_leaf *leaf = trie_insert_str(&groups->by_name, entry->gr_name); if (leaf) { if (!leaf->value) { leaf->value = entry; } } else { error = errno; goto fail_free; } leaf = trie_insert_mem(&groups->by_gid, &entry->gr_gid, sizeof(entry->gr_gid)); if (leaf) { if (!leaf->value) { leaf->value = entry; } } else { error = errno; goto fail_free; } } return groups; fail_end: endgrent(); fail_free: bfs_groups_free(groups); errno = error; return NULL; } const struct group *bfs_getgrnam(const struct bfs_groups *groups, const char *name) { const struct trie_leaf *leaf = trie_find_str(&groups->by_name, name); if (leaf) { return leaf->value; } else { return NULL; } } const struct group *bfs_getgrgid(const struct bfs_groups *groups, gid_t gid) { const struct trie_leaf *leaf = trie_find_mem(&groups->by_gid, &gid, sizeof(gid)); if (leaf) { return leaf->value; } else { return NULL; } } void bfs_groups_free(struct bfs_groups *groups) { if (groups) { trie_destroy(&groups->by_gid); trie_destroy(&groups->by_name); for (size_t i = 0; i < darray_length(groups->entries); ++i) { struct group *entry = groups->entries + i; for (size_t j = 0; j < darray_length(entry->gr_mem); ++j) { free(entry->gr_mem[j]); } darray_free(entry->gr_mem); free(entry->gr_name); } darray_free(groups->entries); free(groups); } } bfs-2.3.1/pwcache.h000066400000000000000000000060231417254370000140560ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2020 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * A caching wrapper for /etc/{passwd,group}. */ #ifndef BFS_PWCACHE_H #define BFS_PWCACHE_H #include #include /** * The user table. */ struct bfs_users; /** * Parse the user table. * * @return * The parsed user table, or NULL on failure. */ struct bfs_users *bfs_users_parse(void); /** * Get a user entry by name. * * @param users * The user table. * @param name * The username to look up. * @return * The matching user, or NULL if not found. */ const struct passwd *bfs_getpwnam(const struct bfs_users *users, const char *name); /** * Get a user entry by ID. * * @param users * The user table. * @param uid * The ID to look up. * @return * The matching user, or NULL if not found. */ const struct passwd *bfs_getpwuid(const struct bfs_users *users, uid_t uid); /** * Free a user table. * * @param users * The user table to free. */ void bfs_users_free(struct bfs_users *users); /** * The group table. */ struct bfs_groups; /** * Parse the group table. * * @return * The parsed group table, or NULL on failure. */ struct bfs_groups *bfs_groups_parse(void); /** * Get a group entry by name. * * @param groups * The group table. * @param name * The group name to look up. * @return * The matching group, or NULL if not found. */ const struct group *bfs_getgrnam(const struct bfs_groups *groups, const char *name); /** * Get a group entry by ID. * * @param groups * The group table. * @param uid * The ID to look up. * @return * The matching group, or NULL if not found. */ const struct group *bfs_getgrgid(const struct bfs_groups *groups, gid_t gid); /** * Free a group table. * * @param groups * The group table to free. */ void bfs_groups_free(struct bfs_groups *groups); #endif // BFS_PWCACHE_H bfs-2.3.1/spawn.c000066400000000000000000000154661417254370000136020ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2018-2022 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "spawn.h" #include "util.h" #include #include #include #include #include #include #include /** * Types of spawn actions. */ enum bfs_spawn_op { BFS_SPAWN_CLOSE, BFS_SPAWN_DUP2, BFS_SPAWN_FCHDIR, BFS_SPAWN_SETRLIMIT, }; /** * A spawn action. */ struct bfs_spawn_action { struct bfs_spawn_action *next; enum bfs_spawn_op op; int in_fd; int out_fd; int resource; struct rlimit rlimit; }; int bfs_spawn_init(struct bfs_spawn *ctx) { ctx->flags = 0; ctx->actions = NULL; ctx->tail = &ctx->actions; return 0; } int bfs_spawn_destroy(struct bfs_spawn *ctx) { struct bfs_spawn_action *action = ctx->actions; while (action) { struct bfs_spawn_action *next = action->next; free(action); action = next; } return 0; } int bfs_spawn_setflags(struct bfs_spawn *ctx, enum bfs_spawn_flags flags) { ctx->flags = flags; return 0; } /** Add a spawn action to the chain. */ static struct bfs_spawn_action *bfs_spawn_add(struct bfs_spawn *ctx, enum bfs_spawn_op op) { struct bfs_spawn_action *action = malloc(sizeof(*action)); if (action) { action->next = NULL; action->op = op; action->in_fd = -1; action->out_fd = -1; *ctx->tail = action; ctx->tail = &action->next; } return action; } int bfs_spawn_addclose(struct bfs_spawn *ctx, int fd) { if (fd < 0) { errno = EBADF; return -1; } struct bfs_spawn_action *action = bfs_spawn_add(ctx, BFS_SPAWN_CLOSE); if (action) { action->out_fd = fd; return 0; } else { return -1; } } int bfs_spawn_adddup2(struct bfs_spawn *ctx, int oldfd, int newfd) { if (oldfd < 0 || newfd < 0) { errno = EBADF; return -1; } struct bfs_spawn_action *action = bfs_spawn_add(ctx, BFS_SPAWN_DUP2); if (action) { action->in_fd = oldfd; action->out_fd = newfd; return 0; } else { return -1; } } int bfs_spawn_addfchdir(struct bfs_spawn *ctx, int fd) { if (fd < 0) { errno = EBADF; return -1; } struct bfs_spawn_action *action = bfs_spawn_add(ctx, BFS_SPAWN_FCHDIR); if (action) { action->in_fd = fd; return 0; } else { return -1; } } int bfs_spawn_addsetrlimit(struct bfs_spawn *ctx, int resource, const struct rlimit *rl) { struct bfs_spawn_action *action = bfs_spawn_add(ctx, BFS_SPAWN_SETRLIMIT); if (action) { action->resource = resource; action->rlimit = *rl; return 0; } else { return -1; } } /** Actually exec() the new process. */ static void bfs_spawn_exec(const char *exe, const struct bfs_spawn *ctx, char **argv, char **envp, int pipefd[2]) { int error; const struct bfs_spawn_action *actions = ctx ? ctx->actions : NULL; xclose(pipefd[0]); for (const struct bfs_spawn_action *action = actions; action; action = action->next) { // Move the error-reporting pipe out of the way if necessary... if (action->out_fd == pipefd[1]) { int fd = dup_cloexec(pipefd[1]); if (fd < 0) { goto fail; } xclose(pipefd[1]); pipefd[1] = fd; } // ... and pretend the pipe doesn't exist if (action->in_fd == pipefd[1]) { errno = EBADF; goto fail; } switch (action->op) { case BFS_SPAWN_CLOSE: if (close(action->out_fd) != 0) { goto fail; } break; case BFS_SPAWN_DUP2: if (dup2(action->in_fd, action->out_fd) < 0) { goto fail; } break; case BFS_SPAWN_FCHDIR: if (fchdir(action->in_fd) != 0) { goto fail; } break; case BFS_SPAWN_SETRLIMIT: if (setrlimit(action->resource, &action->rlimit) != 0) { goto fail; } break; } } execve(exe, argv, envp); fail: error = errno; // In case of a write error, the parent will still see that we exited // unsuccessfully, but won't know why (void) xwrite(pipefd[1], &error, sizeof(error)); xclose(pipefd[1]); _Exit(127); } pid_t bfs_spawn(const char *exe, const struct bfs_spawn *ctx, char **argv, char **envp) { extern char **environ; if (!envp) { envp = environ; } enum bfs_spawn_flags flags = ctx ? ctx->flags : 0; char *resolved = NULL; if (flags & BFS_SPAWN_USEPATH) { exe = resolved = bfs_spawn_resolve(exe); if (!resolved) { return -1; } } // Use a pipe to report errors from the child int pipefd[2]; if (pipe_cloexec(pipefd) != 0) { free(resolved); return -1; } pid_t pid = fork(); if (pid < 0) { close_quietly(pipefd[1]); close_quietly(pipefd[0]); free(resolved); return -1; } else if (pid == 0) { // Child bfs_spawn_exec(exe, ctx, argv, envp, pipefd); } // Parent xclose(pipefd[1]); free(resolved); int error; ssize_t nbytes = xread(pipefd[0], &error, sizeof(error)); xclose(pipefd[0]); if (nbytes == sizeof(error)) { int wstatus; waitpid(pid, &wstatus, 0); errno = error; return -1; } return pid; } char *bfs_spawn_resolve(const char *exe) { if (strchr(exe, '/')) { return strdup(exe); } const char *path = getenv("PATH"); char *confpath = NULL; if (!path) { path = confpath = xconfstr(_CS_PATH); if (!path) { return NULL; } } size_t cap = 0; char *ret = NULL; while (true) { const char *end = strchr(path, ':'); size_t len = end ? (size_t)(end - path) : strlen(path); // POSIX 8.3: "A zero-length prefix is a legacy feature that // indicates the current working directory." if (len == 0) { path = "."; len = 1; } size_t total = len + 1 + strlen(exe) + 1; if (cap < total) { char *grown = realloc(ret, total); if (!grown) { goto fail; } ret = grown; cap = total; } memcpy(ret, path, len); if (ret[len - 1] != '/') { ret[len++] = '/'; } strcpy(ret + len, exe); if (xfaccessat(AT_FDCWD, ret, X_OK) == 0) { break; } if (!end) { errno = ENOENT; goto fail; } path = end + 1; } free(confpath); return ret; fail: free(confpath); free(ret); return NULL; } bfs-2.3.1/spawn.h000066400000000000000000000071611417254370000136000ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2018-2019 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * A process-spawning library inspired by posix_spawn(). */ #ifndef BFS_SPAWN_H #define BFS_SPAWN_H #include #include /** * bfs_spawn() flags. */ enum bfs_spawn_flags { /** Use the PATH variable to resolve the executable (like execvp()). */ BFS_SPAWN_USEPATH = 1 << 0, }; /** * bfs_spawn() attributes, controlling the context of the new process. */ struct bfs_spawn { enum bfs_spawn_flags flags; struct bfs_spawn_action *actions; struct bfs_spawn_action **tail; }; /** * Create a new bfs_spawn() context. * * @return 0 on success, -1 on failure. */ int bfs_spawn_init(struct bfs_spawn *ctx); /** * Destroy a bfs_spawn() context. * * @return 0 on success, -1 on failure. */ int bfs_spawn_destroy(struct bfs_spawn *ctx); /** * Set the flags for a bfs_spawn() context. * * @return 0 on success, -1 on failure. */ int bfs_spawn_setflags(struct bfs_spawn *ctx, enum bfs_spawn_flags flags); /** * Add a close() action to a bfs_spawn() context. * * @return 0 on success, -1 on failure. */ int bfs_spawn_addclose(struct bfs_spawn *ctx, int fd); /** * Add a dup2() action to a bfs_spawn() context. * * @return 0 on success, -1 on failure. */ int bfs_spawn_adddup2(struct bfs_spawn *ctx, int oldfd, int newfd); /** * Add an fchdir() action to a bfs_spawn() context. * * @return 0 on success, -1 on failure. */ int bfs_spawn_addfchdir(struct bfs_spawn *ctx, int fd); /** * Add a setrlimit() action to a bfs_spawn() context. * * @return 0 on success, -1 on failure. */ int bfs_spawn_addsetrlimit(struct bfs_spawn *ctx, int resource, const struct rlimit *rl); /** * Spawn a new process. * * @param exe * The executable to run. * @param ctx * The context for the new process. * @param argv * The arguments for the new process. * @param envp * The environment variables for the new process (NULL for the current * environment). * @return * The PID of the new process, or -1 on error. */ pid_t bfs_spawn(const char *exe, const struct bfs_spawn *ctx, char **argv, char **envp); /** * Look up an executable in the current PATH, as BFS_SPAWN_USEPATH or execvp() * would do. * * @param exe * The name of the binary to execute. Bare names without a '/' will be * searched on the provided PATH. * @return * The full path to the executable, which should be free()'d, or NULL on * failure. */ char *bfs_spawn_resolve(const char *exe); #endif // BFS_SPAWN_H bfs-2.3.1/stat.c000066400000000000000000000224421417254370000134150ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2018-2019 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "stat.h" #include "util.h" #include #include #include #include #include #include #include #if BFS_HAS_SYS_PARAM # include #endif #ifdef STATX_BASIC_STATS # define HAVE_STATX true #elif __linux__ # include # include # include #endif #if HAVE_STATX || defined(__NR_statx) # define HAVE_BFS_STATX true #endif #if __APPLE__ # define st_atim st_atimespec # define st_ctim st_ctimespec # define st_mtim st_mtimespec # define st_birthtim st_birthtimespec #endif const char *bfs_stat_field_name(enum bfs_stat_field field) { switch (field) { case BFS_STAT_DEV: return "device number"; case BFS_STAT_INO: return "inode nunmber"; case BFS_STAT_TYPE: return "type"; case BFS_STAT_MODE: return "mode"; case BFS_STAT_NLINK: return "link count"; case BFS_STAT_GID: return "group ID"; case BFS_STAT_UID: return "user ID"; case BFS_STAT_SIZE: return "size"; case BFS_STAT_BLOCKS: return "block count"; case BFS_STAT_RDEV: return "underlying device"; case BFS_STAT_ATTRS: return "attributes"; case BFS_STAT_ATIME: return "access time"; case BFS_STAT_BTIME: return "birth time"; case BFS_STAT_CTIME: return "change time"; case BFS_STAT_MTIME: return "modification time"; } assert(!"Unrecognized stat field"); return "???"; } /** * Check if we should retry a failed stat() due to a potentially broken link. */ static bool bfs_stat_retry(int ret, enum bfs_stat_flags flags) { return ret != 0 && (flags & (BFS_STAT_NOFOLLOW | BFS_STAT_TRYFOLLOW)) == BFS_STAT_TRYFOLLOW && is_nonexistence_error(errno); } /** * Convert a struct stat to a struct bfs_stat. */ static void bfs_stat_convert(const struct stat *statbuf, struct bfs_stat *buf) { buf->mask = 0; buf->dev = statbuf->st_dev; buf->mask |= BFS_STAT_DEV; buf->ino = statbuf->st_ino; buf->mask |= BFS_STAT_INO; buf->mode = statbuf->st_mode; buf->mask |= BFS_STAT_TYPE | BFS_STAT_MODE; buf->nlink = statbuf->st_nlink; buf->mask |= BFS_STAT_NLINK; buf->gid = statbuf->st_gid; buf->mask |= BFS_STAT_GID; buf->uid = statbuf->st_uid; buf->mask |= BFS_STAT_UID; buf->size = statbuf->st_size; buf->mask |= BFS_STAT_SIZE; buf->blocks = statbuf->st_blocks; buf->mask |= BFS_STAT_BLOCKS; buf->rdev = statbuf->st_rdev; buf->mask |= BFS_STAT_RDEV; #if BSD buf->attrs = statbuf->st_flags; buf->mask |= BFS_STAT_ATTRS; #endif buf->atime = statbuf->st_atim; buf->mask |= BFS_STAT_ATIME; buf->ctime = statbuf->st_ctim; buf->mask |= BFS_STAT_CTIME; buf->mtime = statbuf->st_mtim; buf->mask |= BFS_STAT_MTIME; #if __APPLE__ || __FreeBSD__ || __NetBSD__ buf->btime = statbuf->st_birthtim; buf->mask |= BFS_STAT_BTIME; #endif } /** * bfs_stat() implementation backed by stat(). */ static int bfs_stat_impl(int at_fd, const char *at_path, int at_flags, enum bfs_stat_flags flags, struct bfs_stat *buf) { struct stat statbuf; int ret = fstatat(at_fd, at_path, &statbuf, at_flags); if (bfs_stat_retry(ret, flags)) { at_flags |= AT_SYMLINK_NOFOLLOW; ret = fstatat(at_fd, at_path, &statbuf, at_flags); } if (ret == 0) { bfs_stat_convert(&statbuf, buf); } return ret; } #if HAVE_BFS_STATX /** * Wrapper for the statx() system call, which had no glibc wrapper prior to 2.28. */ static int bfs_statx(int at_fd, const char *at_path, int at_flags, unsigned int mask, struct statx *buf) { #if BFS_HAS_FEATURE(memory_sanitizer, false) // -fsanitize=memory doesn't know about statx(), so tell it the memory // got initialized memset(buf, 0, sizeof(*buf)); #endif #if HAVE_STATX return statx(at_fd, at_path, at_flags, mask, buf); #else return syscall(__NR_statx, at_fd, at_path, at_flags, mask, buf); #endif } /** * bfs_stat() implementation backed by statx(). */ static int bfs_statx_impl(int at_fd, const char *at_path, int at_flags, enum bfs_stat_flags flags, struct bfs_stat *buf) { unsigned int mask = STATX_BASIC_STATS | STATX_BTIME; struct statx xbuf; int ret = bfs_statx(at_fd, at_path, at_flags, mask, &xbuf); if (bfs_stat_retry(ret, flags)) { at_flags |= AT_SYMLINK_NOFOLLOW; ret = bfs_statx(at_fd, at_path, at_flags, mask, &xbuf); } if (ret != 0) { return ret; } // Callers shouldn't have to check anything except the times const unsigned int guaranteed = STATX_BASIC_STATS ^ (STATX_ATIME | STATX_CTIME | STATX_MTIME); if ((xbuf.stx_mask & guaranteed) != guaranteed) { errno = ENOTSUP; return -1; } buf->mask = 0; buf->dev = bfs_makedev(xbuf.stx_dev_major, xbuf.stx_dev_minor); buf->mask |= BFS_STAT_DEV; if (xbuf.stx_mask & STATX_INO) { buf->ino = xbuf.stx_ino; buf->mask |= BFS_STAT_INO; } buf->mode = xbuf.stx_mode; if (xbuf.stx_mask & STATX_TYPE) { buf->mask |= BFS_STAT_TYPE; } if (xbuf.stx_mask & STATX_MODE) { buf->mask |= BFS_STAT_MODE; } if (xbuf.stx_mask & STATX_NLINK) { buf->nlink = xbuf.stx_nlink; buf->mask |= BFS_STAT_NLINK; } if (xbuf.stx_mask & STATX_GID) { buf->gid = xbuf.stx_gid; buf->mask |= BFS_STAT_GID; } if (xbuf.stx_mask & STATX_UID) { buf->uid = xbuf.stx_uid; buf->mask |= BFS_STAT_UID; } if (xbuf.stx_mask & STATX_SIZE) { buf->size = xbuf.stx_size; buf->mask |= BFS_STAT_SIZE; } if (xbuf.stx_mask & STATX_BLOCKS) { buf->blocks = xbuf.stx_blocks; buf->mask |= BFS_STAT_BLOCKS; } buf->rdev = bfs_makedev(xbuf.stx_rdev_major, xbuf.stx_rdev_minor); buf->mask |= BFS_STAT_RDEV; buf->attrs = xbuf.stx_attributes; buf->mask |= BFS_STAT_ATTRS; if (xbuf.stx_mask & STATX_ATIME) { buf->atime.tv_sec = xbuf.stx_atime.tv_sec; buf->atime.tv_nsec = xbuf.stx_atime.tv_nsec; buf->mask |= BFS_STAT_ATIME; } if (xbuf.stx_mask & STATX_BTIME) { buf->btime.tv_sec = xbuf.stx_btime.tv_sec; buf->btime.tv_nsec = xbuf.stx_btime.tv_nsec; buf->mask |= BFS_STAT_BTIME; } if (xbuf.stx_mask & STATX_CTIME) { buf->ctime.tv_sec = xbuf.stx_ctime.tv_sec; buf->ctime.tv_nsec = xbuf.stx_ctime.tv_nsec; buf->mask |= BFS_STAT_CTIME; } if (xbuf.stx_mask & STATX_MTIME) { buf->mtime.tv_sec = xbuf.stx_mtime.tv_sec; buf->mtime.tv_nsec = xbuf.stx_mtime.tv_nsec; buf->mask |= BFS_STAT_MTIME; } return ret; } #endif // HAVE_BFS_STATX /** * Allows calling stat with custom at_flags. */ static int bfs_stat_explicit(int at_fd, const char *at_path, int at_flags, enum bfs_stat_flags flags, struct bfs_stat *buf) { #if HAVE_BFS_STATX static bool has_statx = true; if (has_statx) { int ret = bfs_statx_impl(at_fd, at_path, at_flags, flags, buf); // EPERM is commonly returned in a seccomp() sandbox that does // not allow statx() if (ret != 0 && (errno == ENOSYS || errno == EPERM)) { has_statx = false; } else { return ret; } } #endif return bfs_stat_impl(at_fd, at_path, at_flags, flags, buf); } int bfs_stat(int at_fd, const char *at_path, enum bfs_stat_flags flags, struct bfs_stat *buf) { int at_flags = 0; if (flags & BFS_STAT_NOFOLLOW) { at_flags |= AT_SYMLINK_NOFOLLOW; } #ifdef AT_STATX_DONT_SYNC if (flags & BFS_STAT_NOSYNC) { at_flags |= AT_STATX_DONT_SYNC; } #endif if (at_path) { return bfs_stat_explicit(at_fd, at_path, at_flags, flags, buf); } // Check __GNU__ to work around https://lists.gnu.org/archive/html/bug-hurd/2021-12/msg00001.html #if defined(AT_EMPTY_PATH) && !__GNU__ static bool has_at_ep = true; if (has_at_ep) { at_flags |= AT_EMPTY_PATH; int ret = bfs_stat_explicit(at_fd, "", at_flags, flags, buf); if (ret != 0 && errno == EINVAL) { has_at_ep = false; } else { return ret; } } #endif struct stat statbuf; if (fstat(at_fd, &statbuf) == 0) { bfs_stat_convert(&statbuf, buf); return 0; } else { return -1; } } const struct timespec *bfs_stat_time(const struct bfs_stat *buf, enum bfs_stat_field field) { if (!(buf->mask & field)) { errno = ENOTSUP; return NULL; } switch (field) { case BFS_STAT_ATIME: return &buf->atime; case BFS_STAT_BTIME: return &buf->btime; case BFS_STAT_CTIME: return &buf->ctime; case BFS_STAT_MTIME: return &buf->mtime; default: assert(!"Invalid stat field for time"); errno = EINVAL; return NULL; } } void bfs_stat_id(const struct bfs_stat *buf, bfs_file_id *id) { memcpy(*id, &buf->dev, sizeof(buf->dev)); memcpy(*id + sizeof(buf->dev), &buf->ino, sizeof(buf->ino)); } bfs-2.3.1/stat.h000066400000000000000000000107031417254370000134170ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2018-2019 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * A facade over the stat() API that unifies some details that diverge between * implementations, like the names of the timespec fields and the presence of * file "birth" times. On new enough Linux kernels, the facade is backed by * statx() instead, and so it exposes a similar interface with a mask for which * fields were successfully returned. */ #ifndef BFS_STAT_H #define BFS_STAT_H #include "util.h" #include #include #if BFS_HAS_SYS_PARAM # include #endif /** * bfs_stat field bitmask. */ enum bfs_stat_field { BFS_STAT_DEV = 1 << 0, BFS_STAT_INO = 1 << 1, BFS_STAT_TYPE = 1 << 2, BFS_STAT_MODE = 1 << 3, BFS_STAT_NLINK = 1 << 4, BFS_STAT_GID = 1 << 5, BFS_STAT_UID = 1 << 6, BFS_STAT_SIZE = 1 << 7, BFS_STAT_BLOCKS = 1 << 8, BFS_STAT_RDEV = 1 << 9, BFS_STAT_ATTRS = 1 << 10, BFS_STAT_ATIME = 1 << 11, BFS_STAT_BTIME = 1 << 12, BFS_STAT_CTIME = 1 << 13, BFS_STAT_MTIME = 1 << 14, }; /** * Get the human-readable name of a bfs_stat field. */ const char *bfs_stat_field_name(enum bfs_stat_field field); /** * bfs_stat() flags. */ enum bfs_stat_flags { /** Follow symlinks (the default). */ BFS_STAT_FOLLOW = 0, /** Never follow symlinks. */ BFS_STAT_NOFOLLOW = 1 << 0, /** Try to follow symlinks, but fall back to the link itself if broken. */ BFS_STAT_TRYFOLLOW = 1 << 1, /** Try to use cached values without synchronizing remote filesystems. */ BFS_STAT_NOSYNC = 1 << 2, }; #ifdef DEV_BSIZE # define BFS_STAT_BLKSIZE DEV_BSIZE #elif defined(S_BLKSIZE) # define BFS_STAT_BLKSIZE S_BLKSIZE #else # define BFS_STAT_BLKSIZE 512 #endif /** * Facade over struct stat. */ struct bfs_stat { /** Bitmask indicating filled fields. */ enum bfs_stat_field mask; /** Device ID containing the file. */ dev_t dev; /** Inode number. */ ino_t ino; /** File type and access mode. */ mode_t mode; /** Number of hard links. */ nlink_t nlink; /** Owner group ID. */ gid_t gid; /** Owner user ID. */ uid_t uid; /** File size in bytes. */ off_t size; /** Number of disk blocks allocated (of size BFS_STAT_BLKSIZE). */ blkcnt_t blocks; /** The device ID represented by this file. */ dev_t rdev; /** Attributes/flags set on the file. */ unsigned long long attrs; /** Access time. */ struct timespec atime; /** Birth/creation time. */ struct timespec btime; /** Status change time. */ struct timespec ctime; /** Modification time. */ struct timespec mtime; }; /** * Facade over fstatat(). * * @param at_fd * The base file descriptor for the lookup. * @param at_path * The path to stat, relative to at_fd. Pass NULL to fstat() at_fd * itself. * @param flags * Flags that affect the lookup. * @param[out] buf * A place to store the stat buffer, if successful. * @return * 0 on success, -1 on error. */ int bfs_stat(int at_fd, const char *at_path, enum bfs_stat_flags flags, struct bfs_stat *buf); /** * Get a particular time field from a bfs_stat() buffer. */ const struct timespec *bfs_stat_time(const struct bfs_stat *buf, enum bfs_stat_field field); /** * A unique ID for a file. */ typedef unsigned char bfs_file_id[sizeof(dev_t) + sizeof(ino_t)]; /** * Compute a unique ID for a file. */ void bfs_stat_id(const struct bfs_stat *buf, bfs_file_id *id); #endif // BFS_STAT_H bfs-2.3.1/tests.sh000077500000000000000000002037761417254370000140120ustar00rootroot00000000000000#!/usr/bin/env bash ############################################################################ # bfs # # Copyright (C) 2015-2021 Tavian Barnes # # # # Permission to use, copy, modify, and/or distribute this software for any # # purpose with or without fee is hereby granted. # # # # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES # # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF # # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR # # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES # # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN # # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF # # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. # ############################################################################ set -e set -o physical umask 022 export LC_ALL=C export TZ=UTC0 export ASAN_OPTIONS="abort_on_error=1" export LSAN_OPTIONS="abort_on_error=1" export MSAN_OPTIONS="abort_on_error=1" export TSAN_OPTIONS="abort_on_error=1" export UBSAN_OPTIONS="abort_on_error=1" if [ -t 1 ]; then BLD="$(printf '\033[01m')" RED="$(printf '\033[01;31m')" GRN="$(printf '\033[01;32m')" YLW="$(printf '\033[01;33m')" BLU="$(printf '\033[01;34m')" MAG="$(printf '\033[01;35m')" CYN="$(printf '\033[01;36m')" RST="$(printf '\033[0m')" fi if command -v capsh &>/dev/null; then if capsh --has-p=cap_dac_override &>/dev/null || capsh --has-p=cap_dac_read_search &>/dev/null; then if [ -n "$BFS_TRIED_DROP" ]; then cat >&2 <&2 <&2 <&2 usage >&2 exit 1 ;; esac done posix_tests=( # General parsing test_basic test_parens test_bang test_implicit_and test_a test_o test_weird_names test_incomplete test_missing_paren test_extra_paren # Flags test_H test_H_slash test_H_broken test_H_notdir test_H_loops test_L test_L_broken test_L_notdir test_L_loops test_flag_weird_names test_flag_comma # Primaries test_depth test_depth_slash test_depth_error test_L_depth test_exec test_exec_plus test_exec_plus_status test_exec_plus_semicolon test_group_name test_group_id test_group_nogroup test_links test_links_plus test_links_minus test_name test_name_root test_name_root_depth test_name_trailing_slash test_newer test_newer_link test_nogroup test_nogroup_ulimit test_nouser test_nouser_ulimit test_ok_stdin test_ok_plus_semicolon test_path test_perm_000 test_perm_000_minus test_perm_222 test_perm_222_minus test_perm_644 test_perm_644_minus test_perm_symbolic test_perm_symbolic_minus test_perm_leading_plus_symbolic_minus test_permcopy test_perm_setid test_perm_sticky test_prune test_prune_or_print test_not_prune test_size test_size_plus test_size_bytes test_type_d test_type_f test_type_l test_H_type_l test_L_type_l test_user_name test_user_id test_user_nouser # Closed file descriptors test_closed_stdin test_closed_stdout test_closed_stderr # PATH_MAX handling test_deep # Optimizer tests test_or_purity test_double_negation test_de_morgan_not test_de_morgan_and test_de_morgan_or test_data_flow_group test_data_flow_user test_data_flow_type test_data_flow_and_swap test_data_flow_or_swap ) bsd_tests=( # Flags test_E test_P test_P_slash test_X test_d_path test_f test_s test_double_dash test_flag_double_dash # Primaries test_acl test_L_acl test_anewer test_asince test_delete test_delete_many test_depth_maxdepth_1 test_depth_maxdepth_2 test_depth_mindepth_1 test_depth_mindepth_2 test_depth_n test_depth_n_plus test_depth_n_minus test_depth_depth_n test_depth_depth_n_plus test_depth_depth_n_minus test_depth_overflow test_data_flow_depth test_exec_substring test_execdir_pwd test_execdir_slash test_execdir_slash_pwd test_execdir_slashes test_execdir_ulimit test_exit test_flags test_follow test_gid_name test_ilname test_L_ilname test_iname test_inum test_ipath test_iregex test_lname test_L_lname test_ls test_L_ls test_maxdepth test_mindepth test_mnewer test_H_mnewer test_msince test_mtime_units test_name_slash test_name_slashes test_H_newer test_newerma test_newermt test_newermt_epoch_minus_one test_ok_stdin test_ok_closed_stdin test_okdir_stdin test_okdir_closed_stdin test_perm_000_plus test_perm_222_plus test_perm_644_plus test_printx test_quit test_quit_child test_quit_depth test_quit_depth_child test_quit_after_print test_quit_before_print test_quit_implicit_print test_rm test_regex test_regex_parens test_samefile test_samefile_symlink test_H_samefile_symlink test_L_samefile_symlink test_samefile_broken test_H_samefile_broken test_L_samefile_broken test_samefile_notdir test_H_samefile_notdir test_L_samefile_notdir test_size_T test_size_big test_uid_name # Optimizer tests test_data_flow_sparse ) gnu_tests=( # General parsing test_not test_and test_or test_comma test_precedence test_follow_comma # Flags test_P test_P_slash test_L_loops_continue test_double_dash test_flag_double_dash # Primaries test_anewer test_path_d test_daystart test_daystart_twice test_delete test_delete_many test_L_delete test_depth_mindepth_1 test_depth_mindepth_2 test_depth_maxdepth_1 test_depth_maxdepth_2 test_empty test_empty_special test_exec_nothing test_exec_substring test_execdir test_execdir_substring test_execdir_plus_semicolon test_execdir_pwd test_execdir_slash test_execdir_slash_pwd test_execdir_slashes test_execdir_ulimit test_executable test_false test_files0_from_file test_files0_from_stdin test_files0_from_none test_files0_from_empty test_files0_from_nowhere test_files0_from_nothing test_files0_from_ok test_fls test_follow test_fprint test_fprint_duplicate test_fprint_error test_fprint_noerror test_fprint_noarg test_fprint_nonexistent test_fprint_truncate test_fprint0 test_fprintf test_fprintf_nofile test_fprintf_noformat test_fstype test_gid test_gid_plus test_gid_plus_plus test_gid_minus test_gid_minus_plus test_ignore_readdir_race test_ignore_readdir_race_root test_ignore_readdir_race_notdir test_ilname test_L_ilname test_iname test_inum test_ipath test_iregex test_lname test_L_lname test_ls test_L_ls test_maxdepth test_mindepth test_name_slash test_name_slashes test_H_newer test_newerma test_newermt test_newermt_epoch_minus_one test_ok_closed_stdin test_ok_nothing test_okdir_closed_stdin test_okdir_plus_semicolon test_perm_000_slash test_perm_222_slash test_perm_644_slash test_perm_symbolic_slash test_perm_leading_plus_symbolic_slash test_print_error test_print0 test_printf test_printf_empty test_printf_slash test_printf_slashes test_printf_trailing_slash test_printf_trailing_slashes test_printf_flags test_printf_types test_printf_escapes test_printf_times test_printf_leak test_printf_nul test_printf_Y_error test_printf_H test_printf_u_g_ulimit test_printf_l_nonlink test_quit test_quit_child test_quit_depth test_quit_depth_child test_quit_after_print test_quit_before_print test_readable test_regex test_regex_parens test_regex_error test_regextype_posix_basic test_regextype_posix_extended test_samefile test_samefile_symlink test_H_samefile_symlink test_L_samefile_symlink test_samefile_broken test_H_samefile_broken test_L_samefile_broken test_samefile_notdir test_H_samefile_notdir test_L_samefile_notdir test_size_big test_true test_uid test_uid_plus test_uid_plus_plus test_uid_minus test_uid_minus_plus test_writable test_xtype_l test_xtype_f test_L_xtype_l test_L_xtype_f # Optimizer tests test_and_purity test_not_reachability test_comma_reachability test_and_false_or_true test_comma_redundant_true test_comma_redundant_false ) bfs_tests=( # General parsing test_path_flag_expr test_path_expr_flag test_flag_expr_path test_expr_flag_path test_expr_path_flag test_unexpected_operator test_typo # Flags test_D_multi test_D_all test_O0 test_O1 test_O2 test_O3 test_Ofast test_S_bfs test_S_dfs test_S_ids # Special forms test_exclude_name test_exclude_depth test_exclude_mindepth test_exclude_print test_exclude_exclude # Primaries test_color test_color_L test_color_rs_lc_rc_ec test_color_escapes test_color_nul test_color_ln_target test_color_L_ln_target test_color_mh test_color_mh0 test_color_or test_color_mi test_color_or_mi test_color_or_mi0 test_color_or0_mi test_color_or0_mi0 test_color_su_sg0 test_color_su0_sg test_color_su0_sg0 test_color_st_tw_ow0 test_color_st_tw0_ow test_color_st_tw0_ow0 test_color_st0_tw_ow test_color_st0_tw_ow0 test_color_st0_tw0_ow test_color_st0_tw0_ow0 test_color_ext test_color_ext0 test_color_ext_override test_color_ext_underride test_color_missing_colon test_color_no_stat test_color_L_no_stat test_color_star test_color_ls test_execdir_plus test_fprint_duplicate_stdout test_fprint_error_stdout test_fprint_error_stderr test_help test_hidden test_hidden_root test_links_noarg test_links_empty test_links_negative test_links_invalid test_newerma_nonexistent test_newermt_invalid test_newermq test_newerqm test_nohidden test_nohidden_depth test_perm_symbolic_trailing_comma test_perm_symbolic_double_comma test_perm_symbolic_missing_action test_perm_leading_plus_symbolic test_printf_w test_printf_incomplete_escape test_printf_invalid_escape test_printf_incomplete_format test_printf_invalid_format test_printf_duplicate_flag test_printf_must_be_numeric test_printf_color test_type_multi test_unique test_unique_depth test_L_unique test_L_unique_loops test_L_unique_depth test_version test_xtype_multi # Optimizer tests test_data_flow_hidden test_xtype_reorder test_xtype_depth # PATH_MAX handling test_deep_strict # Error handling test_stderr_fails_silently test_stderr_fails_loudly ) sudo_tests=( test_capable test_L_capable test_mount test_L_mount test_xdev test_L_xdev test_inum_mount test_inum_bind_mount test_type_bind_mount test_xtype_bind_mount ) case "$UNAME" in Darwin|FreeBSD) bsd_tests+=( test_xattr test_L_xattr test_xattrname test_L_xattrname ) ;; *) sudo_tests+=( test_xattr test_L_xattr test_xattrname test_L_xattrname ) ;; esac if [ "$DEFAULT" ]; then POSIX=yes BSD=yes GNU=yes ALL=yes fi if [ ! "$EXPLICIT" ]; then [ "$POSIX" ] && enabled_tests+=("${posix_tests[@]}") [ "$BSD" ] && enabled_tests+=("${bsd_tests[@]}") [ "$GNU" ] && enabled_tests+=("${gnu_tests[@]}") [ "$ALL" ] && enabled_tests+=("${bfs_tests[@]}") [ "$SUDO" ] && enabled_tests+=("${sudo_tests[@]}") fi eval enabled_tests=($(printf '%q\n' "${enabled_tests[@]}" | sort -u)) # The temporary directory that will hold our test data TMP="$(mktemp -d "${TMPDIR:-/tmp}"/bfs.XXXXXXXXXX)" chown "$(id -u):$(id -g)" "$TMP" # Clean up temporary directories on exit function cleanup() { # Don't force rm to deal with long paths for dir in "$TMP"/deep/*/*; do if [ -d "$dir" ]; then (cd "$dir" && rm -rf *) fi done # In case a test left anything weird in scratch/ if [ -e "$TMP"/scratch ]; then chmod -R +rX "$TMP"/scratch fi rm -rf "$TMP" } if [ "$CLEAN" ]; then trap cleanup EXIT else echo "Test files saved to $TMP" fi # Install a file, creating any parent directories function installp() { local target="${@: -1}" mkdir -p "${target%/*}" install "$@" } # Prefer GNU touch to work around https://apple.stackexchange.com/a/425730/397839 if command -v gtouch &>/dev/null; then TOUCH=gtouch else TOUCH=touch fi # Like a mythical touch -p function touchp() { for arg; do installp -m644 /dev/null "$arg" done } # Creates a simple file+directory structure for tests function make_basic() { touchp "$1/a" touchp "$1/b" touchp "$1/c/d" touchp "$1/e/f" mkdir -p "$1/g/h" mkdir -p "$1/i" touchp "$1/j/foo" touchp "$1/k/foo/bar" touchp "$1/l/foo/bar/baz" echo baz >"$1/l/foo/bar/baz" } make_basic "$TMP/basic" # Creates a file+directory structure with various permissions for tests function make_perms() { installp -m000 /dev/null "$1/0" installp -m444 /dev/null "$1/r" installp -m222 /dev/null "$1/w" installp -m644 /dev/null "$1/rw" installp -m555 /dev/null "$1/rx" installp -m311 /dev/null "$1/wx" installp -m755 /dev/null "$1/rwx" } make_perms "$TMP/perms" # Creates a file+directory structure with various symbolic and hard links function make_links() { touchp "$1/file" ln -s file "$1/symlink" ln "$1/file" "$1/hardlink" ln -s nowhere "$1/broken" ln -s symlink/file "$1/notdir" mkdir -p "$1/deeply/nested/dir" touchp "$1/deeply/nested/file" ln -s file "$1/deeply/nested/link" ln -s nowhere "$1/deeply/nested/broken" ln -s deeply/nested "$1/skip" } make_links "$TMP/links" # Creates a file+directory structure with symbolic link loops function make_loops() { touchp "$1/file" ln -s file "$1/symlink" ln -s nowhere "$1/broken" ln -s symlink/file "$1/notdir" ln -s loop "$1/loop" mkdir -p "$1/deeply/nested/dir" ln -s ../../deeply "$1/deeply/nested/loop" ln -s deeply/nested/loop/nested "$1/skip" } make_loops "$TMP/loops" # Creates a file+directory structure with varying timestamps function make_times() { mkdir -p "$1" $TOUCH -t 199112140000 "$1/a" $TOUCH -t 199112140001 "$1/b" $TOUCH -t 199112140002 "$1/c" ln -s a "$1/l" $TOUCH -h -t 199112140003 "$1/l" $TOUCH -t 199112140004 "$1" } make_times "$TMP/times" # Creates a file+directory structure with various weird file/directory names function make_weirdnames() { touchp "$1/-/a" touchp "$1/(/b" touchp "$1/(-/c" touchp "$1/!/d" touchp "$1/!-/e" touchp "$1/,/f" touchp "$1/)/g" touchp "$1/.../h" touchp "$1/\\/i" touchp "$1/ /j" } make_weirdnames "$TMP/weirdnames" # Creates a very deep directory structure for testing PATH_MAX handling function make_deep() { mkdir -p "$1" # $name will be 255 characters, aka _XOPEN_NAME_MAX local name="0123456789ABCDEF" name="${name}${name}${name}${name}" name="${name}${name}${name}${name}" name="${name:0:255}" for i in {0..9} A B C D E F; do ( mkdir "$1/$i" cd "$1/$i" # 16 * 256 == 4096 == PATH_MAX for j in {1..16}; do mkdir "$name" cd "$name" 2>/dev/null done $TOUCH "$name" ) done } make_deep "$TMP/deep" # Creates a directory structure with many different types, and therefore colors function make_rainbow() { touchp "$1/file.txt" touchp "$1/file.dat" touchp "$1/star".{gz,tar,tar.gz} ln -s file.txt "$1/link.txt" touchp "$1/mh1" ln "$1/mh1" "$1/mh2" mkfifo "$1/pipe" # TODO: block ln -s /dev/null "$1/chardev_link" ln -s nowhere "$1/broken" "$TESTS/mksock" "$1/socket" touchp "$1"/s{u,g,ug}id chmod u+s "$1"/su{,g}id chmod g+s "$1"/s{u,}gid mkdir "$1/ow" "$1"/sticky{,_ow} chmod o+w "$1"/*ow chmod +t "$1"/sticky* touchp "$1"/exec.sh chmod +x "$1"/exec.sh } make_rainbow "$TMP/rainbow" # Creates a scratch directory that tests can modify function make_scratch() { mkdir -p "$1" } make_scratch "$TMP/scratch" function bfs_sort() { awk -F/ '{ print NF - 1 " " $0 }' | sort -n | cut -d' ' -f2- } # Close stdin so bfs doesn't think we're interactive exec &1 fi function bfs_verbose() { if [ "$VERBOSE" ]; then if [ -t 3 ]; then printf "${GRN}%q${RST} " $BFS >&3 local expr_started= for arg; do if [[ $arg == -[A-Z]* ]]; then printf "${CYN}%q${RST} " "$arg" >&3 elif [[ $arg == [\(!] || $arg == -[ao] || $arg == -and || $arg == -or || $arg == -not ]]; then expr_started=yes printf "${RED}%q${RST} " "$arg" >&3 elif [[ $expr_started && $arg == [\),] ]]; then printf "${RED}%q${RST} " "$arg" >&3 elif [[ $arg == -?* ]]; then expr_started=yes printf "${BLU}%q${RST} " "$arg" >&3 elif [ "$expr_started" ]; then printf "${BLD}%q${RST} " "$arg" >&3 else printf "${MAG}%q${RST} " "$arg" >&3 fi done else printf '%q ' $BFS "$@" >&3 fi printf '\n' >&3 fi } function invoke_bfs() { bfs_verbose "$@" $BFS "$@" } # Silence stderr unless --verbose is set function quiet() { if [ "$VERBOSE" ]; then "$@" else "$@" 2>/dev/null fi } # Expect a command to fail, but not crash function fail() { "$@" local STATUS="$?" if ((STATUS > 125)); then return "$STATUS" elif ((STATUS)); then return 0 else return 1 fi } # Return value when bfs fails EX_BFS=10 # Return value when a difference is detected EX_DIFF=20 function bfs_diff() ( bfs_verbose "$@" # Close the dup()'d stdout to make sure we have enough fd's for the process # substitution, even with low ulimit -n exec 3>&- local CALLER for CALLER in "${FUNCNAME[@]}"; do if [[ $CALLER == test_* ]]; then break fi done local EXPECTED="$TESTS/$CALLER.out" if [ "$UPDATE" ]; then local ACTUAL="$EXPECTED" else local ACTUAL="$TMP/$CALLER.out" fi $BFS "$@" | bfs_sort >"$ACTUAL" local STATUS="${PIPESTATUS[0]}" if [ ! "$UPDATE" ]; then diff -u "$EXPECTED" "$ACTUAL" || return $EX_DIFF fi if [ "$STATUS" -eq 0 ]; then return 0 else return $EX_BFS fi ) function closefrom() { if [ -d /proc/self/fd ]; then local fds=/proc/self/fd else local fds=/dev/fd fi for fd in "$fds"/*; do if [ ! -e "$fd" ]; then continue fi local fd="${fd##*/}" if [ "$fd" -ge "$1" ]; then eval "exec ${fd}<&-" fi done } function inum() { ls -id "$@" | awk '{ print $1 }' } cd "$TMP" set +e # Test cases function test_basic() { bfs_diff basic } function test_type_d() { bfs_diff basic -type d } function test_type_f() { bfs_diff basic -type f } function test_type_l() { bfs_diff links/skip -type l } function test_H_type_l() { bfs_diff -H links/skip -type l } function test_L_type_l() { bfs_diff -L links/skip -type l } function test_type_multi() { bfs_diff links -type f,d,c } function test_mindepth() { bfs_diff basic -mindepth 1 } function test_maxdepth() { bfs_diff basic -maxdepth 1 } function test_depth() { bfs_diff basic -depth } function test_depth_slash() { bfs_diff basic/ -depth } function test_depth_mindepth_1() { bfs_diff basic -mindepth 1 -depth } function test_depth_mindepth_2() { bfs_diff basic -mindepth 2 -depth } function test_depth_maxdepth_1() { bfs_diff basic -maxdepth 1 -depth } function test_depth_maxdepth_2() { bfs_diff basic -maxdepth 2 -depth } function test_depth_error() { rm -rf scratch/* touchp scratch/foo/bar chmod -r scratch/foo quiet bfs_diff scratch -depth local ret=$? chmod +r scratch/foo rm -rf scratch/* [ $ret -eq $EX_BFS ] } function test_name() { bfs_diff basic -name '*f*' } function test_name_root() { bfs_diff basic/a -name a } function test_name_root_depth() { bfs_diff basic/g -depth -name g } function test_name_trailing_slash() { bfs_diff basic/g/ -name g } function test_name_slash() { bfs_diff / -maxdepth 0 -name / } function test_name_slashes() { bfs_diff /// -maxdepth 0 -name / } function test_path() { bfs_diff basic -path 'basic/*f*' } function test_true() { bfs_diff basic -true } function test_false() { bfs_diff basic -false } function test_executable() { bfs_diff perms -executable } function test_readable() { bfs_diff perms -readable } function test_writable() { bfs_diff perms -writable } function test_empty() { bfs_diff basic -empty } function test_empty_special() { bfs_diff rainbow -empty } function test_gid() { bfs_diff basic -gid "$(id -g)" } function test_gid_plus() { if [ "$(id -g)" -ne 0 ]; then bfs_diff basic -gid +0 fi } function test_gid_plus_plus() { if [ "$(id -g)" -ne 0 ]; then bfs_diff basic -gid ++0 fi } function test_gid_minus() { bfs_diff basic -gid "-$(($(id -g) + 1))" } function test_gid_minus_plus() { bfs_diff basic -gid "-+$(($(id -g) + 1))" } function test_uid() { bfs_diff basic -uid "$(id -u)" } function test_uid_plus() { if [ "$(id -u)" -ne 0 ]; then bfs_diff basic -uid +0 fi } function test_uid_plus_plus() { if [ "$(id -u)" -ne 0 ]; then bfs_diff basic -uid ++0 fi } function test_uid_minus() { bfs_diff basic -uid "-$(($(id -u) + 1))" } function test_uid_minus_plus() { bfs_diff basic -uid "-+$(($(id -u) + 1))" } function test_newer() { bfs_diff times -newer times/a } function test_newer_link() { bfs_diff times -newer times/l } function test_anewer() { bfs_diff times -anewer times/a } function test_asince() { bfs_diff times -asince 1991-12-14T00:01 } function test_links() { bfs_diff links -type f -links 2 } function test_links_plus() { bfs_diff links -type f -links +1 } function test_links_minus() { bfs_diff links -type f -links -2 } function test_links_noarg() { fail quiet invoke_bfs links -links } function test_links_empty() { fail quiet invoke_bfs links -links '' } function test_links_negative() { fail quiet invoke_bfs links -links +-1 } function test_links_invalid() { fail quiet invoke_bfs links -links ASDF } function test_P() { bfs_diff -P links/deeply/nested/dir } function test_P_slash() { bfs_diff -P links/deeply/nested/dir/ } function test_H() { bfs_diff -H links/deeply/nested/dir } function test_H_slash() { bfs_diff -H links/deeply/nested/dir/ } function test_H_broken() { bfs_diff -H links/broken } function test_H_notdir() { bfs_diff -H links/notdir } function test_H_newer() { bfs_diff -H times -newer times/l } function test_H_loops() { bfs_diff -H loops/deeply/nested/loop } function test_L() { bfs_diff -L links } function test_L_broken() { bfs_diff -H links/broken } function test_L_notdir() { bfs_diff -H links/notdir } function test_L_loops() { # POSIX says it's okay to either stop or keep going on seeing a filesystem # loop, as long as a diagnostic is printed local errors="$(invoke_bfs -L loops 2>&1 >/dev/null)" [ -n "$errors" ] } function test_L_loops_continue() { quiet bfs_diff -L loops [ $? -eq $EX_BFS ] } function test_X() { quiet bfs_diff -X weirdnames [ $? -eq $EX_BFS ] } function test_follow() { bfs_diff links -follow } function test_L_depth() { bfs_diff -L links -depth } function test_samefile() { bfs_diff links -samefile links/file } function test_samefile_symlink() { bfs_diff links -samefile links/symlink } function test_H_samefile_symlink() { bfs_diff -H links -samefile links/symlink } function test_L_samefile_symlink() { bfs_diff -L links -samefile links/symlink } function test_samefile_broken() { bfs_diff links -samefile links/broken } function test_H_samefile_broken() { bfs_diff -H links -samefile links/broken } function test_L_samefile_broken() { bfs_diff -L links -samefile links/broken } function test_samefile_notdir() { bfs_diff links -samefile links/notdir } function test_H_samefile_notdir() { bfs_diff -H links -samefile links/notdir } function test_L_samefile_notdir() { bfs_diff -L links -samefile links/notdir } function test_xtype_l() { bfs_diff links -xtype l } function test_xtype_f() { bfs_diff links -xtype f } function test_L_xtype_l() { bfs_diff -L links -xtype l } function test_L_xtype_f() { bfs_diff -L links -xtype f } function test_xtype_multi() { bfs_diff links -xtype f,d,c } function test_xtype_reorder() { # Make sure -xtype is not reordered in front of anything -- if -xtype runs # before -links 100, it will report an ELOOP error bfs_diff loops -links 100 -xtype l invoke_bfs loops -links 100 -xtype l } function test_xtype_depth() { # Make sure -xtype is considered side-effecting for facts_when_impure fail quiet invoke_bfs loops -xtype l -depth 100 } function test_iname() { bfs_diff basic -iname '*F*' } function test_ipath() { bfs_diff basic -ipath 'basic/*F*' } function test_lname() { bfs_diff links -lname '[aq]' } function test_ilname() { bfs_diff links -ilname '[AQ]' } function test_L_lname() { bfs_diff -L links -lname '[aq]' } function test_L_ilname() { bfs_diff -L links -ilname '[AQ]' } function test_user_name() { bfs_diff basic -user "$(id -un)" } function test_user_id() { bfs_diff basic -user "$(id -u)" } function test_user_nouser() { # Regression test: this was wrongly optimized to -false bfs_diff basic -user "$(id -u)" \! -nouser } function test_group_name() { bfs_diff basic -group "$(id -gn)" } function test_group_id() { bfs_diff basic -group "$(id -g)" } function test_group_nogroup() { # Regression test: this was wrongly optimized to -false bfs_diff basic -group "$(id -g)" \! -nogroup } function test_daystart() { bfs_diff basic -daystart -mtime 0 } function test_daystart_twice() { bfs_diff basic -daystart -daystart -mtime 0 } function test_newerma() { bfs_diff times -newerma times/a } function test_newermt() { bfs_diff times -newermt 1991-12-14T00:01 } function test_newermt_epoch_minus_one() { bfs_diff times -newermt 1969-12-31T23:59:59Z } function test_newermt_invalid() { fail quiet invoke_bfs times -newermt not_a_date_time } function test_newerma_nonexistent() { fail quiet invoke_bfs times -newerma basic/nonexistent } function test_newermq() { fail quiet invoke_bfs times -newermq times/a } function test_newerqm() { fail quiet invoke_bfs times -newerqm times/a } function test_size() { bfs_diff basic -type f -size 0 } function test_size_plus() { bfs_diff basic -type f -size +0 } function test_size_bytes() { bfs_diff basic -type f -size +0c } function test_size_big() { bfs_diff basic -size 9223372036854775807 } function test_exec() { bfs_diff basic -exec echo '{}' \; } function test_exec_nothing() { # Regression test: don't segfault on missing command fail quiet invoke_bfs basic -exec \; } function test_exec_plus() { bfs_diff basic -exec "$TESTS/sort-args.sh" '{}' + } function test_exec_plus_status() { # -exec ... {} + should always return true, but if the command fails, bfs # should exit with a non-zero status bfs_diff basic -exec false '{}' + -print (($? == EX_BFS)) } function test_exec_plus_semicolon() { # POSIX says: # Only a that immediately follows an argument containing only the two characters "{}" # shall punctuate the end of the primary expression. Other uses of the shall not be # treated as special. bfs_diff basic -exec echo foo '{}' bar + baz \; } function test_exec_substring() { bfs_diff basic -exec echo '-{}-' ';' } function test_execdir() { bfs_diff basic -execdir echo '{}' ';' } function test_execdir_plus() { if [[ "$BFS" != *"-S dfs"* ]]; then bfs_diff basic -execdir "$TESTS/sort-args.sh" '{}' + fi } function test_execdir_substring() { bfs_diff basic -execdir echo '-{}-' ';' } function test_execdir_plus_semicolon() { bfs_diff basic -execdir echo foo '{}' bar + baz \; } function test_execdir_pwd() { local TMP_REAL="$(cd "$TMP" && pwd)" local OFFSET="$((${#TMP_REAL} + 2))" bfs_diff basic -execdir bash -c "pwd | cut -b$OFFSET-" ';' } function test_execdir_slash() { # Don't prepend ./ for absolute paths in -execdir bfs_diff / -maxdepth 0 -execdir echo '{}' ';' } function test_execdir_slash_pwd() { bfs_diff / -maxdepth 0 -execdir pwd ';' } function test_execdir_slashes() { bfs_diff /// -maxdepth 0 -execdir echo '{}' ';' } function test_execdir_ulimit() { rm -rf scratch/* mkdir -p scratch/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z mkdir -p scratch/a/b/c/d/e/f/g/h/i/j/k/l/m/0/1/2/3/4/5/6/7/8/9/A/B/C closefrom 4 ulimit -n 13 bfs_diff scratch -execdir echo '{}' ';' } function test_weird_names() { cd weirdnames bfs_diff '-' '(-' '!-' ',' ')' './(' './!' \( \! -print -o -print \) } function test_flag_weird_names() { cd weirdnames bfs_diff -L '-' '(-' '!-' ',' ')' './(' './!' \( \! -print -o -print \) } function test_flag_comma() { # , is a filename until a non-flag is seen cd weirdnames bfs_diff -L ',' -print } function test_follow_comma() { # , is an operator after a non-flag is seen cd weirdnames bfs_diff -follow ',' -print } function test_fprint() { invoke_bfs basic -fprint scratch/test_fprint.out sort -o scratch/test_fprint.out scratch/test_fprint.out if [ "$UPDATE" ]; then cp {scratch,"$TESTS"}/test_fprint.out else diff -u {"$TESTS",scratch}/test_fprint.out fi } function test_fprint_duplicate() { touchp scratch/test_fprint_duplicate.out ln scratch/test_fprint_duplicate.out scratch/test_fprint_duplicate.hard ln -s test_fprint_duplicate.out scratch/test_fprint_duplicate.soft invoke_bfs basic -fprint scratch/test_fprint_duplicate.out -fprint scratch/test_fprint_duplicate.hard -fprint scratch/test_fprint_duplicate.soft sort -o scratch/test_fprint_duplicate.out scratch/test_fprint_duplicate.out if [ "$UPDATE" ]; then cp {scratch,"$TESTS"}/test_fprint_duplicate.out else diff -u {"$TESTS",scratch}/test_fprint_duplicate.out fi } function test_fprint_duplicate_stdout() { touchp scratch/test_fprint_duplicate_stdout.out invoke_bfs basic -fprint scratch/test_fprint_duplicate_stdout.out -print >scratch/test_fprint_duplicate_stdout.out sort -o scratch/test_fprint_duplicate_stdout.out{,} if [ "$UPDATE" ]; then cp {scratch,"$TESTS"}/test_fprint_duplicate_stdout.out else diff -u {"$TESTS",scratch}/test_fprint_duplicate_stdout.out fi } function test_fprint_noarg() { fail quiet invoke_bfs basic -fprint } function test_fprint_nonexistent() { fail quiet invoke_bfs basic -fprint scratch/nonexistent/path } function test_fprint_truncate() { printf "basic\nbasic\n" >scratch/test_fprint_truncate.out invoke_bfs basic -maxdepth 0 -fprint scratch/test_fprint_truncate.out sort -o scratch/test_fprint_truncate.out scratch/test_fprint_truncate.out if [ "$UPDATE" ]; then cp {scratch,"$TESTS"}/test_fprint_truncate.out else diff -u {"$TESTS",scratch}/test_fprint_truncate.out fi } function test_double_dash() { cd basic bfs_diff -- . -type f } function test_flag_double_dash() { cd basic bfs_diff -L -- . -type f } function test_ignore_readdir_race() { rm -rf scratch/* $TOUCH scratch/{foo,bar} # -links 1 forces a stat() call, which will fail for the second file invoke_bfs scratch -mindepth 1 -ignore_readdir_race -links 1 -exec "$TESTS/remove-sibling.sh" '{}' ';' } function test_ignore_readdir_race_root() { # Make sure -ignore_readdir_race doesn't suppress ENOENT at the root fail quiet invoke_bfs basic/nonexistent -ignore_readdir_race } function test_ignore_readdir_race_notdir() { # Check -ignore_readdir_race handling when a directory is replaced with a file rm -rf scratch/* touchp scratch/foo/bar invoke_bfs scratch -mindepth 1 -ignore_readdir_race -execdir rm -r '{}' \; -execdir $TOUCH '{}' \; } function test_perm_000() { bfs_diff perms -perm 000 } function test_perm_000_minus() { bfs_diff perms -perm -000 } function test_perm_000_slash() { bfs_diff perms -perm /000 } function test_perm_000_plus() { bfs_diff perms -perm +000 } function test_perm_222() { bfs_diff perms -perm 222 } function test_perm_222_minus() { bfs_diff perms -perm -222 } function test_perm_222_slash() { bfs_diff perms -perm /222 } function test_perm_222_plus() { bfs_diff perms -perm +222 } function test_perm_644() { bfs_diff perms -perm 644 } function test_perm_644_minus() { bfs_diff perms -perm -644 } function test_perm_644_slash() { bfs_diff perms -perm /644 } function test_perm_644_plus() { bfs_diff perms -perm +644 } function test_perm_symbolic() { bfs_diff perms -perm a+r,u=wX,g+wX-w } function test_perm_symbolic_minus() { bfs_diff perms -perm -a+r,u=wX,g+wX-w } function test_perm_symbolic_slash() { bfs_diff perms -perm /a+r,u=wX,g+wX-w } function test_perm_symbolic_trailing_comma() { fail quiet invoke_bfs perms -perm a+r, } function test_perm_symbolic_double_comma() { fail quiet invoke_bfs perms -perm a+r,,u+w } function test_perm_symbolic_missing_action() { fail quiet invoke_bfs perms -perm a } function test_perm_leading_plus_symbolic() { bfs_diff perms -perm +rwx } function test_perm_leading_plus_symbolic_minus() { bfs_diff perms -perm -+rwx } function test_perm_leading_plus_symbolic_slash() { bfs_diff perms -perm /+rwx } function test_permcopy() { bfs_diff perms -perm u+rw,g+u-w,o=g } function test_perm_setid() { bfs_diff rainbow -perm -u+s -o -perm -g+s } function test_perm_sticky() { bfs_diff rainbow -perm -a+t } function test_prune() { bfs_diff basic -name foo -prune } function test_prune_or_print() { bfs_diff basic -name foo -prune -o -print } function test_not_prune() { bfs_diff basic \! \( -name foo -prune \) } function test_ok_nothing() { # Regression test: don't segfault on missing command fail quiet invoke_bfs basic -ok \; } function test_ok_stdin() { # -ok should *not* close stdin # See https://savannah.gnu.org/bugs/?24561 yes | quiet bfs_diff basic -ok bash -c 'printf "%s? " "$1" && head -n1' bash '{}' \; } function test_okdir_stdin() { # -okdir should *not* close stdin yes | quiet bfs_diff basic -okdir bash -c 'printf "%s? " "$1" && head -n1' bash '{}' \; } function test_ok_plus_semicolon() { yes | quiet bfs_diff basic -ok echo '{}' + \; } function test_okdir_plus_semicolon() { yes | quiet bfs_diff basic -okdir echo '{}' + \; } function test_delete() { rm -rf scratch/* touchp scratch/foo/bar/baz # Don't try to delete '.' (cd scratch && invoke_bfs . -delete) bfs_diff scratch } function test_delete_many() { # Test for https://github.com/tavianator/bfs/issues/67 rm -rf scratch/* mkdir scratch/foo $TOUCH scratch/foo/{1..256} invoke_bfs scratch/foo -delete bfs_diff scratch } function test_L_delete() { rm -rf scratch/* mkdir scratch/foo mkdir scratch/bar ln -s ../foo scratch/bar/baz # Don't try to rmdir() a symlink invoke_bfs -L scratch/bar -delete || return 1 bfs_diff scratch } function test_rm() { rm -rf scratch/* touchp scratch/foo/bar/baz (cd scratch && invoke_bfs . -rm) bfs_diff scratch } function test_regex() { bfs_diff basic -regex 'basic/./.' } function test_iregex() { bfs_diff basic -iregex 'basic/[A-Z]/[a-z]' } function test_regex_parens() { cd weirdnames bfs_diff . -regex '\./\((\)' } function test_regex_error() { fail quiet invoke_bfs basic -regex '[' } function test_E() { cd weirdnames bfs_diff -E . -regex '\./(\()' } function test_regextype_posix_basic() { cd weirdnames bfs_diff -regextype posix-basic -regex '\./\((\)' } function test_regextype_posix_extended() { cd weirdnames bfs_diff -regextype posix-extended -regex '\./(\()' } function test_d_path() { bfs_diff -d basic } function test_path_d() { bfs_diff basic -d } function test_f() { cd weirdnames bfs_diff -f '-' -f '(' } function test_s() { invoke_bfs -s weirdnames -maxdepth 1 >"$TMP/test_s.out" if [ "$UPDATE" ]; then cp {"$TMP","$TESTS"}/test_s.out else diff -u {"$TESTS","$TMP"}/test_s.out fi } function test_hidden() { bfs_diff weirdnames -hidden } function test_hidden_root() { cd weirdnames bfs_diff . ./. ... ./... .../.. -hidden } function test_nohidden() { bfs_diff weirdnames -nohidden } function test_nohidden_depth() { bfs_diff weirdnames -depth -nohidden } function test_depth_n() { bfs_diff basic -depth 2 } function test_depth_n_plus() { bfs_diff basic -depth +2 } function test_depth_n_minus() { bfs_diff basic -depth -2 } function test_depth_depth_n() { bfs_diff basic -depth -depth 2 } function test_depth_depth_n_plus() { bfs_diff basic -depth -depth +2 } function test_depth_depth_n_minus() { bfs_diff basic -depth -depth -2 } function test_depth_overflow() { bfs_diff basic -depth -4294967296 } function test_gid_name() { bfs_diff basic -gid "$(id -gn)" } function test_uid_name() { bfs_diff basic -uid "$(id -un)" } function test_mnewer() { bfs_diff times -mnewer times/a } function test_H_mnewer() { bfs_diff -H times -mnewer times/l } function test_msince() { bfs_diff times -msince 1991-12-14T00:01 } function test_mtime_units() { bfs_diff times -mtime +500w400d300h200m100s } function test_size_T() { bfs_diff basic -type f -size 1T } function test_quit() { bfs_diff basic/g -print -name g -quit } function test_quit_child() { bfs_diff basic/g -print -name h -quit } function test_quit_depth() { bfs_diff basic/g -depth -print -name g -quit } function test_quit_depth_child() { bfs_diff basic/g -depth -print -name h -quit } function test_quit_after_print() { bfs_diff basic basic -print -quit } function test_quit_before_print() { bfs_diff basic basic -quit -print } function test_quit_implicit_print() { bfs_diff basic -name basic -o -quit } function test_inum() { bfs_diff basic -inum "$(inum basic/k/foo/bar)" } function test_nogroup() { bfs_diff basic -nogroup } function test_nogroup_ulimit() { closefrom 4 ulimit -n 16 bfs_diff deep -nogroup } function test_nouser() { bfs_diff basic -nouser } function test_nouser_ulimit() { closefrom 4 ulimit -n 16 bfs_diff deep -nouser } function test_ls() { invoke_bfs rainbow -ls >scratch/test_ls.out } function test_L_ls() { invoke_bfs -L rainbow -ls >scratch/test_L_ls.out } function test_fls() { invoke_bfs rainbow -fls scratch/test_fls.out } function test_printf() { bfs_diff basic -printf '%%p(%p) %%d(%d) %%f(%f) %%h(%h) %%H(%H) %%P(%P) %%m(%m) %%M(%M) %%y(%y)\n' } function test_printf_empty() { bfs_diff basic -printf '' } function test_printf_slash() { bfs_diff / -maxdepth 0 -printf '(%h)/(%f)\n' } function test_printf_slashes() { bfs_diff /// -maxdepth 0 -printf '(%h)/(%f)\n' } function test_printf_trailing_slash() { bfs_diff basic/ -printf '(%h)/(%f)\n' } function test_printf_trailing_slashes() { bfs_diff basic/// -printf '(%h)/(%f)\n' } function test_printf_flags() { bfs_diff basic -printf '|%- 10.10p| %+03d %#4m\n' } function test_printf_types() { bfs_diff loops -printf '(%p) (%l) %y %Y\n' } function test_printf_escapes() { bfs_diff basic -maxdepth 0 -printf '\18\118\1118\11118\n\cfoo' } function test_printf_times() { bfs_diff times -type f -printf '%p | %a %AY-%Am-%Ad %AH:%AI:%AS %T@ | %t %TY-%Tm-%Td %TH:%TI:%TS %T@\n' } function test_printf_leak() { # Memory leak regression test bfs_diff basic -maxdepth 0 -printf '%p' } function test_printf_nul() { # NUL byte regression test local EXPECTED="$TESTS/${FUNCNAME[0]}.out" if [ "$UPDATE" ]; then local ACTUAL="$EXPECTED" else local ACTUAL="$TMP/${FUNCNAME[0]}.out" fi invoke_bfs basic -maxdepth 0 -printf '%h\0%f\n' >"$ACTUAL" if [ ! "$UPDATE" ]; then diff -u "$EXPECTED" "$ACTUAL" fi } function test_printf_w() { # Birth times may not be supported, so just check that %w/%W/%B can be parsed bfs_diff times -false -printf '%w %WY %BY\n' } function test_printf_Y_error() { rm -rf scratch/* mkdir scratch/foo chmod -x scratch/foo ln -s foo/bar scratch/bar quiet bfs_diff scratch -printf '(%p) (%l) %y %Y\n' local ret=$? chmod +x scratch/foo rm -rf scratch/* [ $ret -eq $EX_BFS ] } function test_printf_H() { bfs_diff basic links -printf '%%p(%p) %%d(%d) %%f(%f) %%h(%h) %%H(%H) %%P(%P) %%y(%y)\n' } function test_printf_u_g_ulimit() { closefrom 4 ulimit -n 16 [ "$(invoke_bfs deep -printf '%u %g\n' | uniq)" = "$(id -un) $(id -gn)" ] } function test_printf_l_nonlink() { bfs_diff links -printf '| %26p -> %-26l |\n' } function test_printf_incomplete_escape() { fail quiet invoke_bfs basic -printf '\' } function test_printf_invalid_escape() { fail quiet invoke_bfs basic -printf '\!' } function test_printf_incomplete_format() { fail quiet invoke_bfs basic -printf '%' } function test_printf_invalid_format() { fail quiet invoke_bfs basic -printf '%!' } function test_printf_duplicate_flag() { fail quiet invoke_bfs basic -printf '%--p' } function test_printf_must_be_numeric() { fail quiet invoke_bfs basic -printf '%+p' } function test_printf_color() { LS_COLORS= bfs_diff -color -path './rainbow*' -printf '%H %h %f %p %P %l\n' } function test_fprintf() { invoke_bfs basic -fprintf scratch/test_fprintf.out '%%p(%p) %%d(%d) %%f(%f) %%h(%h) %%H(%H) %%P(%P) %%m(%m) %%M(%M) %%y(%y)\n' sort -o scratch/test_fprintf.out scratch/test_fprintf.out if [ "$UPDATE" ]; then cp scratch/test_fprintf.out "$TESTS/test_fprintf.out" else diff -u "$TESTS/test_fprintf.out" scratch/test_fprintf.out fi } function test_fprintf_nofile() { fail quiet invoke_bfs basic -fprintf } function test_fprintf_noformat() { fail quiet invoke_bfs basic -fprintf /dev/null } function test_fstype() { fstype="$(invoke_bfs basic -maxdepth 0 -printf '%F\n')" bfs_diff basic -fstype "$fstype" } function test_path_flag_expr() { bfs_diff links/skip -H -type l } function test_path_expr_flag() { bfs_diff links/skip -type l -H } function test_flag_expr_path() { bfs_diff -H -type l links/skip } function test_expr_flag_path() { bfs_diff -type l -H links/skip } function test_expr_path_flag() { bfs_diff -type l links/skip -H } function test_parens() { bfs_diff basic \( -name '*f*' \) } function test_bang() { bfs_diff basic \! -name foo } function test_not() { bfs_diff basic -not -name foo } function test_implicit_and() { bfs_diff basic -name foo -type d } function test_a() { bfs_diff basic -name foo -a -type d } function test_and() { bfs_diff basic -name foo -and -type d } function test_o() { bfs_diff basic -name foo -o -type d } function test_or() { bfs_diff basic -name foo -or -type d } function test_comma() { bfs_diff basic -name '*f*' -print , -print } function test_precedence() { bfs_diff basic \( -name foo -type d -o -name bar -a -type f \) -print , \! -empty -type f -print } function test_incomplete() { fail quiet invoke_bfs basic \( } function test_missing_paren() { fail quiet invoke_bfs basic \( -print } function test_extra_paren() { fail quiet invoke_bfs basic -print \) } function test_color() { LS_COLORS= bfs_diff rainbow -color } function test_color_L() { LS_COLORS= bfs_diff -L rainbow -color } function test_color_rs_lc_rc_ec() { LS_COLORS="rs=RS:lc=LC:rc=RC:ec=EC:" bfs_diff rainbow -color } function test_color_escapes() { LS_COLORS="lc=\e[:rc=\155\::ec=^[\x5B\x6d:" bfs_diff rainbow -color } function test_color_nul() { local EXPECTED="$TESTS/${FUNCNAME[0]}.out" if [ "$UPDATE" ]; then local ACTUAL="$EXPECTED" else local ACTUAL="$TMP/${FUNCNAME[0]}.out" fi LS_COLORS="ec=\33[m\0:" invoke_bfs rainbow -color -maxdepth 0 >"$ACTUAL" if [ ! "$UPDATE" ]; then diff -u "$EXPECTED" "$ACTUAL" fi } function test_color_ln_target() { LS_COLORS="ln=target:or=01;31:mi=01;33:" bfs_diff rainbow -color } function test_color_L_ln_target() { LS_COLORS="ln=target:or=01;31:mi=01;33:" bfs_diff -L rainbow -color } function test_color_mh() { LS_COLORS="mh=01:" bfs_diff rainbow -color } function test_color_mh0() { LS_COLORS="mh=00:" bfs_diff rainbow -color } function test_color_or() { LS_COLORS="or=01:" bfs_diff rainbow -color } function test_color_mi() { LS_COLORS="mi=01:" bfs_diff rainbow -color } function test_color_or_mi() { LS_COLORS="or=01;31:mi=01;33:" bfs_diff rainbow -color } function test_color_or_mi0() { LS_COLORS="or=01;31:mi=00:" bfs_diff rainbow -color } function test_color_or0_mi() { LS_COLORS="or=00:mi=01;33:" bfs_diff rainbow -color } function test_color_or0_mi0() { LS_COLORS="or=00:mi=00:" bfs_diff rainbow -color } function test_color_su_sg0() { LS_COLORS="su=37;41:sg=00:" bfs_diff rainbow -color } function test_color_su0_sg() { LS_COLORS="su=00:sg=30;43:" bfs_diff rainbow -color } function test_color_su0_sg0() { LS_COLORS="su=00:sg=00:" bfs_diff rainbow -color } function test_color_st_tw_ow0() { LS_COLORS="st=37;44:tw=40;32:ow=00:" bfs_diff rainbow -color } function test_color_st_tw0_ow() { LS_COLORS="st=37;44:tw=00:ow=34;42:" bfs_diff rainbow -color } function test_color_st_tw0_ow0() { LS_COLORS="st=37;44:tw=00:ow=00:" bfs_diff rainbow -color } function test_color_st0_tw_ow() { LS_COLORS="st=00:tw=40;32:ow=34;42:" bfs_diff rainbow -color } function test_color_st0_tw_ow0() { LS_COLORS="st=00:tw=40;32:ow=00:" bfs_diff rainbow -color } function test_color_st0_tw0_ow() { LS_COLORS="st=00:tw=00:ow=34;42:" bfs_diff rainbow -color } function test_color_st0_tw0_ow0() { LS_COLORS="st=00:tw=00:ow=00:" bfs_diff rainbow -color } function test_color_ext() { LS_COLORS="*.txt=01:" bfs_diff rainbow -color } function test_color_ext0() { LS_COLORS="*.txt=00:" bfs_diff rainbow -color } function test_color_ext_override() { LS_COLORS="*.tar.gz=01;31:*.TAR=01;32:*.gz=01;33:" bfs_diff rainbow -color } function test_color_ext_underride() { LS_COLORS="*.gz=01;33:*.TAR=01;32:*.tar.gz=01;31:" bfs_diff rainbow -color } function test_color_missing_colon() { LS_COLORS="*.txt=01" bfs_diff rainbow -color } function test_color_no_stat() { LS_COLORS="mh=0:ex=0:sg=0:su=0:st=0:ow=0:tw=0:*.txt=01:" bfs_diff rainbow -color } function test_color_L_no_stat() { LS_COLORS="mh=0:ex=0:sg=0:su=0:st=0:ow=0:tw=0:*.txt=01:" bfs_diff -L rainbow -color } function test_color_star() { # Regression test: don't segfault on LS_COLORS="*" LS_COLORS="*" bfs_diff rainbow -color } function test_color_ls() { rm -rf scratch/* touchp scratch/foo/bar/baz ln -s foo/bar/baz scratch/link ln -s foo/bar/nowhere scratch/broken ln -s foo/bar/nowhere/nothing scratch/nested ln -s foo/bar/baz/qux scratch/notdir ln -s scratch/foo/bar scratch/relative mkdir scratch/__bfs__ ln -s /__bfs__/nowhere scratch/absolute local EXPECTED="$TESTS/${FUNCNAME[0]}.out" if [ "$UPDATE" ]; then local ACTUAL="$EXPECTED" else local ACTUAL="$TMP/${FUNCNAME[0]}.out" fi LS_COLORS="or=01;31:" invoke_bfs scratch/{,link,broken,nested,notdir,relative,absolute} -color -type l -ls \ | sed 's/.* -> //' \ | sort -o "$ACTUAL" if [ ! "$UPDATE" ]; then diff -u "$EXPECTED" "$ACTUAL" fi } function test_deep() { closefrom 4 ulimit -n 16 bfs_diff deep -type f -exec bash -c 'echo "${1:0:6}/.../${1##*/} (${#1})"' bash '{}' \; } function test_deep_strict() { closefrom 4 # Not even enough fds to keep the root open ulimit -n 7 bfs_diff deep -type f -exec bash -c 'echo "${1:0:6}/.../${1##*/} (${#1})"' bash '{}' \; } function test_exit() { invoke_bfs basic -name foo -exit 42 if [ $? -ne 42 ]; then return 1 fi invoke_bfs basic -name qux -exit 42 if [ $? -ne 0 ]; then return 1 fi bfs_diff basic/g -print -name g -exit } function test_printx() { bfs_diff weirdnames -printx } function test_and_purity() { # Regression test: (-a lhs(pure) rhs(always_false)) <==> rhs is only valid if rhs is pure bfs_diff basic -name nonexistent \( -print , -false \) } function test_or_purity() { # Regression test: (-o lhs(pure) rhs(always_true)) <==> rhs is only valid if rhs is pure bfs_diff basic -name '*' -o -print } function test_double_negation() { bfs_diff basic \! \! -name 'foo' } function test_not_reachability() { bfs_diff basic -print \! -quit -print } function test_comma_reachability() { bfs_diff basic -print -quit , -print } function test_de_morgan_not() { bfs_diff basic \! \( -name 'foo' -o \! -type f \) } function test_de_morgan_and() { bfs_diff basic \( \! -name 'foo' -a \! -type f \) } function test_de_morgan_or() { bfs_diff basic \( \! -name 'foo' -o \! -type f \) } function test_and_false_or_true() { # Test (-a lhs(always_true) -false) <==> (! lhs), # (-o lhs(always_false) -true) <==> (! lhs) bfs_diff basic -prune -false -o -true } function test_comma_redundant_true() { # Test (, lhs(always_true) -true) <==> lhs bfs_diff basic -prune , -true } function test_comma_redundant_false() { # Test (, lhs(always_false) -false) <==> lhs bfs_diff basic -print -not -prune , -false } function test_data_flow_depth() { bfs_diff basic -depth +1 -depth -4 } function test_data_flow_group() { bfs_diff basic \( -group "$(id -g)" -nogroup \) -o \( -group "$(id -g)" -o -nogroup \) } function test_data_flow_user() { bfs_diff basic \( -user "$(id -u)" -nouser \) -o \( -user "$(id -u)" -o -nouser \) } function test_data_flow_hidden() { bfs_diff basic \( -hidden -not -hidden \) -o \( -hidden -o -not -hidden \) } function test_data_flow_sparse() { bfs_diff basic \( -sparse -not -sparse \) -o \( -sparse -o -not -sparse \) } function test_data_flow_type() { bfs_diff basic \! \( -type f -o \! -type f \) } function test_data_flow_and_swap() { bfs_diff basic \! -type f -a -type d } function test_data_flow_or_swap() { bfs_diff basic \! \( -type f -o \! -type d \) } function test_print_error() { if [ -e /dev/full ]; then fail quiet invoke_bfs basic -maxdepth 0 >/dev/full fi } function test_fprint_error() { if [ -e /dev/full ]; then fail quiet invoke_bfs basic -maxdepth 0 -fprint /dev/full fi } function test_fprint_noerror() { # Regression test: /dev/full should not fail until actually written to if [ -e /dev/full ]; then invoke_bfs basic -false -fprint /dev/full fi } function test_fprint_error_stdout() { if [ -e /dev/full ]; then fail quiet invoke_bfs basic -maxdepth 0 -fprint /dev/full >/dev/full fi } function test_fprint_error_stderr() { if [ -e /dev/full ]; then fail invoke_bfs basic -maxdepth 0 -fprint /dev/full 2>/dev/full fi } function test_print0() { invoke_bfs basic/a basic/b -print0 >scratch/test_print0.out if [ "$UPDATE" ]; then cp scratch/test_print0.out "$TESTS/test_print0.out" else cmp -s scratch/test_print0.out "$TESTS/test_print0.out" fi } function test_fprint0() { invoke_bfs basic/a basic/b -fprint0 scratch/test_fprint0.out if [ "$UPDATE" ]; then cp scratch/test_fprint0.out "$TESTS/test_fprint0.out" else cmp -s scratch/test_fprint0.out "$TESTS/test_fprint0.out" fi } function test_closed_stdin() { bfs_diff basic <&- } function test_ok_closed_stdin() { quiet bfs_diff basic -ok echo \; <&- } function test_okdir_closed_stdin() { quiet bfs_diff basic -okdir echo {} \; <&- } function test_closed_stdout() { fail quiet invoke_bfs basic >&- } function test_closed_stderr() { fail invoke_bfs basic >&- 2>&- } function test_unique() { bfs_diff links/{file,symlink,hardlink} -unique } function test_unique_depth() { bfs_diff basic -unique -depth } function test_L_unique() { bfs_diff -L links/{file,symlink,hardlink} -unique } function test_L_unique_loops() { bfs_diff -L loops/deeply/nested -unique } function test_L_unique_depth() { bfs_diff -L loops/deeply/nested -unique -depth } function test_mount() { rm -rf scratch/* mkdir scratch/{foo,mnt} sudo mount -t tmpfs tmpfs scratch/mnt $TOUCH scratch/foo/bar scratch/mnt/baz bfs_diff scratch -mount local ret=$? sudo umount scratch/mnt return $ret } function test_L_mount() { rm -rf scratch/* mkdir scratch/{foo,mnt} sudo mount -t tmpfs tmpfs scratch/mnt ln -s ../mnt scratch/foo/bar $TOUCH scratch/mnt/baz ln -s ../mnt/baz scratch/foo/qux bfs_diff -L scratch -mount local ret=$? sudo umount scratch/mnt return $ret } function test_xdev() { rm -rf scratch/* mkdir scratch/{foo,mnt} sudo mount -t tmpfs tmpfs scratch/mnt $TOUCH scratch/foo/bar scratch/mnt/baz bfs_diff scratch -xdev local ret=$? sudo umount scratch/mnt return $ret } function test_L_xdev() { rm -rf scratch/* mkdir scratch/{foo,mnt} sudo mount -t tmpfs tmpfs scratch/mnt ln -s ../mnt scratch/foo/bar $TOUCH scratch/mnt/baz ln -s ../mnt/baz scratch/foo/qux bfs_diff -L scratch -xdev local ret=$? sudo umount scratch/mnt return $ret } function test_inum_mount() { rm -rf scratch/* mkdir scratch/{foo,mnt} sudo mount -t tmpfs tmpfs scratch/mnt bfs_diff scratch -inum "$(inum scratch/mnt)" local ret=$? sudo umount scratch/mnt return $ret } function test_inum_bind_mount() { rm -rf scratch/* $TOUCH scratch/{foo,bar} sudo mount --bind scratch/{foo,bar} bfs_diff scratch -inum "$(inum scratch/bar)" local ret=$? sudo umount scratch/bar return $ret } function test_type_bind_mount() { rm -rf scratch/* $TOUCH scratch/{file,null} sudo mount --bind /dev/null scratch/null bfs_diff scratch -type c local ret=$? sudo umount scratch/null return $ret } function test_xtype_bind_mount() { rm -rf scratch/* $TOUCH scratch/{file,null} sudo mount --bind /dev/null scratch/null ln -s /dev/null scratch/link bfs_diff -L scratch -type c local ret=$? sudo umount scratch/null return $ret } function set_acl() { case "$UNAME" in Darwin) chmod +a "$(id -un) allow read,write" "$1" ;; FreeBSD) if [ "$(getconf ACL_NFS4 "$1")" -gt 0 ]; then setfacl -m "u:$(id -un):rw::allow" "$1" else setfacl -m "u:$(id -un):rw" "$1" fi ;; *) setfacl -m "u:$(id -un):rw" "$1" ;; esac } function test_acl() { rm -rf scratch/* quiet invoke_bfs scratch -quit -acl || return 0 $TOUCH scratch/{normal,acl} set_acl scratch/acl || return 0 ln -s acl scratch/link bfs_diff scratch -acl } function test_L_acl() { rm -rf scratch/* quiet invoke_bfs scratch -quit -acl || return 0 $TOUCH scratch/{normal,acl} set_acl scratch/acl || return 0 ln -s acl scratch/link bfs_diff -L scratch -acl } function test_capable() { rm -rf scratch/* if fail quiet invoke_bfs scratch -quit -capable; then return 0 fi $TOUCH scratch/{normal,capable} sudo setcap all+ep scratch/capable ln -s capable scratch/link bfs_diff scratch -capable } function test_L_capable() { rm -rf scratch/* if fail quiet invoke_bfs scratch -quit -capable; then return 0 fi $TOUCH scratch/{normal,capable} sudo setcap all+ep scratch/capable ln -s capable scratch/link bfs_diff -L scratch -capable } function make_xattrs() { rm -rf scratch/* $TOUCH scratch/{normal,xattr,xattr_2} ln -s xattr scratch/link ln -s normal scratch/xattr_link case "$UNAME" in Darwin) xattr -w bfs_test true scratch/xattr \ && xattr -w bfs_test_2 true scratch/xattr_2 \ && xattr -s -w bfs_test true scratch/xattr_link ;; FreeBSD) setextattr user bfs_test true scratch/xattr \ && setextattr user bfs_test_2 true scratch/xattr_2 \ && setextattr -h user bfs_test true scratch/xattr_link ;; *) # Linux tmpfs doesn't support the user.* namespace, so we use the security.* # namespace, which is writable by root and readable by others sudo setfattr -n security.bfs_test scratch/xattr \ && sudo setfattr -n security.bfs_test_2 scratch/xattr_2 \ && sudo setfattr -h -n security.bfs_test scratch/xattr_link ;; esac } function test_xattr() { quiet invoke_bfs scratch -quit -xattr || return 0 make_xattrs || return 0 bfs_diff scratch -xattr } function test_L_xattr() { quiet invoke_bfs scratch -quit -xattr || return 0 make_xattrs || return 0 bfs_diff -L scratch -xattr } function test_xattrname() { quiet invoke_bfs scratch -quit -xattr || return 0 make_xattrs || return 0 case "$UNAME" in Darwin|FreeBSD) bfs_diff scratch -xattrname bfs_test ;; *) bfs_diff scratch -xattrname security.bfs_test ;; esac } function test_L_xattrname() { quiet invoke_bfs scratch -quit -xattr || return 0 make_xattrs || return 0 case "$UNAME" in Darwin|FreeBSD) bfs_diff -L scratch -xattrname bfs_test ;; *) bfs_diff -L scratch -xattrname security.bfs_test ;; esac } function test_help() { invoke_bfs -help | grep -E '\{...?\}' && return 1 invoke_bfs -D help | grep -E '\{...?\}' && return 1 invoke_bfs -S help | grep -E '\{...?\}' && return 1 invoke_bfs -regextype help | grep -E '\{...?\}' && return 1 return 0 } function test_version() { invoke_bfs -version >/dev/null } function test_typo() { invoke_bfs -dikkiq 2>&1 | grep follow >/dev/null } function test_D_multi() { quiet bfs_diff -D opt,tree,unknown basic } function test_D_all() { quiet bfs_diff -D all basic } function test_O0() { bfs_diff -O0 basic -not \( -type f -not -type f \) } function test_O1() { bfs_diff -O1 basic -not \( -type f -not -type f \) } function test_O2() { bfs_diff -O2 basic -not \( -type f -not -type f \) } function test_O3() { bfs_diff -O3 basic -not \( -type f -not -type f \) } function test_Ofast() { bfs_diff -Ofast basic -not \( -xtype f -not -xtype f \) } function test_S() { invoke_bfs -S "$1" -s basic >"$TMP/test_S_$1.out" if [ "$UPDATE" ]; then cp {"$TMP","$TESTS"}/"test_S_$1.out" else diff -u {"$TESTS","$TMP"}/"test_S_$1.out" fi } function test_S_bfs() { test_S bfs } function test_S_dfs() { test_S dfs } function test_S_ids() { test_S ids } function test_exclude_name() { bfs_diff basic -exclude -name foo } function test_exclude_depth() { bfs_diff basic -depth -exclude -name foo } function test_exclude_mindepth() { bfs_diff basic -mindepth 3 -exclude -name foo } function test_exclude_print() { fail quiet invoke_bfs basic -exclude -print } function test_exclude_exclude() { fail quiet invoke_bfs basic -exclude -exclude -name foo } function test_flags() { quiet invoke_bfs scratch -quit -flags offline || return 0 rm -rf scratch/* $TOUCH scratch/{foo,bar} chflags offline scratch/bar || return 0 bfs_diff scratch -flags -offline,nohidden } function test_files0_from_file() { cd weirdnames invoke_bfs -mindepth 1 -fprintf ../scratch/files0.in "%P\0" bfs_diff -files0-from ../scratch/files0.in } function test_files0_from_stdin() { cd weirdnames invoke_bfs -mindepth 1 -printf "%P\0" | bfs_diff -files0-from - } function test_files0_from_none() { printf "" | fail quiet invoke_bfs -files0-from - } function test_files0_from_empty() { printf "\0" | fail quiet invoke_bfs -files0-from - } function test_files0_from_nowhere() { fail quiet invoke_bfs -files0-from } function test_files0_from_nothing() { fail quiet invoke_bfs -files0-from basic/nonexistent } function test_files0_from_ok() { printf "basic\0" | fail quiet invoke_bfs -files0-from - -ok echo {} \; } function test_stderr_fails_silently() { if [ -e /dev/full ]; then bfs_diff -D all basic 2>/dev/full fi } function test_stderr_fails_loudly() { if [ -e /dev/full ]; then fail invoke_bfs -D all basic -false -fprint /dev/full 2>/dev/full fi } function test_unexpected_operator() { fail quiet invoke_bfs \! -o -print } BOL= EOL='\n' function update_eol() { # Put the cursor at the last column, then write a space so the next # character will wrap EOL="\\033[${COLUMNS}G " } if [ -t 1 -a ! "$VERBOSE" ]; then BOL='\r\033[K' # Workaround for bash 4: checkwinsize is off by default. We can turn it on, # but we also have to explicitly trigger a foreground job to finish so that # it will update the window size before we use $COLUMNS shopt -s checkwinsize (:) update_eol trap update_eol WINCH fi passed=0 failed=0 for test in "${enabled_tests[@]}"; do printf "${BOL}${YLW}%s${RST}${EOL}" "$test" ("$test") status=$? if [ $status -eq 0 ]; then ((++passed)) else ((++failed)) printf "${BOL}${RED}%s failed!${RST}\n" "$test" fi done if [ $passed -gt 0 ]; then printf "${BOL}${GRN}tests passed: %d${RST}\n" "$passed" fi if [ $failed -gt 0 ]; then printf "${BOL}${RED}tests failed: %s${RST}\n" "$failed" exit 1 fi bfs-2.3.1/tests/000077500000000000000000000000001417254370000134345ustar00rootroot00000000000000bfs-2.3.1/tests/find-color.sh000077500000000000000000000030101417254370000160210ustar00rootroot00000000000000#!/usr/bin/env bash ############################################################################ # bfs # # Copyright (C) 2019 Tavian Barnes # # # # Permission to use, copy, modify, and/or distribute this software for any # # purpose with or without fee is hereby granted. # # # # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES # # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF # # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR # # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES # # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN # # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF # # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. # ############################################################################ set -e L= COLOR= ARGS=() for ARG; do case "$ARG" in -L) L="$ARG" ;; -color) COLOR=y ;; *) ARGS+=("$ARG") ;; esac done LS_COLOR="${BASH_SOURCE%/*}/ls-color.sh" if [ "$COLOR" ]; then find "${ARGS[@]}" -exec "$LS_COLOR" $L {} \; else find "${ARGS[@]}" fi bfs-2.3.1/tests/ls-color.sh000077500000000000000000000031651417254370000155320ustar00rootroot00000000000000#!/usr/bin/env bash ############################################################################ # bfs # # Copyright (C) 2019 Tavian Barnes # # # # Permission to use, copy, modify, and/or distribute this software for any # # purpose with or without fee is hereby granted. # # # # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES # # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF # # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR # # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES # # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN # # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF # # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. # ############################################################################ # Prints the "ground truth" coloring of a path using ls set -e L= if [ "$1" = "-L" ]; then L="$1" shift fi function ls_color() { # Strip the leading reset sequence from the ls output ls -1d --color "$@" | sed $'s/^\033\\[0m//' } DIR="${1%/*}" if [ "$DIR" = "$1" ]; then ls_color "$1" exit fi BASE="${1##*/}" ls_color $L "$DIR/" | tr -d '\n' if [ -e "$1" ]; then (cd "$DIR" && ls_color $L "$BASE") else (cd "$DIR" && ls_color "$BASE") fi bfs-2.3.1/tests/mksock.c000066400000000000000000000063211417254370000150710ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2019 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * There's no standard Unix utility that creates a socket file, so this small * program does the job. */ #include #include #include #include #include #include #include #include /** * Print an error message. */ static void errmsg(const char *cmd, const char *path) { fprintf(stderr, "%s: '%s': %s.\n", cmd, path, strerror(errno)); } /** * struct sockaddr_un::sun_path is very short, so we chdir() into the target * directory before creating sockets in case the full path is too long but the * file name is not. */ static int chdir_parent(const char *path) { char *copy = strdup(path); if (!copy) { return -1; } const char *dir = dirname(copy); int ret = chdir(dir); int error = errno; free(copy); errno = error; return ret; } /** * Initialize a struct sockaddr_un with the right filename. */ static int init_sun(struct sockaddr_un *sock, const char *path) { size_t len = strlen(path); if (len == 0 || path[len - 1] == '/') { errno = ENOENT; return -1; } char *copy = strdup(path); if (!copy) { return -1; } const char *base = basename(copy); len = strlen(base); if (len >= sizeof(sock->sun_path)) { free(copy); errno = ENAMETOOLONG; return -1; } sock->sun_family = AF_UNIX; memcpy(sock->sun_path, base, len + 1); free(copy); return 0; } int main(int argc, char *argv[]) { const char *cmd = argc > 0 ? argv[0] : "mksock"; if (argc != 2) { fprintf(stderr, "Usage: %s NAME\n", cmd); return EXIT_FAILURE; } const char *path = argv[1]; if (chdir_parent(path) != 0) { errmsg(cmd, path); return EXIT_FAILURE; } struct sockaddr_un sock; if (init_sun(&sock, path) != 0) { errmsg(cmd, path); return EXIT_FAILURE; } int fd = socket(AF_UNIX, SOCK_STREAM, 0); if (fd < 0) { errmsg(cmd, path); return EXIT_FAILURE; } int ret = EXIT_SUCCESS; if (bind(fd, (struct sockaddr *)&sock, sizeof(sock)) != 0) { errmsg(cmd, path); ret = EXIT_FAILURE; } if (close(fd) != 0) { errmsg(cmd, path); ret = EXIT_FAILURE; } return ret; } bfs-2.3.1/tests/remove-sibling.sh000077500000000000000000000002111417254370000167070ustar00rootroot00000000000000#!/usr/bin/env bash for file in "${1%/*}"/*; do if [ "$file" != "$1" ]; then rm "$file" exit $? fi done exit 1 bfs-2.3.1/tests/sort-args.sh000077500000000000000000000001321417254370000157100ustar00rootroot00000000000000#!/usr/bin/env bash args=($({ for arg; do echo "$arg"; done } | sort)) echo "${args[@]}" bfs-2.3.1/tests/test_D_all.out000066400000000000000000000003041417254370000162340ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_D_multi.out000066400000000000000000000003041417254370000166160ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_E.out000066400000000000000000000000041417254370000154020ustar00rootroot00000000000000./( bfs-2.3.1/tests/test_H.out000066400000000000000000000000301417254370000154040ustar00rootroot00000000000000links/deeply/nested/dir bfs-2.3.1/tests/test_H_broken.out000066400000000000000000000000151417254370000167470ustar00rootroot00000000000000links/broken bfs-2.3.1/tests/test_H_loops.out000066400000000000000000000002021417254370000166210ustar00rootroot00000000000000loops/deeply/nested/loop loops/deeply/nested/loop/nested loops/deeply/nested/loop/nested/dir loops/deeply/nested/loop/nested/loop bfs-2.3.1/tests/test_H_mnewer.out000066400000000000000000000000361417254370000167670ustar00rootroot00000000000000times times/b times/c times/l bfs-2.3.1/tests/test_H_newer.out000066400000000000000000000000361417254370000166120ustar00rootroot00000000000000times times/b times/c times/l bfs-2.3.1/tests/test_H_notdir.out000066400000000000000000000000151417254370000167660ustar00rootroot00000000000000links/notdir bfs-2.3.1/tests/test_H_samefile_broken.out000066400000000000000000000000151417254370000206140ustar00rootroot00000000000000links/broken bfs-2.3.1/tests/test_H_samefile_notdir.out000066400000000000000000000000151417254370000206330ustar00rootroot00000000000000links/notdir bfs-2.3.1/tests/test_H_samefile_symlink.out000066400000000000000000000000321417254370000210210ustar00rootroot00000000000000links/file links/hardlink bfs-2.3.1/tests/test_H_slash.out000066400000000000000000000000311417254370000165770ustar00rootroot00000000000000links/deeply/nested/dir/ bfs-2.3.1/tests/test_H_type_l.out000066400000000000000000000000421417254370000167630ustar00rootroot00000000000000links/skip/broken links/skip/link bfs-2.3.1/tests/test_L.out000066400000000000000000000004321417254370000154160ustar00rootroot00000000000000links links/broken links/deeply links/file links/hardlink links/notdir links/skip links/symlink links/deeply/nested links/skip/broken links/skip/dir links/skip/file links/skip/link links/deeply/nested/broken links/deeply/nested/dir links/deeply/nested/file links/deeply/nested/link bfs-2.3.1/tests/test_L_acl.out000066400000000000000000000000311417254370000162300ustar00rootroot00000000000000scratch/acl scratch/link bfs-2.3.1/tests/test_L_broken.out000066400000000000000000000000151417254370000167530ustar00rootroot00000000000000links/broken bfs-2.3.1/tests/test_L_capable.out000066400000000000000000000000351417254370000170640ustar00rootroot00000000000000scratch/capable scratch/link bfs-2.3.1/tests/test_L_delete.out000066400000000000000000000000241417254370000167350ustar00rootroot00000000000000scratch scratch/foo bfs-2.3.1/tests/test_L_depth.out000066400000000000000000000004321417254370000166020ustar00rootroot00000000000000links links/broken links/deeply links/file links/hardlink links/notdir links/skip links/symlink links/deeply/nested links/skip/broken links/skip/dir links/skip/file links/skip/link links/deeply/nested/broken links/deeply/nested/dir links/deeply/nested/file links/deeply/nested/link bfs-2.3.1/tests/test_L_ilname.out000066400000000000000000000000001417254370000167320ustar00rootroot00000000000000bfs-2.3.1/tests/test_L_lname.out000066400000000000000000000000001417254370000165610ustar00rootroot00000000000000bfs-2.3.1/tests/test_L_loops_continue.out000066400000000000000000000002341417254370000205360ustar00rootroot00000000000000loops loops/broken loops/deeply loops/file loops/notdir loops/skip loops/symlink loops/deeply/nested loops/skip/dir loops/skip/loop loops/deeply/nested/dir bfs-2.3.1/tests/test_L_mount.out000066400000000000000000000001001417254370000166300ustar00rootroot00000000000000scratch scratch/foo scratch/mnt scratch/foo/bar scratch/foo/qux bfs-2.3.1/tests/test_L_notdir.out000066400000000000000000000000151417254370000167720ustar00rootroot00000000000000links/notdir bfs-2.3.1/tests/test_L_samefile_broken.out000066400000000000000000000000151417254370000206200ustar00rootroot00000000000000links/broken bfs-2.3.1/tests/test_L_samefile_notdir.out000066400000000000000000000000151417254370000206370ustar00rootroot00000000000000links/notdir bfs-2.3.1/tests/test_L_samefile_symlink.out000066400000000000000000000000501417254370000210250ustar00rootroot00000000000000links/file links/hardlink links/symlink bfs-2.3.1/tests/test_L_type_l.out000066400000000000000000000000221417254370000167650ustar00rootroot00000000000000links/skip/broken bfs-2.3.1/tests/test_L_unique.out000066400000000000000000000000131417254370000167770ustar00rootroot00000000000000links/file bfs-2.3.1/tests/test_L_unique_depth.out000066400000000000000000000001051417254370000201650ustar00rootroot00000000000000loops/deeply/nested loops/deeply/nested/dir loops/deeply/nested/loop bfs-2.3.1/tests/test_L_unique_loops.out000066400000000000000000000001051417254370000202150ustar00rootroot00000000000000loops/deeply/nested loops/deeply/nested/dir loops/deeply/nested/loop bfs-2.3.1/tests/test_L_xattr.out000066400000000000000000000000531417254370000166370ustar00rootroot00000000000000scratch/link scratch/xattr scratch/xattr_2 bfs-2.3.1/tests/test_L_xattrname.out000066400000000000000000000000331417254370000174760ustar00rootroot00000000000000scratch/link scratch/xattr bfs-2.3.1/tests/test_L_xdev.out000066400000000000000000000001001417254370000164340ustar00rootroot00000000000000scratch scratch/foo scratch/mnt scratch/foo/bar scratch/foo/qux bfs-2.3.1/tests/test_L_xtype_f.out000066400000000000000000000001031417254370000171470ustar00rootroot00000000000000links/file links/hardlink links/skip/file links/deeply/nested/file bfs-2.3.1/tests/test_L_xtype_l.out000066400000000000000000000002111417254370000171550ustar00rootroot00000000000000links/broken links/notdir links/skip links/symlink links/skip/broken links/skip/link links/deeply/nested/broken links/deeply/nested/link bfs-2.3.1/tests/test_O0.out000066400000000000000000000003041417254370000154770ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_O1.out000066400000000000000000000003041417254370000155000ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_O2.out000066400000000000000000000003041417254370000155010ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_O3.out000066400000000000000000000003041417254370000155020ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_Ofast.out000066400000000000000000000003041417254370000162750ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_P.out000066400000000000000000000000301417254370000154140ustar00rootroot00000000000000links/deeply/nested/dir bfs-2.3.1/tests/test_P_slash.out000066400000000000000000000000311417254370000166070ustar00rootroot00000000000000links/deeply/nested/dir/ bfs-2.3.1/tests/test_S_bfs.out000066400000000000000000000003041417254370000162550ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_S_dfs.out000066400000000000000000000003041417254370000162570ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/c/d basic/e basic/e/f basic/g basic/g/h basic/i basic/j basic/j/foo basic/k basic/k/foo basic/k/foo/bar basic/l basic/l/foo basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_S_ids.out000066400000000000000000000003041417254370000162620ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_X.out000066400000000000000000000003631417254370000154350ustar00rootroot00000000000000weirdnames weirdnames/! weirdnames/!- weirdnames/( weirdnames/(- weirdnames/) weirdnames/, weirdnames/- weirdnames/... weirdnames/!-/e weirdnames/!/d weirdnames/(-/c weirdnames/(/b weirdnames/)/g weirdnames/,/f weirdnames/-/a weirdnames/.../h bfs-2.3.1/tests/test_a.out000066400000000000000000000000301417254370000154350ustar00rootroot00000000000000basic/k/foo basic/l/foo bfs-2.3.1/tests/test_acl.out000066400000000000000000000000141417254370000157560ustar00rootroot00000000000000scratch/acl bfs-2.3.1/tests/test_and.out000066400000000000000000000000301417254370000157570ustar00rootroot00000000000000basic/k/foo basic/l/foo bfs-2.3.1/tests/test_and_false_or_true.out000066400000000000000000000000061417254370000206730ustar00rootroot00000000000000basic bfs-2.3.1/tests/test_and_purity.out000066400000000000000000000000001417254370000173700ustar00rootroot00000000000000bfs-2.3.1/tests/test_anewer.out000066400000000000000000000000361417254370000165040ustar00rootroot00000000000000times times/b times/c times/l bfs-2.3.1/tests/test_asince.out000066400000000000000000000000261417254370000164640ustar00rootroot00000000000000times times/c times/l bfs-2.3.1/tests/test_bang.out000066400000000000000000000002401417254370000161270ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_basic.out000066400000000000000000000003041417254370000163020ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_capable.out000066400000000000000000000000201417254370000166030ustar00rootroot00000000000000scratch/capable bfs-2.3.1/tests/test_closed_stdin.out000066400000000000000000000003041417254370000176730ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_color.out000066400000000000000000000012511417254370000163410ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_L.out000066400000000000000000000012351417254370000166160ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/chardev_link rainbow/socket rainbow/broken rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/link.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_L_ln_target.out000066400000000000000000000012351417254370000206550ustar00rootroot00000000000000rainbow rainbow/broken rainbow/exec.sh rainbow/chardev_link rainbow/socket rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/link.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_L_no_stat.out000066400000000000000000000011771417254370000203520ustar00rootroot00000000000000rainbow rainbow/chardev_link rainbow/ow rainbow/sticky rainbow/sticky_ow rainbow/socket rainbow/broken rainbow/file.txt rainbow/link.txt rainbow/pipe rainbow/exec.sh rainbow/file.dat rainbow/mh1 rainbow/mh2 rainbow/sgid rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz rainbow/sugid rainbow/suid bfs-2.3.1/tests/test_color_escapes.out000066400000000000000000000012511417254370000200440ustar00rootroot00000000000000:rainbow :rainbow/:exec.sh :rainbow/:socket :rainbow/:broken :rainbow/:chardev_link :rainbow/:link.txt :rainbow/:sticky_ow :rainbow/:sgid :rainbow/:pipe :rainbow/:ow :rainbow/:sugid :rainbow/:suid :rainbow/:sticky :rainbow/file.dat :rainbow/file.txt :rainbow/mh1 :rainbow/mh2 :rainbow/star.gz :rainbow/star.tar :rainbow/star.tar.gz bfs-2.3.1/tests/test_color_ext.out000066400000000000000000000012621417254370000172230ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/file.txt rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_ext0.out000066400000000000000000000012621417254370000173030ustar00rootroot00000000000000rainbow rainbow/file.txt rainbow/exec.sh rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_ext_override.out000066400000000000000000000013151417254370000211210ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/star.tar rainbow/star.gz rainbow/star.tar.gz rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 bfs-2.3.1/tests/test_color_ext_underride.out000066400000000000000000000013151417254370000212630ustar00rootroot00000000000000rainbow rainbow/star.tar.gz rainbow/exec.sh rainbow/star.tar rainbow/star.gz rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 bfs-2.3.1/tests/test_color_ln_target.out000066400000000000000000000012351417254370000204020ustar00rootroot00000000000000rainbow rainbow/broken rainbow/exec.sh rainbow/chardev_link rainbow/socket rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/link.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_ls.out000066400000000000000000000010321417254370000170340ustar00rootroot00000000000000scratch/foo/bar scratch/foo/bar /__bfs__/nowhere /__bfs__/nowhere foo/bar/baz/qux foo/bar/baz/qux foo/bar/nowhere foo/bar/nowhere foo/bar/nowhere/nothing foo/bar/nowhere/nothing foo/bar/baz foo/bar/baz bfs-2.3.1/tests/test_color_mh.out000066400000000000000000000012731417254370000170310ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/mh1 rainbow/mh2 rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_mh0.out000066400000000000000000000012511417254370000171050ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_mi.out000066400000000000000000000012511417254370000170260ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_missing_colon.out000066400000000000000000000012621417254370000212660ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/file.txt rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_no_stat.out000066400000000000000000000012021417254370000200640ustar00rootroot00000000000000rainbow rainbow/ow rainbow/sticky rainbow/sticky_ow rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/file.txt rainbow/pipe rainbow/exec.sh rainbow/file.dat rainbow/mh1 rainbow/mh2 rainbow/sgid rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz rainbow/sugid rainbow/suid bfs-2.3.1/tests/test_color_nul.out000066400000000000000000000000241417254370000172140ustar00rootroot00000000000000rainbow bfs-2.3.1/tests/test_color_or.out000066400000000000000000000012461417254370000170450ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/socket rainbow/chardev_link rainbow/link.txt rainbow/broken rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_or0_mi.out000066400000000000000000000012511417254370000176060ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_or0_mi0.out000066400000000000000000000012511417254370000176660ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_or_mi.out000066400000000000000000000012511417254370000175260ustar00rootroot00000000000000rainbow rainbow/broken rainbow/exec.sh rainbow/socket rainbow/chardev_link rainbow/link.txt rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_or_mi0.out000066400000000000000000000012511417254370000176060ustar00rootroot00000000000000rainbow rainbow/broken rainbow/exec.sh rainbow/socket rainbow/chardev_link rainbow/link.txt rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_rs_lc_rc_ec.out000066400000000000000000000012111417254370000206520ustar00rootroot00000000000000LC01;34RCrainbowEC LC01;34RCrainbow/ECLC01;32RCexec.shEC LC01;34RCrainbow/ECLC01;35RCsocketEC LC01;34RCrainbow/ECLC01;36RCbrokenEC LC01;34RCrainbow/ECLC01;36RCchardev_linkEC LC01;34RCrainbow/ECLC01;36RClink.txtEC LC01;34RCrainbow/ECLC30;42RCsticky_owEC LC01;34RCrainbow/ECLC30;43RCsgidEC LC01;34RCrainbow/ECLC33RCpipeEC LC01;34RCrainbow/ECLC34;42RCowEC LC01;34RCrainbow/ECLC37;41RCsugidEC LC01;34RCrainbow/ECLC37;41RCsuidEC LC01;34RCrainbow/ECLC37;44RCstickyEC LC01;34RCrainbow/ECfile.dat LC01;34RCrainbow/ECfile.txt LC01;34RCrainbow/ECmh1 LC01;34RCrainbow/ECmh2 LC01;34RCrainbow/ECstar.gz LC01;34RCrainbow/ECstar.tar LC01;34RCrainbow/ECstar.tar.gz bfs-2.3.1/tests/test_color_st0_tw0_ow.out000066400000000000000000000012511417254370000204260ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/sticky rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sgid rainbow/pipe rainbow/ow rainbow/sticky_ow rainbow/sugid rainbow/suid rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_st0_tw0_ow0.out000066400000000000000000000012511417254370000205060ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/ow rainbow/sticky rainbow/sticky_ow rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sgid rainbow/pipe rainbow/sugid rainbow/suid rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_st0_tw_ow.out000066400000000000000000000012511417254370000203460ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/sticky rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky_ow rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_st0_tw_ow0.out000066400000000000000000000012511417254370000204260ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/ow rainbow/sticky rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sgid rainbow/pipe rainbow/sugid rainbow/suid rainbow/sticky_ow rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_st_tw0_ow.out000066400000000000000000000012511417254370000203460ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sgid rainbow/pipe rainbow/ow rainbow/sticky_ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_st_tw0_ow0.out000066400000000000000000000012511417254370000204260ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/ow rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sgid rainbow/pipe rainbow/sugid rainbow/suid rainbow/sticky rainbow/sticky_ow rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_st_tw_ow0.out000066400000000000000000000012511417254370000203460ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/ow rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sgid rainbow/pipe rainbow/sugid rainbow/suid rainbow/sticky rainbow/sticky_ow rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_star.out000066400000000000000000000012511417254370000173720ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sticky_ow rainbow/sgid rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_color_su0_sg.out000066400000000000000000000012351417254370000176230ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sticky_ow rainbow/sgid rainbow/sugid rainbow/pipe rainbow/ow rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz rainbow/suid bfs-2.3.1/tests/test_color_su0_sg0.out000066400000000000000000000012051417254370000177000ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sticky_ow rainbow/pipe rainbow/ow rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/sgid rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz rainbow/sugid rainbow/suid bfs-2.3.1/tests/test_color_su_sg0.out000066400000000000000000000012351417254370000176230ustar00rootroot00000000000000rainbow rainbow/exec.sh rainbow/socket rainbow/broken rainbow/chardev_link rainbow/link.txt rainbow/sticky_ow rainbow/pipe rainbow/ow rainbow/sugid rainbow/suid rainbow/sticky rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/sgid rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz bfs-2.3.1/tests/test_comma.out000066400000000000000000000003621417254370000163210ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/e/f basic/g/h basic/j/foo basic/j/foo basic/k/foo basic/k/foo basic/l/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_comma_reachability.out000066400000000000000000000000061417254370000210340ustar00rootroot00000000000000basic bfs-2.3.1/tests/test_comma_redundant_false.out000066400000000000000000000000061417254370000215320ustar00rootroot00000000000000basic bfs-2.3.1/tests/test_comma_redundant_true.out000066400000000000000000000000061417254370000214170ustar00rootroot00000000000000basic bfs-2.3.1/tests/test_d_path.out000066400000000000000000000003041417254370000164600ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_data_flow_and_swap.out000066400000000000000000000001601417254370000210350ustar00rootroot00000000000000basic basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/g/h basic/k/foo basic/l/foo basic/l/foo/bar bfs-2.3.1/tests/test_data_flow_depth.out000066400000000000000000000001421417254370000203450ustar00rootroot00000000000000basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar bfs-2.3.1/tests/test_data_flow_group.out000066400000000000000000000003041417254370000203750ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_data_flow_hidden.out000066400000000000000000000003041417254370000204740ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_data_flow_or_swap.out000066400000000000000000000001601417254370000207130ustar00rootroot00000000000000basic basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/g/h basic/k/foo basic/l/foo basic/l/foo/bar bfs-2.3.1/tests/test_data_flow_sparse.out000066400000000000000000000003041417254370000205360ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_data_flow_type.out000066400000000000000000000000001417254370000202130ustar00rootroot00000000000000bfs-2.3.1/tests/test_data_flow_user.out000066400000000000000000000003041417254370000202170ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_daystart.out000066400000000000000000000003041417254370000170540ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_daystart_twice.out000066400000000000000000000003041417254370000202470ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_de_morgan_and.out000066400000000000000000000001301417254370000177730ustar00rootroot00000000000000basic basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/g/h basic/l/foo/bar bfs-2.3.1/tests/test_de_morgan_not.out000066400000000000000000000001101417254370000200270ustar00rootroot00000000000000basic/a basic/b basic/c/d basic/e/f basic/k/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_de_morgan_or.out000066400000000000000000000002701417254370000176560ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_deep.out000066400000000000000000000104401417254370000161400ustar00rootroot00000000000000deep/0/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/1/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/2/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/3/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/4/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/5/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/6/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/7/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/8/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/9/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/A/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/B/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/C/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/D/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/E/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/F/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) bfs-2.3.1/tests/test_deep_strict.out000066400000000000000000000104401417254370000175300ustar00rootroot00000000000000deep/0/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/1/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/2/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/3/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/4/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/5/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/6/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/7/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/8/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/9/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/A/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/B/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/C/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/D/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/E/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) deep/F/.../0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE (4358) bfs-2.3.1/tests/test_delete.out000066400000000000000000000000101417254370000164550ustar00rootroot00000000000000scratch bfs-2.3.1/tests/test_delete_many.out000066400000000000000000000000101417254370000175010ustar00rootroot00000000000000scratch bfs-2.3.1/tests/test_depth.out000066400000000000000000000003041417254370000163250ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_depth_depth_n.out000066400000000000000000000001021417254370000200220ustar00rootroot00000000000000basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo bfs-2.3.1/tests/test_depth_depth_n_minus.out000066400000000000000000000001161417254370000212420ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l bfs-2.3.1/tests/test_depth_depth_n_plus.out000066400000000000000000000000641417254370000210740ustar00rootroot00000000000000basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_depth_error.out000066400000000000000000000000241417254370000175350ustar00rootroot00000000000000scratch scratch/foo bfs-2.3.1/tests/test_depth_maxdepth_1.out000066400000000000000000000001161417254370000204400ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l bfs-2.3.1/tests/test_depth_maxdepth_2.out000066400000000000000000000002201417254370000204350ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo bfs-2.3.1/tests/test_depth_mindepth_1.out000066400000000000000000000002761417254370000204450ustar00rootroot00000000000000basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_depth_mindepth_2.out000066400000000000000000000001661417254370000204440ustar00rootroot00000000000000basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_depth_n.out000066400000000000000000000001021417254370000166360ustar00rootroot00000000000000basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo bfs-2.3.1/tests/test_depth_n_minus.out000066400000000000000000000001161417254370000200560ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l bfs-2.3.1/tests/test_depth_n_plus.out000066400000000000000000000000641417254370000177100ustar00rootroot00000000000000basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_depth_overflow.out000066400000000000000000000003041417254370000202500ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_depth_slash.out000066400000000000000000000003051417254370000175200ustar00rootroot00000000000000basic/ basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_double_dash.out000066400000000000000000000000701417254370000174720ustar00rootroot00000000000000./a ./b ./c/d ./e/f ./j/foo ./k/foo/bar ./l/foo/bar/baz bfs-2.3.1/tests/test_double_negation.out000066400000000000000000000000441417254370000203600ustar00rootroot00000000000000basic/j/foo basic/k/foo basic/l/foo bfs-2.3.1/tests/test_empty.out000066400000000000000000000001221417254370000163550ustar00rootroot00000000000000basic/a basic/b basic/i basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo/bar bfs-2.3.1/tests/test_empty_special.out000066400000000000000000000003231417254370000200600ustar00rootroot00000000000000rainbow/exec.sh rainbow/file.dat rainbow/file.txt rainbow/mh1 rainbow/mh2 rainbow/ow rainbow/sgid rainbow/star.gz rainbow/star.tar rainbow/star.tar.gz rainbow/sticky rainbow/sticky_ow rainbow/sugid rainbow/suid bfs-2.3.1/tests/test_exclude_depth.out000066400000000000000000000001541417254370000200410ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h bfs-2.3.1/tests/test_exclude_mindepth.out000066400000000000000000000000001417254370000205330ustar00rootroot00000000000000bfs-2.3.1/tests/test_exclude_name.out000066400000000000000000000001541417254370000176550ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h bfs-2.3.1/tests/test_exec.out000066400000000000000000000003041417254370000161450ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_exec_plus.out000066400000000000000000000003041417254370000172100ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/c/d basic/e basic/e/f basic/g basic/g/h basic/i basic/j basic/j/foo basic/k basic/k/foo basic/k/foo/bar basic/l basic/l/foo basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_exec_plus_semicolon.out000066400000000000000000000007161417254370000212670ustar00rootroot00000000000000foo basic bar + baz foo basic/a bar + baz foo basic/b bar + baz foo basic/c bar + baz foo basic/e bar + baz foo basic/g bar + baz foo basic/i bar + baz foo basic/j bar + baz foo basic/k bar + baz foo basic/l bar + baz foo basic/c/d bar + baz foo basic/e/f bar + baz foo basic/g/h bar + baz foo basic/j/foo bar + baz foo basic/k/foo bar + baz foo basic/l/foo bar + baz foo basic/k/foo/bar bar + baz foo basic/l/foo/bar bar + baz foo basic/l/foo/bar/baz bar + baz bfs-2.3.1/tests/test_exec_plus_status.out000066400000000000000000000003041417254370000206130ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_exec_substring.out000066400000000000000000000003521417254370000202500ustar00rootroot00000000000000-basic- -basic/a- -basic/b- -basic/c- -basic/e- -basic/g- -basic/i- -basic/j- -basic/k- -basic/l- -basic/c/d- -basic/e/f- -basic/g/h- -basic/j/foo- -basic/k/foo- -basic/l/foo- -basic/k/foo/bar- -basic/l/foo/bar- -basic/l/foo/bar/baz- bfs-2.3.1/tests/test_execdir.out000066400000000000000000000001341417254370000166450ustar00rootroot00000000000000./a ./b ./bar ./bar ./basic ./baz ./c ./d ./e ./f ./foo ./foo ./foo ./g ./h ./i ./j ./k ./l bfs-2.3.1/tests/test_execdir_plus.out000066400000000000000000000001341417254370000177100ustar00rootroot00000000000000./bar ./bar ./basic ./baz ./d ./f ./foo ./foo ./foo ./h ./a ./b ./c ./e ./g ./i ./j ./k ./l bfs-2.3.1/tests/test_execdir_plus_semicolon.out000066400000000000000000000005461417254370000217670ustar00rootroot00000000000000foo ./a bar + baz foo ./b bar + baz foo ./bar bar + baz foo ./bar bar + baz foo ./basic bar + baz foo ./baz bar + baz foo ./c bar + baz foo ./d bar + baz foo ./e bar + baz foo ./f bar + baz foo ./foo bar + baz foo ./foo bar + baz foo ./foo bar + baz foo ./g bar + baz foo ./h bar + baz foo ./i bar + baz foo ./j bar + baz foo ./k bar + baz foo ./l bar + baz bfs-2.3.1/tests/test_execdir_pwd.out000066400000000000000000000002171417254370000175210ustar00rootroot00000000000000 basic basic basic basic basic basic basic basic basic basic/c basic/e basic/g basic/j basic/k basic/l basic/k/foo basic/l/foo basic/l/foo/bar bfs-2.3.1/tests/test_execdir_slash.out000066400000000000000000000000021417254370000200310ustar00rootroot00000000000000/ bfs-2.3.1/tests/test_execdir_slash_pwd.out000066400000000000000000000000021417254370000207030ustar00rootroot00000000000000/ bfs-2.3.1/tests/test_execdir_slashes.out000066400000000000000000000000021417254370000203610ustar00rootroot00000000000000/ bfs-2.3.1/tests/test_execdir_substring.out000066400000000000000000000002021417254370000207410ustar00rootroot00000000000000-./a- -./b- -./bar- -./bar- -./basic- -./baz- -./c- -./d- -./e- -./f- -./foo- -./foo- -./foo- -./g- -./h- -./i- -./j- -./k- -./l- bfs-2.3.1/tests/test_execdir_ulimit.out000066400000000000000000000002461417254370000202340ustar00rootroot00000000000000./0 ./1 ./2 ./3 ./4 ./5 ./6 ./7 ./8 ./9 ./A ./B ./C ./a ./b ./c ./d ./e ./f ./g ./h ./i ./j ./k ./l ./m ./n ./o ./p ./q ./r ./s ./scratch ./t ./u ./v ./w ./x ./y ./z bfs-2.3.1/tests/test_executable.out000066400000000000000000000000421417254370000173410ustar00rootroot00000000000000perms perms/rwx perms/rx perms/wx bfs-2.3.1/tests/test_exit.out000066400000000000000000000000101417254370000161640ustar00rootroot00000000000000basic/g bfs-2.3.1/tests/test_expr_flag_path.out000066400000000000000000000000421417254370000202030ustar00rootroot00000000000000links/skip/broken links/skip/link bfs-2.3.1/tests/test_expr_path_flag.out000066400000000000000000000000421417254370000202030ustar00rootroot00000000000000links/skip/broken links/skip/link bfs-2.3.1/tests/test_f.out000066400000000000000000000000141417254370000154440ustar00rootroot00000000000000( - (/b -/a bfs-2.3.1/tests/test_false.out000066400000000000000000000000001417254370000163040ustar00rootroot00000000000000bfs-2.3.1/tests/test_files0_from_file.out000066400000000000000000000001601417254370000204250ustar00rootroot00000000000000 ! !- ( (- ) , - ... \ /j /j !-/e !-/e !/d !/d (-/c (-/c (/b (/b )/g )/g ,/f ,/f -/a -/a .../h .../h \/i \/i bfs-2.3.1/tests/test_files0_from_stdin.out000066400000000000000000000001601417254370000206270ustar00rootroot00000000000000 ! !- ( (- ) , - ... \ /j /j !-/e !-/e !/d !/d (-/c (-/c (/b (/b )/g )/g ,/f ,/f -/a -/a .../h .../h \/i \/i bfs-2.3.1/tests/test_flag_comma.out000066400000000000000000000000061417254370000173050ustar00rootroot00000000000000, ,/f bfs-2.3.1/tests/test_flag_double_dash.out000066400000000000000000000000701417254370000204630ustar00rootroot00000000000000./a ./b ./c/d ./e/f ./j/foo ./k/foo/bar ./l/foo/bar/baz bfs-2.3.1/tests/test_flag_expr_path.out000066400000000000000000000000421417254370000202030ustar00rootroot00000000000000links/skip/broken links/skip/link bfs-2.3.1/tests/test_flag_weird_names.out000066400000000000000000000001541417254370000205120ustar00rootroot00000000000000!- !- (- (- ) ) , , - - !-/e !-/e (-/c (-/c )/g )/g ,/f ,/f -/a -/a ./! ./! ./( ./( ./!/d ./!/d ./(/b ./(/b bfs-2.3.1/tests/test_flags.out000066400000000000000000000000141417254370000163130ustar00rootroot00000000000000scratch/bar bfs-2.3.1/tests/test_follow.out000066400000000000000000000004321417254370000165250ustar00rootroot00000000000000links links/broken links/deeply links/file links/hardlink links/notdir links/skip links/symlink links/deeply/nested links/skip/broken links/skip/dir links/skip/file links/skip/link links/deeply/nested/broken links/deeply/nested/dir links/deeply/nested/file links/deeply/nested/link bfs-2.3.1/tests/test_follow_comma.out000066400000000000000000000001561417254370000177040ustar00rootroot00000000000000. ./ ./! ./!- ./( ./(- ./) ./, ./- ./... ./\ ./ /j ./!-/e ./!/d ./(-/c ./(/b ./)/g ./,/f ./-/a ./.../h ./\/i bfs-2.3.1/tests/test_fprint.out000066400000000000000000000003041417254370000165230ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/c/d basic/e basic/e/f basic/g basic/g/h basic/i basic/j basic/j/foo basic/k basic/k/foo basic/k/foo/bar basic/l basic/l/foo basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_fprint0.out000066400000000000000000000000201417254370000165760ustar00rootroot00000000000000basic/abasic/bbfs-2.3.1/tests/test_fprint_append.out000066400000000000000000000006101417254370000200520ustar00rootroot00000000000000basic basic basic/a basic/a basic/b basic/b basic/c basic/c basic/c/d basic/c/d basic/e basic/e basic/e/f basic/e/f basic/g basic/g basic/g/h basic/g/h basic/i basic/i basic/j basic/j basic/j/foo basic/j/foo basic/k basic/k basic/k/foo basic/k/foo basic/k/foo/bar basic/k/foo/bar basic/l basic/l basic/l/foo basic/l/foo basic/l/foo/bar basic/l/foo/bar basic/l/foo/bar/baz basic/l/foo/bar/baz bfs-2.3.1/tests/test_fprint_duplicate.out000066400000000000000000000011141417254370000205550ustar00rootroot00000000000000basic basic basic basic/a basic/a basic/a basic/b basic/b basic/b basic/c basic/c basic/c basic/c/d basic/c/d basic/c/d basic/e basic/e basic/e basic/e/f basic/e/f basic/e/f basic/g basic/g basic/g basic/g/h basic/g/h basic/g/h basic/i basic/i basic/i basic/j basic/j basic/j basic/j/foo basic/j/foo basic/j/foo basic/k basic/k basic/k basic/k/foo basic/k/foo basic/k/foo basic/k/foo/bar basic/k/foo/bar basic/k/foo/bar basic/l basic/l basic/l basic/l/foo basic/l/foo basic/l/foo basic/l/foo/bar basic/l/foo/bar basic/l/foo/bar basic/l/foo/bar/baz basic/l/foo/bar/baz basic/l/foo/bar/baz bfs-2.3.1/tests/test_fprint_duplicate_stdout.out000066400000000000000000000006101417254370000221570ustar00rootroot00000000000000basic basic basic/a basic/a basic/b basic/b basic/c basic/c basic/c/d basic/c/d basic/e basic/e basic/e/f basic/e/f basic/g basic/g basic/g/h basic/g/h basic/i basic/i basic/j basic/j basic/j/foo basic/j/foo basic/k basic/k basic/k/foo basic/k/foo basic/k/foo/bar basic/k/foo/bar basic/l basic/l basic/l/foo basic/l/foo basic/l/foo/bar basic/l/foo/bar basic/l/foo/bar/baz basic/l/foo/bar/baz bfs-2.3.1/tests/test_fprint_truncate.out000066400000000000000000000000061417254370000204270ustar00rootroot00000000000000basic bfs-2.3.1/tests/test_fprintf.out000066400000000000000000000031441417254370000166760ustar00rootroot00000000000000%p(basic) %d(0) %f(basic) %h(.) %H(basic) %P() %m(755) %M(drwxr-xr-x) %y(d) %p(basic/a) %d(1) %f(a) %h(basic) %H(basic) %P(a) %m(644) %M(-rw-r--r--) %y(f) %p(basic/b) %d(1) %f(b) %h(basic) %H(basic) %P(b) %m(644) %M(-rw-r--r--) %y(f) %p(basic/c) %d(1) %f(c) %h(basic) %H(basic) %P(c) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/c/d) %d(2) %f(d) %h(basic/c) %H(basic) %P(c/d) %m(644) %M(-rw-r--r--) %y(f) %p(basic/e) %d(1) %f(e) %h(basic) %H(basic) %P(e) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/e/f) %d(2) %f(f) %h(basic/e) %H(basic) %P(e/f) %m(644) %M(-rw-r--r--) %y(f) %p(basic/g) %d(1) %f(g) %h(basic) %H(basic) %P(g) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/g/h) %d(2) %f(h) %h(basic/g) %H(basic) %P(g/h) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/i) %d(1) %f(i) %h(basic) %H(basic) %P(i) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/j) %d(1) %f(j) %h(basic) %H(basic) %P(j) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/j/foo) %d(2) %f(foo) %h(basic/j) %H(basic) %P(j/foo) %m(644) %M(-rw-r--r--) %y(f) %p(basic/k) %d(1) %f(k) %h(basic) %H(basic) %P(k) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/k/foo) %d(2) %f(foo) %h(basic/k) %H(basic) %P(k/foo) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/k/foo/bar) %d(3) %f(bar) %h(basic/k/foo) %H(basic) %P(k/foo/bar) %m(644) %M(-rw-r--r--) %y(f) %p(basic/l) %d(1) %f(l) %h(basic) %H(basic) %P(l) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/l/foo) %d(2) %f(foo) %h(basic/l) %H(basic) %P(l/foo) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/l/foo/bar) %d(3) %f(bar) %h(basic/l/foo) %H(basic) %P(l/foo/bar) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/l/foo/bar/baz) %d(4) %f(baz) %h(basic/l/foo/bar) %H(basic) %P(l/foo/bar/baz) %m(644) %M(-rw-r--r--) %y(f) bfs-2.3.1/tests/test_fstype.out000066400000000000000000000003041417254370000165330ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_gid.out000066400000000000000000000003041417254370000157640ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_gid_minus.out000066400000000000000000000003041417254370000171770ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_gid_minus_plus.out000066400000000000000000000003041417254370000202420ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_gid_name.out000066400000000000000000000003041417254370000167640ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_gid_plus.out000066400000000000000000000003041417254370000170270ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_gid_plus_plus.out000066400000000000000000000003041417254370000200720ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_group_id.out000066400000000000000000000003041417254370000170310ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_group_name.out000066400000000000000000000003041417254370000173550ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_group_nogroup.out000066400000000000000000000003041417254370000201260ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_hidden.out000066400000000000000000000000171417254370000164550ustar00rootroot00000000000000weirdnames/... bfs-2.3.1/tests/test_hidden_root.out000066400000000000000000000000431417254370000175170ustar00rootroot00000000000000... ./... ./... .../../... ././... bfs-2.3.1/tests/test_ilname.out000066400000000000000000000000001417254370000164570ustar00rootroot00000000000000bfs-2.3.1/tests/test_implicit_and.out000066400000000000000000000000301417254370000176510ustar00rootroot00000000000000basic/k/foo basic/l/foo bfs-2.3.1/tests/test_iname.out000066400000000000000000000000561417254370000163160ustar00rootroot00000000000000basic/e/f basic/j/foo basic/k/foo basic/l/foo bfs-2.3.1/tests/test_inum.out000066400000000000000000000000201417254370000161640ustar00rootroot00000000000000basic/k/foo/bar bfs-2.3.1/tests/test_inum_bind_mount.out000066400000000000000000000000301417254370000204030ustar00rootroot00000000000000scratch/bar scratch/foo bfs-2.3.1/tests/test_inum_mount.out000066400000000000000000000000141417254370000174110ustar00rootroot00000000000000scratch/mnt bfs-2.3.1/tests/test_ipath.out000066400000000000000000000001421417254370000163260ustar00rootroot00000000000000basic/e/f basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_iregex.out000066400000000000000000000000361417254370000165060ustar00rootroot00000000000000basic/c/d basic/e/f basic/g/h bfs-2.3.1/tests/test_links.out000066400000000000000000000000321417254370000163370ustar00rootroot00000000000000links/file links/hardlink bfs-2.3.1/tests/test_links_minus.out000066400000000000000000000000311417254370000175510ustar00rootroot00000000000000links/deeply/nested/file bfs-2.3.1/tests/test_links_plus.out000066400000000000000000000000321417254370000174020ustar00rootroot00000000000000links/file links/hardlink bfs-2.3.1/tests/test_lname.out000066400000000000000000000000001417254370000163060ustar00rootroot00000000000000bfs-2.3.1/tests/test_maxdepth.out000066400000000000000000000001161417254370000170340ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l bfs-2.3.1/tests/test_mindepth.out000066400000000000000000000002761417254370000170410ustar00rootroot00000000000000basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_mnewer.out000066400000000000000000000000361417254370000165200ustar00rootroot00000000000000times times/b times/c times/l bfs-2.3.1/tests/test_mount.out000066400000000000000000000000601417254370000163620ustar00rootroot00000000000000scratch scratch/foo scratch/mnt scratch/foo/bar bfs-2.3.1/tests/test_msince.out000066400000000000000000000000261417254370000165000ustar00rootroot00000000000000times times/c times/l bfs-2.3.1/tests/test_mtime_units.out000066400000000000000000000000461417254370000175610ustar00rootroot00000000000000times times/a times/b times/c times/l bfs-2.3.1/tests/test_name.out000066400000000000000000000000561417254370000161450ustar00rootroot00000000000000basic/e/f basic/j/foo basic/k/foo basic/l/foo bfs-2.3.1/tests/test_name_root.out000066400000000000000000000000101417254370000171760ustar00rootroot00000000000000basic/a bfs-2.3.1/tests/test_name_root_depth.out000066400000000000000000000000101417254370000203620ustar00rootroot00000000000000basic/g bfs-2.3.1/tests/test_name_slash.out000066400000000000000000000000021417254370000173260ustar00rootroot00000000000000/ bfs-2.3.1/tests/test_name_slashes.out000066400000000000000000000000041417254370000176600ustar00rootroot00000000000000/// bfs-2.3.1/tests/test_name_trailing_slash.out000066400000000000000000000000111417254370000212170ustar00rootroot00000000000000basic/g/ bfs-2.3.1/tests/test_newer.out000066400000000000000000000000361417254370000163430ustar00rootroot00000000000000times times/b times/c times/l bfs-2.3.1/tests/test_newer_link.out000066400000000000000000000000061417254370000173550ustar00rootroot00000000000000times bfs-2.3.1/tests/test_newerma.out000066400000000000000000000000361417254370000166610ustar00rootroot00000000000000times times/b times/c times/l bfs-2.3.1/tests/test_newermt.out000066400000000000000000000000261417254370000167030ustar00rootroot00000000000000times times/c times/l bfs-2.3.1/tests/test_newermt_epoch_minus_one.out000066400000000000000000000000461417254370000221370ustar00rootroot00000000000000times times/a times/b times/c times/l bfs-2.3.1/tests/test_nogroup.out000066400000000000000000000000001417254370000167030ustar00rootroot00000000000000bfs-2.3.1/tests/test_nogroup_ulimit.out000066400000000000000000000000001417254370000202660ustar00rootroot00000000000000bfs-2.3.1/tests/test_nohidden.out000066400000000000000000000004131417254370000170120ustar00rootroot00000000000000weirdnames weirdnames/ weirdnames/! weirdnames/!- weirdnames/( weirdnames/(- weirdnames/) weirdnames/, weirdnames/- weirdnames/\ weirdnames/ /j weirdnames/!-/e weirdnames/!/d weirdnames/(-/c weirdnames/(/b weirdnames/)/g weirdnames/,/f weirdnames/-/a weirdnames/\/i bfs-2.3.1/tests/test_nohidden_depth.out000066400000000000000000000004131417254370000201760ustar00rootroot00000000000000weirdnames weirdnames/ weirdnames/! weirdnames/!- weirdnames/( weirdnames/(- weirdnames/) weirdnames/, weirdnames/- weirdnames/\ weirdnames/ /j weirdnames/!-/e weirdnames/!/d weirdnames/(-/c weirdnames/(/b weirdnames/)/g weirdnames/,/f weirdnames/-/a weirdnames/\/i bfs-2.3.1/tests/test_not.out000066400000000000000000000002401417254370000160200ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_not_prune.out000066400000000000000000000001541417254370000172350ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h bfs-2.3.1/tests/test_not_reachability.out000066400000000000000000000000061417254370000205400ustar00rootroot00000000000000basic bfs-2.3.1/tests/test_nouser.out000066400000000000000000000000001417254370000165250ustar00rootroot00000000000000bfs-2.3.1/tests/test_nouser_ulimit.out000066400000000000000000000000001417254370000201100ustar00rootroot00000000000000bfs-2.3.1/tests/test_o.out000066400000000000000000000001741417254370000154640ustar00rootroot00000000000000basic basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/l/foo/bar bfs-2.3.1/tests/test_ok_closed_stdin.out000066400000000000000000000000001417254370000203550ustar00rootroot00000000000000bfs-2.3.1/tests/test_ok_plus_semicolon.out000066400000000000000000000003521417254370000207500ustar00rootroot00000000000000basic + basic/a + basic/b + basic/c + basic/e + basic/g + basic/i + basic/j + basic/k + basic/l + basic/c/d + basic/e/f + basic/g/h + basic/j/foo + basic/k/foo + basic/l/foo + basic/k/foo/bar + basic/l/foo/bar + basic/l/foo/bar/baz + bfs-2.3.1/tests/test_ok_stdin.out000066400000000000000000000003751417254370000170430ustar00rootroot00000000000000basic? y basic/a? y basic/b? y basic/c? y basic/e? y basic/g? y basic/i? y basic/j? y basic/k? y basic/l? y basic/c/d? y basic/e/f? y basic/g/h? y basic/j/foo? y basic/k/foo? y basic/l/foo? y basic/k/foo/bar? y basic/l/foo/bar? y basic/l/foo/bar/baz? y bfs-2.3.1/tests/test_okdir_closed_stdin.out000066400000000000000000000000001417254370000210540ustar00rootroot00000000000000bfs-2.3.1/tests/test_okdir_plus_semicolon.out000066400000000000000000000002021417254370000214410ustar00rootroot00000000000000./a + ./b + ./bar + ./bar + ./basic + ./baz + ./c + ./d + ./e + ./f + ./foo + ./foo + ./foo + ./g + ./h + ./i + ./j + ./k + ./l + bfs-2.3.1/tests/test_okdir_stdin.out000066400000000000000000000002251417254370000175340ustar00rootroot00000000000000./a? y ./b? y ./bar? y ./bar? y ./basic? y ./baz? y ./c? y ./d? y ./e? y ./f? y ./foo? y ./foo? y ./foo? y ./g? y ./h? y ./i? y ./j? y ./k? y ./l? y bfs-2.3.1/tests/test_or.out000066400000000000000000000001741417254370000156460ustar00rootroot00000000000000basic basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/l/foo/bar bfs-2.3.1/tests/test_or_purity.out000066400000000000000000000000001417254370000172460ustar00rootroot00000000000000bfs-2.3.1/tests/test_parens.out000066400000000000000000000000561417254370000165150ustar00rootroot00000000000000basic/e/f basic/j/foo basic/k/foo basic/l/foo bfs-2.3.1/tests/test_path.out000066400000000000000000000001421417254370000161550ustar00rootroot00000000000000basic/e/f basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_path_d.out000066400000000000000000000003041417254370000164600ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_path_expr_flag.out000066400000000000000000000000421417254370000202030ustar00rootroot00000000000000links/skip/broken links/skip/link bfs-2.3.1/tests/test_path_flag_expr.out000066400000000000000000000000421417254370000202030ustar00rootroot00000000000000links/skip/broken links/skip/link bfs-2.3.1/tests/test_perm_000.out000066400000000000000000000000101417254370000165350ustar00rootroot00000000000000perms/0 bfs-2.3.1/tests/test_perm_000_minus.out000066400000000000000000000001031417254370000177530ustar00rootroot00000000000000perms perms/0 perms/r perms/rw perms/rwx perms/rx perms/w perms/wx bfs-2.3.1/tests/test_perm_000_plus.out000066400000000000000000000001031417254370000176030ustar00rootroot00000000000000perms perms/0 perms/r perms/rw perms/rwx perms/rx perms/w perms/wx bfs-2.3.1/tests/test_perm_000_slash.out000066400000000000000000000001031417254370000177320ustar00rootroot00000000000000perms perms/0 perms/r perms/rw perms/rwx perms/rx perms/w perms/wx bfs-2.3.1/tests/test_perm_222.out000066400000000000000000000000101417254370000165430ustar00rootroot00000000000000perms/w bfs-2.3.1/tests/test_perm_222_minus.out000066400000000000000000000000101417254370000177560ustar00rootroot00000000000000perms/w bfs-2.3.1/tests/test_perm_222_plus.out000066400000000000000000000000521417254370000176140ustar00rootroot00000000000000perms perms/rw perms/rwx perms/w perms/wx bfs-2.3.1/tests/test_perm_222_slash.out000066400000000000000000000000521417254370000177430ustar00rootroot00000000000000perms perms/rw perms/rwx perms/w perms/wx bfs-2.3.1/tests/test_perm_644.out000066400000000000000000000000111417254370000165540ustar00rootroot00000000000000perms/rw bfs-2.3.1/tests/test_perm_644_minus.out000066400000000000000000000000311417254370000177710ustar00rootroot00000000000000perms perms/rw perms/rwx bfs-2.3.1/tests/test_perm_644_plus.out000066400000000000000000000000731417254370000176270ustar00rootroot00000000000000perms perms/r perms/rw perms/rwx perms/rx perms/w perms/wx bfs-2.3.1/tests/test_perm_644_slash.out000066400000000000000000000000731417254370000177560ustar00rootroot00000000000000perms perms/r perms/rw perms/rwx perms/rx perms/w perms/wx bfs-2.3.1/tests/test_perm_leading_plus_symbolic.out000066400000000000000000000000001417254370000226040ustar00rootroot00000000000000bfs-2.3.1/tests/test_perm_leading_plus_symbolic_minus.out000066400000000000000000000000001417254370000240170ustar00rootroot00000000000000bfs-2.3.1/tests/test_perm_leading_plus_symbolic_slash.out000066400000000000000000000000731417254370000240100ustar00rootroot00000000000000perms perms/r perms/rw perms/rwx perms/rx perms/w perms/wx bfs-2.3.1/tests/test_perm_setid.out000066400000000000000000000000501417254370000173520ustar00rootroot00000000000000rainbow/sgid rainbow/sugid rainbow/suid bfs-2.3.1/tests/test_perm_sticky.out000066400000000000000000000000411417254370000175500ustar00rootroot00000000000000rainbow/sticky rainbow/sticky_ow bfs-2.3.1/tests/test_perm_symbolic.out000066400000000000000000000000001417254370000200560ustar00rootroot00000000000000bfs-2.3.1/tests/test_perm_symbolic_minus.out000066400000000000000000000000311417254370000212750ustar00rootroot00000000000000perms perms/rw perms/rwx bfs-2.3.1/tests/test_perm_symbolic_slash.out000066400000000000000000000000731417254370000212620ustar00rootroot00000000000000perms perms/r perms/rw perms/rwx perms/rx perms/w perms/wx bfs-2.3.1/tests/test_permcopy.out000066400000000000000000000000111417254370000170520ustar00rootroot00000000000000perms/rw bfs-2.3.1/tests/test_precedence.out000066400000000000000000000000741417254370000173220ustar00rootroot00000000000000basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_print0.out000066400000000000000000000000201417254370000164300ustar00rootroot00000000000000basic/abasic/bbfs-2.3.1/tests/test_printf.out000066400000000000000000000031441417254370000165300ustar00rootroot00000000000000%p(basic) %d(0) %f(basic) %h(.) %H(basic) %P() %m(755) %M(drwxr-xr-x) %y(d) %p(basic/a) %d(1) %f(a) %h(basic) %H(basic) %P(a) %m(644) %M(-rw-r--r--) %y(f) %p(basic/b) %d(1) %f(b) %h(basic) %H(basic) %P(b) %m(644) %M(-rw-r--r--) %y(f) %p(basic/c) %d(1) %f(c) %h(basic) %H(basic) %P(c) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/e) %d(1) %f(e) %h(basic) %H(basic) %P(e) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/g) %d(1) %f(g) %h(basic) %H(basic) %P(g) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/i) %d(1) %f(i) %h(basic) %H(basic) %P(i) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/j) %d(1) %f(j) %h(basic) %H(basic) %P(j) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/k) %d(1) %f(k) %h(basic) %H(basic) %P(k) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/l) %d(1) %f(l) %h(basic) %H(basic) %P(l) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/c/d) %d(2) %f(d) %h(basic/c) %H(basic) %P(c/d) %m(644) %M(-rw-r--r--) %y(f) %p(basic/e/f) %d(2) %f(f) %h(basic/e) %H(basic) %P(e/f) %m(644) %M(-rw-r--r--) %y(f) %p(basic/g/h) %d(2) %f(h) %h(basic/g) %H(basic) %P(g/h) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/j/foo) %d(2) %f(foo) %h(basic/j) %H(basic) %P(j/foo) %m(644) %M(-rw-r--r--) %y(f) %p(basic/k/foo) %d(2) %f(foo) %h(basic/k) %H(basic) %P(k/foo) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/l/foo) %d(2) %f(foo) %h(basic/l) %H(basic) %P(l/foo) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/k/foo/bar) %d(3) %f(bar) %h(basic/k/foo) %H(basic) %P(k/foo/bar) %m(644) %M(-rw-r--r--) %y(f) %p(basic/l/foo/bar) %d(3) %f(bar) %h(basic/l/foo) %H(basic) %P(l/foo/bar) %m(755) %M(drwxr-xr-x) %y(d) %p(basic/l/foo/bar/baz) %d(4) %f(baz) %h(basic/l/foo/bar) %H(basic) %P(l/foo/bar/baz) %m(644) %M(-rw-r--r--) %y(f) bfs-2.3.1/tests/test_printf_H.out000066400000000000000000000043351417254370000170020ustar00rootroot00000000000000%p(basic) %d(0) %f(basic) %h(.) %H(basic) %P() %y(d) %p(links) %d(0) %f(links) %h(.) %H(links) %P() %y(d) %p(basic/a) %d(1) %f(a) %h(basic) %H(basic) %P(a) %y(f) %p(basic/b) %d(1) %f(b) %h(basic) %H(basic) %P(b) %y(f) %p(basic/c) %d(1) %f(c) %h(basic) %H(basic) %P(c) %y(d) %p(basic/e) %d(1) %f(e) %h(basic) %H(basic) %P(e) %y(d) %p(basic/g) %d(1) %f(g) %h(basic) %H(basic) %P(g) %y(d) %p(basic/i) %d(1) %f(i) %h(basic) %H(basic) %P(i) %y(d) %p(basic/j) %d(1) %f(j) %h(basic) %H(basic) %P(j) %y(d) %p(basic/k) %d(1) %f(k) %h(basic) %H(basic) %P(k) %y(d) %p(basic/l) %d(1) %f(l) %h(basic) %H(basic) %P(l) %y(d) %p(links/broken) %d(1) %f(broken) %h(links) %H(links) %P(broken) %y(l) %p(links/deeply) %d(1) %f(deeply) %h(links) %H(links) %P(deeply) %y(d) %p(links/file) %d(1) %f(file) %h(links) %H(links) %P(file) %y(f) %p(links/hardlink) %d(1) %f(hardlink) %h(links) %H(links) %P(hardlink) %y(f) %p(links/notdir) %d(1) %f(notdir) %h(links) %H(links) %P(notdir) %y(l) %p(links/skip) %d(1) %f(skip) %h(links) %H(links) %P(skip) %y(l) %p(links/symlink) %d(1) %f(symlink) %h(links) %H(links) %P(symlink) %y(l) %p(basic/c/d) %d(2) %f(d) %h(basic/c) %H(basic) %P(c/d) %y(f) %p(basic/e/f) %d(2) %f(f) %h(basic/e) %H(basic) %P(e/f) %y(f) %p(basic/g/h) %d(2) %f(h) %h(basic/g) %H(basic) %P(g/h) %y(d) %p(basic/j/foo) %d(2) %f(foo) %h(basic/j) %H(basic) %P(j/foo) %y(f) %p(basic/k/foo) %d(2) %f(foo) %h(basic/k) %H(basic) %P(k/foo) %y(d) %p(basic/l/foo) %d(2) %f(foo) %h(basic/l) %H(basic) %P(l/foo) %y(d) %p(links/deeply/nested) %d(2) %f(nested) %h(links/deeply) %H(links) %P(deeply/nested) %y(d) %p(basic/k/foo/bar) %d(3) %f(bar) %h(basic/k/foo) %H(basic) %P(k/foo/bar) %y(f) %p(basic/l/foo/bar) %d(3) %f(bar) %h(basic/l/foo) %H(basic) %P(l/foo/bar) %y(d) %p(links/deeply/nested/broken) %d(3) %f(broken) %h(links/deeply/nested) %H(links) %P(deeply/nested/broken) %y(l) %p(links/deeply/nested/dir) %d(3) %f(dir) %h(links/deeply/nested) %H(links) %P(deeply/nested/dir) %y(d) %p(links/deeply/nested/file) %d(3) %f(file) %h(links/deeply/nested) %H(links) %P(deeply/nested/file) %y(f) %p(links/deeply/nested/link) %d(3) %f(link) %h(links/deeply/nested) %H(links) %P(deeply/nested/link) %y(l) %p(basic/l/foo/bar/baz) %d(4) %f(baz) %h(basic/l/foo/bar) %H(basic) %P(l/foo/bar/baz) %y(f) bfs-2.3.1/tests/test_printf_Y_error.out000066400000000000000000000001021417254370000202200ustar00rootroot00000000000000(scratch) () d d (scratch/foo) () d d (scratch/bar) (foo/bar) l ? bfs-2.3.1/tests/test_printf_color.out000066400000000000000000000046771417254370000177420ustar00rootroot00000000000000. . rainbow ./rainbow rainbow . ./rainbow exec.sh ./rainbow/exec.sh rainbow/exec.sh . ./rainbow socket ./rainbow/socket rainbow/socket . ./rainbow broken ./rainbow/broken rainbow/broken nowhere . ./rainbow link.txt ./rainbow/link.txt rainbow/link.txt file.txt . ./rainbow sticky_ow ./rainbow/sticky_ow rainbow/sticky_ow . ./rainbow sgid ./rainbow/sgid rainbow/sgid . ./rainbow pipe ./rainbow/pipe rainbow/pipe . ./rainbow ow ./rainbow/ow rainbow/ow . ./rainbow sugid ./rainbow/sugid rainbow/sugid . ./rainbow suid ./rainbow/suid rainbow/suid . ./rainbow sticky ./rainbow/sticky rainbow/sticky . ./rainbow file.dat ./rainbow/file.dat rainbow/file.dat . ./rainbow file.txt ./rainbow/file.txt rainbow/file.txt . ./rainbow mh1 ./rainbow/mh1 rainbow/mh1 . ./rainbow mh2 ./rainbow/mh2 rainbow/mh2 . ./rainbow star.gz ./rainbow/star.gz rainbow/star.gz . ./rainbow star.tar ./rainbow/star.tar rainbow/star.tar . ./rainbow star.tar.gz ./rainbow/star.tar.gz rainbow/star.tar.gz . ./rainbow chardev_link ./rainbow/chardev_link rainbow/chardev_link /dev/null bfs-2.3.1/tests/test_printf_empty.out000066400000000000000000000000001417254370000177320ustar00rootroot00000000000000bfs-2.3.1/tests/test_printf_escapes.out000066400000000000000000000000121417254370000202220ustar00rootroot000000000000008 8I8I18 bfs-2.3.1/tests/test_printf_flags.out000066400000000000000000000006421417254370000177040ustar00rootroot00000000000000|basic | +00 0755 |basic/a | +01 0644 |basic/b | +01 0644 |basic/c | +01 0755 |basic/e | +01 0755 |basic/g | +01 0755 |basic/i | +01 0755 |basic/j | +01 0755 |basic/k | +01 0755 |basic/l | +01 0755 |basic/c/d | +02 0644 |basic/e/f | +02 0644 |basic/g/h | +02 0755 |basic/j/fo| +02 0644 |basic/k/fo| +02 0755 |basic/k/fo| +03 0644 |basic/l/fo| +02 0755 |basic/l/fo| +03 0755 |basic/l/fo| +04 0644 bfs-2.3.1/tests/test_printf_l_nonlink.out000066400000000000000000000014311417254370000205700ustar00rootroot00000000000000| links -> | | links/file -> | | links/broken -> nowhere | | links/deeply -> | | links/symlink -> file | | links/hardlink -> | | links/skip -> deeply/nested | | links/notdir -> symlink/file | | links/deeply/nested -> | | links/deeply/nested/dir -> | | links/deeply/nested/file -> | | links/deeply/nested/link -> file | | links/deeply/nested/broken -> nowhere | bfs-2.3.1/tests/test_printf_leak.out000066400000000000000000000000061417254370000175160ustar00rootroot00000000000000basic bfs-2.3.1/tests/test_printf_nul.out000066400000000000000000000000101417254370000173730ustar00rootroot00000000000000.basic bfs-2.3.1/tests/test_printf_slash.out000066400000000000000000000000101417254370000177070ustar00rootroot00000000000000(/)/(/) bfs-2.3.1/tests/test_printf_slashes.out000066400000000000000000000000101417254370000202370ustar00rootroot00000000000000(/)/(/) bfs-2.3.1/tests/test_printf_times.out000066400000000000000000000010641417254370000177300ustar00rootroot00000000000000times/a | Sat Dec 14 00:00:00.0000000000 1991 1991-12-14 00:12:00.0000000000 692668800.0000000000 | Sat Dec 14 00:00:00.0000000000 1991 1991-12-14 00:12:00.0000000000 692668800.0000000000 times/b | Sat Dec 14 00:01:00.0000000000 1991 1991-12-14 00:12:00.0000000000 692668860.0000000000 | Sat Dec 14 00:01:00.0000000000 1991 1991-12-14 00:12:00.0000000000 692668860.0000000000 times/c | Sat Dec 14 00:02:00.0000000000 1991 1991-12-14 00:12:00.0000000000 692668920.0000000000 | Sat Dec 14 00:02:00.0000000000 1991 1991-12-14 00:12:00.0000000000 692668920.0000000000 bfs-2.3.1/tests/test_printf_trailing_slash.out000066400000000000000000000004231417254370000216100ustar00rootroot00000000000000(basic)/(a) (basic)/(b) (basic)/(c) (basic)/(e) (basic)/(g) (basic)/(i) (basic)/(j) (basic)/(k) (basic)/(l) (.)/(basic/) (basic/c)/(d) (basic/e)/(f) (basic/g)/(h) (basic/j)/(foo) (basic/k)/(foo) (basic/l)/(foo) (basic/k/foo)/(bar) (basic/l/foo)/(bar) (basic/l/foo/bar)/(baz) bfs-2.3.1/tests/test_printf_trailing_slashes.out000066400000000000000000000004711417254370000221430ustar00rootroot00000000000000(basic//)/(a) (basic//)/(b) (basic//)/(c) (basic//)/(e) (basic//)/(g) (basic//)/(i) (basic//)/(j) (basic//)/(k) (basic//)/(l) (.)/(basic///) (basic///c)/(d) (basic///e)/(f) (basic///g)/(h) (basic///j)/(foo) (basic///k)/(foo) (basic///l)/(foo) (basic///k/foo)/(bar) (basic///l/foo)/(bar) (basic///l/foo/bar)/(baz) bfs-2.3.1/tests/test_printf_types.out000066400000000000000000000005041417254370000177510ustar00rootroot00000000000000(loops) () d d (loops/broken) (nowhere) l N (loops/deeply) () d d (loops/file) () f f (loops/loop) (loop) l L (loops/symlink) (file) l f (loops/deeply/nested) () d d (loops/notdir) (symlink/file) l N (loops/deeply/nested/dir) () d d (loops/skip) (deeply/nested/loop/nested) l d (loops/deeply/nested/loop) (../../deeply) l d bfs-2.3.1/tests/test_printf_w.out000066400000000000000000000000001417254370000170420ustar00rootroot00000000000000bfs-2.3.1/tests/test_printx.out000066400000000000000000000004571417254370000165560ustar00rootroot00000000000000weirdnames weirdnames/! weirdnames/!- weirdnames/( weirdnames/(- weirdnames/) weirdnames/, weirdnames/- weirdnames/... weirdnames/\ weirdnames/\\ weirdnames/!-/e weirdnames/!/d weirdnames/(-/c weirdnames/(/b weirdnames/)/g weirdnames/,/f weirdnames/-/a weirdnames/.../h weirdnames/\ /j weirdnames/\\/i bfs-2.3.1/tests/test_prune.out000066400000000000000000000000441417254370000163530ustar00rootroot00000000000000basic/j/foo basic/k/foo basic/l/foo bfs-2.3.1/tests/test_prune_or_print.out000066400000000000000000000001541417254370000202710ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h bfs-2.3.1/tests/test_quit.out000066400000000000000000000000101417254370000161750ustar00rootroot00000000000000basic/g bfs-2.3.1/tests/test_quit_after_print.out000066400000000000000000000000061417254370000205770ustar00rootroot00000000000000basic bfs-2.3.1/tests/test_quit_before_print.out000066400000000000000000000000001417254370000207320ustar00rootroot00000000000000bfs-2.3.1/tests/test_quit_child.out000066400000000000000000000000221417254370000173430ustar00rootroot00000000000000basic/g basic/g/h bfs-2.3.1/tests/test_quit_depth.out000066400000000000000000000000221417254370000173640ustar00rootroot00000000000000basic/g basic/g/h bfs-2.3.1/tests/test_quit_depth_child.out000066400000000000000000000000121417254370000205260ustar00rootroot00000000000000basic/g/h bfs-2.3.1/tests/test_quit_implicit_print.out000066400000000000000000000000061417254370000213100ustar00rootroot00000000000000basic bfs-2.3.1/tests/test_readable.out000066400000000000000000000000521417254370000167600ustar00rootroot00000000000000perms perms/r perms/rw perms/rwx perms/rx bfs-2.3.1/tests/test_regex.out000066400000000000000000000000361417254370000163350ustar00rootroot00000000000000basic/c/d basic/e/f basic/g/h bfs-2.3.1/tests/test_regex_parens.out000066400000000000000000000000041417254370000177000ustar00rootroot00000000000000./( bfs-2.3.1/tests/test_regextype_posix_basic.out000066400000000000000000000000041417254370000216150ustar00rootroot00000000000000./( bfs-2.3.1/tests/test_regextype_posix_extended.out000066400000000000000000000000041417254370000223340ustar00rootroot00000000000000./( bfs-2.3.1/tests/test_rm.out000066400000000000000000000000101417254370000156310ustar00rootroot00000000000000scratch bfs-2.3.1/tests/test_s.out000066400000000000000000000002211417254370000154610ustar00rootroot00000000000000weirdnames weirdnames/ weirdnames/! weirdnames/!- weirdnames/( weirdnames/(- weirdnames/) weirdnames/, weirdnames/- weirdnames/... weirdnames/\ bfs-2.3.1/tests/test_samefile.out000066400000000000000000000000321417254370000170040ustar00rootroot00000000000000links/file links/hardlink bfs-2.3.1/tests/test_samefile_broken.out000066400000000000000000000000151417254370000203450ustar00rootroot00000000000000links/broken bfs-2.3.1/tests/test_samefile_notdir.out000066400000000000000000000000151417254370000203640ustar00rootroot00000000000000links/notdir bfs-2.3.1/tests/test_samefile_symlink.out000066400000000000000000000000161417254370000205540ustar00rootroot00000000000000links/symlink bfs-2.3.1/tests/test_size.out000066400000000000000000000001001417254370000161650ustar00rootroot00000000000000basic/a basic/b basic/c/d basic/e/f basic/j/foo basic/k/foo/bar bfs-2.3.1/tests/test_size_T.out000066400000000000000000000000241417254370000164550ustar00rootroot00000000000000basic/l/foo/bar/baz bfs-2.3.1/tests/test_size_big.out000066400000000000000000000000001417254370000170050ustar00rootroot00000000000000bfs-2.3.1/tests/test_size_bytes.out000066400000000000000000000000241417254370000174000ustar00rootroot00000000000000basic/l/foo/bar/baz bfs-2.3.1/tests/test_size_plus.out000066400000000000000000000000241417254370000172350ustar00rootroot00000000000000basic/l/foo/bar/baz bfs-2.3.1/tests/test_stderr_fails_silently.out000066400000000000000000000003041417254370000216250ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_true.out000066400000000000000000000003041417254370000162000ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_type_bind_mount.out000066400000000000000000000000151417254370000204170ustar00rootroot00000000000000scratch/null bfs-2.3.1/tests/test_type_d.out000066400000000000000000000001601417254370000165050ustar00rootroot00000000000000basic basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/g/h basic/k/foo basic/l/foo basic/l/foo/bar bfs-2.3.1/tests/test_type_f.out000066400000000000000000000001241417254370000165070ustar00rootroot00000000000000basic/a basic/b basic/c/d basic/e/f basic/j/foo basic/k/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_type_l.out000066400000000000000000000000131417254370000165120ustar00rootroot00000000000000links/skip bfs-2.3.1/tests/test_type_multi.out000066400000000000000000000001621417254370000174160ustar00rootroot00000000000000links links/deeply links/file links/hardlink links/deeply/nested links/deeply/nested/dir links/deeply/nested/file bfs-2.3.1/tests/test_uid.out000066400000000000000000000003041417254370000160020ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_uid_minus.out000066400000000000000000000003041417254370000172150ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_uid_minus_plus.out000066400000000000000000000003041417254370000202600ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_uid_name.out000066400000000000000000000003041417254370000170020ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_uid_plus.out000066400000000000000000000003041417254370000170450ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_uid_plus_plus.out000066400000000000000000000003041417254370000201100ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_unique.out000066400000000000000000000000311417254370000165240ustar00rootroot00000000000000links/file links/symlink bfs-2.3.1/tests/test_unique_depth.out000066400000000000000000000003041417254370000177130ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_user_id.out000066400000000000000000000003041417254370000166530ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_user_name.out000066400000000000000000000003041417254370000171770ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_user_nouser.out000066400000000000000000000003041417254370000175720ustar00rootroot00000000000000basic basic/a basic/b basic/c basic/e basic/g basic/i basic/j basic/k basic/l basic/c/d basic/e/f basic/g/h basic/j/foo basic/k/foo basic/l/foo basic/k/foo/bar basic/l/foo/bar basic/l/foo/bar/baz bfs-2.3.1/tests/test_weird_names.out000066400000000000000000000001541417254370000175210ustar00rootroot00000000000000!- !- (- (- ) ) , , - - !-/e !-/e (-/c (-/c )/g )/g ,/f ,/f -/a -/a ./! ./! ./( ./( ./!/d ./!/d ./(/b ./(/b bfs-2.3.1/tests/test_writable.out000066400000000000000000000000521417254370000170320ustar00rootroot00000000000000perms perms/rw perms/rwx perms/w perms/wx bfs-2.3.1/tests/test_xattr.out000066400000000000000000000000611417254370000163630ustar00rootroot00000000000000scratch/xattr scratch/xattr_2 scratch/xattr_link bfs-2.3.1/tests/test_xattrname.out000066400000000000000000000000411417254370000172220ustar00rootroot00000000000000scratch/xattr scratch/xattr_link bfs-2.3.1/tests/test_xdev.out000066400000000000000000000000601417254370000161660ustar00rootroot00000000000000scratch scratch/foo scratch/mnt scratch/foo/bar bfs-2.3.1/tests/test_xtype_bind_mount.out000066400000000000000000000000321417254370000206060ustar00rootroot00000000000000scratch/link scratch/null bfs-2.3.1/tests/test_xtype_f.out000066400000000000000000000001321417254370000166760ustar00rootroot00000000000000links/file links/hardlink links/symlink links/deeply/nested/file links/deeply/nested/link bfs-2.3.1/tests/test_xtype_l.out000066400000000000000000000000651417254370000167110ustar00rootroot00000000000000links/broken links/notdir links/deeply/nested/broken bfs-2.3.1/tests/test_xtype_multi.out000066400000000000000000000002441417254370000176070ustar00rootroot00000000000000links links/deeply links/file links/hardlink links/skip links/symlink links/deeply/nested links/deeply/nested/dir links/deeply/nested/file links/deeply/nested/link bfs-2.3.1/tests/test_xtype_reorder.out000066400000000000000000000000001417254370000201050ustar00rootroot00000000000000bfs-2.3.1/tests/trie.c000066400000000000000000000067401417254370000145520ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2020-2022 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #undef NDEBUG #include "../trie.h" #include #include #include const char *keys[] = { "foo", "bar", "baz", "qux", "quux", "quuux", "quuuux", "pre", "pref", "prefi", "prefix", "AAAA", "AADD", "ABCD", "DDAA", "DDDD", "<<<", "<<<>>>", "<<<<<<", "<<<<<<>>>>>>", ">>>>>>", ">>><<<", ">>>", }; const size_t nkeys = sizeof(keys) / sizeof(keys[0]); int main(void) { struct trie trie; trie_init(&trie); for (size_t i = 0; i < nkeys; ++i) { assert(!trie_find_str(&trie, keys[i])); const char *prefix = NULL; for (size_t j = 0; j < i; ++j) { if (strncmp(keys[i], keys[j], strlen(keys[j])) == 0) { if (!prefix || strcmp(keys[j], prefix) > 0) { prefix = keys[j]; } } } struct trie_leaf *leaf = trie_find_prefix(&trie, keys[i]); if (prefix) { assert(leaf); assert(strcmp(prefix, leaf->key) == 0); } else { assert(!leaf); } leaf = trie_insert_str(&trie, keys[i]); assert(leaf); assert(strcmp(keys[i], leaf->key) == 0); assert(leaf->length == strlen(keys[i]) + 1); } for (size_t i = 0; i < nkeys; ++i) { struct trie_leaf *leaf = trie_find_str(&trie, keys[i]); assert(leaf); assert(strcmp(keys[i], leaf->key) == 0); assert(leaf->length == strlen(keys[i]) + 1); trie_remove(&trie, leaf); leaf = trie_find_str(&trie, keys[i]); assert(!leaf); const char *postfix = NULL; for (size_t j = i + 1; j < nkeys; ++j) { if (strncmp(keys[i], keys[j], strlen(keys[i])) == 0) { if (!postfix || strcmp(keys[j], postfix) < 0) { postfix = keys[j]; } } } leaf = trie_find_postfix(&trie, keys[i]); if (postfix) { assert(leaf); assert(strcmp(postfix, leaf->key) == 0); } else { assert(!leaf); } } // This tests the "jump" node handling on 32-bit platforms size_t longsize = 1 << 20; char *longstr = malloc(longsize); assert(longstr); memset(longstr, 0xAC, longsize); assert(!trie_find_mem(&trie, longstr, longsize)); assert(trie_insert_mem(&trie, longstr, longsize)); memset(longstr + longsize/2, 0xAB, longsize/2); assert(!trie_find_mem(&trie, longstr, longsize)); assert(trie_insert_mem(&trie, longstr, longsize)); memset(longstr, 0xAA, longsize/2); assert(!trie_find_mem(&trie, longstr, longsize)); assert(trie_insert_mem(&trie, longstr, longsize)); free(longstr); trie_destroy(&trie); return EXIT_SUCCESS; } bfs-2.3.1/tests/xtimegm.c000066400000000000000000000062221417254370000152540ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2020 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "../time.h" #include #include #include #include #include static bool tm_equal(const struct tm *tma, const struct tm *tmb) { if (tma->tm_year != tmb->tm_year) { return false; } if (tma->tm_mon != tmb->tm_mon) { return false; } if (tma->tm_mday != tmb->tm_mday) { return false; } if (tma->tm_hour != tmb->tm_hour) { return false; } if (tma->tm_min != tmb->tm_min) { return false; } if (tma->tm_sec != tmb->tm_sec) { return false; } if (tma->tm_wday != tmb->tm_wday) { return false; } if (tma->tm_yday != tmb->tm_yday) { return false; } if (tma->tm_isdst != tmb->tm_isdst) { return false; } return true; } static void tm_print(FILE *file, const struct tm *tm) { fprintf(file, "Y%d M%d D%d h%d m%d s%d wd%d yd%d%s\n", tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_wday, tm->tm_yday, tm->tm_isdst ? (tm->tm_isdst < 0 ? " (DST?)" : " (DST)") : ""); } int main(void) { if (setenv("TZ", "UTC0", true) != 0) { perror("setenv()"); return EXIT_FAILURE; } struct tm tm = { .tm_isdst = -1, }; for (tm.tm_year = 10; tm.tm_year <= 200; tm.tm_year += 10) for (tm.tm_mon = -3; tm.tm_mon <= 15; tm.tm_mon += 3) for (tm.tm_mday = -31; tm.tm_mday <= 61; tm.tm_mday += 4) for (tm.tm_hour = -1; tm.tm_hour <= 24; tm.tm_hour += 5) for (tm.tm_min = -1; tm.tm_min <= 60; tm.tm_min += 31) for (tm.tm_sec = -60; tm.tm_sec <= 120; tm.tm_sec += 5) { struct tm tma = tm, tmb = tm; time_t ta, tb; ta = mktime(&tma); if (xtimegm(&tmb, &tb) != 0) { tb = -1; } bool fail = false; if (ta != tb) { printf("Mismatch: %jd != %jd\n", (intmax_t)ta, (intmax_t)tb); fail = true; } if (ta != -1 && !tm_equal(&tma, &tmb)) { printf("mktime(): "); tm_print(stdout, &tma); printf("xtimegm(): "); tm_print(stdout, &tmb); fail = true; } if (fail) { printf("Input: "); tm_print(stdout, &tm); return EXIT_FAILURE; } } return EXIT_SUCCESS; } bfs-2.3.1/time.c000066400000000000000000000154271417254370000134050ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2020 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "time.h" #include #include #include #include #include /** Whether tzset() has been called. */ static bool tz_is_set = false; int xlocaltime(const time_t *timep, struct tm *result) { // Should be called before localtime_r() according to POSIX.1-2004 if (!tz_is_set) { tzset(); tz_is_set = true; } if (localtime_r(timep, result)) { return 0; } else { return -1; } } int xgmtime(const time_t *timep, struct tm *result) { // Should be called before gmtime_r() according to POSIX.1-2004 if (!tz_is_set) { tzset(); tz_is_set = true; } if (gmtime_r(timep, result)) { return 0; } else { return -1; } } int xmktime(struct tm *tm, time_t *timep) { *timep = mktime(tm); if (*timep == -1) { int error = errno; struct tm tmp; if (xlocaltime(timep, &tmp) != 0) { return -1; } if (tm->tm_year != tmp.tm_year || tm->tm_yday != tmp.tm_yday || tm->tm_hour != tmp.tm_hour || tm->tm_min != tmp.tm_min || tm->tm_sec != tmp.tm_sec) { errno = error; return -1; } } return 0; } static int safe_add(int *value, int delta) { if (*value >= 0) { if (delta > INT_MAX - *value) { return -1; } } else { if (delta < INT_MIN - *value) { return -1; } } *value += delta; return 0; } static int floor_div(int n, int d) { int a = n < 0; return (n + a)/d - a; } static int wrap(int *value, int max, int *next) { int carry = floor_div(*value, max); *value -= carry * max; return safe_add(next, carry); } static int month_length(int year, int month) { static const int month_lengths[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; int ret = month_lengths[month]; if (month == 1 && year%4 == 0 && (year%100 != 0 || (year + 300)%400 == 0)) { ++ret; } return ret; } int xtimegm(struct tm *tm, time_t *timep) { tm->tm_isdst = 0; if (wrap(&tm->tm_sec, 60, &tm->tm_min) != 0) { goto overflow; } if (wrap(&tm->tm_min, 60, &tm->tm_hour) != 0) { goto overflow; } if (wrap(&tm->tm_hour, 24, &tm->tm_mday) != 0) { goto overflow; } // In order to wrap the days of the month, we first need to know what // month it is if (wrap(&tm->tm_mon, 12, &tm->tm_year) != 0) { goto overflow; } if (tm->tm_mday < 1) { do { --tm->tm_mon; if (wrap(&tm->tm_mon, 12, &tm->tm_year) != 0) { goto overflow; } tm->tm_mday += month_length(tm->tm_year, tm->tm_mon); } while (tm->tm_mday < 1); } else { while (true) { int days = month_length(tm->tm_year, tm->tm_mon); if (tm->tm_mday <= days) { break; } tm->tm_mday -= days; ++tm->tm_mon; if (wrap(&tm->tm_mon, 12, &tm->tm_year) != 0) { goto overflow; } } } tm->tm_yday = 0; for (int i = 0; i < tm->tm_mon; ++i) { tm->tm_yday += month_length(tm->tm_year, i); } tm->tm_yday += tm->tm_mday - 1; int leap_days; // Compute floor((year - 69)/4) - floor((year - 1)/100) + floor((year + 299)/400) without overflows if (tm->tm_year >= 0) { leap_days = floor_div(tm->tm_year - 69, 4) - floor_div(tm->tm_year - 1, 100) + floor_div(tm->tm_year - 101, 400) + 1; } else { leap_days = floor_div(tm->tm_year + 3, 4) - floor_div(tm->tm_year + 99, 100) + floor_div(tm->tm_year + 299, 400) - 17; } long long epoch_days = 365LL*(tm->tm_year - 70) + leap_days + tm->tm_yday; tm->tm_wday = (epoch_days + 4)%7; if (tm->tm_wday < 0) { tm->tm_wday += 7; } long long epoch_time = tm->tm_sec + 60*(tm->tm_min + 60*(tm->tm_hour + 24*epoch_days)); *timep = (time_t)epoch_time; if ((long long)*timep != epoch_time) { goto overflow; } return 0; overflow: errno = EOVERFLOW; return -1; } /** Parse some digits from a timestamp. */ static int parse_timestamp_part(const char **str, size_t n, int *result) { char buf[n + 1]; for (size_t i = 0; i < n; ++i, ++*str) { char c = **str; if (c < '0' || c > '9') { return -1; } buf[i] = c; } buf[n] = '\0'; *result = atoi(buf); return 0; } int parse_timestamp(const char *str, struct timespec *result) { struct tm tm = { .tm_isdst = -1, }; int tz_hour = 0; int tz_min = 0; bool tz_negative = false; bool local = true; // YYYY if (parse_timestamp_part(&str, 4, &tm.tm_year) != 0) { goto invalid; } tm.tm_year -= 1900; // MM if (*str == '-') { ++str; } if (parse_timestamp_part(&str, 2, &tm.tm_mon) != 0) { goto invalid; } tm.tm_mon -= 1; // DD if (*str == '-') { ++str; } if (parse_timestamp_part(&str, 2, &tm.tm_mday) != 0) { goto invalid; } if (!*str) { goto end; } else if (*str == 'T') { ++str; } // hh if (parse_timestamp_part(&str, 2, &tm.tm_hour) != 0) { goto invalid; } // mm if (!*str) { goto end; } else if (*str == ':') { ++str; } if (parse_timestamp_part(&str, 2, &tm.tm_min) != 0) { goto invalid; } // ss if (!*str) { goto end; } else if (*str == ':') { ++str; } if (parse_timestamp_part(&str, 2, &tm.tm_sec) != 0) { goto invalid; } if (!*str) { goto end; } else if (*str == 'Z') { local = false; ++str; } else if (*str == '+' || *str == '-') { local = false; tz_negative = *str == '-'; ++str; // hh if (parse_timestamp_part(&str, 2, &tz_hour) != 0) { goto invalid; } // mm if (!*str) { goto end; } else if (*str == ':') { ++str; } if (parse_timestamp_part(&str, 2, &tz_min) != 0) { goto invalid; } } else { goto invalid; } if (*str) { goto invalid; } end: if (local) { if (xmktime(&tm, &result->tv_sec) != 0) { goto error; } } else { if (xtimegm(&tm, &result->tv_sec) != 0) { goto error; } int offset = 60*tz_hour + tz_min; if (tz_negative) { result->tv_sec -= offset; } else { result->tv_sec += offset; } } result->tv_nsec = 0; return 0; invalid: errno = EINVAL; error: return -1; } bfs-2.3.1/time.h000066400000000000000000000051471417254370000134100ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2020 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * Date/time handling. */ #ifndef BFS_TIME_H #define BFS_TIME_H #include /** * localtime_r() wrapper that calls tzset() first. * * @param[in] timep * The time_t to convert. * @param[out] result * Buffer to hold the result. * @return * 0 on success, -1 on failure. */ int xlocaltime(const time_t *timep, struct tm *result); /** * gmtime_r() wrapper that calls tzset() first. * * @param[in] timep * The time_t to convert. * @param[out] result * Buffer to hold the result. * @return * 0 on success, -1 on failure. */ int xgmtime(const time_t *timep, struct tm *result); /** * mktime() wrapper that reports errors more reliably. * * @param[in,out] tm * The struct tm to convert. * @param[out] timep * A pointer to the result. * @return * 0 on success, -1 on failure. */ int xmktime(struct tm *tm, time_t *timep); /** * A portable timegm(), the inverse of gmtime(). * * @param[in,out] tm * The struct tm to convert. * @param[out] timep * A pointer to the result. * @return * 0 on success, -1 on failure. */ int xtimegm(struct tm *tm, time_t *timep); /** * Parse an ISO 8601-style timestamp. * * @param[in] str * The string to parse. * @param[out] result * A pointer to the result. * @return * 0 on success, -1 on failure. */ int parse_timestamp(const char *str, struct timespec *result); #endif // BFS_TIME_H bfs-2.3.1/trie.c000066400000000000000000000447301417254370000134110ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2019 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * This is an implementation of a "qp trie," as documented at * https://dotat.at/prog/qp/README.html * * An uncompressed trie over the dataset {AAAA, AADD, ABCD, DDAA, DDDD} would * look like * * A A A A * *--->*--->*--->*--->$ * | | | D D * | | +--->*--->$ * | | B C D * | +--->*--->*--->$ * | D D A A * +--->*--->*--->*--->$ * | D D * +--->*--->$ * * A compressed (PATRICIA) trie collapses internal nodes that have only a single * child, like this: * * A A AA * *--->*--->*---->$ * | | | DD * | | +---->$ * | | BCD * | +----->$ * | DD AA * +---->*---->$ * | DD * +---->$ * * The nodes can be compressed further by dropping the actual compressed * sequences from the nodes, storing it only in the leaves. This is the * technique applied in QP tries, and the crit-bit trees that inspired them * (https://cr.yp.to/critbit.html). Only the index to test, and the values to * branch on, need to be stored in each node. * * A A A * 0--->1--->2--->AAAA * | | | D * | | +--->AADD * | | B * | +--->ABCD * | D A * +--->2--->DDAA * | D * +--->DDDD * * Nodes are represented very compactly. Rather than a dense array of children, * a sparse array of only the non-NULL children directly follows the node in * memory. A bitmap is used to track which children exist; the index of a child * i is found by counting the number of bits below bit i that are set. A tag * bit is used to tell pointers to internal nodes apart from pointers to leaves. * * This implementation tests a whole nibble (half byte/hex digit) at every * branch, so the bitmap takes up 16 bits. The remainder of a machine word is * used to hold the offset, which severely constrains its range on 32-bit * platforms. As a workaround, we store relative instead of absolute offsets, * and insert intermediate singleton "jump" nodes when necessary. */ #include "trie.h" #include "util.h" #include #include #include #include #include #include #if CHAR_BIT != 8 # error "This trie implementation assumes 8-bit bytes." #endif /** Number of bits for the sparse array bitmap, aka the range of a nibble. */ #define BITMAP_BITS 16 /** The number of remaining bits in a word, to hold the offset. */ #define OFFSET_BITS (sizeof(size_t)*CHAR_BIT - BITMAP_BITS) /** The highest representable offset (only 64k on a 32-bit architecture). */ #define OFFSET_MAX (((size_t)1 << OFFSET_BITS) - 1) /** * An internal node of the trie. */ struct trie_node { /** * A bitmap that hold which indices exist in the sparse children array. * Bit i will be set if a child exists at logical index i, and its index * into the array will be popcount(bitmap & ((1 << i) - 1)). */ size_t bitmap : BITMAP_BITS; /** * The offset into the key in nibbles. This is relative to the parent * node, to support offsets larger than OFFSET_MAX. */ size_t offset : OFFSET_BITS; /** * Flexible array of children. Each pointer uses the lowest bit as a * tag to distinguish internal nodes from leaves. This is safe as long * as all dynamic allocations are aligned to more than a single byte. */ uintptr_t children[]; }; /** Check if an encoded pointer is to a leaf. */ static bool trie_is_leaf(uintptr_t ptr) { return ptr & 1; } /** Decode a pointer to a leaf. */ static struct trie_leaf *trie_decode_leaf(uintptr_t ptr) { assert(trie_is_leaf(ptr)); return (struct trie_leaf *)(ptr ^ 1); } /** Encode a pointer to a leaf. */ static uintptr_t trie_encode_leaf(const struct trie_leaf *leaf) { uintptr_t ptr = (uintptr_t)leaf ^ 1; assert(trie_is_leaf(ptr)); return ptr; } /** Decode a pointer to an internal node. */ static struct trie_node *trie_decode_node(uintptr_t ptr) { assert(!trie_is_leaf(ptr)); return (struct trie_node *)ptr; } /** Encode a pointer to an internal node. */ static uintptr_t trie_encode_node(const struct trie_node *node) { uintptr_t ptr = (uintptr_t)node; assert(!trie_is_leaf(ptr)); return ptr; } void trie_init(struct trie *trie) { trie->root = 0; } /** Compute the popcount (Hamming weight) of a bitmap. */ static unsigned int trie_popcount(unsigned int n) { #if __POPCNT__ // Use the x86 instruction if we have it. Otherwise, GCC generates a // library call, so use the below implementation instead. return __builtin_popcount(n); #else // See https://en.wikipedia.org/wiki/Hamming_weight#Efficient_implementation n -= (n >> 1) & 0x5555; n = (n & 0x3333) + ((n >> 2) & 0x3333); n = (n + (n >> 4)) & 0x0F0F; n = (n + (n >> 8)) & 0xFF; return n; #endif } /** Extract the nibble at a certain offset from a byte sequence. */ static unsigned char trie_key_nibble(const void *key, size_t offset) { const unsigned char *bytes = key; size_t byte = offset >> 1; // A branchless version of // if (offset & 1) { // return bytes[byte] >> 4; // } else { // return bytes[byte] & 0xF; // } unsigned int shift = (offset & 1) << 2; return (bytes[byte] >> shift) & 0xF; } /** * Finds a leaf in the trie that matches the key at every branch. If the key * exists in the trie, the representative will match the searched key. But * since only branch points are tested, it can be different from the key. In * that case, the first mismatch between the key and the representative will be * the depth at which to make a new branch to insert the key. */ static struct trie_leaf *trie_representative(const struct trie *trie, const void *key, size_t length) { uintptr_t ptr = trie->root; if (!ptr) { return NULL; } size_t offset = 0; while (!trie_is_leaf(ptr)) { struct trie_node *node = trie_decode_node(ptr); offset += node->offset; unsigned int index = 0; if ((offset >> 1) < length) { unsigned char nibble = trie_key_nibble(key, offset); unsigned int bit = 1U << nibble; if (node->bitmap & bit) { index = trie_popcount(node->bitmap & (bit - 1)); } } ptr = node->children[index]; } return trie_decode_leaf(ptr); } struct trie_leaf *trie_first_leaf(const struct trie *trie) { return trie_representative(trie, NULL, 0); } struct trie_leaf *trie_find_str(const struct trie *trie, const char *key) { return trie_find_mem(trie, key, strlen(key) + 1); } struct trie_leaf *trie_find_mem(const struct trie *trie, const void *key, size_t length) { struct trie_leaf *rep = trie_representative(trie, key, length); if (rep && rep->length == length && memcmp(rep->key, key, length) == 0) { return rep; } else { return NULL; } } struct trie_leaf *trie_find_postfix(const struct trie *trie, const char *key) { size_t length = strlen(key); struct trie_leaf *rep = trie_representative(trie, key, length + 1); if (rep && rep->length >= length && memcmp(rep->key, key, length) == 0) { return rep; } else { return NULL; } } /** * Find a leaf that may end at the current node. */ static struct trie_leaf *trie_terminal_leaf(const struct trie_node *node) { // Finding a terminating NUL byte may take two nibbles for (int i = 0; i < 2; ++i) { if (!(node->bitmap & 1)) { break; } uintptr_t ptr = node->children[0]; if (trie_is_leaf(ptr)) { return trie_decode_leaf(ptr); } else { node = trie_decode_node(ptr); } } return NULL; } /** Check if a leaf is a prefix of a search key. */ static bool trie_check_prefix(struct trie_leaf *leaf, size_t skip, const char *key, size_t length) { if (leaf && leaf->length <= length) { return memcmp(key + skip, leaf->key + skip, leaf->length - skip - 1) == 0; } else { return false; } } struct trie_leaf *trie_find_prefix(const struct trie *trie, const char *key) { uintptr_t ptr = trie->root; if (!ptr) { return NULL; } struct trie_leaf *best = NULL; size_t skip = 0; size_t length = strlen(key) + 1; size_t offset = 0; while (!trie_is_leaf(ptr)) { struct trie_node *node = trie_decode_node(ptr); offset += node->offset; if ((offset >> 1) >= length) { return best; } struct trie_leaf *leaf = trie_terminal_leaf(node); if (trie_check_prefix(leaf, skip, key, length)) { best = leaf; skip = offset >> 1; } unsigned char nibble = trie_key_nibble(key, offset); unsigned int bit = 1U << nibble; if (node->bitmap & bit) { unsigned int index = trie_popcount(node->bitmap & (bit - 1)); ptr = node->children[index]; } else { return best; } } struct trie_leaf *leaf = trie_decode_leaf(ptr); if (trie_check_prefix(leaf, skip, key, length)) { best = leaf; } return best; } /** Create a new leaf, holding a copy of the given key. */ static struct trie_leaf *new_trie_leaf(const void *key, size_t length) { struct trie_leaf *leaf = malloc(BFS_FLEX_SIZEOF(struct trie_leaf, key, length)); if (leaf) { leaf->value = NULL; leaf->length = length; memcpy(leaf->key, key, length); } return leaf; } /** Compute the size of a trie node with a certain number of children. */ static size_t trie_node_size(unsigned int size) { // Empty nodes aren't supported assert(size > 0); // Node size must be a power of two assert((size & (size - 1)) == 0); return BFS_FLEX_SIZEOF(struct trie_node, children, size); } /** Find the offset of the first nibble that differs between two keys. */ static size_t trie_key_mismatch(const void *key1, const void *key2, size_t length) { const unsigned char *bytes1 = key1; const unsigned char *bytes2 = key2; size_t i = 0; size_t offset = 0; const size_t chunk = sizeof(size_t); for (; i + chunk <= length; i += chunk) { if (memcmp(bytes1 + i, bytes2 + i, chunk) != 0) { break; } } for (; i < length; ++i) { unsigned char b1 = bytes1[i], b2 = bytes2[i]; if (b1 != b2) { offset = (b1 & 0xF) == (b2 & 0xF); break; } } offset |= i << 1; return offset; } /** * Insert a key into a node. The node must not have a child in that position * already. Effectively takes a subtrie like this: * * ptr * | * v X * *--->... * | Z * +--->... * * and transforms it to: * * ptr * | * v X * *--->... * | Y * +--->key * | Z * +--->... */ static struct trie_leaf *trie_node_insert(uintptr_t *ptr, const void *key, size_t length, size_t offset) { struct trie_node *node = trie_decode_node(*ptr); unsigned int size = trie_popcount(node->bitmap); // Double the capacity every power of two if ((size & (size - 1)) == 0) { node = realloc(node, trie_node_size(2*size)); if (!node) { return NULL; } *ptr = trie_encode_node(node); } struct trie_leaf *leaf = new_trie_leaf(key, length); if (!leaf) { return NULL; } unsigned char nibble = trie_key_nibble(key, offset); unsigned int bit = 1U << nibble; // The child must not already be present assert(!(node->bitmap & bit)); node->bitmap |= bit; unsigned int index = trie_popcount(node->bitmap & (bit - 1)); uintptr_t *child = node->children + index; if (index < size) { memmove(child + 1, child, (size - index)*sizeof(*child)); } *child = trie_encode_leaf(leaf); return leaf; } /** * When the current offset exceeds OFFSET_MAX, insert "jump" nodes that bridge * the gap. This function takes a subtrie like this: * * ptr * | * v * *--->rep * * and changes it to: * * ptr ret * | | * v v * *--->*--->rep * * so that a new key can be inserted like: * * ptr ret * | | * v v X * *--->*--->rep * | Y * +--->key */ static uintptr_t *trie_jump(uintptr_t *ptr, const char *key, size_t *offset) { // We only ever need to jump to leaf nodes, since internal nodes are // guaranteed to be within OFFSET_MAX anyway assert(trie_is_leaf(*ptr)); struct trie_node *node = malloc(trie_node_size(1)); if (!node) { return NULL; } *offset += OFFSET_MAX; node->offset = OFFSET_MAX; unsigned char nibble = trie_key_nibble(key, *offset); node->bitmap = 1 << nibble; node->children[0] = *ptr; *ptr = trie_encode_node(node); return node->children; } /** * Split a node in the trie. Changes a subtrie like this: * * ptr * | * v * *...>--->rep * * into this: * * ptr * | * v X * *--->*...>--->rep * | Y * +--->key */ static struct trie_leaf *trie_split(uintptr_t *ptr, const void *key, size_t length, struct trie_leaf *rep, size_t offset, size_t mismatch) { unsigned char key_nibble = trie_key_nibble(key, mismatch); unsigned char rep_nibble = trie_key_nibble(rep->key, mismatch); assert(key_nibble != rep_nibble); struct trie_node *node = malloc(trie_node_size(2)); if (!node) { return NULL; } struct trie_leaf *leaf = new_trie_leaf(key, length); if (!leaf) { free(node); return NULL; } node->bitmap = (1 << key_nibble) | (1 << rep_nibble); size_t delta = mismatch - offset; if (!trie_is_leaf(*ptr)) { struct trie_node *child = trie_decode_node(*ptr); child->offset -= delta; } node->offset = delta; unsigned int key_index = key_nibble > rep_nibble; node->children[key_index] = trie_encode_leaf(leaf); node->children[key_index ^ 1] = *ptr; *ptr = trie_encode_node(node); return leaf; } struct trie_leaf *trie_insert_str(struct trie *trie, const char *key) { return trie_insert_mem(trie, key, strlen(key) + 1); } struct trie_leaf *trie_insert_mem(struct trie *trie, const void *key, size_t length) { struct trie_leaf *rep = trie_representative(trie, key, length); if (!rep) { struct trie_leaf *leaf = new_trie_leaf(key, length); if (leaf) { trie->root = trie_encode_leaf(leaf); } return leaf; } size_t limit = length < rep->length ? length : rep->length; size_t mismatch = trie_key_mismatch(key, rep->key, limit); if ((mismatch >> 1) >= length) { return rep; } size_t offset = 0; uintptr_t *ptr = &trie->root; while (!trie_is_leaf(*ptr)) { struct trie_node *node = trie_decode_node(*ptr); if (offset + node->offset > mismatch) { break; } offset += node->offset; unsigned char nibble = trie_key_nibble(key, offset); unsigned int bit = 1U << nibble; if (node->bitmap & bit) { assert(offset < mismatch); unsigned int index = trie_popcount(node->bitmap & (bit - 1)); ptr = node->children + index; } else { assert(offset == mismatch); return trie_node_insert(ptr, key, length, offset); } } while (mismatch - offset > OFFSET_MAX) { ptr = trie_jump(ptr, key, &offset); if (!ptr) { return NULL; } } return trie_split(ptr, key, length, rep, offset, mismatch); } /** Free a chain of singleton nodes. */ static void trie_free_singletons(uintptr_t ptr) { while (!trie_is_leaf(ptr)) { struct trie_node *node = trie_decode_node(ptr); // Make sure the bitmap is a power of two, i.e. it has just one child assert((node->bitmap & (node->bitmap - 1)) == 0); ptr = node->children[0]; free(node); } free(trie_decode_leaf(ptr)); } /** * Try to collapse a two-child node like: * * parent child * | | * v v * *----->*----->*----->leaf * | * +----->other * * into * * parent * | * v * other */ static int trie_collapse_node(uintptr_t *parent, struct trie_node *parent_node, unsigned int child_index) { uintptr_t other = parent_node->children[child_index ^ 1]; if (!trie_is_leaf(other)) { struct trie_node *other_node = trie_decode_node(other); if (other_node->offset + parent_node->offset <= OFFSET_MAX) { other_node->offset += parent_node->offset; } else { return -1; } } *parent = other; free(parent_node); return 0; } void trie_remove(struct trie *trie, struct trie_leaf *leaf) { uintptr_t *child = &trie->root; uintptr_t *parent = NULL; unsigned int child_bit = 0, child_index = 0; size_t offset = 0; while (!trie_is_leaf(*child)) { struct trie_node *node = trie_decode_node(*child); offset += node->offset; assert((offset >> 1) < leaf->length); unsigned char nibble = trie_key_nibble(leaf->key, offset); unsigned int bit = 1U << nibble; unsigned int bitmap = node->bitmap; assert(bitmap & bit); unsigned int index = trie_popcount(bitmap & (bit - 1)); // Advance the parent pointer, unless this node had only one child if (bitmap & (bitmap - 1)) { parent = child; child_bit = bit; child_index = index; } child = node->children + index; } assert(trie_decode_leaf(*child) == leaf); if (!parent) { trie_free_singletons(trie->root); trie->root = 0; return; } struct trie_node *node = trie_decode_node(*parent); child = node->children + child_index; trie_free_singletons(*child); node->bitmap ^= child_bit; unsigned int parent_size = trie_popcount(node->bitmap); assert(parent_size > 0); if (parent_size == 1 && trie_collapse_node(parent, node, child_index) == 0) { return; } if (child_index < parent_size) { memmove(child, child + 1, (parent_size - child_index)*sizeof(*child)); } if ((parent_size & (parent_size - 1)) == 0) { node = realloc(node, trie_node_size(parent_size)); if (node) { *parent = trie_encode_node(node); } } } /** Free an encoded pointer to a node. */ static void free_trie_ptr(uintptr_t ptr) { if (trie_is_leaf(ptr)) { free(trie_decode_leaf(ptr)); } else { struct trie_node *node = trie_decode_node(ptr); size_t size = trie_popcount(node->bitmap); for (size_t i = 0; i < size; ++i) { free_trie_ptr(node->children[i]); } free(node); } } void trie_destroy(struct trie *trie) { if (trie->root) { free_trie_ptr(trie->root); } } bfs-2.3.1/trie.h000066400000000000000000000100421417254370000134030ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2019 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #ifndef BFS_TRIE_H #define BFS_TRIE_H #include #include /** * A trie that holds a set of fixed- or variable-length strings. */ struct trie { uintptr_t root; }; /** * A leaf of a trie. */ struct trie_leaf { /** * An arbitrary value associated with this leaf. */ void *value; /** * The length of the key in bytes. */ size_t length; /** * The key itself, stored inline. */ char key[]; }; /** * Initialize an empty trie. */ void trie_init(struct trie *trie); /** * Get the first (lexicographically earliest) leaf in the trie. * * @param trie * The trie to search. * @return * The first leaf, or NULL if the trie is empty. */ struct trie_leaf *trie_first_leaf(const struct trie *trie); /** * Find the leaf for a string key. * * @param trie * The trie to search. * @param key * The key to look up. * @return * The found leaf, or NULL if the key is not present. */ struct trie_leaf *trie_find_str(const struct trie *trie, const char *key); /** * Find the leaf for a fixed-size key. * * @param trie * The trie to search. * @param key * The key to look up. * @param length * The length of the key in bytes. * @return * The found leaf, or NULL if the key is not present. */ struct trie_leaf *trie_find_mem(const struct trie *trie, const void *key, size_t length); /** * Find the shortest leaf that starts with a given key. * * @param trie * The trie to search. * @param key * The key to look up. * @return * A leaf that starts with the given key, or NULL. */ struct trie_leaf *trie_find_postfix(const struct trie *trie, const char *key); /** * Find the leaf that is the longest prefix of the given key. * * @param trie * The trie to search. * @param key * The key to look up. * @return * The longest prefix match for the given key, or NULL. */ struct trie_leaf *trie_find_prefix(const struct trie *trie, const char *key); /** * Insert a string key into the trie. * * @param trie * The trie to modify. * @param key * The key to insert. * @return * The inserted leaf, or NULL on failure. */ struct trie_leaf *trie_insert_str(struct trie *trie, const char *key); /** * Insert a fixed-size key into the trie. * * @param trie * The trie to modify. * @param key * The key to insert. * @param length * The length of the key in bytes. * @return * The inserted leaf, or NULL on failure. */ struct trie_leaf *trie_insert_mem(struct trie *trie, const void *key, size_t length); /** * Remove a leaf from a trie. * * @param trie * The trie to modify. * @param leaf * The leaf to remove. */ void trie_remove(struct trie *trie, struct trie_leaf *leaf); /** * Destroy a trie and its contents. */ void trie_destroy(struct trie *trie); #endif // BFS_TRIE_H bfs-2.3.1/typo.c000066400000000000000000000111741417254370000134350ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2016 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "typo.h" #include #include #include // Assume QWERTY layout for now static const int key_coords[UCHAR_MAX][3] = { ['`'] = { 0, 0, 0}, ['~'] = { 0, 0, 1}, ['1'] = { 3, 0, 0}, ['!'] = { 3, 0, 1}, ['2'] = { 6, 0, 0}, ['@'] = { 6, 0, 1}, ['3'] = { 9, 0, 0}, ['#'] = { 9, 0, 1}, ['4'] = {12, 0, 0}, ['$'] = {12, 0, 1}, ['5'] = {15, 0, 0}, ['%'] = {15, 0, 1}, ['6'] = {18, 0, 0}, ['^'] = {18, 0, 1}, ['7'] = {21, 0, 0}, ['&'] = {21, 0, 1}, ['8'] = {24, 0, 0}, ['*'] = {24, 0, 1}, ['9'] = {27, 0, 0}, ['('] = {27, 0, 1}, ['0'] = {30, 0, 0}, [')'] = {30, 0, 1}, ['-'] = {33, 0, 0}, ['_'] = {33, 0, 1}, ['='] = {36, 0, 0}, ['+'] = {36, 0, 1}, ['\t'] = { 1, 3, 0}, ['q'] = { 4, 3, 0}, ['Q'] = { 4, 3, 1}, ['w'] = { 7, 3, 0}, ['W'] = { 7, 3, 1}, ['e'] = {10, 3, 0}, ['E'] = {10, 3, 1}, ['r'] = {13, 3, 0}, ['R'] = {13, 3, 1}, ['t'] = {16, 3, 0}, ['T'] = {16, 3, 1}, ['y'] = {19, 3, 0}, ['Y'] = {19, 3, 1}, ['u'] = {22, 3, 0}, ['U'] = {22, 3, 1}, ['i'] = {25, 3, 0}, ['I'] = {25, 3, 1}, ['o'] = {28, 3, 0}, ['O'] = {28, 3, 1}, ['p'] = {31, 3, 0}, ['P'] = {31, 3, 1}, ['['] = {34, 3, 0}, ['{'] = {34, 3, 1}, [']'] = {37, 3, 0}, ['}'] = {37, 3, 1}, ['\\'] = {40, 3, 0}, ['|'] = {40, 3, 1}, ['a'] = { 5, 6, 0}, ['A'] = { 5, 6, 1}, ['s'] = { 8, 6, 0}, ['S'] = { 8, 6, 1}, ['d'] = {11, 6, 0}, ['D'] = {11, 6, 1}, ['f'] = {14, 6, 0}, ['F'] = {14, 6, 1}, ['g'] = {17, 6, 0}, ['G'] = {17, 6, 1}, ['h'] = {20, 6, 0}, ['H'] = {20, 6, 1}, ['j'] = {23, 6, 0}, ['J'] = {23, 6, 1}, ['k'] = {26, 6, 0}, ['K'] = {26, 6, 1}, ['l'] = {29, 6, 0}, ['L'] = {29, 6, 1}, [';'] = {32, 6, 0}, [':'] = {32, 6, 1}, ['\''] = {35, 6, 0}, ['"'] = {35, 6, 1}, ['\n'] = {38, 6, 0}, ['z'] = { 6, 9, 0}, ['Z'] = { 6, 9, 1}, ['x'] = { 9, 9, 0}, ['X'] = { 9, 9, 1}, ['c'] = {12, 9, 0}, ['C'] = {12, 9, 1}, ['v'] = {15, 9, 0}, ['V'] = {15, 9, 1}, ['b'] = {18, 9, 0}, ['B'] = {18, 9, 1}, ['n'] = {21, 9, 0}, ['N'] = {21, 9, 1}, ['m'] = {24, 9, 0}, ['M'] = {24, 9, 1}, [','] = {27, 9, 0}, ['<'] = {27, 9, 1}, ['.'] = {30, 9, 0}, ['>'] = {30, 9, 1}, ['/'] = {33, 9, 0}, ['?'] = {33, 9, 1}, [' '] = {18, 12, 0}, }; static int char_distance(char a, char b) { const int *ac = key_coords[(unsigned char)a], *bc = key_coords[(unsigned char)b]; int ret = 0; for (int i = 0; i < 3; ++i) { ret += abs(ac[i] - bc[i]); } return ret; } int typo_distance(const char *actual, const char *expected) { // This is the Wagner-Fischer algorithm for Levenshtein distance, using // Manhattan distance on the keyboard for individual characters. const int insert_cost = 12; size_t rows = strlen(actual) + 1; size_t cols = strlen(expected) + 1; int arr0[cols], arr1[cols]; int *row0 = arr0, *row1 = arr1; for (size_t j = 0; j < cols; ++j) { row0[j] = insert_cost * j; } for (size_t i = 1; i < rows; ++i) { row1[0] = row0[0] + insert_cost; char a = actual[i - 1]; for (size_t j = 1; j < cols; ++j) { char b = expected[j - 1]; int cost = row0[j - 1] + char_distance(a, b); int del_cost = row0[j] + insert_cost; if (del_cost < cost) { cost = del_cost; } int ins_cost = row1[j - 1] + insert_cost; if (ins_cost < cost) { cost = ins_cost; } row1[j] = cost; } int *tmp = row0; row0 = row1; row1 = tmp; } return row0[cols - 1]; } bfs-2.3.1/typo.h000066400000000000000000000027651417254370000134500ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2016 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #ifndef BFS_TYPO_H #define BFS_TYPO_H /** * Find the "typo" distance between two strings. * * @param actual * The actual string typed by the user. * @param expected * The expected valid string. * @return The distance between the two strings. */ int typo_distance(const char *actual, const char *expected); #endif // BFS_TYPO_H bfs-2.3.1/util.c000066400000000000000000000213231417254370000134140ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2016-2022 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ #include "util.h" #include "dstring.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #if BFS_HAS_SYS_PARAM # include #endif #if BFS_HAS_SYS_SYSMACROS # include #elif BFS_HAS_SYS_MKDEV # include #endif #if BFS_HAS_UTIL # include #endif char *xreadlinkat(int fd, const char *path, size_t size) { ssize_t len; char *name = NULL; if (size == 0) { size = 64; } else { ++size; // NUL terminator } while (true) { char *new_name = realloc(name, size); if (!new_name) { goto error; } name = new_name; len = readlinkat(fd, path, name, size); if (len < 0) { goto error; } else if ((size_t)len >= size) { size *= 2; } else { break; } } name[len] = '\0'; return name; error: free(name); return NULL; } int dup_cloexec(int fd) { #ifdef F_DUPFD_CLOEXEC return fcntl(fd, F_DUPFD_CLOEXEC, 0); #else int ret = dup(fd); if (ret < 0) { return -1; } if (fcntl(ret, F_SETFD, FD_CLOEXEC) == -1) { close_quietly(ret); return -1; } return ret; #endif } int pipe_cloexec(int pipefd[2]) { #if __linux__ || (BSD && !__APPLE__) return pipe2(pipefd, O_CLOEXEC); #else if (pipe(pipefd) != 0) { return -1; } if (fcntl(pipefd[0], F_SETFD, FD_CLOEXEC) == -1 || fcntl(pipefd[1], F_SETFD, FD_CLOEXEC) == -1) { close_quietly(pipefd[1]); close_quietly(pipefd[0]); return -1; } return 0; #endif } char *xregerror(int err, const regex_t *regex) { size_t len = regerror(err, regex, NULL, 0); char *str = malloc(len); if (str) { regerror(err, regex, str, len); } return str; } /** Get the single character describing the given file type. */ static char type_char(mode_t mode) { switch (mode & S_IFMT) { case S_IFREG: return '-'; case S_IFBLK: return 'b'; case S_IFCHR: return 'c'; case S_IFDIR: return 'd'; case S_IFLNK: return 'l'; case S_IFIFO: return 'p'; case S_IFSOCK: return 's'; #ifdef S_IFDOOR case S_IFDOOR: return 'D'; #endif #ifdef S_IFPORT case S_IFPORT: return 'P'; #endif #ifdef S_IFWHT case S_IFWHT: return 'w'; #endif } return '?'; } void xstrmode(mode_t mode, char str[11]) { strcpy(str, "----------"); str[0] = type_char(mode); if (mode & 00400) { str[1] = 'r'; } if (mode & 00200) { str[2] = 'w'; } if ((mode & 04100) == 04000) { str[3] = 'S'; } else if (mode & 04000) { str[3] = 's'; } else if (mode & 00100) { str[3] = 'x'; } if (mode & 00040) { str[4] = 'r'; } if (mode & 00020) { str[5] = 'w'; } if ((mode & 02010) == 02000) { str[6] = 'S'; } else if (mode & 02000) { str[6] = 's'; } else if (mode & 00010) { str[6] = 'x'; } if (mode & 00004) { str[7] = 'r'; } if (mode & 00002) { str[8] = 'w'; } if ((mode & 01001) == 01000) { str[9] = 'T'; } else if (mode & 01000) { str[9] = 't'; } else if (mode & 00001) { str[9] = 'x'; } } const char *xbasename(const char *path) { const char *i; // Skip trailing slashes for (i = path + strlen(path); i > path && i[-1] == '/'; --i); // Find the beginning of the name for (; i > path && i[-1] != '/'; --i); // Skip leading slashes for (; i[0] == '/' && i[1]; ++i); return i; } int xfaccessat(int fd, const char *path, int amode) { int ret = faccessat(fd, path, amode, 0); #ifdef AT_EACCESS // Some platforms, like Hurd, only support AT_EACCESS. Other platforms, // like Android, don't support AT_EACCESS at all. if (ret != 0 && (errno == EINVAL || errno == ENOTSUP)) { ret = faccessat(fd, path, amode, AT_EACCESS); } #endif return ret; } int xstrtofflags(const char **str, unsigned long long *set, unsigned long long *clear) { #if BSD && !__GNU__ char *str_arg = (char *)*str; unsigned long set_arg = 0; unsigned long clear_arg = 0; #if __NetBSD__ int ret = string_to_flags(&str_arg, &set_arg, &clear_arg); #else int ret = strtofflags(&str_arg, &set_arg, &clear_arg); #endif *str = str_arg; *set = set_arg; *clear = clear_arg; if (ret != 0) { errno = EINVAL; } return ret; #else // !BSD errno = ENOTSUP; return -1; #endif } bool is_nonexistence_error(int error) { return error == ENOENT || errno == ENOTDIR; } /** Compile and execute a regular expression for xrpmatch(). */ static int xrpregex(nl_item item, const char *response) { const char *pattern = nl_langinfo(item); if (!pattern) { return REG_BADPAT; } regex_t regex; int ret = regcomp(®ex, pattern, REG_EXTENDED); if (ret != 0) { return ret; } ret = regexec(®ex, response, 0, NULL, 0); regfree(®ex); return ret; } /** Check if a response is affirmative or negative. */ static int xrpmatch(const char *response) { int ret = xrpregex(NOEXPR, response); if (ret == 0) { return 0; } else if (ret != REG_NOMATCH) { return -1; } ret = xrpregex(YESEXPR, response); if (ret == 0) { return 1; } else if (ret != REG_NOMATCH) { return -1; } // Failsafe: always handle y/n char c = response[0]; if (c == 'n' || c == 'N') { return 0; } else if (c == 'y' || c == 'Y') { return 1; } else { return -1; } } int ynprompt(void) { fflush(stderr); char *line = xgetdelim(stdin, '\n'); int ret = line ? xrpmatch(line) : -1; free(line); return ret; } dev_t bfs_makedev(int ma, int mi) { #ifdef makedev return makedev(ma, mi); #else return (ma << 8) | mi; #endif } int bfs_major(dev_t dev) { #ifdef major return major(dev); #else return dev >> 8; #endif } int bfs_minor(dev_t dev) { #ifdef minor return minor(dev); #else return dev & 0xFF; #endif } size_t xread(int fd, void *buf, size_t nbytes) { size_t count = 0; while (count < nbytes) { ssize_t ret = read(fd, (char *)buf + count, nbytes - count); if (ret < 0) { if (errno == EINTR) { continue; } else { break; } } else if (ret == 0) { // EOF errno = 0; break; } else { count += ret; } } return count; } size_t xwrite(int fd, const void *buf, size_t nbytes) { size_t count = 0; while (count < nbytes) { ssize_t ret = write(fd, (const char *)buf + count, nbytes - count); if (ret < 0) { if (errno == EINTR) { continue; } else { break; } } else if (ret == 0) { // EOF? errno = 0; break; } else { count += ret; } } return count; } char *xconfstr(int name) { size_t len = confstr(name, NULL, 0); if (len == 0) { return NULL; } char *str = malloc(len); if (!str) { return NULL; } if (confstr(name, str, len) != len) { free(str); return NULL; } return str; } char *xgetdelim(FILE *file, char delim) { char *chunk = NULL; size_t n = 0; ssize_t len = getdelim(&chunk, &n, delim, file); if (len >= 0) { if (chunk[len] == delim) { chunk[len] = '\0'; } return chunk; } else { free(chunk); if (!ferror(file)) { errno = 0; } return NULL; } } FILE *xfopen(const char *path, int flags) { char mode[4]; switch (flags & O_ACCMODE) { case O_RDONLY: strcpy(mode, "rb"); break; case O_WRONLY: strcpy(mode, "wb"); break; case O_RDWR: strcpy(mode, "r+b"); break; default: assert(!"Invalid access mode"); errno = EINVAL; return NULL; } if (flags & O_APPEND) { mode[0] = 'a'; } int fd; if (flags & O_CREAT) { fd = open(path, flags, 0666); } else { fd = open(path, flags); } if (fd < 0) { return NULL; } FILE *ret = fdopen(fd, mode); if (!ret) { close_quietly(fd); return NULL; } return ret; } int xclose(int fd) { int ret = close(fd); if (ret != 0) { assert(errno != EBADF); } return ret; } void close_quietly(int fd) { int error = errno; xclose(fd); errno = error; } bfs-2.3.1/util.h000066400000000000000000000206021417254370000134200ustar00rootroot00000000000000/**************************************************************************** * bfs * * Copyright (C) 2016-2022 Tavian Barnes * * * * Permission to use, copy, modify, and/or distribute this software for any * * purpose with or without fee is hereby granted. * * * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * ****************************************************************************/ /** * Assorted utilities that don't belong anywhere else. */ #ifndef BFS_UTIL_H #define BFS_UTIL_H #include #include #include #include #include #include #include // Some portability concerns #ifdef __has_feature # define BFS_HAS_FEATURE(feature, fallback) __has_feature(feature) #else # define BFS_HAS_FEATURE(feature, fallback) fallback #endif #ifdef __has_include # define BFS_HAS_INCLUDE(header, fallback) __has_include(header) #else # define BFS_HAS_INCLUDE(header, fallback) fallback #endif #ifdef __has_c_attribute # define BFS_HAS_C_ATTRIBUTE(attr) __has_c_attribute(attr) #else # define BFS_HAS_C_ATTRIBUTE(attr) false #endif #if __GNUC__ && defined(__has_attribute) # define BFS_HAS_GNU_ATTRIBUTE(attr) __has_attribute(attr) #else # define BFS_HAS_GNU_ATTRIBUTE(attr) false #endif #ifndef BFS_HAS_MNTENT # define BFS_HAS_MNTENT BFS_HAS_INCLUDE(, __GLIBC__) #endif #ifndef BFS_HAS_SYS_ACL # define BFS_HAS_SYS_ACL BFS_HAS_INCLUDE(, true) #endif #ifndef BFS_HAS_SYS_CAPABILITY # define BFS_HAS_SYS_CAPABILITY BFS_HAS_INCLUDE(, __linux__) #endif #ifndef BFS_HAS_SYS_EXTATTR # define BFS_HAS_SYS_EXTATTR BFS_HAS_INCLUDE(, __FreeBSD__) #endif #ifndef BFS_HAS_SYS_MKDEV # define BFS_HAS_SYS_MKDEV BFS_HAS_INCLUDE(, false) #endif #ifndef BFS_HAS_SYS_PARAM # define BFS_HAS_SYS_PARAM BFS_HAS_INCLUDE(, true) #endif #ifndef BFS_HAS_SYS_SYSMACROS # define BFS_HAS_SYS_SYSMACROS BFS_HAS_INCLUDE(, __GLIBC__) #endif #ifndef BFS_HAS_SYS_XATTR # define BFS_HAS_SYS_XATTR BFS_HAS_INCLUDE(, __linux__) #endif #ifndef BFS_HAS_UTIL # define BFS_HAS_UTIL BFS_HAS_INCLUDE(, __NetBSD__) #endif #if !defined(FNM_CASEFOLD) && defined(FNM_IGNORECASE) # define FNM_CASEFOLD FNM_IGNORECASE #endif #ifndef O_DIRECTORY # define O_DIRECTORY 0 #endif #if BFS_HAS_C_ATTRIBUTE(fallthrough) # define BFS_FALLTHROUGH [[fallthrough]] #elif BFS_HAS_GNU_ATTRIBUTE(fallthrough) # define BFS_FALLTHROUGH __attribute__((fallthrough)) #else # define BFS_FALLTHROUGH ((void)0) #endif /** * Adds compiler warnings for bad printf()-style function calls, if supported. */ #if BFS_HAS_GNU_ATTRIBUTE(format) # define BFS_FORMATTER(fmt, args) __attribute__((format(printf, fmt, args))) #else # define BFS_FORMATTER(fmt, args) #endif // Lower bound on BFS_FLEX_SIZEOF() #define BFS_FLEX_LB(type, member, length) (offsetof(type, member) + sizeof(((type *)NULL)->member[0]) * (length)) // Maximum macro for BFS_FLEX_SIZE() #define BFS_FLEX_MAX(a, b) ((a) > (b) ? (a) : (b)) /** * Computes the size of a struct containing a flexible array member of the given * length. * * @param type * The type of the struct containing the flexible array. * @param member * The name of the flexible array member. * @param length * The length of the flexible array. */ #define BFS_FLEX_SIZEOF(type, member, length) \ (sizeof(type) <= BFS_FLEX_LB(type, member, 0) \ ? BFS_FLEX_LB(type, member, length) \ : BFS_FLEX_MAX(sizeof(type), BFS_FLEX_LB(type, member, length))) /** * readlinkat() wrapper that dynamically allocates the result. * * @param fd * The base directory descriptor. * @param path * The path to the link, relative to fd. * @param size * An estimate for the size of the link name (pass 0 if unknown). * @return The target of the link, allocated with malloc(), or NULL on failure. */ char *xreadlinkat(int fd, const char *path, size_t size); /** * Like dup(), but set the FD_CLOEXEC flag. * * @param fd * The file descriptor to duplicate. * @return A duplicated file descriptor, or -1 on failure. */ int dup_cloexec(int fd); /** * Like pipe(), but set the FD_CLOEXEC flag. * * @param pipefd * The array to hold the two file descriptors. * @return 0 on success, -1 on failure. */ int pipe_cloexec(int pipefd[2]); /** * Dynamically allocate a regex error message. * * @param err * The error code to stringify. * @param regex * The (partially) compiled regex. * @return A human-readable description of the error, allocated with malloc(). */ char *xregerror(int err, const regex_t *regex); /** * Format a mode like ls -l (e.g. -rw-r--r--). * * @param mode * The mode to format. * @param str * The string to hold the formatted mode. */ void xstrmode(mode_t mode, char str[11]); /** * basename() variant that doesn't modify the input. * * @param path * The path in question. * @return A pointer into path at the base name offset. */ const char *xbasename(const char *path); /** * Wrapper for faccessat() that handles some portability issues. */ int xfaccessat(int fd, const char *path, int amode); /** * Portability wrapper for strtofflags(). * * @param str * The string to parse. The pointee will be advanced to the first * invalid position on error. * @param set * The flags that are set in the string. * @param clear * The flags that are cleared in the string. * @return * 0 on success, -1 on failure. */ int xstrtofflags(const char **str, unsigned long long *set, unsigned long long *clear); /** * Return whether an error code is due to a path not existing. */ bool is_nonexistence_error(int error); /** * Process a yes/no prompt. * * @return 1 for yes, 0 for no, and -1 for unknown. */ int ynprompt(void); /** * Portable version of makedev(). */ dev_t bfs_makedev(int ma, int mi); /** * Portable version of major(). */ int bfs_major(dev_t dev); /** * Portable version of minor(). */ int bfs_minor(dev_t dev); /** * A safe version of read() that handles interrupted system calls and partial * reads. * * @return * The number of bytes read. A value != nbytes indicates an error * (errno != 0) or end of file (errno == 0). */ size_t xread(int fd, void *buf, size_t nbytes); /** * A safe version of write() that handles interrupted system calls and partial * writes. * * @return The number of bytes written. A value != nbytes indicates an error. */ size_t xwrite(int fd, const void *buf, size_t nbytes); /** * Wrapper for confstr() that allocates with malloc(). * * @param name * The ID of the confstr to look up. * @return * The value of the confstr, or NULL on failure. */ char *xconfstr(int name); /** * Convenience wrapper for getdelim(). * * @param file * The file to read. * @param delim * The delimiter character to split on. * @return * The read chunk (without the delimiter), allocated with malloc(). * NULL is returned on error (errno != 0) or end of file (errno == 0). */ char *xgetdelim(FILE *file, char delim); /** * fopen() variant that takes open() style flags. * * @param path * The path to open. * @param flags * Flags to pass to open(). */ FILE *xfopen(const char *path, int flags); /** * close() wrapper that asserts the file descriptor is valid. * * @param fd * The file descriptor to close. * @return * 0 on success, or -1 on error. */ int xclose(int fd); /** * close() variant that preserves errno. * * @param fd * The file descriptor to close. */ void close_quietly(int fd); #endif // BFS_UTIL_H