Issues in Generic.php (master) - Issues in master - kakserpom/phpdaemon - Measure and Improve Code Quality continuously with Scrutinizer

Issues (1507)

Security Analysis not enabled

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Header Injection

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

PHPDaemon/Thread/Generic.php (6 issues)

Labels

Severity

Minor 6

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php
namespace PHPDaemon\Thread;

use PHPDaemon\Core\EventLoop;
use PHPDaemon\Exceptions\ClearStack;

/**
 * Thread
 *
 * @package Core
 *
 * @author  Vasily Zorin <[email protected]>
 */
abstract class Generic
{
    use \PHPDaemon\Traits\ClassWatchdog;
    use \PHPDaemon\Traits\StaticObjectWatchdog;

    /**
     * Hash of known signal [no => name, ...]
     * @var array
     */
    public static $signals = [
        SIGHUP => 'SIGHUP',
        SIGSYS => 'SIGSYS',
        SIGPIPE => 'SIGPIPE',
        SIGALRM => 'SIGALRM',
        SIGTERM => 'SIGTERM',
        SIGSTOP => 'SIGSTOP',
        SIGINT => 'SIGINT',
        SIGCHLD => 'SIGCHLD',
        SIGTTIN => 'SIGTTIN',
        SIGTTOU => 'SIGTTOU',
        SIGIO => 'SIGIO',
        SIGXCPU => 'SIGXCPU',
        SIGXFSZ => 'SIGXFSZ',
        SIGVTALRM => 'SIGVTALRM',
        SIGPROF => 'SIGPROF',
        SIGWINCH => 'SIGWINCH',
        SIGUSR1 => 'SIGUSR1',
        SIGUSR2 => 'SIGUSR2',
        SIGTSTP => 'SIGTSTP',
    ];
    /**
     * Process identificator
     * @var int
     */
    public $id;
    /**
     * PID
     * @var int
     */
    protected $pid;
    /**
     * Is this thread shutdown?
     * @var boolean
     */
    protected $shutdown = false;
    /**
     * Is this thread terminated?
     * @var boolean
     */
    protected $terminated = false;
    /**
     * Collections of childrens
     * @var array|Collection[]
     */
    protected $collections = [];
    /**
     * Storage of signal handler events
     * @var array
     */
    protected $sigEvents = [];
    /**
     * If true, we do not register signals automatically at start
     * @var boolean
     */
    protected $delayedSigReg = false;

    /**
     * Checks if given process ID does exist
     * @static
     * @param integer PID
     * @param integer $pid
     * @return boolean Success
     */
    public static function ifExistsByPid($pid)
    {
        return \posix_kill($pid, 0);
    }

    /**
     * Get PID of this Thread
     * @return integer
     */
    public function getPid()
    {
        return $this->pid;
    }

    /**
     * Get ID of this Thread
     * @return integer
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * Set ID of this Thread
     * @param integer Id
     * @return void
     */
    public function setId($id)
    {
        $this->id = $id;
    }

    /**
     * Is this thread terminated?
     * @return boolean
     */
    public function isTerminated()
    {
        return $this->terminated;
    }

    public function setTerminated()
    {
        $this->terminated = true;
        $this->onTerminated();
    }

    protected function onTerminated()
    {
    }

    /**
     * Invoke magic method
     * @return void
     */

    public function __invoke()
    {
        $this->run();
        $this->shutdown();
    }

    /**
     * Run thread process
     * @return void
     */
    protected function run()
    {
    }

    /**
     * Shutdowns the current process properly
     * @return void
     */
    protected function shutdown()
    {
        \posix_kill(\posix_getppid(), SIGCHLD);
        exit(0);
    }

    /**
     * Called when a signal caught through libevent.
     * @param integer Signal's number.
     * @param integer Events.
     * @param mixed   Argument.
     * @return void
     */
    public function eventSighandler($fd, $arg)
    {
        $this->sighandler($arg[0]);
    }

