logo

utils-std

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

split.c (7119B)

    

  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
  21. const char *argv0 = "split";
  23. const char *name = "x";
  24. size_t name_len = 1;
  26. size_t suffix_len = 2, bytes = 0, lines = 0;
  27. char *name_in = NULL;
  29. static int
  30. base26(int id, char *str)
  31. {
  32. 	memcpy(str, name, name_len);
  33. 	memset(str + name_len, 'a', suffix_len);
  35. 	size_t id_p = name_len + suffix_len;
  36. 	do
  37. 	{
  38. 		str[id_p--] = 'a' + (id % 26);
  39. 		id /= 26;
  40. 	} while(id > 0 && id_p > name_len);
  42. 	if(id_p <= name_len)
  43. 	{
  44. 		fprintf(stderr,
  45. 		        "%s: error: Failed representing %d into suffix of length %zu\n",
  46. 		        argv0,
  47. 		        id,
  48. 		        suffix_len);
  49. 		return -1;
  50. 	}
  52. 	return 0;
  53. }
  55. static int
  56. split_bytes(void)
  57. {
  58. 	int fd_in = STDIN_FILENO;
  59. 	if(name_in != NULL)
  60. 	{
  61. 		fd_in = open(name_in, O_RDONLY | O_NOCTTY);
  62. 		if(fd_in < 0)
  63. 		{
  64. 			fprintf(stderr, "%s: error: Failed opening '%s' file: %s\n", argv0, name_in, strerror(errno));
  65. 			return 1;
  66. 		}
  67. 	}
  69. 	struct stat fd_in_stat;
  70. 	if(fstat(fd_in, &fd_in_stat) != 0)
  71. 	{
  72. 		fprintf(stderr,
  73. 		        "%s: error: Failed getting status from file '%s': %s",
  74. 		        argv0,
  75. 		        name_in,
  76. 		        strerror(errno));
  77. 		close(fd_in);
  78. 		return 1;
  79. 	}
  81. 	posix_fadvise(fd_in, 0, 0, POSIX_FADV_SEQUENTIAL);
  82. 	errno = 0;
  84. 	int err = 0;
  85. 	off_t wrote = 0;
  86. 	int split_id = 0;
  87. 	while(wrote < fd_in_stat.st_size)
  88. 	{
  89. 		char name_out[NAME_MAX] = "";
  90. 		if(base26(split_id++, name_out) < 0) return 1;
  92. 		int fd_out = open(name_out, O_WRONLY | O_NOCTTY | O_CREAT, 0644);
  93. 		if(fd_out < 0)
  94. 		{
  95. 			fprintf(
  96. 			    stderr, "%s: error: Failed opening '%s' file: %s\n", argv0, name_out, strerror(errno));
  97. 			err = 1;
  98. 			break;
  99. 		}
  101. 		posix_fadvise(fd_out, 0, 0, POSIX_FADV_SEQUENTIAL);
  102. 		errno = 0;
  104. 		int ret = auto_file_copy(fd_in, fd_out, bytes, 0);
  105. 		if(ret < 0)
  106. 		{
  107. 			fprintf(stderr,
  108. 			        "%s: error: Failed copying from file '%s' to file '%s': %s\n",
  109. 			        argv0,
  110. 			        name_in ? name_in : "<stdin>",
  111. 			        name_out,
  112. 			        strerror(errno));
  113. 			close(fd_out);
  114. 			err = 1;
  115. 			break;
  116. 		}
  118. 		wrote += ret;
  120. 		if(close(fd_out) < 0)
  121. 		{
  122. 			fprintf(
  123. 			    stderr, "%s: error: Failed closing file '%s': %s\n", argv0, name_out, strerror(errno));
  124. 			err = 1;
  125. 			break;
  126. 		}
  127. 	}
  129. 	if(name_in != NULL) close(fd_in);
  131. 	return err;
  132. }
  134. static int
  135. split_lines(void)
  136. {
  137. 	FILE *in = stdin;
  138. 	if(name_in != NULL)
  139. 	{
  140. 		in = fopen(name_in, "r");
  141. 		if(in == NULL)
  142. 		{
  143. 			fprintf(stderr, "%s: error: Failed opening '%s' file: %s\n", argv0, name_in, strerror(errno));
  144. 			return 1;
  145. 		}
  146. 	}
  148. 	int err = 0;
  149. 	char *line = NULL;
  150. 	size_t line_len = 0;
  151. 	int split_id = 0;
  152. 	while(true)
  153. 	{
  154. 		if(feof(in)) break;
  155. 		if(ferror(in))
  156. 		{
  157. 			fprintf(stderr,
  158. 			        "%s: error: Failed reading line from file '%s': %s\n",
  159. 			        argv0,
  160. 			        name_in,
  161. 			        strerror(errno));
  162. 			err = 1;
  163. 			break;
  164. 		}
  166. 		char name_out[NAME_MAX] = "";
  167. 		if(base26(split_id++, name_out) < 0)
  168. 		{
  169. 			err = 1;
  170. 			break;
  171. 		}
  173. 		FILE *out = NULL;
  174. 		for(size_t i = 0; i < lines; i++)
  175. 		{
  176. 			ssize_t nread = getline(&line, &line_len, in);
  177. 			if(nread < 0)
  178. 			{
  179. 				if(errno != 0)
  180. 				{
  181. 					fprintf(stderr,
  182. 					        "%s: error: Failed reading line from file '%s': %s\n",
  183. 					        argv0,
  184. 					        name_in,
  185. 					        strerror(errno));
  186. 					err = 1;
  187. 				}
  188. 				break;
  189. 			}
  191. 			if(out == NULL)
  192. 			{
  193. 				out = fopen(name_out, "w");
  194. 				if(out == NULL)
  195. 				{
  196. 					fprintf(stderr,
  197. 					        "%s: error: Failed opening '%s' file: %s\n",
  198. 					        argv0,
  199. 					        name_out,
  200. 					        strerror(errno));
  201. 					err = 1;
  202. 					break;
  203. 				}
  204. 			}
  206. 			if(fwrite(line, nread, 1, out) == 0)
  207. 			{
  208. 				fprintf(stderr,
  209. 				        "%s: error: Failed writing line to file '%s': %s\n",
  210. 				        argv0,
  211. 				        name_out,
  212. 				        strerror(errno));
  213. 				err = 1;
  214. 				break;
  215. 			}
  216. 		}
  218. 		if(out != NULL)
  219. 		{
  220. 			if(fclose(out) < 0)
  221. 			{
  222. 				fprintf(
  223. 				    stderr, "%s: error: Failed closing file '%s': %s\n", argv0, name_out, strerror(errno));
  224. 				err = 1;
  225. 				break;
  226. 			}
  227. 		}
  229. 		if(err != 0) break;
  230. 	}
  232. 	if(line_len > 0) free(line);
  234. 	if(name_in != NULL) fclose(in);
  236. 	return err;
  237. }
  239. static const char *error_opt_b_l = "%s: error: Options -b and -l are mutually exclusive\n";
  241. int
  242. main(int argc, char *argv[])
  243. {
  244. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":a:b:l:")) != -1;)
  245. 	{
  246. 		char *endptr = NULL;
  248. 		switch(c)
  249. 		{
  250. 		case 'a':
  251. 			suffix_len = strtoul(optarg, &endptr, 0);
  252. 			if(suffix_len == 0)
  253. 			{
  254. 				fprintf(stderr, "%s: error: Failed parsing '-a %s': %s\n", argv0, optarg, strerror(errno));
  255. 				return 1;
  256. 			}
  257. 			if(endptr != NULL && *endptr != '\0')
  258. 			{
  259. 				fprintf(stderr,
  260. 				        "%s: error: Invalid trailing characters in '-a %s': %s\n",
  261. 				        argv0,
  262. 				        optarg,
  263. 				        endptr);
  264. 				return 1;
  265. 			}
  266. 			break;
  267. 		case 'b':
  268. 		{
  269. 			if(lines != 0)
  270. 			{
  271. 				fprintf(stderr, error_opt_b_l, argv0);
  272. 				return 1;
  273. 			}
  275. 			unsigned long opt_b = strtoul(optarg, &endptr, 0);
  276. 			if(opt_b == 0)
  277. 			{
  278. 				fprintf(stderr, "%s: error: Failed parsing '-b %s': %s\n", argv0, optarg, strerror(errno));
  279. 				return 1;
  280. 			}
  282. 			if(endptr != NULL && *endptr != 0)
  283. 				if(apply_size_suffix(&opt_b, endptr) != 0) return 1;
  285. 			bytes = opt_b;
  286. 			lines = 0;
  287. 			break;
  288. 		}
  289. 		case 'l':
  290. 			if(bytes != 0)
  291. 			{
  292. 				fprintf(stderr, error_opt_b_l, argv0);
  293. 				return 1;
  294. 			}
  296. 			lines = strtoul(optarg, &endptr, 0);
  297. 			if(lines == 0)
  298. 			{
  299. 				fprintf(stderr, "%s: error: Failed parsing '-l %s': %s\n", argv0, optarg, strerror(errno));
  300. 				return 1;
  301. 			}
  302. 			if(endptr != NULL && *endptr != '\0')
  303. 			{
  304. 				fprintf(stderr,
  305. 				        "%s: error: Invalid trailing characters in '-l %s': %s\n",
  306. 				        argv0,
  307. 				        optarg,
  308. 				        endptr);
  309. 				return 1;
  310. 			}
  311. 			break;
  312. 		case ':':
  313. 			fprintf(stderr, "%s: error: Option '-%c' requires an operand\n", argv0, optopt);
  314. 			return 1;
  315. 		default:
  316. 			fprintf(stderr, "%s: error: Unhandled option '-%c'\n", argv0, optopt);
  317. 			return 1;
  318. 		}
  319. 	}
  321. 	argc -= optind;
  322. 	argv += optind;
  324. 	if(lines == 0 && bytes == 0) lines = 1000;
  326. 	if(argc > 2 || argc < 0)
  327. 	{
  328. 		fprintf(stderr, "%s: error: Expected 0, 1, or 2 arguments, got %d\n", argv0, argc);
  329. 		return 1;
  330. 	}
  331. 	else if(argc >= 1)
  332. 	{
  333. 		if(!(argv[0][0] == '-' && argv[0][1] == '\0')) name_in = argv[0];
  335. 		if(argc == 2) name = argv[1];
  336. 	}
  338. 	name_len = strlen(name);
  339. 	if(name_len + suffix_len > NAME_MAX)
  340. 	{
  341. 		fprintf(stderr,
  342. 		        "%s: error: name(%zd bytes) + suffix_length(%zd bytes) > NAME_MAX(%d bytes)\n",
  343. 		        argv0,
  344. 		        name_len,
  345. 		        suffix_len,
  346. 		        NAME_MAX);
  347. 		return 1;
  348. 	}
  350. 	if(bytes != 0) return split_bytes();
  352. 	return split_lines();
  353. }