logo

utils-std

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

split.c (7034B)

    

  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 "../lib/fs.h" // auto_file_copy
  8. #include "../lib/getopt_nolong.h"
  9. #include "../lib/truncation.h" // apply_size_suffix
  11. #include <errno.h>
  12. #include <fcntl.h>    // open
  13. #include <limits.h>   // NAME_MAX
  14. #include <stdio.h>    // fprintf
  15. #include <stdlib.h>   // strtoul
  16. #include <string.h>   // strerror
  17. #include <sys/stat.h> // fstat
  18. #include <unistd.h>   // getopt
  20. const char *argv0 = "split";
  22. const char *name = "x";
  23. size_t name_len = 1;
  25. size_t suffix_len = 2, bytes = 0, lines = 0;
  26. char *name_in = NULL;
  28. static int
  29. base26(int id, char *str)
  30. {
  31. 	memcpy(str, name, name_len);
  32. 	memset(str + name_len, 'a', suffix_len);
  34. 	size_t id_p = name_len + suffix_len;
  35. 	do
  36. 	{
  37. 		str[id_p--] = 'a' + (id % 26);
  38. 		id /= 26;
  39. 	} while(id > 0 && id_p > name_len);
  41. 	if(id_p <= name_len)
  42. 	{
  43. 		fprintf(stderr,
  44. 		        "%s: error: Failed representing %d into suffix of length %zu\n",
  45. 		        argv0,
  46. 		        id,
  47. 		        suffix_len);
  48. 		return -1;
  49. 	}
  51. 	return 0;
  52. }
  54. static int
  55. split_bytes(void)
  56. {
  57. 	int fd_in = STDIN_FILENO;
  58. 	if(name_in != NULL)
  59. 	{
  60. 		fd_in = open(name_in, O_RDONLY | O_NOCTTY);
  61. 		if(fd_in < 0)
  62. 		{
  63. 			fprintf(stderr, "%s: error: Failed opening '%s' file: %s\n", argv0, name_in, strerror(errno));
  64. 			return 1;
  65. 		}
  66. 	}
  68. 	struct stat fd_in_stat;
  69. 	if(fstat(fd_in, &fd_in_stat) != 0)
  70. 	{
  71. 		fprintf(stderr,
  72. 		        "%s: error: Failed getting status from file '%s': %s",
  73. 		        argv0,
  74. 		        name_in,
  75. 		        strerror(errno));
  76. 		close(fd_in);
  77. 		return 1;
  78. 	}
  80. 	posix_fadvise(fd_in, 0, 0, POSIX_FADV_SEQUENTIAL);
  81. 	errno = 0;
  83. 	int err = 0;
  84. 	off_t wrote = 0;
  85. 	int split_id = 0;
  86. 	while(wrote < fd_in_stat.st_size)
  87. 	{
  88. 		char name_out[NAME_MAX] = "";
  89. 		if(base26(split_id++, name_out) < 0) return 1;
  91. 		int fd_out = open(name_out, O_WRONLY | O_NOCTTY | O_CREAT, 0644);
  92. 		if(fd_out < 0)
  93. 		{
  94. 			fprintf(
  95. 			    stderr, "%s: error: Failed opening '%s' file: %s\n", argv0, name_out, strerror(errno));
  96. 			err = 1;
  97. 			break;
  98. 		}
  100. 		posix_fadvise(fd_out, 0, 0, POSIX_FADV_SEQUENTIAL);
  101. 		errno = 0;
  103. 		int ret = auto_file_copy(fd_in, fd_out, bytes, 0);
  104. 		if(ret < 0)
  105. 		{
  106. 			fprintf(stderr,
  107. 			        "%s: error: Failed copying from file '%s' to file '%s': %s\n",
  108. 			        argv0,
  109. 			        name_in ? name_in : "<stdin>",
  110. 			        name_out,
  111. 			        strerror(errno));
  112. 			close(fd_out);
  113. 			err = 1;
  114. 			break;
  115. 		}
  117. 		wrote += ret;
  119. 		if(close(fd_out) < 0)
  120. 		{
  121. 			fprintf(
  122. 			    stderr, "%s: error: Failed closing file '%s': %s\n", argv0, name_out, strerror(errno));
  123. 			err = 1;
  124. 			break;
  125. 		}
  126. 	}
  128. 	if(name_in != NULL) close(fd_in);
  130. 	return err;
  131. }
  133. static int
  134. split_lines(void)
  135. {
  136. 	FILE *in = stdin;
  137. 	if(name_in != NULL)
  138. 	{
  139. 		in = fopen(name_in, "r");
  140. 		if(in == NULL)
  141. 		{
  142. 			fprintf(stderr, "%s: error: Failed opening '%s' file: %s\n", argv0, name_in, strerror(errno));
  143. 			return 1;
  144. 		}
  145. 	}
  147. 	int err = 0;
  148. 	char *line = NULL;
  149. 	size_t line_len = 0;
  150. 	int split_id = 0;
  151. 	while(true)
  152. 	{
  153. 		if(feof(in)) break;
  154. 		if(ferror(in))
  155. 		{
  156. 			fprintf(stderr,
  157. 			        "%s: error: Failed reading line from file '%s': %s\n",
  158. 			        argv0,
  159. 			        name_in,
  160. 			        strerror(errno));
  161. 			err = 1;
  162. 			break;
  163. 		}
  165. 		char name_out[NAME_MAX] = "";
  166. 		if(base26(split_id++, name_out) < 0)
  167. 		{
  168. 			err = 1;
  169. 			break;
  170. 		}
  172. 		FILE *out = NULL;
  173. 		for(size_t i = 0; i < lines; i++)
  174. 		{
  175. 			ssize_t nread = getline(&line, &line_len, in);
  176. 			if(nread < 0)
  177. 			{
  178. 				if(errno != 0)
  179. 				{
  180. 					fprintf(stderr,
  181. 					        "%s: error: Failed reading line from file '%s': %s\n",
  182. 					        argv0,
  183. 					        name_in,
  184. 					        strerror(errno));
  185. 					err = 1;
  186. 				}
  187. 				break;
  188. 			}
  190. 			if(out == NULL)
  191. 			{
  192. 				out = fopen(name_out, "w");
  193. 				if(out == NULL)
  194. 				{
  195. 					fprintf(stderr,
  196. 					        "%s: error: Failed opening '%s' file: %s\n",
  197. 					        argv0,
  198. 					        name_out,
  199. 					        strerror(errno));
  200. 					err = 1;
  201. 					break;
  202. 				}
  203. 			}
  205. 			if(fwrite(line, nread, 1, out) == 0)
  206. 			{
  207. 				fprintf(stderr,
  208. 				        "%s: error: Failed writing line to file '%s': %s\n",
  209. 				        argv0,
  210. 				        name_out,
  211. 				        strerror(errno));
  212. 				err = 1;
  213. 				break;
  214. 			}
  215. 		}
  217. 		if(out != NULL)
  218. 		{
  219. 			if(fclose(out) < 0)
  220. 			{
  221. 				fprintf(
  222. 				    stderr, "%s: error: Failed closing file '%s': %s\n", argv0, name_out, strerror(errno));
  223. 				err = 1;
  224. 				break;
  225. 			}
  226. 		}
  228. 		if(err != 0) break;
  229. 	}
  231. 	if(line_len > 0) free(line);
  233. 	if(name_in != NULL) fclose(in);
  235. 	return err;
  236. }
  238. static const char *error_opt_b_l = "%s: error: Options -b and -l are mutually exclusive\n";
  240. int
  241. main(int argc, char *argv[])
  242. {
  243. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":a:b:l:")) != -1;)
  244. 	{
  245. 		char *endptr = NULL;
  247. 		switch(c)
  248. 		{
  249. 		case 'a':
  250. 			suffix_len = strtoul(optarg, &endptr, 0);
  251. 			if(suffix_len == 0)
  252. 			{
  253. 				fprintf(stderr, "%s: error: Failed parsing '-a %s': %s\n", argv0, optarg, strerror(errno));
  254. 				return 1;
  255. 			}
  256. 			if(endptr != NULL && *endptr != '\0')
  257. 			{
  258. 				fprintf(stderr,
  259. 				        "%s: error: Invalid trailing characters in '-a %s': %s\n",
  260. 				        argv0,
  261. 				        optarg,
  262. 				        endptr);
  263. 				return 1;
  264. 			}
  265. 			break;
  266. 		case 'b':
  267. 		{
  268. 			if(lines != 0)
  269. 			{
  270. 				fprintf(stderr, error_opt_b_l, argv0);
  271. 				return 1;
  272. 			}
  274. 			unsigned long opt_b = strtoul(optarg, &endptr, 0);
  275. 			if(opt_b == 0)
  276. 			{
  277. 				fprintf(stderr, "%s: error: Failed parsing '-b %s': %s\n", argv0, optarg, strerror(errno));
  278. 				return 1;
  279. 			}
  281. 			if(endptr != NULL && *endptr != 0)
  282. 				if(apply_size_suffix(&opt_b, endptr) != 0) return 1;
  284. 			bytes = opt_b;
  285. 			lines = 0;
  286. 			break;
  287. 		}
  288. 		case 'l':
  289. 			if(bytes != 0)
  290. 			{
  291. 				fprintf(stderr, error_opt_b_l, argv0);
  292. 				return 1;
  293. 			}
  295. 			lines = strtoul(optarg, &endptr, 0);
  296. 			if(lines == 0)
  297. 			{
  298. 				fprintf(stderr, "%s: error: Failed parsing '-l %s': %s\n", argv0, optarg, strerror(errno));
  299. 				return 1;
  300. 			}
  301. 			if(endptr != NULL && *endptr != '\0')
  302. 			{
  303. 				fprintf(stderr,
  304. 				        "%s: error: Invalid trailing characters in '-l %s': %s\n",
  305. 				        argv0,
  306. 				        optarg,
  307. 				        endptr);
  308. 				return 1;
  309. 			}
  310. 			break;
  311. 		case ':':
  312. 			fprintf(stderr, "%s: error: Option '-%c' requires an operand\n", argv0, optopt);
  313. 			return 1;
  314. 		default:
  315. 			fprintf(stderr, "%s: error: Unhandled option '-%c'\n", argv0, optopt);
  316. 			return 1;
  317. 		}
  318. 	}
  320. 	argc -= optind;
  321. 	argv += optind;
  323. 	if(lines == 0 && bytes == 0) lines = 1000;
  325. 	if(argc > 2 || argc < 0)
  326. 	{
  327. 		fprintf(stderr, "%s: error: Expected 0, 1, or 2 arguments, got %d\n", argv0, argc);
  328. 		return 1;
  329. 	}
  330. 	else if(argc >= 1)
  331. 	{
  332. 		name_in = argv[0];
  334. 		if(argc == 2) name = argv[1];
  335. 	}
  337. 	name_len = strlen(name);
  338. 	if(name_len + suffix_len > NAME_MAX)
  339. 	{
  340. 		fprintf(stderr,
  341. 		        "%s: error: name(%zd bytes) + suffix_length(%zd bytes) > NAME_MAX(%d bytes)\n",
  342. 		        argv0,
  343. 		        name_len,
  344. 		        suffix_len,
  345. 		        NAME_MAX);
  346. 		return 1;
  347. 	}
  349. 	if(bytes != 0) return split_bytes();
  351. 	return split_lines();
  352. }