s6-portable-utils-2.2.2.1/0002755000000000000000000000000013553343655012054 5ustar s6-portable-utils-2.2.2.1/README.solaris0000644000000000000000000000065312376372746014416 0ustar This package assumes the existence of a POSIX shell in /bin/sh. On Solaris, /bin/sh is not POSIX. Most versions of Solaris provide a POSIX shell in /usr/xpg4/bin/sh. To compile this package on Solaris, you will need to run ./patch-for-solaris before you run ./configure. This script will change the #! invocation of the configure script and various tools so that a POSIX shell is used for the compilation process. s6-portable-utils-2.2.2.1/AUTHORS0000644000000000000000000000045613405477326013126 0ustar Main author: Laurent Bercot Contributors: Luis Ressel Thanks to: Dan J. Bernstein Jean Marot Jorge Almeida Vallo Kallaste Josuah Demangeon s6-portable-utils-2.2.2.1/INSTALL0000644000000000000000000001301713553360340013073 0ustar Build Instructions ------------------ * Requirements ------------ - A POSIX-compliant C development environment - GNU make version 3.81 or later - skalibs version 2.9.1.0 or later: http://skarnet.org/software/skalibs/ This software will run on any operating system that implements POSIX.1-2008, available at: http://pubs.opengroup.org/onlinepubs/9699919799/ * Standard usage -------------- ./configure && make && sudo make install will work for most users. It will install the binaries in /bin. You can strip the binaries of their extra symbols via "make strip" before the "make install" phase. It will shave a few bytes off them. * Customization ------------- You can customize paths via flags given to configure. See ./configure --help for a list of all available configure options. * Environment variables --------------------- Controlling a build process via environment variables is a big and dangerous hammer. You should try and pass flags to configure instead; nevertheless, a few standard environment variables are recognized. If the CC environment variable is set, its value will override compiler detection by configure. The --host=HOST option will still add a HOST- prefix to the value of CC. The values of CFLAGS, CPPFLAGS and LDFLAGS will be appended to flags auto-detected by configure. To entirely override the flags set by configure instead, use make variables. * Make variables -------------- You can invoke make with a few variables for more configuration. CC, CFLAGS, CPPFLAGS, LDFLAGS, LDLIBS, AR, RANLIB, STRIP, INSTALL and CROSS_COMPILE can all be overridden on the make command line. This is an even bigger hammer than running ./configure with environment variables, so it is advised to only do this when it is the only way of obtaining the behaviour you want. DESTDIR can be given on the "make install" command line in order to install to a staging directory. * Static binaries --------------- By default, binaries are linked against static versions of all the libraries they depend on, except for the libc. You can enforce linking against the static libc with --enable-static-libc. (If you are using a GNU/Linux system, be aware that the GNU libc behaves badly with static linking and produces huge executables, which is why it is not the default. Other libcs are better suited to static linking, for instance musl: http://musl-libc.org/) * Cross-compilation ----------------- skarnet.org packages centralize all the difficulty of cross-compilation in one place: skalibs. Once you have cross-compiled skalibs, the rest is easy. * Use the --host=HOST option to configure, HOST being the triplet for your target. * Make sure your cross-toolchain binaries (i.e. prefixed with HOST-) are accessible via your PATH environment variable. * Make sure to use the correct version of skalibs for your target, and the correct sysdeps directory, making use of the --with-include, --with-lib, --with-dynlib and --with-sysdeps options as necessary. * The slashpackage convention --------------------------- The slashpackage convention (http://cr.yp.to/slashpackage.html) is a package installation scheme that provides a few guarantees over other conventions such as the FHS, for instance fixed absolute pathnames. skarnet.org packages support it: use the --enable-slashpackage option to configure, or --enable-slashpackage=DIR for a prefixed DIR/package tree. This option will activate slashpackage support during the build and set slashpackage-compatible installation directories. If $package_home is the home of the package, defined as DIR/package/$category/$package-$version with the variables read from the package/info file, then: --dynlibdir is set to $package_home/library.so --bindir is set to $package_home/command --sbindir is also set to $package_home/command (slashpackage differentiates root-only binaries by their Unix rights, not their location in the filesystem) --libexecdir is also set to $package_home/command (slashpackage does not need a specific directory for internal binaries) --libdir is set to $package_home/library --includedir is set to $package_home/include --prefix is pretty much ignored when you use --enable-slashpackage. You should probably not use both --enable-slashpackage and --prefix. When using slashpackage, two additional Makefile targets are available after "make install": - "make update" changes the default version of the software to the freshly installed one. (This is useful when you have several installed versions of the same software, which slashpackage supports.) - "make -L global-links" adds links from /command and /library.so to the default version of the binaries and shared libraries. The "-L" option to make is necessary because targets are symbolic links, and the default make behaviour is to check the pointed file's timestamp and not the symlink's timestamp. * Absolute pathnames ------------------ You may want to use fixed absolute pathnames even if you're not following the slashpackage convention: for instance, the Nix packaging system prefers calling binaries with immutable paths rather than rely on PATH resolution. If you are in that case, use the --enable-absolute-paths option to configure. This will ensure that programs calling binaries from this package will call them with their full installation path (in bindir) without relying on a PATH search. * Out-of-tree builds ------------------ skarnet.org packages do not support out-of-tree builds. They are small, so it does not cost much to duplicate the entire source tree if parallel builds are needed. s6-portable-utils-2.2.2.1/patch-for-solaris0000755000000000000000000000075112443715062015330 0ustar #!/usr/xpg4/bin/sh patchit () { echo '#!/usr/xpg4/bin/sh' > $1.tmp tail -n +2 $1 >> $1.tmp mv -f $1.tmp $1 chmod 755 $1 } # Solaris doesn't understand POSIX.1-2008 either. sed -e 's/XOPEN_SOURCE=700/XOPEN_SOURCE=600/' < configure > configure.tmp mv -f configure.tmp configure patchit ./configure patchit ./tools/install.sh patchit ./tools/gen-deps.sh echo 'SHELL := /usr/xpg4/bin/sh' > Makefile.tmp echo >> Makefile.tmp cat Makefile >> Makefile.tmp mv -f Makefile.tmp Makefile s6-portable-utils-2.2.2.1/README0000644000000000000000000000136613553367227012741 0ustar s6-portable-utils - tiny general Unix utilities ----------------------------------------------- s6-portable-utils is a set of tiny general Unix utilities, some performing well-known tasks such as cut and grep, others being nonstandard but useful in a variety of scripting situations; they have been optimized for simplicity and small size. They were designed for embedded systems and other constrained environments, but they work everywhere. See https://skarnet.org/software/s6-portable-utils/ for details. * Installation ------------ See the INSTALL file. * Contact information ------------------- Laurent Bercot Please use the mailing-list for questions about s6-portable-utils. s6-portable-utils-2.2.2.1/src/0000755000000000000000000000000012376727143012641 5ustar s6-portable-utils-2.2.2.1/src/include-local/0000755000000000000000000000000012376727143015354 5ustar s6-portable-utils-2.2.2.1/src/skaembutils/0000755000000000000000000000000013541513366015157 5ustar s6-portable-utils-2.2.2.1/src/skaembutils/seekablepipe.c0000644000000000000000000000220113147033175017744 0ustar /* ISC license. */ #include #include #include #include #define USAGE "seekablepipe tempfile prog..." #define N 8192 int main (int argc, char const *const *argv, char const *const *envp) { iobuffer b ; int fdr, fdw ; int r ; PROG = "seekablepipe" ; if (argc < 3) strerr_dieusage(100, USAGE) ; fdw = open_trunc(argv[1]) ; if (fdw < 0) strerr_diefu2sys(111, "create temporary ", argv[1]) ; fdr = open_readb(argv[1]) ; if (fdr < 0) strerr_diefu3sys(111, "open ", argv[1], " for reading") ; if (unlink(argv[1]) < 0) strerr_diefu2sys(111, "unlink ", argv[1]) ; if (ndelay_off(fdw) < 0) strerr_diefu1sys(111, "set fdw blocking") ; if (!iobuffer_init(&b, 0, fdw)) strerr_diefu1sys(111, "iobuffer_init") ; while ((r = iobuffer_fill(&b)) > 0) if (!iobuffer_flush(&b)) strerr_diefu2sys(111, "write to ", argv[1]) ; if (r < 0) strerr_diefu1sys(111, "read from stdin") ; iobuffer_finish(&b) ; fd_close(fdw) ; if (fd_move(0, fdr) < 0) strerr_diefu1sys(111, "move fdr to stdin") ; xpathexec_run(argv[2], argv+2, envp) ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-hiercopy.c0000644000000000000000000000061512472731024017470 0ustar /* ISC license. */ #include #include #include #define USAGE "s6-hiercopy src dst" int main (int argc, char const *const *argv) { PROG = "s6-hiercopy" ; if (argc < 3) strerr_dieusage(100, USAGE) ; umask(0) ; if (!hiercopy(argv[1], argv[2])) strerr_diefu4sys(111, "copy hierarchy from ", argv[1], " to ", argv[2]) ; return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-quote.c0000644000000000000000000000277313061734213017010 0ustar /* ISC license. */ #include #include #include #include #include #include #define USAGE "s6-quote [ -n ] [ -u ] [ -d delim ] string" int main (int argc, char const *const *argv) { stralloc sa = STRALLOC_ZERO ; char const *delim = "\"" ; size_t delimlen ; size_t startquote = 1 ; int nl = 1 ; PROG = "s6-quote" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "nud:", &l) ; if (opt == -1) break ; switch (opt) { case 'n' : nl = 0 ; break ; case 'u' : startquote = 0 ; break ; case 'd': delim = l.arg ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (!argc) strerr_dieusage(100, USAGE) ; delimlen = strlen(delim) ; if (startquote) { if (!delimlen) strerr_dief1x(100, "no character to quote with!") ; if (!stralloc_catb(&sa, delim, 1)) strerr_diefu1sys(111, "stralloc_catb") ; } if (!string_quote_nodelim_mustquote(&sa, *argv, strlen(*argv), delim, delimlen)) strerr_diefu1sys(111, "quote") ; if (startquote) { if (!stralloc_catb(&sa, delim, 1)) strerr_diefu1sys(111, "stralloc_catb") ; } if (nl) { if (!stralloc_catb(&sa, "\n", 1)) strerr_diefu1sys(111, "stralloc_catb") ; } if (allwrite(1, sa.s, sa.len) < sa.len) strerr_diefu1sys(111, "write to stdout") ; return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-grep.c0000644000000000000000000000667113465464232016622 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-grep [ -E | -F ] [ -i ] [ -c ] [ -n ] [ -q ] [ -v ] pattern" #define dieusage() strerr_dieusage(100, USAGE) typedef struct flags_s flags_t, *flags_t_ref ; struct flags_s { unsigned int extended : 1 ; unsigned int ignorecase: 1 ; unsigned int fixed : 1 ; unsigned int count : 1 ; unsigned int num : 1 ; unsigned int quiet : 1 ; unsigned int not : 1 ; } ; #define FLAGS_ZERO { .extended = 0, .ignorecase = 0, .fixed = 0, .count = 0, .num = 0, .quiet = 0, .not = 0 } static void xout (char const *s, size_t len) { if (buffer_put(buffer_1, s, len) < 0) strerr_diefu1sys(111, "write to stdout") ; } int main (int argc, char const *const *argv) { unsigned int count = 0 ; flags_t flags = FLAGS_ZERO ; PROG = "s6-grep" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "EFicnqv", &l) ; if (opt == -1) break ; switch (opt) { case 'E': flags.extended = 1 ; break ; case 'F': flags.fixed = 1 ; break ; case 'i': flags.ignorecase = 1 ; break ; case 'c': flags.count = 1 ; break ; case 'n': flags.num = 1 ; break ; case 'q': flags.quiet = 1 ; break ; case 'v': flags.not = 1 ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; } if (!argc) dieusage() ; { stralloc line = STRALLOC_ZERO ; regex_t re ; unsigned int num = 0 ; size_t arglen = strlen(argv[0]) ; if (!flags.fixed) { int e = skalibs_regcomp(&re, argv[0], REG_NOSUB | (flags.extended ? REG_EXTENDED : 0) | (flags.ignorecase ? REG_ICASE : 0)) ; if (e) { char buf[256] ; regerror(e, &re, buf, 256) ; strerr_diefu2x(111, "compile regular expression: ", buf) ; } } for (;;) { int r ; line.len = 0 ; r = skagetln(buffer_0f1, &line, '\n') ; if (!r) break ; if (r < 0) { if ((errno != EPIPE) || !stralloc_catb(&line, "\n", 1)) strerr_diefu1sys(111, "read from stdin") ; } num++ ; line.s[line.len-1] = 0 ; if (flags.fixed) { if (flags.ignorecase) r = case_str(line.s, argv[0]) >= arglen ; else r = !strstr(line.s, argv[0]) ; } else { r = regexec(&re, line.s, 0, 0, 0) ; if (r && r != REG_NOMATCH) { char buf[256] ; regerror(r, &re, buf, 256) ; strerr_diefu2x(111, "match regular expression: ", buf) ; } } line.s[line.len-1] = '\n' ; if (!r ^ flags.not) { count++ ; if (!flags.quiet && !flags.count) { if (flags.num) { char fmt[UINT_FMT] ; size_t n = uint_fmt(fmt, num) ; fmt[n++] = ':' ; xout(fmt, n) ; } xout(line.s, line.len) ; } } } if (flags.quiet) return !count ; stralloc_free(&line) ; if (!flags.fixed) regfree(&re) ; } if (flags.count) { char fmt[UINT_FMT] ; size_t n = uint_fmt(fmt, count) ; fmt[n++] = '\n' ; xout(fmt, n) ; } return !count ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-linkname.c0000644000000000000000000000211013061734212017431 0ustar /* ISC license. */ #include #include #include #include #include #define USAGE "s6-linkname [ -n ] [ -f ] link" #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv) { stralloc sa = STRALLOC_ZERO ; int path = 0, nl = 1 ; PROG = "s6-linkname" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "nf", &l) ; if (opt == -1) break ; switch(opt) { case 'n' : nl = 0 ; break ; case 'f' : path = 1 ; break ; default : dieusage() ; } } argv += l.ind ; argc -= l.ind ; } if (!argc) dieusage() ; if ((path ? sarealpath(&sa, *argv) : sareadlink(&sa, *argv)) < 0) strerr_diefu2sys(111, "resolve ", *argv) ; if ((buffer_put(buffer_1small, sa.s, sa.len) < 0) || (nl && (buffer_put(buffer_1small, "\n", 1)) < 0) || (!buffer_flush(buffer_1small))) strerr_diefu1sys(111, "write to stdout") ; /* stralloc_free(&sa) ; */ return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-false.c0000644000000000000000000000011213061734212016725 0ustar /* ISC license. */ #include int main (void) { _exit(1) ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-ls.c0000644000000000000000000000270713061734212016265 0ustar /* ISC license. */ #include #include #include #include #include #define USAGE "s6-ls [ -0 ] [ -a | -A ] [ -x exclude ] dir" int main (int argc, char const *const *argv) { unsigned int all = 0 ; char const *exclude = 0 ; char delim = '\n' ; PROG = "s6-ls" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "0aAx:", &l) ; if (opt == -1) break ; switch (opt) { case '0': delim = '\0' ; break ; case 'a': all = 1 ; break ; case 'A': all = 2 ; break ; case 'x': exclude = l.arg ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (!argc) strerr_dieusage(100, USAGE) ; { direntry *d ; DIR *dir = opendir(*argv) ; if (!dir) strerr_diefu2sys(111, "open directory ", *argv) ; while ((d = readdir(dir))) { if ((d->d_name[0] == '.') && (all < 2)) { if (!all || !d->d_name[1] || ((d->d_name[1] == '.') && !d->d_name[2])) continue ; } if (exclude && !strcmp(exclude, d->d_name)) continue ; if ((buffer_puts(buffer_1, d->d_name) < 0) || (buffer_put(buffer_1, &delim, 1) < 0)) strerr_diefu1sys(111, "write to stdout") ; } dir_close(dir) ; } if (!buffer_flush(buffer_1)) strerr_diefu1sys(111, "write to stdout") ; return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-ln.c0000644000000000000000000000675613402756175016303 0ustar /* ISC license. */ #include #ifdef SKALIBS_HASLINKAT #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-ln [ -n ] [ -s ] [ -f ] [ -L ] [ -P ] src... dest" #define SUFFIX ":s6-ln:XXXXXX" #ifdef SKALIBS_HASLINKAT static int linknoderef (char const *old, char const *new) { return linkat(AT_FDCWD, old, AT_FDCWD, new, 0) ; } static int linkderef (char const *old, char const *new) { return linkat(AT_FDCWD, old, AT_FDCWD, new, AT_SYMLINK_FOLLOW) ; } #else /* can't implement SUSv4, default to link */ # define linknoderef link # define linkderef link #endif static void doit (char const *old, char const *new, linkfunc_t_ref mylink, int force) { if ((*mylink)(old, new) == -1) { if (!force || errno != EEXIST) strerr_diefu5sys(111, "make a link", " from ", new, " to ", old) ; { size_t newlen = strlen(new) ; char fn[newlen + sizeof(SUFFIX)] ; memcpy(fn, new, newlen) ; memcpy(fn + newlen, SUFFIX, sizeof(SUFFIX)) ; if (mklinktemp(old, fn, mylink) == -1) strerr_diefu3sys(111, "make a link", " to ", old) ; if (rename(fn, new) == -1) { unlink_void(fn) ; strerr_diefu2sys(111, "atomically replace ", new) ; } /* if old == new, rename() didn't remove fn */ unlink_void(fn) ; } } } int main (int argc, char const *const *argv) { linkfunc_t_ref mylink = &link ; /* default to system behaviour */ int force = 0 ; int nodir = 0 ; PROG = "s6-ln" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "nsfLP", &l) ; if (opt == -1) break ; switch (opt) { case 'n' : nodir = 1 ; break ; case 's': mylink = &symlink ; break ; case 'f': force = 1 ; break ; case 'L': if (mylink != &symlink) mylink = &linkderef ; break ; case 'P': if (mylink != &symlink) mylink = &linknoderef ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (argc < 2) strerr_dieusage(100, USAGE) ; if (argc > 2) { stralloc sa = STRALLOC_ZERO ; unsigned int i = 0 ; size_t base ; if (!stralloc_cats(&sa, argv[argc-1]) || !stralloc_catb(&sa, "/", 1)) strerr_diefu1sys(111, "stralloc_cats") ; base = sa.len ; for (; i < (unsigned int)(argc-1) ; i++) { sa.len = base ; if (!sabasename(&sa, argv[i], strlen(argv[i]))) strerr_diefu1sys(111, "sabasename") ; if (!stralloc_0(&sa)) strerr_diefu1sys(111, "stralloc_0") ; doit(argv[i], sa.s, mylink, force) ; } return 0 ; } { struct stat st ; if (nodir ? lstat(argv[1], &st) : stat(argv[1], &st) < 0) { if (errno != ENOENT) strerr_diefu2sys(111, "stat ", argv[1]) ; doit(argv[0], argv[1], mylink, force) ; return 0 ; } if (!S_ISDIR(st.st_mode)) { doit(argv[0], argv[1], mylink, force) ; return 0 ; } } { stralloc sa = STRALLOC_ZERO ; if (!stralloc_cats(&sa, argv[1]) || !stralloc_catb(&sa, "/", 1) || !sabasename(&sa, argv[0], strlen(argv[0])) || !stralloc_0(&sa)) strerr_diefu1sys(111, "stralloc_catb") ; doit(argv[0], sa.s, mylink, force) ; } return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-true.c0000644000000000000000000000011213061734213016613 0ustar /* ISC license. */ #include int main (void) { _exit(0) ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-seq.c0000644000000000000000000000314213061734213016432 0ustar /* ISC license. */ #include #include #include #include #include #define USAGE "s6-seq [ -w ] [ -s separator ] limits" #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv) { char const *sep = "\n" ; size_t fixed = 0, seplen = 1 ; unsigned int i = 1, increment = 1, last ; char fmt[UINT_FMT] ; PROG = "s6-seq" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "ws:", &l) ; if (opt == -1) break ; switch (opt) { case 'w': fixed = 1 ; break ; case 's': sep = l.arg ; seplen = strlen(sep) ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; } switch (argc) { case 1 : if (!uint0_scan(argv[0], &last)) dieusage() ; break ; case 2 : if (!uint0_scan(argv[0], &i) || !uint0_scan(argv[1], &last)) dieusage() ; break ; case 3 : if (!uint0_scan(argv[0], &i) || !uint0_scan(argv[1], &increment) || !uint0_scan(argv[2], &last)) dieusage() ; break ; default : dieusage() ; } if (!seplen) seplen = 1 ; if (fixed) fixed = uint_fmt(0, i + increment * ((last - i) / increment)) ; for (; i <= last ; i += increment) { if (buffer_put(buffer_1, fmt, fixed ? (uint0_fmt(fmt, i, fixed), fixed) : uint_fmt(fmt, i)) < 0) goto err ; if (buffer_put(buffer_1, sep, seplen) < 0) goto err ; } if (!buffer_flush(buffer_1)) goto err ; return 0 ; err: strerr_diefu1sys(111, "write to stdout") ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-unquote-filter.c0000644000000000000000000001134613061734213020632 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #define USAGE "s6-unquote-filter [ -q | -Q | -v | -w ] [ -d delim ]" static unsigned int strictness = 1 ; static char const *delim = "\"" ; static size_t delimlen = 1 ; static void fillfmt (char *fmt, char const *s, size_t len) { size_t n = len < 39 ? len+1 : 36 ; memcpy(fmt, s, n) ; if (len >= 39) { memcpy(fmt+n, "...", 3) ; n += 3 ; } fmt[n] = 0 ; } static int doit (char const *s, size_t len) { if (delimlen) { if (!len) { switch (strictness) { case 1 : case 2 : strerr_warnw1x("empty line") ; break ; case 3 : buffer_flush(buffer_1) ; strerr_dief1x(100, "empty line") ; default : break ; } return 1 ; } if (!memchr(delim, delimlen, *s)) { switch (strictness) { case 0 : return 0 ; case 1 : { strerr_warnw1x("invalid starting quote character") ; return 0 ; } case 2 : { char fmt[40] ; fillfmt(fmt, s, len) ; strerr_warnw3x("invalid starting quote character", " in line: ", fmt) ; return 0 ; } case 3 : { buffer_flush(buffer_1) ; strerr_dief1x(100, "invalid starting quote character") ; } default : strerr_dief1x(101, "can't happen: unknown strictness") ; } } } { size_t r, w ; char d[len] ; if (!string_unquote_withdelim(d, &w, s + !!delimlen, len - !!delimlen, &r, delim, delimlen)) { switch (strictness) { case 0 : return 0 ; case 1 : { strerr_warnwu1sys("unquote") ; return 0 ; } case 2 : { char fmt[40] ; fillfmt(fmt, s, len) ; strerr_warnwu3sys("unquote", " line: ", fmt) ; return 0 ; } case 3 : { int e = errno ; buffer_flush(buffer_1) ; errno = e ; strerr_diefu1sys(100, "unquote") ; } default : strerr_dief1x(101, "can't happen: unknown strictness") ; } } if (delimlen) { if (r+1 == len) { switch (strictness) { case 0 : return 0 ; case 1 : { strerr_warnwu2x("unquote", ": no ending quote character") ; return 0 ; } case 2 : { char fmt[40] ; fillfmt(fmt, s, len) ; strerr_warnwu5x("unquote", ": no ending quote character", " in ", "line: ", fmt) ; return 0 ; } case 3 : { int e = errno ; buffer_flush(buffer_1) ; errno = e ; strerr_diefu2x(100, "unquote", ": no ending quote character") ; } default : strerr_dief1x(101, "can't happen: unknown strictness") ; } } else if ((r+2 < len) && (strictness >= 2)) { char fmtnum[SIZE_FMT] ; char fmtden[SIZE_FMT] ; char fmt[40] ; fillfmt(fmt, s, len) ; fmtnum[size_fmt(fmtnum, r+1)] = 0 ; fmtden[size_fmt(fmtden, len-1)] = 0 ; strerr_warnw7x("found ending quote character at position ", fmtnum, "/", fmtden, ", ignoring remainder of ", "line: ", fmt) ; } } if (buffer_put(buffer_1, d, w) < (ssize_t)w) strerr_diefu1sys(111, "write to stdout") ; } return 1 ; } int main (int argc, char const *const *argv) { stralloc src = STRALLOC_ZERO ; PROG = "s6-unquote-filter" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "qQvwd:", &l) ; if (opt == -1) break ; switch (opt) { case 'q': strictness = 0 ; break ; case 'Q': strictness = 1 ; break ; case 'v': strictness = 2 ; break ; case 'w': strictness = 3 ; break ; case 'd': delim = l.arg ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } delimlen = strlen(delim) ; for (;;) { int r ; src.len = 0 ; r = skagetln(buffer_0f1, &src, '\n') ; if (!r) break ; if (r < 0) { if (errno != EPIPE) strerr_diefu1sys(111, "read from stdin") ; } else src.len-- ; if (!doit(src.s, src.len)) { if (buffer_put(buffer_1, src.s, src.len) < (ssize_t)src.len) strerr_diefu1sys(111, "write to stdout") ; } if (r > 0) { if (buffer_put(buffer_1, "\n", 1) < 1) strerr_diefu1sys(111, "write to stdout") ; } } return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-sync.c0000644000000000000000000000012513061734213016614 0ustar /* ISC license. */ #include int main (void) { sync() ; _exit(0) ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-basename.c0000644000000000000000000000221413061734212017413 0ustar /* ISC license. */ #include #include #include #include #include #include #define USAGE "s6-basename [ -n ] file [ suffix ]" int main (int argc, char const *const *argv) { stralloc sa = STRALLOC_ZERO ; int nl = 1 ; PROG = "s6-basename" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "n", &l) ; if (opt == -1) break ; switch (opt) { case 'n' : nl = 0 ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (!argc) strerr_dieusage(100, USAGE) ; if (!sabasename(&sa, argv[0], strlen(argv[0]))) strerr_diefu2sys(111, "get basename of ", argv[0]) ; if (argc >= 2) { size_t n = strlen(argv[1]) ; if ((n < sa.len) && !strncmp(argv[1], sa.s + sa.len - n, n)) sa.len -= n ; } if (nl && !stralloc_catb(&sa, "\n", 1)) strerr_diefu2sys(111, "get basename of ", argv[0]) ; if (allwrite(1, sa.s, sa.len) < sa.len) strerr_diefu1sys(111, "write to stdout") ; return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-printenv.c0000644000000000000000000000240013061734212017502 0ustar /* ISC license. */ #include #include #include #include #include #define USAGE "s6-printenv [ -n ] [ -0 | -d delimchar ]" int main (int argc, char const *const *argv, char const *const *envp) { char delim = '\n' ; int zero = 0, nl = 1 ; PROG = "s6-printenv" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "nd:0", &l) ; if (opt == -1) break ; switch (opt) { case 'n' : nl = 0 ; break ; case 'd' : delim = *l.arg ; break ; case '0' : zero = 1 ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (zero) delim = 0 ; for (; *envp ; envp++) { if (delim || zero) { if ((buffer_puts(buffer_1, *envp) < 0) || ((nl || envp[1]) && (buffer_put(buffer_1, &delim, 1) < 0))) strerr_diefu1sys(111, "write to stdout") ; } else { size_t written = 0 ; if (!netstring_put(buffer_1, *envp, strlen(*envp), &written)) strerr_diefu1sys(111, "write a netstring to stdout") ; } } if (!buffer_flush(buffer_1)) strerr_diefu1sys(111, "write to stdout") ; return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-env.c0000644000000000000000000000212513147040702016430 0ustar /* ISC license. */ #include #include #include #include #include #include #include #define USAGE "s6-env [ -i ] [ name=value... ] prog..." int main (int argc, char const *const *argv, char const *const *envp) { stralloc modifs = STRALLOC_ZERO ; char const *arg_zero[2] = { S6_PORTABLE_UTILS_BINPREFIX "s6-printenv", 0 } ; char const *env_zero[1] = { 0 } ; PROG = "s6-env" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "i", &l) ; if (opt == -1) break ; switch (opt) { case 'i': envp = env_zero ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } for (; argc ; argc--, argv++) { if (!strchr(*argv, '=')) break ; if (!stralloc_cats(&modifs, *argv) || !stralloc_0(&modifs)) strerr_diefu1sys(111, "stralloc_cats") ; } if (!argc) argv = arg_zero ; xpathexec_r(argv, envp, env_len(envp), modifs.s, modifs.len) ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-rmrf.c0000644000000000000000000000056412376732547016635 0ustar /* ISC license. */ #include #include #define USAGE "s6-rmrf file ..." int main (int argc, char const *const *argv) { char const *const *p = argv + 1 ; PROG = "s6-rmrf" ; if (argc < 2) strerr_dieusage(100, USAGE) ; for (; *p ; p++) if (rm_rf(*p) == -1) strerr_diefu2sys(111, "remove ", argv[1]) ; return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-chown.c0000644000000000000000000000252613220061647016766 0ustar /* ISC license. */ #include #include #include #include #include #include #define USAGE "s6-chown [ -U ] [ -u uid ] [ -g gid ] file" int main (int argc, char const *const *argv) { uid_t uid = -1 ; gid_t gid = -1 ; PROG = "s6-chown" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "Uu:g:", &l) ; if (opt == -1) break ; switch (opt) { case 'u': { if (!uid0_scan(l.arg, &uid)) strerr_dieusage(100, USAGE) ; break ; } case 'g': { if (!gid0_scan(l.arg, &gid)) strerr_dieusage(100, USAGE) ; break ; } case 'U': { char const *s = getenv("UID") ; if (!s) strerr_dienotset(100, "UID") ; if (!uid0_scan(s, &uid)) strerr_dieinvalid(100, "UID") ; s = getenv("GID") ; if (!s) strerr_dienotset(100, "GID") ; if (!gid0_scan(s, &gid)) strerr_dieinvalid(100, "GID") ; break ; } default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (!argc) strerr_dieusage(100, USAGE) ; if (chown(*argv, uid, gid) == -1) strerr_diefu2sys(111, "chown ", argv[0]) ; return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-format-filter.c0000644000000000000000000000273013061734212020416 0ustar /* ISC license. */ #include #include #include #include #include #define USAGE "s6-format-filter format [ args... ]" int main (int argc, char const *const *argv) { stralloc src = STRALLOC_ZERO ; stralloc dst = STRALLOC_ZERO ; char vars[12] = "s0123456789" ; char const *args[12] = { "" } ; char const *format ; PROG = "s6-format-filter" ; argc-- ; args[1] = *argv++ ; if (!argc--) strerr_dieusage(100, USAGE) ; format = *argv++ ; if (argc > 9) argc = 9 ; vars[argc+2] = 0 ; { unsigned int i = 0 ; for (; i < (unsigned int)argc ; i++) args[2+i] = argv[i] ; } if (!string_format(&dst, vars, format, args)) strerr_diefu1sys(111, "compile format") ; for (;;) { int r ; src.len = 0 ; dst.len = 0 ; r = skagetln(buffer_0f1, &src, '\n') ; if (!r) break ; else if (r < 0) { if ((errno != EPIPE) || !stralloc_0(&src)) strerr_diefu1sys(111, "read from stdin") ; } else src.s[src.len-1] = 0 ; args[0] = src.s ; if (!string_format(&dst, vars, format, args)) { int e = errno ; buffer_flush(buffer_1) ; errno = e ; strerr_diefu1sys(111, "format") ; } if (r > 0) { if (!stralloc_catb(&dst, "\n", 1)) strerr_diefu1sys(111, "format") ; } if (buffer_put(buffer_1, dst.s, dst.len) < 0) strerr_diefu1sys(111, "write to stdout") ; } return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-maximumtime.c0000644000000000000000000000543013534433773020214 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-maximumtime [ -0 | -a | -b | -i | -k | -q | -t | -x | -1 | -2 ] milliseconds prog..." int main (int argc, char const *const *argv, char const *const *envp) { tain_t deadline ; iopause_fd x[1] = { { .fd = -1, .events = IOPAUSE_READ, .revents = 0 } } ; pid_t pid = 0 ; int tosend = SIGTERM ; unsigned int timeout ; PROG = "s6-maximumtime" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "0abikqtx12", &l) ; if (opt == -1) break ; switch (opt) { case '0': tosend = 0 ; break ; case 'a': tosend = SIGALRM ; break ; case 'b': tosend = SIGABRT ; break ; case 'i': tosend = SIGINT ; break ; case 'k': tosend = SIGKILL ; break ; case 'q': tosend = SIGQUIT ; break ; case 't': tosend = SIGTERM ; break ; case 'x': tosend = SIGXCPU ; break ; case '1': tosend = SIGUSR1 ; break ; case '2': tosend = SIGUSR2 ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if ((argc < 2) || !uint0_scan(argv[0], &timeout)) strerr_dieusage(100, USAGE) ; if (timeout) tain_from_millisecs(&deadline, timeout) ; else deadline = tain_infinite_relative ; x[0].fd = selfpipe_init() ; if (x[0].fd < 0) strerr_diefu1sys(111, "selfpipe_init") ; if (selfpipe_trap(SIGCHLD) < 0) strerr_diefu1sys(111, "selfpipe_trap") ; pid = child_spawn0(argv[1], argv+1, envp) ; if (!pid) strerr_diefu2sys(111, "spawn ", argv[1]) ; tain_now_set_stopwatch_g() ; tain_add_g(&deadline, &deadline) ; for (;;) { int r = iopause_g(x, 1, &deadline) ; if (r < 0) strerr_diefu1sys(111, "iopause") ; if (!r) break ; if (x[0].revents & IOPAUSE_READ) { int cont = 1 ; while (cont) { switch (selfpipe_read()) { case -1 : strerr_diefu1sys(111, "selfpipe_read") ; case 0 : cont = 0 ; break ; case SIGCHLD : { int wstat ; if (wait_pid_nohang(pid, &wstat) == pid) { if (WIFSIGNALED(wstat)) strerr_diew1x(111, "child process crashed") ; else return WEXITSTATUS(wstat) ; } } default : strerr_diefu1x(101, "internal error, please submit a bug-report.") ; } } } } kill(pid, tosend) ; errno = ETIMEDOUT ; strerr_diewu1sys(99, "wait for child process") ; } s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/0000755000000000000000000000000013540723124016663 5ustar s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-uniquename0000644000000000000000000000005013540723124021276 0ustar -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-mkdir0000644000000000000000000000001212376726104020242 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-format-filter0000644000000000000000000000001212376726104021707 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-quote-filter0000644000000000000000000000001212376726104021554 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-touch0000644000000000000000000000001212376726104020256 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-cut0000644000000000000000000000001212376726104017727 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-grep0000644000000000000000000000001212376726104020071 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-env0000644000000000000000000000001212376726104017724 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-echo0000644000000000000000000000001212504642611020043 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-sort0000644000000000000000000000001212376726104020123 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-dumpenv0000644000000000000000000000001212474611321020603 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-rmrf0000644000000000000000000000001212376726104020102 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-update-symlinks0000644000000000000000000000005013540723124022260 0ustar -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-rename0000644000000000000000000000001212376726104020403 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-mkfifo0000644000000000000000000000001212376726104020407 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-chmod0000644000000000000000000000001212376726104020226 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-chown0000644000000000000000000000001212376726104020252 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-pause0000644000000000000000000000001212476367376020266 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-unquote-filter0000644000000000000000000000001212376726104022117 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-ls0000644000000000000000000000001212376726104017552 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-clock0000644000000000000000000000003212376726104020231 0ustar -lskarnet ${SYSCLOCK_LIB} s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-nuke0000644000000000000000000000001212376726104020076 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-head0000644000000000000000000000001212376726104020035 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-hiercopy0000644000000000000000000000001212472717713020761 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-nice0000644000000000000000000000001212376726104020052 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-tail0000644000000000000000000000001212376726104020065 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-ln0000644000000000000000000000005013540723124017540 0ustar -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-cat0000644000000000000000000000001212376726104017703 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-sleep0000644000000000000000000000003213540723124020237 0ustar -lskarnet ${SYSCLOCK_LIB} s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-false0000644000000000000000000000000012376726104020223 0ustar s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-unquote0000644000000000000000000000001212376726104020634 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-maximumtime0000644000000000000000000000004713540723124021471 0ustar -lskarnet ${SYSCLOCK_LIB} ${SPAWN_LIB} s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-printenv0000644000000000000000000000001212376726104021001 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-seq0000644000000000000000000000001212522154531017714 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/seekablepipe0000644000000000000000000000001212456007776021245 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-true0000644000000000000000000000000012376726104020110 0ustar s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-basename0000644000000000000000000000001212376726104020707 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-linkname0000644000000000000000000000001212376726104020732 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-test0000644000000000000000000000001212376726104020113 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-sync0000644000000000000000000000000012376726104020105 0ustar s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-quote0000644000000000000000000000001212376726104020271 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-expr0000644000000000000000000000001212376726104020112 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/deps-exe/s6-dirname0000644000000000000000000000001212376726104020553 0ustar -lskarnet s6-portable-utils-2.2.2.1/src/skaembutils/s6-dumpenv.c0000644000000000000000000000311613132710710017314 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #define USAGE "s6-dumpenv [ -m mode ] envdir" #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv, char const *const *envp) { unsigned int mode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH ; size_t dirlen ; PROG = "s6-dumpenv" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "m:", &l) ; if (opt == -1) break ; switch (opt) { case 'm' : if (!uint0_oscan(l.arg, &mode)) dieusage() ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; } if (!argc) dieusage() ; if (mkdir(argv[0], mode) < 0) { struct stat st ; if (errno != EEXIST) strerr_diefu2sys(111, "mkdir ", argv[0]) ; if (stat(argv[0], &st) < 0) strerr_diefu2sys(111, "stat ", argv[0]) ; if (!S_ISDIR(st.st_mode)) { errno = ENOTDIR ; strerr_diefu2sys(111, "mkdir ", argv[0]) ; } } dirlen = strlen(argv[0]) ; for (; *envp ; envp++) { size_t varlen = str_chr(*envp, '=') ; char fn[dirlen + varlen + 2] ; memcpy(fn, argv[0], dirlen) ; fn[dirlen] = '/' ; memcpy(fn + dirlen + 1, *envp, varlen) ; fn[dirlen + 1 + varlen] = 0 ; if (!openwritenclose_suffix(fn, *envp + varlen + 1, strlen(*envp + varlen + 1), "=.tmp")) strerr_diefu2sys(111, "open ", fn) ; } return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-head.c0000644000000000000000000000744413061734212016553 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-head [ -S ] [ -1..9 | -n lines | -c chars ] [ file... ]" #define dieusage() strerr_dieusage(100, USAGE) typedef int headfunc_t (int, size_t) ; typedef headfunc_t *headfunc_t_ref ; static int dolines (int fd, size_t lines) { char buf[BUFFER_INSIZE] ; buffer in = BUFFER_INIT(&buffer_read, fd, buf, BUFFER_INSIZE) ; buffer out = BUFFER_INIT(&buffer_write, 1, buf, BUFFER_INSIZE) ; struct iovec v[2] ; while (lines) { size_t w = 0 ; ssize_t r = buffer_fill(&in) ; if (r <= 0) return !r ; out.c.n = in.c.n ; out.c.p = in.c.p ; buffer_rpeek(&in, v) ; for (;;) { size_t n = siovec_len(v, 2) ; size_t i ; if (!n) break ; i = siovec_bytechr(v, 2, '\n') ; if (i < n) { w += i+1 ; siovec_seek(v, 2, i+1) ; if (!--lines) { out.c.n = (out.c.p + w) % out.c.a ; break ; } } else siovec_seek(v, 2, i) ; } if (!buffer_flush(&out)) return 0 ; in.c.n = out.c.n ; in.c.p = out.c.p ; } return 1 ; } static int safedolines (int fd, size_t lines) { char tmp[lines] ; while (lines) { size_t r = allread(fd, tmp, lines) ; if ((r < lines) && (errno != EPIPE)) return 0 ; lines -= byte_count(tmp, r, '\n') ; if (buffer_put(buffer_1, tmp, r) < (ssize_t)r) return 0 ; } if (!buffer_flush(buffer_1)) return 0 ; return 1 ; } static int safedochars (int fd, size_t chars) { return (fd_catn(fd, 1, chars) >= chars) ; } int main (int argc, char const *const *argv) { headfunc_t_ref f ; unsigned int lines = 10 ; int islines = 1, safe = 0 ; PROG = "s6-head" ; { subgetopt_t l = SUBGETOPT_ZERO ; int done = 0 ; for (;;) { int opt = subgetopt_r(argc, argv, "S123456789n:c:", &l) ; if (opt == -1) break ; switch (opt) { case 'S' : safe = 1 ; break ; case '1' : case '2' : case '3' : case '4' : case '5' : case '6' : case '7' : case '8' : case '9' : { if (done) dieusage() ; islines = 1 ; lines = opt - '0' ; done = 1 ; break ; } case 'n' : { if (done || !uint0_scan(l.arg, &lines)) strerr_dieusage(100, USAGE) ; islines = 1 ; done = 1 ; break ; } case 'c' : { if (done || !uint0_scan(l.arg, &lines)) strerr_dieusage(100, USAGE) ; islines = 0 ; done = 1 ; break ; } default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (argc) safe = 0 ; f = islines ? safe ? &safedolines : &dolines : &safedochars ; if (!argc) { if (!(*f)(0, lines)) strerr_diefu1sys(111, "head stdin") ; } else { unsigned int i = 0 ; for (; argv[i] ; i++) { int fd ; if (argc >= 2) { if (i) buffer_putnoflush(buffer_1, "\n", 1) ; buffer_putnoflush(buffer_1, "==> ", 4) ; if ((buffer_puts(buffer_1, argv[i]) <= 0) || (buffer_putflush(buffer_1, " <==\n", 5) < 0)) strerr_diefu1sys(111, "write to stdout") ; } if ((argv[i][0] == '-') && !argv[i][1]) fd = 0 ; else fd = open_readb(argv[i]) ; if (fd == -1) strerr_diefu3sys(111, "open ", argv[i], " for reading") ; if (!(*f)(fd, lines)) strerr_diefu2sys(111, "head ", argv[i]) ; fd_close(fd) ; } } return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-touch.c0000644000000000000000000000054112710166721016767 0ustar /* ISC license. */ #include #include #define USAGE "s6-touch file ..." int main (int argc, char const *const *argv) { char const *const *p = argv + 1 ; PROG = "s6-touch" ; if (argc < 2) strerr_dieusage(100, USAGE) ; for (; *p ; p++) if (!touch(*p)) strerr_diefu2sys(111, "touch ", *p) ; return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-nuke.c0000644000000000000000000000167213061734212016611 0ustar /* ISC license. */ #include #include #include #include #include #define USAGE "s6-nuke [ -h | -t | -k ]" int main (int argc, char const *const *argv) { int doterm = 0, dohangup = 0, dokill = 0 ; PROG = "s6-nuke" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "htk", &l) ; if (opt == -1) break ; switch (opt) { case 'h': dohangup = 1 ; break ; case 't': doterm = 1 ; break ; case 'k': dokill = 1 ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (dohangup) { sig_ignore(SIGHUP) ; kill(-1, SIGHUP) ; } if (doterm) { sig_ignore(SIGTERM) ; kill(-1, SIGTERM) ; kill(-1, SIGCONT) ; } if (dokill) kill(-1, SIGKILL) ; if (errno) strerr_diefu1sys(111, "kill") ; return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-rename.c0000644000000000000000000000052213061734213017110 0ustar /* ISC license. */ #include #include #define USAGE "s6-rename old new" int main (int argc, char const *const *argv) { PROG = "s6-rename" ; if (argc < 3) strerr_dieusage(100, USAGE) ; if (rename(argv[1], argv[2]) == -1) strerr_diefu4sys(111, "rename ", argv[1], " to ", argv[2]) ; return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-mkfifo.c0000644000000000000000000000155013061734212017115 0ustar /* ISC license. */ #include #include #include #include #include #define USAGE "s6-mkfifo [ -m mode ] fifo..." int main (int argc, char const *const *argv) { unsigned int mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH ; PROG = "s6-mkfifo" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "m:", &l) ; if (opt == -1) break ; switch (opt) { case 'm': if (uint0_oscan(l.arg, &mode)) break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (!argc) strerr_dieusage(100, USAGE) ; umask(S_IXUSR|S_IXGRP|S_IXOTH) ; for (; *argv ; argv++) if (mkfifo(*argv, mode) < 0) strerr_diefu2sys(111, "mkfifo ", *argv) ; return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-expr.c0000644000000000000000000001203013061734212016613 0ustar /* ISC license. */ #include #include #include #include #define USAGE "s6-expr arithmetic expression" #define bail() strerr_dief1x(2, "invalid expression") enum opnum { T_DATA, T_AND, T_OR, T_LEFTP, T_RIGHTP, T_EQUAL, T_NEQUAL, T_GREATER, T_GREATERE, T_LESSER, T_LESSERE, T_PLUS, T_MINUS, T_TIMES, T_DIV, T_MOD } ; struct token { char const *string ; enum opnum op ; unsigned int type ; } ; struct node { enum opnum op ; unsigned int type ; unsigned int arg1 ; unsigned int arg2 ; long data ; } ; static unsigned int lex (struct node *tree, char const *const *argv) { static struct token const tokens[16] = { { "+", T_PLUS, 3 }, { "-", T_MINUS, 3 }, { "*", T_TIMES, 2 }, { "/", T_DIV, 2 }, { "%", T_MOD, 2 }, { "(", T_LEFTP, 7 }, { ")", T_RIGHTP, 8 }, { "=", T_EQUAL, 4 }, { "!=", T_NEQUAL, 4 }, { "<", T_LESSER, 4 }, { "<=", T_LESSERE, 4 }, { ">", T_GREATER, 4 }, { ">=", T_GREATERE, 4 }, { "|", T_OR, 6 }, { "&", T_AND, 5 }, { 0, 0, 0 } } ; unsigned int pos = 0 ; for (; argv[pos] ; pos++) { unsigned int i = 0 ; for (i = 0 ; tokens[i].string ; i++) if (!strcmp(argv[pos], tokens[i].string)) { tree[pos].op = tokens[i].op ; tree[pos].type = tokens[i].type ; break ; } if (!tokens[i].string) { tree[pos].op = T_DATA ; tree[pos].type = 0 ; if (!long_scan(argv[pos], &tree[pos].data)) bail() ; } } return pos ; } static void reduce (struct node *tree, unsigned int *stack, unsigned int *sp, unsigned int type) { if (tree[stack[*sp-1]].type == type) { tree[stack[*sp-1]].arg1 = stack[*sp-2] ; tree[stack[*sp-1]].arg2 = stack[*sp] ; stack[*sp-2] = stack[*sp-1] ; *sp -= 2 ; } tree[stack[*sp]].type = type + 7 ; } static unsigned int parse (struct node *tree, unsigned int n) { static char const table[9][15] = { "xsssssssxzzzzzz", "xxxxxxxx!zzzzzz", "mxxxxxxxMszzzzz", "mxxxxxxxMaszzzz", "mxxxxxxxMacszzz", "mxxxxxxxMacAszz", "mxxxxxxxMacAOsz", "xsssssssxzzzzzz", "mxxxxxxxMacAOEs" } ; unsigned int stack[n] ; unsigned int sp = 0, pos = 0 ; char cont = 1 ; stack[0] = n + 1 ; tree[n].type = 8 ; /* add ) for the final reduce */ tree[n+1].type = 1 ; /* add EOF */ while (cont) { switch (table[tree[pos].type][tree[stack[sp]].type]) { case 'x' : bail() ; case '!' : cont = 0 ; break ; case 's' : stack[++sp] = pos++ ; break ; case 'M' : if (tree[stack[sp-2]].type != 7) bail() ; stack[sp-2] = stack[sp-1] ; sp -= 2 ; case 'm' : reduce(tree, stack, &sp, 2) ; break ; case 'a' : reduce(tree, stack, &sp, 3) ; break ; case 'c' : reduce(tree, stack, &sp, 4) ; break ; case 'A' : reduce(tree, stack, &sp, 5) ; break ; case 'O' : reduce(tree, stack, &sp, 6) ; break ; case 'E' : tree[stack[sp]].type = 14 ; break ; case 'z' : default : strerr_dief1x(101, "internal error in parse, please submit a bug-report.") ; /* can't happen */ } } if (sp != 2) bail() ; return stack[1] ; } static long run (struct node const *tree, unsigned int root) { switch (tree[root].op) { case T_DATA : return tree[root].data ; case T_OR : { long r = run(tree, tree[root].arg1) ; return r ? r : run(tree, tree[root].arg2) ; } case T_AND : { long r = run(tree, tree[root].arg1) ; return r ? run(tree, tree[root].arg2) ? r : 0 : 0 ; } case T_EQUAL : return run(tree, tree[root].arg1) == run(tree, tree[root].arg2) ; case T_NEQUAL : return run(tree, tree[root].arg1) != run(tree, tree[root].arg2) ; case T_GREATER : return run(tree, tree[root].arg1) > run(tree, tree[root].arg2) ; case T_GREATERE : return run(tree, tree[root].arg1) >= run(tree, tree[root].arg2) ; case T_LESSER : return run(tree, tree[root].arg1) < run(tree, tree[root].arg2) ; case T_LESSERE : return run(tree, tree[root].arg1) <= run(tree, tree[root].arg2) ; case T_PLUS : return run(tree, tree[root].arg1) + run(tree, tree[root].arg2) ; case T_MINUS : return run(tree, tree[root].arg1) - run(tree, tree[root].arg2) ; case T_TIMES : return run(tree, tree[root].arg1) * run(tree, tree[root].arg2) ; case T_DIV : return run(tree, tree[root].arg1) / run(tree, tree[root].arg2) ; case T_MOD : return run(tree, tree[root].arg1) % run(tree, tree[root].arg2) ; default : strerr_dief1x(101, "internal error in run, please submit a bug-report") ; } } int main (int argc, char const *const *argv) { char fmt[LONG_FMT] ; long val ; size_t len ; PROG = "s6-expr" ; if (argc <= 1) return 2 ; { struct node tree[argc + 1] ; val = run(tree, parse(tree, lex(tree, argv+1))) ; } len = long_fmt(fmt, val) ; fmt[len++] = '\n' ; if (allwrite(1, fmt, len) < len) strerr_diefu1sys(111, "write to stdout") ; return !val ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-pause.c0000644000000000000000000000264013061734212016760 0ustar /* ISC license. */ #include #include #include #include #include #include #define USAGE "s6-pause [ -t ] [ -h ] [ -a ] [ -q ] [ -b ] [ -i ] [ -p signal,signal... ]" #define dieusage() strerr_dieusage(100, USAGE) #define MAX 64 int main (int argc, char const *const *argv) { PROG = "s6-pause" ; unsigned int sigs[MAX] ; size_t nsig = 0 ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "thaqbip:", &l) ; if (opt == -1) break ; switch (opt) { case 't' : if (nsig >= MAX) dieusage() ; sigs[nsig++] = SIGTERM ; break ; case 'h' : if (nsig >= MAX) dieusage() ; sigs[nsig++] = SIGHUP ; break ; case 'a' : if (nsig >= MAX) dieusage() ; sigs[nsig++] = SIGALRM ; break ; case 'q' : if (nsig >= MAX) dieusage() ; sigs[nsig++] = SIGQUIT ; break ; case 'b' : if (nsig >= MAX) dieusage() ; sigs[nsig++] = SIGABRT ; break ; case 'i' : if (nsig >= MAX) dieusage() ; sigs[nsig++] = SIGINT ; break ; case 'p' : { size_t n ; if (!uint_scanlist(sigs + nsig, MAX - nsig, l.arg, &n)) dieusage() ; nsig += n ; break ; } default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; } while (nsig--) sig_ignore(sigs[nsig]) ; pause() ; return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-cut.c0000644000000000000000000001265313061734212016443 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-cut [ -b list | -c list | -f list ] [ -d delim ] [ -n ] [ -s ] [ file... ]" static int disize_cmpleft (void const *a, void const *b) { return ((disize const *)a)->left - ((disize const *)b)->left ; } static void disizealloc_normalize (genalloc *list) { size_t i = 1, cur = 0 ; size_t len = genalloc_len(disize, list) ; disize *const s = genalloc_s(disize, list) ; qsort(s, len, sizeof(disize), &disize_cmpleft) ; for (; i < len ; i++) if (!s[cur].right) break ; else if (s[i].left > s[cur].right) s[++cur] = s[i] ; else if (s[cur].right < s[i].right) s[cur].right = s[i].right ; genalloc_setlen(disize, list, cur+1) ; } static void scanlist (genalloc *list, char const *s) { size_t i = 0 ; genalloc_setlen(disize, list, 0) ; while (s[i]) { char const sep[4] = ", \t" ; disize iv ; if (s[i] == '-') iv.left = 1 ; else { size_t j = size_scan(s+i, &iv.left) ; if (!j || !iv.left) strerr_dief2x(100, "invalid list argument: ", s) ; i += j ; } if (s[i] != '-') iv.right = iv.left ; else { size_t j = size_scan(s + ++i, &iv.right) ; if (!j) iv.right = 0 ; else if (iv.right < iv.left) strerr_dief2x(100, "invalid list argument: ", s) ; else i += j ; } switch (byte_chr(sep, 4, s[i])) { case 0 : case 1 : case 2 : i++ ; case 3 : break ; case 4 : strerr_dief2x(100, "invalid list argument: ", s) ; } if (!genalloc_append(disize, list, &iv)) strerr_diefu1sys(111, "build interval list") ; } } static int doit (int fd, disize const *s, size_t len, unsigned int flags, char delim) { char buf[BUFFER_INSIZE] ; buffer b = BUFFER_INIT(&buffer_flush1read, fd, buf, BUFFER_INSIZE) ; for (;;) { int r ; satmp.len = 0 ; r = skagetln(&b, &satmp, '\n') ; if ((r == -1) && (errno != EPIPE)) return 0 ; if (!r) break ; if (flags & 2) { size_t i = 0 ; for (; i < len ; i++) { size_t j = s[i].right ; if (s[i].left >= satmp.len) break ; if (!j || (j > satmp.len)) { j = satmp.len ; r = 0 ; } if (buffer_put(buffer_1, satmp.s + s[i].left - 1, j + 1 - s[i].left) == -1) return 0 ; } } else { size_t i = 0, j = 0, count = 1 ; for (; i < len ; i++) { for (; count < s[i].left ; count++) { j += byte_chr(satmp.s + j, satmp.len - j, delim) ; if (j == satmp.len) break ; j++ ; } if (j == satmp.len) { if (count == 1) { if ((flags & 1) && (buffer_put(buffer_1, satmp.s, satmp.len) < 0)) return 0 ; r = 0 ; } break ; } for (; !s[i].right || (count <= s[i].right) ; count++) { size_t k = byte_chr(satmp.s + j, satmp.len - j, delim) ; if ((count > s[0].left) && (buffer_put(buffer_1, &delim, 1) < 0)) return 0 ; if (buffer_put(buffer_1, satmp.s + j, k) < 0) return 0 ; j += k ; if (j == satmp.len) { r = 0 ; break ; } j++ ; } if (j == satmp.len) break ; } } if ((r > 0) && (buffer_put(buffer_1, "\n", 1) < 0)) return 0 ; } return 1 ; } int main (int argc, char const *const *argv) { genalloc list = GENALLOC_ZERO ; /* array of disize */ char delim = '\t' ; unsigned int what = 0 ; PROG = "s6-cut" ; { subgetopt_t l = SUBGETOPT_ZERO ; int flagnodel = 1 ; for (;;) { int opt = subgetopt_r(argc, argv, "nsb:c:f:d:", &l) ; if (opt == -1) break ; switch (opt) { case 'n': break ; /* ignored */ case 's': flagnodel = 0 ; break ; case 'd': delim = *l.arg ; break ; case 'b': case 'c': { if (what) strerr_dieusage(100, USAGE) ; what = 2 ; scanlist(&list, l.arg) ; break ; } case 'f': { if (what) strerr_dieusage(100, USAGE) ; what = 4 ; scanlist(&list, l.arg) ; break ; } default : strerr_dieusage(100, USAGE) ; } } what += flagnodel ; argc -= l.ind ; argv += l.ind ; } if (!genalloc_len(disize, &list)) strerr_dieusage(100, USAGE) ; disizealloc_normalize(&list) ; if (!argc) { if (!doit(0, genalloc_s(disize, &list), genalloc_len(disize, &list), what, delim)) strerr_diefu1sys(111, "cut stdin") ; } else { for (; *argv ; argv++) { if ((argv[0][0] == '-') && !argv[0][1]) { if (!doit(0, genalloc_s(disize, &list), genalloc_len(disize, &list), what, delim)) strerr_diefu1sys(111, "process stdin") ; } else { int fd = open_readb(*argv) ; if (fd == -1) strerr_diefu3sys(111, "open ", *argv, " for reading") ; if (!doit(fd, genalloc_s(disize, &list), genalloc_len(disize, &list), what, delim)) strerr_diefu2sys(111, "cut ", *argv) ; fd_close(fd) ; } } } return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-uniquename.c0000644000000000000000000000232313061734213020011 0ustar /* ISC license. */ #include #include #include #include #include #include #include #define USAGE "s6-uniquename [ -n randomlen ] prefix" #define usage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv) { stralloc sa = STRALLOC_ZERO ; unsigned int n = 8 ; PROG = "s6-uniquename" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "n:", &l) ; if (opt == -1) break ; switch (opt) { case 'n' : if (!uint0_scan(l.arg, &n)) usage() ; break ; default : usage() ; } } argc -= l.ind ; argv += l.ind ; } if (argc < 1) usage() ; if (!random_init()) strerr_diefu1sys(111, "init random generator") ; if (!stralloc_cats(&sa, argv[0])) strerr_diefu1sys(111, "stralloc_cats") ; if (!(n ? random_sauniquename(&sa, n) : sauniquename(&sa))) strerr_diefu1sys(111, "make unique name") ; if (!stralloc_catb(&sa, "\n", 1)) strerr_diefu1sys(111, "stralloc_cats") ; if (allwrite(1, sa.s, sa.len) < sa.len) strerr_diefu1sys(111, "write to stdout") ; return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-clock.c0000644000000000000000000000123512376735535016756 0ustar /* ISC license. */ #include #include #include #define USAGE "s6-clock [ tai64nlabel ]" static int getit (void) { char fmt[TIMESTAMP+1] ; timestamp(fmt) ; fmt[TIMESTAMP] = '\n' ; if (allwrite(1, fmt, TIMESTAMP+1) < TIMESTAMP+1) strerr_diefu1sys(111, "write to stdout") ; return 0 ; } static int setit (char const *h) { tain_t a ; if (!timestamp_scan(h, &a)) strerr_dieusage(100, USAGE) ; if (!tain_setnow(&a)) strerr_diefu1sys(111, "taia_setnow") ; return 0 ; } int main (int argc, char const *const *argv) { PROG = "s6-clock" ; return (argc < 2) ? getit() : setit(argv[1]) ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-sort.c0000644000000000000000000000626513061734213016642 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-sort [ -bcfru0 ]" typedef int strncmp_t (char const *, char const *, size_t) ; typedef strncmp_t *strncmp_t_ref ; typedef int qsortcmp_t (void const *, void const *) ; typedef qsortcmp_t *qsortcmp_t_ref ; static int flagnoblanks = 0, flagreverse = 0, flaguniq = 0 ; static strncmp_t_ref comp = &strncmp ; static int compit (char const *s1, size_t n1, char const *s2, size_t n2) { int r ; if (flagnoblanks) { while ((*s1 == ' ') || (*s1 == '\t')) (s1++, n1--) ; while ((*s2 == ' ') || (*s2 == '\t')) (s2++, n2--) ; } r = (*comp)(s1, s2, n1 < n2 ? n1 : n2) ; if (!r) r = n1 - n2 ; return flagreverse ? -r : r ; } static int sacmp (stralloc const *a, stralloc const *b) { return compit(a->s, a->len - 1, b->s, b->len - 1) ; } static ssize_t slurplines (genalloc *lines, char sep) { ssize_t i = 0 ; for (;; i++) { stralloc sa = STRALLOC_ZERO ; int r = skagetln(buffer_0, &sa, sep) ; if (!r) break ; if ((r < 0) && ((errno != EPIPE) || !stralloc_catb(&sa, &sep, 1))) return -1 ; stralloc_shrink(&sa) ; if (!genalloc_append(stralloc, lines, &sa)) return -1 ; } return i ; } static void uniq (genalloc *lines) { size_t len = genalloc_len(stralloc, lines) ; stralloc *s = genalloc_s(stralloc, lines) ; size_t i = 1 ; for (; i < len ; i++) if (!sacmp(s+i-1, s+i)) stralloc_free(s+i-1) ; } static ssize_t outputlines (stralloc const *s, size_t len) { size_t i = 0 ; for (; i < len ; i++) if (buffer_put(buffer_1, s[i].s, s[i].len) < 0) return 0 ; return buffer_flush(buffer_1) ; } static int check (stralloc const *s, size_t len) { size_t i = 1 ; for (; i < len ; i++) if (sacmp(s+i-1, s+i) >= !flaguniq) return 0 ; return 1 ; } int main (int argc, char const *const *argv) { genalloc lines = GENALLOC_ZERO ; /* array of stralloc */ char sep = '\n' ; int flagcheck = 0 ; PROG = "s6-sort" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "bcfru0", &l) ; if (opt == -1) break ; switch (opt) { case 'b' : flagnoblanks = 1 ; break ; case 'c' : flagcheck = 1 ; break ; case 'f' : comp = &strncasecmp ; break ; case 'r' : flagreverse = 1 ; break ; case 'u' : flaguniq = 1 ; break ; case '0' : sep = '\0' ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (slurplines(&lines, sep) < 0) strerr_diefu1sys(111, "read from stdin") ; if (flagcheck) return !check(genalloc_s(stralloc, &lines), genalloc_len(stralloc, &lines)) ; qsort(genalloc_s(stralloc, &lines), genalloc_len(stralloc, &lines), sizeof(stralloc), (qsortcmp_t_ref)&sacmp) ; if (flaguniq) uniq(&lines) ; if (!outputlines(genalloc_s(stralloc, &lines), genalloc_len(stralloc, &lines))) strerr_diefu1sys(111, "write to stdout") ; return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-tail.c0000644000000000000000000001072413147033267016605 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-tail [ -c chars | -n lines | -1..9 ] [ file ]" typedef int tailfunc_t (int, size_t) ; typedef tailfunc_t *tailfunc_t_ref ; static int pluslines (int fd, size_t n) { if (n) n-- ; { char buf[BUFFER_INSIZE] ; buffer b = BUFFER_INIT(&buffer_read, fd, buf, BUFFER_INSIZE) ; size_t count = 0 ; while (count < n) { ssize_t r = buffer_fill(&b) ; if (r <= 0) return !r ; while (!buffer_isempty(&b) && (count < n)) { struct iovec v[2] ; size_t i ; buffer_rpeek(&b, v) ; i = siovec_bytechr(v, 2, '\n') ; if (i < buffer_len(&b)) { count++ ; i++ ; } buffer_rseek(&b, i) ; } } b.op = &buffer_write ; b.fd = 1 ; if (!buffer_flush(&b)) return 0 ; } return (fd_cat(fd, 1) >= 0) ; } static int pluschars (int fd, size_t n) { if (n-- > 1) { int nil = open_write("/dev/null") ; if (nil < 0) return 0 ; if (!fd_catn(fd, nil, n)) { fd_close(nil) ; return 0 ; } fd_close(nil) ; } return (fd_cat(fd, 1) >= 0) ; } static int minuslines (int fd, size_t n) { char buf[BUFFER_INSIZE] ; buffer b = BUFFER_INIT(&buffer_read, fd, buf, BUFFER_INSIZE) ; size_t head = 0, tail = 0 ; stralloc tab[n+1] ; for (; head <= n ; head++) tab[head] = stralloc_zero ; head = 0 ; for (;;) { int r ; r = skagetln(&b, tab + tail, '\n') ; if (!r) break ; if (r < 0) { if (errno == EPIPE) break ; else goto err ; } tail = (tail + 1) % (n+1) ; if (tail == head) { tab[head].len = 0 ; head = (head + 1) % (n+1) ; } } buffer_init(&b, &buffer_write, 1, buf, BUFFER_INSIZE) ; for (; head != tail ; head = (head + 1) % (n+1)) { if (buffer_put(&b, tab[head].s, tab[head].len) < tab[head].len) goto err ; } for (head = 0 ; head <= n ; head++) stralloc_free(tab + head) ; return buffer_flush(&b) ; err: for (head = 0 ; head <= n ; head++) stralloc_free(tab + head) ; return 0 ; } static int minuschars (int fd, size_t n) { char buf[BUFFER_INSIZE + n] ; buffer b = BUFFER_INIT(&buffer_read, fd, buf, BUFFER_INSIZE + n) ; for (;;) { ssize_t r = buffer_fill(&b) ; if (!r) break ; if (r < 0) return 0 ; buffer_rseek(&b, buffer_len(&b)) ; buffer_unget(&b, n) ; } b.op = &buffer_write ; b.fd = 1 ; return buffer_flush(&b) ; } int main (int argc, char const *const *argv) { tailfunc_t_ref f = &minuslines ; unsigned int n = 10 ; int gotit = 0 ; PROG = "s6-tail" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "123456789n:c:", &l) ; if (opt == -1) break ; switch (opt) { case '1' : case '2' : case '3' : case '4' : case '5' : case '6' : case '7' : case '8' : case '9' : { if (gotit) strerr_dieusage(100, USAGE) ; gotit = 1 ; f = &minuslines ; n = opt - '0' ; break ; } case 'n': { if (gotit) strerr_dieusage(100, USAGE) ; gotit = 1 ; f = &minuslines ; if (*l.arg == '-') l.arg++ ; else if (*l.arg == '+') { f = &pluslines ; l.arg++ ; } if (!uint0_scan(l.arg, &n)) strerr_dieusage(100, USAGE) ; break ; } case 'c': { if (gotit) strerr_dieusage(100, USAGE) ; gotit = 1 ; f = &minuschars ; if (*l.arg == '-') l.arg++ ; else if (*l.arg == '+') { f = &pluschars ; l.arg++ ; } if (!uint0_scan(l.arg, &n)) strerr_dieusage(100, USAGE) ; break ; } default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (!argc) { if (!(*f)(0, n)) strerr_diefu1sys(111, "tail stdin") ; } else { int fd = open_readb(argv[0]) ; if (fd == -1) strerr_diefu3sys(111, "open ", argv[0], " for reading") ; if (!(*f)(fd, n)) strerr_diefu2sys(111, "tail ", argv[0]) ; fd_close(fd) ; } return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-nice.c0000644000000000000000000000211713147040406016560 0ustar /* ISC license. */ #include #include #include #include #include #include #define USAGE "s6-nice [ -I | -i ] [ -n value ] prog..." int main (int argc, char const *const *argv, char const *const *envp) { int incr = 10 ; int strict = 0 ; PROG = "s6-nice" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "Iin:", &l) ; if (opt == -1) break ; switch (opt) { case 'I' : strict = 0 ; break ; case 'i' : strict = 1 ; break ; case 'n': if (!int_scan(l.arg, &incr)) strerr_dieusage(100, USAGE) ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (!argc) strerr_dieusage(100, USAGE) ; errno = 0 ; if ((nice(incr) < 0) && errno) { char fmt[1+UINT_FMT] ; fmt[int_fmt(fmt, incr)] = 0 ; if (strict) strerr_diefu2sys(111, "nice to ", fmt) ; else strerr_warnwu2sys("nice to ", fmt) ; } xpathexec_run(argv[0], argv, envp) ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-unquote.c0000644000000000000000000000355513061734213017352 0ustar /* ISC license. */ #include #include #include #include #include #include #define USAGE "s6-unquote [ -n ] [ -d delim ] string" int main (int argc, char const *const *argv) { char const *delim = "\"" ; char const *string ; size_t len, delimlen ; int nl = 1 ; PROG = "s6-unquote" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "nd:", &l) ; if (opt == -1) break ; switch (opt) { case 'n' : nl = 0 ; break ; case 'd': delim = l.arg ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (!argc) strerr_dieusage(100, USAGE) ; string = *argv ; len = strlen(string) ; delimlen = strlen(delim) ; if (delimlen) { if (!len--) strerr_dief1x(100, "the empty string isn't a quoted string") ; if (!memchr(delim, *string++, delimlen)) strerr_dief1x(100, "invalid starting quote character") ; } { size_t r = 0, w = 0 ; char buf[len+1] ; if (!string_unquote_withdelim(buf, &w, string, len, &r, delim, delimlen)) { char fmt[SIZE_FMT] ; fmt[size_fmt(fmt, r + !!delimlen)] = 0 ; strerr_diefu2sys(100, "unquote at character ", fmt) ; } if (delimlen) { if (r == len) strerr_dief1x(100, "no ending quote character") ; else if (r < len - 1) { char fmtnum[SIZE_FMT] ; char fmtden[SIZE_FMT] ; fmtnum[size_fmt(fmtnum, r+1)] = 0 ; fmtden[size_fmt(fmtden, len)] = 0 ; strerr_warnw5x("found ending quote character at position ", fmtnum, "/", fmtden, "; ignoring remainder") ; } } if (nl) buf[w++] = '\n' ; if (allwrite(1, buf, w) < w) strerr_diefu1sys(111, "write to stdout") ; } return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-chmod.c0000644000000000000000000000154613061734212016741 0ustar /* ISC license. */ #include #include #include #define USAGE "s6-chmod mode file" int main (int argc, char const *const *argv) { mode_t mode = 0 ; unsigned int m ; PROG = "s6-chmod" ; if (argc < 3) strerr_dieusage(100, USAGE) ; if (!uint0_oscan(argv[1], &m)) strerr_dieusage(100, USAGE) ; if (m & 0001) mode |= S_IXOTH ; if (m & 0002) mode |= S_IWOTH ; if (m & 0004) mode |= S_IROTH ; if (m & 0010) mode |= S_IXGRP ; if (m & 0020) mode |= S_IWGRP ; if (m & 0040) mode |= S_IRGRP ; if (m & 0100) mode |= S_IXUSR ; if (m & 0200) mode |= S_IWUSR ; if (m & 0400) mode |= S_IRUSR ; if (m & 01000) mode |= S_ISVTX ; if (m & 02000) mode |= S_ISGID ; if (m & 04000) mode |= S_ISUID ; if (chmod(argv[2], mode) == -1) strerr_diefu2sys(111, "change mode of ", argv[2]) ; return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-update-symlinks.c0000644000000000000000000002260013324555361021002 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-update-symlinks /destdir /srcdir [ /srcdir ... ]" #define MAGICNEW ":s6-update-symlinks-new" #define MAGICOLD ":s6-update-symlinks-old" #define CONFLICT -2 #define ERROR -1 #define MODIFIED 0 #define OVERRIDEN 1 static stralloc errdst = STRALLOC_ZERO ; static stralloc errsrc = STRALLOC_ZERO ; typedef struct stralloc3 stralloc3, *stralloc3_ref ; struct stralloc3 { stralloc dst ; stralloc src ; stralloc tmp ; } ; #define STRALLOC3_ZERO { STRALLOC_ZERO, STRALLOC_ZERO, STRALLOC_ZERO } static void cleanup (stralloc *sa, unsigned int pos) { int e = errno ; rm_rf_in_tmp(sa, pos) ; errno = e ; } static int makeuniquename (stralloc *sa, char const *path, char const *magic) { size_t base = sa->len ; int wasnull = !sa->s ; if (!stralloc_cats(sa, path)) return 0 ; if (!stralloc_cats(sa, magic)) goto err ; if (!random_sauniquename(sa, 8)) goto err ; if (!stralloc_0(sa)) goto err ; return 1 ; err: if (wasnull) stralloc_free(sa) ; else sa->len = base ; return 0 ; } static int addlink (stralloc3 *blah, unsigned int dstpos, unsigned int srcpos) { if (symlink(blah->src.s + srcpos, blah->dst.s + dstpos) >= 0) return MODIFIED ; if (errno != EEXIST) return ERROR ; { size_t dstbase = blah->dst.len ; size_t srcbase = blah->src.len ; size_t tmpbase = blah->tmp.len ; size_t dststop ; size_t srcstop ; signed int diffsize = 0 ; int collect = 1 ; { size_t n = strlen(blah->dst.s + dstpos) ; if (!stralloc_readyplus(&blah->dst, n+1)) return ERROR ; stralloc_catb(&blah->dst, blah->dst.s + dstpos, n) ; } stralloc_catb(&blah->dst, "/", 1) ; dststop = blah->dst.len ; { int r ; DIR *dir = opendir(blah->dst.s + dstpos) ; if (!dir) { blah->dst.len = dstbase ; if (errno != ENOTDIR) return ERROR ; if ((unlink(blah->dst.s + dstpos) == -1) || (symlink(blah->src.s + srcpos, blah->dst.s + dstpos) == -1)) return ERROR ; return OVERRIDEN ; /* replaced a link to a normal file */ } r = sareadlink(&blah->src, blah->dst.s + dstpos) ; if ((r == -1) && (errno != EINVAL)) { blah->dst.len = dstbase ; dir_close(dir) ; return ERROR ; } if (r < 0) { for (;;) { direntry *d ; errno = 0 ; d = readdir(dir) ; if (!d) break ; if ((d->d_name[0] == '.') && (!d->d_name[1] || ((d->d_name[1] == '.') && !d->d_name[2]))) continue ; diffsize-- ; /* need to know the size for collect */ } if (errno) { blah->src.len = srcbase ; blah->dst.len = dstbase ; dir_close(dir) ; return ERROR ; } } else if ((unlink(blah->dst.s + dstpos) == -1) || (mkdir(blah->dst.s + dstpos, 0777) == -1) || !stralloc_catb(&blah->src, "/", 1)) { blah->src.len = srcbase ; blah->dst.len = dstbase ; dir_close(dir) ; return ERROR ; } else /* expand */ { srcstop = blah->src.len ; for (;;) { direntry *d ; errno = 0 ; d = readdir(dir) ; if (!d) break ; if ((d->d_name[0] == '.') && (!d->d_name[1] || ((d->d_name[1] == '.') && !d->d_name[2]))) continue ; diffsize-- ; blah->dst.len = dststop ; blah->src.len = srcstop ; if (!stralloc_cats(&blah->dst, d->d_name) || !stralloc_0(&blah->dst) || !stralloc_cats(&blah->src, d->d_name) || !stralloc_0(&blah->src) || (symlink(blah->src.s + srcbase, blah->dst.s + dstbase) == -1)) { blah->src.len = srcbase ; blah->dst.len = dstbase ; dir_close(dir) ; return ERROR ; } } if (errno) { blah->src.len = srcbase ; blah->dst.len = dstbase ; dir_close(dir) ; return ERROR ; } } dir_close(dir) ; } blah->src.len = srcbase ; { size_t n = strlen(blah->src.s + srcpos) ; if (!stralloc_readyplus(&blah->src, n+1)) { blah->dst.len = dstbase ; return ERROR ; } stralloc_catb(&blah->src, blah->src.s + srcpos, n) ; } stralloc_catb(&blah->src, "/", 1) ; srcstop = blah->src.len ; /* prepare tmp for recursion */ { DIR *dir = opendir(blah->src.s + srcpos) ; if (!dir) { blah->src.len = srcbase ; blah->dst.len = dstbase ; if (errno != ENOTDIR) return ERROR ; errdst.len = errsrc.len = 0 ; if (!stralloc_cats(&errdst, blah->dst.s + dstpos) || !stralloc_0(&errdst) || !stralloc_cats(&errsrc, blah->src.s + srcpos) || !stralloc_0(&errsrc)) return ERROR ; return CONFLICT ; /* dst is a dir but src is not */ } for (;;) { direntry *d ; errno = 0 ; d = readdir(dir) ; if (!d) break ; if ((d->d_name[0] == '.') && (!d->d_name[1] || ((d->d_name[1] == '.') && !d->d_name[2]))) continue ; if (!stralloc_cats(&blah->tmp, d->d_name) || !stralloc_0(&blah->tmp)) { blah->tmp.len = tmpbase ; blah->src.len = srcbase ; blah->dst.len = dstbase ; dir_close(dir) ; return ERROR ; } } if (errno) { blah->tmp.len = tmpbase ; blah->src.len = srcbase ; blah->dst.len = dstbase ; dir_close(dir) ; return ERROR ; } dir_close(dir) ; } /* recurse */ { size_t i = tmpbase ; while (i < blah->tmp.len) { diffsize++ ; blah->dst.len = dststop ; blah->src.len = srcstop ; { size_t n = strlen(blah->tmp.s + i) + 1 ; if (!stralloc_catb(&blah->dst, blah->tmp.s + i, n) || !stralloc_catb(&blah->src, blah->tmp.s + i, n)) { blah->tmp.len = tmpbase ; blah->src.len = srcbase ; blah->dst.len = dstbase ; return ERROR ; } i += n ; } switch (addlink(blah, dstbase, srcbase)) { case ERROR : blah->tmp.len = tmpbase ; blah->src.len = srcbase ; blah->dst.len = dstbase ; return ERROR ; case CONFLICT : blah->tmp.len = tmpbase ; blah->src.len = srcbase ; blah->dst.len = dstbase ; return CONFLICT ; case MODIFIED : collect = 0 ; } } } blah->tmp.len = tmpbase ; blah->src.len = srcbase ; blah->dst.len = dstbase ; /* collect */ if (collect && !diffsize) { if (rm_rf_in_tmp(&blah->dst, dstpos) == -1) return ERROR ; if (symlink(blah->src.s + srcpos, blah->dst.s + dstpos) == -1) return ERROR ; return OVERRIDEN ; } } return MODIFIED ; } int main (int argc, char *const *argv) { stralloc3 blah = STRALLOC3_ZERO ; PROG = "s6-update-symlinks" ; if (argc < 3) strerr_dieusage(100, USAGE) ; { char *const *p = argv + 1 ; for (; *p ; p++) if (**p != '/') strerr_dieusage(100, USAGE) ; } { size_t i = strlen(argv[1]) ; while (i && (argv[1][i-1] == '/')) argv[1][--i] = 0 ; if (!i) strerr_diefu1x(100, "replace root directory") ; } if (!random_init()) strerr_diefu1sys(111, "init random generator") ; if (!makeuniquename(&blah.dst, argv[1], MAGICNEW)) strerr_diefu2sys(111, "make random unique name based on ", argv[1]) ; if ((unlink(blah.dst.s) == -1) && (errno != ENOENT)) strerr_diefu2sys(111, "unlink ", blah.dst.s) ; { char *const *p = argv + 2 ; for (; *p ; p++) { int r ; blah.src.len = 0 ; if (!stralloc_cats(&blah.src, *p) || !stralloc_0(&blah.src)) strerr_diefu1sys(111, "make stralloc") ; r = addlink(&blah, 0, 0) ; if (r < 0) { stralloc_free(&blah.tmp) ; stralloc_free(&blah.src) ; cleanup(&blah.dst, 0) ; stralloc_free(&blah.dst) ; if (r == CONFLICT) strerr_dief4x(100, "destination ", errdst.s, " conflicts with source ", errsrc.s) ; else strerr_dief2sys(111, "error processing ", *p) ; } } } stralloc_free(&blah.tmp) ; if (rename(blah.dst.s, argv[1]) == -1) /* be atomic if possible */ { blah.src.len = 0 ; if (!makeuniquename(&blah.src, argv[1], MAGICOLD)) { cleanup(&blah.dst, 0) ; strerr_diefu2sys(111, "make random unique name based on ", argv[1]) ; } if (rename(argv[1], blah.src.s) == -1) { cleanup(&blah.dst, 0) ; strerr_diefu4sys(111, "rename ", argv[1], " to ", blah.src.s) ; } /* XXX: unavoidable race condition here: argv[1] does not exist */ if (rename(blah.dst.s, argv[1]) == -1) { rename(blah.src.s, argv[1]) ; cleanup(&blah.dst, 0) ; strerr_diefu4sys(111, "rename ", blah.dst.s, " to ", argv[1]) ; } stralloc_free(&blah.dst) ; if (rm_rf_in_tmp(&blah.src, 0) == -1) strerr_warnwu2sys("remove old directory ", blah.src.s) ; stralloc_free(&blah.src) ; } return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-cat.c0000644000000000000000000000027613061734212016415 0ustar /* ISC license. */ #include #include int main (void) { PROG = "s6-cat" ; if (fd_cat(0, 1) < 0) strerr_diefu1sys(111, "fd_cat") ; return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-quote-filter.c0000644000000000000000000000345313061734213020267 0ustar /* ISC license. */ #include #include #include #include #include #include #include #define USAGE "s6-quote-filter [ -u ] [ -d delim ]" int main (int argc, char const *const *argv) { stralloc src = STRALLOC_ZERO ; stralloc dst = STRALLOC_ZERO ; char const *delim = "\"" ; size_t delimlen ; size_t startquote = 1 ; PROG = "s6-quote-filter" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "ud:", &l) ; if (opt == -1) break ; switch (opt) { case 'u' : startquote = 0 ; break ; case 'd': delim = l.arg ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } delimlen = strlen(delim) ; if (startquote) { if(!delimlen) strerr_dief1x(100, "no character to quote with!") ; if (!stralloc_catb(&dst, delim, 1)) strerr_diefu1sys(111, "stralloc_catb") ; } for (;;) { int r ; src.len = 0 ; r = skagetln(buffer_0f1, &src, '\n') ; if (!r) break ; if ((r < 0) && (errno != EPIPE)) strerr_diefu1sys(111, "read from stdin") ; dst.len = startquote ; if (!string_quote_nodelim_mustquote(&dst, src.s, src.len - (r > 0), delim, delimlen)) { int e = errno ; buffer_flush(buffer_1) ; errno = e ; strerr_diefu1sys(111, "quote") ; } if (startquote) { if (!stralloc_catb(&dst, delim, 1)) strerr_diefu1sys(111, "stralloc_catb") ; } if (r > 0) { if (!stralloc_catb(&dst, "\n", 1)) strerr_diefu1sys(111, "stralloc_catb") ; } if (buffer_put(buffer_1, dst.s, dst.len) < 0) strerr_diefu1sys(111, "write to stdout") ; } return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-mkdir.c0000644000000000000000000000330413061734212016747 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #define USAGE "s6-mkdir [ -p ] [ -v ] [ -m mode ] dir" static int doit (char const *s, unsigned int mode, int verbose, int ee) { if (mkdir(s, mode) == -1) { if (ee || (errno != EEXIST)) { strerr_warnwu2sys("mkdir ", s) ; return 111 ; } } else if (verbose) { buffer_puts(buffer_2, PROG) ; buffer_puts(buffer_2, ": created directory ") ; buffer_puts(buffer_2, s) ; buffer_putflush(buffer_2, "\n", 1) ; } return 0 ; } static int doparents (char const *s, unsigned int mode, int verbose) { size_t n = strlen(s), i = 0 ; char tmp[n+1] ; for (; i < n ; i++) { if ((s[i] == '/') && i) { int e ; tmp[i] = 0 ; e = doit(tmp, mode, verbose, 0) ; if (e) return e ; } tmp[i] = s[i] ; } return doit(s, mode, verbose, 0) ; } int main (int argc, char const *const *argv) { int parents = 0, verbose = 0 ; unsigned int mode = 0777 ; int e = 0 ; PROG = "s6-mkdir" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "pvm:", &l) ; if (opt == -1) break ; switch (opt) { case 'p': parents = 1 ; break ; case 'v': verbose = 1 ; break ; case 'm': if (uint_oscan(l.arg, &mode)) break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } for ( ; *argv ; argv++) e |= parents ? doparents(*argv, mode, verbose) : doit(*argv, mode, verbose, 1) ; return e ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-test.c0000644000000000000000000003201313220061554016616 0ustar /* ISC license. */ #include #include #include #include #include #include #include #define USAGE "s6-test expression... or [ expression... ]" enum opnum { T_NOT, T_AND, T_OR, T_LEFTP, T_RIGHTP, T_BLOCK, T_CHAR, T_DIR, T_EXIST, T_REGULAR, T_SGID, T_SYMLINK, T_STICKY, T_NONZERO, T_FIFO, T_READABLE, T_NONZEROFILE, T_TERM, T_SUID, T_WRITABLE, T_EXECUTABLE, T_ZERO, T_EUID, T_EGID, T_SOCKET, T_MODIFIED, T_NEWER, T_OLDER, T_DEVINO, T_STREQUAL, T_STRNEQUAL, T_STRLESSER, T_STRLESSERE, T_STRGREATER, T_STRGREATERE, T_NUMEQUAL, T_NUMNEQUAL, T_NUMGREATER, T_NUMGREATERE, T_NUMLESSER, T_NUMLESSERE, T_ENV } ; struct token { char const *string ; enum opnum op ; unsigned int type ; } ; struct node { enum opnum op ; unsigned int type ; unsigned int arg1 ; unsigned int arg2 ; char const *data ; } ; static unsigned int lex (struct node *tree, char const *const *argv) { static struct token const tokens[45] = { { "-n", T_NONZERO, 2 }, { "-z", T_ZERO, 2 }, { "=", T_STREQUAL, 3 }, { "!=", T_STRNEQUAL, 3 }, { "-eq", T_NUMEQUAL, 3 }, { "-ne", T_NUMNEQUAL, 3 }, { "-gt", T_NUMGREATER, 3 }, { "-ge", T_NUMGREATERE, 3 }, { "-lt", T_NUMLESSER, 3 }, { "-le", T_NUMLESSERE, 3 }, { "-f", T_REGULAR, 2 }, { "-h", T_SYMLINK, 2 }, { "-L", T_SYMLINK, 2 }, { "-e", T_EXIST, 2 }, { "-k", T_STICKY, 2 }, { "-a", T_AND, 7 }, { "-o", T_OR, 8 }, { "!", T_NOT, 6 }, { "(", T_LEFTP, 4 }, { ")", T_RIGHTP, 5 }, { "-b", T_BLOCK, 2 }, { "-c", T_CHAR, 2 }, { "-d", T_DIR, 2 }, { "-g", T_SGID, 2 }, { "-p", T_FIFO, 2 }, { "-r", T_READABLE, 2 }, { "-s", T_NONZEROFILE, 2 }, { "-t", T_TERM, 2 }, { "-u", T_SUID, 2 }, { "-w", T_WRITABLE, 2 }, { "-x", T_EXECUTABLE, 2 }, { "-O", T_EUID, 2 }, { "-U", T_EUID, 2 }, { "-G", T_EGID, 2 }, { "-S", T_SOCKET, 2 }, { "-N", T_MODIFIED, 2 }, { "-nt", T_NEWER, 3 }, { "-ot", T_OLDER, 3 }, { "-ef", T_DEVINO, 3 }, { "<", T_STRLESSER, 3 }, { "<=", T_STRLESSERE, 3 }, { ">", T_STRGREATER, 3 }, { ">=", T_STRGREATERE, 3 }, { "-v", T_ENV, 2 }, { 0, 0, 0 } } ; unsigned int pos = 0 ; for (; argv[pos] ; pos++) { unsigned int i = 0 ; tree[pos].data = argv[pos] ; for (i = 0 ; tokens[i].string ; i++) if (!strcmp(argv[pos], tokens[i].string)) { tree[pos].op = tokens[i].op ; tree[pos].type = tokens[i].type ; break ; } if (!tokens[i].string) { tree[pos].op = T_NONZERO ; tree[pos].type = 0 ; tree[pos].arg1 = pos ; if (*(argv[pos]) == '\\') tree[pos].data++ ; /* better than SUSv3 */ } } return pos ; } static unsigned int parse (struct node *tree, unsigned int n) { static char const table[9][13] = { "xssssxsssxxxx", "xxxxxaxxxxxxx", "xsxxsxsssxxxx", "sxxxxxxxxxxxx", "xsxxsxsssxxxx", "nxxxxNxxxAOEs", "xsxxsxsssxxxx", "nxxxxNxxxAsxx", "nxxxxNxxxAOsx" } ; unsigned int stack[n+2] ; unsigned int sp = 0, pos = 0 ; int cont = 1 ; stack[0] = n+1 ; tree[n].type = 5 ; /* add ) for the final reduce */ tree[n+1].type = 1 ; /* add EOF */ while (cont) { switch (table[tree[pos].type][tree[stack[sp]].type]) { case 'x' : /* error */ { char fmt[UINT_FMT] ; fmt[uint_fmt(fmt, pos)] = 0 ; strerr_dief2x(100, "parse error at argument ", fmt) ; break ; } case 'a' : /* accept */ { cont = 0 ; break ; } case 's' : /* shift */ { stack[++sp] = pos++ ; break ; } case 'n' : /* reduce -> expr without nots, from atom */ { switch (tree[stack[sp-1]].type) { case 2 : { tree[stack[sp-1]].arg1 = stack[sp] ; sp-- ; break ; } case 3 : { tree[stack[sp-1]].arg1 = stack[sp-2] ; tree[stack[sp-1]].arg2 = stack[sp] ; stack[sp-2] = stack[sp-1] ; sp -= 2 ; break ; } /* default : assert: its a zero */ } tree[stack[sp]].type = 9 ; while (tree[stack[sp-1]].type == 6) { tree[stack[sp-1]].type = 9 ; tree[stack[sp-1]].arg1 = stack[sp] ; sp-- ; } break ; } case 'N' : /* reduce -> expr without nots, from expr */ { if (tree[stack[sp-2]].type != 4) { char fmt[UINT_FMT] ; fmt[uint_fmt(fmt, pos)] = 0 ; strerr_dief2x(100, "parse error: bad right parenthesis at argument ", fmt) ; } stack[sp-2] = stack[sp-1] ; sp -= 2 ; tree[stack[sp]].type = 9 ; while (tree[stack[sp-1]].type == 6) { tree[stack[sp-1]].type = 9 ; tree[stack[sp-1]].arg1 = stack[sp] ; sp-- ; } break ; } case 'A' : /* reduce -> exprs without ands */ { if (tree[stack[sp-1]].type == 7) { tree[stack[sp-1]].arg1 = stack[sp-2] ; tree[stack[sp-1]].arg2 = stack[sp] ; stack[sp-2] = stack[sp-1] ; sp -= 2 ; } tree[stack[sp]].type = 10 ; break ; } case 'O' : /* reduce -> expr without ors */ { if (tree[stack[sp-1]].type == 8) { tree[stack[sp-1]].arg1 = stack[sp-2] ; tree[stack[sp-1]].arg2 = stack[sp] ; stack[sp-2] = stack[sp-1] ; sp -= 2 ; } tree[stack[sp]].type = 11 ; break ; } case 'E' : /* reduce -> expr */ { tree[stack[sp]].type = 12 ; break ; } default : /* can't happen */ strerr_dief1x(101, "internal error, please submit a bug-report.") ; } } if (sp != 2) strerr_dief1x(100, "parse error: too many left parentheses") ; return stack[1] ; } static int run (struct node const *tree, unsigned int root) { switch (tree[root].op) { case T_NOT : return !run(tree, tree[root].arg1) ; case T_AND : return run(tree, tree[root].arg1) && run(tree, tree[root].arg2) ; case T_OR : return run(tree, tree[root].arg1) || run(tree, tree[root].arg2) ; case T_EXIST : { struct stat st ; return !stat(tree[tree[root].arg1].data, &st) ; } case T_BLOCK : { struct stat st ; if (stat(tree[tree[root].arg1].data, &st) == -1) return 0 ; return S_ISBLK(st.st_mode) ; } case T_CHAR : { struct stat st ; if (stat(tree[tree[root].arg1].data, &st) == -1) return 0 ; return S_ISCHR(st.st_mode) ; } case T_DIR : { struct stat st ; if (stat(tree[tree[root].arg1].data, &st) == -1) return 0 ; return S_ISDIR(st.st_mode) ; } case T_REGULAR : { struct stat st ; if (stat(tree[tree[root].arg1].data, &st) == -1) return 0 ; return S_ISREG(st.st_mode) ; } case T_FIFO : { struct stat st ; if (stat(tree[tree[root].arg1].data, &st) == -1) return 0 ; return S_ISFIFO(st.st_mode) ; } case T_SOCKET : { struct stat st ; if (stat(tree[tree[root].arg1].data, &st) == -1) return 0 ; return S_ISSOCK(st.st_mode) ; } case T_SYMLINK : { struct stat st ; if (lstat(tree[tree[root].arg1].data, &st) == -1) return 0 ; return S_ISLNK(st.st_mode) ; } case T_SGID : { struct stat st ; if (stat(tree[tree[root].arg1].data, &st) == -1) return 0 ; return (st.st_mode & S_ISGID) ; } case T_SUID : { struct stat st ; if (stat(tree[tree[root].arg1].data, &st) == -1) return 0 ; return (st.st_mode & S_ISUID) ; } case T_STICKY : { struct stat st ; if (stat(tree[tree[root].arg1].data, &st) == -1) return 0 ; return (st.st_mode & S_ISVTX) ; } case T_NONZEROFILE : { struct stat st ; if (stat(tree[tree[root].arg1].data, &st) == -1) return 0 ; return (st.st_size > 0) ; } case T_MODIFIED : { struct stat st ; if (stat(tree[tree[root].arg1].data, &st) == -1) return 0 ; return (st.st_mtime > st.st_atime) ; } case T_EUID : { struct stat st ; if (stat(tree[tree[root].arg1].data, &st) == -1) return 0 ; return st.st_uid == geteuid() ; } case T_EGID : { struct stat st ; if (stat(tree[tree[root].arg1].data, &st) == -1) return 0 ; return st.st_gid == getegid() ; } case T_READABLE : { struct stat st ; if (stat(tree[tree[root].arg1].data, &st) == -1) return 0 ; if (st.st_uid == geteuid()) return st.st_mode & S_IRUSR ; else if (st.st_gid == getegid()) return st.st_mode & S_IRGRP ; else return st.st_mode & S_IROTH ; } case T_WRITABLE : { struct stat st ; if (stat(tree[tree[root].arg1].data, &st) == -1) return 0 ; if (st.st_uid == geteuid()) return st.st_mode & S_IWUSR ; else if (st.st_gid == getegid()) return st.st_mode & S_IWGRP ; else return st.st_mode & S_IWOTH ; } case T_EXECUTABLE : { struct stat st ; if (stat(tree[tree[root].arg1].data, &st) == -1) return 0 ; if (st.st_uid == geteuid()) return st.st_mode & S_IXUSR ; else if (st.st_gid == getegid()) return st.st_mode & S_IXGRP ; else return st.st_mode & S_IXOTH ; } case T_NEWER : { struct stat st1, st2 ; if (stat(tree[tree[root].arg1].data, &st1) == -1) return 0 ; if (stat(tree[tree[root].arg2].data, &st2) == -1) return 1 ; return st1.st_mtime > st2.st_mtime ; } case T_OLDER : { struct stat st1, st2 ; if (stat(tree[tree[root].arg1].data, &st1) == -1) return 1 ; if (stat(tree[tree[root].arg2].data, &st2) == -1) return 0 ; return st1.st_mtime < st2.st_mtime ; } case T_DEVINO : { struct stat st1, st2 ; if (stat(tree[tree[root].arg1].data, &st1) == -1) return 0 ; if (stat(tree[tree[root].arg2].data, &st2) == -1) return 1 ; return (st1.st_dev == st2.st_dev) && (st1.st_ino == st2.st_ino) ; } case T_TERM : { unsigned int fd ; if (!uint0_scan(tree[tree[root].arg1].data, &fd)) strerr_dief2x(100, tree[root].data, " requires an integer argument") ; return isatty(fd) ; } case T_NONZERO : return tree[tree[root].arg1].data[0] ; case T_ZERO : return !tree[tree[root].arg1].data[0] ; case T_STREQUAL : return !strcmp(tree[tree[root].arg1].data, tree[tree[root].arg2].data) ; case T_STRNEQUAL : return !!strcmp(tree[tree[root].arg1].data, tree[tree[root].arg2].data) ; case T_STRLESSER : return strcmp(tree[tree[root].arg1].data, tree[tree[root].arg2].data) < 0 ; case T_STRLESSERE : return strcmp(tree[tree[root].arg1].data, tree[tree[root].arg2].data) <= 0 ; case T_STRGREATER : return strcmp(tree[tree[root].arg1].data, tree[tree[root].arg2].data) > 0 ; case T_STRGREATERE : return strcmp(tree[tree[root].arg1].data, tree[tree[root].arg2].data) >= 0 ; case T_NUMEQUAL : { int n1, n2 ; if (!int_scan(tree[tree[root].arg1].data, &n1) || !int_scan(tree[tree[root].arg2].data, &n2)) goto errorint ; return n1 == n2 ; } case T_NUMNEQUAL : { int n1, n2 ; if (!int_scan(tree[tree[root].arg1].data, &n1) || !int_scan(tree[tree[root].arg2].data, &n2)) goto errorint ; return n1 != n2 ; } case T_NUMGREATER : { int n1, n2 ; if (!int_scan(tree[tree[root].arg1].data, &n1) || !int_scan(tree[tree[root].arg2].data, &n2)) goto errorint ; return n1 > n2 ; } case T_NUMGREATERE : { int n1, n2 ; if (!int_scan(tree[tree[root].arg1].data, &n1) || !int_scan(tree[tree[root].arg2].data, &n2)) goto errorint ; return n1 >= n2 ; } case T_NUMLESSER : { int n1, n2 ; if (!int_scan(tree[tree[root].arg1].data, &n1) || !int_scan(tree[tree[root].arg2].data, &n2)) goto errorint ; return n1 < n2 ; } case T_NUMLESSERE : { int n1, n2 ; if (!int_scan(tree[tree[root].arg1].data, &n1) || !int_scan(tree[tree[root].arg2].data, &n2)) goto errorint ; return n1 <= n2 ; } case T_ENV : return !!getenv(tree[tree[root].arg1].data) ; default: strerr_dief1x(111, "operation not implemented") ; } errorint: strerr_dief2x(100, tree[root].data, " requires integer arguments") ; } int main (int argc, char const *const *argv) { PROG = "s6-test" ; if (argc <= 1) return 1 ; { struct node tree[argc + 2] ; unsigned int n = lex(tree, argv+1) ; if ((argv[0][0] == '[') && !argv[0][1]) { if (n && (!tree[n-1].type) && (tree[n-1].data[0] == ']') && !tree[n-1].data[1]) n-- ; else strerr_dief1x(100, "parse error: missing closing bracket") ; } return !run(tree, parse(tree, n)) ; } } s6-portable-utils-2.2.2.1/src/skaembutils/s6-sleep.c0000644000000000000000000000202113534433752016756 0ustar /* ISC license. */ #include #include #include #include #include #include #define USAGE "s6-sleep [ -m ] duration prog..." int main (int argc, char const *const *argv, char const *const *envp) { unsigned int n ; int milli = 0 ; PROG = "s6-sleep" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "m", &l) ; if (opt == -1) break ; switch (opt) { case 'm': milli = 1 ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (!argc) strerr_dieusage(100, USAGE) ; if (!uint0_scan(argv[0], &n)) strerr_dieusage(100, USAGE) ; { tain_t deadline ; if (milli) tain_from_millisecs(&deadline, n) ; else tain_uint(&deadline, n) ; tain_now_set_stopwatch_g() ; tain_add_g(&deadline, &deadline) ; deepsleepuntil_g(&deadline) ; } xpathexec0_run(argv+1, envp) ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-echo.c0000644000000000000000000000166113061734212016563 0ustar /* ISC license. */ #include #include #include #define USAGE "s6-echo [ -n ] [ -s sep ] args..." int main (int argc, char const *const *argv) { char sep = ' ' ; char donl = 1 ; PROG = "s6-echo" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "ns:", &l) ; if (opt == -1) break ; switch (opt) { case 'n': donl = 0 ; break ; case 's': sep = *l.arg ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } for ( ; *argv ; argv++) if ((buffer_puts(buffer_1small, *argv) < 0) || (argv[1] && (buffer_put(buffer_1small, &sep, 1) < 0))) goto err ; if (donl && (buffer_put(buffer_1small, "\n", 1) < 0)) goto err ; if (!buffer_flush(buffer_1small)) goto err ; return 0 ; err: strerr_diefu1sys(111, "write to stdout") ; } s6-portable-utils-2.2.2.1/src/skaembutils/s6-dirname.c0000644000000000000000000000175613061734212017271 0ustar /* ISC license. */ #include #include #include #include #include #include #define USAGE "s6-dirname [ -n ] file" int main (int argc, char const *const *argv) { stralloc sa = STRALLOC_ZERO ; int nl = 1 ; PROG = "s6-dirname" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { int opt = subgetopt_r(argc, argv, "n", &l) ; if (opt == -1) break ; switch (opt) { case 'n' : nl = 0 ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (!argc) strerr_dieusage(100, USAGE) ; if (!sadirname(&sa, argv[0], strlen(argv[0]))) strerr_diefu2sys(111, "get dirname of ", argv[0]) ; if (nl && !stralloc_catb(&sa, "\n", 1)) strerr_diefu2sys(111, "get dirname of ", argv[0]) ; if (allwrite(1, sa.s, sa.len) < sa.len) strerr_diefu1sys(111, "write to stdout") ; return 0 ; } s6-portable-utils-2.2.2.1/src/skaembutils/deps-lib/0000755000000000000000000000000012376732603016660 5ustar s6-portable-utils-2.2.2.1/src/include/0000755000000000000000000000000012376727050014261 5ustar s6-portable-utils-2.2.2.1/src/include/s6-portable-utils/0000755000000000000000000000000013541513366017553 5ustar s6-portable-utils-2.2.2.1/package/0002755000000000000000000000000012504642611013434 5ustar s6-portable-utils-2.2.2.1/package/deps.mak0000644000000000000000000001567213553364330015076 0ustar # # This file has been generated by tools/gen-deps.sh # src/skaembutils/s6-basename.o src/skaembutils/s6-basename.lo: src/skaembutils/s6-basename.c src/skaembutils/s6-cat.o src/skaembutils/s6-cat.lo: src/skaembutils/s6-cat.c src/skaembutils/s6-chmod.o src/skaembutils/s6-chmod.lo: src/skaembutils/s6-chmod.c src/skaembutils/s6-chown.o src/skaembutils/s6-chown.lo: src/skaembutils/s6-chown.c src/skaembutils/s6-clock.o src/skaembutils/s6-clock.lo: src/skaembutils/s6-clock.c src/skaembutils/s6-cut.o src/skaembutils/s6-cut.lo: src/skaembutils/s6-cut.c src/skaembutils/s6-dirname.o src/skaembutils/s6-dirname.lo: src/skaembutils/s6-dirname.c src/skaembutils/s6-dumpenv.o src/skaembutils/s6-dumpenv.lo: src/skaembutils/s6-dumpenv.c src/skaembutils/s6-echo.o src/skaembutils/s6-echo.lo: src/skaembutils/s6-echo.c src/skaembutils/s6-env.o src/skaembutils/s6-env.lo: src/skaembutils/s6-env.c src/include/s6-portable-utils/config.h src/skaembutils/s6-expr.o src/skaembutils/s6-expr.lo: src/skaembutils/s6-expr.c src/skaembutils/s6-false.o src/skaembutils/s6-false.lo: src/skaembutils/s6-false.c src/skaembutils/s6-format-filter.o src/skaembutils/s6-format-filter.lo: src/skaembutils/s6-format-filter.c src/skaembutils/s6-grep.o src/skaembutils/s6-grep.lo: src/skaembutils/s6-grep.c src/skaembutils/s6-head.o src/skaembutils/s6-head.lo: src/skaembutils/s6-head.c src/skaembutils/s6-hiercopy.o src/skaembutils/s6-hiercopy.lo: src/skaembutils/s6-hiercopy.c src/skaembutils/s6-linkname.o src/skaembutils/s6-linkname.lo: src/skaembutils/s6-linkname.c src/skaembutils/s6-ln.o src/skaembutils/s6-ln.lo: src/skaembutils/s6-ln.c src/skaembutils/s6-ls.o src/skaembutils/s6-ls.lo: src/skaembutils/s6-ls.c src/skaembutils/s6-maximumtime.o src/skaembutils/s6-maximumtime.lo: src/skaembutils/s6-maximumtime.c src/skaembutils/s6-mkdir.o src/skaembutils/s6-mkdir.lo: src/skaembutils/s6-mkdir.c src/skaembutils/s6-mkfifo.o src/skaembutils/s6-mkfifo.lo: src/skaembutils/s6-mkfifo.c src/skaembutils/s6-nice.o src/skaembutils/s6-nice.lo: src/skaembutils/s6-nice.c src/skaembutils/s6-nuke.o src/skaembutils/s6-nuke.lo: src/skaembutils/s6-nuke.c src/skaembutils/s6-pause.o src/skaembutils/s6-pause.lo: src/skaembutils/s6-pause.c src/skaembutils/s6-printenv.o src/skaembutils/s6-printenv.lo: src/skaembutils/s6-printenv.c src/skaembutils/s6-quote-filter.o src/skaembutils/s6-quote-filter.lo: src/skaembutils/s6-quote-filter.c src/skaembutils/s6-quote.o src/skaembutils/s6-quote.lo: src/skaembutils/s6-quote.c src/skaembutils/s6-rename.o src/skaembutils/s6-rename.lo: src/skaembutils/s6-rename.c src/skaembutils/s6-rmrf.o src/skaembutils/s6-rmrf.lo: src/skaembutils/s6-rmrf.c src/skaembutils/s6-seq.o src/skaembutils/s6-seq.lo: src/skaembutils/s6-seq.c src/skaembutils/s6-sleep.o src/skaembutils/s6-sleep.lo: src/skaembutils/s6-sleep.c src/skaembutils/s6-sort.o src/skaembutils/s6-sort.lo: src/skaembutils/s6-sort.c src/skaembutils/s6-sync.o src/skaembutils/s6-sync.lo: src/skaembutils/s6-sync.c src/skaembutils/s6-tail.o src/skaembutils/s6-tail.lo: src/skaembutils/s6-tail.c src/skaembutils/s6-test.o src/skaembutils/s6-test.lo: src/skaembutils/s6-test.c src/skaembutils/s6-touch.o src/skaembutils/s6-touch.lo: src/skaembutils/s6-touch.c src/skaembutils/s6-true.o src/skaembutils/s6-true.lo: src/skaembutils/s6-true.c src/skaembutils/s6-uniquename.o src/skaembutils/s6-uniquename.lo: src/skaembutils/s6-uniquename.c src/skaembutils/s6-unquote-filter.o src/skaembutils/s6-unquote-filter.lo: src/skaembutils/s6-unquote-filter.c src/skaembutils/s6-unquote.o src/skaembutils/s6-unquote.lo: src/skaembutils/s6-unquote.c src/skaembutils/s6-update-symlinks.o src/skaembutils/s6-update-symlinks.lo: src/skaembutils/s6-update-symlinks.c src/skaembutils/seekablepipe.o src/skaembutils/seekablepipe.lo: src/skaembutils/seekablepipe.c s6-basename: EXTRA_LIBS := -lskarnet s6-basename: src/skaembutils/s6-basename.o s6-cat: EXTRA_LIBS := -lskarnet s6-cat: src/skaembutils/s6-cat.o s6-chmod: EXTRA_LIBS := -lskarnet s6-chmod: src/skaembutils/s6-chmod.o s6-chown: EXTRA_LIBS := -lskarnet s6-chown: src/skaembutils/s6-chown.o s6-clock: EXTRA_LIBS := -lskarnet ${SYSCLOCK_LIB} s6-clock: src/skaembutils/s6-clock.o s6-cut: EXTRA_LIBS := -lskarnet s6-cut: src/skaembutils/s6-cut.o s6-dirname: EXTRA_LIBS := -lskarnet s6-dirname: src/skaembutils/s6-dirname.o s6-dumpenv: EXTRA_LIBS := -lskarnet s6-dumpenv: src/skaembutils/s6-dumpenv.o s6-echo: EXTRA_LIBS := -lskarnet s6-echo: src/skaembutils/s6-echo.o s6-env: EXTRA_LIBS := -lskarnet s6-env: src/skaembutils/s6-env.o s6-expr: EXTRA_LIBS := -lskarnet s6-expr: src/skaembutils/s6-expr.o s6-false: EXTRA_LIBS := s6-false: src/skaembutils/s6-false.o s6-format-filter: EXTRA_LIBS := -lskarnet s6-format-filter: src/skaembutils/s6-format-filter.o s6-grep: EXTRA_LIBS := -lskarnet s6-grep: src/skaembutils/s6-grep.o s6-head: EXTRA_LIBS := -lskarnet s6-head: src/skaembutils/s6-head.o s6-hiercopy: EXTRA_LIBS := -lskarnet s6-hiercopy: src/skaembutils/s6-hiercopy.o s6-linkname: EXTRA_LIBS := -lskarnet s6-linkname: src/skaembutils/s6-linkname.o s6-ln: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-ln: src/skaembutils/s6-ln.o s6-ls: EXTRA_LIBS := -lskarnet s6-ls: src/skaembutils/s6-ls.o s6-maximumtime: EXTRA_LIBS := -lskarnet ${SYSCLOCK_LIB} ${SPAWN_LIB} s6-maximumtime: src/skaembutils/s6-maximumtime.o s6-mkdir: EXTRA_LIBS := -lskarnet s6-mkdir: src/skaembutils/s6-mkdir.o s6-mkfifo: EXTRA_LIBS := -lskarnet s6-mkfifo: src/skaembutils/s6-mkfifo.o s6-nice: EXTRA_LIBS := -lskarnet s6-nice: src/skaembutils/s6-nice.o s6-nuke: EXTRA_LIBS := -lskarnet s6-nuke: src/skaembutils/s6-nuke.o s6-pause: EXTRA_LIBS := -lskarnet s6-pause: src/skaembutils/s6-pause.o s6-printenv: EXTRA_LIBS := -lskarnet s6-printenv: src/skaembutils/s6-printenv.o s6-quote: EXTRA_LIBS := -lskarnet s6-quote: src/skaembutils/s6-quote.o s6-quote-filter: EXTRA_LIBS := -lskarnet s6-quote-filter: src/skaembutils/s6-quote-filter.o s6-rename: EXTRA_LIBS := -lskarnet s6-rename: src/skaembutils/s6-rename.o s6-rmrf: EXTRA_LIBS := -lskarnet s6-rmrf: src/skaembutils/s6-rmrf.o s6-seq: EXTRA_LIBS := -lskarnet s6-seq: src/skaembutils/s6-seq.o s6-sleep: EXTRA_LIBS := -lskarnet ${SYSCLOCK_LIB} s6-sleep: src/skaembutils/s6-sleep.o s6-sort: EXTRA_LIBS := -lskarnet s6-sort: src/skaembutils/s6-sort.o s6-sync: EXTRA_LIBS := s6-sync: src/skaembutils/s6-sync.o s6-tail: EXTRA_LIBS := -lskarnet s6-tail: src/skaembutils/s6-tail.o s6-test: EXTRA_LIBS := -lskarnet s6-test: src/skaembutils/s6-test.o s6-touch: EXTRA_LIBS := -lskarnet s6-touch: src/skaembutils/s6-touch.o s6-true: EXTRA_LIBS := s6-true: src/skaembutils/s6-true.o s6-uniquename: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-uniquename: src/skaembutils/s6-uniquename.o s6-unquote: EXTRA_LIBS := -lskarnet s6-unquote: src/skaembutils/s6-unquote.o s6-unquote-filter: EXTRA_LIBS := -lskarnet s6-unquote-filter: src/skaembutils/s6-unquote-filter.o s6-update-symlinks: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-update-symlinks: src/skaembutils/s6-update-symlinks.o seekablepipe: EXTRA_LIBS := -lskarnet seekablepipe: src/skaembutils/seekablepipe.o s6-portable-utils-2.2.2.1/package/deps-build0000644000000000000000000000002612357112413015401 0ustar /package/prog/skalibs s6-portable-utils-2.2.2.1/package/targets.mak0000644000000000000000000000104713000763570015577 0ustar BIN_TARGETS := \ s6-basename \ s6-cat \ s6-chmod \ s6-chown \ s6-clock \ s6-cut \ s6-dirname \ s6-dumpenv \ s6-echo \ s6-env \ s6-expr \ s6-false \ s6-format-filter \ s6-grep \ s6-head \ s6-hiercopy \ s6-linkname \ s6-ln \ s6-ls \ s6-maximumtime \ s6-mkdir \ s6-mkfifo \ s6-nice \ s6-nuke \ s6-pause \ s6-printenv \ s6-quote \ s6-quote-filter \ s6-rename \ s6-rmrf \ s6-seq \ s6-sleep \ s6-sort \ s6-sync \ s6-tail \ s6-test \ s6-touch \ s6-true \ s6-uniquename \ s6-unquote \ s6-unquote-filter \ s6-update-symlinks \ seekablepipe LIBEXEC_TARGETS := s6-portable-utils-2.2.2.1/package/modes0000644000000000000000000000127712522156700014472 0ustar s6-basename 0755 s6-cat 0755 s6-chmod 0755 s6-chown 0755 s6-clock 0755 s6-cut 0755 s6-dirname 0755 s6-dumpenv 0755 s6-echo 0755 s6-env 0755 s6-expr 0755 s6-false 0755 s6-format-filter 0755 s6-grep 0755 s6-head 0755 s6-hiercopy 0755 s6-linkname 0755 s6-ln 0755 s6-ls 0755 s6-maximumtime 0755 s6-mkdir 0755 s6-mkfifo 0755 s6-nice 0755 s6-nuke 0755 s6-pause 0755 s6-printenv 0755 s6-quote 0755 s6-quote-filter 0755 s6-rename 0755 s6-rmrf 0755 s6-seq 0755 s6-sleep 0755 s6-sort 0755 s6-sync 0755 s6-tail 0755 s6-test 0755 s6-touch 0755 s6-true 0755 s6-uniquename 0755 s6-unquote 0755 s6-unquote-filter 0755 s6-update-symlinks 0755 seekablepipe 0755 s6-portable-utils-2.2.2.1/package/info0000644000000000000000000000013613553360305014312 0ustar package=s6-portable-utils version=2.2.2.1 category=admin package_macro_name=S6_PORTABLE_UTILS s6-portable-utils-2.2.2.1/COPYING0000644000000000000000000000137013415644224013077 0ustar Copyright (c) 2011-2019 Laurent Bercot Permission to use, copy, modify, and distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. 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. s6-portable-utils-2.2.2.1/configure0000755000000000000000000003246113553343655013767 0ustar #!/bin/sh cd `dirname "$0"` . package/info usage () { cat </dev/null 2>&1 && { echo "$1" ; return 0 ; } $1 EOF echo "$1" | sed -e "s/'/'\\\\''/g" -e "1s/^/'/" -e "\$s/\$/'/" -e "s#^'\([-[:alnum:]_,./:]*\)=\(.*\)\$#\1='\2#" -e "s|\*/|* /|g" } fail () { echo "$*" exit 1 } fnmatch () { eval "case \"\$2\" in $1) return 0 ;; *) return 1 ;; esac" } cmdexists () { type "$1" >/dev/null 2>&1 } trycc () { test -z "$CC_AUTO" && cmdexists "$1" && CC_AUTO="$*" } stripdir () { while eval "fnmatch '*/' \"\${$1}\"" ; do eval "$1=\${$1%/}" done } tryflag () { echo "Checking whether compiler accepts $2 ..." echo "typedef int x;" > "$tmpc" if $CC_AUTO $CPPFLAGS_AUTO $CPPFLAGS $CPPFLAGS_POST $CFLAGS_AUTO $CFLAGS $CFLAGS_POST "$2" -c -o /dev/null "$tmpc" >/dev/null 2>&1 ; then echo " ... yes" eval "$1=\"\${$1} \$2\"" eval "$1=\${$1# }" return 0 else echo " ... no" return 1 fi } tryldflag () { echo "Checking whether linker accepts $2 ..." echo "typedef int x;" > "$tmpc" if $CC_AUTO $CFLAGS_AUTO $CFLAGS $CFLAGS_POST $LDFLAGS_AUTO $LDFLAGS $LDFLAGS_POST -nostdlib "$2" -o /dev/null "$tmpc" >/dev/null 2>&1 ; then echo " ... yes" eval "$1=\"\${$1} \$2\"" eval "$1=\${$1# }" return 0 else echo " ... no" return 1 fi } # Actual script CC_AUTO= CPPFLAGS_AUTO="-D_POSIX_C_SOURCE=200809L -D_XOPEN_SOURCE=700 -iquote src/include-local -Isrc/include" CPPFLAGS_POST="$CPPFLAGS" CPPFLAGS= CFLAGS_AUTO="-pipe -Wall" CFLAGS_POST="$CFLAGS" CFLAGS=-O2 LDFLAGS_AUTO= LDFLAGS_POST="$LDFLAGS" LDFLAGS= LDFLAGS_NOSHARED= LDFLAGS_SHARED=-shared prefix= exec_prefix='$prefix' dynlibdir='$prefix/lib' libexecdir='$exec_prefix/libexec' bindir='$exec_prefix/bin' libdir='$prefix/lib/$package' includedir='$prefix/include' sysdeps='$prefix/lib/skalibs/sysdeps' manualsysdeps=false shared=false static=true allpic=true slashpackage=false abspath=false sproot= home= exthome= allstatic=true evenmorestatic=false addincpath='' addlibspath='' addlibdpath='' vpaths='' vpathd='' build= for arg ; do case "$arg" in --help) usage ;; --prefix=*) prefix=${arg#*=} ;; --exec-prefix=*) exec_prefix=${arg#*=} ;; --dynlibdir=*) dynlibdir=${arg#*=} ;; --libexecdir=*) libexecdir=${arg#*=} ;; --bindir=*) bindir=${arg#*=} ;; --libdir=*) libdir=${arg#*=} ;; --includedir=*) includedir=${arg#*=} ;; --with-sysdeps=*) sysdeps=${arg#*=} manualsysdeps=true ;; --with-include=*) var=${arg#*=} ; stripdir var ; addincpath="$addincpath -I$var" ;; --with-lib=*) var=${arg#*=} ; stripdir var ; addlibspath="$addlibspath -L$var" ; vpaths="$vpaths $var" ;; --with-dynlib=*) var=${arg#*=} ; stripdir var ; addlibdpath="$addlibdpath -L$var" ; vpathd="$vpathd $var" ;; --enable-shared|--enable-shared=yes) shared=true ;; --disable-shared|--enable-shared=no) shared=false ;; --enable-static|--enable-static=yes) static=true ;; --disable-static|--enable-static=no) static=false ;; --enable-allstatic|--enable-allstatic=yes) allstatic=true ;; --disable-allstatic|--enable-allstatic=no) allstatic=false ; evenmorestatic=false ;; --enable-static-libc|--enable-static-libc=yes) allstatic=true ; evenmorestatic=true ;; --disable-static-libc|--enable-static-libc=no) evenmorestatic=false ;; --enable-all-pic|--enable-all-pic=yes) allpic=true ;; --disable-all-pic|--enable-all-pic=no) allpic=false ;; --enable-slashpackage=*) sproot=${arg#*=} ; slashpackage=true ; ;; --enable-slashpackage) sproot= ; slashpackage=true ;; --disable-slashpackage) sproot= ; slashpackage=false ;; --enable-absolute-paths|--enable-absolute-paths=yes) abspath=true ;; --disable-absolute-paths|--enable-absolute-paths=no) abspath=false ;; --enable-*|--disable-*|--with-*|--without-*|--*dir=*) ;; --host=*|--target=*) target=${arg#*=} ;; --build=*) build=${arg#*=} ;; -* ) echo "$0: unknown option $arg" ;; *=*) ;; *) target=$arg ;; esac done # Add /usr in the default default case if test -z "$prefix" ; then if test "$libdir" = '$prefix/lib/$package' ; then libdir=/usr/lib/$package fi if test "$includedir" = '$prefix/include' ; then includedir=/usr/include fi if test "$sysdeps" = '$prefix/lib/skalibs/sysdeps' ; then sysdeps=/usr/lib/skalibs/sysdeps fi fi # Expand installation directories stripdir prefix for i in exec_prefix dynlibdir libexecdir bindir libdir includedir sysdeps sproot ; do eval tmp=\${$i} eval $i=$tmp stripdir $i done # Get usable temp filenames i=0 set -C while : ; do i=$(($i+1)) tmpc="./tmp-configure-$$-$PPID-$i.c" tmpe="./tmp-configure-$$-$PPID-$i.tmp" 2>|/dev/null > "$tmpc" && break 2>|/dev/null > "$tmpe" && break test "$i" -gt 50 && fail "$0: cannot create temporary files" done set +C trap 'rm -f "$tmpc" "$tmpe"' EXIT ABRT INT QUIT TERM HUP # Set slashpackage values if $slashpackage ; then home=${sproot}/package/${category}/${package}-${version} exthome=${sproot}/package/${category}/${package} if $manualsysdeps ; then : else sysdeps=${sproot}/package/prog/skalibs/sysdeps fi extbinprefix=${exthome}/command dynlibdir=${home}/library.so bindir=${home}/command libdir=${home}/library libexecdir=$bindir includedir=${home}/include while read dep condvar ; do if test -n "$condvar" ; then eval "cond=$condvar" else cond=true fi if $cond ; then addincpath="$addincpath -I${sproot}${dep}/include" vpaths="$vpaths ${sproot}${dep}/library" addlibspath="$addlibspath -L${sproot}${dep}/library" vpathd="$vpathd ${sproot}${dep}/library.so" addlibdpath="$addlibdpath -L${sproot}${dep}/library.so" fi done < package/deps-build fi # Find a C compiler to use if test -n "$target" && test x${build} != x${target} ; then cross=${target}- else cross= fi echo "Checking for C compiler..." trycc ${CC} if test -n "$CC_AUTO" ; then b=`basename "$CC"` adjust_cross=false if test "$b" != "$CC" ; then adjust_cross=true echo "$0: warning: compiler $CC is declared with its own path. If it's not accessible via PATH, you will need to pass AR, RANLIB and STRIP make variables to the make invocation." 1>&2 fi if test -n "$cross" ; then if test "$b" = "${b##$cross}" ; then echo "$0: warning: compiler $CC is declared as a cross-compiler for target $target but does not start with prefix ${cross}" 1>&2 elif $adjust_cross ; then cross=`dirname "$CC"`/"$cross" fi fi fi trycc ${cross}gcc trycc ${cross}clang trycc ${cross}cc test -n "$CC_AUTO" || { echo "$0: cannot find a C compiler" ; exit 1 ; } echo " ... $CC_AUTO" echo "Checking whether C compiler works... " echo "typedef int x;" > "$tmpc" if $CC_AUTO $CPPFLAGS_AUTO $CPPFLAGS $CPPFLAGS_POST $CFLAGS_AUTO $CFLAGS $CFLAGS_POST -c -o /dev/null "$tmpc" 2>"$tmpe" ; then echo " ... yes" else echo " ... no. Compiler output follows:" cat < "$tmpe" exit 1 fi echo "Checking target system type..." if test -z "$target" ; then if test -n "$build" ; then target=$build ; else target=$($CC_AUTO -dumpmachine 2>/dev/null) || target=unknown fi fi echo " ... $target" if test ! -d $sysdeps || test ! -f $sysdeps/target ; then echo "$0: error: $sysdeps is not a valid sysdeps directory" exit 1 fi if [ "x$target" != "x$(cat $sysdeps/target)" ] ; then echo "$0: error: target $target does not match the contents of $sysdeps/target" exit 1 fi spawn_lib=$(cat $sysdeps/spawn.lib) socket_lib=$(cat $sysdeps/socket.lib) sysclock_lib=$(cat $sysdeps/sysclock.lib) timer_lib=$(cat $sysdeps/timer.lib) util_lib=$(cat $sysdeps/util.lib) if $allpic ; then tryflag CPPFLAGS_AUTO -fPIC fi tryflag CFLAGS_AUTO -std=c99 tryflag CFLAGS -fomit-frame-pointer tryflag CFLAGS_AUTO -fno-exceptions tryflag CFLAGS_AUTO -fno-unwind-tables tryflag CFLAGS_AUTO -fno-asynchronous-unwind-tables tryflag CFLAGS_AUTO -Wa,--noexecstack tryflag CFLAGS -fno-stack-protector tryflag CPPFLAGS_AUTO -Werror=implicit-function-declaration tryflag CPPFLAGS_AUTO -Werror=implicit-int tryflag CPPFLAGS_AUTO -Werror=pointer-sign tryflag CPPFLAGS_AUTO -Werror=pointer-arith tryflag CFLAGS_AUTO -ffunction-sections tryflag CFLAGS_AUTO -fdata-sections tryldflag LDFLAGS_AUTO -Wl,--sort-section=alignment tryldflag LDFLAGS_AUTO -Wl,--sort-common CPPFLAGS_AUTO="${CPPFLAGS_AUTO}${addincpath}" if $evenmorestatic ; then LDFLAGS_NOSHARED=-static fi if $shared ; then tryldflag LDFLAGS -Wl,--hash-style=both fi LDFLAGS_SHARED="${LDFLAGS_SHARED}${addlibdpath}" if $allstatic ; then LDFLAGS_NOSHARED="${LDFLAGS_NOSHARED}${addlibspath}" tryldflag LDFLAGS_NOSHARED -Wl,--gc-sections else LDFLAGS_NOSHARED="${LDFLAGS_NOSHARED}${addlibdpath}" fi if test -z "$vpaths" ; then while read dep ; do base=$(basename $dep) ; vpaths="$vpaths /usr/lib/$base" addlibspath="$addlibspath -L/usr/lib/$base" done < package/deps-build fi echo "Creating config.mak..." cmdline=$(quote "$0") for i ; do cmdline="$cmdline $(quote "$i")" ; done exec 3>&1 1>config.mak cat << EOF # This file was generated by: # $cmdline # Any changes made here will be lost if configure is re-run. target := $target package := $package prefix := $prefix exec_prefix := $exec_prefix dynlibdir := $dynlibdir libexecdir := $libexecdir bindir := $bindir libdir := $libdir includedir := $includedir sysdeps := $sysdeps slashpackage := $slashpackage sproot := $sproot version := $version home := $home exthome := $exthome SPAWN_LIB := ${spawn_lib} SOCKET_LIB := ${socket_lib} SYSCLOCK_LIB := ${sysclock_lib} TIMER_LIB := ${timer_lib} UTIL_LIB := ${util_lib} CC := $CC_AUTO CPPFLAGS_AUTO := $CPPFLAGS_AUTO CPPFLAGS := $CPPFLAGS $CPPFLAGS_POST CFLAGS_AUTO := $CFLAGS_AUTO CFLAGS := $CFLAGS $CFLAGS_POST LDFLAGS_AUTO := $LDFLAGS_AUTO LDFLAGS := $LDFLAGS $LDFLAGS_POST LDFLAGS_SHARED := $LDFLAGS_SHARED LDFLAGS_NOSHARED := $LDFLAGS_NOSHARED CROSS_COMPILE := $cross vpath lib%.a$vpaths vpath lib%.so$vpathd EOF if $allstatic ; then echo ".LIBPATTERNS := lib%.a" echo "DO_ALLSTATIC := 1" else echo ".LIBPATTERNS := lib%.so" fi if $static ; then echo "DO_STATIC := 1" else echo "DO_STATIC :=" fi if $shared ; then echo "DO_SHARED := 1" else echo "DO_SHARED :=" fi if $allpic ; then echo "STATIC_LIBS_ARE_PIC := 1" else echo "STATIC_LIBS_ARE_PIC :=" fi exec 1>&3 3>&- echo " ... done." echo "Creating src/include/${package}/config.h..." mkdir -p -m 0755 src/include/${package} exec 3>&1 1> src/include/${package}/config.h cat <&3 3>&- echo " ... done." s6-portable-utils-2.2.2.1/tools/0002755000000000000000000000000013553363665013217 5ustar s6-portable-utils-2.2.2.1/tools/install.sh0000755000000000000000000000167512365207173015222 0ustar #!/bin/sh usage() { echo "usage: $0 [-D] [-l] [-m mode] src dst" 1>&2 exit 1 } mkdirp=false symlink=false mode=0755 while getopts Dlm: name ; do case "$name" in D) mkdirp=true ;; l) symlink=true ;; m) mode=$OPTARG ;; ?) usage ;; esac done shift $(($OPTIND - 1)) test "$#" -eq 2 || usage src=$1 dst=$2 tmp="$dst.tmp.$$" case "$dst" in */) echo "$0: $dst ends in /" 1>&2 ; exit 1 ;; esac set -C set -e if $mkdirp ; then umask 022 case "$2" in */*) mkdir -p "${dst%/*}" ;; esac fi trap 'rm -f "$tmp"' EXIT INT QUIT TERM HUP umask 077 if $symlink ; then ln -s "$src" "$tmp" else cat < "$1" > "$tmp" chmod "$mode" "$tmp" fi mv -f "$tmp" "$dst" if test -d "$dst" ; then rm -f "$dst/$(basename $tmp)" if $symlink ; then mkdir "$tmp" ln -s "$src" "$tmp/$(basename $dst)" mv -f "$tmp/$(basename $dst)" "${dst%/*}" rmdir "$tmp" else echo "$0: $dst is a directory" 1>&2 exit 1 fi fi s6-portable-utils-2.2.2.1/tools/gen-deps.sh0000755000000000000000000000474313553363665015266 0ustar #!/bin/sh -e . package/info echo '#' echo '# This file has been generated by tools/gen-deps.sh' echo '#' echo for dir in src/include/${package} src/* ; do for file in $(ls -1 $dir | grep -- \\.h$) ; do { grep -F -- "#include <${package}/" < ${dir}/$file | cut -d'<' -f2 | cut -d'>' -f1 ; grep -- '#include ".*\.h"' < ${dir}/$file | cut -d'"' -f2 } | sort -u | { deps= while read dep ; do if echo $dep | grep -q "^${package}/" ; then deps="$deps src/include/$dep" elif test -f "${dir}/$dep" ; then deps="$deps ${dir}/$dep" else deps="$deps src/include-local/$dep" fi done if test -n "$deps" ; then echo "${dir}/${file}:${deps}" fi } done done for dir in src/* ; do for file in $(ls -1 $dir | grep -- \\.c$) ; do { grep -F -- "#include <${package}/" < ${dir}/$file | cut -d'<' -f2 | cut -d'>' -f1 ; grep -- '#include ".*\.h"' < ${dir}/$file | cut -d'"' -f2 } | sort -u | { deps=" ${dir}/$file" while read dep ; do if echo $dep | grep -q "^${package}/" ; then deps="$deps src/include/$dep" elif test -f "${dir}/$dep" ; then deps="$deps ${dir}/$dep" else deps="$deps src/include-local/$dep" fi done o=$(echo $file | sed s/\\.c$/.o/) lo=$(echo $file | sed s/\\.c$/.lo/) echo "${dir}/${o} ${dir}/${lo}:${deps}" } done done echo for dir in $(ls -1 src | grep -v ^include) ; do for file in $(ls -1 src/$dir/deps-lib) ; do deps= libs= while read dep ; do if echo $dep | grep -q -e ^-l -e '^\${.*_LIB}' ; then libs="$libs $dep" else deps="$deps src/$dir/$dep" fi done < src/$dir/deps-lib/$file echo 'ifeq ($(strip $(STATIC_LIBS_ARE_PIC)),)' echo "lib${file}.a.xyzzy:$deps" echo else echo "lib${file}.a.xyzzy:$(echo "$deps" | sed 's/\.o/.lo/g')" echo endif echo "lib${file}.so.xyzzy: EXTRA_LIBS :=$libs" echo "lib${file}.so.xyzzy:$(echo "$deps" | sed 's/\.o/.lo/g')" done for file in $(ls -1 src/$dir/deps-exe) ; do deps= libs= while read dep ; do if echo $dep | grep -q -- \\.o$ ; then dep="src/$dir/$dep" fi if echo $dep | grep -q -e ^-l -e '^\${.*_LIB}' ; then libs="$libs $dep" else deps="$deps $dep" fi done < src/$dir/deps-exe/$file echo "$file: EXTRA_LIBS :=$libs" echo "$file: src/$dir/$file.o$deps" done done s6-portable-utils-2.2.2.1/NEWS0000644000000000000000000000143113553360327012543 0ustar Changelog for s6-portable-utils. In 2.2.2.1 ---------- - Bugfixes. In 2.2.2.0 ---------- - Adaptation to skalibs-2.9.0.0. In 2.2.1.3 ---------- - s6-ln doesn't use potentially blocking random anymore, so it's usable in early boot. This needs skalibs-2.8.0.0, however. - Everything now builds as PIC by default. In 2.2.1.2 ---------- - Adaptation to skalibs-2.7.0.0. In 2.2.1.1 ---------- - Bugfix release. - Adaptation to skalibs-2.6.0.0. In 2.2.1.0 ---------- - s6-ln now accepts the non-standard -n option, with a meaning similar to the one in GNU ln. This is used to atomically update symbolic links to directories. In 2.2.0.0 ---------- - Added this NEWS file. :) - Major types overhaul to make them more POSIXly correct: compatibility with skalibs-2.5.0.0. s6-portable-utils-2.2.2.1/Makefile0000644000000000000000000001125513515356574013520 0ustar # # This Makefile requires GNU make. # # Do not make changes here. # Use the included .mak files. # it: all make_need := 3.81 ifeq "" "$(strip $(filter $(make_need), $(firstword $(sort $(make_need) $(MAKE_VERSION)))))" fail := $(error Your make ($(MAKE_VERSION)) is too old. You need $(make_need) or newer) endif CC = $(error Please use ./configure first) STATIC_LIBS := SHARED_LIBS := INTERNAL_LIBS := EXTRA_TARGETS := LIB_DEFS := define library_definition LIB$(firstword $(subst =, ,$(1))) := lib$(lastword $(subst =, ,$(1))).$(if $(DO_ALLSTATIC),a,so).xyzzy ifdef DO_SHARED SHARED_LIBS += lib$(lastword $(subst =, ,$(1))).so.xyzzy endif ifdef DO_STATIC STATIC_LIBS += lib$(lastword $(subst =, ,$(1))).a.xyzzy endif endef -include config.mak include package/targets.mak $(foreach var,$(LIB_DEFS),$(eval $(call library_definition,$(var)))) include package/deps.mak version_m := $(basename $(version)) version_M := $(basename $(version_m)) version_l := $(basename $(version_M)) CPPFLAGS_ALL := $(CPPFLAGS_AUTO) $(CPPFLAGS) CFLAGS_ALL := $(CFLAGS_AUTO) $(CFLAGS) ifeq ($(strip $(STATIC_LIBS_ARE_PIC)),) CFLAGS_SHARED := -fPIC else CFLAGS_SHARED := endif LDFLAGS_ALL := $(LDFLAGS_AUTO) $(LDFLAGS) AR := $(CROSS_COMPILE)ar RANLIB := $(CROSS_COMPILE)ranlib STRIP := $(CROSS_COMPILE)strip INSTALL := ./tools/install.sh ALL_BINS := $(LIBEXEC_TARGETS) $(BIN_TARGETS) ALL_LIBS := $(SHARED_LIBS) $(STATIC_LIBS) $(INTERNAL_LIBS) ALL_INCLUDES := $(wildcard src/include/$(package)/*.h) all: $(ALL_LIBS) $(ALL_BINS) $(ALL_INCLUDES) clean: @exec rm -f $(ALL_LIBS) $(ALL_BINS) $(wildcard src/*/*.o src/*/*.lo) $(EXTRA_TARGETS) distclean: clean @exec rm -f config.mak src/include/$(package)/config.h tgz: distclean @. package/info && \ rm -rf /tmp/$$package-$$version && \ cp -a . /tmp/$$package-$$version && \ cd /tmp && \ tar -zpcv --owner=0 --group=0 --numeric-owner --exclude=.git* -f /tmp/$$package-$$version.tar.gz $$package-$$version && \ exec rm -rf /tmp/$$package-$$version strip: $(ALL_LIBS) $(ALL_BINS) ifneq ($(strip $(STATIC_LIBS)),) exec $(STRIP) -x -R .note -R .comment -R .note.GNU-stack $(STATIC_LIBS) endif ifneq ($(strip $(ALL_BINS)$(SHARED_LIBS)),) exec $(STRIP) -R .note -R .comment -R .note.GNU-stack $(ALL_BINS) $(SHARED_LIBS) endif install: install-dynlib install-libexec install-bin install-lib install-include install-dynlib: $(SHARED_LIBS:lib%.so.xyzzy=$(DESTDIR)$(dynlibdir)/lib%.so) install-libexec: $(LIBEXEC_TARGETS:%=$(DESTDIR)$(libexecdir)/%) install-bin: $(BIN_TARGETS:%=$(DESTDIR)$(bindir)/%) install-lib: $(STATIC_LIBS:lib%.a.xyzzy=$(DESTDIR)$(libdir)/lib%.a) install-include: $(ALL_INCLUDES:src/include/$(package)/%.h=$(DESTDIR)$(includedir)/$(package)/%.h) install-data: $(ALL_DATA:src/etc/%=$(DESTDIR)$(datadir)/%) ifneq ($(exthome),) $(DESTDIR)$(exthome): $(DESTDIR)$(home) exec $(INSTALL) -l $(notdir $(home)) $(DESTDIR)$(exthome) update: $(DESTDIR)$(exthome) global-links: $(DESTDIR)$(exthome) $(SHARED_LIBS:lib%.so.xyzzy=$(DESTDIR)$(sproot)/library.so/lib%.so.$(version_M)) $(BIN_TARGETS:%=$(DESTDIR)$(sproot)/command/%) $(DESTDIR)$(sproot)/command/%: $(DESTDIR)$(home)/command/% exec $(INSTALL) -D -l ..$(subst $(sproot),,$(exthome))/command/$( s6-portable-utils: the s6-hiercopy program

