Add support for limiting maximum execution time based on wall-time

Author: kocsismate

Zend/zend_execute.h

@@ -321,7 +321,9 @@ ZEND_API bool zend_is_executing(void);
 ZEND_API ZEND_COLD void ZEND_FASTCALL zend_cannot_pass_by_reference(uint32_t arg_num);
 
 ZEND_API void zend_set_timeout(zend_long seconds, bool reset_signals);
+ZEND_API void zend_set_wall_timeout(zend_long seconds, bool reset_signals);
 ZEND_API void zend_unset_timeout(void);
+ZEND_API void zend_unset_wall_timeout(void);
 ZEND_API ZEND_NORETURN void ZEND_FASTCALL zend_timeout(void);
 ZEND_API zend_class_entry *zend_fetch_class(zend_string *class_name, int fetch_type);
 ZEND_API zend_class_entry *zend_fetch_class_by_name(zend_string *class_name, zend_string *lcname, int fetch_type);

Zend/zend_execute_API.c

@@ -1260,9 +1260,14 @@ ZEND_API zend_result zend_eval_string_ex(const char *str, zval *retval_ptr, cons
 /* }}} */
 
 static void zend_set_timeout_ex(zend_long seconds, bool reset_signals);
+static void zend_set_wall_timeout_ex(zend_long seconds, bool reset_signals);
 
 ZEND_API ZEND_NORETURN void ZEND_FASTCALL zend_timeout(void) /* {{{ */
 {
+	zend_long original_timed_out = EG(timed_out);
+	zend_long original_timeout_seconds = EG(timeout_seconds);
+	zend_long original_wall_timeout_seconds = EG(wall_timeout_seconds);
+
 #if defined(PHP_WIN32)
 # ifndef ZTS
 	/* No action is needed if we're timed out because zero seconds are
@@ -1278,10 +1283,18 @@ ZEND_API ZEND_NORETURN void ZEND_FASTCALL zend_timeout(void) /* {{{ */
 # endif
 #else
 	EG(timed_out) = 0;
-	zend_set_timeout_ex(0, 1);
+	if (original_timed_out == 1) {
+		zend_set_timeout_ex(0, 1);
+	} else {
+		zend_set_wall_timeout_ex(0, 1);
+	}
 #endif
 
-	zend_error_noreturn(E_ERROR, "Maximum execution time of " ZEND_LONG_FMT " second%s exceeded", EG(timeout_seconds), EG(timeout_seconds) == 1 ? "" : "s");
+	if (original_timed_out == 1) {
+		zend_error_noreturn(E_ERROR, "Maximum execution time of " ZEND_LONG_FMT " second%s exceeded", original_timeout_seconds, original_timeout_seconds == 1 ? "" : "s");
+	} else {
+		zend_error_noreturn(E_ERROR, "Maximum execution wall-time of " ZEND_LONG_FMT " second%s exceeded", original_wall_timeout_seconds, original_wall_timeout_seconds == 1 ? "" : "s");
+	}
 }
 /* }}} */
 
@@ -1337,6 +1350,57 @@ static void zend_timeout_handler(int dummy) /* {{{ */
 /* }}} */
 #endif
 
+#ifndef ZEND_WIN32
+static void zend_wall_timeout_handler(int dummy) /* {{{ */
+{
+#ifndef ZTS
+    if (EG(timed_out)) {
+		/* Die on hard timeout */
+		const char *error_filename = NULL;
+		uint32_t error_lineno = 0;
+		char log_buffer[2048];
+		int output_len = 0;
+
+		if (zend_is_compiling()) {
+			error_filename = ZSTR_VAL(zend_get_compiled_filename());
+			error_lineno = zend_get_compiled_lineno();
+		} else if (zend_is_executing()) {
+			error_filename = zend_get_executed_filename();
+			if (error_filename[0] == '[') { /* [no active file] */
+				error_filename = NULL;
+				error_lineno = 0;
+			} else {
+				error_lineno = zend_get_executed_lineno();
+			}
+		}
+		if (!error_filename) {
+			error_filename = "Unknown";
+		}
+
+		output_len = snprintf(log_buffer, sizeof(log_buffer), "\nFatal error: Maximum execution wall-time of " ZEND_LONG_FMT "+" ZEND_LONG_FMT " seconds exceeded (terminated) in %s on line %d\n", EG(wall_timeout_seconds), EG(hard_timeout), error_filename, error_lineno);
+		if (output_len > 0) {
+			zend_quiet_write(2, log_buffer, MIN(output_len, sizeof(log_buffer)));
+		}
+		_exit(124);
+    }
+#endif
+
+	if (zend_on_timeout) {
+		zend_on_timeout(EG(wall_timeout_seconds));
+	}
+
+	EG(timed_out) = 2;
+	EG(vm_interrupt) = 1;
+
+#ifndef ZTS
+	if (EG(hard_timeout)) {
+		zend_set_wall_timeout_ex(EG(hard_timeout), 1);
+	}
+#endif
+}
+/* }}} */
+#endif
+
 #ifdef ZEND_WIN32
 VOID CALLBACK tq_timer_cb(PVOID arg, BOOLEAN timed_out)
 {
@@ -1431,15 +1495,89 @@ static void zend_set_timeout_ex(zend_long seconds, bool reset_signals) /* {{{ */
 }
 /* }}} */
 
-void zend_set_timeout(zend_long seconds, bool reset_signals) /* {{{ */
+static void zend_set_wall_timeout_ex(zend_long seconds, bool reset_signals) /* {{{ */
 {
+#ifdef ZEND_WIN32
+	zend_executor_globals *eg;
+
+	if (!seconds) {
+		return;
+	}
+
+	/* Don't use ChangeTimerQueueTimer() as it will not restart an expired
+	 * timer, so we could end up with just an ignored timeout. Instead
+	 * delete and recreate. */
+	if (NULL != tq_timer) {
+		if (!DeleteTimerQueueTimer(NULL, tq_timer, INVALID_HANDLE_VALUE)) {
+			tq_timer = NULL;
+			zend_error_noreturn(E_ERROR, "Could not delete queued timer");
+			return;
+		}
+		tq_timer = NULL;
+	}
+
+	/* XXX passing NULL means the default timer queue provided by the system is used */
+	eg = ZEND_MODULE_GLOBALS_BULK(executor);
+	if (!CreateTimerQueueTimer(&tq_timer, NULL, (WAITORTIMERCALLBACK)tq_timer_cb, (VOID*)eg, seconds*1000, 0, WT_EXECUTEONLYONCE)) {
+		tq_timer = NULL;
+		zend_error_noreturn(E_ERROR, "Could not queue new timer");
+		return;
+	}
+#elif defined(HAVE_SETITIMER)
+	{
+		struct itimerval t_r;		/* timeout requested */
+		int signo;
+
+		if(seconds) {
+			t_r.it_value.tv_sec = seconds;
+			t_r.it_value.tv_usec = t_r.it_interval.tv_sec = t_r.it_interval.tv_usec = 0;
+
+			setitimer(ITIMER_REAL, &t_r, NULL);
+		}
+		signo = SIGALRM;
 
+		if (reset_signals) {
+
+# ifdef ZEND_SIGNALS
+			zend_signal(signo, zend_wall_timeout_handler);
+# else
+			sigset_t sigset;
+#  ifdef HAVE_SIGACTION
+			struct sigaction act;
+
+			act.sa_handler = zend_wall_timeout_handler;
+			sigemptyset(&act.sa_mask);
+			act.sa_flags = SA_RESETHAND | SA_NODEFER;
+			sigaction(signo, &act, NULL);
+#  else
+			signal(signo, zend_wall_timeout_handler);
+#  endif /* HAVE_SIGACTION */
+			sigemptyset(&sigset);
+			sigaddset(&sigset, signo);
+			sigprocmask(SIG_UNBLOCK, &sigset, NULL);
+# endif /* ZEND_SIGNALS */
+		}
+	}
+#endif /* HAVE_SETITIMER */
+}
+/* }}} */
+
+void zend_set_timeout(zend_long seconds, bool reset_signals) /* {{{ */
+{
 	EG(timeout_seconds) = seconds;
 	zend_set_timeout_ex(seconds, reset_signals);
 	EG(timed_out) = 0;
 }
 /* }}} */
 
+void zend_set_wall_timeout(zend_long seconds, bool reset_signals) /* {{{ */
+{
+	EG(wall_timeout_seconds) = seconds;
+	zend_set_wall_timeout_ex(seconds, reset_signals);
+	EG(timed_out) = 0;
+}
+/* }}} */
+
 void zend_unset_timeout(void) /* {{{ */
 {
 #ifdef ZEND_WIN32
@@ -1469,6 +1607,31 @@ void zend_unset_timeout(void) /* {{{ */
 }
 /* }}} */
 
+void zend_unset_wall_timeout(void) /* {{{ */
+{
+#ifdef ZEND_WIN32
+	if (NULL != tq_timer) {
+		if (!DeleteTimerQueueTimer(NULL, tq_timer, INVALID_HANDLE_VALUE)) {
+			EG(timed_out) = 0;
+			tq_timer = NULL;
+			zend_error_noreturn(E_ERROR, "Could not delete queued timer");
+			return;
+		}
+		tq_timer = NULL;
+	}
+#elif defined(HAVE_SETITIMER)
+	if (EG(wall_timeout_seconds)) {
+		struct itimerval no_timeout;
+
+		no_timeout.it_value.tv_sec = no_timeout.it_value.tv_usec = no_timeout.it_interval.tv_sec = no_timeout.it_interval.tv_usec = 0;
+
+		setitimer(ITIMER_REAL, &no_timeout, NULL);
+	}
+#endif
+	EG(timed_out) = 0;
+}
+/* }}} */
+
 zend_class_entry *zend_fetch_class(zend_string *class_name, int fetch_type) /* {{{ */
 {
 	zend_class_entry *ce, *scope;

Zend/zend_globals.h

@@ -184,7 +184,7 @@ struct _zend_executor_globals {
 	bool no_extensions;
 
 	bool vm_interrupt;
-	bool timed_out;
+	zend_long timed_out;
 	zend_long hard_timeout;
 
 #ifdef ZEND_WIN32
@@ -206,6 +206,7 @@ struct _zend_executor_globals {
 
 	/* timeout support */
 	zend_long timeout_seconds;
+	zend_long wall_timeout_seconds;
 
 	int capture_warnings_during_sccp;
 

Zend/zend_signal.c

@@ -62,14 +62,7 @@ ZEND_API zend_signal_globals_t zend_signal_globals;
 static void zend_signal_handler(int signo, siginfo_t *siginfo, void *context);
 static int zend_signal_register(int signo, void (*handler)(int, siginfo_t*, void*));
 
-#if defined(__CYGWIN__) || defined(__PASE__)
-/* Matches zend_excute_API.c; these platforms don't support ITIMER_PROF. */
-#define TIMEOUT_SIG SIGALRM
-#else
-#define TIMEOUT_SIG SIGPROF
-#endif
-
-static int zend_sigs[] = { TIMEOUT_SIG, SIGHUP, SIGINT, SIGQUIT, SIGTERM, SIGUSR1, SIGUSR2 };
+static int zend_sigs[] = { SIGPROF, SIGALRM, SIGHUP, SIGINT, SIGQUIT, SIGTERM, SIGUSR1, SIGUSR2 };
 
 #define SA_FLAGS_MASK ~(SA_NODEFER | SA_RESETHAND)
 

main/main.c

@@ -400,6 +400,21 @@ static PHP_INI_MH(OnUpdateTimeout)
 }
 /* }}} */
 
+/* {{{ PHP_INI_MH */
+static PHP_INI_MH(OnUpdateWallTimeout)
+{
+	if (stage==PHP_INI_STAGE_STARTUP) {
+		/* Don't set a timeout on startup, only per-request */
+		ZEND_ATOL(EG(wall_timeout_seconds), ZSTR_VAL(new_value));
+		return SUCCESS;
+	}
+	zend_unset_wall_timeout();
+	ZEND_ATOL(EG(wall_timeout_seconds), ZSTR_VAL(new_value));
+	zend_set_wall_timeout(EG(wall_timeout_seconds), 0);
+	return SUCCESS;
+}
+/* }}} */
+
 /* {{{ php_get_display_errors_mode() helper function */
 static zend_uchar php_get_display_errors_mode(char *value, size_t value_length)
 {
@@ -688,6 +703,7 @@ PHP_INI_BEGIN()
 	STD_PHP_INI_ENTRY("sys_temp_dir",			NULL,		PHP_INI_SYSTEM,		OnUpdateStringUnempty,	sys_temp_dir,			php_core_globals,	core_globals)
 	STD_PHP_INI_ENTRY("include_path",			PHP_INCLUDE_PATH,		PHP_INI_ALL,		OnUpdateStringUnempty,	include_path,			php_core_globals,	core_globals)
 	PHP_INI_ENTRY("max_execution_time",			"30",		PHP_INI_ALL,			OnUpdateTimeout)
+	PHP_INI_ENTRY("max_execution_wall_time",	"0",		PHP_INI_ALL,			OnUpdateWallTimeout)
 	STD_PHP_INI_ENTRY("open_basedir",			NULL,		PHP_INI_ALL,		OnUpdateBaseDir,			open_basedir,			php_core_globals,	core_globals)
 
 	STD_PHP_INI_BOOLEAN("file_uploads",			"1",		PHP_INI_SYSTEM,		OnUpdateBool,			file_uploads,			php_core_globals,	core_globals)
@@ -1686,6 +1702,7 @@ int php_request_startup(void)
 		} else {
 			zend_set_timeout(PG(max_input_time), 1);
 		}
+		zend_set_wall_timeout(EG(wall_timeout_seconds), 1);
 
 		/* Disable realpath cache if an open_basedir is set */
 		if (PG(open_basedir) && *PG(open_basedir)) {
@@ -1772,9 +1789,10 @@ void php_request_shutdown(void *dummy)
 		}
 	} zend_end_try();
 
-	/* 4. Reset max_execution_time (no longer executing php code after response sent) */
+	/* 4. Reset max_execution_time and max_execution_wall_time (no longer executing php code after response sent) */
 	zend_try {
 		zend_unset_timeout();
+		zend_unset_wall_timeout();
 	} zend_end_try();
 
 	/* 5. Call all extensions RSHUTDOWN functions */

tests/basic/wall_timeout_variation_0.phpt

@@ -0,0 +1,15 @@
+--TEST--
+Retrieve max_execution_wall_time ini value
+--FILE--
+<?php
+
+var_dump(ini_get("max_execution_wall_time"));
+
+ini_set("max_execution_wall_time", 1);
+
+var_dump(ini_get("max_execution_wall_time"));
+
+?>
+--EXPECTF--
+string(1) "0"
+string(1) "1"

tests/basic/wall_timeout_variation_1.phpt

@@ -0,0 +1,21 @@
+--TEST--
+Timeout in loop
+--SKIPIF--
+<?php
+if (getenv("SKIP_SLOW_TESTS")) die("skip slow test");
+?>
+--FILE--
+<?php
+
+ini_set("max_execution_time", 1);
+ini_set("max_execution_wall_time", 1);
+
+for ($i = 0; $i < 3; $i++) {
+    sleep(1);
+}
+
+echo "Never reached";
+
+?>
+--EXPECTF--
+Fatal error: Maximum execution wall-time of 1 second exceeded in %s on line %d

tests/basic/wall_timeout_variation_2.phpt

@@ -0,0 +1,31 @@
+--TEST--
+Safe shutdown when hard timeout is not reached
+--SKIPIF--
+<?php
+if (getenv("SKIP_SLOW_TESTS")) die("skip slow test");
+include __DIR__ . "/../../sapi/cli/tests/skipif.inc";
+?>
+--INI--
+allow_url_fopen=1
+hard_timeout=5
+--FILE--
+<?php
+
+require __DIR__ . "/../../sapi/cli/tests/php_cli_server.inc";
+
+php_cli_server_start("sleep(3);");
+
+ini_set("max_execution_time", 1);
+ini_set("max_execution_wall_time", 1);
+ini_set("default_socket_timeout", 1);
+
+register_shutdown_function(function () {
+    echo "OK";
+});
+
+@file_get_contents("http://" . PHP_CLI_SERVER_ADDRESS);
+
+?>
+--EXPECTF--
+Fatal error: Maximum execution wall-time of 1 second exceeded in %s on line %d
+OK