Merge branch 'busybox' into merge

4 files changed, 149 insertions, 130 deletions

diff --git a/coreutils/chown.c b/coreutils/chown.c
index 679c0d832..247aa3bf1 100644
--- a/coreutils/chown.c
+++ b/coreutils/chown.c
@@ -11,9 +11,9 @@
 /* http://www.opengroup.org/onlinepubs/007904975/utilities/chown.html */
 
 //usage:#define chown_trivial_usage
-//usage:       "[-Rh"IF_DESKTOP("LHPcvf")"]... OWNER[<.|:>[GROUP]] FILE..."
+//usage:       "[-Rh"IF_DESKTOP("LHPcvf")"]... USER[:[GRP]] FILE..."
 //usage:#define chown_full_usage "\n\n"
-//usage:       "Change the owner and/or group of each FILE to OWNER and/or GROUP\n"
+//usage:       "Change the owner and/or group of each FILE to USER and/or GRP\n"
 //usage:     "\n        -R      Recurse"
 //usage:     "\n        -h      Affect symlinks instead of symlink targets"
 //usage:        IF_DESKTOP(
@@ -112,10 +112,6 @@ int chown_main(int argc UNUSED_PARAM, char **argv)
         int opt, flags;
         struct param_t param;
 
-        /* Just -1 might not work: uid_t may be unsigned long */
-        param.ugid.uid = -1L;
-        param.ugid.gid = -1L;
-
 #if ENABLE_FEATURE_CHOWN_LONG_OPTIONS
         applet_long_options = chown_longopts;
 #endif
diff --git a/coreutils/dd.c b/coreutils/dd.c
index 589547e77..ccb91f69d 100644
--- a/coreutils/dd.c
+++ b/coreutils/dd.c
@@ -327,7 +327,7 @@ int dd_main(int argc UNUSED_PARAM, char **argv)
                                         *arg = '\0';
                                 n = index_in_strings(conv_words, val);
                                 if (n < 0)
-                                        bb_error_msg_and_die(bb_msg_invalid_arg, val, "conv");
+                                        bb_error_msg_and_die(bb_msg_invalid_arg_to, val, "conv");
                                 G.flags |= (1 << n);
                                 if (!arg) /* no ',' left, so this was the last specifier */
                                         break;
@@ -369,7 +369,7 @@ int dd_main(int argc UNUSED_PARAM, char **argv)
                         int n;
                         n = index_in_strings(status_words, val);
                         if (n < 0)
-                                bb_error_msg_and_die(bb_msg_invalid_arg, val, "status");
+                                bb_error_msg_and_die(bb_msg_invalid_arg_to, val, "status");
                         G.flags |= FLAG_STATUS << n;
                         /*continue;*/
                 }
