busybox/coreutils/split.c

/* vi: set sw=4 ts=4: */
/*
 * split - split a file into pieces
 * Copyright (c) 2007 Bernhard Reutner-Fischer
 *
 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
 */
/* BB_AUDIT: SUSv3 compliant
 * SUSv3 requirements:
 * http://www.opengroup.org/onlinepubs/009695399/utilities/split.html
 */
#include "libbb.h"

static const struct suffix_mult split_suffices[] = {
#if ENABLE_FEATURE_SPLIT_FANCY
	{ "b", 512 },
#endif
	{ "k", 1024 },
	{ "m", 1024*1024 },
#if ENABLE_FEATURE_SPLIT_FANCY
	{ "g", 1024*1024*1024 },
#endif
	{ "", 0 }
};

/* Increment the suffix part of the filename.
 * Returns NULL if we are out of filenames.
 */
static char *next_file(char *old, unsigned suffix_len)
{
	size_t end = strlen(old);
	unsigned i = 1;
	char *curr;

	do {
		curr = old + end - i;
		if (*curr < 'z') {
			*curr += 1;
			break;
		}
		i++;
		if (i > suffix_len) {
			return NULL;
		}
		*curr = 'a';
	} while (1);

	return old;
}

#define read_buffer bb_common_bufsiz1
enum { READ_BUFFER_SIZE = COMMON_BUFSIZE - 1 };

#define SPLIT_OPT_l (1<<0)
#define SPLIT_OPT_b (1<<1)
#define SPLIT_OPT_a (1<<2)

