logo

utils-std

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

head.c (7579B)

    

  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_fd_copy
  9. #include "../libutils/getopt_nolong.h"
  10. #include "../libutils/truncation.h" // apply_size_suffix
  12. #include <assert.h>
  13. #include <ctype.h> // isdigit
  14. #include <errno.h>
  15. #include <fcntl.h>  // open
  16. #include <stdio.h>  // fprintf, fopen, fread
  17. #include <stdlib.h> // strtoul
  18. #include <string.h> // strerror
  19. #include <unistd.h> // read
  20. #ifdef HAS_GETOPT_LONG
  21. #include <getopt.h>
  22. #endif
  24. static const char *header_fmt = "==> %s <==\n";
  26. const char *argv0 = "head";
  28. ssize_t lines = 10;
  29. size_t bytes = 0;
  31. char *buf = NULL;
  32. size_t buflen = 0;
  34. int delim = '\n';
  36. static int
  37. copy_bytes(const char *filename)
  38. {
  39. 	int fd = -1;
  40. 	if(filename[0] == '-' && filename[1] == 0)
  41. 	{
  42. 		fd = STDIN_FILENO;
  43. 	}
  44. 	else
  45. 	{
  46. 		fd = open(filename, O_RDONLY | O_CLOEXEC | O_NOCTTY);
  47. 		if(fd < 0)
  48. 		{
  49. 			fprintf(
  50. 			    stderr, "%s: error: Failed opening file '%s': %s\n", argv0, filename, strerror(errno));
  51. 			return 1;
  52. 		}
  54. 		posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL);
  55. 	}
  57. 	int err = 0;
  58. 	if(auto_fd_copy(fd, STDOUT_FILENO, bytes) < 0)
  59. 	{
  60. 		fprintf(stderr,
  61. 		        "%s: error: Failed copying data from '%s' to <stdout>: %s\n",
  62. 		        argv0,
  63. 		        filename,
  64. 		        strerror(errno));
  65. 		err = 1;
  66. 	}
  68. 	if(fd != STDIN_FILENO)
  69. 		if(close(fd) != 0)
  70. 		{
  71. 			fprintf(
  72. 			    stderr, "%s: error: Failed closing file '%s': %s\n", argv0, filename, strerror(errno));
  73. 			return 1;
  74. 		}
  76. 	return err;
  77. }
  79. static int
  80. copy_lines(const char *filename)
  81. {
  82. 	int err = 0;
  83. 	FILE *in = NULL;
  85. 	if(filename[0] == '-' && filename[1] == 0)
  86. 	{
  87. 		in = stdin;
  88. 	}
  89. 	else
  90. 	{
  91. 		in = fopen(filename, "r");
  92. 		if(in == NULL)
  93. 		{
  94. 			fprintf(
  95. 			    stderr, "%s: error: Failed opening file '%s': %s\n", argv0, filename, strerror(errno));
  96. 			return 1;
  97. 		}
  98. 		assert(in != stdin);
  99. 	}
  101. 	// Relative to EOF, GNU extension
  102. 	if(lines < 0)
  103. 	{
  104. 		struct strbuf
  105. 		{
  106. 			size_t len;
  107. 			size_t cap;
  108. 			char *buf;
  109. 		};
  110. 		size_t nlines = (size_t)-lines;
  111. 		size_t wini = 0;
  112. 		struct strbuf *win = calloc(nlines, sizeof(struct strbuf));
  113. 		if(!win)
  114. 		{
  115. 			fprintf(stderr, "%s: error: Failed allocating lines array: %s\n", argv0, strerror(errno));
  116. 			err = 1;
  117. 			goto copy_lines_end;
  118. 		}
  120. 		while(true)
  121. 		{
  122. 			ssize_t ret = getdelim(&buf, &buflen, delim, in);
  123. 			if(ret < 0)
  124. 			{
  125. 				if(errno == 0) break;
  127. 				fprintf(stderr,
  128. 				        "%s: error: Failed reading line from '%s': %s\n",
  129. 				        argv0,
  130. 				        filename,
  131. 				        strerror(errno));
  132. 				err = 1;
  133. 				break;
  134. 			}
  135. 			size_t nread = ret;
  137. 			if(win[wini].len)
  138. 			{
  139. 				if(write(STDOUT_FILENO, win[wini].buf, win[wini].len) < 0)
  140. 				{
  141. 					fprintf(stderr,
  142. 					        "%s: error: Failed writing line from '%s' to stdout: %s\n",
  143. 					        argv0,
  144. 					        filename,
  145. 					        strerror(errno));
  146. 					err = 1;
  147. 					break;
  148. 				}
  149. 			}
  151. 			if(nread == 0) continue;
  153. 			if(win[wini].cap < nread)
  154. 			{
  155. 				win[wini].buf = realloc(win[wini].buf, nread);
  156. 				if(!win[wini].buf)
  157. 				{
  158. 					fprintf(
  159. 					    stderr, "%s: error: Failed (re)allocating line buffer: %s\n", argv0, strerror(errno));
  160. 					err = 1;
  161. 					break;
  162. 				}
  163. 				win[wini].cap = nread;
  164. 			}
  166. 			win[wini].len = nread;
  167. 			memcpy(win[wini].buf, buf, nread);
  168. 			wini = (wini + 1) % nlines;
  169. 		}
  171. 		for(size_t i = 0; i < nlines; i++)
  172. 			free(win[i].buf);
  174. 		free(win);
  175. 	}
  176. 	else
  177. 	{
  178. 		size_t nlines = lines;
  179. 		for(size_t i = 0; i < nlines; i++)
  180. 		{
  181. 			ssize_t nread = getdelim(&buf, &buflen, delim, in);
  182. 			if(nread < 0)
  183. 			{
  184. 				if(errno == 0) break;
  186. 				fprintf(stderr,
  187. 				        "%s: error: Failed reading line from '%s': %s\n",
  188. 				        argv0,
  189. 				        filename,
  190. 				        strerror(errno));
  191. 				err = 1;
  192. 				break;
  193. 			}
  195. 			if(write(STDOUT_FILENO, buf, nread) < 0)
  196. 			{
  197. 				fprintf(stderr,
  198. 				        "%s: error: Failed writing line from '%s' to stdout: %s\n",
  199. 				        argv0,
  200. 				        filename,
  201. 				        strerror(errno));
  202. 				err = 1;
  203. 				break;
  204. 			}
  205. 		}
  206. 	}
  208. copy_lines_end:
  209. 	if(in != stdin)
  210. 		if(fclose(in) != 0)
  211. 		{
  212. 			fprintf(
  213. 			    stderr, "%s: error: Failed closing file '%s': %s\n", argv0, filename, strerror(errno));
  214. 			return 1;
  215. 		}
  217. 	return err;
  218. }
  220. static void
  221. usage(void)
  222. {
  223. 	fprintf(stderr, "Usage: head [-qvz] [-c size | -n num | -num] [file...]\n");
  224. }
  226. int
  227. main(int argc, char *argv[])
  228. {
  229. 	int (*copy_action)(const char *filename) = copy_lines;
  231. 	int print_header = 0;
  232. 	while(optind < argc)
  233. 	{
  234. 		/* Skip getopt(3) for parsing -num option due to how it works:
  235. 		 * - optstring = "12"; args="head -12" considered the same as -1 -2
  236. 		 * - optstring = "1:"; args="head -12" considered the same as -1 2
  237. 		 *
  238. 		 * And we need args="head -12" as "12"
  239. 		 */
  240. 		if(argv[optind] && argv[optind][0] == '-' && isdigit(argv[optind][1]))
  241. 		{
  242. 			char *arg = argv[optind] + 1;
  244. 			char *endptr = NULL;
  245. 			lines = strtol(arg, &endptr, 0);
  246. 			if(!(errno == 0 && endptr != NULL && *endptr == '\0'))
  247. 			{
  248. 				fprintf(stderr,
  249. 				        "%s: error: Failed parsing number for `-%s`: %s\n",
  250. 				        argv0,
  251. 				        arg,
  252. 				        strerror(errno));
  253. 				return 1;
  254. 			}
  256. 			optind++;
  257. 			continue;
  258. 		}
  260. #ifdef HAS_GETOPT_LONG
  261. 		// Strictly for GNUisms compatibility so no long-only options
  262. 		// clang-format off
  263. 		static struct option opts[] = {
  264. 			{"bytes", required_argument, NULL, 'c'},
  265. 			{"lines", optional_argument, NULL, 'n'},
  266. 			{"quiet", no_argument, NULL, 'q'},
  267. 			{"silent", no_argument, NULL, 'q'},
  268. 			{"zero-terminated", no_argument, NULL, 'z'},
  269. 			{0, 0, 0, 0},
  270. 		};
  271. 		// clang-format on
  273. 		// Need + as first character to get POSIX-style option parsing
  274. 		int c = getopt_long(argc, argv, "+:qvc:n:z", opts, NULL);
  275. #else
  276. 		int c = getopt_nolong(argc, argv, ":qvc:n:z");
  277. #endif
  278. 		if(c == -1) break;
  280. 		switch(c)
  281. 		{
  282. 		case 'q':
  283. 			print_header = -1;
  284. 			break;
  285. 		case 'v':
  286. 			print_header = 1;
  287. 			break;
  288. 		case 'c':
  289. 		{
  290. 			char *endptr = NULL;
  291. 			unsigned long size = strtoul(optarg, &endptr, 0);
  292. 			if(errno != 0)
  293. 			{
  294. 				fprintf(stderr,
  295. 				        "%s: error: Failed parsing number for `-n %s`: %s\n",
  296. 				        argv0,
  297. 				        optarg,
  298. 				        strerror(errno));
  299. 				return 1;
  300. 			}
  302. 			if(endptr != NULL && *endptr != 0)
  303. 				if(apply_size_suffix(&size, endptr) != 0) return 1;
  305. 			bytes = size;
  306. 			copy_action = &copy_bytes;
  307. 			break;
  308. 		}
  309. 		case 'n':
  310. 		{
  311. 			char *endptr = NULL;
  312. 			lines = strtol(optarg, &endptr, 0);
  313. 			if(!(errno == 0 && endptr != NULL && *endptr == '\0'))
  314. 			{
  315. 				fprintf(stderr,
  316. 				        "%s: error: Failed parsing number for `-n %s`: %s\n",
  317. 				        argv0,
  318. 				        optarg,
  319. 				        strerror(errno));
  320. 				return 1;
  321. 			}
  322. 			break;
  323. 		}
  324. 		case 'z':
  325. 			delim = '\0';
  326. 			break;
  327. 		case ':':
  328. 			fprintf(stderr, "%s: error: Missing operand for option: '-%c'\n", argv0, optopt);
  329. 			usage();
  330. 			return 1;
  331. 		case '?':
  332. 			GETOPT_UNKNOWN_OPT
  333. 			usage();
  334. 			return 1;
  335. 		default:
  336. 			abort();
  337. 		}
  338. 	}
  340. 	argc -= optind;
  341. 	argv += optind;
  343. 	if(argc <= 0)
  344. 	{
  345. 		const char *filename = "-";
  347. 		if(print_header == 1)
  348. 		{
  349. 			printf(header_fmt, filename);
  350. 			fflush(stdout);
  351. 		}
  353. 		int err = copy_action(filename);
  355. 		free(buf);
  357. 		return err;
  358. 	}
  360. 	if(print_header == 0) print_header = argc > 1;
  362. 	int err = 0;
  364. 	for(int i = 0; i < argc; i++)
  365. 	{
  366. 		char *filename = argv[i];
  368. 		if(print_header > 0)
  369. 		{
  370. 			printf(header_fmt, filename);
  371. 			header_fmt = "\n==> %s <==\n";
  372. 			fflush(stdout);
  373. 		}
  375. 		if(copy_action(filename) != 0)
  376. 		{
  377. 			err = 1;
  378. 			break;
  379. 		}
  380. 	}
  382. 	free(buf);
  384. 	return err;
  385. }