diff --git a/coreutils/du.c b/coreutils/du.c
index 9c6ff8800..1889c16bb 100644
--- a/coreutils/du.c
+++ b/coreutils/du.c
@@ -75,7 +75,7 @@ enum {
 
 struct globals {
 #if ENABLE_FEATURE_HUMAN_READABLE
-        unsigned long disp_hr;
+        unsigned long disp_unit;
 #else
         unsigned disp_k;
 #endif
@@ -89,18 +89,27 @@ struct globals {
 #define INIT_G() do { } while (0)
 
 
-/* FIXME? coreutils' du rounds sizes up:
- * for example,  1025k file is shown as "2" by du -m.
- * We round to nearest.
- */
 static void print(unsigned long long size, const char *filename)
 {
         /* TODO - May not want to defer error checking here. */
 #if ENABLE_FEATURE_HUMAN_READABLE
+# if ENABLE_DESKTOP
+        /* ~30 bytes of code for extra comtat:
+         * coreutils' du rounds sizes up:
+         * for example,  1025k file is shown as "2" by du -m.
+         * We round to nearest if human-readable [too hard to fix],
+         * else (fixed scale such as -m), we round up. To that end,
+         * add yet another half of the unit before displaying:
+         */
+        if (G.disp_unit)
+                size += (G.disp_unit-1) / (unsigned)(512 * 2);
+# endif
         printf("%s\t%s\n",
-                        /* size x 512 / G.disp_hr, show one fractional,
-                         * use suffixes if G.disp_hr == 0 */
-                        make_human_readable_str(size, 512, G.disp_hr),
+                        /* size x 512 / G.disp_unit.
+                         * If G.disp_unit == 0, show one fractional
+                         * and use suffixes
+                         */
+                        make_human_readable_str(size, 512, G.disp_unit),
                         filename);
 #else
         if (G.disp_k) {
@@ -199,10 +208,10 @@ int du_main(int argc UNUSED_PARAM, char **argv)
         INIT_G();
 
 #if ENABLE_FEATURE_HUMAN_READABLE
-        IF_FEATURE_DU_DEFAULT_BLOCKSIZE_1K(G.disp_hr = 1024;)
-        IF_NOT_FEATURE_DU_DEFAULT_BLOCKSIZE_1K(G.disp_hr = 512;)
+        IF_FEATURE_DU_DEFAULT_BLOCKSIZE_1K(G.disp_unit = 1024;)
+        IF_NOT_FEATURE_DU_DEFAULT_BLOCKSIZE_1K(G.disp_unit = 512;)
         if (getenv("POSIXLY_CORRECT"))  /* TODO - a new libbb function? */
-                G.disp_hr = 512;
+                G.disp_unit = 512;
 #else
         IF_FEATURE_DU_DEFAULT_BLOCKSIZE_1K(G.disp_k = 1;)
         /* IF_NOT_FEATURE_DU_DEFAULT_BLOCKSIZE_1K(G.disp_k = 0;) - G is pre-zeroed */
@@ -220,13 +229,13 @@ int du_main(int argc UNUSED_PARAM, char **argv)
         opt = getopt32(argv, "aHkLsx" "d:" "lc" "hm", &G.max_print_depth);
         argv += optind;
         if (opt & OPT_h_for_humans) {
-                G.disp_hr = 0;
+                G.disp_unit = 0;
         }
         if (opt & OPT_m_mbytes) {
-                G.disp_hr = 1024*1024;
+                G.disp_unit = 1024*1024;
         }
         if (opt & OPT_k_kbytes) {
-                G.disp_hr = 1024;
+                G.disp_unit = 1024;
         }
 #else
         opt_complementary = "H-L:L-H:s-d:d-s:d+";
diff --git a/coreutils/od_bloaty.c b/coreutils/od_bloaty.c
index 1e7c5bfa0..3e0423a3d 100644
--- a/coreutils/od_bloaty.c
+++ b/coreutils/od_bloaty.c
@@ -66,7 +66,7 @@ enum {
         /* -S was -s and also had optional parameter */ \
         /* but in coreutils 6.3 it was renamed and now has */ \
         /* _mandatory_ parameter */ \
-        &str_A, &str_N, &str_j, &lst_t, &str_S, &bytes_per_block)
+        &str_A, &str_N, &str_j, &lst_t, &str_S, &G.bytes_per_block)
 
 
 /* Check for 0x7f is a coreutils 6.3 addition */
@@ -181,38 +181,52 @@ struct ERR_width_bytes_has_bad_size {
         char ERR_width_bytes_has_bad_size[ARRAY_SIZE(width_bytes) == N_SIZE_SPECS ? 1 : -1];
 };
 
-static smallint exit_code;
+struct globals {
+        smallint exit_code;
 
-static unsigned string_min;
+        unsigned string_min;
 
-/* An array of specs describing how to format each input block.  */
-static size_t n_specs;
-static struct tspec *spec;
+        /* An array of specs describing how to format each input block.  */
+        unsigned n_specs;
+        struct tspec *spec;
 
-/* Function that accepts an address and an optional following char,
-   and prints the address and char to stdout.  */
-static void (*format_address)(off_t, char);
-/* The difference between the old-style pseudo starting address and
-   the number of bytes to skip.  */
+        /* Function that accepts an address and an optional following char,
+           and prints the address and char to stdout.  */
+        void (*format_address)(off_t, char);
+
+        /* The difference between the old-style pseudo starting address and
+           the number of bytes to skip.  */
 #if ENABLE_LONG_OPTS
-static off_t pseudo_offset;
-#else
-enum { pseudo_offset = 0 };
+        off_t pseudo_offset;
+# define G_pseudo_offset G.pseudo_offset
 #endif
-/* When zero, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
-   input is formatted.  */
-
-/* The number of input bytes formatted per output line.  It must be
-   a multiple of the least common multiple of the sizes associated with
-   the specified output types.  It should be as large as possible, but
-   no larger than 16 -- unless specified with the -w option.  */
-static unsigned bytes_per_block = 32; /* have to use unsigned, not size_t */
-
-/* A NULL-terminated list of the file-arguments from the command line.  */
-static const char *const *file_list;
+        /* When zero, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
+           input is formatted.  */
+
+        /* The number of input bytes formatted per output line.  It must be
+           a multiple of the least common multiple of the sizes associated with
+           the specified output types.  It should be as large as possible, but
+           no larger than 16 -- unless specified with the -w option.  */
+        unsigned bytes_per_block; /* have to use unsigned, not size_t */
+
+        /* A NULL-terminated list of the file-arguments from the command line.  */
+        const char *const *file_list;
+
+        /* The input stream associated with the current file.  */
+        FILE *in_stream;
+
+        bool not_first;
+        bool prev_pair_equal;
+} FIX_ALIASING;
+#if !ENABLE_LONG_OPTS
+enum { G_pseudo_offset = 0 };
+#endif
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define INIT_G() do { \
+        BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
+        G.bytes_per_block = 32; \
+} while (0)
 
-/* The input stream associated with the current file.  */
-static FILE *in_stream;
 
 #define MAX_INTEGRAL_TYPE_SIZE sizeof(ulonglong_t)
 static const unsigned char integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1] ALIGN1 = {
@@ -483,17 +497,17 @@ static void
 open_next_file(void)
 {
         while (1) {
-                if (!*file_list)
+                if (!*G.file_list)
                         return;
-                in_stream = fopen_or_warn_stdin(*file_list++);
-                if (in_stream) {
+                G.in_stream = fopen_or_warn_stdin(*G.file_list++);
+                if (G.in_stream) {
                         break;
                 }
-                exit_code = 1;
+                G.exit_code = 1;
         }
 
         if ((option_mask32 & (OPT_N|OPT_S)) == OPT_N)
-                setbuf(in_stream, NULL);
+                setbuf(G.in_stream, NULL);
 }
 
 /* Test whether there have been errors on in_stream, and close it if
@@ -506,16 +520,16 @@ open_next_file(void)
 static void
 check_and_close(void)
 {
-        if (in_stream) {
-                if (ferror(in_stream))  {
-                        bb_error_msg("%s: read error", (in_stream == stdin)
+        if (G.in_stream) {
+                if (ferror(G.in_stream))        {
+                        bb_error_msg("%s: read error", (G.in_stream == stdin)
                                         ? bb_msg_standard_input
-                                        : file_list[-1]
+                                        : G.file_list[-1]
                         );
-                        exit_code = 1;
+                        G.exit_code = 1;
                 }
-                fclose_if_not_stdin(in_stream);
-                in_stream = NULL;
+                fclose_if_not_stdin(G.in_stream);
+                G.in_stream = NULL;
         }
 
         if (ferror(stdout)) {
@@ -751,9 +765,9 @@ decode_format_string(const char *s)
 
                 assert(s != next);
                 s = next;
-                spec = xrealloc_vector(spec, 4, n_specs);
-                memcpy(&spec[n_specs], &tspec, sizeof(spec[0]));
-                n_specs++;
+                G.spec = xrealloc_vector(G.spec, 4, G.n_specs);
+                memcpy(&G.spec[G.n_specs], &tspec, sizeof(G.spec[0]));
+                G.n_specs++;
         }
 }
 
@@ -770,7 +784,7 @@ skip(off_t n_skip)
         if (n_skip == 0)
                 return;
 
-        while (in_stream) { /* !EOF */
+        while (G.in_stream) { /* !EOF */
                 struct stat file_stats;
 
                 /* First try seeking.  For large offsets, this extra work is
@@ -788,15 +802,15 @@ skip(off_t n_skip)
                            If the number of bytes left to skip is at least
                            as large as the size of the current file, we can
                            decrement n_skip and go on to the next file.  */
-                if (fstat(fileno(in_stream), &file_stats) == 0
+                if (fstat(fileno(G.in_stream), &file_stats) == 0
                  && S_ISREG(file_stats.st_mode) && file_stats.st_size > 0
                 ) {
                         if (file_stats.st_size < n_skip) {
                                 n_skip -= file_stats.st_size;
                                 /* take "check & close / open_next" route */
                         } else {
-                                if (fseeko(in_stream, n_skip, SEEK_CUR) != 0)
-                                        exit_code = 1;
+                                if (fseeko(G.in_stream, n_skip, SEEK_CUR) != 0)
+                                        G.exit_code = 1;
                                 return;
                         }
                 } else {
@@ -809,7 +823,7 @@ skip(off_t n_skip)
                         while (n_skip > 0) {
                                 if (n_skip < n_bytes_to_read)
                                         n_bytes_to_read = n_skip;
-                                n_bytes_read = fread(buf, 1, n_bytes_to_read, in_stream);
+                                n_bytes_read = fread(buf, 1, n_bytes_to_read, G.in_stream);
                                 n_skip -= n_bytes_read;
                                 if (n_bytes_read != n_bytes_to_read)
                                         break; /* EOF on this file or error */
@@ -862,7 +876,7 @@ static void
 format_address_label(off_t address, char c)
 {
         format_address_std(address, ' ');
-        format_address_paren(address + pseudo_offset, c);
+        format_address_paren(address + G_pseudo_offset, c);
 }
 #endif
 
@@ -893,36 +907,34 @@ static void
 write_block(off_t current_offset, size_t n_bytes,
                 const char *prev_block, const char *curr_block)
 {
-        static char first = 1;
-        static char prev_pair_equal = 0;
-        size_t i;
+        unsigned i;
 
         if (!(option_mask32 & OPT_v)
-         && !first
-         && n_bytes == bytes_per_block
-         && memcmp(prev_block, curr_block, bytes_per_block) == 0
+         && G.not_first
+         && n_bytes == G.bytes_per_block
+         && memcmp(prev_block, curr_block, G.bytes_per_block) == 0
         ) {
-                if (prev_pair_equal) {
+                if (G.prev_pair_equal) {
                         /* The two preceding blocks were equal, and the current
                            block is the same as the last one, so print nothing.  */
                 } else {
                         puts("*");
-                        prev_pair_equal = 1;
+                        G.prev_pair_equal = 1;
                 }
         } else {
-                first = 0;
-                prev_pair_equal = 0;
-                for (i = 0; i < n_specs; i++) {
+                G.not_first = 1;
+                G.prev_pair_equal = 0;
+                for (i = 0; i < G.n_specs; i++) {
                         if (i == 0)
-                                format_address(current_offset, '\0');
+                                G.format_address(current_offset, '\0');
                         else
                                 printf("%*s", address_pad_len_char - '0', "");
-                        (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
-                        if (spec[i].hexl_mode_trailer) {
+                        (*G.spec[i].print_function) (n_bytes, curr_block, G.spec[i].fmt_string);
+                        if (G.spec[i].hexl_mode_trailer) {
                                 /* space-pad out to full line width, then dump the trailer */
-                                unsigned datum_width = width_bytes[spec[i].size];
-                                unsigned blank_fields = (bytes_per_block - n_bytes) / datum_width;
-                                unsigned field_width = spec[i].field_width + 1;
+                                unsigned datum_width = width_bytes[G.spec[i].size];
+                                unsigned blank_fields = (G.bytes_per_block - n_bytes) / datum_width;
+                                unsigned field_width = G.spec[i].field_width + 1;
                                 printf("%*s", blank_fields * field_width, "");
                                 dump_hexl_mode_trailer(n_bytes, curr_block);
                         }
@@ -934,19 +946,19 @@ write_block(off_t current_offset, size_t n_bytes,
 static void
 read_block(size_t n, char *block, size_t *n_bytes_in_buffer)
 {
-        assert(0 < n && n <= bytes_per_block);
+        assert(0 < n && n <= G.bytes_per_block);
 
         *n_bytes_in_buffer = 0;
 
         if (n == 0)
                 return;
 
-        while (in_stream != NULL) { /* EOF.  */
+        while (G.in_stream != NULL) { /* EOF.  */
                 size_t n_needed;
                 size_t n_read;
 
                 n_needed = n - *n_bytes_in_buffer;
-                n_read = fread(block + *n_bytes_in_buffer, 1, n_needed, in_stream);
+                n_read = fread(block + *n_bytes_in_buffer, 1, n_needed, G.in_stream);
                 *n_bytes_in_buffer += n_read;
                 if (n_read == n_needed)
                         break;
@@ -965,8 +977,8 @@ get_lcm(void)
         size_t i;
         int l_c_m = 1;
 
-        for (i = 0; i < n_specs; i++)
-                l_c_m = lcm(l_c_m, width_bytes[(int) spec[i].size]);
+        for (i = 0; i < G.n_specs; i++)
+                l_c_m = lcm(l_c_m, width_bytes[(int) G.spec[i].size]);
         return l_c_m;
 }
 
@@ -987,8 +999,8 @@ dump(off_t current_offset, off_t end_offset)
         int idx;
         size_t n_bytes_read;
 
-        block[0] = xmalloc(2 * bytes_per_block);
-        block[1] = block[0] + bytes_per_block;
+        block[0] = xmalloc(2 * G.bytes_per_block);
+        block[1] = block[0] + G.bytes_per_block;
 
         idx = 0;
         if (option_mask32 & OPT_N) {
@@ -998,21 +1010,21 @@ dump(off_t current_offset, off_t end_offset)
                                 n_bytes_read = 0;
                                 break;
                         }
-                        n_needed = MIN(end_offset - current_offset, (off_t) bytes_per_block);
+                        n_needed = MIN(end_offset - current_offset, (off_t) G.bytes_per_block);
                         read_block(n_needed, block[idx], &n_bytes_read);
-                        if (n_bytes_read < bytes_per_block)
+                        if (n_bytes_read < G.bytes_per_block)
                                 break;
-                        assert(n_bytes_read == bytes_per_block);
+                        assert(n_bytes_read == G.bytes_per_block);
                         write_block(current_offset, n_bytes_read, block[idx ^ 1], block[idx]);
                         current_offset += n_bytes_read;
                         idx ^= 1;
                 }
         } else {
                 while (1) {
-                        read_block(bytes_per_block, block[idx], &n_bytes_read);
-                        if (n_bytes_read < bytes_per_block)
+                        read_block(G.bytes_per_block, block[idx], &n_bytes_read);
+                        if (n_bytes_read < G.bytes_per_block)
                                 break;
-                        assert(n_bytes_read == bytes_per_block);
+                        assert(n_bytes_read == G.bytes_per_block);
                         write_block(current_offset, n_bytes_read, block[idx ^ 1], block[idx]);
                         current_offset += n_bytes_read;
                         idx ^= 1;
@@ -1035,7 +1047,7 @@ dump(off_t current_offset, off_t end_offset)
                 current_offset += n_bytes_read;
         }
 
-        format_address(current_offset, '\n');
+        G.format_address(current_offset, '\n');
 
         if ((option_mask32 & OPT_N) && current_offset >= end_offset)
                 check_and_close();
@@ -1066,16 +1078,16 @@ dump(off_t current_offset, off_t end_offset)
 static void
 dump_strings(off_t address, off_t end_offset)
 {
-        unsigned bufsize = MAX(100, string_min);
+        unsigned bufsize = MAX(100, G.string_min);
         unsigned char *buf = xmalloc(bufsize);
 
         while (1) {
                 size_t i;
                 int c;
 
-                /* See if the next 'string_min' chars are all printing chars.  */
+                /* See if the next 'G.string_min' chars are all printing chars.  */
  tryline:
-                if ((option_mask32 & OPT_N) && (end_offset - string_min <= address))
+                if ((option_mask32 & OPT_N) && (end_offset - G.string_min <= address))
                         break;
                 i = 0;
                 while (!(option_mask32 & OPT_N) || address < end_offset) {
@@ -1084,8 +1096,8 @@ dump_strings(off_t address, off_t end_offset)
                                 buf = xrealloc(buf, bufsize);
                         }
 
-                        while (in_stream) { /* !EOF */
-                                c = fgetc(in_stream);
+                        while (G.in_stream) { /* !EOF */
+                                c = fgetc(G.in_stream);
                                 if (c != EOF)
                                         goto got_char;
                                 check_and_close();
@@ -1102,12 +1114,12 @@ dump_strings(off_t address, off_t end_offset)
                         buf[i++] = c;           /* String continues; store it all.  */
                 }
 
-                if (i < string_min)             /* Too short! */
+                if (i < G.string_min)           /* Too short! */
                         goto tryline;
 
                 /* If we get here, the string is all printable and NUL-terminated */
                 buf[i] = 0;
-                format_address(address - i - 1, ' ');
+                G.format_address(address - i - 1, ' ');
 
                 for (i = 0; (c = buf[i]); i++) {
                         switch (c) {
@@ -1125,7 +1137,7 @@ dump_strings(off_t address, off_t end_offset)
         }
 
         /* We reach this point only if we search through
-           (max_bytes_to_format - string_min) bytes before reaching EOF.  */
+           (max_bytes_to_format - G.string_min) bytes before reaching EOF.  */
         check_and_close();
  ret:
         free(buf);
@@ -1197,8 +1209,10 @@ int od_main(int argc UNUSED_PARAM, char **argv)
         /* The maximum number of bytes that will be formatted.  */
         off_t max_bytes_to_format = 0;
 
-        spec = NULL;
-        format_address = format_address_std;
+        INIT_G();
+
+        /*G.spec = NULL; - already is */
+        G.format_address = format_address_std;
         address_base_char = 'o';
         address_pad_len_char = '7';
 
@@ -1224,7 +1238,7 @@ int od_main(int argc UNUSED_PARAM, char **argv)
                         bb_error_msg_and_die("bad output address radix "
                                 "'%c' (must be [doxn])", str_A[0]);
                 pos = p - doxn;
-                if (pos == 3) format_address = format_address_none;
+                if (pos == 3) G.format_address = format_address_none;
                 address_base_char = doxn_address_base_char[pos];
                 address_pad_len_char = doxn_address_pad_len_char[pos];
         }
@@ -1247,11 +1261,11 @@ int od_main(int argc UNUSED_PARAM, char **argv)
         if (opt & OPT_x) decode_format_string("x2");
         if (opt & OPT_s) decode_format_string("d2");
         if (opt & OPT_S) {
-                string_min = xstrtou_sfx(str_S, 0, bkm_suffixes);
+                G.string_min = xstrtou_sfx(str_S, 0, bkm_suffixes);
         }
 
         // Bloat:
-        //if ((option_mask32 & OPT_S) && n_specs > 0)
+        //if ((option_mask32 & OPT_S) && G.n_specs > 0)
         //      bb_error_msg_and_die("no type may be specified when dumping strings");
 
         /* If the --traditional option is used, there may be from
@@ -1307,14 +1321,14 @@ int od_main(int argc UNUSED_PARAM, char **argv)
                         }
 
                         if (pseudo_start >= 0) {
-                                if (format_address == format_address_none) {
+                                if (G.format_address == format_address_none) {
                                         address_base_char = 'o';
                                         address_pad_len_char = '7';
-                                        format_address = format_address_paren;
+                                        G.format_address = format_address_paren;
                                 } else {
-                                        format_address = format_address_label;
+                                        G.format_address = format_address_label;
                                 }
-                                pseudo_offset = pseudo_start - n_bytes_to_skip;
+                                G_pseudo_offset = pseudo_start - n_bytes_to_skip;
                         }
                 }
                 /* else: od --traditional (without args) */
@@ -1327,45 +1341,45 @@ int od_main(int argc UNUSED_PARAM, char **argv)
                         bb_error_msg_and_die("SKIP + SIZE is too large");
         }
 
-        if (n_specs == 0) {
+        if (G.n_specs == 0) {
                 decode_format_string("o2");
-                /*n_specs = 1; - done by decode_format_string */
+                /*G.n_specs = 1; - done by decode_format_string */
         }
 
         /* If no files were listed on the command line,
            set the global pointer FILE_LIST so that it
            references the null-terminated list of one name: "-".  */
-        file_list = bb_argv_dash;
+        G.file_list = bb_argv_dash;
         if (argv[0]) {
                 /* Set the global pointer FILE_LIST so that it
                    references the first file-argument on the command-line.  */
-                file_list = (char const *const *) argv;
+                G.file_list = (char const *const *) argv;
         }
 
         /* Open the first input file */
         open_next_file();
         /* Skip over any unwanted header bytes */
         skip(n_bytes_to_skip);
-        if (!in_stream)
+        if (!G.in_stream)
                 return EXIT_FAILURE;
 
         /* Compute output block length */
         l_c_m = get_lcm();
 
         if (opt & OPT_w) { /* -w: width */
-                if (!bytes_per_block || bytes_per_block % l_c_m != 0) {
+                if (!G.bytes_per_block || G.bytes_per_block % l_c_m != 0) {
                         bb_error_msg("warning: invalid width %u; using %d instead",
-                                        (unsigned)bytes_per_block, l_c_m);
-                        bytes_per_block = l_c_m;
+                                        (unsigned)G.bytes_per_block, l_c_m);
+                        G.bytes_per_block = l_c_m;
                 }
         } else {
-                bytes_per_block = l_c_m;
+                G.bytes_per_block = l_c_m;
                 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
-                        bytes_per_block *= DEFAULT_BYTES_PER_BLOCK / l_c_m;
+                        G.bytes_per_block *= DEFAULT_BYTES_PER_BLOCK / l_c_m;
         }
 
 #ifdef DEBUG
-        for (i = 0; i < n_specs; i++) {
+        for (i = 0; i < G.n_specs; i++) {
                 printf("%d: fmt=\"%s\" width=%d\n",
                         i, spec[i].fmt_string, width_bytes[spec[i].size]);
         }
@@ -1379,5 +1393,5 @@ int od_main(int argc UNUSED_PARAM, char **argv)
         if (fclose(stdin))
                 bb_perror_msg_and_die(bb_msg_standard_input);
 
-        return exit_code;
+        return G.exit_code;
 }