    /**
     * Called when the signal is caught
     * @param integer Signal's number
     * @return void
     */
    public function sighandler($signo)
    {
        if (!isset(self::$signals[$signo])) {
            $this->log('caught unknown signal #' . $signo);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            return;
        }
        if (method_exists($this, $m = strtolower(self::$signals[$signo]))) {
            $this->$m();
        } elseif (method_exists($this, 'sigunknown')) {
            $this->sigunknown($signo);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        }
    }

    /**
     * Starts the process
     * @return void
     */
    public function start($clearstack = true)
    {
        $pid = \pcntl_fork();

        if ($pid === -1) {
            throw new \Exception('Could not fork');
        } elseif ($pid === 0) { // we are the child
            $thread = $this;
            $thread->pid = \posix_getpid();
            if (!$thread->delayedSigReg) {
                $thread->registerSignals();
            }
            if ($clearstack) {
                throw new ClearStack('', 0, $thread);
            } else {
                $thread->run();
                $thread->shutdown();
            }
        } else { // we are the master
            $this->pid = $pid;
        }
    }

    /**
     * Registers signals
     * @return void
     */
    protected function registerSignals()
    {
        foreach (self::$signals as $no => $name) {
            if (($name === 'SIGKILL') || ($name == 'SIGSTOP')) {
                continue;
            }

            if (!\pcntl_signal($no, [$this, 'sighandler'], true)) {
                $this->log('Cannot assign ' . $name . ' signal');
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            }
        }
    }

    /**
     * Delays the process execution for the given number of seconds
     * @param integer Sleep time in seconds
     * @return boolean Success
     */
    public function sleep($s)
    {
        static $interval = 0.2;
        $n = $s / $interval;

        for ($i = 0; $i < $n; ++$i) {
            if ($this->shutdown) {
                return false;
            }

            \usleep($interval * 1000000);
        }

        return true;
    }

    /**
     * Terminates the process
     * @param boolean Kill?
     * @return void
     */
    public function stop($kill = false)
    {
        $this->shutdown = true;
        \posix_kill($this->pid, $kill ? SIGKILL : SIGTERM);
    }

    /**
     * Sends arbitrary signal to the process
     * @param integer Signal's number
     * @return boolean Success
     */
    public function signal($sig)
    {
        return \posix_kill($this->pid, $sig);
    }

    /**
     * Checks if this process does exist
     * @return boolean Success
     */
    public function ifExists()
    {
        return \posix_kill($this->pid, 0);
    }

    /**
     * Register signals.
     * @return void
     */
    protected function registerEventSignals()
    {
        if (!EventLoop::$instance) {
            return;
        }
        foreach (self::$signals as $no => $name) {
            if ($name === 'SIGKILL' || $name == 'SIGSTOP') {
                continue;
            }

            $ev = EventLoop::$instance->signal($no, [$this, 'eventSighandler'], [$no]);
            if (!$ev) {
                $this->log('Cannot event_set for ' . $name . ' signal');
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            }
            $ev->add();
            $this->sigEvents[$no] = $ev;
        }
    }

    /**
     * Unregister signals.
     * @return void
     */
    protected function unregisterSignals()
    {
        foreach ($this->sigEvents as $no => $ev) {
            $ev->free();
            unset($this->sigEvents[$no]);
        }
    }

    /**
     * Sends the signal to parent process
     * @param integer Signal's number
     * @return boolean Success
     */
    protected function backsig($sig)
    {
        return \posix_kill(\posix_getppid(), $sig);
    }

    /**
     * Called when the signal SIGCHLD caught
     * @return void
     */
    protected function sigchld()
    {
        $this->waitPid();
    }