s6-portable-utils
Software
skarnet.org

The s6-hiercopy program

s6-hiercopy copies a directory structure recursively.

Interface 

     s6-hiercopy source destination
  • s6-hiercopy recursively copies source to destination, which is created if it doesn't exist. The permissions are preserved. The owner and group are preserved if the user is the superuser.
  • It exits 0 on success and 111 on temporary failure.

Notes

  • Copying files and browsing through directories is one of Unix's weakest points, and s6-hiercopy is not meant to work around the problem; it's only a quick hack that I needed to boot my embedded platform. I originally planned to write the ultimate cp utility, portable and reliable and featureful and everything - while needing approximately a hundred times less resources than GNU cp does, of course. But I eventually dropped the idea: it's impossible to design, much less write, such a utility. Notably, you cannot make it reliable because Unix's set of filesystem management primitives is just too weak. It lacks a lot of atomic operations, and filesystem transactions. As a result, s6-hiercopy is a walking race condition and should absolutely not be considered instant when used in a multitasking environment. But then, cp shouldn't either.
  • There is no standard way of creating device nodes on a filesystem, so any cp-like utility is inherently non-portable. Fortunately, most systems still agree on the non-portable usages of mknod specification, so things should work in practice. Consequently, the s6-hiercopy utility has been moved from s6-linux-utils to s6-portable-utils.
