logo

utils-std

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

timeout.c (6617B)

    

  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";
  38. static bool timeout = false;
  39. static int cmd_exit_timeout = CMD_EXIT_TIMEOUT;
  41. static void
  42. handle_sigchld(int sig)
  43. {
  44. 	// Doesn't uses exit() to avoid running the atexit handlers
  45. 	// one of which being gcc --coverage handler which causes a hang
  46. 	(void)sig;
  47. 	int stat_loc = 0;
  49. 	if(timeout && cmd_exit_timeout != 0) _Exit(CMD_EXIT_TIMEOUT);
  51. 	waitpid(child, &stat_loc, WNOHANG);
  53. 	_Exit(WEXITSTATUS(stat_loc));
  54. }
  56. static void
  57. usage(void)
  58. {
  59. 	fprintf(stderr,
  60. 	        "Usage: timeout [-fp] [-k duration] [-s SIGNAL] duration command [arguments...]\n");
  61. }
  63. int
  64. main(int argc, char *argv[])
  65. {
  66. 	struct timespec time_kill = {.tv_sec = 0, .tv_nsec = 0};
  67. 	int term_sig = SIGTERM;
  68. 	const char *term_signame = "SIGTERM";
  69. 	bool kill_child = true;
  71. 	char *arg = NULL;
  73. #ifdef HAS_GETOPT_LONG
  74. 	// Strictly for GNUisms compatibility so no long-only options
  75. 	// clang-format off
  76. 	static struct option opts[] = {
  77. 		{"kill-after", required_argument, NULL, 'k'},
  78. 		{"preserve-status", required_argument, NULL, 'p'},
  79. 		{"signal", required_argument, NULL, 's'},
  80. 		{0, 0, 0, 0},
  81. 	};
  82. 	// clang-format on
  84. 	// Need + as first character to get POSIX-style option parsing
  85. 	for(int c = -1; (c = getopt_long(argc, argv, "+:fk:ps:", opts, NULL)) != -1;)
  86. #else
  87. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":fk:ps:")) != -1;)
  88. #endif
  89. 	{
  90. 		switch(c)
  91. 		{
  92. 		case 'f':
  93. 			kill_child = false;
  94. 			break;
  95. 		case 'k':
  96. 			if(strtodur(optarg, &time_kill) < 0) return 1;
  98. 			if(time_kill.tv_sec == 0 && time_kill.tv_nsec == 0)
  99. 			{
  100. 				fprintf(stderr, "timeout: error: Got a duration of 0 for SIGKILL timeout.\n");
  101. 				return CMD_EXIT_FAILURE;
  102. 			}
  103. 			break;
  104. 		case 'p':
  105. 			cmd_exit_timeout = 0;
  106. 			break;
  107. 		case 's':
  108. 			if(isdigit(optarg[0]))
  109. 			{
  110. 				char *endptr = NULL;
  112. 				unsigned long optoul = strtoul(optarg, &endptr, 10);
  113. 				if(!(errno == 0 && endptr != NULL && *endptr == '\0'))
  114. 				{
  115. 					fprintf(
  116. 					    stderr,
  117. 					    "timeout: error: Mix of digit and non-digit characters passed to -s option '%s'\n",
  118. 					    endptr);
  119. 					return 1;
  120. 				}
  121. 				if(errno == 0 && optoul == 0) errno = EINVAL;
  122. 				if(errno == 0 && optoul >= util_sys_signame_len) errno = ERANGE;
  123. 				if(errno != 0)
  124. 				{
  125. 					fprintf(stderr,
  126. 					        "timeout: error: Invalid number passed to -s '%s' (got: %lu): %s\n",
  127. 					        optarg,
  128. 					        optoul,
  129. 					        strerror(errno));
  130. 					return 1;
  131. 				}
  133. 				if(util_sys_signame[optoul] == NULL)
  134. 				{
  135. 					fprintf(stderr, "timeout: error: Unknown signal number %lu\n", optoul);
  136. 					return 1;
  137. 				}
  139. 				term_sig = optoul;
  140. 			}
  141. 			else
  142. 			{
  143. 				arg = optarg;
  144. 				if(arg[0] == 'S' && arg[1] == 'I' && arg[2] == 'G') arg += 3;
  146. 				size_t i = 0;
  147. 				for(; i < (util_sys_signame_len); i++)
  148. 				{
  149. 					if(util_sys_signame[i] == NULL) continue;
  150. 					if(strcmp(arg, util_sys_signame[i]) == 0)
  151. 					{
  152. 						term_sig = i;
  153. 						term_signame = optarg;
  154. 						break;
  155. 					}
  156. 				}
  157. 				if(i >= util_sys_signame_len)
  158. 				{
  159. 					fprintf(stderr, "timeout: error: Unknown signal name '%s'\n", optarg);
  160. 					return CMD_EXIT_FAILURE;
  161. 				}
  162. 			}
  163. 			break;
  164. 		case ':':
  165. 			fprintf(stderr, "timeout: error: Missing operand for option: '-%c'\n", optopt);
  166. 			usage();
  167. 			return 1;
  168. 		case '?':
  169. 			GETOPT_UNKNOWN_OPT
  170. 			usage();
  171. 			return 1;
  172. 		}
  173. 	}
  175. 	argv += optind;
  176. 	argc -= optind;
  178. 	struct timespec term = {.tv_sec = 0, .tv_nsec = 0};
  179. 	if(strtodur(argv[0], &term) < 0) return 1;
  181. 	if(term.tv_sec == 0 && term.tv_nsec == 0)
  182. 	{
  183. 		fprintf(stderr, "timeout: error: Got a duration of 0 for (%s) timeout.\n", term_signame);
  184. 		return CMD_EXIT_FAILURE;
  185. 	}
  187. 	argv++;
  188. 	argc--;
  190. 	struct sigaction sa = {
  191. 	    .sa_handler = handle_sigchld,
  192. 	    .sa_flags = 0,
  193. 	};
  194. 	if(sigaction(SIGCHLD, &sa, NULL) != 0)
  195. 	{
  196. 		fprintf(
  197. 		    stderr, "timeout: error: Failed registering handler for SIGCHLD: %s\n", strerror(errno));
  198. 		return CMD_EXIT_FAILURE;
  199. 	}
  201. 	if(posix_spawnp(&child, argv[0], NULL, NULL, argv, environ) != 0)
  202. 	{
  203. 		fprintf(stderr, "timeout: error: Failed executing '%s': %s\n", argv[0], strerror(errno));
  204. 		return CMD_EXIT_E_EXEC;
  205. 	}
  207. 	// Because PATH-finding typically relies on trial-and-error
  208. 	errno = 0;
  210. 	if(nanosleep(&term, &term) < 0)
  211. 	{
  212. 		if(errno == EINTR)
  213. 		{
  214. 			fprintf(stderr,
  215. 			        "timeout: warning: Interrupted during sleeping for %s, still had %" PRId64
  216. 			        ".%09" PRId64 " seconds remaining\n",
  217. 			        term_signame,
  218. 			        (int64_t)term.tv_sec,
  219. 			        (int64_t)term.tv_nsec);
  220. 		}
  221. 		else
  222. 		{
  223. 			fprintf(
  224. 			    stderr, "timeout: error: Failed sleeping before %s: %s\n", term_signame, strerror(errno));
  225. 			return CMD_EXIT_FAILURE;
  226. 		}
  227. 	}
  229. 	timeout = true;
  231. 	if(!kill_child)
  232. 	{
  233. 		return cmd_exit_timeout;
  234. 	}
  236. 	if(kill(child, term_sig) != 0)
  237. 	{
  238. 		fprintf(stderr,
  239. 		        "timeout: error: Failed sending %s to child %d after timeout: %s\n",
  240. 		        term_signame,
  241. 		        child,
  242. 		        strerror(errno));
  243. 		return CMD_EXIT_FAILURE;
  244. 	}
  246. 	if(time_kill.tv_sec == 0 && time_kill.tv_nsec == 0)
  247. 	{
  248. 		return cmd_exit_timeout;
  249. 	}
  251. 	if(nanosleep(&time_kill, &time_kill) < 0)
  252. 	{
  253. 		if(errno == EINTR)
  254. 		{
  255. 			fprintf(stderr,
  256. 			        "timeout: warning: Interrupted during KILL-sleep, still had %" PRId64 ".%09" PRId64
  257. 			        " seconds remaining\n",
  258. 			        (int64_t)term.tv_sec,
  259. 			        (int64_t)term.tv_nsec);
  260. 		}
  261. 		else
  262. 		{
  263. 			fprintf(stderr, "timeout: error: Failed sleeping before KILL: %s\n", strerror(errno));
  264. 			return CMD_EXIT_FAILURE;
  265. 		}
  266. 	}
  268. 	if(kill(child, SIGKILL) != 0)
  269. 	{
  270. 		fprintf(stderr,
  271. 		        "timeout: error: Failed sending SIGKILL to child %d after timeout: %s\n",
  272. 		        child,
  273. 		        strerror(errno));
  274. 		return CMD_EXIT_FAILURE;
  275. 	}
  277. 	return cmd_exit_timeout;
  278. }