10 files changed, 219 insertions, 71 deletions

diff --git a/libbb/Kbuild.src b/libbb/Kbuild.src
index fc9371db1..0d7dd2a2c 100644
--- a/libbb/Kbuild.src
+++ b/libbb/Kbuild.src
@@ -77,6 +77,7 @@ lib-y += safe_gethostname.o
 lib-y += safe_poll.o
 lib-y += safe_strncpy.o
 lib-y += safe_write.o
+lib-y += securetty.o
 lib-y += setup_environment.o
 lib-y += simplify_path.o
 lib-y += single_argv.o
diff --git a/libbb/bb_cat.c b/libbb/bb_cat.c
new file mode 100644
index 000000000..0a4a350fb
--- /dev/null
+++ b/libbb/bb_cat.c
@@ -0,0 +1,33 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Copyright (C) 2003  Manuel Novoa III  <mjn3@codepoet.org>
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
+//kbuild:lib-y += bb_cat.o
+
+#include "libbb.h"
+
+int FAST_FUNC bb_cat(char **argv)
+{
+        int fd;
+        int retval = EXIT_SUCCESS;
+
+        if (!*argv)
+                argv = (char**) &bb_argv_dash;
+
+        do {
+                fd = open_or_warn_stdin(*argv);
+                if (fd >= 0) {
+                        /* This is not a xfunc - never exits */
+                        off_t r = bb_copyfd_eof(fd, STDOUT_FILENO);
+                        if (fd != STDIN_FILENO)
+                                close(fd);
+                        if (r >= 0)
+                                continue;
+                }
+                retval = EXIT_FAILURE;
+        } while (*++argv);
+
+        return retval;
+}
diff --git a/libbb/correct_password.c b/libbb/correct_password.c
index 513c93028..f4635a5bc 100644
--- a/libbb/correct_password.c
+++ b/libbb/correct_password.c
@@ -63,7 +63,7 @@ static const char *get_passwd(const struct passwd *pw, char buffer[SHADOW_BUFSIZ
 }
 
 /*
- * Return 1 if PW has an empty password.
+ * Return CHECKPASS_PW_HAS_EMPTY_PASSWORD if PW has an empty password.
  * Return 1 if the user gives the correct password for entry PW,
  * 0 if not.
  * NULL pw means "just fake it for login with bad username"
@@ -77,7 +77,7 @@ int FAST_FUNC check_password(const struct passwd *pw, const char *plaintext)
 
         pw_pass = get_passwd(pw, buffer);
         if (!pw_pass[0]) { /* empty password field? */
-                return 1;
+                return CHECKPASS_PW_HAS_EMPTY_PASSWORD;
         }
 
         encrypted = pw_encrypt(plaintext, /*salt:*/ pw_pass, 1);
@@ -88,7 +88,7 @@ int FAST_FUNC check_password(const struct passwd *pw, const char *plaintext)
 
 
 /* Ask the user for a password.
- * Return 1 without asking if PW has an empty password.
+ * Return CHECKPASS_PW_HAS_EMPTY_PASSWORD without asking if PW has an empty password.
  * Return -1 on EOF, error while reading input, or timeout.
  * Return 1 if the user gives the correct password for entry PW,
  * 0 if not.
@@ -105,7 +105,7 @@ int FAST_FUNC ask_and_check_password_extended(const struct passwd *pw,
 
         pw_pass = get_passwd(pw, buffer);
         if (!pw_pass[0]) /* empty password field? */