s6-portable-utils-2.2.2.1/doc/s6-unquote.html0000644000000000000000000000357213111013207015513 0ustar s6-portable-utils: the s6-unquote program

s6-portable-utils
Software
skarnet.org

The s6-unquote program

s6-unquote unquotes a quoted string and writes it to stdout.

Interface 

     s6-unquote [ -n ] [ -d delim ] string
  • s6-unquote unquotes string, which must follow the syntax of s6-quote's output strings
  • It prints various warning or error messages to stderr if it cannot unquote string properly
  • If successful, it prints the result to stdout and exits 0

Options

  • -n : do not print a trailing newline.
  • -d delim : a list of characters that will be considered as delimitors (to start and end the quoted string). By default, only the double quote is such a character. If delim is the empty string, s6-unquote interprets string as non-delimited, only escaped (i.e. the result of some s6-quote -u operation).

Notes

s6-portable-utils-2.2.2.1/doc/s6-update-symlinks.html0000644000000000000000000000711713111013207017143 0ustar s6-portable-utils: the s6-update-symlinks program

s6
Software
skarnet.org

The s6-update-symlinks program

s6-update-symlinks links the content of several similar directory trees under a single tree. Its main use is to replace search paths like $PATH or $MANPATH, by creating a unique access tree based on the source trees. Name conflicts are solved by giving precedence to the last named directory. Subdirectories are created exactly as needed ; what can be shared is shared.

