logo

utils-std

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

timeout.c (6484B)

    

  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
  6. #define _DEFAULT_SOURCE // For NSIG in sys_signame.h, thanks glibc
  7. #include "../config.h"
  8. #include "../lib/sys_signame.h"
  9. #include "../libutils/getopt_nolong.h"
  10. #include "../libutils/strtodur.h"
  12. #include <ctype.h>
  13. #include <errno.h>
  14. #include <inttypes.h> // PRId64
  15. #include <signal.h>   // kill
  16. #include <spawn.h>    // posix_spawn
  17. #include <stdbool.h>
  18. #include <stdio.h>  // fprintf
  19. #include <stdlib.h> // exit
  20. #include <string.h> // strerror
  21. #include <sys/wait.h>
  22. #include <time.h>   // nanosleep
  23. #include <unistd.h> // getopt
  24. #ifdef HAS_GETOPT_LONG
  25. #include <getopt.h>
  26. #endif
  28. #define CMD_EXIT_TIMEOUT 124
  29. #define CMD_EXIT_FAILURE 125
  30. #define CMD_EXIT_E_EXEC 126
  31. #define CMD_EXIT_ENOENT 127
  32. #define CMD_EXIT_KILL 137
  34. extern char **environ;
  36. pid_t child = 0;
  37. const char *argv0 = "timeout";
  39. static void
  40. handle_sigchld(int sig)
  41. {
  42. 	(void)sig;
  43. 	int stat_loc = 0;
  44. 	waitpid(child, &stat_loc, WNOHANG);
  46. 	// Not exit() to avoid running the atexit handlers
  47. 	// one of which being gcc --coverage handler which causes a hang
  48. 	_Exit(WEXITSTATUS(stat_loc));
  49. }
  51. static void
  52. usage(void)
  53. {
  54. 	fprintf(stderr,
  55. 	        "Usage: timeout [-fp] [-k duration] [-s SIGNAL] duration command [arguments...]\n");
  56. }
  58. int
  59. main(int argc, char *argv[])
  60. {
  61. 	struct timespec time_kill = {.tv_sec = 0, .tv_nsec = 0};
  62. 	int term_sig = SIGTERM;
  63. 	const char *term_signame = "SIGTERM";
  64. 	bool kill_child = true;
  65. 	int cmd_exit_timeout = CMD_EXIT_TIMEOUT;
  67. 	char *arg = NULL;
  69. #ifdef HAS_GETOPT_LONG
  70. 	// Strictly for GNUisms compatibility so no long-only options
  71. 	// clang-format off
  72. 	static struct option opts[] = {
  73. 		{"kill-after", required_argument, NULL, 'k'},
  74. 		{"preserve-status", required_argument, NULL, 'p'},
  75. 		{"signal", required_argument, NULL, 's'},
  76. 		{0, 0, 0, 0},
  77. 	};
  78. 	// clang-format on
  80. 	// Need + as first character to get POSIX-style option parsing
  81. 	for(int c = -1; (c = getopt_long(argc, argv, "+:fk:ps:", opts, NULL)) != -1;)
  82. #else
  83. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":fk:ps:")) != -1;)
  84. #endif
  85. 	{
  86. 		switch(c)
  87. 		{
  88. 		case 'f':
  89. 			kill_child = false;
  90. 			break;
  91. 		case 'k':
  92. 			if(strtodur(optarg, &time_kill) < 0) return 1;
  94. 			if(time_kill.tv_sec == 0 && time_kill.tv_nsec == 0)
  95. 			{
  96. 				fprintf(stderr, "timeout: error: Got a duration of 0 for SIGKILL timeout.\n");
  97. 				return CMD_EXIT_FAILURE;
  98. 			}
  99. 			break;
  100. 		case 'p':
  101. 			cmd_exit_timeout = 0;
  102. 			break;
  103. 		case 's':
  104. 			if(isdigit(optarg[0]))
  105. 			{
  106. 				char *endptr = NULL;
  108. 				unsigned long optoul = strtoul(optarg, &endptr, 10);
  109. 				if(!(errno == 0 && endptr != NULL && *endptr == '\0'))
  110. 				{
  111. 					fprintf(
  112. 					    stderr,
  113. 					    "timeout: error: Mix of digit and non-digit characters passed to -s option '%s'\n",
  114. 					    endptr);
  115. 					return 1;
  116. 				}
  117. 				if(errno == 0 && optoul == 0) errno = EINVAL;
  118. 				if(errno == 0 && optoul >= util_sys_signame_len) errno = ERANGE;
  119. 				if(errno != 0)
  120. 				{
  121. 					fprintf(stderr,
  122. 					        "timeout: error: Invalid number passed to -s '%s' (got: %lu): %s\n",
  123. 					        optarg,
  124. 					        optoul,
  125. 					        strerror(errno));
  126. 					return 1;
  127. 				}
  129. 				if(util_sys_signame[optoul] == NULL)
  130. 				{
  131. 					fprintf(stderr, "timeout: error: Unknown signal number %lu\n", optoul);
  132. 					return 1;
  133. 				}
  135. 				term_sig = optoul;
  136. 			}
  137. 			else
  138. 			{
  139. 				arg = optarg;
  140. 				if(arg[0] == 'S' && arg[1] == 'I' && arg[2] == 'G') arg += 3;
  142. 				size_t i = 0;
  143. 				for(; i < (util_sys_signame_len); i++)
  144. 				{
  145. 					if(util_sys_signame[i] == NULL) continue;
  146. 					if(strcmp(arg, util_sys_signame[i]) == 0)
  147. 					{
  148. 						term_sig = i;
  149. 						term_signame = optarg;
  150. 						break;
  151. 					}
  152. 				}
  153. 				if(i >= util_sys_signame_len)
  154. 				{
  155. 					fprintf(stderr, "timeout: error: Unknown signal name '%s'\n", optarg);
  156. 					return CMD_EXIT_FAILURE;
  157. 				}
  158. 			}
  159. 			break;
  160. 		case ':':
  161. 			fprintf(stderr, "timeout: error: Missing operand for option: '-%c'\n", optopt);
  162. 			usage();
  163. 			return 1;
  164. 		case '?':
  165. 			GETOPT_UNKNOWN_OPT
  166. 			usage();
  167. 			return 1;
  168. 		}
  169. 	}
  171. 	argv += optind;
  172. 	argc -= optind;
  174. 	struct timespec term = {.tv_sec = 0, .tv_nsec = 0};
  175. 	if(strtodur(argv[0], &term) < 0) return 1;
  177. 	if(term.tv_sec == 0 && term.tv_nsec == 0)
  178. 	{
  179. 		fprintf(stderr, "timeout: error: Got a duration of 0 for (%s) timeout.\n", term_signame);
  180. 		return CMD_EXIT_FAILURE;
  181. 	}
  183. 	argv++;
  184. 	argc--;
  186. 	struct sigaction sa = {
  187. 		.sa_handler = handle_sigchld,
  188. 		.sa_flags = 0,
  189. 	};
  190. 	if(sigaction(SIGCHLD, &sa, NULL) != 0)
  191. 	{
  192. 		fprintf(
  193. 		    stderr, "timeout: error: Failed registering handler for SIGCHLD: %s\n", strerror(errno));
  194. 		return CMD_EXIT_FAILURE;
  195. 	}
  197. 	if(posix_spawnp(&child, argv[0], NULL, NULL, argv, environ) != 0)
  198. 	{
  199. 		fprintf(stderr, "timeout: error: Failed executing '%s': %s\n", argv[0], strerror(errno));
  200. 		return CMD_EXIT_E_EXEC;
  201. 	}
  203. 	// Because PATH-finding typically relies on trial-and-error
  204. 	errno = 0;
  206. 	if(nanosleep(&term, &term) < 0)
  207. 	{
  208. 		if(errno == EINTR)
  209. 		{
  210. 			fprintf(stderr,
  211. 			        "timeout: warning: Interrupted during sleeping for %s, still had %" PRId64
  212. 			        ".%09" PRId64 " seconds remaining\n",
  213. 			        term_signame,
  214. 			        (int64_t)term.tv_sec,
  215. 			        (int64_t)term.tv_nsec);
  216. 		}
  217. 		else
  218. 		{
  219. 			fprintf(
  220. 			    stderr, "timeout: error: Failed sleeping before %s: %s\n", term_signame, strerror(errno));
  221. 			return CMD_EXIT_FAILURE;
  222. 		}
  223. 	}
  225. 	if(!kill_child)
  226. 	{
  227. 		return cmd_exit_timeout;
  228. 	}
  230. 	if(kill(child, term_sig) != 0)
  231. 	{
  232. 		fprintf(stderr,
  233. 		        "timeout: error: Failed sending %s to child %d after timeout: %s\n",
  234. 		        term_signame,
  235. 		        child,
  236. 		        strerror(errno));
  237. 		return CMD_EXIT_FAILURE;
  238. 	}
  240. 	if(time_kill.tv_sec == 0 && time_kill.tv_nsec == 0)
  241. 	{
  242. 		return cmd_exit_timeout;
  243. 	}
  245. 	if(nanosleep(&time_kill, &time_kill) < 0)
  246. 	{
  247. 		if(errno == EINTR)
  248. 		{
  249. 			fprintf(stderr,
  250. 			        "timeout: warning: Interrupted during KILL-sleep, still had %" PRId64 ".%09" PRId64
  251. 			        " seconds remaining\n",
  252. 			        (int64_t)term.tv_sec,
  253. 			        (int64_t)term.tv_nsec);
  254. 		}
  255. 		else
  256. 		{
  257. 			fprintf(stderr, "timeout: error: Failed sleeping before KILL: %s\n", strerror(errno));
  258. 			return CMD_EXIT_FAILURE;
  259. 		}
  260. 	}
  262. 	if(kill(child, SIGKILL) != 0)
  263. 	{
  264. 		fprintf(stderr,
  265. 		        "timeout: error: Failed sending SIGKILL to child %d after timeout: %s\n",
  266. 		        child,
  267. 		        strerror(errno));
  268. 		return CMD_EXIT_FAILURE;
  269. 	}
  271. 	return cmd_exit_timeout;
  272. }