Adding upstream version 9.1.upstream/9.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1673 insertions, 0 deletions

diff --git a/src/split.c b/src/split.c
new file mode 100644
index 0000000..b7a0d0e
--- /dev/null
+++ b/src/split.c
@@ -0,0 +1,1673 @@
+/* split.c -- split a file into pieces.
+   Copyright (C) 1988-2022 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+/* By tege@sics.se, with rms.
+
+   TODO:
+   * support -p REGEX as in BSD's split.
+   * support --suppress-matched as in csplit.  */
+#include <config.h>
+
+#include <assert.h>
+#include <stdio.h>
+#include <getopt.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include "system.h"
+#include "alignalloc.h"
+#include "die.h"
+#include "error.h"
+#include "fd-reopen.h"
+#include "fcntl--.h"
+#include "full-write.h"
+#include "ioblksize.h"
+#include "quote.h"
+#include "safe-read.h"
+#include "sig2str.h"
+#include "xbinary-io.h"
+#include "xdectoint.h"
+#include "xstrtol.h"
+
+/* The official name of this program (e.g., no 'g' prefix).  */
+#define PROGRAM_NAME "split"
+
+#define AUTHORS \
+  proper_name ("Torbjorn Granlund"), \
+  proper_name ("Richard M. Stallman")
+
+/* Shell command to filter through, instead of creating files.  */
+static char const *filter_command;
+
+/* Process ID of the filter.  */
+static int filter_pid;
+
+/* Array of open pipes.  */
+static int *open_pipes;
+static size_t open_pipes_alloc;
+static size_t n_open_pipes;
+
+/* Blocked signals.  */
+static sigset_t oldblocked;
+static sigset_t newblocked;
+
+/* Base name of output files.  */
+static char const *outbase;
+
+/* Name of output files.  */
+static char *outfile;
+
+/* Pointer to the end of the prefix in OUTFILE.
+   Suffixes are inserted here.  */
+static char *outfile_mid;
+
+/* Generate new suffix when suffixes are exhausted.  */
+static bool suffix_auto = true;
+
+/* Length of OUTFILE's suffix.  */
+static size_t suffix_length;
+
+/* Alphabet of characters to use in suffix.  */
+static char const *suffix_alphabet = "abcdefghijklmnopqrstuvwxyz";
+
+/* Numerical suffix start value.  */
+static char const *numeric_suffix_start;
+
+/* Additional suffix to append to output file names.  */
+static char const *additional_suffix;
+
+/* Name of input file.  May be "-".  */
+static char *infile;
+
+/* stat buf for input file.  */
+static struct stat in_stat_buf;
+
+/* Descriptor on which output file is open.  */
+static int output_desc = -1;
+
+/* If true, print a diagnostic on standard error just before each
+   output file is opened. */
+static bool verbose;
+
+/* If true, don't generate zero length output files. */
+static bool elide_empty_files;
+
+/* If true, in round robin mode, immediately copy
+   input to output, which is much slower, so disabled by default.  */
+static bool unbuffered;
+
+/* The character marking end of line.  Defaults to \n below.  */
+static int eolchar = -1;
+
+/* The split mode to use.  */
+enum Split_type
+{
+  type_undef, type_bytes, type_byteslines, type_lines, type_digits,
+  type_chunk_bytes, type_chunk_lines, type_rr
+};
+
+/* For long options that have no equivalent short option, use a
+   non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
+enum
+{
+  VERBOSE_OPTION = CHAR_MAX + 1,
+  FILTER_OPTION,
+  IO_BLKSIZE_OPTION,
+  ADDITIONAL_SUFFIX_OPTION
+};
+
+static struct option const longopts[] =
+{
+  {"bytes", required_argument, NULL, 'b'},
+  {"lines", required_argument, NULL, 'l'},
+  {"line-bytes", required_argument, NULL, 'C'},
+  {"number", required_argument, NULL, 'n'},
+  {"elide-empty-files", no_argument, NULL, 'e'},
+  {"unbuffered", no_argument, NULL, 'u'},
+  {"suffix-length", required_argument, NULL, 'a'},
+  {"additional-suffix", required_argument, NULL,
+   ADDITIONAL_SUFFIX_OPTION},
+  {"numeric-suffixes", optional_argument, NULL, 'd'},
+  {"hex-suffixes", optional_argument, NULL, 'x'},
+  {"filter", required_argument, NULL, FILTER_OPTION},
+  {"verbose", no_argument, NULL, VERBOSE_OPTION},
+  {"separator", required_argument, NULL, 't'},
+  {"-io-blksize", required_argument, NULL,
+   IO_BLKSIZE_OPTION}, /* do not document */
+  {GETOPT_HELP_OPTION_DECL},
+  {GETOPT_VERSION_OPTION_DECL},
+  {NULL, 0, NULL, 0}
+};
+
+/* Return true if the errno value, ERR, is ignorable.  */
+static inline bool
+ignorable (int err)
+{
+  return filter_command && err == EPIPE;
+}
+
+static void
+set_suffix_length (uintmax_t n_units, enum Split_type split_type)
+{
+#define DEFAULT_SUFFIX_LENGTH 2
+
+  uintmax_t suffix_length_needed = 0;
+
+  /* The suffix auto length feature is incompatible with
+     a user specified start value as the generated suffixes
+     are not all consecutive.  */
+  if (numeric_suffix_start)
+    suffix_auto = false;
+
+  /* Auto-calculate the suffix length if the number of files is given.  */
+  if (split_type == type_chunk_bytes || split_type == type_chunk_lines
+      || split_type == type_rr)
+    {
+      uintmax_t n_units_end = n_units - 1;
+      if (numeric_suffix_start)
+        {
+          uintmax_t n_start;
+          strtol_error e = xstrtoumax (numeric_suffix_start, NULL, 10,
+                                       &n_start, "");
+          if (e == LONGINT_OK && n_start <= UINTMAX_MAX - n_units)
+            {
+              /* Restrict auto adjustment so we don't keep
+                 incrementing a suffix size arbitrarily,
+                 as that would break sort order for files
+                 generated from multiple split runs.  */
+              if (n_start < n_units)
+                n_units_end += n_start;
+            }
+
+        }
+      size_t alphabet_len = strlen (suffix_alphabet);
+      do
+        suffix_length_needed++;
+      while (n_units_end /= alphabet_len);
+
+      suffix_auto = false;
+    }
+
+  if (suffix_length)            /* set by user */
+    {
+      if (suffix_length < suffix_length_needed)
+        {
+          die (EXIT_FAILURE, 0,
+               _("the suffix length needs to be at least %"PRIuMAX),
+               suffix_length_needed);
+        }
+      suffix_auto = false;
+      return;
+    }
+  else
+    suffix_length = MAX (DEFAULT_SUFFIX_LENGTH, suffix_length_needed);
+}
+
+void
+usage (int status)
+{
+  if (status != EXIT_SUCCESS)
+    emit_try_help ();
+  else
+    {
+      printf (_("\
+Usage: %s [OPTION]... [FILE [PREFIX]]\n\
+"),
+              program_name);
+      fputs (_("\
+Output pieces of FILE to PREFIXaa, PREFIXab, ...;\n\
+default size is 1000 lines, and default PREFIX is 'x'.\n\
+"), stdout);
+
+      emit_stdin_note ();
+      emit_mandatory_arg_note ();
+
+      fprintf (stdout, _("\
+  -a, --suffix-length=N   generate suffixes of length N (default %d)\n\
+      --additional-suffix=SUFFIX  append an additional SUFFIX to file names\n\
+  -b, --bytes=SIZE        put SIZE bytes per output file\n\
+  -C, --line-bytes=SIZE   put at most SIZE bytes of records per output file\n\
+  -d                      use numeric suffixes starting at 0, not alphabetic\n\
+      --numeric-suffixes[=FROM]  same as -d, but allow setting the start value\
+\n\
+  -x                      use hex suffixes starting at 0, not alphabetic\n\
+      --hex-suffixes[=FROM]  same as -x, but allow setting the start value\n\
+  -e, --elide-empty-files  do not generate empty output files with '-n'\n\
+      --filter=COMMAND    write to shell COMMAND; file name is $FILE\n\
+  -l, --lines=NUMBER      put NUMBER lines/records per output file\n\
+  -n, --number=CHUNKS     generate CHUNKS output files; see explanation below\n\
+  -t, --separator=SEP     use SEP instead of newline as the record separator;\n\
+                            '\\0' (zero) specifies the NUL character\n\
+  -u, --unbuffered        immediately copy input to output with '-n r/...'\n\
+"), DEFAULT_SUFFIX_LENGTH);
+      fputs (_("\
+      --verbose           print a diagnostic just before each\n\
+                            output file is opened\n\
+"), stdout);
+      fputs (HELP_OPTION_DESCRIPTION, stdout);
+      fputs (VERSION_OPTION_DESCRIPTION, stdout);
+      emit_size_note ();
+      fputs (_("\n\
+CHUNKS may be:\n\
+  N       split into N files based on size of input\n\
+  K/N     output Kth of N to stdout\n\
+  l/N     split into N files without splitting lines/records\n\
+  l/K/N   output Kth of N to stdout without splitting lines/records\n\
+  r/N     like 'l' but use round robin distribution\n\
+  r/K/N   likewise but only output Kth of N to stdout\n\
+"), stdout);
+      emit_ancillary_info (PROGRAM_NAME);
+    }
+  exit (status);
+}
+
+/* Return the number of bytes that can be read from FD with status ST.
+   Store up to the first BUFSIZE bytes of the file's data into BUF,
+   and advance the file position by the number of bytes read.  On
+   input error, set errno and return -1.  */
+
+static off_t
+input_file_size (int fd, struct stat const *st, char *buf, size_t bufsize)
+{
+  off_t cur = lseek (fd, 0, SEEK_CUR);
+  if (cur < 0)
+    {
+      if (errno == ESPIPE)
+        errno = 0; /* Suppress confusing seek error.  */
+      return -1;
+    }
+
+  off_t size = 0;
+  do
+    {
+      size_t n_read = safe_read (fd, buf + size, bufsize - size);
+      if (n_read == 0)
+        return size;
+      if (n_read == SAFE_READ_ERROR)
+        return -1;
+      size += n_read;
+    }
+  while (size < bufsize);
+
+  /* Note we check st_size _after_ the read() above
+     because /proc files on GNU/Linux are seekable
+     but have st_size == 0.  */
+  if (st->st_size == 0)
+    {
+      /* We've filled the buffer, from a seekable file,
+         which has an st_size==0, E.g., /dev/zero on GNU/Linux.
+         Assume there is no limit to file size.  */
+      errno = EOVERFLOW;
+      return -1;
+    }
+
+  cur += size;
+  off_t end;
+  if (usable_st_size (st) && cur <= st->st_size)
+    end = st->st_size;
+  else
+    {
+      end = lseek (fd, 0, SEEK_END);
+      if (end < 0)
+        return -1;
+      if (end != cur)
+        {
+          if (lseek (fd, cur, SEEK_SET) < 0)
+            return -1;
+          if (end < cur)
+            end = cur;
+        }
+    }
+
+  size += end - cur;
+  if (size == OFF_T_MAX)
+    {
+      /* E.g., /dev/zero on GNU/Hurd.  */
+      errno = EOVERFLOW;
+      return -1;
+    }
+
+  return size;
+}
+
+/* Compute the next sequential output file name and store it into the
+   string 'outfile'.  */
+
+static void
+next_file_name (void)
+{
+  /* Index in suffix_alphabet of each character in the suffix.  */
+  static size_t *sufindex;
+  static size_t outbase_length;
+  static size_t outfile_length;
+  static size_t addsuf_length;
+
+  if (! outfile)
+    {
+      bool widen;
+
+new_name:
+      widen = !! outfile_length;
+
+      if (! widen)
+        {
+          /* Allocate and initialize the first file name.  */
+
+          outbase_length = strlen (outbase);
+          addsuf_length = additional_suffix ? strlen (additional_suffix) : 0;
+          outfile_length = outbase_length + suffix_length + addsuf_length;
+        }
+      else
+        {
+          /* Reallocate and initialize a new wider file name.
+             We do this by subsuming the unchanging part of
+             the generated suffix into the prefix (base), and
+             reinitializing the now one longer suffix.  */
+
+          outfile_length += 2;
+          suffix_length++;
+        }
+
+      if (outfile_length + 1 < outbase_length)
+        xalloc_die ();
+      outfile = xrealloc (outfile, outfile_length + 1);
+
+      if (! widen)
+        memcpy (outfile, outbase, outbase_length);
+      else
+        {
+          /* Append the last alphabet character to the file name prefix.  */
+          outfile[outbase_length] = suffix_alphabet[sufindex[0]];
+          outbase_length++;
+        }
+
+      outfile_mid = outfile + outbase_length;
+      memset (outfile_mid, suffix_alphabet[0], suffix_length);
+      if (additional_suffix)
+        memcpy (outfile_mid + suffix_length, additional_suffix, addsuf_length);
+      outfile[outfile_length] = 0;
+
+      free (sufindex);
+      sufindex = xcalloc (suffix_length, sizeof *sufindex);
+
+      if (numeric_suffix_start)
+        {
+          assert (! widen);
+
+          /* Update the output file name.  */
+          size_t i = strlen (numeric_suffix_start);
+          memcpy (outfile_mid + suffix_length - i, numeric_suffix_start, i);
+
+          /* Update the suffix index.  */
+          size_t *sufindex_end = sufindex + suffix_length;
+          while (i-- != 0)
+            *--sufindex_end = numeric_suffix_start[i] - '0';
+        }
+
+#if ! _POSIX_NO_TRUNC && HAVE_PATHCONF && defined _PC_NAME_MAX
+      /* POSIX requires that if the output file name is too long for
+         its directory, 'split' must fail without creating any files.
+         This must be checked for explicitly on operating systems that
+         silently truncate file names.  */
+      {
+        char *dir = dir_name (outfile);
+        long name_max = pathconf (dir, _PC_NAME_MAX);
+        if (0 <= name_max && name_max < base_len (last_component (outfile)))
+          die (EXIT_FAILURE, ENAMETOOLONG, "%s", quotef (outfile));
+        free (dir);
+      }
+#endif
+    }
+  else
+    {
+      /* Increment the suffix in place, if possible.  */
+
+      size_t i = suffix_length;
+      while (i-- != 0)
+        {
+          sufindex[i]++;
+          if (suffix_auto && i == 0 && ! suffix_alphabet[sufindex[0] + 1])
+            goto new_name;
+          outfile_mid[i] = suffix_alphabet[sufindex[i]];
+          if (outfile_mid[i])
+            return;
+          sufindex[i] = 0;
+          outfile_mid[i] = suffix_alphabet[sufindex[i]];
+        }
+      die (EXIT_FAILURE, 0, _("output file suffixes exhausted"));
+    }
+}
+
+/* Create or truncate a file.  */
+
+static int
+create (char const *name)
+{
+  if (!filter_command)
+    {
+      if (verbose)
+        fprintf (stdout, _("creating file %s\n"), quoteaf (name));
+
+      int fd = open (name, O_WRONLY | O_CREAT | O_BINARY, MODE_RW_UGO);
+      if (fd < 0)
+        return fd;
+      struct stat out_stat_buf;
+      if (fstat (fd, &out_stat_buf) != 0)
+        die (EXIT_FAILURE, errno, _("failed to stat %s"), quoteaf (name));
+      if (SAME_INODE (in_stat_buf, out_stat_buf))
+        die (EXIT_FAILURE, 0, _("%s would overwrite input; aborting"),
+             quoteaf (name));
+      if (ftruncate (fd, 0) != 0
+          && (S_ISREG (out_stat_buf.st_mode) || S_TYPEISSHM (&out_stat_buf)))
+        die (EXIT_FAILURE, errno, _("%s: error truncating"), quotef (name));
+
+      return fd;
+    }
+  else
+    {
+      int fd_pair[2];
+      pid_t child_pid;
+      char const *shell_prog = getenv ("SHELL");
+      if (shell_prog == NULL)
+        shell_prog = "/bin/sh";
+      if (setenv ("FILE", name, 1) != 0)
+        die (EXIT_FAILURE, errno,
+             _("failed to set FILE environment variable"));
+      if (verbose)
+        fprintf (stdout, _("executing with FILE=%s\n"), quotef (name));
+      if (pipe (fd_pair) != 0)
+        die (EXIT_FAILURE, errno, _("failed to create pipe"));
+      child_pid = fork ();
+      if (child_pid == 0)
+        {
+          /* This is the child process.  If an error occurs here, the
+             parent will eventually learn about it after doing a wait,
+             at which time it will emit its own error message.  */
+          int j;
+          /* We have to close any pipes that were opened during an
+             earlier call, otherwise this process will be holding a
+             write-pipe that will prevent the earlier process from
+             reading an EOF on the corresponding read-pipe.  */
+          for (j = 0; j < n_open_pipes; ++j)
+            if (close (open_pipes[j]) != 0)
+              die (EXIT_FAILURE, errno, _("closing prior pipe"));
+          if (close (fd_pair[1]))
+            die (EXIT_FAILURE, errno, _("closing output pipe"));
+          if (fd_pair[0] != STDIN_FILENO)
+            {
+              if (dup2 (fd_pair[0], STDIN_FILENO) != STDIN_FILENO)
+                die (EXIT_FAILURE, errno, _("moving input pipe"));
+              if (close (fd_pair[0]) != 0)
+                die (EXIT_FAILURE, errno, _("closing input pipe"));
+            }
+          sigprocmask (SIG_SETMASK, &oldblocked, NULL);
+          execl (shell_prog, last_component (shell_prog), "-c",
+                 filter_command, (char *) NULL);
+          die (EXIT_FAILURE, errno, _("failed to run command: \"%s -c %s\""),
+               shell_prog, filter_command);
+        }
+      if (child_pid == -1)
+        die (EXIT_FAILURE, errno, _("fork system call failed"));
+      if (close (fd_pair[0]) != 0)
+        die (EXIT_FAILURE, errno, _("failed to close input pipe"));
+      filter_pid = child_pid;
+      if (n_open_pipes == open_pipes_alloc)
+        open_pipes = x2nrealloc (open_pipes, &open_pipes_alloc,
+                                 sizeof *open_pipes);
+      open_pipes[n_open_pipes++] = fd_pair[1];
+      return fd_pair[1];
+    }
+}
+
+/* Close the output file, and do any associated cleanup.
+   If FP and FD are both specified, they refer to the same open file;
+   in this case FP is closed, but FD is still used in cleanup.  */
+static void
+closeout (FILE *fp, int fd, pid_t pid, char const *name)
+{
+  if (fp != NULL && fclose (fp) != 0 && ! ignorable (errno))
+    die (EXIT_FAILURE, errno, "%s", quotef (name));
+  if (fd >= 0)
+    {
+      if (fp == NULL && close (fd) < 0)
+        die (EXIT_FAILURE, errno, "%s", quotef (name));
+      int j;
+      for (j = 0; j < n_open_pipes; ++j)
+        {
+          if (open_pipes[j] == fd)
+            {
+              open_pipes[j] = open_pipes[--n_open_pipes];
+              break;
+            }
+        }
+    }
+  if (pid > 0)
+    {
+      int wstatus = 0;
+      if (waitpid (pid, &wstatus, 0) == -1 && errno != ECHILD)
+        die (EXIT_FAILURE, errno, _("waiting for child process"));
+      if (WIFSIGNALED (wstatus))
+        {
+          int sig = WTERMSIG (wstatus);
+          if (sig != SIGPIPE)
+            {
+              char signame[MAX (SIG2STR_MAX, INT_BUFSIZE_BOUND (int))];
+              if (sig2str (sig, signame) != 0)
+                sprintf (signame, "%d", sig);
+              error (sig + 128, 0,
+                     _("with FILE=%s, signal %s from command: %s"),
+                     quotef (name), signame, filter_command);
+            }
+        }
+      else if (WIFEXITED (wstatus))
+        {
+          int ex = WEXITSTATUS (wstatus);
+          if (ex != 0)
+            error (ex, 0, _("with FILE=%s, exit %d from command: %s"),
+                   quotef (name), ex, filter_command);
+        }
+      else
+        {
+          /* shouldn't happen.  */
+          die (EXIT_FAILURE, 0,
+               _("unknown status from command (0x%X)"), wstatus + 0u);
+        }
+    }
+}
+
+/* Write BYTES bytes at BP to an output file.
+   If NEW_FILE_FLAG is true, open the next output file.
+   Otherwise add to the same output file already in use.
+   Return true if successful.  */
+
+static bool
+cwrite (bool new_file_flag, char const *bp, size_t bytes)
+{
+  if (new_file_flag)
+    {
+      if (!bp && bytes == 0 && elide_empty_files)
+        return true;
+      closeout (NULL, output_desc, filter_pid, outfile);
+      next_file_name ();
+      output_desc = create (outfile);
+      if (output_desc < 0)
+        die (EXIT_FAILURE, errno, "%s", quotef (outfile));
+    }
+
+  if (full_write (output_desc, bp, bytes) == bytes)
+    return true;
+  else
+    {
+      if (! ignorable (errno))
+        die (EXIT_FAILURE, errno, "%s", quotef (outfile));
+      return false;
+    }
+}
+
+/* Split into pieces of exactly N_BYTES bytes.
+   Use buffer BUF, whose size is BUFSIZE.
+   BUF contains the first INITIAL_READ input bytes.  */
+
+static void
+bytes_split (uintmax_t n_bytes, char *buf, size_t bufsize, size_t initial_read,
+             uintmax_t max_files)
+{
+  size_t n_read;
+  bool new_file_flag = true;
+  bool filter_ok = true;
+  uintmax_t to_write = n_bytes;
+  uintmax_t opened = 0;
+  bool eof;
+
+  do
+    {
+      if (initial_read != SIZE_MAX)
+        {
+          n_read = initial_read;
+          initial_read = SIZE_MAX;
+          eof = n_read < bufsize;
+        }
+      else
+        {
+          if (! filter_ok
+              && lseek (STDIN_FILENO, to_write, SEEK_CUR) != -1)
+            {
+              to_write = n_bytes;
+              new_file_flag = true;
+            }
+
+          n_read = safe_read (STDIN_FILENO, buf, bufsize);
+          if (n_read == SAFE_READ_ERROR)
+            die (EXIT_FAILURE, errno, "%s", quotef (infile));
+          eof = n_read == 0;
+        }
+      char *bp_out = buf;
+      while (to_write <= n_read)
+        {
+          if (filter_ok || new_file_flag)
+            filter_ok = cwrite (new_file_flag, bp_out, to_write);
+          opened += new_file_flag;
+          new_file_flag = !max_files || (opened < max_files);
+          if (! filter_ok && ! new_file_flag)
+            {
+              /* If filters no longer accepting input, stop reading.  */
+              n_read = 0;
+              eof = true;
+              break;
+            }
+          bp_out += to_write;
+          n_read -= to_write;
+          to_write = n_bytes;
+        }
+      if (n_read != 0)
+        {
+          if (filter_ok || new_file_flag)
+            filter_ok = cwrite (new_file_flag, bp_out, n_read);
+          opened += new_file_flag;
+          new_file_flag = false;
+          if (! filter_ok && opened == max_files)
+            {
+              /* If filters no longer accepting input, stop reading.  */
+              break;
+            }
+          to_write -= n_read;
+        }
+    }
+  while (! eof);
+
+  /* Ensure NUMBER files are created, which truncates
+     any existing files or notifies any consumers on fifos.
+     FIXME: Should we do this before EXIT_FAILURE?  */
+  while (opened++ < max_files)
+    cwrite (true, NULL, 0);
+}
+
+/* Split into pieces of exactly N_LINES lines.
+   Use buffer BUF, whose size is BUFSIZE.  */
+
+static void
+lines_split (uintmax_t n_lines, char *buf, size_t bufsize)
+{
+  size_t n_read;
+  char *bp, *bp_out, *eob;
+  bool new_file_flag = true;
+  uintmax_t n = 0;
+
+  do
+    {
+      n_read = safe_read (STDIN_FILENO, buf, bufsize);
+      if (n_read == SAFE_READ_ERROR)
+        die (EXIT_FAILURE, errno, "%s", quotef (infile));
+      bp = bp_out = buf;
+      eob = bp + n_read;
+      *eob = eolchar;
+      while (true)
+        {
+          bp = rawmemchr (bp, eolchar);
+          if (bp == eob)
+            {
+              if (eob != bp_out) /* do not write 0 bytes! */
+                {
+                  size_t len = eob - bp_out;
+                  cwrite (new_file_flag, bp_out, len);
+                  new_file_flag = false;
+                }
+              break;
+            }
+
+          ++bp;
+          if (++n >= n_lines)
+            {
+              cwrite (new_file_flag, bp_out, bp - bp_out);
+              bp_out = bp;
+              new_file_flag = true;
+              n = 0;
+            }
+        }
+    }
+  while (n_read);
+}
+
+/* Split into pieces that are as large as possible while still not more
+   than N_BYTES bytes, and are split on line boundaries except
+   where lines longer than N_BYTES bytes occur. */
+
+static void
+line_bytes_split (uintmax_t n_bytes, char *buf, size_t bufsize)
+{
+  size_t n_read;
+  uintmax_t n_out = 0;      /* for each split.  */
+  size_t n_hold = 0;
+  char *hold = NULL;        /* for lines > bufsize.  */
+  size_t hold_size = 0;
+  bool split_line = false;  /* Whether a \n was output in a split.  */
+
+  do
+    {
+      n_read = safe_read (STDIN_FILENO, buf, bufsize);
+      if (n_read == SAFE_READ_ERROR)
+        die (EXIT_FAILURE, errno, "%s", quotef (infile));
+      size_t n_left = n_read;
+      char *sob = buf;
+      while (n_left)
+        {
+          size_t split_rest = 0;
+          char *eoc = NULL;
+          char *eol;
+
+          /* Determine End Of Chunk and/or End of Line,
+             which are used below to select what to write or buffer.  */
+          if (n_bytes - n_out - n_hold <= n_left)
+            {
+              /* Have enough for split.  */
+              split_rest = n_bytes - n_out - n_hold;
+              eoc = sob + split_rest - 1;
+              eol = memrchr (sob, eolchar, split_rest);
+            }
+          else
+            eol = memrchr (sob, eolchar, n_left);
+
+          /* Output hold space if possible.  */
+          if (n_hold && !(!eol && n_out))
+            {
+              cwrite (n_out == 0, hold, n_hold);
+              n_out += n_hold;
+              if (n_hold > bufsize)
+                hold = xrealloc (hold, bufsize);
+              n_hold = 0;
+              hold_size = bufsize;
+            }
+
+          /* Output to eol if present.  */
+          if (eol)
+            {
+              split_line = true;
+              size_t n_write = eol - sob + 1;
+              cwrite (n_out == 0, sob, n_write);
+              n_out += n_write;
+              n_left -= n_write;
+              sob += n_write;
+              if (eoc)
+                split_rest -= n_write;
+            }
+
+          /* Output to eoc or eob if possible.  */
+          if (n_left && !split_line)
+            {
+              size_t n_write = eoc ? split_rest : n_left;
+              cwrite (n_out == 0, sob, n_write);
+              n_out += n_write;
+              n_left -= n_write;
+              sob += n_write;
+              if (eoc)
+                split_rest -= n_write;
+            }
+
+          /* Update hold if needed.  */
+          if ((eoc && split_rest) || (!eoc && n_left))
+            {
+              size_t n_buf = eoc ? split_rest : n_left;
+              if (hold_size - n_hold < n_buf)
+                {
+                  if (hold_size <= SIZE_MAX - bufsize)
+                    hold_size += bufsize;
+                  else
+                    xalloc_die ();
+                  hold = xrealloc (hold, hold_size);
+                }
+              memcpy (hold + n_hold, sob, n_buf);
+              n_hold += n_buf;
+              n_left -= n_buf;
+              sob += n_buf;
+            }
+
+          /* Reset for new split.  */
+          if (eoc)
+            {
+              n_out = 0;
+              split_line = false;
+            }
+        }
+    }
+  while (n_read);
+
+  /* Handle no eol at end of file.  */
+  if (n_hold)
+    cwrite (n_out == 0, hold, n_hold);
+
+  free (hold);
+}
+
+/* -n l/[K/]N: Write lines to files of approximately file size / N.
+   The file is partitioned into file size / N sized portions, with the
+   last assigned any excess.  If a line _starts_ within a partition
+   it is written completely to the corresponding file.  Since lines
+   are not split even if they overlap a partition, the files written
+   can be larger or smaller than the partition size, and even empty
+   if a line is so long as to completely overlap the partition.  */
+
+static void
+lines_chunk_split (uintmax_t k, uintmax_t n, char *buf, size_t bufsize,
+                   size_t initial_read, off_t file_size)
+{
+  assert (n && k <= n && n <= file_size);
+
+  const off_t chunk_size = file_size / n;
+  uintmax_t chunk_no = 1;
+  off_t chunk_end = chunk_size - 1;
+  off_t n_written = 0;
+  bool new_file_flag = true;
+  bool chunk_truncated = false;
+
+  if (k > 1)
+    {
+      /* Start reading 1 byte before kth chunk of file.  */
+      off_t start = (k - 1) * chunk_size - 1;
+      if (start < initial_read)
+        {
+          memmove (buf, buf + start, initial_read - start);
+          initial_read -= start;
+        }
+      else
+        {
+          if (lseek (STDIN_FILENO, start - initial_read, SEEK_CUR) < 0)
+            die (EXIT_FAILURE, errno, "%s", quotef (infile));
+          initial_read = SIZE_MAX;
+        }
+      n_written = start;
+      chunk_no = k - 1;
+      chunk_end = chunk_no * chunk_size - 1;
+    }
+
+  while (n_written < file_size)
+    {
+      char *bp = buf, *eob;
+      size_t n_read;
+      if (initial_read != SIZE_MAX)
+        {
+          n_read = initial_read;
+          initial_read = SIZE_MAX;
+        }
+      else
+        {
+          n_read = safe_read (STDIN_FILENO, buf, bufsize);
+          if (n_read == SAFE_READ_ERROR)
+            die (EXIT_FAILURE, errno, "%s", quotef (infile));
+        }
+      if (n_read == 0)
+        break; /* eof.  */
+      n_read = MIN (n_read, file_size - n_written);
+      chunk_truncated = false;
+      eob = buf + n_read;
+
+      while (bp != eob)
+        {
+          size_t to_write;
+          bool next = false;
+
+          /* Begin looking for '\n' at last byte of chunk.  */
+          off_t skip = MIN (n_read, MAX (0, chunk_end - n_written));
+          char *bp_out = memchr (bp + skip, eolchar, n_read - skip);
+          if (bp_out)
+            {
+              bp_out++;
+              next = true;
+            }
+          else
+            bp_out = eob;
+          to_write = bp_out - bp;
+
+          if (k == chunk_no)
+            {
+              /* We don't use the stdout buffer here since we're writing
+                 large chunks from an existing file, so it's more efficient
+                 to write out directly.  */
+              if (full_write (STDOUT_FILENO, bp, to_write) != to_write)
+                die (EXIT_FAILURE, errno, "%s", _("write error"));
+            }
+          else if (! k)
+            cwrite (new_file_flag, bp, to_write);
+          n_written += to_write;
+          bp += to_write;
+          n_read -= to_write;
+          new_file_flag = next;
+
+          /* A line could have been so long that it skipped
+             entire chunks. So create empty files in that case.  */
+          while (next || chunk_end <= n_written - 1)
+            {
+              if (!next && bp == eob)
+                {
+                  /* replenish buf, before going to next chunk.  */
+                  chunk_truncated = true;
+                  break;
+                }
+              chunk_no++;
+              if (k && chunk_no > k)
+                return;
+              if (chunk_no == n)
+                chunk_end = file_size - 1; /* >= chunk_size.  */
+              else
+                chunk_end += chunk_size;
+              if (chunk_end <= n_written - 1)
+                {
+                  if (! k)
+                    cwrite (true, NULL, 0);
+                }
+              else
+                next = false;
+            }
+        }
+    }
+
+  if (chunk_truncated)
+    chunk_no++;
+
+  /* Ensure NUMBER files are created, which truncates
+     any existing files or notifies any consumers on fifos.
+     FIXME: Should we do this before EXIT_FAILURE?  */
+  while (!k && chunk_no++ <= n)
+    cwrite (true, NULL, 0);
+}
+
+/* -n K/N: Extract Kth of N chunks.  */
+
+static void
+bytes_chunk_extract (uintmax_t k, uintmax_t n, char *buf, size_t bufsize,
+                     size_t initial_read, off_t file_size)
+{
+  off_t start;
+  off_t end;
+
+  assert (k && n && k <= n && n <= file_size);
+
+  start = (k - 1) * (file_size / n);
+  end = (k == n) ? file_size : k * (file_size / n);
+
+  if (start < initial_read)
+    {
+      memmove (buf, buf + start, initial_read - start);
+      initial_read -= start;
+    }
+  else
+    {
+      if (lseek (STDIN_FILENO, start - initial_read, SEEK_CUR) < 0)
+        die (EXIT_FAILURE, errno, "%s", quotef (infile));
+      initial_read = SIZE_MAX;
+    }
+
+  while (start < end)
+    {
+      size_t n_read;
+      if (initial_read != SIZE_MAX)
+        {
+          n_read = initial_read;
+          initial_read = SIZE_MAX;
+        }
+      else
+        {
+          n_read = safe_read (STDIN_FILENO, buf, bufsize);
+          if (n_read == SAFE_READ_ERROR)
+            die (EXIT_FAILURE, errno, "%s", quotef (infile));
+        }
+      if (n_read == 0)
+        break; /* eof.  */
+      n_read = MIN (n_read, end - start);
+      if (full_write (STDOUT_FILENO, buf, n_read) != n_read
+          && ! ignorable (errno))
+        die (EXIT_FAILURE, errno, "%s", quotef ("-"));
+      start += n_read;
+    }
+}
+
+typedef struct of_info
+{
+  char *of_name;
+  int ofd;
+  FILE *ofile;
+  int opid;
+} of_t;
+
+enum
+{
+  OFD_NEW = -1,
+  OFD_APPEND = -2
+};
+
+/* Rotate file descriptors when we're writing to more output files than we
+   have available file descriptors.
+   Return whether we came under file resource pressure.
+   If so, it's probably best to close each file when finished with it.  */
+
+static bool
+ofile_open (of_t *files, size_t i_check, size_t nfiles)
+{
+  bool file_limit = false;
+
+  if (files[i_check].ofd <= OFD_NEW)
+    {
+      int fd;
+      size_t i_reopen = i_check ? i_check - 1 : nfiles - 1;
+
+      /* Another process could have opened a file in between the calls to
+         close and open, so we should keep trying until open succeeds or
+         we've closed all of our files.  */
+      while (true)
+        {
+          if (files[i_check].ofd == OFD_NEW)
+            fd = create (files[i_check].of_name);
+          else /* OFD_APPEND  */
+            {
+              /* Attempt to append to previously opened file.
+                 We use O_NONBLOCK to support writing to fifos,
+                 where the other end has closed because of our
+                 previous close.  In that case we'll immediately
+                 get an error, rather than waiting indefinitely.
+                 In specialised cases the consumer can keep reading
+                 from the fifo, terminating on conditions in the data
+                 itself, or perhaps never in the case of 'tail -f'.
+                 I.e., for fifos it is valid to attempt this reopen.
+
+                 We don't handle the filter_command case here, as create()
+                 will exit if there are not enough files in that case.
+                 I.e., we don't support restarting filters, as that would
+                 put too much burden on users specifying --filter commands.  */
+              fd = open (files[i_check].of_name,
+                         O_WRONLY | O_BINARY | O_APPEND | O_NONBLOCK);
+            }
+
+          if (-1 < fd)
+            break;
+
+          if (!(errno == EMFILE || errno == ENFILE))
+            die (EXIT_FAILURE, errno, "%s", quotef (files[i_check].of_name));
+
+          file_limit = true;
+
+          /* Search backwards for an open file to close.  */
+          while (files[i_reopen].ofd < 0)
+            {
+              i_reopen = i_reopen ? i_reopen - 1 : nfiles - 1;
+              /* No more open files to close, exit with E[NM]FILE.  */
+              if (i_reopen == i_check)
+                die (EXIT_FAILURE, errno, "%s",
+                     quotef (files[i_check].of_name));
+            }
+
+          if (fclose (files[i_reopen].ofile) != 0)
+            die (EXIT_FAILURE, errno, "%s", quotef (files[i_reopen].of_name));
+          files[i_reopen].ofile = NULL;
+          files[i_reopen].ofd = OFD_APPEND;
+        }
+
+      files[i_check].ofd = fd;
+      if (!(files[i_check].ofile = fdopen (fd, "a")))
+        die (EXIT_FAILURE, errno, "%s", quotef (files[i_check].of_name));
+      files[i_check].opid = filter_pid;
+      filter_pid = 0;
+    }
+
+  return file_limit;
+}
+
+/* -n r/[K/]N: Divide file into N chunks in round robin fashion.
+   Use BUF of size BUFSIZE for the buffer, and if allocating storage
+   put its address into *FILESP to pacify -fsanitize=leak.
+   When K == 0, we try to keep the files open in parallel.
+   If we run out of file resources, then we revert
+   to opening and closing each file for each line.  */
+
+static void
+lines_rr (uintmax_t k, uintmax_t n, char *buf, size_t bufsize, of_t **filesp)
+{
+  bool wrapped = false;
+  bool wrote = false;
+  bool file_limit;
+  size_t i_file;
+  of_t *files IF_LINT (= NULL);
+  uintmax_t line_no;
+
+  if (k)
+    line_no = 1;
+  else
+    {
+      if (SIZE_MAX < n)
+        xalloc_die ();
+      files = *filesp = xnmalloc (n, sizeof *files);
+
+      /* Generate output file names. */
+      for (i_file = 0; i_file < n; i_file++)
+        {
+          next_file_name ();
+          files[i_file].of_name = xstrdup (outfile);
+          files[i_file].ofd = OFD_NEW;
+          files[i_file].ofile = NULL;
+          files[i_file].opid = 0;
+        }
+      i_file = 0;
+      file_limit = false;
+    }
+
+  while (true)
+    {
+      char *bp = buf, *eob;
+      size_t n_read = safe_read (STDIN_FILENO, buf, bufsize);
+      if (n_read == SAFE_READ_ERROR)
+        die (EXIT_FAILURE, errno, "%s", quotef (infile));
+      else if (n_read == 0)
+        break; /* eof.  */
+      eob = buf + n_read;
+
+      while (bp != eob)
+        {
+          size_t to_write;
+          bool next = false;
+
+          /* Find end of line. */
+          char *bp_out = memchr (bp, eolchar, eob - bp);
+          if (bp_out)
+            {
+              bp_out++;
+              next = true;
+            }
+          else
+            bp_out = eob;
+          to_write = bp_out - bp;
+
+          if (k)
+            {
+              if (line_no == k && unbuffered)
+                {
+                  if (full_write (STDOUT_FILENO, bp, to_write) != to_write)
+                    die (EXIT_FAILURE, errno, "%s", _("write error"));
+                }
+              else if (line_no == k && fwrite (bp, to_write, 1, stdout) != 1)
+                {
+                  clearerr (stdout); /* To silence close_stdout().  */
+                  die (EXIT_FAILURE, errno, "%s", _("write error"));
+                }
+              if (next)
+                line_no = (line_no == n) ? 1 : line_no + 1;
+            }
+          else
+            {
+              /* Secure file descriptor. */
+              file_limit |= ofile_open (files, i_file, n);
+              if (unbuffered)
+                {
+                  /* Note writing to fd, rather than flushing the FILE gives
+                     an 8% performance benefit, due to reduced data copying.  */
+                  if (full_write (files[i_file].ofd, bp, to_write) != to_write
+                      && ! ignorable (errno))
+                    {
+                      die (EXIT_FAILURE, errno, "%s",
+                           quotef (files[i_file].of_name));
+                    }
+                }
+              else if (fwrite (bp, to_write, 1, files[i_file].ofile) != 1
+                       && ! ignorable (errno))
+                {
+                  die (EXIT_FAILURE, errno, "%s",
+                       quotef (files[i_file].of_name));
+                }
+
+              if (! ignorable (errno))
+                wrote = true;
+
+              if (file_limit)
+                {
+                  if (fclose (files[i_file].ofile) != 0)
+                    {
+                      die (EXIT_FAILURE, errno, "%s",
+                           quotef (files[i_file].of_name));
+                    }
+                  files[i_file].ofile = NULL;
+                  files[i_file].ofd = OFD_APPEND;
+                }
+              if (next && ++i_file == n)
+                {
+                  wrapped = true;
+                  /* If no filters are accepting input, stop reading.  */
+                  if (! wrote)
+                    goto no_filters;
+                  wrote = false;
+                  i_file = 0;
+                }
+            }
+
+          bp = bp_out;
+        }
+    }
+
+no_filters:
+  /* Ensure all files created, so that any existing files are truncated,
+     and to signal any waiting fifo consumers.
+     Also, close any open file descriptors.
+     FIXME: Should we do this before EXIT_FAILURE?  */
+  if (!k)
+    {
+      int ceiling = (wrapped ? n : i_file);
+      for (i_file = 0; i_file < n; i_file++)
+        {
+          if (i_file >= ceiling && !elide_empty_files)
+            file_limit |= ofile_open (files, i_file, n);
+          if (files[i_file].ofd >= 0)
+            closeout (files[i_file].ofile, files[i_file].ofd,
+                      files[i_file].opid, files[i_file].of_name);
+          files[i_file].ofd = OFD_APPEND;
+        }
+    }
+}
+
+#define FAIL_ONLY_ONE_WAY()					\
+  do								\
+    {								\
+      error (0, 0, _("cannot split in more than one way"));	\
+      usage (EXIT_FAILURE);					\
+    }								\
+  while (0)
+
+
+/* Parse K/N syntax of chunk options.  */
+
+static void
+parse_chunk (uintmax_t *k_units, uintmax_t *n_units, char *slash)
+{
+  *n_units = xdectoumax (slash + 1, 1, UINTMAX_MAX, "",
+                         _("invalid number of chunks"), 0);
+  if (slash != optarg)           /* a leading number is specified.  */
+    {
+      *slash = '\0';
+      *k_units = xdectoumax (optarg, 1, *n_units, "",
+                             _("invalid chunk number"), 0);
+    }
+}
+
+
+int
+main (int argc, char **argv)
+{
+  enum Split_type split_type = type_undef;
+  idx_t in_blk_size = 0;	/* optimal block size of input file device */
+  size_t page_size = getpagesize ();
+  uintmax_t k_units = 0;
+  uintmax_t n_units = 0;
+
+  static char const multipliers[] = "bEGKkMmPTYZ0";
+  int c;
+  int digits_optind = 0;
+  off_t file_size = OFF_T_MAX;
+
+  initialize_main (&argc, &argv);
+  set_program_name (argv[0]);
+  setlocale (LC_ALL, "");
+  bindtextdomain (PACKAGE, LOCALEDIR);
+  textdomain (PACKAGE);
+
+  atexit (close_stdout);
+
+  /* Parse command line options.  */
+
+  infile = bad_cast ("-");
+  outbase = bad_cast ("x");
+
+  while (true)
+    {
+      /* This is the argv-index of the option we will read next.  */
+      int this_optind = optind ? optind : 1;
+      char *slash;
+
+      c = getopt_long (argc, argv, "0123456789C:a:b:del:n:t:ux",
+                       longopts, NULL);
+      if (c == -1)
+        break;
+
+      switch (c)
+        {
+        case 'a':
+          suffix_length = xdectoumax (optarg, 0, SIZE_MAX / sizeof (size_t),
+                                      "", _("invalid suffix length"), 0);
+          break;
+
+        case ADDITIONAL_SUFFIX_OPTION:
+          if (last_component (optarg) != optarg)
+            {
+              error (0, 0,
+                     _("invalid suffix %s, contains directory separator"),
+                     quote (optarg));
+              usage (EXIT_FAILURE);
+            }
+          additional_suffix = optarg;
+          break;
+
+        case 'b':
+          if (split_type != type_undef)
+            FAIL_ONLY_ONE_WAY ();
+          split_type = type_bytes;
+          /* Limit to OFF_T_MAX, because if input is a pipe, we could get more
+             data than is possible to write to a single file, so indicate that
+             immediately rather than having possibly future invocations fail. */
+          n_units = xdectoumax (optarg, 1, OFF_T_MAX, multipliers,
+                                _("invalid number of bytes"), 0);
+          break;
+
+        case 'l':
+          if (split_type != type_undef)
+            FAIL_ONLY_ONE_WAY ();
+          split_type = type_lines;
+          n_units = xdectoumax (optarg, 1, UINTMAX_MAX, "",
+                                _("invalid number of lines"), 0);
+          break;
+
+        case 'C':
+          if (split_type != type_undef)
+            FAIL_ONLY_ONE_WAY ();
+          split_type = type_byteslines;
+          n_units = xdectoumax (optarg, 1, MIN (SIZE_MAX, OFF_T_MAX),
+                                multipliers, _("invalid number of bytes"), 0);
+          break;
+
+        case 'n':
+          if (split_type != type_undef)
+            FAIL_ONLY_ONE_WAY ();
+          /* skip any whitespace */
+          while (isspace (to_uchar (*optarg)))
+            optarg++;
+          if (STRNCMP_LIT (optarg, "r/") == 0)
+            {
+              split_type = type_rr;
+              optarg += 2;
+            }
+          else if (STRNCMP_LIT (optarg, "l/") == 0)
+            {
+              split_type = type_chunk_lines;
+              optarg += 2;
+            }
+          else
+            split_type = type_chunk_bytes;
+          if ((slash = strchr (optarg, '/')))
+            parse_chunk (&k_units, &n_units, slash);
+          else
+            n_units = xdectoumax (optarg, 1, UINTMAX_MAX, "",
+                                  _("invalid number of chunks"), 0);
+          break;
+
+        case 'u':
+          unbuffered = true;
+          break;
+
+        case 't':
+          {
+            char neweol = optarg[0];
+            if (! neweol)
+              die (EXIT_FAILURE, 0, _("empty record separator"));
+            if (optarg[1])
+              {
+                if (STREQ (optarg, "\\0"))
+                  neweol = '\0';
+                else
+                  {
+                    /* Provoke with 'split -txx'.  Complain about
+                       "multi-character tab" instead of "multibyte tab", so
+                       that the diagnostic's wording does not need to be
+                       changed once multibyte characters are supported.  */
+                    die (EXIT_FAILURE, 0, _("multi-character separator %s"),
+                         quote (optarg));
+                  }
+              }
+            /* Make it explicit we don't support multiple separators.  */
+            if (0 <= eolchar && neweol != eolchar)
+              {
+                die (EXIT_FAILURE, 0,
+                     _("multiple separator characters specified"));
+              }
+
+            eolchar = neweol;
+          }
+          break;
+
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+          if (split_type == type_undef)
+            {
+              split_type = type_digits;
+              n_units = 0;
+            }
+          if (split_type != type_undef && split_type != type_digits)
+            FAIL_ONLY_ONE_WAY ();
+          if (digits_optind != 0 && digits_optind != this_optind)
+            n_units = 0;	/* More than one number given; ignore other. */
+          digits_optind = this_optind;
+          if (!DECIMAL_DIGIT_ACCUMULATE (n_units, c - '0', uintmax_t))
+            {
+              char buffer[INT_BUFSIZE_BOUND (uintmax_t)];
+              die (EXIT_FAILURE, 0,
+                   _("line count option -%s%c... is too large"),
+                   umaxtostr (n_units, buffer), c);
+            }
+          break;
+
+        case 'd':
+        case 'x':
+          if (c == 'd')
+            suffix_alphabet = "0123456789";
+          else
+            suffix_alphabet = "0123456789abcdef";
+          if (optarg)
+            {
+              if (strlen (optarg) != strspn (optarg, suffix_alphabet))
+                {
+                  error (0, 0,
+                         (c == 'd') ?
+                           _("%s: invalid start value for numerical suffix") :
+                           _("%s: invalid start value for hexadecimal suffix"),
+                         quote (optarg));
+                  usage (EXIT_FAILURE);
+                }
+              else
+                {
+                  /* Skip any leading zero.  */
+                  while (*optarg == '0' && *(optarg + 1) != '\0')
+                    optarg++;
+                  numeric_suffix_start = optarg;
+                }
+            }
+          break;
+
+        case 'e':
+          elide_empty_files = true;
+          break;
+
+        case FILTER_OPTION:
+          filter_command = optarg;
+          break;
+
+        case IO_BLKSIZE_OPTION:
+          in_blk_size = xdectoumax (optarg, 1, MIN (IDX_MAX, SIZE_MAX) - 1,
+                                    multipliers, _("invalid IO block size"), 0);
+          break;
+
+        case VERBOSE_OPTION:
+          verbose = true;
+          break;
+
+        case_GETOPT_HELP_CHAR;
+
+        case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
+
+        default:
+          usage (EXIT_FAILURE);
+        }
+    }
+
+  if (k_units != 0 && filter_command)
+    {
+      error (0, 0, _("--filter does not process a chunk extracted to stdout"));
+      usage (EXIT_FAILURE);
+    }
+
+  /* Handle default case.  */
+  if (split_type == type_undef)
+    {
+      split_type = type_lines;
+      n_units = 1000;
+    }
+
+  if (n_units == 0)
+    {
+      error (0, 0, "%s: %s", _("invalid number of lines"), quote ("0"));
+      usage (EXIT_FAILURE);
+    }
+
+  if (eolchar < 0)
+    eolchar = '\n';
+
+  set_suffix_length (n_units, split_type);
+
+  /* Get out the filename arguments.  */
+
+  if (optind < argc)
+    infile = argv[optind++];
+
+  if (optind < argc)
+    outbase = argv[optind++];
+
+  if (optind < argc)
+    {
+      error (0, 0, _("extra operand %s"), quote (argv[optind]));
+      usage (EXIT_FAILURE);
+    }
+
+  /* Check that the suffix length is large enough for the numerical
+     suffix start value.  */
+  if (numeric_suffix_start && strlen (numeric_suffix_start) > suffix_length)
+    {
+      error (0, 0, _("numerical suffix start value is too large "
+                     "for the suffix length"));
+      usage (EXIT_FAILURE);
+    }
+
+  /* Open the input file.  */
+  if (! STREQ (infile, "-")
+      && fd_reopen (STDIN_FILENO, infile, O_RDONLY, 0) < 0)
+    die (EXIT_FAILURE, errno, _("cannot open %s for reading"),
+         quoteaf (infile));
+
+  /* Binary I/O is safer when byte counts are used.  */
+  xset_binary_mode (STDIN_FILENO, O_BINARY);
+
+  /* Get the optimal block size of input device and make a buffer.  */
+
+  if (fstat (STDIN_FILENO, &in_stat_buf) != 0)
+    die (EXIT_FAILURE, errno, "%s", quotef (infile));
+
+  bool specified_buf_size = !! in_blk_size;
+  if (! specified_buf_size)
+    in_blk_size = io_blksize (in_stat_buf);
+
+  char *buf = xalignalloc (page_size, in_blk_size + 1);
+  size_t initial_read = SIZE_MAX;
+
+  if (split_type == type_chunk_bytes || split_type == type_chunk_lines)
+    {
+      file_size = input_file_size (STDIN_FILENO, &in_stat_buf,
+                                   buf, in_blk_size);
+      if (file_size < 0)
+        die (EXIT_FAILURE, errno, _("%s: cannot determine file size"),
+             quotef (infile));
+      initial_read = MIN (file_size, in_blk_size);
+      /* Overflow, and sanity checking.  */
+      if (OFF_T_MAX < n_units)
+        {
+          char buffer[INT_BUFSIZE_BOUND (uintmax_t)];
+          die (EXIT_FAILURE, EOVERFLOW, "%s: %s",
+               _("invalid number of chunks"),
+               quote (umaxtostr (n_units, buffer)));
+        }
+      /* increase file_size to n_units here, so that we still process
+         any input data, and create empty files for the rest.  */
+      file_size = MAX (file_size, n_units);
+    }
+
+  /* When filtering, closure of one pipe must not terminate the process,
+     as there may still be other streams expecting input from us.  */
+  if (filter_command)
+    {
+      struct sigaction act;
+      sigemptyset (&newblocked);
+      sigaction (SIGPIPE, NULL, &act);
+      if (act.sa_handler != SIG_IGN)
+        sigaddset (&newblocked, SIGPIPE);
+      sigprocmask (SIG_BLOCK, &newblocked, &oldblocked);
+    }
+
+  switch (split_type)
+    {
+    case type_digits:
+    case type_lines:
+      lines_split (n_units, buf, in_blk_size);
+      break;
+
+    case type_bytes:
+      bytes_split (n_units, buf, in_blk_size, SIZE_MAX, 0);
+      break;
+
+    case type_byteslines:
+      line_bytes_split (n_units, buf, in_blk_size);
+      break;
+
+    case type_chunk_bytes:
+      if (k_units == 0)
+        bytes_split (file_size / n_units, buf, in_blk_size, initial_read,
+                     n_units);
+      else
+        bytes_chunk_extract (k_units, n_units, buf, in_blk_size, initial_read,
+                             file_size);
+      break;
+
+    case type_chunk_lines:
+      lines_chunk_split (k_units, n_units, buf, in_blk_size, initial_read,
+                         file_size);
+      break;
+
+    case type_rr:
+      /* Note, this is like 'sed -n ${k}~${n}p' when k > 0,
+         but the functionality is provided for symmetry.  */
+      {
+        of_t *files;
+        lines_rr (k_units, n_units, buf, in_blk_size, &files);
+      }
+      break;
+
+    default:
+      abort ();
+    }
+
+  if (close (STDIN_FILENO) != 0)
+    die (EXIT_FAILURE, errno, "%s", quotef (infile));
+  closeout (NULL, output_desc, filter_pid, outfile);
+
+  main_exit (EXIT_SUCCESS);
+}