    /**
     * Checks for SIGCHLD
     * @return boolean Success
     */
    protected function waitPid()
    {
        start:
        $pid = \pcntl_waitpid(-1, $status, WNOHANG);
        if ($pid > 0) {
            foreach ($this->collections as $col) {
                foreach ($col->threads as $k => $t) {
                    if ($t->pid === $pid) {
                        $t->setTerminated();
                        unset($col->threads[$k]);
                        goto start;
                    }
                }
            }
        }

        return false;
    }

    /**
     * Called when the signal SIGTERM caught
     * @return void
     */
    protected function sigterm()
    {
        exit(0);
    }

    /**
     * Called when the signal SIGINT caught
     * @return void
     */
    protected function sigint()
    {
        exit(0);
    }

    /**
     * Called when the signal SIGTERM caught
     * @return void
     */
    protected function sigquit()
    {
        $this->shutdown = true;
    }

    /**
     * Called when the signal SIGKILL caught
     * @return void
     */
    protected function sigkill()
    {
        exit(0);
    }

    /**
     * Wait until all processes are terminated
     * @return void
     */
    protected function waitAll()
    {
        do {
            $n = 0;

            foreach ($this->collections as &$col) {
                $n += $col->removeTerminated();
            }
            if (!$this->waitPid()) {
                $this->sigwait(0, 20000);
            }
        } while ($n > 0);
    }

    /**
     * Waits for signals, with a timeout
     * @param int Seconds
     * @param int Nanoseconds
     * @return boolean Success
     */
    protected function sigwait($sec = 0, $nano = 0.3e9)
    {
        $siginfo = null;

        if (!function_exists('pcntl_sigtimedwait')) {
            $signo = $this->sigtimedwait(array_keys(static::$signals), $siginfo, $sec, $nano);
        } else {
            $signo = @\pcntl_sigtimedwait(array_keys(static::$signals), $siginfo, $sec, $nano);
        }

        if (is_bool($signo)) {
            return $signo;
        }

        if ($signo > 0) {
            $this->sighandler($signo);

            return true;
        }

        return false;
    }

    /**
     * Implementation of pcntl_sigtimedwait for Mac.
     *
     * @param array Signal
     * @param null|array SigInfo
     * @param int Seconds
     * @param int Nanoseconds
     * @param integer $sec
     * @param double $nano
     * @return boolean Success
     */
    protected function sigtimedwait($signals, $siginfo, $sec, $nano)

    {
        \pcntl_signal_dispatch();
        if (\time_nanosleep($sec, $nano) === true) {
            return false;
        }
        \pcntl_signal_dispatch();
        return true;
    }

    /**
     * Sets a title of the current process
     *
     * @param string $title
     * @return boolean Success
     */
    protected function setTitle($title)
    {
        return cli_set_process_title($title);
    }

    /**
     * Returns a title of the current process
     *
     * @return string
     */
    protected function getTitle()
    {
        return cli_get_process_title();
    }
}