s6-update-symlinks is useful when one wants to combine a logical package system, like Dan Bernstein's /package and /command, with physical filesystem constraints, like /, /usr and /usr/local on separate filesystems.

Interface 

     s6-update-symlinks d src1 src2 ...
  • d is the destination directory. It will be created if it doesn't exist.
  • src1, src2, ... are the directory containing the files to be linked.
  • d and srcn must be absolute paths, else s6-update-symlinks refuses to run. Using relative paths doesn't make sense here, anyway.
  • If src2 is empty, then d becomes a link to src1.
  • If src1 is empty or entirely overridden by src2, then d becomes a link to src2.
  • If src1/file exists but not src2/file, then d becomes a real directory and d/file a link to src1/file. Then if src2/file2 exists, d/file2 links to it.
  • And so on with other src directories, and subdirs.
  • If s6-update-symlinks manages to performs all the requested tasks, it exits 0. If it encounters a hard error, it exits 111. If it is unable to resolve a conflict between given sources, it exits 100.

Examples

  • s6-update-symlinks /command /bin /sbin /usr/bin /usr/sbin /usr/local/bin /usr/local/sbin
    makes all files under /bin, ..., /usr/local/sbin available under /command. The programs linked are the same as the ones that would be accessed with PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin".
  • s6-update-symlinks /package /initrd/package /slash/package /usr/package /usr/local/package
    builds a /package hierarchy with what it finds in the listed directories. This allows oddities like, for instance, having the daemontools sources in /usr/package/admin/daemontools/src, and the daemontools binaries in /initrd/package/admin/daemontools/bin, but accessing both through /package/admin/daemontools/.
