logo

utils-std

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

split.c (6869B)

    

  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/truncation.h" // apply_size_suffix
  10. #include <errno.h>
  11. #include <fcntl.h>    // open
  12. #include <limits.h>   // NAME_MAX
  13. #include <stdio.h>    // fprintf
  14. #include <stdlib.h>   // strtoul
  15. #include <string.h>   // strerror
  16. #include <sys/stat.h> // fstat
  17. #include <unistd.h>   // getopt
  19. const char *argv0 = "split";
  21. const char *name = "x";
  22. size_t name_len = 1;
  24. size_t suffix_len = 2, bytes = 0, lines = 0;
  25. char *name_in = NULL;
  27. static int
  28. base26(int id, char *str)
  29. {
  30. 	memcpy(str, name, name_len);
  31. 	memset(str + name_len, 'a', suffix_len);
  33. 	size_t id_p = name_len + suffix_len;
  34. 	do
  35. 	{
  36. 		str[id_p--] = 'a' + (id % 26);
  37. 		id /= 26;
  38. 	} while(id > 0 && id_p > name_len);
  40. 	if(id_p <= name_len)
  41. 	{
  42. 		fprintf(stderr,
  43. 		        "%s: error: Failed representing %d into suffix of length %zu\n",
  44. 		        argv0,
  45. 		        id,
  46. 		        suffix_len);
  47. 		return -1;
  48. 	}
  50. 	return 0;
  51. }
  53. static int
  54. split_bytes(void)
  55. {
  56. 	int fd_in = STDIN_FILENO;
  57. 	if(name_in != NULL)
  58. 	{
  59. 		fd_in = open(name_in, O_RDONLY | O_NOCTTY);
  60. 		if(fd_in < 0)
  61. 		{
  62. 			fprintf(stderr, "%s: error: Failed opening '%s' file: %s\n", argv0, name_in, strerror(errno));
  63. 			return 1;
  64. 		}
  65. 	}
  67. 	struct stat fd_in_stat;
  68. 	if(fstat(fd_in, &fd_in_stat) != 0)
  69. 	{
  70. 		fprintf(stderr,
  71. 		        "%s: error: Failed getting status from file '%s': %s",
  72. 		        argv0,
  73. 		        name_in,
  74. 		        strerror(errno));
  75. 		close(fd_in);
  76. 		return 1;
  77. 	}
  79. 	int err = 0;
  80. 	off_t wrote = 0;
  81. 	int split_id = 0;
  82. 	while(wrote < fd_in_stat.st_size)
  83. 	{
  84. 		char name_out[NAME_MAX] = "";
  85. 		if(base26(split_id++, name_out) < 0) return 1;
  87. 		int fd_out = open(name_out, O_WRONLY | O_NOCTTY | O_CREAT, 0644);
  88. 		if(fd_out < 0)
  89. 		{
  90. 			fprintf(
  91. 			    stderr, "%s: error: Failed opening '%s' file: %s\n", argv0, name_out, strerror(errno));
  92. 			err = 1;
  93. 			break;
  94. 		}
  96. 		int ret = auto_file_copy(fd_in, fd_out, bytes, 0);
  97. 		if(ret < 0)
  98. 		{
  99. 			fprintf(stderr,
  100. 			        "%s: error: Failed copying from file '%s' to file '%s': %s\n",
  101. 			        argv0,
  102. 			        name_in ? name_in : "<stdin>",
  103. 			        name_out,
  104. 			        strerror(errno));
  105. 			close(fd_out);
  106. 			err = 1;
  107. 			break;
  108. 		}
  110. 		wrote += ret;
  112. 		if(close(fd_out) < 0)
  113. 		{
  114. 			fprintf(
  115. 			    stderr, "%s: error: Failed closing file '%s': %s\n", argv0, name_out, strerror(errno));
  116. 			err = 1;
  117. 			break;
  118. 		}
  119. 	}
  121. 	if(name_in != NULL) close(fd_in);
  123. 	return err;
  124. }
  126. static int
  127. split_lines(void)
  128. {
  129. 	FILE *in = stdin;
  130. 	if(name_in != NULL)
  131. 	{
  132. 		in = fopen(name_in, "r");
  133. 		if(in == NULL)
  134. 		{
  135. 			fprintf(stderr, "%s: error: Failed opening '%s' file: %s\n", argv0, name_in, strerror(errno));
  136. 			return 1;
  137. 		}
  138. 	}
  140. 	int err = 0;
  141. 	char *line = NULL;
  142. 	size_t line_len = 0;
  143. 	int split_id = 0;
  144. 	while(true)
  145. 	{
  146. 		if(feof(in)) break;
  147. 		if(ferror(in))
  148. 		{
  149. 			fprintf(stderr,
  150. 			        "%s: error: Failed reading line from file '%s': %s\n",
  151. 			        argv0,
  152. 			        name_in,
  153. 			        strerror(errno));
  154. 			err = 1;
  155. 			break;
  156. 		}
  158. 		char name_out[NAME_MAX] = "";
  159. 		if(base26(split_id++, name_out) < 0)
  160. 		{
  161. 			err = 1;
  162. 			break;
  163. 		}
  165. 		FILE *out = NULL;
  166. 		for(size_t i = 0; i < lines; i++)
  167. 		{
  168. 			ssize_t nread = getline(&line, &line_len, in);
  169. 			if(nread < 0)
  170. 			{
  171. 				if(errno != 0)
  172. 				{
  173. 					fprintf(stderr,
  174. 					        "%s: error: Failed reading line from file '%s': %s\n",
  175. 					        argv0,
  176. 					        name_in,
  177. 					        strerror(errno));
  178. 					err = 1;
  179. 				}
  180. 				break;
  181. 			}
  183. 			if(out == NULL)
  184. 			{
  185. 				out = fopen(name_out, "w");
  186. 				if(out == NULL)
  187. 				{
  188. 					fprintf(stderr,
  189. 					        "%s: error: Failed opening '%s' file: %s\n",
  190. 					        argv0,
  191. 					        name_out,
  192. 					        strerror(errno));
  193. 					err = 1;
  194. 					break;
  195. 				}
  196. 			}
  198. 			if(fwrite(line, nread, 1, out) < 0)
  199. 			{
  200. 				fprintf(stderr,
  201. 				        "%s: error: Failed writing line to file '%s': %s\n",
  202. 				        argv0,
  203. 				        name_out,
  204. 				        strerror(errno));
  205. 				err = 1;
  206. 				break;
  207. 			}
  208. 		}
  210. 		if(out != NULL)
  211. 		{
  212. 			if(fclose(out) < 0)
  213. 			{
  214. 				fprintf(
  215. 				    stderr, "%s: error: Failed closing file '%s': %s\n", argv0, name_out, strerror(errno));
  216. 				err = 1;
  217. 				break;
  218. 			}
  219. 		}
  221. 		if(err != 0) break;
  222. 	}
  224. 	if(line_len > 0) free(line);
  226. 	if(name_in != NULL) fclose(in);
  228. 	return err;
  229. }
  231. static const char *error_opt_b_l = "%s: error: Options -b and -l are mutually exclusive\n";
  233. int
  234. main(int argc, char *argv[])
  235. {
  236. 	int c = -1;
  237. 	while((c = getopt(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. }