logo

utils-std

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

timeout.c (6316B)

    

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