logo

utils-std

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

head.c (6875B)

    

  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 "../libutils/fs.h" // auto_fd_copy
  8. #include "../libutils/getopt_nolong.h"
  9. #include "../libutils/truncation.h" // apply_size_suffix
  11. #include <ctype.h> // isdigit
  12. #include <errno.h>
  13. #include <fcntl.h>  // open
  14. #include <stdio.h>  // fprintf, fopen, fread
  15. #include <stdlib.h> // strtoul
  16. #include <string.h> // strerror
  17. #include <unistd.h> // read
  19. static const char *header_fmt = "==> %s <==\n";
  21. const char *argv0 = "head";
  23. ssize_t lines = 10;
  24. size_t bytes = 0;
  26. char *buf = NULL;
  27. size_t buflen = 0;
  29. int delim = '\n';
  31. static int
  32. copy_bytes(const char *filename)
  33. {
  34. 	int fd = -1;
  35. 	if(filename[0] == '-' && filename[1] == 0)
  36. 	{
  37. 		fd = STDIN_FILENO;
  38. 	}
  39. 	else
  40. 	{
  41. 		fd = open(filename, O_RDONLY | O_CLOEXEC | O_NOCTTY);
  42. 		if(fd < 0)
  43. 		{
  44. 			fprintf(
  45. 			    stderr, "%s: error: Failed opening file '%s': %s\n", argv0, filename, strerror(errno));
  46. 			return 1;
  47. 		}
  49. 		posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL);
  50. 	}
  52. 	int err = 0;
  53. 	if(auto_fd_copy(fd, STDOUT_FILENO, bytes) < 0)
  54. 	{
  55. 		fprintf(stderr,
  56. 		        "%s: error: Failed copying data from '%s' to <stdout>: %s\n",
  57. 		        argv0,
  58. 		        filename,
  59. 		        strerror(errno));
  60. 		err = 1;
  61. 	}
  63. 	if(fd != STDIN_FILENO)
  64. 		if(close(fd) != 0)
  65. 		{
  66. 			fprintf(
  67. 			    stderr, "%s: error: Failed closing file '%s': %s\n", argv0, filename, strerror(errno));
  68. 			return 1;
  69. 		}
  71. 	return err;
  72. }
  74. static int
  75. copy_lines(const char *filename)
  76. {
  77. 	int err = 0;
  78. 	FILE *in = NULL;
  80. 	if(filename[0] == '-' && filename[1] == 0)
  81. 	{
  82. 		in = stdin;
  83. 	}
  84. 	else
  85. 	{
  86. 		in = fopen(filename, "r");
  87. 		if(in == NULL)
  88. 		{
  89. 			fprintf(
  90. 			    stderr, "%s: error: Failed opening file '%s': %s\n", argv0, filename, strerror(errno));
  91. 			return 1;
  92. 		}
  93. 	}
  95. 	// Relative to EOF, GNU extension
  96. 	if(lines < 0)
  97. 	{
  98. 		struct strbuf
  99. 		{
  100. 			size_t len;
  101. 			size_t cap;
  102. 			char *buf;
  103. 		};
  104. 		size_t nlines = (size_t)-lines;
  105. 		size_t wini = 0;
  106. 		struct strbuf *win = calloc(nlines, sizeof(struct strbuf));
  107. 		if(!win)
  108. 		{
  109. 			fprintf(stderr, "%s: error: Failed allocating lines array: %s\n", argv0, strerror(errno));
  110. 			return 1;
  111. 		}
  113. 		while(true)
  114. 		{
  115. 			ssize_t ret = getdelim(&buf, &buflen, delim, in);
  116. 			if(ret < 0)
  117. 			{
  118. 				if(errno == 0) break;
  120. 				fprintf(stderr,
  121. 				        "%s: error: Failed reading line from '%s': %s\n",
  122. 				        argv0,
  123. 				        filename,
  124. 				        strerror(errno));
  125. 				err = 1;
  126. 				break;
  127. 			}
  128. 			size_t nread = ret;
  130. 			if(win[wini].len)
  131. 			{
  132. 				if(write(STDOUT_FILENO, win[wini].buf, win[wini].len) < 0)
  133. 				{
  134. 					fprintf(stderr,
  135. 					        "%s: error: Failed writing line from '%s' to stdout: %s\n",
  136. 					        argv0,
  137. 					        filename,
  138. 					        strerror(errno));
  139. 					err = 1;
  140. 					break;
  141. 				}
  142. 			}
  144. 			if(nread == 0) continue;
  146. 			if(win[wini].cap < nread)
  147. 			{
  148. 				win[wini].buf = realloc(win[wini].buf, nread);
  149. 				if(!win[wini].buf)
  150. 				{
  151. 					fprintf(
  152. 					    stderr, "%s: error: Failed (re)allocating line buffer: %s\n", argv0, strerror(errno));
  153. 					return 1;
  154. 				}
  155. 				win[wini].cap = nread;
  156. 			}
  158. 			win[wini].len = nread;
  159. 			memcpy(win[wini].buf, buf, nread);
  160. 			wini = (wini + 1) % nlines;
  161. 		}
  163. 		for(size_t i = 0; i < nlines; i++)
  164. 			free(win[i].buf);
  166. 		free(win);
  167. 	}
  168. 	else
  169. 	{
  170. 		size_t nlines = lines;
  171. 		for(size_t i = 0; i < nlines; i++)
  172. 		{
  173. 			ssize_t nread = getdelim(&buf, &buflen, delim, in);
  174. 			if(nread < 0)
  175. 			{
  176. 				if(errno == 0) break;
  178. 				fprintf(stderr,
  179. 				        "%s: error: Failed reading line from '%s': %s\n",
  180. 				        argv0,
  181. 				        filename,
  182. 				        strerror(errno));
  183. 				err = 1;
  184. 				break;
  185. 			}
  187. 			if(write(STDOUT_FILENO, buf, nread) < 0)
  188. 			{
  189. 				fprintf(stderr,
  190. 				        "%s: error: Failed writing line from '%s' to stdout: %s\n",
  191. 				        argv0,
  192. 				        filename,
  193. 				        strerror(errno));
  194. 				err = 1;
  195. 				break;
  196. 			}
  197. 		}
  198. 	}
  200. 	if(in != stdin)
  201. 		if(fclose(in) != 0)
  202. 		{
  203. 			fprintf(
  204. 			    stderr, "%s: error: Failed closing file '%s': %s\n", argv0, filename, strerror(errno));
  205. 			return 1;
  206. 		}
  208. 	return err;
  209. }
  211. static void
  212. usage(void)
  213. {
  214. 	fprintf(stderr, "Usage: head [-qvz] [-c size | -n num | -num] [file...]\n");
  215. }
  217. int
  218. main(int argc, char *argv[])
  219. {
  220. 	int (*copy_action)(const char *filename) = copy_lines;
  222. 	int print_header = 0;
  223. 	while(optind < argc)
  224. 	{
  225. 		/* Skip getopt(3) for parsing -num option due to how it works:
  226. 		 * - optstring = "12"; args="head -12" considered the same as -1 -2
  227. 		 * - optstring = "1:"; args="head -12" considered the same as -1 2
  228. 		 *
  229. 		 * And we need args="head -12" as "12"
  230. 		 */
  231. 		if(argv[optind] && argv[optind][0] == '-' && isdigit(argv[optind][1]))
  232. 		{
  233. 			char *arg = argv[optind] + 1;
  235. 			char *endptr = NULL;
  236. 			lines = strtol(arg, &endptr, 0);
  237. 			if(!(errno == 0 && endptr != NULL && *endptr == '\0'))
  238. 			{
  239. 				fprintf(stderr,
  240. 				        "%s: error: Failed parsing number for `-%s`: %s\n",
  241. 				        argv0,
  242. 				        arg,
  243. 				        strerror(errno));
  244. 				return 1;
  245. 			}
  247. 			optind++;
  248. 			continue;
  249. 		}
  251. 		int c = getopt_nolong(argc, argv, ":qvc:n:z");
  252. 		if(c == -1) break;
  254. 		switch(c)
  255. 		{
  256. 		case 'q':
  257. 			print_header = -1;
  258. 			break;
  259. 		case 'v':
  260. 			print_header = 1;
  261. 			break;
  262. 		case 'c':
  263. 		{
  264. 			char *endptr = NULL;
  265. 			unsigned long size = strtoul(optarg, &endptr, 0);
  266. 			if(errno != 0)
  267. 			{
  268. 				fprintf(stderr,
  269. 				        "%s: error: Failed parsing number for `-n %s`: %s\n",
  270. 				        argv0,
  271. 				        optarg,
  272. 				        strerror(errno));
  273. 				return 1;
  274. 			}
  276. 			if(endptr != NULL && *endptr != 0)
  277. 				if(apply_size_suffix(&size, endptr) != 0) return 1;
  279. 			bytes = size;
  280. 			copy_action = &copy_bytes;
  281. 			break;
  282. 		}
  283. 		case 'n':
  284. 		{
  285. 			char *endptr = NULL;
  286. 			lines = strtol(optarg, &endptr, 0);
  287. 			if(!(errno == 0 && endptr != NULL && *endptr == '\0'))
  288. 			{
  289. 				fprintf(stderr,
  290. 				        "%s: error: Failed parsing number for `-n %s`: %s\n",
  291. 				        argv0,
  292. 				        optarg,
  293. 				        strerror(errno));
  294. 				return 1;
  295. 			}
  296. 			break;
  297. 		}
  298. 		case 'z':
  299. 			delim = '\0';
  300. 			break;
  301. 		case ':':
  302. 			fprintf(stderr, "%s: error: Missing operand for option: '-%c'\n", argv0, optopt);
  303. 			usage();
  304. 			return 1;
  305. 		case '?':
  306. 			GETOPT_UNKNOWN_OPT
  307. 			usage();
  308. 			return 1;
  309. 		default:
  310. 			abort();
  311. 		}
  312. 	}
  314. 	argc -= optind;
  315. 	argv += optind;
  317. 	if(argc <= 0)
  318. 	{
  319. 		const char *filename = "-";
  321. 		if(print_header == 1)
  322. 		{
  323. 			printf(header_fmt, filename);
  324. 			fflush(stdout);
  325. 		}
  327. 		int err = copy_action(filename);
  329. 		free(buf);
  331. 		return err;
  332. 	}
  334. 	if(print_header == 0) print_header = argc > 1;
  336. 	int err = 0;
  338. 	for(int i = 0; i < argc; i++)
  339. 	{
  340. 		char *filename = argv[i];
  342. 		if(print_header > 0)
  343. 		{
  344. 			printf(header_fmt, filename);
  345. 			header_fmt = "\n==> %s <==\n";
  346. 			fflush(stdout);
  347. 		}
  349. 		if(copy_action(filename) != 0)
  350. 		{
  351. 			err = 1;
  352. 			break;
  353. 		}
  354. 	}
  356. 	free(buf);
  358. 	return err;
  359. }