1			<?php
2			namespace PHPDaemon\Thread;
3
4			use PHPDaemon\Core\EventLoop;
5			use PHPDaemon\Exceptions\ClearStack;
6
7			/**
8			* Thread
9			*
10			* @package Core
11			*
12			* @author Vasily Zorin <[email protected]>
13			*/
14			abstract class Generic
15			{
16			use \PHPDaemon\Traits\ClassWatchdog;
17			use \PHPDaemon\Traits\StaticObjectWatchdog;
18
19			/**
20			* Hash of known signal [no => name, ...]
21			* @var array
22			*/
23			public static $signals = [
24			SIGHUP => 'SIGHUP',
25			SIGSYS => 'SIGSYS',
26			SIGPIPE => 'SIGPIPE',
27			SIGALRM => 'SIGALRM',
28			SIGTERM => 'SIGTERM',
29			SIGSTOP => 'SIGSTOP',
30			SIGINT => 'SIGINT',
31			SIGCHLD => 'SIGCHLD',
32			SIGTTIN => 'SIGTTIN',
33			SIGTTOU => 'SIGTTOU',
34			SIGIO => 'SIGIO',
35			SIGXCPU => 'SIGXCPU',
36			SIGXFSZ => 'SIGXFSZ',
37			SIGVTALRM => 'SIGVTALRM',
38			SIGPROF => 'SIGPROF',
39			SIGWINCH => 'SIGWINCH',
40			SIGUSR1 => 'SIGUSR1',
41			SIGUSR2 => 'SIGUSR2',
42			SIGTSTP => 'SIGTSTP',
43			];
44			/**
45			* Process identificator
46			* @var int
47			*/
48			public $id;
49			/**
50			* PID
51			* @var int
52			*/
53			protected $pid;
54			/**
55			* Is this thread shutdown?
56			* @var boolean
57			*/
58			protected $shutdown = false;
59			/**
60			* Is this thread terminated?
61			* @var boolean
62			*/
63			protected $terminated = false;
64			/**
65			* Collections of childrens
66			* @var array\|Collection[]
67			*/
68			protected $collections = [];
69			/**
70			* Storage of signal handler events
71			* @var array
72			*/
73			protected $sigEvents = [];
74			/**
75			* If true, we do not register signals automatically at start
76			* @var boolean
77			*/
78			protected $delayedSigReg = false;
79
80			/**
81			* Checks if given process ID does exist
82			* @static
83			* @param integer PID
84			* @param integer $pid
85			* @return boolean Success
86			*/
87			public static function ifExistsByPid($pid)
88			{
89			return \posix_kill($pid, 0);
90			}
91
92			/**
93			* Get PID of this Thread
94			* @return integer
95			*/
96			public function getPid()
97			{
98			return $this->pid;
99			}
100
101			/**
102			* Get ID of this Thread
103			* @return integer
104			*/
105			public function getId()
106			{
107			return $this->id;
108			}
109
110			/**
111			* Set ID of this Thread
112			* @param integer Id
113			* @return void
114			*/
115			public function setId($id)
116			{
117			$this->id = $id;
118			}
119
120			/**
121			* Is this thread terminated?
122			* @return boolean
123			*/
124			public function isTerminated()
125			{
126			return $this->terminated;
127			}
128
129			public function setTerminated()
130			{
131			$this->terminated = true;
132			$this->onTerminated();
133			}
134
135			protected function onTerminated()
136			{
137			}
138
139			/**
140			* Invoke magic method
141			* @return void
142			*/
143
144			public function __invoke()
145			{
146			$this->run();
147			$this->shutdown();
148			}
149
150			/**
151			* Run thread process
152			* @return void
153			*/
154			protected function run()
155			{
156			}
157
158			/**
159			* Shutdowns the current process properly
160			* @return void
161			*/
162			protected function shutdown()
163			{
164			\posix_kill(\posix_getppid(), SIGCHLD);
165			exit(0);
166			}
167
168			/**
169			* Called when a signal caught through libevent.
170			* @param integer Signal's number.
171			* @param integer Events.
172			* @param mixed Argument.
173			* @return void
174			*/
175			public function eventSighandler($fd, $arg)
176			{
177			$this->sighandler($arg[0]);
178			}
179
180			/**
181			* Called when the signal is caught
182			* @param integer Signal's number
183			* @return void
184			*/
185			public function sighandler($signo)
186			{
187			if (!isset(self::$signals[$signo])) {
188			$this->log('caught unknown signal #' . $signo);
			0 ignored issues – show Documentation Bug introduced 2015-12-06 14:42 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `log` does not exist on `object<PHPDaemon\Thread\Generic>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
189			return;
190			}
191			if (method_exists($this, $m = strtolower(self::$signals[$signo]))) {
192			$this->$m();
193			} elseif (method_exists($this, 'sigunknown')) {
194			$this->sigunknown($signo);
			0 ignored issues – show Documentation Bug introduced 2016-03-02 14:58 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `sigunknown` does not exist on `object<PHPDaemon\Thread\Generic>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
195			}
196			}
197
198			/**
199			* Starts the process
200			* @return void
201			*/
202			public function start($clearstack = true)
203			{
204			$pid = \pcntl_fork();
205
206			if ($pid === -1) {
207			throw new \Exception('Could not fork');
208			} elseif ($pid === 0) { // we are the child
209			$thread = $this;
210			$thread->pid = \posix_getpid();
211			if (!$thread->delayedSigReg) {
212			$thread->registerSignals();
213			}
214			if ($clearstack) {
215			throw new ClearStack('', 0, $thread);
216			} else {
217			$thread->run();
218			$thread->shutdown();
219			}
220			} else { // we are the master
221			$this->pid = $pid;
222			}
223			}
224
225			/**
226			* Registers signals
227			* @return void
228			*/
229			protected function registerSignals()
230			{
231			foreach (self::$signals as $no => $name) {
232			if (($name === 'SIGKILL') \|\| ($name == 'SIGSTOP')) {
233			continue;
234			}
235
236			if (!\pcntl_signal($no, [$this, 'sighandler'], true)) {
237			$this->log('Cannot assign ' . $name . ' signal');
			0 ignored issues – show Documentation Bug introduced 2015-12-06 14:42 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `log` does not exist on `object<PHPDaemon\Thread\Generic>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
238			}
239			}
240			}
241
242			/**
243			* Delays the process execution for the given number of seconds
244			* @param integer Sleep time in seconds
245			* @return boolean Success
246			*/
247			public function sleep($s)
248			{
249			static $interval = 0.2;
250			$n = $s / $interval;
251
252			for ($i = 0; $i < $n; ++$i) {
253			if ($this->shutdown) {
254			return false;
255			}
256
257			\usleep($interval * 1000000);
258			}
259
260			return true;
261			}
262
263			/**
264			* Terminates the process
265			* @param boolean Kill?
266			* @return void
267			*/
268			public function stop($kill = false)
269			{
270			$this->shutdown = true;
271			\posix_kill($this->pid, $kill ? SIGKILL : SIGTERM);
272			}
273
274			/**
275			* Sends arbitrary signal to the process
276			* @param integer Signal's number
277			* @return boolean Success
278			*/
279			public function signal($sig)
280			{
281			return \posix_kill($this->pid, $sig);
282			}
283
284			/**
285			* Checks if this process does exist
286			* @return boolean Success
287			*/
288			public function ifExists()
289			{
290			return \posix_kill($this->pid, 0);
291			}
292
293			/**
294			* Register signals.
295			* @return void
296			*/
297			protected function registerEventSignals()
298			{
299			if (!EventLoop::$instance) {
300			return;
301			}
302			foreach (self::$signals as $no => $name) {
303			if ($name === 'SIGKILL' \|\| $name == 'SIGSTOP') {
304			continue;
305			}
306
307			$ev = EventLoop::$instance->signal($no, [$this, 'eventSighandler'], [$no]);
308			if (!$ev) {
309			$this->log('Cannot event_set for ' . $name . ' signal');
			0 ignored issues – show Documentation Bug introduced 2015-12-06 14:42 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `log` does not exist on `object<PHPDaemon\Thread\Generic>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
310			}
311			$ev->add();
312			$this->sigEvents[$no] = $ev;
313			}
314			}
315
316			/**
317			* Unregister signals.
318			* @return void
319			*/
320			protected function unregisterSignals()
321			{
322			foreach ($this->sigEvents as $no => $ev) {
323			$ev->free();
324			unset($this->sigEvents[$no]);
325			}
326			}
327
328			/**
329			* Sends the signal to parent process
330			* @param integer Signal's number
331			* @return boolean Success
332			*/
333			protected function backsig($sig)
334			{
335			return \posix_kill(\posix_getppid(), $sig);
336			}
337
338			/**
339			* Called when the signal SIGCHLD caught
340			* @return void
341			*/
342			protected function sigchld()
343			{
344			$this->waitPid();
345			}
346
347			/**
348			* Checks for SIGCHLD
349			* @return boolean Success
350			*/
351			protected function waitPid()
352			{
353			start:
354			$pid = \pcntl_waitpid(-1, $status, WNOHANG);
355			if ($pid > 0) {
356			foreach ($this->collections as $col) {
357			foreach ($col->threads as $k => $t) {
358			if ($t->pid === $pid) {
359			$t->setTerminated();
360			unset($col->threads[$k]);
361			goto start;
362			}
363			}
364			}
365			}
366
367			return false;
368			}
369
370			/**
371			* Called when the signal SIGTERM caught
372			* @return void
373			*/
374			protected function sigterm()
375			{
376			exit(0);
377			}
378
379			/**
380			* Called when the signal SIGINT caught
381			* @return void
382			*/
383			protected function sigint()
384			{
385			exit(0);
386			}
387
388			/**
389			* Called when the signal SIGTERM caught
390			* @return void
391			*/
392			protected function sigquit()
393			{
394			$this->shutdown = true;
395			}
396
397			/**
398			* Called when the signal SIGKILL caught
399			* @return void
400			*/
401			protected function sigkill()
402			{
403			exit(0);
404			}
405
406			/**
407			* Wait until all processes are terminated
408			* @return void
409			*/
410			protected function waitAll()
411			{
412			do {
413			$n = 0;
414
415			foreach ($this->collections as &$col) {
416			$n += $col->removeTerminated();
417			}
418			if (!$this->waitPid()) {
419			$this->sigwait(0, 20000);
420			}
421			} while ($n > 0);
422			}
423
424			/**
425			* Waits for signals, with a timeout
426			* @param int Seconds
427			* @param int Nanoseconds
428			* @return boolean Success
429			*/
430			protected function sigwait($sec = 0, $nano = 0.3e9)
431			{
432			$siginfo = null;
433
434			if (!function_exists('pcntl_sigtimedwait')) {
435			$signo = $this->sigtimedwait(array_keys(static::$signals), $siginfo, $sec, $nano);
436			} else {
437			$signo = @\pcntl_sigtimedwait(array_keys(static::$signals), $siginfo, $sec, $nano);
438			}
439
440			if (is_bool($signo)) {
441			return $signo;
442			}
443
444			if ($signo > 0) {
445			$this->sighandler($signo);
446
447			return true;
448			}
449
450			return false;
451			}
452
453			/**
454			* Implementation of pcntl_sigtimedwait for Mac.
455			*
456			* @param array Signal
457			* @param null\|array SigInfo
458			* @param int Seconds
459			* @param int Nanoseconds
460			* @param integer $sec
461			* @param double $nano
462			* @return boolean Success
463			*/
464			protected function sigtimedwait($signals, $siginfo, $sec, $nano)
			0 ignored issues – show Unused Code introduced 2018-01-16 22:41 UTC by Report Bug Copy Issue Report Show Similar Issues like this The parameter `$signals` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2018-01-16 22:41 UTC by Report Bug Copy Issue Report Show Similar Issues like this The parameter `$siginfo` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
465			{
466			\pcntl_signal_dispatch();
467			if (\time_nanosleep($sec, $nano) === true) {
468			return false;
469			}
470			\pcntl_signal_dispatch();
471			return true;
472			}
473
474			/**
475			* Sets a title of the current process
476			*
477			* @param string $title
478			* @return boolean Success
479			*/
480			protected function setTitle($title)
481			{
482			return cli_set_process_title($title);
483			}
484
485			/**
486			* Returns a title of the current process
487			*
488			* @return string
489			*/
490			protected function getTitle()
491			{
492			return cli_get_process_title();
493			}
494			}
495

kakserpom / phpdaemon

Issues (1507)

Security Analysis not enabled

PHPDaemon/Thread/Generic.php (6 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like