-                return 1;
+                return CHECKPASS_PW_HAS_EMPTY_PASSWORD;
 
         plaintext = bb_ask(STDIN_FILENO, timeout, prompt);
         if (!plaintext) {
diff --git a/libbb/getopt32.c b/libbb/getopt32.c
index 03fca3493..b87b83538 100644
--- a/libbb/getopt32.c
+++ b/libbb/getopt32.c
@@ -128,7 +128,7 @@ const char *opt_complementary
  "abc"  If groups of two or more chars are specified, the first char
         is the main option and the other chars are secondary options.
         Their flags will be turned on if the main option is found even
-        if they are not specifed on the command line.  For example:
+        if they are not specified on the command line.  For example:
 
         opt_complementary = "abc";
         flags = getopt32(argv, "abcd")
@@ -576,13 +576,7 @@ getopt32(char **argv, const char *applet_opts, ...)
          * run_nofork_applet() does this, but we might end up here
          * also via gunzip_main() -> gzip_main(). Play safe.
          */
-#if defined(__GLIBC__) || ENABLE_PLATFORM_MINGW32
-        optind = 0;
-#else /* BSD style */
-        optind = 1;
-        /* optreset = 1; */
-#endif
-        /* optarg = NULL; opterr = 0; optopt = 0; - do we need this?? */
+        GETOPT_RESET();
 
         /* Note: just "getopt() <= 0" will not work well for
          * "fake" short options, like this one:
diff --git a/libbb/isqrt.c b/libbb/isqrt.c
new file mode 100644
index 000000000..817b7d036
--- /dev/null
+++ b/libbb/isqrt.c
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2017 Denys Vlasenko <vda.linux@googlemail.com>
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
+
+//kbuild:lib-y += isqrt.o
+
+#ifndef ISQRT_TEST
+# include "libbb.h"
+#else
+/* gcc -DISQRT_TEST -Wall -O2 isqrt.c -oisqrt && ./isqrt $((RANDOM*RANDOM)) */
+# include <stdlib.h>
+# include <stdio.h>
+# include <time.h>
+# define FAST_FUNC /* nothing */
+#endif
+
+/* Returns such x that x+1 > sqrt(N) */
+unsigned long FAST_FUNC isqrt(unsigned long long N)
+{
+        unsigned long x;
+        unsigned shift;
+#define LL_WIDTH_BITS (unsigned)(sizeof(N)*8)
+
+        shift = LL_WIDTH_BITS - 2;
+        x = 0;
+        do {
+                x = (x << 1) + 1;
+                if ((unsigned long long)x * x > (N >> shift))
+                        x--; /* whoops, that +1 was too much */
+                shift -= 2;
+        } while ((int)shift >= 0);
+        return x;
+}
+
+#ifdef ISQRT_TEST
+int main(int argc, char **argv)
+{
+        unsigned long long n = argv[1] ? strtoull(argv[1], NULL, 0) : time(NULL);
+        for (;;) {
+                unsigned long h;
+                n--;
+                h = isqrt(n);
+                if (!(n & 0xffff))
+                        printf("isqrt(%llx)=%lx\n", n, h);
+                if ((unsigned long long)h * h > n) {
+                        printf("BAD1: isqrt(%llx)=%lx\n", n, h);
+                        return 1;
+                }
+                h++;
+                if ((unsigned long long)h * h != 0 /* this can overflow to 0 - not a bug */
+                 && (unsigned long long)h * h <= n)
+                {
+                        printf("BAD2: isqrt(%llx)=%lx\n", n, h);
+                        return 1;
+                }
+        }
+}
+#endif
diff --git a/libbb/loop.c b/libbb/loop.c
index d30b378d7..f0d4296ae 100644
--- a/libbb/loop.c
+++ b/libbb/loop.c
@@ -78,22 +78,24 @@ int FAST_FUNC del_loop(const char *device)
         return rc;
 }
 
-/* Returns 0 if mounted RW, 1 if mounted read-only, <0 for error.
-   *device is loop device to use, or if *device==NULL finds a loop device to
-   mount it on and sets *device to a strdup of that loop device name.  This
-   search will re-use an existing loop device already bound to that
-   file/offset if it finds one.
+/* Returns opened fd to the loop device, <0 on error.
+ * *device is loop device to use, or if *device==NULL finds a loop device to
+ * mount it on and sets *device to a strdup of that loop device name.  This
+ * search will re-use an existing loop device already bound to that
+ * file/offset if it finds one.
  */