s6-portable-utils-2.2.2.1/doc/index.html0000644000000000000000000001553213553360404014611 0ustar s6-portable-utils - skarnet.org's tiny general Unix utilities

Software
skarnet.org

s6-portable-utils

What is it ?

s6-portable-utils is a set of tiny general Unix utilities, often performing well-known tasks such as cut and grep, but optimized for simplicity and small size. They were designed for embedded systems and other constrained environments, but they work everywhere.

Other set of small utilities are usually system-specific; for instance, the (otherwise good) BusyBox project only works on Linux.

Some of s6-portable-utils' programs are a conformant implementation of a POSIX utility as determined by the Single Unix Specification, version 4; the relevant documentation pages mentions this. However, none of the s6-portable-utils programs supports internationalization.

It is now an explicit non-goal of s6-portable-utils to duplicate the work of existing projects that aim to provide a lightweight implementation of standard commands. No more rewriting of standard commands will occur in s6-portable-utils; the package is now used to host specific utilities such as s6-uniquename.

Installation

Requirements

  • A POSIX-compliant system with a standard C development environment
  • GNU make, version 3.81 or later
  • skalibs version 2.9.1.0 or later. It's a build-time requirement. It's also a run-time requirement if you link against the shared version of the skalibs library.

Licensing

s6-portable-utils is free software. It is available under the ISC license.

