posix_kill - PHP code example

The Function POSIX_Kill() in PHP

The POSIX extension provides a number of functions that enable you to retrieve information about the effective and real user IDs of a process (this article will focus on the user-related ones). It also gives you the ability to send signals to processes (although you should be aware that the signals are not sent in the same order as they appear in the system, so SIGTERM may not always be received by the program you're killing if you use this technique; this depends on which platform you are using PHP on).

The function posix_kill() is part of the POSIX library that enables you to manage processes within your PHP script. It's crucial for allowing you to control the execution flow of your code and, as such, it's worth familiarizing yourself with it.

As far as signals are concerned, I should point out that if you kill a process with this function, it will send signal number 15 (SIGTERM) to the process; the purpose of this is to give the program a chance to clean up its environment before exiting. For this reason, it is generally considered a bad idea to simply execute external programs from within PHP without using this function or the equivalents (like shell_exec(), passthru(), exec() or popen()).

There's no way to guarantee that an external program will use the same escape characters that you use in your script. This can lead to problems, especially when you execute commands from the CLI, where it's possible for malicious hackers to harvest data, such as usernames and passwords, from the list of programs running on the system (which you can see by using the ps command). To avoid this, it's generally best to use the functions escapeshellarg() and escapeshellcmd().

posix_kill example

$vendor = __DIR__;
while (!file_exists($vendor.'/vendor')) {
    $vendor = \dirname($vendor);
}
require $vendor.'/vendor/autoload.php';

class MyCommand extends Command implements SignalableCommandInterface
{
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        posix_kill(posix_getpid(), \SIGINT);

        $output->writeln('should not be displayed');

        return 0;
    }

    public function getSubscribedSignals(): array
    {
        return [\SIGINT];
    }

$this->expectExceptionMessage('The process has been signaled with signal "9".');
        if (!\function_exists('posix_kill')) {
            $this->markTestSkipped('Function posix_kill is required.');
        }

        if (self::$sigchild) {
            $this->markTestSkipped('PHP is compiled with --enable-sigchild.');
        }

        $process = $this->getProcessForCode('sleep(32.1);');
        $process->start();
        posix_kill($process->getPid(), 9); // SIGKILL
        $process->wait();
    }

    public function testRestart()
    {
        $process1 = $this->getProcessForCode('echo getmypid();');
        $process1->run();
        $process2 = $process1->restart();

        $process2->wait(); // wait for output

// Wait the start of the child             pcntl_sigwaitinfo([\SIGHUP], $info);

            $store = $this->getStore();
            try {
                // This call should failed given the lock should already by acquired by the child                 $store->save($key);
                $this->fail('The store saves a locked key.');
            } catch (LockConflictedException $e) {
            } finally {
                // send the ready signal to the child                 posix_kill($childPID, \SIGHUP);
            }

            // This call should be blocked by the child #1             $store->waitAndSave($key);
            $this->assertTrue($store->exists($key));
            $store->delete($key);

            // Now, assert the child process worked well             pcntl_waitpid($childPID, $status1);
            $this->assertSame(0, pcntl_wexitstatus($status1), 'The child process couldn\'t lock the resource');
        } else {

if ($exitCode && $this->isRunning()) {
                if ($throwException) {
                    throw new RuntimeException(sprintf('Unable to kill the process (%s).', implode(' ', $output)));
                }

                return false;
            }
        } else {
            if (!$this->isSigchildEnabled()) {
                $ok = @proc_terminate($this->process, $signal);
            } elseif (\function_exists('posix_kill')) {
                $ok = @posix_kill($pid, $signal);
            } elseif ($ok = proc_open(sprintf('kill -%d %d', $signal, $pid), [2 => ['pipe', 'w']], $pipes)) {
                $ok = false === fgets($pipes[2]);
            }
            if (!$ok) {
                if ($throwException) {
                    throw new RuntimeException(sprintf('Error while sending signal "%s".', $signal));
                }

                return false;
            }
        }

    public function testOneCallbackForASignalSignalIsHandled()
    {
        $signalRegistry = new SignalRegistry();

        $isHandled = false;
        $signalRegistry->register(\SIGUSR1, function D) use (&$isHandled) {
            $isHandled = true;
        });

        posix_kill(posix_getpid(), \SIGUSR1);

        $this->assertTrue($isHandled);
    }

    public function testTwoCallbacksForASignalBothCallbacksAreCalled()
    {
        $signalRegistry = new SignalRegistry();

        $isHandled1 = false;
        $signalRegistry->register(\SIGUSR1, function D) use (&$isHandled1) {
            $isHandled1 = true;
        });

public function __construct(bool $emitsSignal = true, int $signal = \SIGUSR1)
    {
        parent::__construct();
        $this->emitsSignal = $emitsSignal;
        $this->signal = $signal;
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        if ($this->emitsSignal) {
            posix_kill(posix_getpid(), $this->signal);
        }

        for ($i = 0; $i < $this->loop; ++$i) {
            usleep(100);
            if ($this->signaled) {
                return $this->exitCode;
            }
        }

        return 0;
    }
}