exec - PHP code example

PHP Function Exec - How to Run a Program Hidden in the Background

php function exec is an inbuilt php function that allows the execution of external commands from within a script. It can be used for tasks such as automating system-level processes, executing command-line utilities, and interacting with other applications.

The exec() and shell_exec() functions allow you to execute commands in the operating system’s shell or terminal, allowing your PHP scripts to interact with the underlying system. They both return the last line of output from the executed command as a string, or NULL if no error occurred. It is important to note that these functions are powerful and can have serious security implications if they are not used properly. They should only be used for trusted commands in a controlled environment. It is also a good practice to perform proper input validation and sanitization of user data before using it in these functions, as this helps reduce the risk of command injection attacks.

One of the most useful and interesting uses of php function exec is to run a program that will be hidden in the background (unlike other solutions such as llbra@phpbrasil’s solution which only works for Linux and not for Windows). The following is an example of how this can be done.

The first optional argument of exec() is the command that you want to execute, here we have used 'pwd' which only returns one line of output. The second optional argument is the $retArr variable which will be filled with each line of output from the command, and the third is the $return_var variable that stores the exit status of the executed command, a value of 0 indicates success.

exec example

'--filter',
        escapeshellarg($filter_string),
      ]);
    }

    // Need to change directories before running the command so that we can use     // relative paths in the configuration file's exclusions.     $old_cwd = getcwd();
    chdir($this->appRoot . "/core");

    // exec in a subshell so that the environment is isolated.     $ret = exec(implode(" ", $command), $output, $status);

    chdir($old_cwd);
    putenv('SIMPLETEST_DB=');
    if ($base_url) {
      putenv('SIMPLETEST_BASE_URL=');
      putenv('BROWSERTEST_OUTPUT_DIRECTORY=');
    }
    return $ret;
  }

  /** * Executes PHPUnit tests and returns the results of the run. * * @param \Drupal\Core\Test\TestRun $test_run * The test run object. * @param string[] $unescaped_test_classnames * An array of test class names, including full namespaces, to be passed as * a regular expression to PHPUnit's --filter option. * @param int $status * (optional) The exit status code of the PHPUnit process will be assigned * to this variable. * * @return array * The parsed results of PHPUnit's JUnit XML output, in the format of * {simpletest}'s schema. * * @internal */

return;
        }

        $db = array();
        while ($row = $query->fetchColumn())
        {
            $db[] = $row;
        }

        if (!in_array($this->options['extras']['prefix'] . 'cache_data', $db))
        {
            $query = $this->mysql->exec('CREATE TABLE `' . $this->options['extras']['prefix'] . 'cache_data` (`id` TEXT CHARACTER SET utf8 NOT NULL, `items` SMALLINT NOT NULL DEFAULT 0, `data` BLOB NOT NULL, `mtime` INT UNSIGNED NOT NULL, UNIQUE (`id`(125)))');
            if ($query === false)
            {
                trigger_error("Can't create " . $this->options['extras']['prefix'] . "cache_data table, check permissions", E_USER_WARNING);
                $this->mysql = null;
                return;
            }
        }

        if (!in_array($this->options['extras']['prefix'] . 'items', $db))
        {
            $query = $this->mysql->exec('CREATE TABLE `' . $this->options['extras']['prefix'] . 'items` (`feed_id` TEXT CHARACTER SET utf8 NOT NULL, `id` TEXT CHARACTER SET utf8 NOT NULL, `data` MEDIUMBLOB NOT NULL, `posted` INT UNSIGNED NOT NULL, INDEX `feed_id` (`feed_id`(125)))');

public function cleanup(array $ids): void
    {
        $this->connection->createQueryBuilder()
            ->delete('s_es_backend_backlog')
            ->where('id IN(:ids)')
            ->setParameter('ids', $ids, Connection::PARAM_INT_ARRAY)
            ->execute();
    }

    public function clear(): void
    {
        $this->connection->exec('TRUNCATE TABLE `s_es_backend_backlog`');
    }
}

        return ($this->lazyObjectState->realInstance ??= ($this->lazyObjectState->initializer)())->evalsha(...\func_get_args());
    }

    public function evalsha_ro($sha1, $args = [], $num_keys = 0): mixed
    {
        return ($this->lazyObjectState->realInstance ??= ($this->lazyObjectState->initializer)())->evalsha_ro(...\func_get_args());
    }

    public function exec(): \Redis|array|false
    {
        return ($this->lazyObjectState->realInstance ??= ($this->lazyObjectState->initializer)())->exec(...\func_get_args());
    }

    public function exists($key, ...$other_keys): \Redis|bool|int
    {
        return ($this->lazyObjectState->realInstance ??= ($this->lazyObjectState->initializer)())->exists(...\func_get_args());
    }

    public function expire($key, $timeout, $mode = null): \Redis|bool
    {
        return ($this->lazyObjectState->realInstance ??= ($this->lazyObjectState->initializer)())->expire(...\func_get_args());
    }