Download

  • The current released version of s6-portable-utils is 2.2.2.1.
  • Alternatively, you can checkout a copy of the s6-portable-utils git repository: 
     git clone git://git.skarnet.org/s6-portable-utils
  • There's also a GitHub mirror of the s6-portable-utils git repository.

Compilation

  • See the enclosed INSTALL file for installation details.

Upgrade notes

  • This page lists the differences to be aware of between the previous versions of s6-portable-utils and the current one.

Reference

Commands

All these commands exit 111 if they encounter a temporary error, and 100 if they encounter a permanent error - such as a misuse. They exit 127 if they're trying to execute into a program and cannot find it, and 126 if they fail to execute into a program for another reason.

Related resources

  • s6-portable-utils is discussed on the skaware mailing-list.
s6-portable-utils-2.2.2.1/doc/s6-ls.html0000644000000000000000000000317013111013176014430 0ustar s6-portable-utils: the s6-ls program

s6-portable-utils
Software
skarnet.org

The s6-ls program

s6-ls lists the contents of a directory.

Interface 

     s6-ls [ -0 ] [ -a | -A ] [ -x exclude ] dir

s6-ls lists the contents of dir, one file per line. It omits files starting with a dot.

Options

  • -0 : separate file names with a null character instead of a newline.
  • -a : do not omit files starting with a dot. Do not list . or .. though.
  • -A : do not omit files starting with a dot, even . and ..
  • -x exclude : if a file name is exclude, do not print it.

