Use extension_loaded instead of function_exists to detect PHP extensions

Hi!

Below few results of some manual testing.

$functionExistsStart = microtime(true);
for ($i = 0; $i < 1000000; $i++) {
    function_exists('this_function_doesnt_exist');
}
$functionExistsEnd = microtime(true);

$extenstionLoadedStart = microtime(true);
for ($i = 0; $i < 1000000; $i++) {
    extension_loaded('this_extension_is_not_loaded');
}
$extenstionLoadedEnd = microtime(true);

echo 'function_exists ' .
    ($functionExistsEnd - $functionExistsStart) .
    PHP_EOL;

echo 'extension_loaded ' .
    ($extenstionLoadedEnd - $extenstionLoadedStart) .
    PHP_EOL;

function_exists 0.35822796821594
extension_loaded 0.40138292312622

Taken from http://www.merkushin.com/function_exists-vs-extension_loaded

I get little different results (i use real functions to check)

function_exists 0.26105785369873
extension_loaded 0.27371501922607 

There is no big deal between those functions, but anyway according this testing "extension_loaded" work slower.
Check please.

You have 1,000,000 calls of each running with a difference of 0.05 second, which is an actual difference of 0,00000005 (10^-7) second for a single call, this is absolutely not significant (even with 1000 calls it's still not significant) and I bet that the 0.05 second is more an artefact of something else interfering with the actual run than an actual delta between both. Performance will not be a concern for this issue :)

Note that the existance of an extension is being checked just to be able to use functions that that extension provides it might actually be safer to use function_exists() because functions provided by an extension can be disabled with the disable_functions PHP ini setting, even if an extension is enabled. Thus, extension_loaded() will return TRUE but the function call will still fatal in that case. function_exists() will return FALSE.

Doesn't mean we shouldn't do this, just wanted to bring this up, because this has bitten people before. I can't find the issue ATM, however.

disable_function setting is a very dangerous thing to use and admins knows it, so I guess that only conscientious people will use it, but yes in theory you are right, but you won't do 10 function_exists calls for the same extension whereas a theoretically only one extension_exists call would be enough ?

@pounard I personally actually prefer doing extension_loaded() alltogether, because it's much more intuitive and readable. I just wanted to bring this up as a possible argument against it. I don't feel strongly either way.

Fair enough, I have no strong opinion either way too. I guess all this issue need is someone willing to take the time to propose a patch! I'm sorry but I probably won't myself.

In #bugsmash longwave suggested using Symfony polyfills for missing extensions.

So I did some grepping ($ egrep -r "function_exists\([^\\$]" core | awk -F'function_exists' '{print $2}' | grep -v \(\) | grep -v module_ | grep -vi drupal | grep -v \'t\' | grep -v theme | awk -F\' '{ print $2 }' | sort -u ) and hand editing to create a list of parameters in function_exists that are not test or drupal specific to see if there are polyfill for them.

apcu_fetch
com_create_guid
fastcgi_finish_request
ftp_connect
gd_info
gzopen
imagecreatefrompng
imagefilter
imagegd2
imagerotate
mb_ereg
opcache_invalidate
pcntl_fork
phpinfo
set_time_limit
ssh2_connect
system_test_help
uuid_create

It is too late to do more here.

From the above, the extensions are

apcu - apcu_fetch
com_create_guid - ?
fastcgi_finish_request - ?
ftp - ftp_connect
gd - gd_info, imagecreatefrompng, imagefilter, imagegd2, imagerotate
mbstring - mb_ereg
opcache - opcache_invalidate
pcntl - pcntl_fork
ssh2_connect - ssh2
zlib - gzopen

Polyfills available for apcu, mbstring

And unassigning since it has been over 5 years.

Checking an extension is loaded instead of checking the necessary function exists assumes the function is always present for every PHP or extension version, which isn't necessarily true; extension functions can also be deprecated and removed.

IMO, the code should:

• Use function_exists() when the purpose is verifying a function can be called before calling it
• Use extension_loaded() when the purpose is telling the users an extension is required for a module to work

For example, the following code should be changed.

  $has_curl = function_exists('curl_init');
  $requirements = [];
  $requirements['curl'] = [
    'title' => t('cURL'),
    'value' => $has_curl ? t('Enabled') : t('Not found'),
  ];
  if (!$has_curl) {
    $requirements['curl']['severity'] = REQUIREMENT_ERROR;
    $requirements['curl']['description'] = t('The Aggregator module requires the <a href="https://secure.php.net/manual/en/curl.setup.php">PHP cURL library</a>. For more information, see the <a href="https://www.drupal.org/requirements/php/curl">online information on installing the PHP cURL extension</a>.');
  }

curl_init() could also be deprecated, and replaced by another function. That is irrelevant, to verify if the extension is loaded.

Vice versa, code like the following one would be wrong.

if (extension_loaded('zlib')) {
  if (!function_exists('gzopen') && function_exists('gzopen64')) {
    function gzopen($filename, $mode, $use_include_path = 0) {
      return gzopen64($filename, $mode, $use_include_path);
    }
  }
}

To add two more examples, I would not change this code too.

  public function getRequirements() {
    $requirements = [];
    $info = gd_info();
    $requirements['version'] = [
      'title' => t('GD library'),
      'value' => $info['GD Version'],
    ];

    // Check for filter and rotate support.
    if (!function_exists('imagefilter') || !function_exists('imagerotate')) {
      $requirements['version']['severity'] = REQUIREMENT_WARNING;
      $requirements['version']['description'] = t('The GD Library for PHP is enabled, but was compiled without support for functions used by the rotate and desaturate effects. It was probably compiled using the official GD libraries from http://www.libgd.org instead of the GD library bundled with PHP. You should recompile PHP --with-gd using the bundled GD library. See <a href="http://php.net/manual/book.image.php">the PHP manual</a>.');
    }
    return $requirements;
  }

  public static function isAvailable() {
    // GD2 support is available.
    return function_exists('imagegd2');
  }

Unless any of the existing uses of function_exists() or extension_loaded() are known to be causing a problem e.g. in an edge case where disable_functions is used or a missing extension is polyfilled, I suggest we just leave this alone - there is no bug to fix here.

I'm with longwave on this, "there is no bug to fix here.". Changing to a task.

As well as to leaving this alone. And as apaderno pointed out that "checking an extension is loaded instead of checking the necessary function exists assumes the function is always present for every PHP or extension version, which isn't necessarily true; extension functions can also be deprecated and removed."

Thanks to everyone who worked on resolving this issue.