public static function generateDimensions()
 {
 try {
 if (is_windows()) {
 // Shells such as `Cygwin` and `Git bash` returns incorrect values // when executing `mode CON`, so we use `tput` instead if (getenv('TERM') || (($shell = getenv('SHELL')) && preg_match('/(?:bash|zsh)(?:\.exe)?$/', $shell))) {
 static::$height = (int) exec('tput lines');
 static::$width = (int) exec('tput cols');
 } else {
 $return = -1;
 $output = [];
 exec('mode CON', $output, $return);

 // Look for the next lines ending in ": <number>" // Searching for "Columns:" or "Lines:" will fail on non-English locales if ($return === 0 && $output && preg_match('/:\s*(\d+)\n[^:]+:\s*(\d+)\n/', implode("\n", $output), $matches)) {
 static::$height = (int) $matches[1];
 static::$width = (int) $matches[2];
 }

if ('\\' !== \DIRECTORY_SEPARATOR) {
            $this->markTestSkipped('Long file names are an issue on Windows');
        }
        $basePath = $this->workspace.'\\directory\\';
        $maxPathLength = \PHP_MAXPATHLEN - 2;

        $oldPath = getcwd();
        mkdir($basePath);
        chdir($basePath);
        $file = str_repeat('T', $maxPathLength - \strlen($basePath) + 1);
        $path = $basePath.$file;
        exec('TYPE NUL >>'.$file); // equivalent of touch, we cannot use the php touch() here because it suffers from the same limitation         $this->longPathNamesWindows[] = $path; // save this so we can clean up later         chdir($oldPath);
        $this->filesystem->exists($path);
    }

    public function testFilesExistsTraversableObjectOfFilesAndDirectories()
    {
        $basePath = $this->workspace.\DIRECTORY_SEPARATOR;

        mkdir($basePath.'dir');
        touch($basePath.'file');

class Migrations_Migration1709 extends Shopware\Components\Migrations\AbstractMigration
{
 public function up($modus)
 {
 if ($modus === self::MODUS_UPDATE) {
 return;
 }

 $this->connection->exec('SET @formId = ( SELECT id FROM `s_core_config_forms` WHERE name = \'Frontend60\' LIMIT 1 );');

 $html = <<<HTML Mit freundlichen Grüßen Ihr Team von {config name=shopName}</div> {{config name=address}|nl2br} Bankverbindung: {{config name=bankAccount}|nl2br} HTML;

foreach ($generator() as $command => $args) {
                $id = 'eval' === $command ? $args[1][0] : $args[0];
                if (!isset($connections[$h = $redis->_target($id)])) {
                    $connections[$h] = [$redis->_instance($h), -1];
                    $connections[$h][0]->multi(\Redis::PIPELINE);
                }
                $connections[$h][0]->{$command}(...$args);
                $results[] = [$h, ++$connections[$h][1]];
                $ids[] = $id;
            }
            foreach ($connections as $h => $c) {
                $connections[$h] = $c[0]->exec();
            }
            foreach ($results as $k => [$h, $c]) {
                $results[$k] = $connections[$h][$c];
            }
        } else {
            $redis->multi($redis instanceof Relay ? Relay::PIPELINE : \Redis::PIPELINE);
            foreach ($generator() as $command => $args) {
                $redis->{$command}(...$args);
                $ids[] = 'eval' === $command ? $args[1][0] : $args[0];
            }
            $results = $redis->exec();
        }

$sql = <<<SQL INSERT IGNORE INTO s_user_addresses_attributes (address_id, $names) SELECT address.id as address_id, $prefixed FROM s_user_addresses address INNER JOIN $table as attr ON address.original_id = attr.$keyColumn AND address.original_type = '$type' SQL;

 $this->connection->exec($sql);
 }

 private function createColumn(string $table, string $name, string $type): void
 {
 $sql = sprintf('ALTER TABLE `%s` ADD `%s` %s NULL DEFAULT NULL', $table, $name, $type);
 $this->connection->exec($sql);
 }

 private function changeColumn(string $table, string $name, string $type): void
 {
 $sql = sprintf('ALTER TABLE `%s` CHANGE `%s` `%s` %s NULL DEFAULT NULL;', $table, $name, $name, $type);

$output = file_get_contents("$component/phpunit.stdout");
            $output .= file_get_contents("$component/phpunit.stderr");

            if ($lastOutput !== $output) {
                $lastOutput = $output;
                $lastOutputTime = microtime(true);
            } elseif (microtime(true) - $lastOutputTime > 60) {
                echo "\033[41mTimeout\033[0m $component\n\n";

                if ('\\' === \DIRECTORY_SEPARATOR) {
                    exec(sprintf('taskkill /F /T /PID %d 2>&1', $procStatus['pid']), $output, $exitCode);
                } else {
                    proc_terminate(current($runningProcs));
                }
            }
        }

        foreach ($terminatedProcs as $component => $procStatus) {
            foreach (['out', 'err'] as $file) {
                $file = "$component/phpunit.std$file";
                readfile($file);
                unlink($file);
            }

public function up($modus)
 {
 $this->prepare();

 require_once __DIR__ . '/common/AttributeTranslationMigrationHelper.php';
 $helper = new AttributeTranslationMigrationHelper($this->connection);
 $helper->migrate(200000);
 }

 private function prepare()
 {
 $this->connection->exec(<<<EOL DROP TABLE IF EXISTS translation_migration_id; CREATE TABLE `translation_migration_id` ( `max_id` int(11) NOT NULL ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci; EOL
 );

 $this->connection->exec('INSERT INTO translation_migration_id (max_id) SELECT MAX(id) as id FROM s_core_translations;');
 }
}

/** * Creates a new compiler based on the "genrb" executable. * * @param string $genrb Optional. The path to the "genrb" executable * @param string $envVars Optional. Environment variables to be loaded when running "genrb". * * @throws RuntimeException if the "genrb" cannot be found */
    public function __construct(string $genrb = 'genrb', string $envVars = '')
    {
        exec('which '.$genrb, $output, $status);

        if (0 !== $status) {
            throw new RuntimeException(sprintf('The command "%s" is not installed.', $genrb));
        }

        $this->genrb = ($envVars ? $envVars.' ' : '').$genrb;
    }

    public function compile(string $sourcePath, string $targetDir): void
    {
        if (is_dir($sourcePath)) {

$this->redis->sAdd(self::KEY, ...$tags);
 }

 public function loadAndDelete(): array
 {
 /** @var array{0: list<string>, 1: mixed} $values */
 $values = $this // @phpstan-ignore-line - PhpStan does not understand redis multi ->redis
 ->multi()
 ->sMembers(self::KEY)
 ->del(self::KEY)
 ->exec();

 return $values[0];
 }
}

'fake.inc',
      ],
    ];
    return $files;
  }

  public function _buildFakeModule() {
    $location = 'temporary://fake';
    if (is_dir($location)) {
      $ret = 0;
      $output = [];
      exec('rm -Rf ' . escapeshellarg($location), $output, $ret);
      if ($ret != 0) {
        throw new \Exception('Error removing fake module directory.');
      }
    }

    $files = $this->_getFakeModuleFiles();
    $this->_writeDirectory($location, $files);
    return $location;
  }

  public function _writeDirectory($base, $files = []) {

/** * First try to truncate table, * if that Fails due to insufficient permissions, use delete query * * @return int */
    public function removeAllAssignments()
    {
        // TRUNCATE is faster than DELETE         try {
            $count = $this->getConnection()->exec('TRUNCATE s_articles_categories_ro');
        } catch (PDOException $e) {
            $count = $this->getConnection()->exec('DELETE FROM s_articles_categories_ro');
        }

        return $count;
    }

    /** * Removes assignments for non-existing products or categories * * @return int */