Peut PHP dire si le serveur os est en 64 bits?

Je fais affaire avec Windows ici.

Je sais que vous pouvez utiliser le $_SERVER['HTTP_USER_AGENT'] variable pour détecter le système d'exploitation du navigateur, l'affichage de la page, mais est de toute façon que PHP peut détecter le serveur de l'OS?

Pour mon INTERFACE utilisateur du programme, je suis en utilisant une page web PHP. J'ai besoin de lire une clé dans le registre qui se trouve dans un emplacement différent sur un OS 64 bits (C'est en vertu de la Wow6432Node Clé).

Pouvez PHP dire quel OS il est en cours d'exécution sur? Peut PHP dire si l'OS est en 64-bits ou 32 bits?

  • Il pourrait être plus facile de simplement essayer de le Wow6432Node touche d'abord et puis aller pour la normale 32 bits de la clé si elle n'existe pas.
  • Avez-vous eu un coup d'oeil à $_ENV?
InformationsquelleAutor BLAKE | 2010-03-01
  1. 30

    Remarque: Cette solution est un peu moins pratique et plus lent que @Salman Une réponse. Je vous conseille d'utiliser sa solution, et vérifier PHP_INT_SIZE == 8 pour voir si vous êtes sur un os 64 bits.

    Si vous voulez juste pour répondre à la 32bit/64bit question, un peu sournois fonction comme ceci ferait l'affaire (en prenant avantage de la intval fonction de la manière de gérer les services de renseignements basés sur les architectures 32 et 64 bits.)

    <?php
function is_64bit()
{
    $int = "9223372036854775807";
    $int = intval($int);
    if ($int == 9223372036854775807) {
        /* 64bit */
        return true;
    } elseif ($int == 2147483647) {
        /* 32bit */
        return false;
    } else {
        /* error */
        return "error";
    }
}
?>

    Vous pouvez voir le code en action ici: http://ideone.com/JWKIf

    Note: Si l'OS est en 64 bits, mais exécute une version 32 bits de php, la fonction retournera false (32 bits)...

    • Pourquoi utiliser un appel de fonction quand vous pouvez vérifier l'PHP_INT_SIZE constante? @Salman Une réponse est beaucoup mieux.
    • J'ai fait d'accord avec vous, je pense que je vais modifier ma réponse à relier les gens à sa réponse...
    InformationsquelleAutor Kristoffer la Cour
  2. 26

    Pour vérifier la taille de l'entier (4/8 octets) vous pouvez utiliser le PHP_INT_SIZE constante. Si PHP_INT_SIZE===8 alors vous avez une version 64 bits de PHP. PHP_INT_SIZE===4 implique qu'une version 32 bits de PHP est utilisé, mais il ne signifie pas que le système d'exploitation et/ou le Processeur est un 32 bits.

    Sur Windows+IIS il y a un $_SERVER["PROCESSOR_ARCHITECTURE"] variable qui contient x86 lors d'un essai sur mon système (windows xp-32 bits). Je pense qu'il va contenir x64 lors de l'exécution sur un OS 64 bits.

    • Sur Windows 7 Home Premium (64 bits) dans l'interface de ligne PHP_INT_SIZE===4. Je pense que Windows les limites de cette. Vérifier Chris0 réponse à un moyen plus sûr de le détecter.
    • Je suppose que vous utilisez une version 32 bits de php sur une version 64 bits de l'OS.
    InformationsquelleAutor Salman A
  3. 12

    Un peu plus courte et plus robuste pour obtenir le nombre de bits.

        strlen(decbin(~0));

    Comment cela fonctionne:

    Le bit à bit opérateur de complément, le tilde, ~, renverse tous les bits.

    @voir http://php.net/manual/en/language.operators.bitwise.php

    À l'aide de ce sur 0 commutateurs sur chaque bit d'un entier.

    Cela vous donne le plus grand nombre que PHP installer peut gérer.

    Puis à l'aide de decbin() vous donnera une représentation de chaîne de ce nombre dans sa forme binaire

    @voir http://php.net/manual/en/function.decbin.php

    et strlen vous donnera le nombre de bits.

    Ici est-il utilisable fonction

    function is64Bits() {
    return strlen(decbin(~0)) == 64;
}
    InformationsquelleAutor Chris0
  4. 7

    Essayez d'utiliser le php_uname fonction...

    <?php
