logo

utils-std

Collection of commonly available Unix tools git clone https://anongit.hacktivis.me/git/utils-std.git/

split.c (7643B)

    

  1. // utils-std: Collection of commonly available Unix tools
  2. // SPDX-FileCopyrightText: 2017 Haelwenn (lanodan) Monnier <contact+utils@hacktivis.me>
  3. // SPDX-License-Identifier: MPL-2.0
  5. #define _POSIX_C_SOURCE 200809L
  7. #include "../config.h"
  8. #include "../libutils/fs.h" // auto_file_copy
  9. #include "../libutils/getopt_nolong.h"
  10. #include "../libutils/truncation.h" // apply_size_suffix
  12. #include <errno.h>
  13. #include <fcntl.h>    // open
  14. #include <limits.h>   // NAME_MAX
  15. #include <stdio.h>    // fprintf
  16. #include <stdlib.h>   // strtoul
  17. #include <string.h>   // strerror
  18. #include <sys/stat.h> // fstat
  19. #include <unistd.h>   // getopt
  20. #ifdef HAS_GETOPT_LONG
  21. #include <getopt.h>
  22. #endif
  24. const char *argv0 = "split";
  26. const char *name = "x";
  27. size_t name_len = 1;
  29. size_t suffix_len = 2, bytes = 0, lines = 0;
  30. char *name_in = NULL;
  32. static int
  33. base26(int id, char *str)
  34. {
  35. 	memcpy(str, name, name_len);
  36. 	memset(str + name_len, 'a', suffix_len);
  38. 	size_t id_p = name_len + suffix_len;
  39. 	do
  40. 	{
  41. 		str[id_p--] = 'a' + (id % 26);
  42. 		id /= 26;
  43. 	} while(id > 0 && id_p > name_len);
  45. 	if(id_p <= name_len)
  46. 	{
  47. 		fprintf(stderr,
  48. 		        "%s: error: Failed representing %d into suffix of length %zu\n",
  49. 		        argv0,
  50. 		        id,
  51. 		        suffix_len);
  52. 		return -1;
  53. 	}
  55. 	return 0;
  56. }
  58. static int
  59. split_bytes(void)
  60. {
  61. 	int fd_in = STDIN_FILENO;
  62. 	if(name_in != NULL)
  63. 	{
  64. 		fd_in = open(name_in, O_RDONLY | O_NOCTTY);
  65. 		if(fd_in < 0)
  66. 		{
  67. 			fprintf(stderr, "%s: error: Failed opening '%s' file: %s\n", argv0, name_in, strerror(errno));
  68. 			return 1;
  69. 		}
  70. 	}
  72. 	struct stat fd_in_stat;
  73. 	if(fstat(fd_in, &fd_in_stat) != 0)
  74. 	{
  75. 		fprintf(stderr,
  76. 		        "%s: error: Failed getting status from file '%s': %s",
  77. 		        argv0,
  78. 		        name_in,
  79. 		        strerror(errno));
  80. 		close(fd_in);
  81. 		return 1;
  82. 	}
  84. 	posix_fadvise(fd_in, 0, 0, POSIX_FADV_SEQUENTIAL);
  85. 	errno = 0;
  87. 	int err = 0;
  88. 	off_t wrote = 0;
  89. 	int split_id = 0;
  90. 	while(wrote < fd_in_stat.st_size)
  91. 	{
  92. 		char name_out[NAME_MAX] = "";
  93. 		if(base26(split_id++, name_out) < 0) return 1;
  95. 		int fd_out = open(name_out, O_WRONLY | O_NOCTTY | O_CREAT, 0644);
  96. 		if(fd_out < 0)
  97. 		{
  98. 			fprintf(
  99. 			    stderr, "%s: error: Failed opening '%s' file: %s\n", argv0, name_out, strerror(errno));
  100. 			err = 1;
  101. 			break;
  102. 		}
  104. 		posix_fadvise(fd_out, 0, 0, POSIX_FADV_SEQUENTIAL);
  105. 		errno = 0;
  107. 		int ret = auto_file_copy(fd_in, fd_out, bytes, 0);
  108. 		if(ret < 0)
  109. 		{
  110. 			fprintf(stderr,
  111. 			        "%s: error: Failed copying from file '%s' to file '%s': %s\n",
  112. 			        argv0,
  113. 			        name_in ? name_in : "<stdin>",
  114. 			        name_out,
  115. 			        strerror(errno));
  116. 			close(fd_out);
  117. 			err = 1;
  118. 			break;
  119. 		}
  121. 		wrote += ret;
  123. 		if(close(fd_out) < 0)
  124. 		{
  125. 			fprintf(
  126. 			    stderr, "%s: error: Failed closing file '%s': %s\n", argv0, name_out, strerror(errno));
  127. 			err = 1;
  128. 			break;
  129. 		}
  130. 	}
  132. 	if(name_in != NULL) close(fd_in);
  134. 	return err;
  135. }
  137. static int
  138. split_lines(void)
  139. {
  140. 	FILE *in = stdin;
  141. 	if(name_in != NULL)
  142. 	{
  143. 		in = fopen(name_in, "r");
  144. 		if(in == NULL)
  145. 		{
  146. 			fprintf(stderr, "%s: error: Failed opening '%s' file: %s\n", argv0, name_in, strerror(errno));
  147. 			return 1;
  148. 		}
  149. 	}
  151. 	int err = 0;
  152. 	char *line = NULL;
  153. 	size_t line_len = 0;
  154. 	int split_id = 0;
  155. 	while(true)
  156. 	{
  157. 		if(feof(in)) break;
  158. 		if(ferror(in))
  159. 		{
  160. 			fprintf(stderr,
  161. 			        "%s: error: Failed reading line from file '%s': %s\n",
  162. 			        argv0,
  163. 			        name_in,
  164. 			        strerror(errno));
  165. 			err = 1;
  166. 			break;
  167. 		}
  169. 		char name_out[NAME_MAX] = "";
  170. 		if(base26(split_id++, name_out) < 0)
  171. 		{
  172. 			err = 1;
  173. 			break;
  174. 		}
  176. 		FILE *out = NULL;
  177. 		for(size_t i = 0; i < lines; i++)
  178. 		{
  179. 			ssize_t nread = getline(&line, &line_len, in);
  180. 			if(nread < 0)
  181. 			{
  182. 				if(errno != 0)
  183. 				{
  184. 					fprintf(stderr,
  185. 					        "%s: error: Failed reading line from file '%s': %s\n",
  186. 					        argv0,
  187. 					        name_in,
  188. 					        strerror(errno));
  189. 					err = 1;
  190. 				}
  191. 				break;
  192. 			}
  194. 			if(out == NULL)
  195. 			{
  196. 				out = fopen(name_out, "w");
  197. 				if(out == NULL)
  198. 				{
  199. 					fprintf(stderr,
  200. 					        "%s: error: Failed opening '%s' file: %s\n",
  201. 					        argv0,
  202. 					        name_out,
  203. 					        strerror(errno));
  204. 					err = 1;
  205. 					break;
  206. 				}
  207. 			}
  209. 			if(fwrite(line, nread, 1, out) == 0)
  210. 			{
  211. 				fprintf(stderr,
  212. 				        "%s: error: Failed writing line to file '%s': %s\n",
  213. 				        argv0,
  214. 				        name_out,
  215. 				        strerror(errno));
  216. 				err = 1;
  217. 				break;
  218. 			}
  219. 		}
  221. 		if(out != NULL)
  222. 		{
  223. 			if(fclose(out) < 0)
  224. 			{
  225. 				fprintf(
  226. 				    stderr, "%s: error: Failed closing file '%s': %s\n", argv0, name_out, strerror(errno));
  227. 				err = 1;
  228. 				break;
  229. 			}
  230. 		}
  232. 		if(err != 0) break;
  233. 	}
  235. 	if(line_len > 0) free(line);
  237. 	if(name_in != NULL) fclose(in);
  239. 	return err;
  240. }
  242. static const char *error_opt_b_l = "%s: error: Options -b and -l are mutually exclusive\n";
  244. int
  245. main(int argc, char *argv[])
  246. {
  247. #ifdef HAS_GETOPT_LONG
  248. 	// Strictly for GNUisms compatibility so no long-only options
  249. 	// clang-format off
  250. 	static struct option opts[] = {
  251. 		{"suffix-length", required_argument, NULL, 'a'},
  252. 		{"bytes", required_argument, NULL, 'b'},
  253. 		{"lines", required_argument, NULL, 'l'},
  254. 		{0, 0, 0, 0},
  255. 	};
  256. 	// clang-format on
  258. 	// Need + as first character to get POSIX-style option parsing
  259. 	for(int c = -1; (c = getopt_long(argc, argv, "+:a:b:l:", opts, NULL)) != -1;)
  260. #else
  261. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":a:b:l:")) != -1;)
  262. #endif
  263. 	{
  264. 		char *endptr = NULL;
  266. 		switch(c)
  267. 		{
  268. 		case 'a':
  269. 			suffix_len = strtoul(optarg, &endptr, 0);
  270. 			if(suffix_len == 0)
  271. 			{
  272. 				fprintf(stderr, "%s: error: Failed parsing '-a %s': %s\n", argv0, optarg, strerror(errno));
  273. 				return 1;
  274. 			}
  275. 			if(endptr != NULL && *endptr != '\0')
  276. 			{
  277. 				fprintf(stderr,
  278. 				        "%s: error: Invalid trailing characters in '-a %s': %s\n",
  279. 				        argv0,
  280. 				        optarg,
  281. 				        endptr);
  282. 				return 1;
  283. 			}
  284. 			break;
  285. 		case 'b':
  286. 		{
  287. 			if(lines != 0)
  288. 			{
  289. 				fprintf(stderr, error_opt_b_l, argv0);
  290. 				return 1;
  291. 			}
  293. 			unsigned long opt_b = strtoul(optarg, &endptr, 0);
  294. 			if(opt_b == 0)
  295. 			{
  296. 				fprintf(stderr, "%s: error: Failed parsing '-b %s': %s\n", argv0, optarg, strerror(errno));
  297. 				return 1;
  298. 			}
  300. 			if(endptr != NULL && *endptr != 0)
  301. 				if(apply_size_suffix(&opt_b, endptr) != 0) return 1;
  303. 			bytes = opt_b;
  304. 			lines = 0;
  305. 			break;
  306. 		}
  307. 		case 'l':
  308. 			if(bytes != 0)
  309. 			{
  310. 				fprintf(stderr, error_opt_b_l, argv0);
  311. 				return 1;
  312. 			}
  314. 			lines = strtoul(optarg, &endptr, 0);
  315. 			if(lines == 0)
  316. 			{
  317. 				fprintf(stderr, "%s: error: Failed parsing '-l %s': %s\n", argv0, optarg, strerror(errno));
  318. 				return 1;
  319. 			}
  320. 			if(endptr != NULL && *endptr != '\0')
  321. 			{
  322. 				fprintf(stderr,
  323. 				        "%s: error: Invalid trailing characters in '-l %s': %s\n",
  324. 				        argv0,
  325. 				        optarg,
  326. 				        endptr);
  327. 				return 1;
  328. 			}
  329. 			break;
  330. 		case ':':
  331. 			fprintf(stderr, "%s: error: Option '-%c' requires an operand\n", argv0, optopt);
  332. 			return 1;
  333. 		default:
  334. 			fprintf(stderr, "%s: error: Unhandled option '-%c'\n", argv0, optopt);
  335. 			return 1;
  336. 		}
  337. 	}
  339. 	argc -= optind;
  340. 	argv += optind;
  342. 	if(lines == 0 && bytes == 0) lines = 1000;
  344. 	if(argc > 2 || argc < 0)
  345. 	{
  346. 		fprintf(stderr, "%s: error: Expected 0, 1, or 2 arguments, got %d\n", argv0, argc);
  347. 		return 1;
  348. 	}
  349. 	else if(argc >= 1)
  350. 	{
  351. 		if(!(argv[0][0] == '-' && argv[0][1] == '\0')) name_in = argv[0];
  353. 		if(argc == 2) name = argv[1];
  354. 	}
  356. 	name_len = strlen(name);
  357. 	if(name_len + suffix_len > NAME_MAX)
  358. 	{
  359. 		fprintf(stderr,
  360. 		        "%s: error: name(%zd bytes) + suffix_length(%zd bytes) > NAME_MAX(%d bytes)\n",
  361. 		        argv0,
  362. 		        name_len,
  363. 		        suffix_len,
  364. 		        NAME_MAX);
  365. 		return 1;
  366. 	}
  368. 	if(bytes != 0) return split_bytes();
  370. 	return split_lines();
  371. }