int split_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int split_main(int argc UNUSED_PARAM, char **argv)
{
	unsigned suffix_len = 2;
	char *pfx;
	char *count_p;
	const char *sfx;
	off_t cnt = 1000;
	off_t remaining = 0;
	unsigned opt;
	ssize_t bytes_read, to_write;
	char *src;

	opt_complementary = "?2:a+"; /* max 2 args; -a N */
	opt = getopt32(argv, "l:b:a:", &count_p, &count_p, &suffix_len);

	if (opt & SPLIT_OPT_l)
		cnt = XATOOFF(count_p);
	if (opt & SPLIT_OPT_b) // FIXME: also needs XATOOFF
		cnt = xatoull_sfx(count_p, split_suffices);
	sfx = "x";

	argv += optind;
	if (argv[0]) {
		int fd;
		if (argv[1])
			sfx = argv[1];
		fd = open_or_warn_stdin(argv[0]);
		if (fd == -1)
			return EXIT_FAILURE;
		xmove_fd(fd, STDIN_FILENO);
	} else {
		argv[0] = (char *) bb_msg_standard_input;
	}

	if (NAME_MAX < strlen(sfx) + suffix_len)
		bb_error_msg_and_die("suffix too long");

	{
		char *char_p = xzalloc(suffix_len + 1);
		memset(char_p, 'a', suffix_len);
		pfx = xasprintf("%s%s", sfx, char_p);
		if (ENABLE_FEATURE_CLEAN_UP)
			free(char_p);
	}

	while (1) {
		bytes_read = safe_read(STDIN_FILENO, read_buffer, READ_BUFFER_SIZE);
		if (!bytes_read)
			break;
		if (bytes_read < 0)
			bb_simple_perror_msg_and_die(argv[0]);
		src = read_buffer;
		do {
			if (!remaining) {
				if (!pfx)
					bb_error_msg_and_die("suffixes exhausted");
				xmove_fd(xopen(pfx, O_WRONLY | O_CREAT | O_TRUNC), 1);
				pfx = next_file(pfx, suffix_len);
				remaining = cnt;
			}

			if (opt & SPLIT_OPT_b) {
				/* split by bytes */
				to_write = (bytes_read < remaining) ? bytes_read : remaining;
				remaining -= to_write;
			} else {
				/* split by lines */
				/* can be sped up by using _memrchr_
				 * and writing many lines at once... */
				char *end = memchr(src, '\n', bytes_read);
				if (end) {
					--remaining;
					to_write = end - src + 1;
				} else {
					to_write = bytes_read;
				}
			}

			xwrite(STDOUT_FILENO, src, to_write);
			bytes_read -= to_write;
			src += to_write;
		} while (bytes_read);
	}
	return EXIT_SUCCESS;
}
1	niro	816	/* vi: set sw=4 ts=4: */
2			/*
3			* split - split a file into pieces
4			* Copyright (c) 2007 Bernhard Reutner-Fischer
5			*
6			* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
7			*/
8			/* BB_AUDIT: SUSv3 compliant
9			* SUSv3 requirements:
10			* http://www.opengroup.org/onlinepubs/009695399/utilities/split.html
11			*/
12			#include "libbb.h"
13
14			static const struct suffix_mult split_suffices[] = {
15			#if ENABLE_FEATURE_SPLIT_FANCY
16			{ "b", 512 },
17			#endif
18			{ "k", 1024 },
19			{ "m", 1024*1024 },
20			#if ENABLE_FEATURE_SPLIT_FANCY
21			{ "g", 102410241024 },
22			#endif
23	niro	984	{ "", 0 }
24	niro	816	};
25
26			/* Increment the suffix part of the filename.
27			* Returns NULL if we are out of filenames.
28			*/
29			static char next_file(char old, unsigned suffix_len)
30			{
31			size_t end = strlen(old);
32			unsigned i = 1;
33			char *curr;
34
35			do {
36			curr = old + end - i;
37			if (*curr < 'z') {
38			*curr += 1;
39			break;
40			}
41			i++;
42			if (i > suffix_len) {
43			return NULL;
44			}
45			*curr = 'a';
46			} while (1);
47
48			return old;
49			}
50
51			#define read_buffer bb_common_bufsiz1
52			enum { READ_BUFFER_SIZE = COMMON_BUFSIZE - 1 };
53
54			#define SPLIT_OPT_l (1<<0)
55			#define SPLIT_OPT_b (1<<1)
56			#define SPLIT_OPT_a (1<<2)
57
58			int split_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
59			int split_main(int argc UNUSED_PARAM, char **argv)
60			{
61			unsigned suffix_len = 2;
62			char *pfx;
63			char *count_p;
64			const char *sfx;
65			off_t cnt = 1000;
66			off_t remaining = 0;
67			unsigned opt;
68			ssize_t bytes_read, to_write;
69			char *src;
70
71			opt_complementary = "?2:a+"; /* max 2 args; -a N */
72			opt = getopt32(argv, "l:b:a:", &count_p, &count_p, &suffix_len);
73
74			if (opt & SPLIT_OPT_l)
75			cnt = XATOOFF(count_p);
76			if (opt & SPLIT_OPT_b) // FIXME: also needs XATOOFF
77			cnt = xatoull_sfx(count_p, split_suffices);
78			sfx = "x";
79
80			argv += optind;
81			if (argv[0]) {
82	niro	984	int fd;
83	niro	816	if (argv[1])
84			sfx = argv[1];
85	niro	984	fd = open_or_warn_stdin(argv[0]);
86			if (fd == -1)
87			return EXIT_FAILURE;
88			xmove_fd(fd, STDIN_FILENO);
89	niro	816	} else {
90			argv[0] = (char *) bb_msg_standard_input;
91			}
92
93			if (NAME_MAX < strlen(sfx) + suffix_len)
94			bb_error_msg_and_die("suffix too long");
95
96			{
97			char *char_p = xzalloc(suffix_len + 1);
98			memset(char_p, 'a', suffix_len);
99			pfx = xasprintf("%s%s", sfx, char_p);
100			if (ENABLE_FEATURE_CLEAN_UP)
101			free(char_p);
102			}
103
104			while (1) {
105			bytes_read = safe_read(STDIN_FILENO, read_buffer, READ_BUFFER_SIZE);
106			if (!bytes_read)
107			break;
108			if (bytes_read < 0)
109			bb_simple_perror_msg_and_die(argv[0]);
110			src = read_buffer;
111			do {
112			if (!remaining) {
113			if (!pfx)
114			bb_error_msg_and_die("suffixes exhausted");
115			xmove_fd(xopen(pfx, O_WRONLY \| O_CREAT \| O_TRUNC), 1);
116			pfx = next_file(pfx, suffix_len);
117			remaining = cnt;
118			}
119
120			if (opt & SPLIT_OPT_b) {
121			/* split by bytes */
122			to_write = (bytes_read < remaining) ? bytes_read : remaining;
123			remaining -= to_write;
124			} else {
125			/* split by lines */
126			/* can be sped up by using _memrchr_
127			* and writing many lines at once... */
128			char *end = memchr(src, '\n', bytes_read);
129			if (end) {
130			--remaining;
131			to_write = end - src + 1;
132			} else {
133			to_write = bytes_read;
134			}
135			}
136
137			xwrite(STDOUT_FILENO, src, to_write);
138			bytes_read -= to_write;
139			src += to_write;
140			} while (bytes_read);
141			}
142			return EXIT_SUCCESS;
143			}