echo php_uname('s');/* Operating system name */
echo "<br />";
echo php_uname('n');/* Host name */
echo "<br />";
echo php_uname('r');/* Release name */
echo "<br />";
echo php_uname('v');/* Version information */
echo "<br />";
echo php_uname('m');/* Machine type */
echo "<br />";
echo PHP_OS;/* constant will contain the operating system PHP was built on */
?>

    Source - Déterminer Le Système D'Exploitation http://www.sitepoint.com/forums/showthread.php?t=510565

    Une autre méthode consiste à utiliser...

     echo $_SERVER['SERVER_SOFTWARE'];

    Retourne la chaîne de caractères suivante sur mon ibm t400 sous Win 7 (64 bits)...

    Apache/2.2.12 (Win32) DAV/2 mod_ssl/2.2.12 OpenSSL/0.9.8 k mod_autoindex_color PHP/5.3.0 mod_perl/2.0.4 Perl/v5.10.0

    Malheureusement, son retour WIN32 parce que je suis sous la version 32 bits de apache.

    Vous pouvez obtenir générales du processeur d'informations (sur un *nix serveur), à l'aide de la cmd...

    echo system('cat /proc/cpuinfo');

    Vous aurez probablement besoin d'utiliser une combinaison de ces méthodes si vous comptez sur l'appui de nombreux différents Systèmes d'exploitation.

    • À l'aide de system() et en s'appuyant sur la mise en page de /proc. Deux de mes choses préférées.
    • Je suis d'accord, vous allez avoir besoin d'essayer un système de cmd pour obtenir la bonne info, et même alors, si votre serveur Apache est 32 bits, vous êtes limité au sein du serveur d'application.
    • Asveikau, d'accord, mais malheureusement il n'y a pas une seule approche fiable. La seule solution est d'utiliser un mashup, et peut-être compter sur le système() comme un dernier recours.
    InformationsquelleAutor John Himmelman
  5. 3

    J'ai eu de la chance avec le décalage de bits, et profitant boolean casting.

    function is64bit()
{
  return (bool)((1<<32)-1);
}
//or
function is32bit()
{
  return 1<<32 === 1;
}
    InformationsquelleAutor emcconville
  6. 2

    Ou de l'utilisation de PHP COM pour appeler wmi

    $obj = new COM('winmgmts://localhost/root/CIMV2');