-int FAST_FUNC set_loop(char **device, const char *file, unsigned long long offset, int ro)
+int FAST_FUNC set_loop(char **device, const char *file, unsigned long long offset, unsigned flags)
 {
         char dev[LOOP_NAMESIZE];
         char *try;
         bb_loop_info loopinfo;
         struct stat statbuf;
-        int i, dfd, ffd, mode, rc = -1;
+        int i, dfd, ffd, mode, rc;
+
+        rc = dfd = -1;
 
         /* Open the file.  Barf if this doesn't work.  */
-        mode = ro ? O_RDONLY : O_RDWR;
+        mode = (flags & BB_LO_FLAGS_READ_ONLY) ? O_RDONLY : O_RDWR;
  open_ffd:
         ffd = open(file, mode);
         if (ffd < 0) {
@@ -144,20 +146,35 @@ int FAST_FUNC set_loop(char **device, const char *file, unsigned long long offse
 
                 /* If device is free, claim it.  */
                 if (rc && errno == ENXIO) {
-                        memset(&loopinfo, 0, sizeof(loopinfo));
-                        safe_strncpy((char *)loopinfo.lo_file_name, file, LO_NAME_SIZE);
-                        loopinfo.lo_offset = offset;
                         /* Associate free loop device with file.  */
                         if (ioctl(dfd, LOOP_SET_FD, ffd) == 0) {
-                                if (ioctl(dfd, BB_LOOP_SET_STATUS, &loopinfo) == 0)
-                                        rc = 0;
-                                else
+                                memset(&loopinfo, 0, sizeof(loopinfo));
+                                safe_strncpy((char *)loopinfo.lo_file_name, file, LO_NAME_SIZE);
+                                loopinfo.lo_offset = offset;
+                                /*
+                                 * Used by mount to set LO_FLAGS_AUTOCLEAR.
+                                 * LO_FLAGS_READ_ONLY is not set because RO is controlled by open type of the file.
+                                 * Note that closing LO_FLAGS_AUTOCLEARed dfd before mount
+                                 * is wrong (would free the loop device!)
+                                 */
+                                loopinfo.lo_flags = (flags & ~BB_LO_FLAGS_READ_ONLY);
+                                rc = ioctl(dfd, BB_LOOP_SET_STATUS, &loopinfo);
+                                if (rc != 0 && (loopinfo.lo_flags & BB_LO_FLAGS_AUTOCLEAR)) {
+                                        /* Old kernel, does not support LO_FLAGS_AUTOCLEAR? */
+                                        /* (this code path is not tested) */
+                                        loopinfo.lo_flags -= BB_LO_FLAGS_AUTOCLEAR;
+                                        rc = ioctl(dfd, BB_LOOP_SET_STATUS, &loopinfo);
+                                }
+                                if (rc != 0) {
                                         ioctl(dfd, LOOP_CLR_FD, 0);
+                                }
                         }
                 } else {
                         rc = -1;
                 }
-                close(dfd);
+                if (rc != 0) {
+                        close(dfd);
+                }
  try_again:
                 if (*device) break;
         }
@@ -165,7 +182,7 @@ int FAST_FUNC set_loop(char **device, const char *file, unsigned long long offse
         if (rc == 0) {
                 if (!*device)
                         *device = xstrdup(dev);
-                return (mode == O_RDONLY); /* 1:ro, 0:rw */
+                return dfd;
         }
         return rc;
 }
diff --git a/libbb/print_numbered_lines.c b/libbb/print_numbered_lines.c
new file mode 100644
index 000000000..702aed1ea
--- /dev/null
+++ b/libbb/print_numbered_lines.c
@@ -0,0 +1,29 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Copyright (C) 2017 Denys Vlasenko <vda.linux@googlemail.com>
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
+//kbuild:lib-y += print_numbered_lines.o
+
+#include "libbb.h"
+
+void FAST_FUNC print_numbered_lines(struct number_state *ns, const char *filename)
+{
+        FILE *fp = fopen_or_warn_stdin(filename);
+        unsigned N = ns->start;
+        char *line;
+
+        while ((line = xmalloc_fgetline(fp)) != NULL) {
+                if (ns->all
+                 || (ns->nonempty && line[0])
+                ) {
+                        printf("%*u%s%s\n", ns->width, N, ns->sep, line);
+                        N += ns->inc;
+                } else if (ns->empty_str)
+                        fputs(ns->empty_str, stdout);
+                free(line);
+        }
+
+        fclose(fp);
+}
diff --git a/libbb/recursive_action.c b/libbb/recursive_action.c
index b5cf7c0ab..8f2b8b932 100644
--- a/libbb/recursive_action.c
+++ b/libbb/recursive_action.c
@@ -30,24 +30,37 @@ static int FAST_FUNC true_action(const char *fileName UNUSED_PARAM,
         return TRUE;
 }
 
-/* fileAction return value of 0 on any file in directory will make
- * recursive_action() return 0, but it doesn't stop directory traversal
+/* fileName is (l)stat'ed (depending on ACTION_FOLLOWLINKS[_L0]).
+ *
+ * If it is a file: fileAction in run on it, its return value is returned.
+ *
+ * In case we are in a recursive invocation (see below):
+ * normally, fileAction should return 1 (TRUE) to indicate that
+ * everything is okay and processing should continue.
+ * fileAction return value of 0 (FALSE) on any file in directory will make
+ * recursive_action() also return 0, but it doesn't stop directory traversal
  * (fileAction/dirAction will be called on each file).
  *
- * If !ACTION_RECURSE, dirAction is called on the directory and its
+ * [TODO: maybe introduce -1 to mean "stop traversal NOW and return"]
+ *
+ * If it is a directory:
+ *
+ * If !ACTION_RECURSE, dirAction is called and its
  * return value is returned from recursive_action(). No recursion.
  *
- * If ACTION_RECURSE, recursive_action() is called on each directory.
+ * If ACTION_RECURSE, directory is opened, and recursive_action() is called
+ * on each file/subdirectory.
  * If any one of these calls returns 0, current recursive_action() returns 0.
  *
+ * If !ACTION_DEPTHFIRST, dirAction is called before recurse.
+ * Return value of 0 (FALSE) is an error: prevents recursion,
+ * the warning is printed (unless ACTION_QUIET) and recursive_action() returns 0.
+ * Return value of 2 (SKIP) prevents recursion, instead recursive_action()
+ * returns 1 (TRUE, no error).
+ *
  * If ACTION_DEPTHFIRST, dirAction is called after recurse.
  * If it returns 0, the warning is printed and recursive_action() returns 0.
  *
- * If !ACTION_DEPTHFIRST, dirAction is called before we recurse.
- * Return value of 0 (FALSE) or 2 (SKIP) prevents recursion
- * into that directory, instead recursive_action() returns 0 (if FALSE)
- * or 1 (if SKIP)
- *
  * ACTION_FOLLOWLINKS mainly controls handling of links to dirs.
  * 0: lstat(statbuf). Calls fileAction on link name even if points to dir.
  * 1: stat(statbuf). Calls dirAction and optionally recurse on link to dir.
@@ -105,7 +118,7 @@ int FAST_FUNC recursive_action(const char *fileName,
 
         if (!(flags & ACTION_DEPTHFIRST)) {
                 status = dirAction(fileName, &statbuf, userData, depth);
-                if (!status)
+                if (status == FALSE)
                         goto done_nak_warn;
                 if (status == SKIP)
                         return TRUE;
@@ -121,24 +134,23 @@ int FAST_FUNC recursive_action(const char *fileName,
         status = TRUE;
         while ((next = readdir(dir)) != NULL) {
                 char *nextFile;
+                int s;
 
                 nextFile = concat_subpath_file(fileName, next->d_name);
                 if (nextFile == NULL)
                         continue;
+
                 /* process every file (NB: ACTION_RECURSE is set in flags) */
-                if (!recursive_action(nextFile, flags, fileAction, dirAction,
-                                                userData, depth + 1))
+                s = recursive_action(nextFile, flags, fileAction, dirAction,
+                                                userData, depth + 1);
+                if (s == FALSE)
                         status = FALSE;
-//              s = recursive_action(nextFile, flags, fileAction, dirAction,
-//                                              userData, depth + 1);
                 free(nextFile);
-//#define RECURSE_RESULT_ABORT 3
+//#define RECURSE_RESULT_ABORT -1
 //              if (s == RECURSE_RESULT_ABORT) {
 //                      closedir(dir);
 //                      return s;
 //              }
-//              if (s == FALSE)
-//                      status = FALSE;
         }
         closedir(dir);
 
diff --git a/libbb/securetty.c b/libbb/securetty.c
new file mode 100644
index 000000000..21354e2fa
--- /dev/null
+++ b/libbb/securetty.c
@@ -0,0 +1,26 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * /etc/securetty checking.
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
+#include "libbb.h"
+
+#if ENABLE_FEATURE_SECURETTY && !ENABLE_PAM
+int FAST_FUNC is_tty_secure(const char *short_tty)
+{
+        char *buf = (char*)"/etc/securetty"; /* any non-NULL is ok */
+        parser_t *parser = config_open2("/etc/securetty", fopen_for_read);
+        while (config_read(parser, &buf, 1, 1, "# \t", PARSE_NORMAL)) {
+                if (strcmp(buf, short_tty) == 0)
+                        break;
+                buf = NULL;
+        }
+        config_close(parser);
+        /* buf != NULL here if config file was not found, empty
+         * or line was found which equals short_tty.
+         * In all these cases, we report "this tty is secure".
+         */
+        return buf != NULL;
+}
+#endif
diff --git a/libbb/vfork_daemon_rexec.c b/libbb/vfork_daemon_rexec.c
index a6d260a40..9ab49d0a1 100644
--- a/libbb/vfork_daemon_rexec.c
+++ b/libbb/vfork_daemon_rexec.c
@@ -123,28 +123,8 @@ int FAST_FUNC run_nofork_applet(int applet_no, char **argv)
 
         /* In case getopt() or getopt32() was already called:
          * reset the libc getopt() function, which keeps internal state.
-         *
-         * BSD-derived getopt() functions require that optind be set to 1 in
-         * order to reset getopt() state.  This used to be generally accepted
-         * way of resetting getopt().  However, glibc's getopt()
-         * has additional getopt() state beyond optind, and requires that
-         * optind be set to zero to reset its state.  So the unfortunate state of
-         * affairs is that BSD-derived versions of getopt() misbehave if
-         * optind is set to 0 in order to reset getopt(), and glibc's getopt()
-         * will core dump if optind is set 1 in order to reset getopt().
-         *
-         * More modern versions of BSD require that optreset be set to 1 in
-         * order to reset getopt().  Sigh.  Standards, anyone?
          */
-#ifdef __GLIBC__
-        optind = 0;
-#else /* BSD style */
-        optind = 1;
-        /* optreset = 1; */
-#endif
-        /* optarg = NULL; opterr = 1; optopt = 63; - do we need this too? */
-        /* (values above are what they initialized to in glibc and uclibc) */
-        /* option_mask32 = 0; - not needed, no applet depends on it being 0 */
+        GETOPT_RESET();
 
         argc = 1;
         while (argv[argc])
@@ -169,11 +149,7 @@ int FAST_FUNC run_nofork_applet(int applet_no, char **argv)
         restore_nofork_data(&old);
 
         /* Other globals can be simply reset to defaults */
-#ifdef __GLIBC__
-        optind = 0;
-#else /* BSD style */
-        optind = 1;
-#endif
+        GETOPT_RESET();
 
         return rc & 0xff; /* don't confuse people with "exitcodes" >255 */
 }