Posixness

s6-ls is not suitable as a Single Unix ls program.

s6-portable-utils-2.2.2.1/doc/s6-sleep.html0000644000000000000000000000303313111013176015120 0ustar s6-portable-utils: the s6-sleep program

s6-portable-utils
Software
skarnet.org

The s6-sleep program

s6-sleep sleeps for a given time, then optionally executes a program.

Interface 

     s6-sleep [ -m ] time [ prog... ]
  • s6-sleep acts as the generic sleep utility. It ignores non-lethal signals.
  • If there are prog... arguments, then s6-sleep executes into prog... after sleeping. Else, it exits 0.

Extra options

  • -m : Interpret time as milliseconds instead of seconds.

Posixness

s6-sleep is suitable as a Single Unix sleep program.

s6-portable-utils-2.2.2.1/doc/s6-unquote-filter.html0000644000000000000000000000503313111013176016775 0ustar s6-portable-utils: the s6-unquote-filter program

s6-portable-utils
Software
skarnet.org

The s6-unquote-filter program

s6-unquote acts as a filter, reading quoted strings on stdin, unquoting them and writing the results to stdout.

Interface 

     s6-unquote-filter [ -q | -Q | -v | -w ] [ -d delim ]
  • s6-unquote-filter reads lines on stdin. It exits 0 on EOF.
  • It expects read lines to follow the syntax of s6-quote's output strings
  • Depending on the strictness options, it prints various warning or error messages to stderr if it cannot properly unquote lines. In the very strict mode, it exits 100 on the first unquoting error.
  • If it is successful at unquoting, it prints the resulting lines to stdout.

Options

  • -d delim : a list of characters that will be considered as delimitors (to start and end the quoted string). By default, only the double quote is such a character. If delim is the empty string, s6-unquote-filter interprets string as non-delimited, only escaped (i.e. for instance the result of some s6-quote-filter -u operation).
  • -q : loose/quiet mode. s6-unquote-filter will silently accommodate errors.
  • -Q : normal mode. This is the default. s6-unquote-filter will warn on errors.
  • -v : strict/verbose mode. s6-unquote-filter will warn loudly on errors, with many details.
  • -w : very strict mode. s6-unquote-filter will complain and die on the first unquoting error it encounters.

Notes

s6-portable-utils-2.2.2.1/doc/s6-rename.html0000644000000000000000000000171013111013176015257 0ustar s6-portable-utils: the s6-rename program

s6-portable-utils
Software
skarnet.org

The s6-rename program

s6-rename atomically renames a file.

Interface 

     s6-rename old new

s6-rename atomically renames old to new.

s6-portable-utils-2.2.2.1/doc/s6-seq.html0000644000000000000000000000402613111013176014603 0ustar s6-portable-utils: the s6-seq program

s6-portable-utils
Software
skarnet.org

The s6-seq program

s6-seq prints a sequence of numbers.

Interface 

     s6-seq [ -w ] [ -s separator ] limits
  • limits can be one, two or three arguments.
    • Three arguments are interpreted as first, increment and last, in this order.
    • Two arguments are interpreted as first and last, and increment defaults to 1.
    • One argument is interpreted as last, and first and increment both default to 1.
  • s6-seq prints all unsigned integers from first to last inclusive, with a step of increment, with a newline after each integer. It then exits 0.

Options

  • -w : fixed width. The numbers will all be printed with the same width; smaller numbers will have leading 0 characters.
  • -s sep : print sep after each number. Default is a newline. If sep is the empty string, a null character will be printed.

Notes

s6-seq is similar to the GNU seq program. However, it does not handle negative numbers, floating point numbers or printf-style formatting.

s6-portable-utils-2.2.2.1/doc/s6-clock.html0000644000000000000000000000310113111013176015077 0ustar s6-portable-utils: the s6-clock program

s6-portable-utils
Software
skarnet.org

The s6-clock program

s6-clock gets or sets the system clock.

Interface 

     s6-clock [ label ]

When called without an argument, s6-clock writes the current system time, as a TAI64N timestamp, to stdout.

When given an argument label, which must be a TAI64N timestamp, s6-clock sets the system time to this value.

Notes

  • s6-clock only prints or accepts TAI time, no matter what the system clock is set to (TAI-10 or UTC); it will automatically make the right conversions for your system clock. Make sure your skalibs has been built with the right settings.
s6-portable-utils-2.2.2.1/doc/s6-quote.html0000644000000000000000000000353113111013176015150 0ustar s6-portable-utils: the s6-quote program

s6-portable-utils
Software
skarnet.org

The s6-quote program

s6-quote quotes a string and writes it to stdout.

Interface 

     s6-quote [ -n ] [ -u ] [ -d delim ] string
  • s6-quote quotes string, putting it inside double quotes and escaping all dubious characters
  • It writes the quoted string to stdout and exits 0

Options

  • -n : do not print a trailing newline
  • -u : do not put string inside double quotes, only escape characters if needed
  • -d delim : use the first character of delim as a quote character, instead of double quotes

Notes

  • Quoted strings are guaranteed to be pure printable ASCII, without control characters.
  • Quoted strings can be unquoted via the s6-unquote or s6-unquote-filter programs.
  • Quoted strings are suitable for interpretation by execlineb.
s6-portable-utils-2.2.2.1/doc/s6-mkfifo.html0000644000000000000000000000232413111013176015265 0ustar s6-portable-utils: the s6-mkfifo program

s6-portable-utils
Software
skarnet.org

The s6-mkfifo program

s6-mkfifo creates FIFOs, a.k.a. named pipes.

Interface 

     s6-mkfifo [ -m mode ] [ fifo... ]

s6-mkfifo acts as the generic mkfifo utility.

Posixness

s6-mkfifo is suitable as a Single Unix mkfifo program.

s6-portable-utils-2.2.2.1/doc/s6-format-filter.html0000644000000000000000000000300413111013176016561 0ustar s6-portable-utils: the s6-format-filter program

s6-portable-utils
Software
skarnet.org

The s6-format-filter program

s6-format-filter processes lines according to its arguments, and prints the result.

Interface 

     s6-format-filter format [ args... ]
  • format is a format string that can contain the following special sequences: %%, %s, and %0 to %9.
  • For every line it reads on stdin, s6-format-filter prints format on stdout, replacing %% with %, %0 with the command name (probably s6-format-filter), %1 to %9 with the first to the ninth argument in args, and %s with the input line.
  • s6-format-filter exits 0 when it reads EOF.
s6-portable-utils-2.2.2.1/doc/s6-cut.html0000644000000000000000000000233013111013176014602 0ustar s6-portable-utils: the s6-cut program

s6-portable-utils
Software
skarnet.org

The s6-cut program

s6-cut prints selected portions of the lines of its input.

Interface 

     s6-cut [ -b list | -c list | -f list ] [ -n ] [ -s ] [ file ... ]

s6-cut acts as the generic cut utility.

Posixness

s6-cut is suitable as a Single Unix cut program.

s6-portable-utils-2.2.2.1/doc/s6-head.html0000644000000000000000000000326413111013176014717 0ustar s6-portable-utils: the s6-head program

