Annotation of embedaddon/php/ext/pcntl/pcntl.c, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | PHP Version 5 |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1997-2012 The PHP Group |
! 6: +----------------------------------------------------------------------+
! 7: | This source file is subject to version 3.01 of the PHP license, |
! 8: | that is bundled with this package in the file LICENSE, and is |
! 9: | available through the world-wide-web at the following url: |
! 10: | http://www.php.net/license/3_01.txt |
! 11: | If you did not receive a copy of the PHP license and are unable to |
! 12: | obtain it through the world-wide-web, please send a note to |
! 13: | license@php.net so we can mail you a copy immediately. |
! 14: +----------------------------------------------------------------------+
! 15: | Author: Jason Greene <jason@inetgurus.net> |
! 16: +----------------------------------------------------------------------+
! 17: */
! 18:
! 19: /* $Id: pcntl.c 321634 2012-01-01 13:15:04Z felipe $ */
! 20:
! 21: #define PCNTL_DEBUG 0
! 22:
! 23: #if PCNTL_DEBUG
! 24: #define DEBUG_OUT printf("DEBUG: ");printf
! 25: #define IF_DEBUG(z) z
! 26: #else
! 27: #define IF_DEBUG(z)
! 28: #endif
! 29:
! 30: #ifdef HAVE_CONFIG_H
! 31: #include "config.h"
! 32: #endif
! 33:
! 34: #include "php.h"
! 35: #include "php_ini.h"
! 36: #include "ext/standard/info.h"
! 37: #include "php_pcntl.h"
! 38: #include "php_signal.h"
! 39: #include "php_ticks.h"
! 40:
! 41: #if HAVE_GETPRIORITY || HAVE_SETPRIORITY || HAVE_WAIT3
! 42: #include <sys/wait.h>
! 43: #include <sys/time.h>
! 44: #include <sys/resource.h>
! 45: #endif
! 46:
! 47: #include <errno.h>
! 48:
! 49: ZEND_DECLARE_MODULE_GLOBALS(pcntl)
! 50: static PHP_GINIT_FUNCTION(pcntl);
! 51:
! 52: /* {{{ arginfo */
! 53: ZEND_BEGIN_ARG_INFO(arginfo_pcntl_void, 0)
! 54: ZEND_END_ARG_INFO()
! 55:
! 56: ZEND_BEGIN_ARG_INFO_EX(arginfo_pcntl_waitpid, 0, 0, 2)
! 57: ZEND_ARG_INFO(0, pid)
! 58: ZEND_ARG_INFO(1, status)
! 59: ZEND_ARG_INFO(0, options)
! 60: ZEND_END_ARG_INFO()
! 61:
! 62: ZEND_BEGIN_ARG_INFO_EX(arginfo_pcntl_wait, 0, 0, 1)
! 63: ZEND_ARG_INFO(1, status)
! 64: ZEND_ARG_INFO(0, options)
! 65: ZEND_END_ARG_INFO()
! 66:
! 67: ZEND_BEGIN_ARG_INFO_EX(arginfo_pcntl_signal, 0, 0, 2)
! 68: ZEND_ARG_INFO(0, signo)
! 69: ZEND_ARG_INFO(0, handler)
! 70: ZEND_ARG_INFO(0, restart_syscalls)
! 71: ZEND_END_ARG_INFO()
! 72:
! 73: ZEND_BEGIN_ARG_INFO_EX(arginfo_pcntl_sigprocmask, 0, 0, 2)
! 74: ZEND_ARG_INFO(0, how)
! 75: ZEND_ARG_INFO(0, set)
! 76: ZEND_ARG_INFO(1, oldset)
! 77: ZEND_END_ARG_INFO()
! 78:
! 79: ZEND_BEGIN_ARG_INFO_EX(arginfo_pcntl_sigwaitinfo, 0, 0, 1)
! 80: ZEND_ARG_INFO(0, set)
! 81: ZEND_ARG_INFO(1, info)
! 82: ZEND_END_ARG_INFO()
! 83:
! 84: ZEND_BEGIN_ARG_INFO_EX(arginfo_pcntl_sigtimedwait, 0, 0, 1)
! 85: ZEND_ARG_INFO(0, set)
! 86: ZEND_ARG_INFO(1, info)
! 87: ZEND_ARG_INFO(0, seconds)
! 88: ZEND_ARG_INFO(0, nanoseconds)
! 89: ZEND_END_ARG_INFO()
! 90:
! 91: ZEND_BEGIN_ARG_INFO_EX(arginfo_pcntl_wifexited, 0, 0, 1)
! 92: ZEND_ARG_INFO(0, status)
! 93: ZEND_END_ARG_INFO()
! 94:
! 95: ZEND_BEGIN_ARG_INFO_EX(arginfo_pcntl_wifstopped, 0, 0, 1)
! 96: ZEND_ARG_INFO(0, status)
! 97: ZEND_END_ARG_INFO()
! 98:
! 99: ZEND_BEGIN_ARG_INFO_EX(arginfo_pcntl_wifsignaled, 0, 0, 1)
! 100: ZEND_ARG_INFO(0, status)
! 101: ZEND_END_ARG_INFO()
! 102:
! 103: ZEND_BEGIN_ARG_INFO_EX(arginfo_pcntl_wifexitstatus, 0, 0, 1)
! 104: ZEND_ARG_INFO(0, status)
! 105: ZEND_END_ARG_INFO()
! 106:
! 107: ZEND_BEGIN_ARG_INFO_EX(arginfo_pcntl_wtermsig, 0, 0, 1)
! 108: ZEND_ARG_INFO(0, status)
! 109: ZEND_END_ARG_INFO()
! 110:
! 111: ZEND_BEGIN_ARG_INFO_EX(arginfo_pcntl_wstopsig, 0, 0, 1)
! 112: ZEND_ARG_INFO(0, status)
! 113: ZEND_END_ARG_INFO()
! 114:
! 115: ZEND_BEGIN_ARG_INFO_EX(arginfo_pcntl_exec, 0, 0, 1)
! 116: ZEND_ARG_INFO(0, path)
! 117: ZEND_ARG_INFO(0, args)
! 118: ZEND_ARG_INFO(0, envs)
! 119: ZEND_END_ARG_INFO()
! 120:
! 121: ZEND_BEGIN_ARG_INFO_EX(arginfo_pcntl_alarm, 0, 0, 1)
! 122: ZEND_ARG_INFO(0, seconds)
! 123: ZEND_END_ARG_INFO()
! 124:
! 125: #ifdef HAVE_GETPRIORITY
! 126: ZEND_BEGIN_ARG_INFO_EX(arginfo_pcntl_getpriority, 0, 0, 0)
! 127: ZEND_ARG_INFO(0, pid)
! 128: ZEND_ARG_INFO(0, process_identifier)
! 129: ZEND_END_ARG_INFO()
! 130: #endif
! 131:
! 132: #ifdef HAVE_SETPRIORITY
! 133: ZEND_BEGIN_ARG_INFO_EX(arginfo_pcntl_setpriority, 0, 0, 1)
! 134: ZEND_ARG_INFO(0, priority)
! 135: ZEND_ARG_INFO(0, pid)
! 136: ZEND_ARG_INFO(0, process_identifier)
! 137: ZEND_END_ARG_INFO()
! 138: #endif
! 139:
! 140: ZEND_BEGIN_ARG_INFO_EX(arginfo_pcntl_strerror, 0, 0, 1)
! 141: ZEND_ARG_INFO(0, errno)
! 142: ZEND_END_ARG_INFO()
! 143: /* }}} */
! 144:
! 145: const zend_function_entry pcntl_functions[] = {
! 146: PHP_FE(pcntl_fork, arginfo_pcntl_void)
! 147: PHP_FE(pcntl_waitpid, arginfo_pcntl_waitpid)
! 148: PHP_FE(pcntl_wait, arginfo_pcntl_wait)
! 149: PHP_FE(pcntl_signal, arginfo_pcntl_signal)
! 150: PHP_FE(pcntl_signal_dispatch, arginfo_pcntl_void)
! 151: PHP_FE(pcntl_wifexited, arginfo_pcntl_wifexited)
! 152: PHP_FE(pcntl_wifstopped, arginfo_pcntl_wifstopped)
! 153: PHP_FE(pcntl_wifsignaled, arginfo_pcntl_wifsignaled)
! 154: PHP_FE(pcntl_wexitstatus, arginfo_pcntl_wifexitstatus)
! 155: PHP_FE(pcntl_wtermsig, arginfo_pcntl_wtermsig)
! 156: PHP_FE(pcntl_wstopsig, arginfo_pcntl_wstopsig)
! 157: PHP_FE(pcntl_exec, arginfo_pcntl_exec)
! 158: PHP_FE(pcntl_alarm, arginfo_pcntl_alarm)
! 159: PHP_FE(pcntl_get_last_error, arginfo_pcntl_void)
! 160: PHP_FALIAS(pcntl_errno, pcntl_get_last_error, NULL)
! 161: PHP_FE(pcntl_strerror, arginfo_pcntl_strerror)
! 162: #ifdef HAVE_GETPRIORITY
! 163: PHP_FE(pcntl_getpriority, arginfo_pcntl_getpriority)
! 164: #endif
! 165: #ifdef HAVE_SETPRIORITY
! 166: PHP_FE(pcntl_setpriority, arginfo_pcntl_setpriority)
! 167: #endif
! 168: #ifdef HAVE_SIGPROCMASK
! 169: PHP_FE(pcntl_sigprocmask, arginfo_pcntl_sigprocmask)
! 170: #endif
! 171: #if HAVE_SIGWAITINFO && HAVE_SIGTIMEDWAIT
! 172: PHP_FE(pcntl_sigwaitinfo, arginfo_pcntl_sigwaitinfo)
! 173: PHP_FE(pcntl_sigtimedwait, arginfo_pcntl_sigtimedwait)
! 174: #endif
! 175: PHP_FE_END
! 176: };
! 177:
! 178: zend_module_entry pcntl_module_entry = {
! 179: STANDARD_MODULE_HEADER,
! 180: "pcntl",
! 181: pcntl_functions,
! 182: PHP_MINIT(pcntl),
! 183: PHP_MSHUTDOWN(pcntl),
! 184: PHP_RINIT(pcntl),
! 185: PHP_RSHUTDOWN(pcntl),
! 186: PHP_MINFO(pcntl),
! 187: NO_VERSION_YET,
! 188: PHP_MODULE_GLOBALS(pcntl),
! 189: PHP_GINIT(pcntl),
! 190: NULL,
! 191: NULL,
! 192: STANDARD_MODULE_PROPERTIES_EX
! 193: };
! 194:
! 195: #ifdef COMPILE_DL_PCNTL
! 196: ZEND_GET_MODULE(pcntl)
! 197: #endif
! 198:
! 199: static void pcntl_signal_handler(int);
! 200: static void pcntl_signal_dispatch();
! 201:
! 202: void php_register_signal_constants(INIT_FUNC_ARGS)
! 203: {
! 204:
! 205: /* Wait Constants */
! 206: #ifdef WNOHANG
! 207: REGISTER_LONG_CONSTANT("WNOHANG", (long) WNOHANG, CONST_CS | CONST_PERSISTENT);
! 208: #endif
! 209: #ifdef WUNTRACED
! 210: REGISTER_LONG_CONSTANT("WUNTRACED", (long) WUNTRACED, CONST_CS | CONST_PERSISTENT);
! 211: #endif
! 212:
! 213: /* Signal Constants */
! 214: REGISTER_LONG_CONSTANT("SIG_IGN", (long) SIG_IGN, CONST_CS | CONST_PERSISTENT);
! 215: REGISTER_LONG_CONSTANT("SIG_DFL", (long) SIG_DFL, CONST_CS | CONST_PERSISTENT);
! 216: REGISTER_LONG_CONSTANT("SIG_ERR", (long) SIG_ERR, CONST_CS | CONST_PERSISTENT);
! 217: REGISTER_LONG_CONSTANT("SIGHUP", (long) SIGHUP, CONST_CS | CONST_PERSISTENT);
! 218: REGISTER_LONG_CONSTANT("SIGINT", (long) SIGINT, CONST_CS | CONST_PERSISTENT);
! 219: REGISTER_LONG_CONSTANT("SIGQUIT", (long) SIGQUIT, CONST_CS | CONST_PERSISTENT);
! 220: REGISTER_LONG_CONSTANT("SIGILL", (long) SIGILL, CONST_CS | CONST_PERSISTENT);
! 221: REGISTER_LONG_CONSTANT("SIGTRAP", (long) SIGTRAP, CONST_CS | CONST_PERSISTENT);
! 222: REGISTER_LONG_CONSTANT("SIGABRT", (long) SIGABRT, CONST_CS | CONST_PERSISTENT);
! 223: #ifdef SIGIOT
! 224: REGISTER_LONG_CONSTANT("SIGIOT", (long) SIGIOT, CONST_CS | CONST_PERSISTENT);
! 225: #endif
! 226: REGISTER_LONG_CONSTANT("SIGBUS", (long) SIGBUS, CONST_CS | CONST_PERSISTENT);
! 227: REGISTER_LONG_CONSTANT("SIGFPE", (long) SIGFPE, CONST_CS | CONST_PERSISTENT);
! 228: REGISTER_LONG_CONSTANT("SIGKILL", (long) SIGKILL, CONST_CS | CONST_PERSISTENT);
! 229: REGISTER_LONG_CONSTANT("SIGUSR1", (long) SIGUSR1, CONST_CS | CONST_PERSISTENT);
! 230: REGISTER_LONG_CONSTANT("SIGSEGV", (long) SIGSEGV, CONST_CS | CONST_PERSISTENT);
! 231: REGISTER_LONG_CONSTANT("SIGUSR2", (long) SIGUSR2, CONST_CS | CONST_PERSISTENT);
! 232: REGISTER_LONG_CONSTANT("SIGPIPE", (long) SIGPIPE, CONST_CS | CONST_PERSISTENT);
! 233: REGISTER_LONG_CONSTANT("SIGALRM", (long) SIGALRM, CONST_CS | CONST_PERSISTENT);
! 234: REGISTER_LONG_CONSTANT("SIGTERM", (long) SIGTERM, CONST_CS | CONST_PERSISTENT);
! 235: #ifdef SIGSTKFLT
! 236: REGISTER_LONG_CONSTANT("SIGSTKFLT",(long) SIGSTKFLT, CONST_CS | CONST_PERSISTENT);
! 237: #endif
! 238: #ifdef SIGCLD
! 239: REGISTER_LONG_CONSTANT("SIGCLD", (long) SIGCLD, CONST_CS | CONST_PERSISTENT);
! 240: #endif
! 241: #ifdef SIGCHLD
! 242: REGISTER_LONG_CONSTANT("SIGCHLD", (long) SIGCHLD, CONST_CS | CONST_PERSISTENT);
! 243: #endif
! 244: REGISTER_LONG_CONSTANT("SIGCONT", (long) SIGCONT, CONST_CS | CONST_PERSISTENT);
! 245: REGISTER_LONG_CONSTANT("SIGSTOP", (long) SIGSTOP, CONST_CS | CONST_PERSISTENT);
! 246: REGISTER_LONG_CONSTANT("SIGTSTP", (long) SIGTSTP, CONST_CS | CONST_PERSISTENT);
! 247: REGISTER_LONG_CONSTANT("SIGTTIN", (long) SIGTTIN, CONST_CS | CONST_PERSISTENT);
! 248: REGISTER_LONG_CONSTANT("SIGTTOU", (long) SIGTTOU, CONST_CS | CONST_PERSISTENT);
! 249: REGISTER_LONG_CONSTANT("SIGURG", (long) SIGURG , CONST_CS | CONST_PERSISTENT);
! 250: REGISTER_LONG_CONSTANT("SIGXCPU", (long) SIGXCPU, CONST_CS | CONST_PERSISTENT);
! 251: REGISTER_LONG_CONSTANT("SIGXFSZ", (long) SIGXFSZ, CONST_CS | CONST_PERSISTENT);
! 252: REGISTER_LONG_CONSTANT("SIGVTALRM",(long) SIGVTALRM, CONST_CS | CONST_PERSISTENT);
! 253: REGISTER_LONG_CONSTANT("SIGPROF", (long) SIGPROF, CONST_CS | CONST_PERSISTENT);
! 254: REGISTER_LONG_CONSTANT("SIGWINCH", (long) SIGWINCH, CONST_CS | CONST_PERSISTENT);
! 255: #ifdef SIGPOLL
! 256: REGISTER_LONG_CONSTANT("SIGPOLL", (long) SIGPOLL, CONST_CS | CONST_PERSISTENT);
! 257: #endif
! 258: REGISTER_LONG_CONSTANT("SIGIO", (long) SIGIO, CONST_CS | CONST_PERSISTENT);
! 259: #ifdef SIGPWR
! 260: REGISTER_LONG_CONSTANT("SIGPWR", (long) SIGPWR, CONST_CS | CONST_PERSISTENT);
! 261: #endif
! 262: #ifdef SIGSYS
! 263: REGISTER_LONG_CONSTANT("SIGSYS", (long) SIGSYS, CONST_CS | CONST_PERSISTENT);
! 264: REGISTER_LONG_CONSTANT("SIGBABY", (long) SIGSYS, CONST_CS | CONST_PERSISTENT);
! 265: #endif
! 266:
! 267: #if HAVE_GETPRIORITY || HAVE_SETPRIORITY
! 268: REGISTER_LONG_CONSTANT("PRIO_PGRP", PRIO_PGRP, CONST_CS | CONST_PERSISTENT);
! 269: REGISTER_LONG_CONSTANT("PRIO_USER", PRIO_USER, CONST_CS | CONST_PERSISTENT);
! 270: REGISTER_LONG_CONSTANT("PRIO_PROCESS", PRIO_PROCESS, CONST_CS | CONST_PERSISTENT);
! 271: #endif
! 272:
! 273: /* {{{ "how" argument for sigprocmask */
! 274: #ifdef HAVE_SIGPROCMASK
! 275: REGISTER_LONG_CONSTANT("SIG_BLOCK", SIG_BLOCK, CONST_CS | CONST_PERSISTENT);
! 276: REGISTER_LONG_CONSTANT("SIG_UNBLOCK", SIG_UNBLOCK, CONST_CS | CONST_PERSISTENT);
! 277: REGISTER_LONG_CONSTANT("SIG_SETMASK", SIG_SETMASK, CONST_CS | CONST_PERSISTENT);
! 278: #endif
! 279: /* }}} */
! 280:
! 281: /* {{{ si_code */
! 282: #if HAVE_SIGWAITINFO && HAVE_SIGTIMEDWAIT
! 283: REGISTER_LONG_CONSTANT("SI_USER", SI_USER, CONST_CS | CONST_PERSISTENT);
! 284: #ifdef SI_NOINFO
! 285: REGISTER_LONG_CONSTANT("SI_NOINFO", SI_NOINFO, CONST_CS | CONST_PERSISTENT);
! 286: #endif
! 287: #ifdef SI_KERNEL
! 288: REGISTER_LONG_CONSTANT("SI_KERNEL", SI_KERNEL, CONST_CS | CONST_PERSISTENT);
! 289: #endif
! 290: REGISTER_LONG_CONSTANT("SI_QUEUE", SI_QUEUE, CONST_CS | CONST_PERSISTENT);
! 291: REGISTER_LONG_CONSTANT("SI_TIMER", SI_TIMER, CONST_CS | CONST_PERSISTENT);
! 292: REGISTER_LONG_CONSTANT("SI_MESGQ", SI_MESGQ, CONST_CS | CONST_PERSISTENT);
! 293: REGISTER_LONG_CONSTANT("SI_ASYNCIO", SI_ASYNCIO, CONST_CS | CONST_PERSISTENT);
! 294: #ifdef SI_SIGIO
! 295: REGISTER_LONG_CONSTANT("SI_SIGIO", SI_SIGIO, CONST_CS | CONST_PERSISTENT);
! 296: #endif
! 297: #ifdef SI_TKILL
! 298: REGISTER_LONG_CONSTANT("SI_TKILL", SI_TKILL, CONST_CS | CONST_PERSISTENT);
! 299: #endif
! 300:
! 301: /* si_code for SIGCHILD */
! 302: #ifdef CLD_EXITED
! 303: REGISTER_LONG_CONSTANT("CLD_EXITED", CLD_EXITED, CONST_CS | CONST_PERSISTENT);
! 304: #endif
! 305: #ifdef CLD_KILLED
! 306: REGISTER_LONG_CONSTANT("CLD_KILLED", CLD_KILLED, CONST_CS | CONST_PERSISTENT);
! 307: #endif
! 308: #ifdef CLD_DUMPED
! 309: REGISTER_LONG_CONSTANT("CLD_DUMPED", CLD_DUMPED, CONST_CS | CONST_PERSISTENT);
! 310: #endif
! 311: #ifdef CLD_TRAPPED
! 312: REGISTER_LONG_CONSTANT("CLD_TRAPPED", CLD_TRAPPED, CONST_CS | CONST_PERSISTENT);
! 313: #endif
! 314: #ifdef CLD_STOPPED
! 315: REGISTER_LONG_CONSTANT("CLD_STOPPED", CLD_STOPPED, CONST_CS | CONST_PERSISTENT);
! 316: #endif
! 317: #ifdef CLD_CONTINUED
! 318: REGISTER_LONG_CONSTANT("CLD_CONTINUED", CLD_CONTINUED, CONST_CS | CONST_PERSISTENT);
! 319: #endif
! 320:
! 321: /* si_code for SIGTRAP */
! 322: #ifdef TRAP_BRKPT
! 323: REGISTER_LONG_CONSTANT("TRAP_BRKPT", TRAP_BRKPT, CONST_CS | CONST_PERSISTENT);
! 324: #endif
! 325: #ifdef TRAP_TRACE
! 326: REGISTER_LONG_CONSTANT("TRAP_TRACE", TRAP_TRACE, CONST_CS | CONST_PERSISTENT);
! 327: #endif
! 328:
! 329: /* si_code for SIGPOLL */
! 330: #ifdef POLL_IN
! 331: REGISTER_LONG_CONSTANT("POLL_IN", POLL_IN, CONST_CS | CONST_PERSISTENT);
! 332: #endif
! 333: #ifdef POLL_OUT
! 334: REGISTER_LONG_CONSTANT("POLL_OUT", POLL_OUT, CONST_CS | CONST_PERSISTENT);
! 335: #endif
! 336: #ifdef POLL_MSG
! 337: REGISTER_LONG_CONSTANT("POLL_MSG", POLL_MSG, CONST_CS | CONST_PERSISTENT);
! 338: #endif
! 339: #ifdef POLL_ERR
! 340: REGISTER_LONG_CONSTANT("POLL_ERR", POLL_ERR, CONST_CS | CONST_PERSISTENT);
! 341: #endif
! 342: #ifdef POLL_PRI
! 343: REGISTER_LONG_CONSTANT("POLL_PRI", POLL_PRI, CONST_CS | CONST_PERSISTENT);
! 344: #endif
! 345: #ifdef POLL_HUP
! 346: REGISTER_LONG_CONSTANT("POLL_HUP", POLL_HUP, CONST_CS | CONST_PERSISTENT);
! 347: #endif
! 348:
! 349: #ifdef ILL_ILLOPC
! 350: REGISTER_LONG_CONSTANT("ILL_ILLOPC", ILL_ILLOPC, CONST_CS | CONST_PERSISTENT);
! 351: #endif
! 352: #ifdef ILL_ILLOPN
! 353: REGISTER_LONG_CONSTANT("ILL_ILLOPN", ILL_ILLOPN, CONST_CS | CONST_PERSISTENT);
! 354: #endif
! 355: #ifdef ILL_ILLADR
! 356: REGISTER_LONG_CONSTANT("ILL_ILLADR", ILL_ILLADR, CONST_CS | CONST_PERSISTENT);
! 357: #endif
! 358: #ifdef ILL_ILLTRP
! 359: REGISTER_LONG_CONSTANT("ILL_ILLTRP", ILL_ILLTRP, CONST_CS | CONST_PERSISTENT);
! 360: #endif
! 361: #ifdef ILL_PRVOPC
! 362: REGISTER_LONG_CONSTANT("ILL_PRVOPC", ILL_PRVOPC, CONST_CS | CONST_PERSISTENT);
! 363: #endif
! 364: #ifdef ILL_PRVREG
! 365: REGISTER_LONG_CONSTANT("ILL_PRVREG", ILL_PRVREG, CONST_CS | CONST_PERSISTENT);
! 366: #endif
! 367: #ifdef ILL_COPROC
! 368: REGISTER_LONG_CONSTANT("ILL_COPROC", ILL_COPROC, CONST_CS | CONST_PERSISTENT);
! 369: #endif
! 370: #ifdef ILL_BADSTK
! 371: REGISTER_LONG_CONSTANT("ILL_BADSTK", ILL_BADSTK, CONST_CS | CONST_PERSISTENT);
! 372: #endif
! 373:
! 374: #ifdef FPE_INTDIV
! 375: REGISTER_LONG_CONSTANT("FPE_INTDIV", FPE_INTDIV, CONST_CS | CONST_PERSISTENT);
! 376: #endif
! 377: #ifdef FPE_INTOVF
! 378: REGISTER_LONG_CONSTANT("FPE_INTOVF", FPE_INTOVF, CONST_CS | CONST_PERSISTENT);
! 379: #endif
! 380: #ifdef FPE_FLTDIV
! 381: REGISTER_LONG_CONSTANT("FPE_FLTDIV", FPE_FLTDIV, CONST_CS | CONST_PERSISTENT);
! 382: #endif
! 383: #ifdef FPE_FLTOVF
! 384: REGISTER_LONG_CONSTANT("FPE_FLTOVF", FPE_FLTOVF, CONST_CS | CONST_PERSISTENT);
! 385: #endif
! 386: #ifdef FPE_FLTUND
! 387: REGISTER_LONG_CONSTANT("FPE_FLTUND", FPE_FLTINV, CONST_CS | CONST_PERSISTENT);
! 388: #endif
! 389: #ifdef FPE_FLTRES
! 390: REGISTER_LONG_CONSTANT("FPE_FLTRES", FPE_FLTRES, CONST_CS | CONST_PERSISTENT);
! 391: #endif
! 392: #ifdef FPE_FLTINV
! 393: REGISTER_LONG_CONSTANT("FPE_FLTINV", FPE_FLTINV, CONST_CS | CONST_PERSISTENT);
! 394: #endif
! 395: #ifdef FPE_FLTSUB
! 396: REGISTER_LONG_CONSTANT("FPE_FLTSUB", FPE_FLTSUB, CONST_CS | CONST_PERSISTENT);
! 397: #endif
! 398:
! 399: #ifdef SEGV_MAPERR
! 400: REGISTER_LONG_CONSTANT("SEGV_MAPERR", SEGV_MAPERR, CONST_CS | CONST_PERSISTENT);
! 401: #endif
! 402: #ifdef SEGV_ACCERR
! 403: REGISTER_LONG_CONSTANT("SEGV_ACCERR", SEGV_ACCERR, CONST_CS | CONST_PERSISTENT);
! 404: #endif
! 405:
! 406: #ifdef BUS_ADRALN
! 407: REGISTER_LONG_CONSTANT("BUS_ADRALN", BUS_ADRALN, CONST_CS | CONST_PERSISTENT);
! 408: #endif
! 409: #ifdef BUS_ADRERR
! 410: REGISTER_LONG_CONSTANT("BUS_ADRERR", BUS_ADRERR, CONST_CS | CONST_PERSISTENT);
! 411: #endif
! 412: #ifdef BUS_OBJERR
! 413: REGISTER_LONG_CONSTANT("BUS_OBJERR", BUS_OBJERR, CONST_CS | CONST_PERSISTENT);
! 414: #endif
! 415: #endif /* HAVE_SIGWAITINFO && HAVE_SIGTIMEDWAIT */
! 416: /* }}} */
! 417: }
! 418:
! 419: static void php_pcntl_register_errno_constants(INIT_FUNC_ARGS)
! 420: {
! 421: #ifdef EINTR
! 422: REGISTER_PCNTL_ERRNO_CONSTANT(EINTR);
! 423: #endif
! 424: #ifdef ECHILD
! 425: REGISTER_PCNTL_ERRNO_CONSTANT(ECHILD);
! 426: #endif
! 427: #ifdef EINVAL
! 428: REGISTER_PCNTL_ERRNO_CONSTANT(EINVAL);
! 429: #endif
! 430: #ifdef EAGAIN
! 431: REGISTER_PCNTL_ERRNO_CONSTANT(EAGAIN);
! 432: #endif
! 433: #ifdef ESRCH
! 434: REGISTER_PCNTL_ERRNO_CONSTANT(ESRCH);
! 435: #endif
! 436: #ifdef EACCES
! 437: REGISTER_PCNTL_ERRNO_CONSTANT(EACCES);
! 438: #endif
! 439: #ifdef EPERM
! 440: REGISTER_PCNTL_ERRNO_CONSTANT(EPERM);
! 441: #endif
! 442: #ifdef ENOMEM
! 443: REGISTER_PCNTL_ERRNO_CONSTANT(ENOMEM);
! 444: #endif
! 445: #ifdef E2BIG
! 446: REGISTER_PCNTL_ERRNO_CONSTANT(E2BIG);
! 447: #endif
! 448: #ifdef EFAULT
! 449: REGISTER_PCNTL_ERRNO_CONSTANT(EFAULT);
! 450: #endif
! 451: #ifdef EIO
! 452: REGISTER_PCNTL_ERRNO_CONSTANT(EIO);
! 453: #endif
! 454: #ifdef EISDIR
! 455: REGISTER_PCNTL_ERRNO_CONSTANT(EISDIR);
! 456: #endif
! 457: #ifdef ELIBBAD
! 458: REGISTER_PCNTL_ERRNO_CONSTANT(ELIBBAD);
! 459: #endif
! 460: #ifdef ELOOP
! 461: REGISTER_PCNTL_ERRNO_CONSTANT(ELOOP);
! 462: #endif
! 463: #ifdef EMFILE
! 464: REGISTER_PCNTL_ERRNO_CONSTANT(EMFILE);
! 465: #endif
! 466: #ifdef ENAMETOOLONG
! 467: REGISTER_PCNTL_ERRNO_CONSTANT(ENAMETOOLONG);
! 468: #endif
! 469: #ifdef ENFILE
! 470: REGISTER_PCNTL_ERRNO_CONSTANT(ENFILE);
! 471: #endif
! 472: #ifdef ENOENT
! 473: REGISTER_PCNTL_ERRNO_CONSTANT(ENOENT);
! 474: #endif
! 475: #ifdef ENOEXEC
! 476: REGISTER_PCNTL_ERRNO_CONSTANT(ENOEXEC);
! 477: #endif
! 478: #ifdef ENOTDIR
! 479: REGISTER_PCNTL_ERRNO_CONSTANT(ENOTDIR);
! 480: #endif
! 481: #ifdef ETXTBSY
! 482: REGISTER_PCNTL_ERRNO_CONSTANT(ETXTBSY);
! 483: #endif
! 484: }
! 485:
! 486: static PHP_GINIT_FUNCTION(pcntl)
! 487: {
! 488: memset(pcntl_globals, 0, sizeof(*pcntl_globals));
! 489: }
! 490:
! 491: PHP_RINIT_FUNCTION(pcntl)
! 492: {
! 493: zend_hash_init(&PCNTL_G(php_signal_table), 16, NULL, ZVAL_PTR_DTOR, 0);
! 494: PCNTL_G(head) = PCNTL_G(tail) = PCNTL_G(spares) = NULL;
! 495: return SUCCESS;
! 496: }
! 497:
! 498: PHP_MINIT_FUNCTION(pcntl)
! 499: {
! 500: php_register_signal_constants(INIT_FUNC_ARGS_PASSTHRU);
! 501: php_pcntl_register_errno_constants(INIT_FUNC_ARGS_PASSTHRU);
! 502: php_add_tick_function(pcntl_signal_dispatch);
! 503:
! 504: return SUCCESS;
! 505: }
! 506:
! 507: PHP_MSHUTDOWN_FUNCTION(pcntl)
! 508: {
! 509: return SUCCESS;
! 510: }
! 511:
! 512: PHP_RSHUTDOWN_FUNCTION(pcntl)
! 513: {
! 514: struct php_pcntl_pending_signal *sig;
! 515:
! 516: /* FIXME: if a signal is delivered after this point, things will go pear shaped;
! 517: * need to remove signal handlers */
! 518: zend_hash_destroy(&PCNTL_G(php_signal_table));
! 519: while (PCNTL_G(head)) {
! 520: sig = PCNTL_G(head);
! 521: PCNTL_G(head) = sig->next;
! 522: efree(sig);
! 523: }
! 524: while (PCNTL_G(spares)) {
! 525: sig = PCNTL_G(spares);
! 526: PCNTL_G(spares) = sig->next;
! 527: efree(sig);
! 528: }
! 529: return SUCCESS;
! 530: }
! 531:
! 532: PHP_MINFO_FUNCTION(pcntl)
! 533: {
! 534: php_info_print_table_start();
! 535: php_info_print_table_header(2, "pcntl support", "enabled");
! 536: php_info_print_table_end();
! 537: }
! 538:
! 539: /* {{{ proto int pcntl_fork(void)
! 540: Forks the currently running process following the same behavior as the UNIX fork() system call*/
! 541: PHP_FUNCTION(pcntl_fork)
! 542: {
! 543: pid_t id;
! 544:
! 545: id = fork();
! 546: if (id == -1) {
! 547: PCNTL_G(last_error) = errno;
! 548: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error %d", errno);
! 549: }
! 550:
! 551: RETURN_LONG((long) id);
! 552: }
! 553: /* }}} */
! 554:
! 555: /* {{{ proto int pcntl_alarm(int seconds)
! 556: Set an alarm clock for delivery of a signal*/
! 557: PHP_FUNCTION(pcntl_alarm)
! 558: {
! 559: long seconds;
! 560:
! 561: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &seconds) == FAILURE)
! 562: return;
! 563:
! 564: RETURN_LONG ((long) alarm(seconds));
! 565: }
! 566: /* }}} */
! 567:
! 568: /* {{{ proto int pcntl_waitpid(int pid, int &status, int options)
! 569: Waits on or returns the status of a forked child as defined by the waitpid() system call */
! 570: PHP_FUNCTION(pcntl_waitpid)
! 571: {
! 572: long pid, options = 0;
! 573: zval *z_status = NULL;
! 574: int status;
! 575: pid_t child_id;
! 576:
! 577: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lz|l", &pid, &z_status, &options) == FAILURE)
! 578: return;
! 579:
! 580: convert_to_long_ex(&z_status);
! 581:
! 582: status = Z_LVAL_P(z_status);
! 583:
! 584: child_id = waitpid((pid_t) pid, &status, options);
! 585:
! 586: if (child_id < 0) {
! 587: PCNTL_G(last_error) = errno;
! 588: }
! 589:
! 590: Z_LVAL_P(z_status) = status;
! 591:
! 592: RETURN_LONG((long) child_id);
! 593: }
! 594: /* }}} */
! 595:
! 596: /* {{{ proto int pcntl_wait(int &status)
! 597: Waits on or returns the status of a forked child as defined by the waitpid() system call */
! 598: PHP_FUNCTION(pcntl_wait)
! 599: {
! 600: long options = 0;
! 601: zval *z_status = NULL;
! 602: int status;
! 603: pid_t child_id;
! 604:
! 605: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &z_status, &options) == FAILURE)
! 606: return;
! 607:
! 608: convert_to_long_ex(&z_status);
! 609:
! 610: status = Z_LVAL_P(z_status);
! 611: #ifdef HAVE_WAIT3
! 612: if(options) {
! 613: child_id = wait3(&status, options, NULL);
! 614: }
! 615: else {
! 616: child_id = wait(&status);
! 617: }
! 618: #else
! 619: child_id = wait(&status);
! 620: #endif
! 621: if (child_id < 0) {
! 622: PCNTL_G(last_error) = errno;
! 623: }
! 624:
! 625: Z_LVAL_P(z_status) = status;
! 626:
! 627: RETURN_LONG((long) child_id);
! 628: }
! 629: /* }}} */
! 630:
! 631: /* {{{ proto bool pcntl_wifexited(int status)
! 632: Returns true if the child status code represents a successful exit */
! 633: PHP_FUNCTION(pcntl_wifexited)
! 634: {
! 635: #ifdef WIFEXITED
! 636: long status_word;
! 637:
! 638: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &status_word) == FAILURE) {
! 639: return;
! 640: }
! 641:
! 642: if (WIFEXITED(status_word))
! 643: RETURN_TRUE;
! 644: #endif
! 645: RETURN_FALSE;
! 646: }
! 647: /* }}} */
! 648:
! 649: /* {{{ proto bool pcntl_wifstopped(int status)
! 650: Returns true if the child status code represents a stopped process (WUNTRACED must have been used with waitpid) */
! 651: PHP_FUNCTION(pcntl_wifstopped)
! 652: {
! 653: #ifdef WIFSTOPPED
! 654: long status_word;
! 655:
! 656: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &status_word) == FAILURE) {
! 657: return;
! 658: }
! 659:
! 660: if (WIFSTOPPED(status_word))
! 661: RETURN_TRUE;
! 662: #endif
! 663: RETURN_FALSE;
! 664: }
! 665: /* }}} */
! 666:
! 667: /* {{{ proto bool pcntl_wifsignaled(int status)
! 668: Returns true if the child status code represents a process that was terminated due to a signal */
! 669: PHP_FUNCTION(pcntl_wifsignaled)
! 670: {
! 671: #ifdef WIFSIGNALED
! 672: long status_word;
! 673:
! 674: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &status_word) == FAILURE) {
! 675: return;
! 676: }
! 677:
! 678: if (WIFSIGNALED(status_word))
! 679: RETURN_TRUE;
! 680: #endif
! 681: RETURN_FALSE;
! 682: }
! 683: /* }}} */
! 684:
! 685: /* {{{ proto int pcntl_wexitstatus(int status)
! 686: Returns the status code of a child's exit */
! 687: PHP_FUNCTION(pcntl_wexitstatus)
! 688: {
! 689: #ifdef WEXITSTATUS
! 690: long status_word;
! 691:
! 692: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &status_word) == FAILURE) {
! 693: return;
! 694: }
! 695:
! 696: RETURN_LONG(WEXITSTATUS(status_word));
! 697: #else
! 698: RETURN_FALSE;
! 699: #endif
! 700: }
! 701: /* }}} */
! 702:
! 703: /* {{{ proto int pcntl_wtermsig(int status)
! 704: Returns the number of the signal that terminated the process who's status code is passed */
! 705: PHP_FUNCTION(pcntl_wtermsig)
! 706: {
! 707: #ifdef WTERMSIG
! 708: long status_word;
! 709:
! 710: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &status_word) == FAILURE) {
! 711: return;
! 712: }
! 713:
! 714: RETURN_LONG(WTERMSIG(status_word));
! 715: #else
! 716: RETURN_FALSE;
! 717: #endif
! 718: }
! 719: /* }}} */
! 720:
! 721: /* {{{ proto int pcntl_wstopsig(int status)
! 722: Returns the number of the signal that caused the process to stop who's status code is passed */
! 723: PHP_FUNCTION(pcntl_wstopsig)
! 724: {
! 725: #ifdef WSTOPSIG
! 726: long status_word;
! 727:
! 728: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &status_word) == FAILURE) {
! 729: return;
! 730: }
! 731:
! 732: RETURN_LONG(WSTOPSIG(status_word));
! 733: #else
! 734: RETURN_FALSE;
! 735: #endif
! 736: }
! 737: /* }}} */
! 738:
! 739: /* {{{ proto bool pcntl_exec(string path [, array args [, array envs]])
! 740: Executes specified program in current process space as defined by exec(2) */
! 741: PHP_FUNCTION(pcntl_exec)
! 742: {
! 743: zval *args = NULL, *envs = NULL;
! 744: zval **element;
! 745: HashTable *args_hash, *envs_hash;
! 746: int argc = 0, argi = 0;
! 747: int envc = 0, envi = 0;
! 748: int return_val = 0;
! 749: char **argv = NULL, **envp = NULL;
! 750: char **current_arg, **pair;
! 751: int pair_length;
! 752: char *key;
! 753: uint key_length;
! 754: char *path;
! 755: int path_len;
! 756: ulong key_num;
! 757:
! 758: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|aa", &path, &path_len, &args, &envs) == FAILURE) {
! 759: return;
! 760: }
! 761:
! 762: if (ZEND_NUM_ARGS() > 1) {
! 763: /* Build argumnent list */
! 764: args_hash = HASH_OF(args);
! 765: argc = zend_hash_num_elements(args_hash);
! 766:
! 767: argv = safe_emalloc((argc + 2), sizeof(char *), 0);
! 768: *argv = path;
! 769: for ( zend_hash_internal_pointer_reset(args_hash), current_arg = argv+1;
! 770: (argi < argc && (zend_hash_get_current_data(args_hash, (void **) &element) == SUCCESS));
! 771: (argi++, current_arg++, zend_hash_move_forward(args_hash)) ) {
! 772:
! 773: convert_to_string_ex(element);
! 774: *current_arg = Z_STRVAL_PP(element);
! 775: }
! 776: *(current_arg) = NULL;
! 777: } else {
! 778: argv = emalloc(2 * sizeof(char *));
! 779: *argv = path;
! 780: *(argv+1) = NULL;
! 781: }
! 782:
! 783: if ( ZEND_NUM_ARGS() == 3 ) {
! 784: /* Build environment pair list */
! 785: envs_hash = HASH_OF(envs);
! 786: envc = zend_hash_num_elements(envs_hash);
! 787:
! 788: envp = safe_emalloc((envc + 1), sizeof(char *), 0);
! 789: for ( zend_hash_internal_pointer_reset(envs_hash), pair = envp;
! 790: (envi < envc && (zend_hash_get_current_data(envs_hash, (void **) &element) == SUCCESS));
! 791: (envi++, pair++, zend_hash_move_forward(envs_hash)) ) {
! 792: switch (return_val = zend_hash_get_current_key_ex(envs_hash, &key, &key_length, &key_num, 0, NULL)) {
! 793: case HASH_KEY_IS_LONG:
! 794: key = emalloc(101);
! 795: snprintf(key, 100, "%ld", key_num);
! 796: key_length = strlen(key);
! 797: break;
! 798: case HASH_KEY_NON_EXISTANT:
! 799: pair--;
! 800: continue;
! 801: }
! 802:
! 803: convert_to_string_ex(element);
! 804:
! 805: /* Length of element + equal sign + length of key + null */
! 806: pair_length = Z_STRLEN_PP(element) + key_length + 2;
! 807: *pair = emalloc(pair_length);
! 808: strlcpy(*pair, key, key_length);
! 809: strlcat(*pair, "=", pair_length);
! 810: strlcat(*pair, Z_STRVAL_PP(element), pair_length);
! 811:
! 812: /* Cleanup */
! 813: if (return_val == HASH_KEY_IS_LONG) efree(key);
! 814: }
! 815: *(pair) = NULL;
! 816:
! 817: if (execve(path, argv, envp) == -1) {
! 818: PCNTL_G(last_error) = errno;
! 819: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error has occured: (errno %d) %s", errno, strerror(errno));
! 820: }
! 821:
! 822: /* Cleanup */
! 823: for (pair = envp; *pair != NULL; pair++) efree(*pair);
! 824: efree(envp);
! 825: } else {
! 826:
! 827: if (execv(path, argv) == -1) {
! 828: PCNTL_G(last_error) = errno;
! 829: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error has occured: (errno %d) %s", errno, strerror(errno));
! 830: }
! 831: }
! 832:
! 833: efree(argv);
! 834:
! 835: RETURN_FALSE;
! 836: }
! 837: /* }}} */
! 838:
! 839: /* {{{ proto bool pcntl_signal(int signo, callback handle [, bool restart_syscalls])
! 840: Assigns a system signal handler to a PHP function */
! 841: PHP_FUNCTION(pcntl_signal)
! 842: {
! 843: zval *handle, **dest_handle = NULL;
! 844: char *func_name;
! 845: long signo;
! 846: zend_bool restart_syscalls = 1;
! 847:
! 848: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lz|b", &signo, &handle, &restart_syscalls) == FAILURE) {
! 849: return;
! 850: }
! 851:
! 852: if (!PCNTL_G(spares)) {
! 853: /* since calling malloc() from within a signal handler is not portable,
! 854: * pre-allocate a few records for recording signals */
! 855: int i;
! 856: for (i = 0; i < 32; i++) {
! 857: struct php_pcntl_pending_signal *psig;
! 858:
! 859: psig = emalloc(sizeof(*psig));
! 860: psig->next = PCNTL_G(spares);
! 861: PCNTL_G(spares) = psig;
! 862: }
! 863: }
! 864:
! 865: /* Special long value case for SIG_DFL and SIG_IGN */
! 866: if (Z_TYPE_P(handle)==IS_LONG) {
! 867: if (Z_LVAL_P(handle)!= (long) SIG_DFL && Z_LVAL_P(handle) != (long) SIG_IGN) {
! 868: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid value for handle argument specified");
! 869: }
! 870: if (php_signal(signo, (Sigfunc *) Z_LVAL_P(handle), (int) restart_syscalls) == SIG_ERR) {
! 871: PCNTL_G(last_error) = errno;
! 872: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error assigning signal");
! 873: RETURN_FALSE;
! 874: }
! 875: RETURN_TRUE;
! 876: }
! 877:
! 878: if (!zend_is_callable(handle, 0, &func_name TSRMLS_CC)) {
! 879: PCNTL_G(last_error) = EINVAL;
! 880: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s is not a callable function name error", func_name);
! 881: efree(func_name);
! 882: RETURN_FALSE;
! 883: }
! 884: efree(func_name);
! 885:
! 886: /* Add the function name to our signal table */
! 887: zend_hash_index_update(&PCNTL_G(php_signal_table), signo, (void **) &handle, sizeof(zval *), (void **) &dest_handle);
! 888: if (dest_handle) zval_add_ref(dest_handle);
! 889:
! 890: if (php_signal4(signo, pcntl_signal_handler, (int) restart_syscalls, 1) == SIG_ERR) {
! 891: PCNTL_G(last_error) = errno;
! 892: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error assigning signal");
! 893: RETURN_FALSE;
! 894: }
! 895: RETURN_TRUE;
! 896: }
! 897: /* }}} */
! 898:
! 899: /* {{{ proto bool pcntl_signal_dispatch()
! 900: Dispatch signals to signal handlers */
! 901: PHP_FUNCTION(pcntl_signal_dispatch)
! 902: {
! 903: pcntl_signal_dispatch();
! 904: RETURN_TRUE;
! 905: }
! 906: /* }}} */
! 907:
! 908: #ifdef HAVE_SIGPROCMASK
! 909: /* {{{ proto bool pcntl_sigprocmask(int how, array set[, array &oldset])
! 910: Examine and change blocked signals */
! 911: PHP_FUNCTION(pcntl_sigprocmask)
! 912: {
! 913: long how, signo;
! 914: zval *user_set, *user_oldset = NULL, **user_signo;
! 915: sigset_t set, oldset;
! 916: HashPosition pos;
! 917:
! 918: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la|z", &how, &user_set, &user_oldset) == FAILURE) {
! 919: return;
! 920: }
! 921:
! 922: if (sigemptyset(&set) != 0 || sigemptyset(&oldset) != 0) {
! 923: PCNTL_G(last_error) = errno;
! 924: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
! 925: RETURN_FALSE;
! 926: }
! 927:
! 928: zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(user_set), &pos);
! 929: while (zend_hash_get_current_data_ex(Z_ARRVAL_P(user_set), (void **)&user_signo, &pos) == SUCCESS)
! 930: {
! 931: if (Z_TYPE_PP(user_signo) != IS_LONG) {
! 932: SEPARATE_ZVAL(user_signo);
! 933: convert_to_long_ex(user_signo);
! 934: }
! 935: signo = Z_LVAL_PP(user_signo);
! 936: if (sigaddset(&set, signo) != 0) {
! 937: PCNTL_G(last_error) = errno;
! 938: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
! 939: RETURN_FALSE;
! 940: }
! 941: zend_hash_move_forward_ex(Z_ARRVAL_P(user_set), &pos);
! 942: }
! 943:
! 944: if (sigprocmask(how, &set, &oldset) != 0) {
! 945: PCNTL_G(last_error) = errno;
! 946: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
! 947: RETURN_FALSE;
! 948: }
! 949:
! 950: if (user_oldset != NULL) {
! 951: if (Z_TYPE_P(user_oldset) != IS_ARRAY) {
! 952: zval_dtor(user_oldset);
! 953: array_init(user_oldset);
! 954: } else {
! 955: zend_hash_clean(Z_ARRVAL_P(user_oldset));
! 956: }
! 957: for (signo = 1; signo < MAX(NSIG-1, SIGRTMAX); ++signo) {
! 958: if (sigismember(&oldset, signo) != 1) {
! 959: continue;
! 960: }
! 961: add_next_index_long(user_oldset, signo);
! 962: }
! 963: }
! 964:
! 965: RETURN_TRUE;
! 966: }
! 967: /* }}} */
! 968: #endif
! 969:
! 970: #if HAVE_SIGWAITINFO && HAVE_SIGTIMEDWAIT
! 971: static void pcntl_sigwaitinfo(INTERNAL_FUNCTION_PARAMETERS, int timedwait) /* {{{ */
! 972: {
! 973: zval *user_set, **user_signo, *user_siginfo = NULL;
! 974: long tv_sec = 0, tv_nsec = 0;
! 975: sigset_t set;
! 976: HashPosition pos;
! 977: int signo;
! 978: siginfo_t siginfo;
! 979: struct timespec timeout;
! 980:
! 981: if (timedwait) {
! 982: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|zll", &user_set, &user_siginfo, &tv_sec, &tv_nsec) == FAILURE) {
! 983: return;
! 984: }
! 985: } else {
! 986: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|z", &user_set, &user_siginfo) == FAILURE) {
! 987: return;
! 988: }
! 989: }
! 990:
! 991: if (sigemptyset(&set) != 0) {
! 992: PCNTL_G(last_error) = errno;
! 993: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
! 994: RETURN_FALSE;
! 995: }
! 996:
! 997: zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(user_set), &pos);
! 998: while (zend_hash_get_current_data_ex(Z_ARRVAL_P(user_set), (void **)&user_signo, &pos) == SUCCESS)
! 999: {
! 1000: if (Z_TYPE_PP(user_signo) != IS_LONG) {
! 1001: SEPARATE_ZVAL(user_signo);
! 1002: convert_to_long_ex(user_signo);
! 1003: }
! 1004: signo = Z_LVAL_PP(user_signo);
! 1005: if (sigaddset(&set, signo) != 0) {
! 1006: PCNTL_G(last_error) = errno;
! 1007: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
! 1008: RETURN_FALSE;
! 1009: }
! 1010: zend_hash_move_forward_ex(Z_ARRVAL_P(user_set), &pos);
! 1011: }
! 1012:
! 1013: if (timedwait) {
! 1014: timeout.tv_sec = (time_t) tv_sec;
! 1015: timeout.tv_nsec = tv_nsec;
! 1016: signo = sigtimedwait(&set, &siginfo, &timeout);
! 1017: } else {
! 1018: signo = sigwaitinfo(&set, &siginfo);
! 1019: }
! 1020: if (signo == -1 && errno != EAGAIN) {
! 1021: PCNTL_G(last_error) = errno;
! 1022: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
! 1023: }
! 1024:
! 1025: /*
! 1026: * sigtimedwait and sigwaitinfo can return 0 on success on some
! 1027: * platforms, e.g. NetBSD
! 1028: */
! 1029: if (!signo && siginfo.si_signo) {
! 1030: signo = siginfo.si_signo;
! 1031: }
! 1032:
! 1033: if (signo > 0 && user_siginfo) {
! 1034: if (Z_TYPE_P(user_siginfo) != IS_ARRAY) {
! 1035: zval_dtor(user_siginfo);
! 1036: array_init(user_siginfo);
! 1037: } else {
! 1038: zend_hash_clean(Z_ARRVAL_P(user_siginfo));
! 1039: }
! 1040: add_assoc_long_ex(user_siginfo, "signo", sizeof("signo"), siginfo.si_signo);
! 1041: add_assoc_long_ex(user_siginfo, "errno", sizeof("errno"), siginfo.si_errno);
! 1042: add_assoc_long_ex(user_siginfo, "code", sizeof("code"), siginfo.si_code);
! 1043: switch(signo) {
! 1044: #ifdef SIGCHLD
! 1045: case SIGCHLD:
! 1046: add_assoc_long_ex(user_siginfo, "status", sizeof("status"), siginfo.si_status);
! 1047: # ifdef si_utime
! 1048: add_assoc_double_ex(user_siginfo, "utime", sizeof("utime"), siginfo.si_utime);
! 1049: # endif
! 1050: # ifdef si_stime
! 1051: add_assoc_double_ex(user_siginfo, "stime", sizeof("stime"), siginfo.si_stime);
! 1052: # endif
! 1053: add_assoc_long_ex(user_siginfo, "pid", sizeof("pid"), siginfo.si_pid);
! 1054: add_assoc_long_ex(user_siginfo, "uid", sizeof("uid"), siginfo.si_uid);
! 1055: break;
! 1056: #endif
! 1057: case SIGILL:
! 1058: case SIGFPE:
! 1059: case SIGSEGV:
! 1060: case SIGBUS:
! 1061: add_assoc_double_ex(user_siginfo, "addr", sizeof("addr"), (long)siginfo.si_addr);
! 1062: break;
! 1063: #ifdef SIGPOLL
! 1064: case SIGPOLL:
! 1065: add_assoc_long_ex(user_siginfo, "band", sizeof("band"), siginfo.si_band);
! 1066: # ifdef si_fd
! 1067: add_assoc_long_ex(user_siginfo, "fd", sizeof("fd"), siginfo.si_fd);
! 1068: # endif
! 1069: break;
! 1070: #endif
! 1071: EMPTY_SWITCH_DEFAULT_CASE();
! 1072: }
! 1073: }
! 1074:
! 1075: RETURN_LONG(signo);
! 1076: }
! 1077: /* }}} */
! 1078:
! 1079: /* {{{ proto int pcnlt_sigwaitinfo(array set[, array &siginfo])
! 1080: Synchronously wait for queued signals */
! 1081: PHP_FUNCTION(pcntl_sigwaitinfo)
! 1082: {
! 1083: pcntl_sigwaitinfo(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
! 1084: }
! 1085: /* }}} */
! 1086:
! 1087: /* {{{ proto int pcntl_sigtimedwait(array set[, array &siginfo[, int seconds[, int nanoseconds]]])
! 1088: Wait for queued signals */
! 1089: PHP_FUNCTION(pcntl_sigtimedwait)
! 1090: {
! 1091: pcntl_sigwaitinfo(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
! 1092: }
! 1093: /* }}} */
! 1094: #endif
! 1095:
! 1096: #ifdef HAVE_GETPRIORITY
! 1097: /* {{{ proto int pcntl_getpriority([int pid [, int process_identifier]])
! 1098: Get the priority of any process */
! 1099: PHP_FUNCTION(pcntl_getpriority)
! 1100: {
! 1101: long who = PRIO_PROCESS;
! 1102: long pid = getpid();
! 1103: int pri;
! 1104:
! 1105: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &pid, &who) == FAILURE) {
! 1106: RETURN_FALSE;
! 1107: }
! 1108:
! 1109: /* needs to be cleared, since any returned value is valid */
! 1110: errno = 0;
! 1111:
! 1112: pri = getpriority(who, pid);
! 1113:
! 1114: if (errno) {
! 1115: PCNTL_G(last_error) = errno;
! 1116: switch (errno) {
! 1117: case ESRCH:
! 1118: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error %d: No process was located using the given parameters", errno);
! 1119: break;
! 1120: case EINVAL:
! 1121: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error %d: Invalid identifier flag", errno);
! 1122: break;
! 1123: default:
! 1124: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown error %d has occured", errno);
! 1125: break;
! 1126: }
! 1127: RETURN_FALSE;
! 1128: }
! 1129:
! 1130: RETURN_LONG(pri);
! 1131: }
! 1132: /* }}} */
! 1133: #endif
! 1134:
! 1135: #ifdef HAVE_SETPRIORITY
! 1136: /* {{{ proto bool pcntl_setpriority(int priority [, int pid [, int process_identifier]])
! 1137: Change the priority of any process */
! 1138: PHP_FUNCTION(pcntl_setpriority)
! 1139: {
! 1140: long who = PRIO_PROCESS;
! 1141: long pid = getpid();
! 1142: long pri;
! 1143:
! 1144: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|ll", &pri, &pid, &who) == FAILURE) {
! 1145: RETURN_FALSE;
! 1146: }
! 1147:
! 1148: if (setpriority(who, pid, pri)) {
! 1149: PCNTL_G(last_error) = errno;
! 1150: switch (errno) {
! 1151: case ESRCH:
! 1152: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error %d: No process was located using the given parameters", errno);
! 1153: break;
! 1154: case EINVAL:
! 1155: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error %d: Invalid identifier flag", errno);
! 1156: break;
! 1157: case EPERM:
! 1158: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error %d: A process was located, but neither its effective nor real user ID matched the effective user ID of the caller", errno);
! 1159: break;
! 1160: case EACCES:
! 1161: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error %d: Only a super user may attempt to increase the process priority", errno);
! 1162: break;
! 1163: default:
! 1164: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown error %d has occured", errno);
! 1165: break;
! 1166: }
! 1167: RETURN_FALSE;
! 1168: }
! 1169:
! 1170: RETURN_TRUE;
! 1171: }
! 1172: /* }}} */
! 1173: #endif
! 1174:
! 1175: /* {{{ proto int pcntl_get_last_error(void)
! 1176: Retrieve the error number set by the last pcntl function which failed. */
! 1177: PHP_FUNCTION(pcntl_get_last_error)
! 1178: {
! 1179: RETURN_LONG(PCNTL_G(last_error));
! 1180: }
! 1181: /* }}} */
! 1182:
! 1183: /* {{{ proto string pcntl_strerror(int errno)
! 1184: Retrieve the system error message associated with the given errno. */
! 1185: PHP_FUNCTION(pcntl_strerror)
! 1186: {
! 1187: long error;
! 1188:
! 1189: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &error) == FAILURE) {
! 1190: RETURN_FALSE;
! 1191: }
! 1192:
! 1193: RETURN_STRING(strerror(error), 1);
! 1194: }
! 1195: /* }}} */
! 1196:
! 1197: /* Our custom signal handler that calls the appropriate php_function */
! 1198: static void pcntl_signal_handler(int signo)
! 1199: {
! 1200: struct php_pcntl_pending_signal *psig;
! 1201: TSRMLS_FETCH();
! 1202:
! 1203: psig = PCNTL_G(spares);
! 1204: if (!psig) {
! 1205: /* oops, too many signals for us to track, so we'll forget about this one */
! 1206: return;
! 1207: }
! 1208: PCNTL_G(spares) = psig->next;
! 1209:
! 1210: psig->signo = signo;
! 1211: psig->next = NULL;
! 1212:
! 1213: /* the head check is important, as the tick handler cannot atomically clear both
! 1214: * the head and tail */
! 1215: if (PCNTL_G(head) && PCNTL_G(tail)) {
! 1216: PCNTL_G(tail)->next = psig;
! 1217: } else {
! 1218: PCNTL_G(head) = psig;
! 1219: }
! 1220: PCNTL_G(tail) = psig;
! 1221: }
! 1222:
! 1223: void pcntl_signal_dispatch()
! 1224: {
! 1225: zval *param, **handle, *retval;
! 1226: struct php_pcntl_pending_signal *queue, *next;
! 1227: sigset_t mask;
! 1228: sigset_t old_mask;
! 1229: TSRMLS_FETCH();
! 1230:
! 1231: /* Mask all signals */
! 1232: sigfillset(&mask);
! 1233: sigprocmask(SIG_BLOCK, &mask, &old_mask);
! 1234:
! 1235: /* Bail if the queue is empty or if we are already playing the queue*/
! 1236: if (! PCNTL_G(head) || PCNTL_G(processing_signal_queue)) {
! 1237: sigprocmask(SIG_SETMASK, &old_mask, NULL);
! 1238: return;
! 1239: }
! 1240:
! 1241: /* Prevent reentrant handler calls */
! 1242: PCNTL_G(processing_signal_queue) = 1;
! 1243:
! 1244: queue = PCNTL_G(head);
! 1245: PCNTL_G(head) = NULL; /* simple stores are atomic */
! 1246:
! 1247: /* Allocate */
! 1248:
! 1249: while (queue) {
! 1250: if (zend_hash_index_find(&PCNTL_G(php_signal_table), queue->signo, (void **) &handle)==SUCCESS) {
! 1251: MAKE_STD_ZVAL(retval);
! 1252: MAKE_STD_ZVAL(param);
! 1253: ZVAL_NULL(retval);
! 1254: ZVAL_LONG(param, queue->signo);
! 1255:
! 1256: /* Call php signal handler - Note that we do not report errors, and we ignore the return value */
! 1257: /* FIXME: this is probably broken when multiple signals are handled in this while loop (retval) */
! 1258: call_user_function(EG(function_table), NULL, *handle, retval, 1, ¶m TSRMLS_CC);
! 1259: zval_ptr_dtor(¶m);
! 1260: zval_ptr_dtor(&retval);
! 1261: }
! 1262:
! 1263: next = queue->next;
! 1264: queue->next = PCNTL_G(spares);
! 1265: PCNTL_G(spares) = queue;
! 1266: queue = next;
! 1267: }
! 1268:
! 1269: /* Re-enable queue */
! 1270: PCNTL_G(processing_signal_queue) = 0;
! 1271:
! 1272: /* return signal mask to previous state */
! 1273: sigprocmask(SIG_SETMASK, &old_mask, NULL);
! 1274: }
! 1275:
! 1276:
! 1277:
! 1278: /*
! 1279: * Local variables:
! 1280: * tab-width: 4
! 1281: * c-basic-offset: 4
! 1282: * indent-tabs-mode: t
! 1283: * End:
! 1284: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pcntl.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / pcntl