1 /* split.c -- split a file into pieces.
2 Copyright (C) 1988, 1991, 1995-2011 Free Software Foundation, Inc.
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
17 /* By tege@sics.se, with rms.
20 * Implement -t CHAR or -t REGEX to specify break characters other
29 #include <sys/types.h>
34 #include "fd-reopen.h"
36 #include "full-read.h"
37 #include "full-write.h"
39 #include "safe-read.h"
44 /* The official name of this program (e.g., no `g' prefix). */
45 #define PROGRAM_NAME "split"
48 proper_name_utf8 ("Torbjorn Granlund", "Torbj\303\266rn Granlund"), \
49 proper_name ("Richard M. Stallman")
51 /* Shell command to filter through, instead of creating files. */
52 static char const *filter_command;
54 /* Process ID of the filter. */
55 static int filter_pid;
57 /* Array of open pipes. */
58 static int *open_pipes;
59 static size_t open_pipes_alloc;
60 static size_t n_open_pipes;
62 /* Blocked signals. */
63 static sigset_t oldblocked;
64 static sigset_t newblocked;
66 /* Base name of output files. */
67 static char const *outbase;
69 /* Name of output files. */
72 /* Pointer to the end of the prefix in OUTFILE.
73 Suffixes are inserted here. */
74 static char *outfile_mid;
76 /* Length of OUTFILE's suffix. */
77 static size_t suffix_length;
79 /* Alphabet of characters to use in suffix. */
80 static char const *suffix_alphabet = "abcdefghijklmnopqrstuvwxyz";
82 /* Name of input file. May be "-". */
85 /* Descriptor on which output file is open. */
86 static int output_desc = -1;
88 /* If true, print a diagnostic on standard error just before each
89 output file is opened. */
92 /* If true, don't generate zero length output files. */
93 static bool elide_empty_files;
95 /* If true, in round robin mode, immediately copy
96 input to output, which is much slower, so disabled by default. */
97 static bool unbuffered;
99 /* The split mode to use. */
102 type_undef, type_bytes, type_byteslines, type_lines, type_digits,
103 type_chunk_bytes, type_chunk_lines, type_rr
106 /* For long options that have no equivalent short option, use a
107 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
110 VERBOSE_OPTION = CHAR_MAX + 1,
115 static struct option const longopts[] =
117 {"bytes", required_argument, NULL, 'b'},
118 {"lines", required_argument, NULL, 'l'},
119 {"line-bytes", required_argument, NULL, 'C'},
120 {"number", required_argument, NULL, 'n'},
121 {"elide-empty-files", no_argument, NULL, 'e'},
122 {"unbuffered", no_argument, NULL, 'u'},
123 {"suffix-length", required_argument, NULL, 'a'},
124 {"numeric-suffixes", no_argument, NULL, 'd'},
125 {"filter", required_argument, NULL, FILTER_OPTION},
126 {"verbose", no_argument, NULL, VERBOSE_OPTION},
127 {"-io-blksize", required_argument, NULL,
128 IO_BLKSIZE_OPTION}, /* do not document */
129 {GETOPT_HELP_OPTION_DECL},
130 {GETOPT_VERSION_OPTION_DECL},
134 /* Return true if the errno value, ERR, is ignorable. */
138 return filter_command && err == EPIPE;
142 set_suffix_length (uintmax_t n_units, enum Split_type split_type)
144 #define DEFAULT_SUFFIX_LENGTH 2
146 size_t suffix_needed = 0;
148 /* Auto-calculate the suffix length if the number of files is given. */
149 if (split_type == type_chunk_bytes || split_type == type_chunk_lines
150 || split_type == type_rr)
152 size_t alphabet_len = strlen (suffix_alphabet);
153 bool alphabet_slop = (n_units % alphabet_len) != 0;
154 while (n_units /= alphabet_len)
156 suffix_needed += alphabet_slop;
159 if (suffix_length) /* set by user */
161 if (suffix_length < suffix_needed)
163 error (EXIT_FAILURE, 0,
164 _("the suffix length needs to be at least %zu"),
170 suffix_length = MAX (DEFAULT_SUFFIX_LENGTH, suffix_needed);
176 if (status != EXIT_SUCCESS)
177 fprintf (stderr, _("Try `%s --help' for more information.\n"),
182 Usage: %s [OPTION]... [INPUT [PREFIX]]\n\
186 Output fixed-size pieces of INPUT to PREFIXaa, PREFIXab, ...; default\n\
187 size is 1000 lines, and default PREFIX is `x'. With no INPUT, or when INPUT\n\
188 is -, read standard input.\n\
192 Mandatory arguments to long options are mandatory for short options too.\n\
194 fprintf (stdout, _("\
195 -a, --suffix-length=N use suffixes of length N (default %d)\n\
196 -b, --bytes=SIZE put SIZE bytes per output file\n\
197 -C, --line-bytes=SIZE put at most SIZE bytes of lines per output file\n\
198 -d, --numeric-suffixes use numeric suffixes instead of alphabetic\n\
199 -e, --elide-empty-files do not generate empty output files with `-n'\n\
200 --filter=COMMAND write to shell COMMAND; file name is $FILE\n\
201 -l, --lines=NUMBER put NUMBER lines per output file\n\
202 -n, --number=CHUNKS generate CHUNKS output files. See below\n\
203 -u, --unbuffered immediately copy input to output with `-n r/...'\n\
204 "), DEFAULT_SUFFIX_LENGTH);
206 --verbose print a diagnostic just before each\n\
207 output file is opened\n\
209 fputs (HELP_OPTION_DESCRIPTION, stdout);
210 fputs (VERSION_OPTION_DESCRIPTION, stdout);
214 N split into N files based on size of input\n\
215 K/N output Kth of N to stdout\n\
216 l/N split into N files without splitting lines\n\
217 l/K/N output Kth of N to stdout without splitting lines\n\
218 r/N like `l' but use round robin distribution\n\
219 r/K/N likewise but only output Kth of N to stdout\n\
221 emit_ancillary_info ();
226 /* Compute the next sequential output file name and store it into the
230 next_file_name (void)
232 /* Index in suffix_alphabet of each character in the suffix. */
233 static size_t *sufindex;
237 /* Allocate and initialize the first file name. */
239 size_t outbase_length = strlen (outbase);
240 size_t outfile_length = outbase_length + suffix_length;
241 if (outfile_length + 1 < outbase_length)
243 outfile = xmalloc (outfile_length + 1);
244 outfile_mid = outfile + outbase_length;
245 memcpy (outfile, outbase, outbase_length);
246 memset (outfile_mid, suffix_alphabet[0], suffix_length);
247 outfile[outfile_length] = 0;
248 sufindex = xcalloc (suffix_length, sizeof *sufindex);
250 #if ! _POSIX_NO_TRUNC && HAVE_PATHCONF && defined _PC_NAME_MAX
251 /* POSIX requires that if the output file name is too long for
252 its directory, `split' must fail without creating any files.
253 This must be checked for explicitly on operating systems that
254 silently truncate file names. */
256 char *dir = dir_name (outfile);
257 long name_max = pathconf (dir, _PC_NAME_MAX);
258 if (0 <= name_max && name_max < base_len (last_component (outfile)))
259 error (EXIT_FAILURE, ENAMETOOLONG, "%s", outfile);
266 /* Increment the suffix in place, if possible. */
268 size_t i = suffix_length;
272 outfile_mid[i] = suffix_alphabet[sufindex[i]];
276 outfile_mid[i] = suffix_alphabet[sufindex[i]];
278 error (EXIT_FAILURE, 0, _("output file suffixes exhausted"));
282 /* Create or truncate a file. */
285 create (const char *name)
290 fprintf (stdout, _("creating file %s\n"), quote (name));
291 return open (name, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
292 (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH));
298 char const *shell_prog = getenv ("SHELL");
299 if (shell_prog == NULL)
300 shell_prog = "/bin/sh";
301 if (setenv ("FILE", name, 1) != 0)
302 error (EXIT_FAILURE, errno,
303 _("failed to set FILE environment variable"));
305 fprintf (stdout, _("executing with FILE=%s\n"), quote (name));
306 if (pipe (fd_pair) != 0)
307 error (EXIT_FAILURE, errno, _("failed to create pipe"));
311 /* This is the child process. If an error occurs here, the
312 parent will eventually learn about it after doing a wait,
313 at which time it will emit its own error message. */
315 /* We have to close any pipes that were opened during an
316 earlier call, otherwise this process will be holding a
317 write-pipe that will prevent the earlier process from
318 reading an EOF on the corresponding read-pipe. */
319 for (j = 0; j < n_open_pipes; ++j)
320 if (close (open_pipes[j]) != 0)
321 error (EXIT_FAILURE, errno, _("closing prior pipe"));
322 if (close (fd_pair[1]))
323 error (EXIT_FAILURE, errno, _("closing output pipe"));
324 if (fd_pair[0] != STDIN_FILENO)
326 if (dup2 (fd_pair[0], STDIN_FILENO) != STDIN_FILENO)
327 error (EXIT_FAILURE, errno, _("moving input pipe"));
328 if (close (fd_pair[0]) != 0)
329 error (EXIT_FAILURE, errno, _("closing input pipe"));
331 sigprocmask (SIG_SETMASK, &oldblocked, NULL);
332 execl (shell_prog, last_component (shell_prog), "-c",
333 filter_command, (char *) NULL);
334 error (EXIT_FAILURE, errno, _("failed to run command: \"%s -c %s\""),
335 shell_prog, filter_command);
338 error (EXIT_FAILURE, errno, _("fork system call failed"));
339 if (close (fd_pair[0]) != 0)
340 error (EXIT_FAILURE, errno, _("failed to close input pipe"));
341 filter_pid = child_pid;
342 if (n_open_pipes == open_pipes_alloc)
343 open_pipes = x2nrealloc (open_pipes, &open_pipes_alloc,
345 open_pipes[n_open_pipes++] = fd_pair[1];
350 /* Close the output file, and do any associated cleanup.
351 If FP and FD are both specified, they refer to the same open file;
352 in this case FP is closed, but FD is still used in cleanup. */
354 closeout (FILE *fp, int fd, pid_t pid, char const *name)
356 if (fp != NULL && fclose (fp) != 0 && ! ignorable (errno))
357 error (EXIT_FAILURE, errno, "%s", name);
360 if (fp == NULL && close (fd) < 0)
361 error (EXIT_FAILURE, errno, "%s", name);
363 for (j = 0; j < n_open_pipes; ++j)
365 if (open_pipes[j] == fd)
367 open_pipes[j] = open_pipes[--n_open_pipes];
375 if (waitpid (pid, &wstatus, 0) == -1 && errno != ECHILD)
376 error (EXIT_FAILURE, errno, _("waiting for child process"));
377 if (WIFSIGNALED (wstatus))
379 int sig = WTERMSIG (wstatus);
382 char signame[MAX (SIG2STR_MAX, INT_BUFSIZE_BOUND (int))];
383 if (sig2str (sig, signame) != 0)
384 sprintf (signame, "%d", sig);
386 _("with FILE=%s, signal %s (%s) from command: %s"),
387 name, signame, strsignal (sig), filter_command);
390 else if (WIFEXITED (wstatus))
392 int ex = WEXITSTATUS (wstatus);
394 error (ex, 0, _("with FILE=%s, exit %d from command: %s"),
395 name, ex, filter_command);
399 /* shouldn't happen. */
400 error (EXIT_FAILURE, 0,
401 _("unknown status from command (0x%X)"), wstatus);
406 /* Write BYTES bytes at BP to an output file.
407 If NEW_FILE_FLAG is true, open the next output file.
408 Otherwise add to the same output file already in use. */
411 cwrite (bool new_file_flag, const char *bp, size_t bytes)
415 if (!bp && bytes == 0 && elide_empty_files)
417 closeout (NULL, output_desc, filter_pid, outfile);
419 if ((output_desc = create (outfile)) < 0)
420 error (EXIT_FAILURE, errno, "%s", outfile);
422 if (full_write (output_desc, bp, bytes) != bytes && ! ignorable (errno))
423 error (EXIT_FAILURE, errno, "%s", outfile);
426 /* Split into pieces of exactly N_BYTES bytes.
427 Use buffer BUF, whose size is BUFSIZE. */
430 bytes_split (uintmax_t n_bytes, char *buf, size_t bufsize, uintmax_t max_files)
433 bool new_file_flag = true;
435 uintmax_t to_write = n_bytes;
437 uintmax_t opened = 0;
441 n_read = full_read (STDIN_FILENO, buf, bufsize);
442 if (n_read < bufsize && errno)
443 error (EXIT_FAILURE, errno, "%s", infile);
448 if (to_read < to_write)
450 if (to_read) /* do not write 0 bytes! */
452 cwrite (new_file_flag, bp_out, to_read);
453 opened += new_file_flag;
455 new_file_flag = false;
462 cwrite (new_file_flag, bp_out, w);
463 opened += new_file_flag;
464 new_file_flag = !max_files || (opened < max_files);
471 while (n_read == bufsize);
473 /* Ensure NUMBER files are created, which truncates
474 any existing files or notifies any consumers on fifos.
475 FIXME: Should we do this before EXIT_FAILURE? */
476 while (opened++ < max_files)
477 cwrite (true, NULL, 0);
480 /* Split into pieces of exactly N_LINES lines.
481 Use buffer BUF, whose size is BUFSIZE. */
484 lines_split (uintmax_t n_lines, char *buf, size_t bufsize)
487 char *bp, *bp_out, *eob;
488 bool new_file_flag = true;
493 n_read = full_read (STDIN_FILENO, buf, bufsize);
494 if (n_read < bufsize && errno)
495 error (EXIT_FAILURE, errno, "%s", infile);
501 bp = memchr (bp, '\n', eob - bp + 1);
504 if (eob != bp_out) /* do not write 0 bytes! */
506 size_t len = eob - bp_out;
507 cwrite (new_file_flag, bp_out, len);
508 new_file_flag = false;
516 cwrite (new_file_flag, bp_out, bp - bp_out);
518 new_file_flag = true;
523 while (n_read == bufsize);
526 /* Split into pieces that are as large as possible while still not more
527 than N_BYTES bytes, and are split on line boundaries except
528 where lines longer than N_BYTES bytes occur.
529 FIXME: Allow N_BYTES to be any uintmax_t value, and don't require a
530 buffer of size N_BYTES, in case N_BYTES is very large. */
533 line_bytes_split (size_t n_bytes)
537 size_t n_buffered = 0;
538 char *buf = xmalloc (n_bytes);
542 /* Fill up the full buffer size from the input file. */
544 size_t to_read = n_bytes - n_buffered;
545 size_t n_read = full_read (STDIN_FILENO, buf + n_buffered, to_read);
546 if (n_read < to_read && errno)
547 error (EXIT_FAILURE, errno, "%s", infile);
549 n_buffered += n_read;
550 if (n_buffered != n_bytes)
557 /* Find where to end this chunk. */
558 bp = buf + n_buffered;
559 if (n_buffered == n_bytes)
561 while (bp > buf && bp[-1] != '\n')
565 /* If chunk has no newlines, use all the chunk. */
567 bp = buf + n_buffered;
569 /* Output the chars as one output file. */
570 cwrite (true, buf, bp - buf);
572 /* Discard the chars we just output; move rest of chunk
573 down to be the start of the next chunk. Source and
574 destination probably overlap. */
575 n_buffered -= bp - buf;
577 memmove (buf, bp, n_buffered);
583 /* -n l/[K/]N: Write lines to files of approximately file size / N.
584 The file is partitioned into file size / N sized portions, with the
585 last assigned any excess. If a line _starts_ within a partition
586 it is written completely to the corresponding file. Since lines
587 are not split even if they overlap a partition, the files written
588 can be larger or smaller than the partition size, and even empty
589 if a line is so long as to completely overlap the partition. */
592 lines_chunk_split (uintmax_t k, uintmax_t n, char *buf, size_t bufsize,
595 assert (n && k <= n && n <= file_size);
597 const off_t chunk_size = file_size / n;
598 uintmax_t chunk_no = 1;
599 off_t chunk_end = chunk_size - 1;
601 bool new_file_flag = true;
602 bool chunk_truncated = false;
606 /* Start reading 1 byte before kth chunk of file. */
607 off_t start = (k - 1) * chunk_size - 1;
608 if (lseek (STDIN_FILENO, start, SEEK_CUR) < 0)
609 error (EXIT_FAILURE, errno, "%s", infile);
612 chunk_end = chunk_no * chunk_size - 1;
615 while (n_written < file_size)
617 char *bp = buf, *eob;
618 size_t n_read = full_read (STDIN_FILENO, buf, bufsize);
619 n_read = MIN (n_read, file_size - n_written);
620 if (n_read < bufsize && errno)
621 error (EXIT_FAILURE, errno, "%s", infile);
622 else if (n_read == 0)
624 chunk_truncated = false;
632 /* Begin looking for '\n' at last byte of chunk. */
633 off_t skip = MIN (n_read, MAX (0, chunk_end - n_written));
634 char *bp_out = memchr (bp + skip, '\n', n_read - skip);
639 to_write = bp_out - bp;
643 /* We don't use the stdout buffer here since we're writing
644 large chunks from an existing file, so it's more efficient
645 to write out directly. */
646 if (full_write (STDOUT_FILENO, bp, to_write) != to_write
647 && ! ignorable (errno))
648 error (EXIT_FAILURE, errno, "%s", _("write error"));
651 cwrite (new_file_flag, bp, to_write);
652 n_written += to_write;
655 new_file_flag = next;
657 /* A line could have been so long that it skipped
658 entire chunks. So create empty files in that case. */
659 while (next || chunk_end <= n_written - 1)
661 if (!next && bp == eob)
663 /* replenish buf, before going to next chunk. */
664 chunk_truncated = true;
668 if (k && chunk_no > k)
671 chunk_end = file_size - 1; /* >= chunk_size. */
673 chunk_end += chunk_size;
674 if (chunk_end <= n_written - 1)
677 cwrite (true, NULL, 0);
688 /* Ensure NUMBER files are created, which truncates
689 any existing files or notifies any consumers on fifos.
690 FIXME: Should we do this before EXIT_FAILURE? */
691 while (!k && chunk_no++ <= n)
692 cwrite (true, NULL, 0);
695 /* -n K/N: Extract Kth of N chunks. */
698 bytes_chunk_extract (uintmax_t k, uintmax_t n, char *buf, size_t bufsize,
704 assert (k && n && k <= n && n <= file_size);
706 start = (k - 1) * (file_size / n);
707 end = (k == n) ? file_size : k * (file_size / n);
709 if (lseek (STDIN_FILENO, start, SEEK_CUR) < 0)
710 error (EXIT_FAILURE, errno, "%s", infile);
714 size_t n_read = full_read (STDIN_FILENO, buf, bufsize);
715 n_read = MIN (n_read, end - start);
716 if (n_read < bufsize && errno)
717 error (EXIT_FAILURE, errno, "%s", infile);
718 else if (n_read == 0)
720 if (full_write (STDOUT_FILENO, buf, n_read) != n_read
721 && ! ignorable (errno))
722 error (EXIT_FAILURE, errno, "%s", quote ("-"));
727 typedef struct of_info
741 /* Rotate file descriptors when we're writing to more output files than we
742 have available file descriptors.
743 Return whether we came under file resource pressure.
744 If so, it's probably best to close each file when finished with it. */
747 ofile_open (of_t *files, size_t i_check, size_t nfiles)
749 bool file_limit = false;
751 if (files[i_check].ofd <= OFD_NEW)
754 size_t i_reopen = i_check ? i_check - 1 : nfiles - 1;
756 /* Another process could have opened a file in between the calls to
757 close and open, so we should keep trying until open succeeds or
758 we've closed all of our files. */
761 if (files[i_check].ofd == OFD_NEW)
762 fd = create (files[i_check].of_name);
763 else /* OFD_APPEND */
765 /* Attempt to append to previously opened file.
766 We use O_NONBLOCK to support writing to fifos,
767 where the other end has closed because of our
768 previous close. In that case we'll immediately
769 get an error, rather than waiting indefinitely.
770 In specialised cases the consumer can keep reading
771 from the fifo, terminating on conditions in the data
772 itself, or perhaps never in the case of `tail -f`.
773 I.E. for fifos it is valid to attempt this reopen. */
774 fd = open (files[i_check].of_name,
775 O_WRONLY | O_BINARY | O_APPEND | O_NONBLOCK);
781 if (!(errno == EMFILE || errno == ENFILE))
782 error (EXIT_FAILURE, errno, "%s", files[i_check].of_name);
786 /* Search backwards for an open file to close. */
787 while (files[i_reopen].ofd < 0)
789 i_reopen = i_reopen ? i_reopen - 1 : nfiles - 1;
790 /* No more open files to close, exit with E[NM]FILE. */
791 if (i_reopen == i_check)
792 error (EXIT_FAILURE, errno, "%s", files[i_check].of_name);
795 if (fclose (files[i_reopen].ofile) != 0 && ! ignorable (errno))
796 error (EXIT_FAILURE, errno, "%s", files[i_reopen].of_name);
797 files[i_reopen].ofile = NULL;
798 files[i_reopen].ofd = OFD_APPEND;
801 files[i_check].ofd = fd;
802 if (!(files[i_check].ofile = fdopen (fd, "a")))
803 error (EXIT_FAILURE, errno, "%s", files[i_check].of_name);
804 files[i_check].opid = filter_pid;
811 /* -n r/[K/]N: Divide file into N chunks in round robin fashion.
812 When K == 0, we try to keep the files open in parallel.
813 If we run out of file resources, then we revert
814 to opening and closing each file for each line. */
817 lines_rr (uintmax_t k, uintmax_t n, char *buf, size_t bufsize)
819 bool wrapped = false;
822 of_t *files IF_LINT (= NULL);
830 error (exit_failure, 0, "%s", _("memory exhausted"));
831 files = xnmalloc (n, sizeof *files);
833 /* Generate output file names. */
834 for (i_file = 0; i_file < n; i_file++)
837 files[i_file].of_name = xstrdup (outfile);
838 files[i_file].ofd = OFD_NEW;
839 files[i_file].ofile = NULL;
840 files[i_file].opid = 0;
848 char *bp = buf, *eob;
849 /* Use safe_read() rather than full_read() here
850 so that we process available data immediately. */
851 size_t n_read = safe_read (STDIN_FILENO, buf, bufsize);
852 if (n_read == SAFE_READ_ERROR)
853 error (EXIT_FAILURE, errno, "%s", infile);
854 else if (n_read == 0)
863 /* Find end of line. */
864 char *bp_out = memchr (bp, '\n', eob - bp);
872 to_write = bp_out - bp;
876 if (line_no == k && unbuffered)
878 if (full_write (STDOUT_FILENO, bp, to_write) != to_write
879 && ! ignorable (errno))
880 error (EXIT_FAILURE, errno, "%s", _("write error"));
882 else if (line_no == k && fwrite (bp, to_write, 1, stdout) != 1
883 && ! ignorable (errno))
885 clearerr (stdout); /* To silence close_stdout(). */
886 error (EXIT_FAILURE, errno, "%s", _("write error"));
889 line_no = (line_no == n) ? 1 : line_no + 1;
893 /* Secure file descriptor. */
894 file_limit |= ofile_open (files, i_file, n);
897 /* Note writing to fd, rather than flushing the FILE gives
898 an 8% performance benefit, due to reduced data copying. */
899 if (full_write (files[i_file].ofd, bp, to_write) != to_write
900 && ! ignorable (errno))
901 error (EXIT_FAILURE, errno, "%s", files[i_file].of_name);
903 else if (fwrite (bp, to_write, 1, files[i_file].ofile) != 1
904 && ! ignorable (errno))
905 error (EXIT_FAILURE, errno, "%s", files[i_file].of_name);
908 if (fclose (files[i_file].ofile) != 0 && ! ignorable (errno))
909 error (EXIT_FAILURE, errno, "%s", files[i_file].of_name);
910 files[i_file].ofile = NULL;
911 files[i_file].ofd = OFD_APPEND;
913 if (next && ++i_file == n)
924 /* Ensure all files created, so that any existing files are truncated,
925 and to signal any waiting fifo consumers.
926 Also, close any open file descriptors.
927 FIXME: Should we do this before EXIT_FAILURE? */
930 int ceiling = (wrapped ? n : i_file);
931 for (i_file = 0; i_file < n; i_file++)
933 if (i_file >= ceiling && !elide_empty_files)
934 file_limit |= ofile_open (files, i_file, n);
935 if (files[i_file].ofd >= 0)
936 closeout (files[i_file].ofile, files[i_file].ofd,
937 files[i_file].opid, files[i_file].of_name);
938 files[i_file].ofd = OFD_APPEND;
943 #define FAIL_ONLY_ONE_WAY() \
946 error (0, 0, _("cannot split in more than one way")); \
947 usage (EXIT_FAILURE); \
951 /* Parse K/N syntax of chunk options. */
954 parse_chunk (uintmax_t *k_units, uintmax_t *n_units, char *slash)
957 if (xstrtoumax (slash + 1, NULL, 10, n_units, "") != LONGINT_OK
959 error (EXIT_FAILURE, 0, _("%s: invalid number of chunks"), slash + 1);
960 if (slash != optarg /* a leading number is specified. */
961 && (xstrtoumax (optarg, NULL, 10, k_units, "") != LONGINT_OK
962 || *k_units == 0 || *n_units < *k_units))
963 error (EXIT_FAILURE, 0, _("%s: invalid chunk number"), optarg);
968 main (int argc, char **argv)
970 struct stat stat_buf;
971 enum Split_type split_type = type_undef;
972 size_t in_blk_size = 0; /* optimal block size of input file device */
973 char *buf; /* file i/o buffer */
974 size_t page_size = getpagesize ();
975 uintmax_t k_units = 0;
978 static char const multipliers[] = "bEGKkMmPTYZ0";
980 int digits_optind = 0;
983 initialize_main (&argc, &argv);
984 set_program_name (argv[0]);
985 setlocale (LC_ALL, "");
986 bindtextdomain (PACKAGE, LOCALEDIR);
987 textdomain (PACKAGE);
989 atexit (close_stdout);
991 /* Parse command line options. */
993 infile = bad_cast ("-");
994 outbase = bad_cast ("x");
998 /* This is the argv-index of the option we will read next. */
999 int this_optind = optind ? optind : 1;
1002 c = getopt_long (argc, argv, "0123456789C:a:b:del:n:u",
1012 if (xstrtoul (optarg, NULL, 10, &tmp, "") != LONGINT_OK
1013 || SIZE_MAX / sizeof (size_t) < tmp)
1015 error (0, 0, _("%s: invalid suffix length"), optarg);
1016 usage (EXIT_FAILURE);
1018 suffix_length = tmp;
1023 if (split_type != type_undef)
1024 FAIL_ONLY_ONE_WAY ();
1025 split_type = type_bytes;
1026 if (xstrtoumax (optarg, NULL, 10, &n_units, multipliers) != LONGINT_OK
1029 error (0, 0, _("%s: invalid number of bytes"), optarg);
1030 usage (EXIT_FAILURE);
1032 /* If input is a pipe, we could get more data than is possible
1033 to write to a single file, so indicate that immediately
1034 rather than having possibly future invocations fail. */
1035 if (OFF_T_MAX < n_units)
1036 error (EXIT_FAILURE, EFBIG,
1037 _("%s: invalid number of bytes"), optarg);
1042 if (split_type != type_undef)
1043 FAIL_ONLY_ONE_WAY ();
1044 split_type = type_lines;
1045 if (xstrtoumax (optarg, NULL, 10, &n_units, "") != LONGINT_OK
1048 error (0, 0, _("%s: invalid number of lines"), optarg);
1049 usage (EXIT_FAILURE);
1054 if (split_type != type_undef)
1055 FAIL_ONLY_ONE_WAY ();
1056 split_type = type_byteslines;
1057 if (xstrtoumax (optarg, NULL, 10, &n_units, multipliers) != LONGINT_OK
1058 || n_units == 0 || SIZE_MAX < n_units)
1060 error (0, 0, _("%s: invalid number of bytes"), optarg);
1061 usage (EXIT_FAILURE);
1063 if (OFF_T_MAX < n_units)
1064 error (EXIT_FAILURE, EFBIG,
1065 _("%s: invalid number of bytes"), optarg);
1069 if (split_type != type_undef)
1070 FAIL_ONLY_ONE_WAY ();
1071 /* skip any whitespace */
1072 while (isspace (to_uchar (*optarg)))
1074 if (STRNCMP_LIT (optarg, "r/") == 0)
1076 split_type = type_rr;
1079 else if (STRNCMP_LIT (optarg, "l/") == 0)
1081 split_type = type_chunk_lines;
1085 split_type = type_chunk_bytes;
1086 if ((slash = strchr (optarg, '/')))
1087 parse_chunk (&k_units, &n_units, slash);
1088 else if (xstrtoumax (optarg, NULL, 10, &n_units, "") != LONGINT_OK
1090 error (EXIT_FAILURE, 0, _("%s: invalid number of chunks"), optarg);
1107 if (split_type == type_undef)
1109 split_type = type_digits;
1112 if (split_type != type_undef && split_type != type_digits)
1113 FAIL_ONLY_ONE_WAY ();
1114 if (digits_optind != 0 && digits_optind != this_optind)
1115 n_units = 0; /* More than one number given; ignore other. */
1116 digits_optind = this_optind;
1117 if (!DECIMAL_DIGIT_ACCUMULATE (n_units, c - '0', uintmax_t))
1119 char buffer[INT_BUFSIZE_BOUND (uintmax_t)];
1120 error (EXIT_FAILURE, 0,
1121 _("line count option -%s%c... is too large"),
1122 umaxtostr (n_units, buffer), c);
1127 suffix_alphabet = "0123456789";
1131 elide_empty_files = true;
1135 filter_command = optarg;
1138 case IO_BLKSIZE_OPTION:
1140 uintmax_t tmp_blk_size;
1141 if (xstrtoumax (optarg, NULL, 10, &tmp_blk_size,
1142 multipliers) != LONGINT_OK
1143 || tmp_blk_size == 0 || SIZE_MAX - page_size < tmp_blk_size)
1144 error (0, 0, _("%s: invalid IO block size"), optarg);
1146 in_blk_size = tmp_blk_size;
1150 case VERBOSE_OPTION:
1154 case_GETOPT_HELP_CHAR;
1156 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1159 usage (EXIT_FAILURE);
1163 /* Handle default case. */
1164 if (split_type == type_undef)
1166 split_type = type_lines;
1172 error (0, 0, _("%s: invalid number of lines"), "0");
1173 usage (EXIT_FAILURE);
1176 set_suffix_length (n_units, split_type);
1178 /* Get out the filename arguments. */
1181 infile = argv[optind++];
1184 outbase = argv[optind++];
1188 error (0, 0, _("extra operand %s"), quote (argv[optind]));
1189 usage (EXIT_FAILURE);
1192 /* Open the input file. */
1193 if (! STREQ (infile, "-")
1194 && fd_reopen (STDIN_FILENO, infile, O_RDONLY, 0) < 0)
1195 error (EXIT_FAILURE, errno, _("cannot open %s for reading"),
1198 /* Binary I/O is safer when byte counts are used. */
1199 if (O_BINARY && ! isatty (STDIN_FILENO))
1200 xfreopen (NULL, "rb", stdin);
1202 /* Get the optimal block size of input device and make a buffer. */
1204 if (fstat (STDIN_FILENO, &stat_buf) != 0)
1205 error (EXIT_FAILURE, errno, "%s", infile);
1206 if (in_blk_size == 0)
1207 in_blk_size = io_blksize (stat_buf);
1208 file_size = stat_buf.st_size;
1210 if (split_type == type_chunk_bytes || split_type == type_chunk_lines)
1212 off_t input_offset = lseek (STDIN_FILENO, 0, SEEK_CUR);
1213 if (input_offset < 0)
1214 error (EXIT_FAILURE, 0, _("%s: cannot determine file size"),
1216 file_size -= input_offset;
1217 /* Overflow, and sanity checking. */
1218 if (OFF_T_MAX < n_units)
1220 char buffer[INT_BUFSIZE_BOUND (uintmax_t)];
1221 error (EXIT_FAILURE, EFBIG, _("%s: invalid number of chunks"),
1222 umaxtostr (n_units, buffer));
1224 /* increase file_size to n_units here, so that we still process
1225 any input data, and create empty files for the rest. */
1226 file_size = MAX (file_size, n_units);
1229 buf = ptr_align (xmalloc (in_blk_size + 1 + page_size - 1), page_size);
1231 /* When filtering, closure of one pipe must not terminate the process,
1232 as there may still be other streams expecting input from us. */
1235 struct sigaction act;
1236 sigemptyset (&newblocked);
1237 sigaction (SIGPIPE, NULL, &act);
1238 if (act.sa_handler != SIG_IGN)
1239 sigaddset (&newblocked, SIGPIPE);
1240 sigprocmask (SIG_BLOCK, &newblocked, &oldblocked);
1247 lines_split (n_units, buf, in_blk_size);
1251 bytes_split (n_units, buf, in_blk_size, 0);
1254 case type_byteslines:
1255 line_bytes_split (n_units);
1258 case type_chunk_bytes:
1260 bytes_split (file_size / n_units, buf, in_blk_size, n_units);
1262 bytes_chunk_extract (k_units, n_units, buf, in_blk_size, file_size);
1265 case type_chunk_lines:
1266 lines_chunk_split (k_units, n_units, buf, in_blk_size, file_size);
1270 /* Note, this is like `sed -n ${k}~${n}p` when k > 0,
1271 but the functionality is provided for symmetry. */
1272 lines_rr (k_units, n_units, buf, in_blk_size);
1279 if (close (STDIN_FILENO) != 0)
1280 error (EXIT_FAILURE, errno, "%s", infile);
1281 closeout (NULL, output_desc, filter_pid, outfile);
1283 exit (EXIT_SUCCESS);