$wmi = $obj->ExecQuery('Select * from Win32_OperatingSystem');
foreach($wmi as $wmiCall)
{
    $architecture = $wmiCall->OSArchitecture;
}
    InformationsquelleAutor user1568407
  7. 1

    vous pouvez utiliser un script de sortie, le type de système d'exploitation

    ici , il est un exemple de la façon d'obtenir cette information à l'aide de WMI.

    Vous pouvez appeler ce script à l'aide de exec et de lire la sortie.

    • +1 WMI est le droit, "Windows-y" façon de le faire.
    InformationsquelleAutor RageZ
  8. 0

    Un peu de retard de réponse, mais si vous voulez juste pour déterminer la taille de mot, vous pouvez utiliser ceci:
    (log(PHP_INT_MAX + 1, 2) + 1)

    InformationsquelleAutor Ain't Nobody Special
  9. 0

    si vous avez la COM extension installée (en php.ini) vous pouvez appeler le service WMI de windows.

    Pour vérifier l'OS:

    function getOsArchitecture() {
    $wmi = new COM('winmgmts:{impersonationLevel=impersonate}//./root/cimv2');
    $wmi = $obj->ExecQuery('SELECT * FROM Win32_OperatingSystem');
    if (!is_object($wmi)) {
        throw new Exception('No access to WMI. Please enable DCOM in php.ini and allow the current user to access the WMI DCOM object.');
    }
    foreach($wmi as $os) {
        return $os->OSArchitecture;
    }
    return "Unknown";
}

    ou, vérifier le processeur physique:

    function getProcessorArchitecture() {
    $wmi = new COM('winmgmts:{impersonationLevel=impersonate}//./root/cimv2');

    if (!is_object($wmi)) {
        throw new Exception('No access to WMI. Please enable DCOM in php.ini and allow the current user to access the WMI DCOM object.');
    }
    foreach($wmi->ExecQuery("SELECT Architecture FROM Win32_Processor") as $cpu) {
        # only need to check the first one (if there is more than one cpu at all)
        switch($cpu->Architecture) {
            case 0:
                return "x86";
            case 1:
                return "MIPS";
            case 2:
                return "Alpha";
            case 3:
                return "PowerPC";
            case 6:
                return "Itanium-based system";
            case 9:
                return "x64";
        }
    }
    return "Unknown";
}
    InformationsquelleAutor doublehelix
  10. 0

    Pas besoin de faire de calculs. Il suffit de cocher la PHP_INT_SIZE constante:

    if(PHP_INT_SIZE>4)
  //64 bit code
else
  //32 bit code

    La taille des nombres entiers est un bon indicateur, mais pas à l'épreuve des balles. Quelqu'un pourrait exécutez une version 32 bits de l'application sur un système 64 bits.

    $_SERVER['SERVER_SOFTWARE'] et $_SERVER['SERVER_SIGNATURE'] peut vous dire quelque chose d'utile, en fonction de la mise en œuvre du serveur.

    InformationsquelleAutor Simon Rigét
  11. 0

    Ici est une solution en ligne pour déterminer si PHP est en cours d'exécution en 64 bits ou 32 bits mode:

    empty(strstr(php_uname("m"), '64')) ?  $php64bit = false : $php64bit = true;

    Après exécution de la ligne de code ci-dessus la $php64bit variable sera réglé soit true ou false

    InformationsquelleAutor Tim Penner
  12. 0

    À la recherche dans tous les de ce les réponses et quelques autres solutions + mon idée de "demander à l'ordinateur directement" je reçois cette solution universelle:

    function is_64bit()
{
//Let's ask system directly
if(function_exists('shell_exec'))
{
if (in_array(strtoupper(substr(PHP_OS, 0, 3)), array('WIN'), true) !== false || defined('DIRECTORY_SEPARATOR') && '\\' === DIRECTORY_SEPARATOR)
{
//Is Windows OS
$shell = shell_exec('wmic os get osarchitecture');
if(!empty($shell))
{
if(strpos($shell, '64') !== false)
return true;
}
}
else
{
//Let's check some UNIX approach if is possible
$shell = shell_exec('uname -m');
if(!empty($shell))
{
if(strpos($shell, '64') !== false)
return true;
}
}
}
//Check is PHP 64bit (PHP 64bit only running on Windows 64bit version)
if (version_compare(PHP_VERSION, '5.0.5') >= 0)
{
if(defined('PHP_INT_SIZE') && PHP_INT_SIZE === 8)
return true;
}
//bit-shifting can help also if PHP_INT_SIZE fail
if((bool)((1<<32)-1))
return true;
//Let's play with bits again but on different way
if(strlen(decbin(~0)) == 64)
return true;
//Let's do something more worse but can work if all above fail
//The largest integer supported in 64 bit systems is 9223372036854775807. (https://en.wikipedia.org/wiki/9,223,372,036,854,775,807)
$int = '9223372036854775807';
if (intval($int) == $int)
return true;
return false;
}

    Est testé sur diverses machines, et pour l'instant j'ai des résultats positifs. N'hésitez pas à utiliser si vous voyez n'importe quel but.

    InformationsquelleAutor Ivijan Stefan Stipić