s6-portable-utils
Software
skarnet.org

The s6-head program

s6-head prints the first lines of its input files.

Interface 

     s6-head [ -S ] [ -1..9 | -n lines | -c chars ] file...

s6-head acts as the generic head utility.

Extra options

  • -S : safe mode. s6-head stops reading its input files right after getting all the lines it needs. The rest of the stream can then be handled by other utilities without any data loss.
  • -1..9 : equivalent to -n 1 .. -n 9.
  • -c chars : cuts after chars characters instead of lines lines.

Posixness

s6-head is suitable as a Single Unix head program.

s6-portable-utils-2.2.2.1/doc/s6-rmrf.html0000644000000000000000000000170013111013176014755 0ustar s6-portable-utils: the s6-rmrf program

s6-portable-utils
Software
skarnet.org

The s6-rmrf program

s6-rmrf removes a file or directory tree entirely.

Interface 

     s6-rmrf subtree

s6-rmrf removes the subtree file hierarchy.

s6-portable-utils-2.2.2.1/doc/s6-env.html0000644000000000000000000000237513111013176014610 0ustar s6-portable-utils: the s6-env program

s6-portable-utils
Software
skarnet.org

The s6-env program

s6-env prints the current environment or modifies the environment before running a program.

Interface 

     s6-env [ -i ] [ name=value... ] [ prog... ]

s6-env acts as the generic env utility.

Posixness

s6-env is suitable as a Single Unix env program.

s6-portable-utils-2.2.2.1/doc/s6-uniquename.html0000644000000000000000000000255613111013176016170 0ustar s6-portable-utils: the s6-uniquename program

s6-portable-utils
Software
skarnet.org

The s6-uniquename program

s6-uniquename creates a guaranteed unique file name and prints it to stdout.

Interface 

     s6-uniquename [ -n randomlen ] prefix
  • s6-uniquename creates a unique filename starting with prefix involving a TAI64N timestamp, the machine's FQDN and the process' PID.
  • It prints it to stdout and exits 0.

Options

  • -n randomlen : for added security, also add a random readable string of randomlen characters to the created pathname.
s6-portable-utils-2.2.2.1/doc/s6-quote-filter.html0000644000000000000000000000337213111013176016436 0ustar s6-portable-utils: the s6-quote-filter program

s6-portable-utils
Software
skarnet.org

The s6-quote-filter program

s6-quote-filter acts as a filter, quoting lines it reads on stdin and writing the quoted lines to stdout.

Interface 

     s6-quote-filter [ -u ] [ -d delim ]
  • s6-quote reads lines on stdin; it quotes every line, putting it inside double quotes and escaping all dubious characters
  • It writes the quoted strings to stdout
  • It exits 0 on EOF

Options

  • -u : do not put read lines inside double quotes, only escape characters if needed
  • -d delim : use the first character of delim as a quote character, instead of double quotes

Notes

  • Quoted strings are guaranteed to be pure printable ASCII, without control characters.
  • Quoted strings can be unquoted via the s6-unquote or s6-unquote-filter programs.
s6-portable-utils-2.2.2.1/doc/s6-sync.html0000644000000000000000000000161113111013176014764 0ustar s6-portable-utils: the s6-sync program

s6-portable-utils
Software
skarnet.org

The s6-sync program

s6-sync flushes all the dirty system buffers, and blocks until they're clean.

Interface 

     s6-sync
s6-portable-utils-2.2.2.1/doc/s6-echo.html0000644000000000000000000000254713111013176014737 0ustar s6-portable-utils: the s6-echo program

s6-portable-utils
Software
skarnet.org

The s6-echo program

s6-echo writes its arguments to stdout.

Interface 

     s6-echo [ -n ] [ -s sep ] args...

s6-echo writes its arguments args to stdout, separated with spaces.

Options

  • -n : do not output a trailing newline.
  • -s sep : separate arguments with the sep character instead of a space.

Posixness

s6-echo is not suitable as a Single Unix echo program.

s6-portable-utils-2.2.2.1/doc/s6-pause.html0000644000000000000000000000315513111013176015132 0ustar s6-portable-utils: the s6-pause program

s6-portable-utils
Software
skarnet.org

The s6-pause program

s6-pause blocks until it is killed.

Interface 

     s6-pause [ -t ] [ -h ] [ -a ] [ -q ] [ -b ] [ -i ] [ -p signals ]

Options

  • -t : ignore SIGTERM
  • -h : ignore SIGHUP
  • -a : ignore SIGALRM
  • -q : ignore SIGQUIT
  • -b : ignore SIGABRT
  • -i : ignore SIGINT
  • -p signals : ignore the signals listed in signals, which must be a comma-separated list of signal numbers.

Usage notes

  • s6-pause is one of the smallest possible long-lived programs. It uses as few resources as the kernel will allow.
  • The options can be used to wait for a specific signal without being killed by others.
s6-portable-utils-2.2.2.1/doc/seekablepipe.html0000644000000000000000000000230613111013176016115 0ustar s6-portable-utils: the seekablepipe program

s6-portable-utils
Software
skarnet.org

The seekablepipe program

seekablepipe turns the reading end of a pipe into a seekable file descriptor, using a temporary file.

Interface 

     writer | seekablepipe tmpfile reader [ args ... ]

seekablepipe writes writer's output to tmpfile, which is unlinked as soon as it is created. Then it execs into reader, reading from a file descriptor on tmpfile.

s6-portable-utils-2.2.2.1/doc/s6-printenv.html0000644000000000000000000000254013111013176015657 0ustar s6-portable-utils: the s6-printenv program

s6-portable-utils
Software
skarnet.org

The s6-printenv program

s6-printenv prints its environment variables.

Interface 

     s6-printenv [ -n ] [ -0 | -d delim ]

s6-printenv prints its environment on stdout, like s6-env.

Options

  • -0 : separate variable definitions with a null character instead of a newline.
  • -d delim : separate variable definitions with the first character of delim instead of a newline
  • -n : omit the last delimiter character
s6-portable-utils-2.2.2.1/doc/s6-ln.html0000644000000000000000000000440413111013176014424 0ustar s6-portable-utils: the s6-ln program

s6-portable-utils
Software
skarnet.org

The s6-ln program

s6-ln creates a link to a file.

Interface 

     s6-ln [ -n ] [ -s ] [ -f ] [ -L ] [ -P ] source... target

s6-ln acts as the generic ln utility.

Options

  • -s : create a symbolic link instead of a hard link
  • -f : force replacement of an existing target
  • -L : link targets of symlinks in source...
  • -P : link symlinks in source... themselves
  • -n : if target is a symlink to a directory, replace it instead of adding a link in the directory

Posixness

s6-ln would be suitable as a Single Unix ln program, except that POSIX mandates that a preexisting target must first be unlink()ed and then (sym)link()ed, which prevents atomic replacements. s6-ln aims to be reliable and allow for atomic replacements, so it deviates from POSIX on that point: when target exists and needs to be replaced, s6-ln first creates a (sym)link to a unique temporary name, then rename()s the temporary name to target. This behaviour makes sure that target is atomically replaced - there's no point in time where it does not exist.

s6-portable-utils-2.2.2.1/doc/s6-sort.html0000644000000000000000000000337713111013176015012 0ustar s6-portable-utils: the s6-sort program

s6-portable-utils
Software
skarnet.org

The s6-sort program

s6-sort sorts its input.

Interface 

     s6-sort [ -b ] [ -c ] [ -f ] [ -r ] [ -u ] [ -0 ]
  • s6-sort reads its stdin until EOF
  • It sorts all the lines it read alphanumerically
  • It prints the sorted lines to stdout and exits 0

Options

  • -b : ignore leading spaces and tabs at the beginning of each line when sorting
  • -c : suppresses normal output, just returns 0 if the output would have been the same as the input and 1 otherwise
  • -f : ignore case when sorting
  • -r : reverse sort
  • -u : suppresses duplicate lines
  • -0 : input and output lines are separated by null characters instead of newlines

Posixness

s6-sort is not suitable as a Single Unix sort program.

s6-portable-utils-2.2.2.1/doc/upgrade.html0000644000000000000000000000666013553360432015134 0ustar s6-portable-utils: how to upgrade

s6-portable-utils
Software
skarnet.org

What has changed in s6-portable-utils

in 2.2.2.1

  • skalibs dependency bumped to 2.9.1.0.

in 2.2.2.0

  • skalibs dependency bumped to 2.9.0.0.

in 2.2.1.3

  • skalibs dependency bumped to 2.8.0.0.
  • Everything now builds as PIC by default no matter the toolchain's settings. Use the --disable-all-pic configure option to build executables and static libraries as non-PIC.

in 2.2.1.2

  • skalibs dependency bumped to 2.7.0.0.

in 2.2.1.1

  • skalibs dependency bumped to 2.6.0.0.

in 2.2.1.0

  • skalibs dependency bumped to 2.5.1.0.
  • s6-ln now accepts the nonstandard -n option.

in 2.2.0.0

  • skalibs dependency bumped to 2.5.0.0.

in 2.1.0.0

  • skalibs dependency bumped to 2.4.0.0.

in 2.0.6.0

  • skalibs dependency bumped to 2.3.10.0.

in 2.0.5.3

  • GNU make dependency pushed back to 3.81.
  • skalibs dependency bumped to 2.3.8.0.

in 2.0.5.2

  • Bugfix release, no changes.

in 2.0.5.1

  • skalibs dependency bumped to 2.3.6.1.

in 2.0.5.0

  • skalibs dependency bumped to 2.3.4.0.
  • New command: s6-seq.

in 2.0.4.0

in 2.0.3.0

in 2.0.2.0

  • skalibs dependency bumped to 2.3.1.0.
  • s6-hiercopy now belongs to this package. (It formely belonged to s6-linux-utils, but it is actually portable in practice.)

in 2.0.1.0

  • skalibs dependency bumped to 2.2.0.0.
  • seekablepipe moved from s6-networking to s6-portable-utils.

in 2.0.0.1

  • skalibs dependency bumped to 2.1.0.0.

in 2.0.0.0

  • The build system has completely changed. It is now a standard ./configure && make && sudo make install build system. See the enclosed INSTALL file for details.
  • slashpackage is not activated by default.
  • shared libraries are not used by default.
  • skalibs dependency bumped to 2.0.0.0.
s6-portable-utils-2.2.2.1/doc/s6-dumpenv.html0000644000000000000000000000311613111013176015470 0ustar s6-portable-utils: the s6-dumpenv program

s6-portable-utils
Software
skarnet.org

The s6-dumpenv program

s6-dumpenv stores its environment variables into a directory.

Interface 

     s6-dumpenv [ -m mode ] dir
  • s6-dumpenv creates the directory dir if it does not exist yet.
  • For every environment variable x with value y that it has, it creates a file dir/x containing y.
  • It then exits 0.

Options

  • -m mode : create dir with mode mode if it doesn't exist yet. Default is 0755.

Notes

  • A program prog can be run with the environment in dir by using s6-envdir -fn -- dir prog.
s6-portable-utils-2.2.2.1/doc/s6-false.html0000644000000000000000000000177613111013176015116 0ustar s6-portable-utils: the s6-false program

s6-portable-utils
Software
skarnet.org

The s6-false program

s6-false returns 1.

Interface 

     s6-false

Posixness

s6-false is suitable as a Single Unix false program.

s6-portable-utils-2.2.2.1/doc/s6-dirname.html0000644000000000000000000000247613111013176015441 0ustar s6-portable-utils: the s6-dirname program

s6-portable-utils
Software
skarnet.org

The s6-dirname program

s6-dirname prints the dirname of a path.

Interface 

     s6-dirname [ -n ] path

s6-dirname acts as the generic dirname utility.

Extra options

  • -n : do not print a trailing newline after the output.

Posixness

s6-dirname is suitable as a Single Unix dirname program.

s6-portable-utils-2.2.2.1/doc/s6-tail.html0000644000000000000000000000266313111013176014751 0ustar s6-portable-utils: the s6-tail program

s6-portable-utils
Software
skarnet.org

The s6-tail program

s6-tail prints a file or its stdin after a certain number of bytes or lines.

Interface 

     s6-tail [ -n lines | -c chars ] [ file ]

s6-tail acts as the generic tail utility, except that the -f option is not supported.

Posixness

s6-tail is not suitable as a Single Unix tail program; however, if you are never using the -f functionality, s6-tail scrupulously follows the rest of the specification.

s6-portable-utils-2.2.2.1/doc/s6-true.html0000644000000000000000000000176613111013176015002 0ustar s6-portable-utils: the s6-true program

s6-portable-utils
Software
skarnet.org

The s6-true program

s6-true returns 0.

Interface 

     s6-true

Posixness

s6-true is suitable as a Single Unix true program.

s6-portable-utils-2.2.2.1/doc/s6-basename.html0000644000000000000000000000255513111013176015573 0ustar s6-portable-utils: the s6-basename program

s6-portable-utils
Software
skarnet.org

The s6-basename program

s6-basename prints the basename of a pathname.

Interface 

     s6-basename [ -n ] path [ suffix ]

s6-basename acts as the generic basename utility.

Extra options

  • -n : do not print a trailing newline after the output.

Posixness

s6-basename is suitable as a Single Unix basename program.

s6-portable-utils-2.2.2.1/doc/s6-expr.html0000644000000000000000000000273013111013176014771 0ustar s6-portable-utils: the s6-expr program

s6-portable-utils
Software
skarnet.org

The s6-expr program

s6-expr evaluates an expression and writes the result to stdout.

Interface 

     s6-expr expression...

s6-expr acts as the generic expr utility, except that the : operator (pattern matching) is not supported.

s6-expr accepts an arbitrary number of arguments.

Posixness

s6-expr is not suitable as a Single Unix expr program; however, if you are never using the pattern matching functionality, s6-expr scrupulously follows the rest of the specification.

s6-portable-utils-2.2.2.1/doc/s6-grep.html0000644000000000000000000000450013111013176014745 0ustar s6-portable-utils: the s6-grep program

s6-portable-utils
Software
skarnet.org

The s6-grep program

s6-grep matches its input against a pattern.

Interface 

     s6-grep [ -E | -F ] [ -i ] [ -c ] [ -n ] [ -q ] [ -v ] pattern
  • s6-grep compiles pattern as a Basic Regular Expression
  • It reads stdin and matches every line against this regexp
  • If the line matches, it prints it to stdout
  • It exits on EOF with code 0 if one or more lines matched and 1 otherwise.

Options

  • -F : pattern is not compiled as a BRE, but is interpreted as a literal string.
  • -E : pattern is not compiled as a BRE, but as an Extended Regular Expression (ERE).
  • -i : ignore case during the match
  • -c : do not write normal output; only write the number of lines that have matched pattern after EOF is received
  • -n : precede every output line by its number and a colon. The first input line has number 1.
  • -q : do not write anything to stdout
  • -v : invert the pattern matching (select lines that do not match pattern).

Posixness

s6-grep is not suitable as a Single Unix grep program.

s6-portable-utils-2.2.2.1/doc/s6-cat.html0000644000000000000000000000234713111013176014566 0ustar s6-portable-utils: the s6-cat program

s6-portable-utils
Software
skarnet.org

The s6-cat program

s6-cat copies stdin to stdout.

Interface 

     s6-cat

s6-cat transfers data from stdin to stdout, until it receives EOF or gets killed.

Notes

On systems that support it (as of 2.0.0.0, only Linux 2.6.17 or later), s6-cat performs zero-copy transfer.

Posixness

s6-cat is not suitable as a Single Unix cat program.

s6-portable-utils-2.2.2.1/doc/s6-linkname.html0000644000000000000000000000253413405477300015624 0ustar s6-portable-utils: the s6-linkname program

s6-portable-utils
Software
skarnet.org

The s6-linkname program

s6-linkname gives the content of a symbolic link or resolves a path.

Interface 

     s6-linkname [ -f ] [ -n ] path
  • If path is a symbolic link, s6-linkname prints its content then exits 0.
  • Else it prints an error message and exits 111.

Options

  • -f : s6-linkname fully resolves path then prints the result on stdout. path does not have to be a symbolic link.
  • -n : do not print a newline after the result.
s6-portable-utils-2.2.2.1/doc/s6-touch.html0000644000000000000000000000232213111013176015132 0ustar s6-portable-utils: the s6-touch program

s6-portable-utils
Software
skarnet.org

The s6-touch program

s6-touch changes the modification and access times of a file, creating it if it does not exist.

Interface 

     s6-touch file...

s6-touch touches every file in the list by opening them for appending then closing them.

Posixness

s6-touch is not suitable as a Single Unix touch program.

s6-portable-utils-2.2.2.1/doc/s6-nuke.html0000644000000000000000000000306713111013176014761 0ustar s6-portable-utils: the s6-nuke program

s6-portable-utils
Software
skarnet.org

The s6-nuke program

s6-nuke sends signals to every process it is allowed to send.

Interface 

     s6-nuke [ -h | -t | -k ]
  • Depending on the options it is given, s6-nuke sends signals to all processes; depending on s6-nuke's rights, not all processes may receive them.
  • s6-nuke protects itself against the signals it sends (which doesn't do much good against SIGKILL). If it survives the blast, it exits 0.

Options

  • -h : send a SIGHUP
  • -t : send a SIGTERM then a SIGCONT
  • -k : send a SIGKILL

Usage notes

s6-nuke can be used during the shutdown procedure of a system, which is described here.

s6-portable-utils-2.2.2.1/doc/s6-test.html0000644000000000000000000000345013111013176014772 0ustar s6-portable-utils: the s6-test program

s6-portable-utils
Software
skarnet.org

The s6-test program

s6-test evaluates an expression and indicates the result via its exit status.

Interface 

     s6-test expression...

s6-test acts as the generic test utility, but it diverges from the specification on one point: if an argument starts with a backslash, this backslash is ignored (and the argument cannot be an operation). This is a simple disambiguation technique that has unfortunately not been chosen by the standard.

s6-test accepts an arbitrary number of arguments.

Posixness

s6-test is not suitable as a Single Unix test program; however, if your arguments never start with a backslash, it exhibits the exact same behaviour.

Non-standard expressions

  • -v VAR : tests whether the VAR variable is defined in the current environment.
s6-portable-utils-2.2.2.1/doc/s6-mkdir.html0000644000000000000000000000246113111013176015122 0ustar s6-portable-utils: the s6-mkdir program

s6-portable-utils
Software
skarnet.org

The s6-mkdir program

s6-mkdir creates directories.

Interface 

     s6-mkdir [ -p ] [ -v ] [ -m mode ] [ dir... ]

s6-mkdir acts as the generic mkdir utility.

Extra options

  • -v : write what it does to stderr.

Posixness

s6-mkdir is suitable as a Single Unix mkdir program.

s6-portable-utils-2.2.2.1/doc/s6-chmod.html0000644000000000000000000000234113111013176015103 0ustar s6-portable-utils: the s6-chmod program

s6-portable-utils
Software
skarnet.org

The s6-chmod program

s6-chmod changes the permissions of a file.

Interface 

     s6-chmod perms file

s6-chmod changes file's permissions to perms, which must be an absolute octal number such as 0755 for rwxr-xr-x or 2700 for rwx--S---.

Posixness

s6-chmod is not suitable as a Single Unix chmod program.

s6-portable-utils-2.2.2.1/doc/s6-maximumtime.html0000644000000000000000000000407113111013176016347 0ustar s6-portable-utils: the s6-maximumtime program

s6-portable-utils
Software
skarnet.org

The s6-maximumtime program

s6-maximumtime executes a program with a time limit.

Interface 

     s6-maximumtime [ -0 | -a | -b | -i | -k | -q | -t | -x | -1 | -2 ] milli prog...
  • s6-maximumtime forks and execs prog... as a child.
  • If milli milliseconds elapse before prog exits, s6-maximumtime sends it a signal and exits 99 with a message.
  • Else s6-maximumtime exits with the same exit code as prog.

Options

  • -0 : on timeout, do not send any signal, just exit
  • -a : on timeout, send a SIGALRM
  • -b : on timeout, send a SIGABRT
  • -i : on timeout, send a SIGINT
  • -k : on timeout, send a SIGKILL
  • -q : on timeout, send a SIGQUIT
  • -t : on timeout, send a SIGTERM - this is the default
  • -x : on timeout, send a SIGXCPU
  • -1 : on timeout, send a SIGUSR1
  • -2 : on timeout, send a SIGUSR2

Notes

  • If milli is 0, then it's interpreted as infinite: no time limit will be enforced.
s6-portable-utils-2.2.2.1/doc/s6-nice.html0000644000000000000000000000305413111013176014731 0ustar s6-portable-utils: the s6-nice program

s6-portable-utils
Software
www.skarnet.org

The s6-nice program

s6-nice executes into a program with an altered nice value.

Interface 

     s6-nice [ -I | -i ] [ -n value ] [ prog... ]

s6-nice acts as the generic nice utility.

Extra options

  • -I : loose. If the nice value cannot be set to value, print a warning message and exec into prog... anyway. This is the default.
  • -i : strict. If the nice value cannot be set to value, exit 111 with an error message.

Posixness

s6-nice is suitable as a Single Unix nice program.

s6-portable-utils-2.2.2.1/doc/s6-chown.html0000644000000000000000000000330713111340200015121 0ustar s6-portable-utils: the s6-chown program

s6-portable-utils
Software
skarnet.org

The s6-chown program

s6-chown changes the owner and/or group of a file.

Interface 

     s6-chown [ -U ] [ -u uid ] [ -g gid ] file
  • s6-chown changes file's owner to (numeric) uid and group to (numeric) gid.
  • If uid isn't provided, the owner remains the same; if gid isn't provided, the group remains the same.
  • The -U option sets uid to the value of the UID environment variable and gid to the value of the GID environment variable. This makes s6-chown easily usable with s6-envuidgid: s6-envuidgid account s6-chown -U file changes file's uid and gid to account's.

Posixness

s6-chown is not suitable as a Single Unix chown program.