logo

utils-std

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

split.c (6901B)

    

  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. 	int err = 0;
  81. 	off_t wrote = 0;
  82. 	int split_id = 0;
  83. 	while(wrote < fd_in_stat.st_size)
  84. 	{
  85. 		char name_out[NAME_MAX] = "";
  86. 		if(base26(split_id++, name_out) < 0) return 1;
  88. 		int fd_out = open(name_out, O_WRONLY | O_NOCTTY | O_CREAT, 0644);
  89. 		if(fd_out < 0)
  90. 		{
  91. 			fprintf(
  92. 			    stderr, "%s: error: Failed opening '%s' file: %s\n", argv0, name_out, strerror(errno));
  93. 			err = 1;
  94. 			break;
  95. 		}
  97. 		int ret = auto_file_copy(fd_in, fd_out, bytes, 0);
  98. 		if(ret < 0)
  99. 		{
  100. 			fprintf(stderr,
  101. 			        "%s: error: Failed copying from file '%s' to file '%s': %s\n",
  102. 			        argv0,
  103. 			        name_in ? name_in : "<stdin>",
  104. 			        name_out,
  105. 			        strerror(errno));
  106. 			close(fd_out);
  107. 			err = 1;
  108. 			break;
  109. 		}
  111. 		wrote += ret;
  113. 		if(close(fd_out) < 0)
  114. 		{
  115. 			fprintf(
  116. 			    stderr, "%s: error: Failed closing file '%s': %s\n", argv0, name_out, strerror(errno));
  117. 			err = 1;
  118. 			break;
  119. 		}
  120. 	}
  122. 	if(name_in != NULL) close(fd_in);
  124. 	return err;
  125. }
  127. static int
  128. split_lines(void)
  129. {
  130. 	FILE *in = stdin;
  131. 	if(name_in != NULL)
  132. 	{
  133. 		in = fopen(name_in, "r");
  134. 		if(in == NULL)
  135. 		{
  136. 			fprintf(stderr, "%s: error: Failed opening '%s' file: %s\n", argv0, name_in, strerror(errno));
  137. 			return 1;
  138. 		}
  139. 	}
  141. 	int err = 0;
  142. 	char *line = NULL;
  143. 	size_t line_len = 0;
  144. 	int split_id = 0;
  145. 	while(true)
  146. 	{
  147. 		if(feof(in)) break;
  148. 		if(ferror(in))
  149. 		{
  150. 			fprintf(stderr,
  151. 			        "%s: error: Failed reading line from file '%s': %s\n",
  152. 			        argv0,
  153. 			        name_in,
  154. 			        strerror(errno));
  155. 			err = 1;
  156. 			break;
  157. 		}
  159. 		char name_out[NAME_MAX] = "";
  160. 		if(base26(split_id++, name_out) < 0)
  161. 		{
  162. 			err = 1;
  163. 			break;
  164. 		}
  166. 		FILE *out = NULL;
  167. 		for(size_t i = 0; i < lines; i++)
  168. 		{
  169. 			ssize_t nread = getline(&line, &line_len, in);
  170. 			if(nread < 0)
  171. 			{
  172. 				if(errno != 0)
  173. 				{
  174. 					fprintf(stderr,
  175. 					        "%s: error: Failed reading line from file '%s': %s\n",
  176. 					        argv0,
  177. 					        name_in,
  178. 					        strerror(errno));
  179. 					err = 1;
  180. 				}
  181. 				break;
  182. 			}
  184. 			if(out == NULL)
  185. 			{
  186. 				out = fopen(name_out, "w");
  187. 				if(out == NULL)
  188. 				{
  189. 					fprintf(stderr,
  190. 					        "%s: error: Failed opening '%s' file: %s\n",
  191. 					        argv0,
  192. 					        name_out,
  193. 					        strerror(errno));
  194. 					err = 1;
  195. 					break;
  196. 				}
  197. 			}
  199. 			if(fwrite(line, nread, 1, out) == 0)
  200. 			{
  201. 				fprintf(stderr,
  202. 				        "%s: error: Failed writing line to file '%s': %s\n",
  203. 				        argv0,
  204. 				        name_out,
  205. 				        strerror(errno));
  206. 				err = 1;
  207. 				break;
  208. 			}
  209. 		}
  211. 		if(out != NULL)
  212. 		{
  213. 			if(fclose(out) < 0)
  214. 			{
  215. 				fprintf(
  216. 				    stderr, "%s: error: Failed closing file '%s': %s\n", argv0, name_out, strerror(errno));
  217. 				err = 1;
  218. 				break;
  219. 			}
  220. 		}
  222. 		if(err != 0) break;
  223. 	}
  225. 	if(line_len > 0) free(line);
  227. 	if(name_in != NULL) fclose(in);
  229. 	return err;
  230. }
  232. static const char *error_opt_b_l = "%s: error: Options -b and -l are mutually exclusive\n";
  234. int
  235. main(int argc, char *argv[])
  236. {
  237. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":a:b:l:")) != -1;)
  238. 	{
  239. 		char *endptr = NULL;
  241. 		switch(c)
  242. 		{
  243. 		case 'a':
  244. 			suffix_len = strtoul(optarg, &endptr, 0);
  245. 			if(suffix_len == 0)
  246. 			{
  247. 				fprintf(stderr, "%s: error: Failed parsing '-a %s': %s\n", argv0, optarg, strerror(errno));
  248. 				return 1;
  249. 			}
  250. 			if(endptr != NULL && *endptr != '\0')
  251. 			{
  252. 				fprintf(stderr,
  253. 				        "%s: error: Invalid trailing characters in '-a %s': %s\n",
  254. 				        argv0,
  255. 				        optarg,
  256. 				        endptr);
  257. 				return 1;
  258. 			}
  259. 			break;
  260. 		case 'b':
  261. 		{
  262. 			if(lines != 0)
  263. 			{
  264. 				fprintf(stderr, error_opt_b_l, argv0);
  265. 				return 1;
  266. 			}
  268. 			unsigned long opt_b = strtoul(optarg, &endptr, 0);
  269. 			if(opt_b == 0)
  270. 			{
  271. 				fprintf(stderr, "%s: error: Failed parsing '-b %s': %s\n", argv0, optarg, strerror(errno));
  272. 				return 1;
  273. 			}
  275. 			if(endptr != NULL && *endptr != 0)
  276. 				if(apply_size_suffix(&opt_b, endptr) != 0) return 1;
  278. 			bytes = opt_b;
  279. 			lines = 0;
  280. 			break;
  281. 		}
  282. 		case 'l':
  283. 			if(bytes != 0)
  284. 			{
  285. 				fprintf(stderr, error_opt_b_l, argv0);
  286. 				return 1;
  287. 			}
  289. 			lines = strtoul(optarg, &endptr, 0);
  290. 			if(lines == 0)
  291. 			{
  292. 				fprintf(stderr, "%s: error: Failed parsing '-l %s': %s\n", argv0, optarg, strerror(errno));
  293. 				return 1;
  294. 			}
  295. 			if(endptr != NULL && *endptr != '\0')
  296. 			{
  297. 				fprintf(stderr,
  298. 				        "%s: error: Invalid trailing characters in '-l %s': %s\n",
  299. 				        argv0,
  300. 				        optarg,
  301. 				        endptr);
  302. 				return 1;
  303. 			}
  304. 			break;
  305. 		case ':':
  306. 			fprintf(stderr, "%s: error: Option '-%c' requires an operand\n", argv0, optopt);
  307. 			return 1;
  308. 		default:
  309. 			fprintf(stderr, "%s: error: Unhandled option '-%c'\n", argv0, optopt);
  310. 			return 1;
  311. 		}
  312. 	}
  314. 	argc -= optind;
  315. 	argv += optind;
  317. 	if(lines == 0 && bytes == 0) lines = 1000;
  319. 	if(argc > 2 || argc < 0)
  320. 	{
  321. 		fprintf(stderr, "%s: error: Expected 0, 1, or 2 arguments, got %d\n", argv0, argc);
  322. 		return 1;
  323. 	}
  324. 	else if(argc >= 1)
  325. 	{
  326. 		name_in = argv[0];
  328. 		if(argc == 2) name = argv[1];
  329. 	}
  331. 	name_len = strlen(name);
  332. 	if(name_len + suffix_len > NAME_MAX)
  333. 	{
  334. 		fprintf(stderr,
  335. 		        "%s: error: name(%zd bytes) + suffix_length(%zd bytes) > NAME_MAX(%d bytes)\n",
  336. 		        argv0,
  337. 		        name_len,
  338. 		        suffix_len,
  339. 		        NAME_MAX);
  340. 		return 1;
  341. 	}
  343. 	if(bytes != 0) return split_bytes();
  345. 	return split_lines();
  346. }