WebSVN – ALCASAR – Diff – /web/acc/phpsysinfo/includes/os/class.BSDCommon.inc.php


<?php
/**
 * BSDCommon Class
 *
 * PHP version 5
 *
 * @category  PHP
 * @package   PSI BSDCommon OS class
 * @author    Michael Cramer <BigMichi1@users.sourceforge.net>
 * @copyright 2009 phpSysInfo
 * @license   http://opensource.org/licenses/gpl-2.0.php GNU General Public License version 2, or (at your option) any later version
 * @version   SVN: $Id: class.BSDCommon.inc.php 621 2012-07-29 18:49:04Z namiltd $
 * @link      http://phpsysinfo.sourceforge.net
 */
 /**
 * BSDCommon class
 * get all the required information for BSD Like systems
 * no need to implement in every class the same methods
 *
 * @category  PHP
 * @package   PSI BSDCommon OS class
 * @author    Michael Cramer <BigMichi1@users.sourceforge.net>
 * @copyright 2009 phpSysInfo
 * @license   http://opensource.org/licenses/gpl-2.0.php GNU General Public License version 2, or (at your option) any later version
 * @version   Release: 3.0
 * @link      http://phpsysinfo.sourceforge.net
 */
abstract class BSDCommon extends OS
{
    /**
     * Assoc array of all CPUs loads.
     */
    private $_cpu_loads = null;
 
    /**
     * content of the syslog
     *
     * @var array
     */
    private $_dmesg = null;
 
    /**
     * regexp1 for cpu information out of the syslog
     *
     * @var string
     */
    private $_CPURegExp1 = "//";
 
    /**
     * regexp2 for cpu information out of the syslog
     *
     * @var string
     */
    private $_CPURegExp2 = "//";
 
    /**
     * regexp1 for scsi information out of the syslog
     *
     * @var string
     */
    private $_SCSIRegExp1 = "//";
 
    /**
     * regexp2 for scsi information out of the syslog
     *
     * @var string
     */
    private $_SCSIRegExp2 = "//";
 
    /**
     * regexp3 for scsi information out of the syslog
     *
     * @var string
     */
    private $_SCSIRegExp3 = "//";
 
    /**
     * regexp1 for pci information out of the syslog
     *
     * @var string
     */
    private $_PCIRegExp1 = "//";
 
    /**
     * regexp1 for pci information out of the syslog
     *
     * @var string
     */
    private $_PCIRegExp2 = "//";
 
    /**
     * setter for cpuregexp1
     *
     * @param string $value value to set
     *
     * @return void
     */
    protected function setCPURegExp1($value)
    {
        $this->_CPURegExp1 = $value;
    }
 
    /**
     * setter for cpuregexp2
     *
     * @param string $value value to set
     *
     * @return void
     */
    protected function setCPURegExp2($value)
    {
        $this->_CPURegExp2 = $value;
    }
 
    /**
     * setter for scsiregexp1
     *
     * @param string $value value to set
     *
     * @return void
     */
    protected function setSCSIRegExp1($value)
    {
        $this->_SCSIRegExp1 = $value;
    }
 
    /**
     * setter for scsiregexp2
     *
     * @param string $value value to set
     *
     * @return void
     */
    protected function setSCSIRegExp2($value)
    {
        $this->_SCSIRegExp2 = $value;
    }
 
    /**
     * setter for scsiregexp3
     *
     * @param string $value value to set
     *
     * @return void
     */
    protected function setSCSIRegExp3($value)
    {
        $this->_SCSIRegExp3 = $value;
    }
 
    /**
     * setter for pciregexp1
     *
     * @param string $value value to set
     *
     * @return void
     */
    protected function setPCIRegExp1($value)
    {
        $this->_PCIRegExp1 = $value;
    }
 
    /**
     * setter for pciregexp2
     *
     * @param string $value value to set
     *
     * @return void
     */
    protected function setPCIRegExp2($value)
    {
        $this->_PCIRegExp2 = $value;
    }
 
    /**
     * read /var/run/dmesg.boot, but only if we haven't already
     *
     * @return array
     */
    protected function readdmesg()
    {
        if ($this->_dmesg === null) {
            if ((PSI_OS != 'Darwin') && (CommonFunctions::rfts('/var/run/dmesg.boot', $buf, 0, 4096, false) || CommonFunctions::rfts('/var/log/dmesg.boot', $buf, 0, 4096, false) || CommonFunctions::rfts('/var/run/dmesg.boot', $buf))) {  // Once again but with debug
                $parts = preg_split("/rebooting|Uptime/", $buf, -1, PREG_SPLIT_NO_EMPTY);
                $this->_dmesg = preg_split("/\n/", $parts[count($parts) - 1], -1, PREG_SPLIT_NO_EMPTY);
            } else {
                $this->_dmesg = array();
            }
        }
 
        return $this->_dmesg;
    }
 
    /**
     * get a value from sysctl command
     *
     * @param string $key key for the value to get
     *
     * @return string
     */
    protected function grabkey($key)
    {
        $buf = "";
        if (CommonFunctions::executeProgram('sysctl', "-n $key", $buf, PSI_DEBUG)) {
            return $buf;
        } else {
            return '';
        }
    }
 
    /**
     * Virtual Host Name
     *
     * @return void
     */
    protected function hostname()
    {
        if (PSI_USE_VHOST) {
            if (CommonFunctions::readenv('SERVER_NAME', $hnm)) $this->sys->setHostname($hnm);
        } else {
            if (CommonFunctions::executeProgram('hostname', '', $buf, PSI_DEBUG)) {
                $this->sys->setHostname($buf);
            }
        }
    }
 
    /**
     * Kernel Version
     *
     * @return void
     */
    protected function kernel()
    {
        $s = $this->grabkey('kern.version');
        $a = preg_split('/:/', $s, 4);
        if (isset($a[3])) {
            if (preg_match('/^(\d{2} [A-Z]{3});/', $a[3], $abuf) // eg. 19:58 GMT;...
               || preg_match('/^(\d{2} [A-Z]{3} \d{4})/', $a[3], $abuf)) { // eg. 26:31 PDT 2019...
                $this->sys->setKernel($a[0].$a[1].':'.$a[2].':'.$abuf[1]);
            } else {
                $this->sys->setKernel($a[0].$a[1].':'.$a[2]);
            }
        } elseif (isset($a[2])) {
            $this->sys->setKernel($a[0].$a[1].':'.$a[2]);
        } else {
            $this->sys->setKernel($s);
        }
    }
 
    /**
     * Virtualizer info
     *
     * @return void
     */
    private function virtualizer()
    {
        if (defined('PSI_SHOW_VIRTUALIZER_INFO') && PSI_SHOW_VIRTUALIZER_INFO) {
            $testvirt = $this->sys->getVirtualizer();
            $novm = true;
            foreach ($testvirt as $virtkey=>$virtvalue) if ($virtvalue) {
                $novm = false;
                break;
            }
            // Detect QEMU cpu
            if ($novm && isset($testvirt["cpuid:QEMU"])) {
                $this->sys->setVirtualizer('qemu'); // QEMU
                $novm = false;
            }
 
            if ($novm && isset($testvirt["hypervisor"])) {
                $this->sys->setVirtualizer('unknown');
            }
        }
    }
 
    /**
     * CPU usage
     *
     * @return void
     */
    protected function cpuusage()
    {
        if (($this->_cpu_loads === null)) {
            $this->_cpu_loads = array();
            if (PSI_OS != 'Darwin') {
                if ($fd = $this->grabkey('kern.cp_time')) {
                    // Find out the CPU load
                    // user + sys = load
                    // total = total
                    if (preg_match($this->_CPURegExp2, $fd, $res) && (sizeof($res) > 4)) {
                        $load = $res[2] + $res[3] + $res[4]; // cpu.user + cpu.sys
                        $total = $res[2] + $res[3] + $res[4] + $res[5]; // cpu.total
                        // we need a second value, wait 1 second befor getting (< 1 second no good value will occour)
                        sleep(1);
                        $fd = $this->grabkey('kern.cp_time');
                        if (preg_match($this->_CPURegExp2, $fd, $res) && (sizeof($res) > 4)) {
                            $load2 = $res[2] + $res[3] + $res[4];
                            $total2 = $res[2] + $res[3] + $res[4] + $res[5];
                            if ($total2 != $total) {
                                $this->_cpu_loads['cpu'] = (100 * ($load2 - $load)) / ($total2 - $total);
                            } else {
                                $this->_cpu_loads['cpu'] = 0;
                            }
                        }
                    }
                }
            } else {
                $ncpu = $this->grabkey('hw.ncpu');
                if (($ncpu !== "") && ($ncpu >= 1) && CommonFunctions::executeProgram('ps', "-A -o %cpu", $pstable, false) && !empty($pstable)) {
                    $pslines = preg_split("/\n/", $pstable, -1, PREG_SPLIT_NO_EMPTY);
                    if (!empty($pslines) && (count($pslines)>1) && (trim($pslines[0])==="%CPU")) {
                        array_shift($pslines);
                        $sum = 0;
                        foreach ($pslines as $psline) {
                            $sum+=str_replace(',', '.', trim($psline));
                        }
                        $this->_cpu_loads['cpu'] = min($sum/$ncpu, 100);
                    }
                }
            }
        }
 
        if (isset($this->_cpu_loads['cpu'])) {
            return $this->_cpu_loads['cpu'];
        } else {
            return null;
        }
    }
 
    /**
     * Processor Load
     * optionally create a loadbar
     *
     * @return void
     */
    protected function loadavg()
    {
        $s = $this->grabkey('vm.loadavg');
        $s = preg_replace('/{ /', '', $s);
        $s = preg_replace('/ }/', '', $s);
        $s = str_replace(',', '.', $s);
        $this->sys->setLoad($s);
 
        if (PSI_LOAD_BAR) {
            $this->sys->setLoadPercent($this->cpuusage());
        }
    }
 
    /**
     * CPU information
     *
     * @return void
     */
    protected function cpuinfo()
    {
        $dev = new CpuDevice();
        $cpumodel = $this->grabkey('hw.model');
        $dev->setModel($cpumodel);
        if (defined('PSI_SHOW_VIRTUALIZER_INFO') && PSI_SHOW_VIRTUALIZER_INFO && preg_match('/^QEMU Virtual CPU version /', $cpumodel)) {
            $this->sys->setVirtualizer("cpuid:QEMU", false);
        }
 
        $notwas = true;
        foreach ($this->readdmesg() as $line) {
            if ($notwas) {
               $regexps = preg_split("/\n/", $this->_CPURegExp1, -1, PREG_SPLIT_NO_EMPTY); // multiple regexp separated by \n
               foreach ($regexps as $regexp) {
                   if (preg_match($regexp, $line, $ar_buf) && (sizeof($ar_buf) > 2)) {
                        if ($dev->getCpuSpeed() == 0) {
                            $dev->setCpuSpeed(round($ar_buf[2]));
                        }
                        $notwas = false;
                        break;
                    }
                }
            } else {
                if (preg_match("/^\s+Origin| Features/", $line, $ar_buf)) {
                    if (preg_match("/^\s+Origin[ ]*=[ ]*\"(.+)\"/", $line, $ar_buf)) {
                        $dev->setVendorId($ar_buf[1]);
                    } elseif (preg_match("/ Features2[ ]*=.*<(.+)>/", $line, $ar_buf)) {
                        $feats = preg_split("/,/", strtolower(trim($ar_buf[1])), -1, PREG_SPLIT_NO_EMPTY);
                        foreach ($feats as $feat) {
                            if (($feat=="vmx") || ($feat=="svm")) {
                                $dev->setVirt($feat);
                            } elseif ($feat=="hv") {
                                if ($dev->getVirt() === null) {
                                    $dev->setVirt('hypervisor');
                                }
                                if (defined('PSI_SHOW_VIRTUALIZER_INFO') && PSI_SHOW_VIRTUALIZER_INFO) {
                                    $this->sys->setVirtualizer("hypervisor", false);
                                }
                            }
                        }
                    }
                } else break;
            }
        }
 
        $ncpu = $this->grabkey('hw.ncpu');
        if (($ncpu === "") || !($ncpu >= 1)) {
            $ncpu = 1;
        }
        if (($ncpu == 1) && PSI_LOAD_BAR) {
            $dev->setLoad($this->cpuusage());
        }
        for ($ncpu ; $ncpu > 0 ; $ncpu--) {
            $this->sys->setCpus($dev);
        }
    }
 
    /**
     * Machine information
     *
     * @return void
     */
    private function machine()
    {
        if ((PSI_OS == 'NetBSD') || (PSI_OS == 'OpenBSD')) {
            $buffer = array();
            if (PSI_OS == 'NetBSD') { // NetBSD
                $buffer['Manufacturer'] = $this->grabkey('machdep.dmi.system-vendor');
                $buffer['Model'] = $this->grabkey('machdep.dmi.system-product');
                $buffer['Product'] = $this->grabkey('machdep.dmi.board-product');
                $buffer['SMBIOSBIOSVersion'] = $this->grabkey('machdep.dmi.bios-version');
                $buffer['ReleaseDate'] = $this->grabkey('machdep.dmi.bios-date');
            } else { // OpenBSD
                $buffer['Manufacturer'] = $this->grabkey('hw.vendor');
                $buffer['Model'] = $this->grabkey('hw.product');
                $buffer['Product'] = "";
                $buffer['SMBIOSBIOSVersion'] = "";
                $buffer['ReleaseDate'] = "";
            }
            if (defined('PSI_SHOW_VIRTUALIZER_INFO') && PSI_SHOW_VIRTUALIZER_INFO) {
                $vendor_array = array();
                $vendor_array[] = $buffer['Model'];
                $vendor_array[] = trim($buffer['Manufacturer']." ".$buffer['Model']);
                if (PSI_OS == 'NetBSD') { // NetBSD
                    $vendor_array[] = $this->grabkey('machdep.dmi.board-vendor');
                    $vendor_array[] = $this->grabkey('machdep.dmi.bios-vendor');
                }
                $virt = CommonFunctions::decodevirtualizer($vendor_array);
                if ($virt !== null) {
                    $this->sys->setVirtualizer($virt);
                }
            }
 
            $buf = "";
            if (($buffer['Manufacturer'] !== "") && !preg_match("/^To be filled by O\.E\.M\.$|^System manufacturer$|^Not Specified$/i", $buf2=trim($buffer['Manufacturer'])) && ($buf2 !== "")) {
                $buf .= ' '.$buf2;
            }
 
            if (($buffer['Model'] !== "") && !preg_match("/^To be filled by O\.E\.M\.$|^System Product Name$|^Not Specified$/i", $buf2=trim($buffer['Model'])) && ($buf2 !== "")) {
                $model = $buf2;
                $buf .= ' '.$buf2;
            }
            if (($buffer['Product'] !== "") && !preg_match("/^To be filled by O\.E\.M\.$|^BaseBoard Product Name$|^Not Specified$|^Default string$/i", $buf2=trim($buffer['Product'])) && ($buf2 !== "")) {
                if ($buf2 !== $model) {
                    $buf .= '/'.$buf2;
                } elseif (isset($buffer['SystemFamily']) && !preg_match("/^To be filled by O\.E\.M\.$|^System Family$|^Not Specified$/i", $buf2=trim($buffer['SystemFamily'])) && ($buf2 !== "")) {
                    $buf .= '/'.$buf2;
                }
            }
 
            $bver = "";
            $brel = "";
            if (($buf2=trim($buffer['SMBIOSBIOSVersion'])) !== "") {
                $bver .= ' '.$buf2;
            }
            if ($buffer['ReleaseDate'] !== "") {
                if (preg_match("/^(\d{4})(\d{2})(\d{2})$/", $buffer['ReleaseDate'], $dateout)) {
                    $brel .= ' '.$dateout[2].'/'.$dateout[3].'/'.$dateout[1];
                } elseif (preg_match("/^\d{2}\/\d{2}\/\d{4}$/", $buffer['ReleaseDate'])) {
                    $brel .= ' '.$buffer['ReleaseDate'];
                }
            }
            if ((trim($bver) !== "") || (trim($brel) !== "")) {
                $buf .= ', BIOS'.$bver.$brel;
            }
 
            if (trim($buf) !== "") {
                $this->sys->setMachine(trim($buf));
            }
        } elseif ((PSI_OS == 'FreeBSD') && defined('PSI_SHOW_VIRTUALIZER_INFO') && PSI_SHOW_VIRTUALIZER_INFO) {
            $vendorid = $this->grabkey('hw.hv_vendor');
            if (trim($vendorid) === "") {
                foreach ($this->readdmesg() as $line) if (preg_match("/^Hypervisor: Origin = \"(.+)\"/", $line, $ar_buf)) {
                    if (trim($ar_buf[1]) !== "") {
                        $vendorid = $ar_buf[1];
                    }
                    break;
                }
            }
            if (trim($vendorid) !== "") {
                $virt = CommonFunctions::decodevirtualizer($vendorid);
                if ($virt !== null) {
                    $this->sys->setVirtualizer($virt);
                } else {
                    $this->sys->setVirtualizer('unknown');
                }
            }
        }
    }
 
    /**
     * SCSI devices
     * get the scsi device information out of dmesg
     *
     * @return void
     */
    protected function scsi()
    {
        foreach ($this->readdmesg() as $line) {
            if (preg_match($this->_SCSIRegExp1, $line, $ar_buf) && (sizeof($ar_buf) > 2)) {
                $dev = new HWDevice();
                $dev->setName($ar_buf[1].": ".trim($ar_buf[2]));
                $this->sys->setScsiDevices($dev);
            } elseif (preg_match($this->_SCSIRegExp2, $line, $ar_buf) && (sizeof($ar_buf) > 1)) {
                /* duplication security */
                $notwas = true;
                foreach ($this->sys->getScsiDevices() as $finddev) {
                    if ($notwas && (substr($finddev->getName(), 0, strpos($finddev->getName(), ': ')) == $ar_buf[1])) {
                        if (defined('PSI_SHOW_DEVICES_INFOS') && PSI_SHOW_DEVICES_INFOS) {
                            if (isset($ar_buf[3]) && ($ar_buf[3]==="G")) {
                                $finddev->setCapacity($ar_buf[2] * 1024 * 1024 * 1024);
                            } elseif (isset($ar_buf[2])) {
                                $finddev->setCapacity($ar_buf[2] * 1024 * 1024);
                            }
                        }
                        $notwas = false;
                        break;
                    }
                }
                if ($notwas) {
                    $dev = new HWDevice();
                    $dev->setName($ar_buf[1]);
                    if (defined('PSI_SHOW_DEVICES_INFOS') && PSI_SHOW_DEVICES_INFOS) {
                        if (isset($ar_buf[3]) && ($ar_buf[3]==="G")) {
                                $dev->setCapacity($ar_buf[2] * 1024 * 1024 * 1024);
                            } elseif (isset($ar_buf[2])) {
                                $dev->setCapacity($ar_buf[2] * 1024 * 1024);
                            }
                    }
                    $this->sys->setScsiDevices($dev);
                }
            } elseif (preg_match($this->_SCSIRegExp3, $line, $ar_buf) && (sizeof($ar_buf) > 1)) {
                /* duplication security */
                $notwas = true;
                foreach ($this->sys->getScsiDevices() as $finddev) {
                    if ($notwas && (substr($finddev->getName(), 0, strpos($finddev->getName(), ': ')) == $ar_buf[1])) {
                        if (defined('PSI_SHOW_DEVICES_INFOS') && PSI_SHOW_DEVICES_INFOS
                           && defined('PSI_SHOW_DEVICES_SERIAL') && PSI_SHOW_DEVICES_SERIAL) {
                            if (isset($ar_buf[2])) $finddev->setSerial(trim($ar_buf[2]));
                        }
                        $notwas = false;
                        break;
                    }
                }
                if ($notwas) {
                    $dev = new HWDevice();
                    $dev->setName($ar_buf[1]);
                    if (defined('PSI_SHOW_DEVICES_INFOS') && PSI_SHOW_DEVICES_INFOS
                       && defined('PSI_SHOW_DEVICES_SERIAL') && PSI_SHOW_DEVICES_SERIAL) {
                        if (isset($ar_buf[2])) $dev->setSerial(trim($ar_buf[2]));
                    }
                    $this->sys->setScsiDevices($dev);
                }
            }
        }
        /* cleaning */
        foreach ($this->sys->getScsiDevices() as $finddev) {
            if (strpos($finddev->getName(), ': ') !== false)
                $finddev->setName(substr(strstr($finddev->getName(), ': '), 2));
        }
    }
 
    /**
     * parsing the output of pciconf command
     *
     * @return Array
     */
    protected function pciconf()
    {
        $arrResults = array();
        $intS = 0;
        if (CommonFunctions::executeProgram("pciconf", "-lv", $strBuf, PSI_DEBUG)) {
            $arrTemp = array();
            $arrBlocks = preg_split("/\n\S/", $strBuf, -1, PREG_SPLIT_NO_EMPTY);
            foreach ($arrBlocks as $strBlock) {
                $arrLines = preg_split("/\n/", $strBlock, -1, PREG_SPLIT_NO_EMPTY);
                $vend = null;
                foreach ($arrLines as $strLine) {
                    if (preg_match("/\sclass=0x([a-fA-F0-9]{4})[a-fA-F0-9]{2}\s.*\schip=0x([a-fA-F0-9]{4})([a-fA-F0-9]{4})\s/", $strLine, $arrParts)) {
                        $arrTemp[$intS] = 'Class '.$arrParts[1].': Device '.$arrParts[3].':'.$arrParts[2];
                        $vend = '';
                    } elseif (preg_match("/(.*) = '(.*)'/", $strLine, $arrParts)) {
                        if (trim($arrParts[1]) == "vendor") {
                            $vend = trim($arrParts[2]);
                        } elseif (trim($arrParts[1]) == "device") {
                            if (($vend !== null) && ($vend !== '')) {
                                $arrTemp[$intS] = $vend." - ".trim($arrParts[2]);
                            } else {
                                $arrTemp[$intS] = trim($arrParts[2]);
                                $vend = '';
                            }
                        }
                    }
                }
                if ($vend !== null) {
                    $intS++;
                }
            }
            foreach ($arrTemp as $name) {
                $dev = new HWDevice();
                $dev->setName($name);
                $arrResults[] = $dev;
            }
        }
 
        return $arrResults;
    }
 
    /**
     * PCI devices
     * get the pci device information out of dmesg
     *
     * @return void
     */
    protected function pci()
    {
        if ((!$results = Parser::lspci(false)) && (!$results = $this->pciconf())) {
            foreach ($this->readdmesg() as $line) {
                if (preg_match($this->_PCIRegExp1, $line, $ar_buf) && (sizeof($ar_buf) > 2)) {
                    $dev = new HWDevice();
                    $dev->setName($ar_buf[1].": ".$ar_buf[2]);
                    $results[] = $dev;
                } elseif (preg_match($this->_PCIRegExp2, $line, $ar_buf) && (sizeof($ar_buf) > 2)) {
                    $dev = new HWDevice();
                    $dev->setName($ar_buf[1].": ".$ar_buf[2]);
                    $results[] = $dev;
                }
            }
        }
        foreach ($results as $dev) {
            $this->sys->setPciDevices($dev);
        }
    }
 
    /**
     * IDE devices
     * get the ide device information out of dmesg
     *
     * @return void
     */
    protected function ide()
    {
        foreach ($this->readdmesg() as $line) {
            if (preg_match('/^(ad[0-9]+): (.*)MB <(.*)> (.*) (.*)/', $line, $ar_buf)) {
                $dev = new HWDevice();
                $dev->setName($ar_buf[1].": ".trim($ar_buf[3]));
                if (defined('PSI_SHOW_DEVICES_INFOS') && PSI_SHOW_DEVICES_INFOS) {
                    $dev->setCapacity($ar_buf[2] * 1024 * 1024);
                }
                $this->sys->setIdeDevices($dev);
            } elseif (preg_match('/^(acd[0-9]+): (.*) <(.*)> (.*)/', $line, $ar_buf)) {
                $dev = new HWDevice();
                $dev->setName($ar_buf[1].": ".trim($ar_buf[3]));
                $this->sys->setIdeDevices($dev);
            } elseif (preg_match('/^(ada[0-9]+): <(.*)> (.*)/', $line, $ar_buf)) {
                $dev = new HWDevice();
                $dev->setName($ar_buf[1].": ".trim($ar_buf[2]));
                $this->sys->setIdeDevices($dev);
            } elseif (preg_match('/^(ada[0-9]+): (.*)MB \((.*)\)/', $line, $ar_buf)) {
                /* duplication security */
                $notwas = true;
                foreach ($this->sys->getIdeDevices() as $finddev) {
                    if ($notwas && (substr($finddev->getName(), 0, strpos($finddev->getName(), ': ')) == $ar_buf[1])) {
                        if (defined('PSI_SHOW_DEVICES_INFOS') && PSI_SHOW_DEVICES_INFOS) {
                            $finddev->setCapacity($ar_buf[2] * 1024 * 1024);
                        }
                        $notwas = false;
                        break;
                    }
                }
                if ($notwas) {
                    $dev = new HWDevice();
                    $dev->setName($ar_buf[1]);
                    if (defined('PSI_SHOW_DEVICES_INFOS') && PSI_SHOW_DEVICES_INFOS) {
                        $dev->setCapacity($ar_buf[2] * 1024 * 1024);
                    }
                    $this->sys->setIdeDevices($dev);
                }
            } elseif (preg_match('/^(ada[0-9]+): Serial Number (.*)/', $line, $ar_buf)) {
                /* duplication security */
                $notwas = true;
                foreach ($this->sys->getIdeDevices() as $finddev) {
                    if ($notwas && (substr($finddev->getName(), 0, strpos($finddev->getName(), ': ')) == $ar_buf[1])) {
                        if (defined('PSI_SHOW_DEVICES_INFOS') && PSI_SHOW_DEVICES_INFOS
                           && defined('PSI_SHOW_DEVICES_SERIAL') && PSI_SHOW_DEVICES_SERIAL) {
                            $finddev->setSerial(trim($ar_buf[2]));
                        }
                        $notwas = false;
                        break;
                    }
                }
                if ($notwas) {
                    $dev = new HWDevice();
                    $dev->setName($ar_buf[1]);
                    if (defined('PSI_SHOW_DEVICES_INFOS') && PSI_SHOW_DEVICES_INFOS
                       && defined('PSI_SHOW_DEVICES_SERIAL') && PSI_SHOW_DEVICES_SERIAL) {
                        $finddev->setSerial(trim($ar_buf[2]));
                    }
                    $this->sys->setIdeDevices($dev);
                }
            }
        }
        /* cleaning */
        foreach ($this->sys->getIdeDevices() as $finddev) {
                    if (strpos($finddev->getName(), ': ') !== false)
                        $finddev->setName(substr(strstr($finddev->getName(), ': '), 2));
        }
    }
 
    /**
     * Physical memory information and Swap Space information
     *
     * @return void
     */
    protected function memory()
    {
        if (PSI_OS == 'FreeBSD' || PSI_OS == 'OpenBSD') {
            // vmstat on fbsd 4.4 or greater outputs kbytes not hw.pagesize
            // I should probably add some version checking here, but for now
            // we only support fbsd 4.4
            $pagesize = 1024;
        } else {
            $pagesize = $this->grabkey('hw.pagesize');
        }
        if (CommonFunctions::executeProgram('vmstat', '', $vmstat, PSI_DEBUG)) {
            $lines = preg_split("/\n/", $vmstat, -1, PREG_SPLIT_NO_EMPTY);
            $ar_buf = preg_split("/\s+/", trim($lines[2]), 19);
            if (PSI_OS == 'NetBSD' || PSI_OS == 'DragonFly') {
                $this->sys->setMemFree($ar_buf[4] * 1024);
            } else {
                $this->sys->setMemFree($ar_buf[4] * $pagesize);
            }
            $this->sys->setMemTotal($this->grabkey('hw.physmem'));
            $this->sys->setMemUsed($this->sys->getMemTotal() - $this->sys->getMemFree());
 
            if (((PSI_OS == 'OpenBSD' || PSI_OS == 'NetBSD') && CommonFunctions::executeProgram('swapctl', '-l -k', $swapstat, PSI_DEBUG)) || CommonFunctions::executeProgram('swapinfo', '-k', $swapstat, PSI_DEBUG)) {
                $lines = preg_split("/\n/", $swapstat, -1, PREG_SPLIT_NO_EMPTY);
                foreach ($lines as $line) {
                    $ar_buf = preg_split("/\s+/", $line, 6);
                    if (($ar_buf[0] != 'Total') && ($ar_buf[0] != 'Device')) {
                        $dev = new DiskDevice();
                        $dev->setMountPoint($ar_buf[0]);
                        $dev->setName("SWAP");
                        $dev->setFsType('swap');
                        $dev->setTotal($ar_buf[1] * 1024);
                        $dev->setUsed($ar_buf[2] * 1024);
                        $dev->setFree($dev->getTotal() - $dev->getUsed());
                        $this->sys->setSwapDevices($dev);
                    }
                }
            }
        }
    }
 
    /**
     * USB devices
     * get the ide device information out of dmesg
     *
     * @return void
     */
    protected function usb()
    {
        $notwas = true;
        if ((PSI_OS == 'FreeBSD') && CommonFunctions::executeProgram('usbconfig', '', $bufr, false)) {
            $lines = preg_split("/\n/", $bufr, -1, PREG_SPLIT_NO_EMPTY);
            foreach ($lines as $line) {
                if (preg_match('/^(ugen[0-9]+\.[0-9]+): <([^,]*)(.*)> at (usbus[0-9]+)/', $line, $ar_buf)) {
                    $notwas = false;
                    $dev = new HWDevice();
                    $dev->setName($ar_buf[2]);
                    $this->sys->setUSBDevices($dev);
                }
            }
        }
        if ($notwas) foreach ($this->readdmesg() as $line) {
//            if (preg_match('/^(ugen[0-9\.]+): <(.*)> (.*) (.*)/', $line, $ar_buf)) {
//                    $dev->setName($ar_buf[1].": ".$ar_buf[2]);
            if (preg_match('/^(u[a-z]+[0-9]+): <([^,]*)(.*)> on (usbus[0-9]+)/', $line, $ar_buf)) {
                    $dev = new HWDevice();
                    $dev->setName($ar_buf[2]);
                    $this->sys->setUSBDevices($dev);
            }
        }
    }
 
    /**
     * filesystem information
     *
     * @return void
     */
    protected function filesystems()
    {
        $arrResult = Parser::df();
        foreach ($arrResult as $dev) {
            $this->sys->setDiskDevices($dev);
        }
    }
 
    /**
     * Distribution
     *
     * @return void
     */
    protected function distro()
    {
        if (CommonFunctions::executeProgram('uname', '-s', $result, PSI_DEBUG)) {
            $this->sys->setDistribution($result);
        }
    }
 
    /**
     * UpTime
     * time the system is running
     *
     * @return void
     */
    private function uptime()
    {
        if ($kb = $this->grabkey('kern.boottime')) {
            if (preg_match("/sec = ([0-9]+)/", $kb, $buf)) { // format like: { sec = 1096732600, usec = 885425 } Sat Oct 2 10:56:40 2004
                $this->sys->setUptime(time() - $buf[1]);
            } else {
                date_default_timezone_set('UTC');
                $kbt = strtotime($kb);
                if (($kbt !== false) && ($kbt != -1)) {
                    $this->sys->setUptime(time() - $kbt); // format like: Sat Oct 2 10:56:40 2004
                } else {
                    $this->sys->setUptime(time() - $kb); // format like: 1096732600
                }
            }
        }
    }
 
    /**
     * get the information
     *
     * @see PSI_Interface_OS::build()
     *
     * @return void
     */
    public function build()
    {
        if (!$this->blockname || $this->blockname==='vitals') {
            $this->distro();
            $this->hostname();
            $this->kernel();
            $this->_users();
            $this->loadavg();
            $this->uptime();
        }
        if (!$this->blockname || $this->blockname==='hardware') {
            $this->machine();
            $this->cpuinfo();
            $this->virtualizer();
            $this->pci();
            $this->ide();
            $this->scsi();
            $this->usb();
        }
        if (!$this->blockname || $this->blockname==='memory') {
            $this->memory();
        }
        if (!$this->blockname || $this->blockname==='filesystem') {
            $this->filesystems();
        }
    }
}
 

Rev 3037	Rev 3100
1	`<?php`	1	`<?php`
2	`/**`	2	`/**`
3	`* BSDCommon Class`	3	`* BSDCommon Class`
4	`*`	4	`*`
5	`* PHP version 5`	5	`* PHP version 5`
6	`*`	6	`*`
7	`* @category PHP`	7	`* @category PHP`
8	`* @package PSI BSDCommon OS class`	8	`* @package PSI BSDCommon OS class`
9	`* @author Michael Cramer <BigMichi1@users.sourceforge.net>`	9	`* @author Michael Cramer <BigMichi1@users.sourceforge.net>`
10	`* @copyright 2009 phpSysInfo`	10	`* @copyright 2009 phpSysInfo`
11	`* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License version 2, or (at your option) any later version`	11	`* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License version 2, or (at your option) any later version`
12	`* @version SVN: $Id: class.BSDCommon.inc.php 621 2012-07-29 18:49:04Z namiltd $`	12	`* @version SVN: $Id: class.BSDCommon.inc.php 621 2012-07-29 18:49:04Z namiltd $`
13	`* @link http://phpsysinfo.sourceforge.net`	13	`* @link http://phpsysinfo.sourceforge.net`
14	`*/`	14	`*/`
15	`/**`	15	`/**`
16	`* BSDCommon class`	16	`* BSDCommon class`
17	`* get all the required information for BSD Like systems`	17	`* get all the required information for BSD Like systems`
18	`* no need to implement in every class the same methods`	18	`* no need to implement in every class the same methods`
19	`*`	19	`*`
20	`* @category PHP`	20	`* @category PHP`
21	`* @package PSI BSDCommon OS class`	21	`* @package PSI BSDCommon OS class`
22	`* @author Michael Cramer <BigMichi1@users.sourceforge.net>`	22	`* @author Michael Cramer <BigMichi1@users.sourceforge.net>`
23	`* @copyright 2009 phpSysInfo`	23	`* @copyright 2009 phpSysInfo`
24	`* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License version 2, or (at your option) any later version`	24	`* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License version 2, or (at your option) any later version`
25	`* @version Release: 3.0`	25	`* @version Release: 3.0`
26	`* @link http://phpsysinfo.sourceforge.net`	26	`* @link http://phpsysinfo.sourceforge.net`
27	`*/`	27	`*/`
28	`abstract class BSDCommon extends OS`	28	`abstract class BSDCommon extends OS`
29	`{`	29	`{`
30	`/**`	30	`/**`
31	`* Assoc array of all CPUs loads.`	31	`* Assoc array of all CPUs loads.`
32	`*/`	32	`*/`
33	`private $_cpu_loads = null;`	33	`private $_cpu_loads = null;`
34		34
35	`/**`	35	`/**`
36	`* content of the syslog`	36	`* content of the syslog`
37	`*`	37	`*`
38	`* @var array`	38	`* @var array`
39	`*/`	39	`*/`
40	`private $_dmesg = null;`	40	`private $_dmesg = null;`
41		41
42	`/**`	42	`/**`
43	`* regexp1 for cpu information out of the syslog`	43	`* regexp1 for cpu information out of the syslog`
44	`*`	44	`*`
45	`* @var string`	45	`* @var string`
46	`*/`	46	`*/`
47	`private $_CPURegExp1 = "//";`	47	`private $_CPURegExp1 = "//";`
48		48
49	`/**`	49	`/**`
50	`* regexp2 for cpu information out of the syslog`	50	`* regexp2 for cpu information out of the syslog`
51	`*`	51	`*`
52	`* @var string`	52	`* @var string`
53	`*/`	53	`*/`
54	`private $_CPURegExp2 = "//";`	54	`private $_CPURegExp2 = "//";`
55		55
56	`/**`	56	`/**`
57	`* regexp1 for scsi information out of the syslog`	57	`* regexp1 for scsi information out of the syslog`
58	`*`	58	`*`
59	`* @var string`	59	`* @var string`
60	`*/`	60	`*/`
61	`private $_SCSIRegExp1 = "//";`	61	`private $_SCSIRegExp1 = "//";`
62		62
63	`/**`	63	`/**`
64	`* regexp2 for scsi information out of the syslog`	64	`* regexp2 for scsi information out of the syslog`
65	`*`	65	`*`
66	`* @var string`	66	`* @var string`
67	`*/`	67	`*/`
68	`private $_SCSIRegExp2 = "//";`	68	`private $_SCSIRegExp2 = "//";`
69		69
70	`/**`	70	`/**`
71	`* regexp3 for scsi information out of the syslog`	71	`* regexp3 for scsi information out of the syslog`
72	`*`	72	`*`
73	`* @var string`	73	`* @var string`
74	`*/`	74	`*/`
75	`private $_SCSIRegExp3 = "//";`	75	`private $_SCSIRegExp3 = "//";`
76		76
77	`/**`	77	`/**`
78	`* regexp1 for pci information out of the syslog`	78	`* regexp1 for pci information out of the syslog`
79	`*`	79	`*`
80	`* @var string`	80	`* @var string`
81	`*/`	81	`*/`
82	`private $_PCIRegExp1 = "//";`	82	`private $_PCIRegExp1 = "//";`
83		83
84	`/**`	84	`/**`
85	`* regexp1 for pci information out of the syslog`	85	`* regexp1 for pci information out of the syslog`
86	`*`	86	`*`
87	`* @var string`	87	`* @var string`
88	`*/`	88	`*/`
89	`private $_PCIRegExp2 = "//";`	89	`private $_PCIRegExp2 = "//";`
90		90
91	`/**`	91	`/**`
92	`* setter for cpuregexp1`	92	`* setter for cpuregexp1`
93	`*`	93	`*`
94	`* @param string $value value to set`	94	`* @param string $value value to set`
95	`*`	95	`*`
96	`* @return void`	96	`* @return void`
97	`*/`	97	`*/`
98	`protected function setCPURegExp1($value)`	98	`protected function setCPURegExp1($value)`
99	`{`	99	`{`
100	`$this->_CPURegExp1 = $value;`	100	`$this->_CPURegExp1 = $value;`
101	`}`	101	`}`
102		102
103	`/**`	103	`/**`
104	`* setter for cpuregexp2`	104	`* setter for cpuregexp2`
105	`*`	105	`*`
106	`* @param string $value value to set`	106	`* @param string $value value to set`
107	`*`	107	`*`
108	`* @return void`	108	`* @return void`
109	`*/`	109	`*/`
110	`protected function setCPURegExp2($value)`	110	`protected function setCPURegExp2($value)`
111	`{`	111	`{`
112	`$this->_CPURegExp2 = $value;`	112	`$this->_CPURegExp2 = $value;`
113	`}`	113	`}`
114		114
115	`/**`	115	`/**`
116	`* setter for scsiregexp1`	116	`* setter for scsiregexp1`
117	`*`	117	`*`
118	`* @param string $value value to set`	118	`* @param string $value value to set`
119	`*`	119	`*`
120	`* @return void`	120	`* @return void`
121	`*/`	121	`*/`
122	`protected function setSCSIRegExp1($value)`	122	`protected function setSCSIRegExp1($value)`
123	`{`	123	`{`
124	`$this->_SCSIRegExp1 = $value;`	124	`$this->_SCSIRegExp1 = $value;`
125	`}`	125	`}`
126		126
127	`/**`	127	`/**`
128	`* setter for scsiregexp2`	128	`* setter for scsiregexp2`
129	`*`	129	`*`
130	`* @param string $value value to set`	130	`* @param string $value value to set`
131	`*`	131	`*`
132	`* @return void`	132	`* @return void`
133	`*/`	133	`*/`
134	`protected function setSCSIRegExp2($value)`	134	`protected function setSCSIRegExp2($value)`
135	`{`	135	`{`
136	`$this->_SCSIRegExp2 = $value;`	136	`$this->_SCSIRegExp2 = $value;`
137	`}`	137	`}`
138		138
139	`/**`	139	`/**`
140	`* setter for scsiregexp3`	140	`* setter for scsiregexp3`
141	`*`	141	`*`
142	`* @param string $value value to set`	142	`* @param string $value value to set`
143	`*`	143	`*`
144	`* @return void`	144	`* @return void`
145	`*/`	145	`*/`
146	`protected function setSCSIRegExp3($value)`	146	`protected function setSCSIRegExp3($value)`
147	`{`	147	`{`
148	`$this->_SCSIRegExp3 = $value;`	148	`$this->_SCSIRegExp3 = $value;`
149	`}`	149	`}`
150		150
151	`/**`	151	`/**`
152	`* setter for pciregexp1`	152	`* setter for pciregexp1`
153	`*`	153	`*`
154	`* @param string $value value to set`	154	`* @param string $value value to set`
155	`*`	155	`*`
156	`* @return void`	156	`* @return void`
157	`*/`	157	`*/`
158	`protected function setPCIRegExp1($value)`	158	`protected function setPCIRegExp1($value)`
159	`{`	159	`{`
160	`$this->_PCIRegExp1 = $value;`	160	`$this->_PCIRegExp1 = $value;`
161	`}`	161	`}`
162		162
163	`/**`	163	`/**`
164	`* setter for pciregexp2`	164	`* setter for pciregexp2`
165	`*`	165	`*`
166	`* @param string $value value to set`	166	`* @param string $value value to set`
167	`*`	167	`*`
168	`* @return void`	168	`* @return void`
169	`*/`	169	`*/`
170	`protected function setPCIRegExp2($value)`	170	`protected function setPCIRegExp2($value)`
171	`{`	171	`{`
172	`$this->_PCIRegExp2 = $value;`	172	`$this->_PCIRegExp2 = $value;`
173	`}`	173	`}`
174		174
175	`/**`	175	`/**`
176	`* read /var/run/dmesg.boot, but only if we haven't already`	176	`* read /var/run/dmesg.boot, but only if we haven't already`
177	`*`	177	`*`
178	`* @return array`	178	`* @return array`
179	`*/`	179	`*/`
180	`protected function readdmesg()`	180	`protected function readdmesg()`
181	`{`	181	`{`
182	`if ($this->_dmesg === null) {`	182	`if ($this->_dmesg === null) {`
183	`if ((PSI_OS != 'Darwin') && (CommonFunctions::rfts('/var/run/dmesg.boot', $buf, 0, 4096, false) \|\| CommonFunctions::rfts('/var/log/dmesg.boot', $buf, 0, 4096, false) \|\| CommonFunctions::rfts('/var/run/dmesg.boot', $buf))) { // Once again but with debug`	183	`if ((PSI_OS != 'Darwin') && (CommonFunctions::rfts('/var/run/dmesg.boot', $buf, 0, 4096, false) \|\| CommonFunctions::rfts('/var/log/dmesg.boot', $buf, 0, 4096, false) \|\| CommonFunctions::rfts('/var/run/dmesg.boot', $buf))) { // Once again but with debug`
184	`$parts = preg_split("/rebooting\|Uptime/", $buf, -1, PREG_SPLIT_NO_EMPTY);`	184	`$parts = preg_split("/rebooting\|Uptime/", $buf, -1, PREG_SPLIT_NO_EMPTY);`
185	`$this->_dmesg = preg_split("/\n/", $parts[count($parts) - 1], -1, PREG_SPLIT_NO_EMPTY);`	185	`$this->_dmesg = preg_split("/\n/", $parts[count($parts) - 1], -1, PREG_SPLIT_NO_EMPTY);`
186	`} else {`	186	`} else {`
187	`$this->_dmesg = array();`	187	`$this->_dmesg = array();`
188	`}`	188	`}`
189	`}`	189	`}`
190		190
191	`return $this->_dmesg;`	191	`return $this->_dmesg;`
192	`}`	192	`}`
193		193
194	`/**`	194	`/**`
195	`* get a value from sysctl command`	195	`* get a value from sysctl command`
196	`*`	196	`*`
197	`* @param string $key key for the value to get`	197	`* @param string $key key for the value to get`
198	`*`	198	`*`
199	`* @return string`	199	`* @return string`
200	`*/`	200	`*/`
201	`protected function grabkey($key)`	201	`protected function grabkey($key)`
202	`{`	202	`{`
203	`$buf = "";`	203	`$buf = "";`
204	`if (CommonFunctions::executeProgram('sysctl', "-n $key", $buf, PSI_DEBUG)) {`	204	`if (CommonFunctions::executeProgram('sysctl', "-n $key", $buf, PSI_DEBUG)) {`
205	`return $buf;`	205	`return $buf;`
206	`} else {`	206	`} else {`
207	`return '';`	207	`return '';`
208	`}`	208	`}`
209	`}`	209	`}`
210		210
211	`/**`	211	`/**`
212	`* Virtual Host Name`	212	`* Virtual Host Name`
213	`*`	213	`*`
214	`* @return void`	214	`* @return void`
215	`*/`	215	`*/`
216	`protected function hostname()`	216	`protected function hostname()`
217	`{`	217	`{`
218	`if (PSI_USE_VHOST) {`	218	`if (PSI_USE_VHOST) {`
219	`if (CommonFunctions::readenv('SERVER_NAME', $hnm)) $this->sys->setHostname($hnm);`	219	`if (CommonFunctions::readenv('SERVER_NAME', $hnm)) $this->sys->setHostname($hnm);`
220	`} else {`	220	`} else {`
221	`if (CommonFunctions::executeProgram('hostname', '', $buf, PSI_DEBUG)) {`	221	`if (CommonFunctions::executeProgram('hostname', '', $buf, PSI_DEBUG)) {`
222	`$this->sys->setHostname($buf);`	222	`$this->sys->setHostname($buf);`
223	`}`	223	`}`
224	`}`	224	`}`
225	`}`	225	`}`
226		226
227	`/**`	227	`/**`
228	`* Kernel Version`	228	`* Kernel Version`
229	`*`	229	`*`
230	`* @return void`	230	`* @return void`
231	`*/`	231	`*/`
232	`protected function kernel()`	232	`protected function kernel()`
233	`{`	233	`{`
234	`$s = $this->grabkey('kern.version');`	234	`$s = $this->grabkey('kern.version');`
235	`$a = preg_split('/:/', $s);`	235	`$a = preg_split('/:/', $s, 4);`
236	`if (isset($a[2])) {`	236	`if (isset($a[3])) {`
-		237	`if (preg_match('/^(\d{2} [A-Z]{3});/', $a[3], $abuf) // eg. 19:58 GMT;...`
-		238	`\|\| preg_match('/^(\d{2} [A-Z]{3} \d{4})/', $a[3], $abuf)) { // eg. 26:31 PDT 2019...`
-		239	`$this->sys->setKernel($a[0].$a[1].':'.$a[2].':'.$abuf[1]);`
-		240	`} else {`
-		241	`$this->sys->setKernel($a[0].$a[1].':'.$a[2]);`
-		242	`}`
-		243	`} elseif (isset($a[2])) {`
237	`$this->sys->setKernel($a[0].$a[1].':'.$a[2]);`	244	`$this->sys->setKernel($a[0].$a[1].':'.$a[2]);`
238	`} else {`	245	`} else {`
239	`$this->sys->setKernel($s);`	246	`$this->sys->setKernel($s);`
240	`}`	247	`}`
241	`}`	248	`}`
242		249
243	`/**`	250	`/**`
244	`* Virtualizer info`	251	`* Virtualizer info`
245	`*`	252	`*`
246	`* @return void`	253	`* @return void`
247	`*/`	254	`*/`
248	`private function virtualizer()`	255	`private function virtualizer()`
249	`{`	256	`{`
250	`if (defined('PSI_SHOW_VIRTUALIZER_INFO') && PSI_SHOW_VIRTUALIZER_INFO) {`	257	`if (defined('PSI_SHOW_VIRTUALIZER_INFO') && PSI_SHOW_VIRTUALIZER_INFO) {`
251	`$testvirt = $this->sys->getVirtualizer();`	258	`$testvirt = $this->sys->getVirtualizer();`
252	`$novm = true;`	259	`$novm = true;`
253	`foreach ($testvirt as $virtkey=>$virtvalue) if ($virtvalue) {`	260	`foreach ($testvirt as $virtkey=>$virtvalue) if ($virtvalue) {`
254	`$novm = false;`	261	`$novm = false;`
255	`break;`	262	`break;`
256	`}`	263	`}`
257	`// Detect QEMU cpu`	264	`// Detect QEMU cpu`
258	`if ($novm && isset($testvirt["cpuid:QEMU"])) {`	265	`if ($novm && isset($testvirt["cpuid:QEMU"])) {`
259	`$this->sys->setVirtualizer('qemu'); // QEMU`	266	`$this->sys->setVirtualizer('qemu'); // QEMU`
260	`$novm = false;`	267	`$novm = false;`
261	`}`	268	`}`
262		269
263	`if ($novm && isset($testvirt["hypervisor"])) {`	270	`if ($novm && isset($testvirt["hypervisor"])) {`
264	`$this->sys->setVirtualizer('unknown');`	271	`$this->sys->setVirtualizer('unknown');`
265	`}`	272	`}`
266	`}`	273	`}`
267	`}`	274	`}`
268		275
269	`/**`	276	`/**`
270	`* CPU usage`	277	`* CPU usage`
271	`*`	278	`*`
272	`* @return void`	279	`* @return void`
273	`*/`	280	`*/`
274	`protected function cpuusage()`	281	`protected function cpuusage()`
275	`{`	282	`{`
276	`if (($this->_cpu_loads === null)) {`	283	`if (($this->_cpu_loads === null)) {`
277	`$this->_cpu_loads = array();`	284	`$this->_cpu_loads = array();`
278	`if (PSI_OS != 'Darwin') {`	285	`if (PSI_OS != 'Darwin') {`
279	`if ($fd = $this->grabkey('kern.cp_time')) {`	286	`if ($fd = $this->grabkey('kern.cp_time')) {`
280	`// Find out the CPU load`	287	`// Find out the CPU load`
281	`// user + sys = load`	288	`// user + sys = load`
282	`// total = total`	289	`// total = total`
283	`if (preg_match($this->_CPURegExp2, $fd, $res) && (sizeof($res) > 4)) {`	290	`if (preg_match($this->_CPURegExp2, $fd, $res) && (sizeof($res) > 4)) {`
284	`$load = $res[2] + $res[3] + $res[4]; // cpu.user + cpu.sys`	291	`$load = $res[2] + $res[3] + $res[4]; // cpu.user + cpu.sys`
285	`$total = $res[2] + $res[3] + $res[4] + $res[5]; // cpu.total`	292	`$total = $res[2] + $res[3] + $res[4] + $res[5]; // cpu.total`
286	`// we need a second value, wait 1 second befor getting (< 1 second no good value will occour)`	293	`// we need a second value, wait 1 second befor getting (< 1 second no good value will occour)`
287	`sleep(1);`	294	`sleep(1);`
288	`$fd = $this->grabkey('kern.cp_time');`	295	`$fd = $this->grabkey('kern.cp_time');`
289	`if (preg_match($this->_CPURegExp2, $fd, $res) && (sizeof($res) > 4)) {`	296	`if (preg_match($this->_CPURegExp2, $fd, $res) && (sizeof($res) > 4)) {`
290	`$load2 = $res[2] + $res[3] + $res[4];`	297	`$load2 = $res[2] + $res[3] + $res[4];`
291	`$total2 = $res[2] + $res[3] + $res[4] + $res[5];`	298	`$total2 = $res[2] + $res[3] + $res[4] + $res[5];`
292	`if ($total2 != $total) {`	299	`if ($total2 != $total) {`
293	`$this->_cpu_loads['cpu'] = (100 * ($load2 - $load)) / ($total2 - $total);`	300	`$this->_cpu_loads['cpu'] = (100 * ($load2 - $load)) / ($total2 - $total);`
294	`} else {`	301	`} else {`
295	`$this->_cpu_loads['cpu'] = 0;`	302	`$this->_cpu_loads['cpu'] = 0;`
296	`}`	303	`}`
297	`}`	304	`}`
298	`}`	305	`}`
299	`}`	306	`}`
300	`} else {`	307	`} else {`
301	`$ncpu = $this->grabkey('hw.ncpu');`	308	`$ncpu = $this->grabkey('hw.ncpu');`
302	`if (($ncpu !== "") && ($ncpu >= 1) && CommonFunctions::executeProgram('ps', "-A -o %cpu", $pstable, false) && !empty($pstable)) {`	309	`if (($ncpu !== "") && ($ncpu >= 1) && CommonFunctions::executeProgram('ps', "-A -o %cpu", $pstable, false) && !empty($pstable)) {`
303	`$pslines = preg_split("/\n/", $pstable, -1, PREG_SPLIT_NO_EMPTY);`	310	`$pslines = preg_split("/\n/", $pstable, -1, PREG_SPLIT_NO_EMPTY);`
304	`if (!empty($pslines) && (count($pslines)>1) && (trim($pslines[0])==="%CPU")) {`	311	`if (!empty($pslines) && (count($pslines)>1) && (trim($pslines[0])==="%CPU")) {`
305	`array_shift($pslines);`	312	`array_shift($pslines);`
306	`$sum = 0;`	313	`$sum = 0;`
307	`foreach ($pslines as $psline) {`	314	`foreach ($pslines as $psline) {`
308	`$sum+=trim($psline);`	315	`$sum+=str_replace(',', '.', trim($psline));`
309	`}`	316	`}`
310	`$this->_cpu_loads['cpu'] = min($sum/$ncpu, 100);`	317	`$this->_cpu_loads['cpu'] = min($sum/$ncpu, 100);`
311	`}`	318	`}`
312	`}`	319	`}`
313	`}`	320	`}`
314	`}`	321	`}`
315		322
316	`if (isset($this->_cpu_loads['cpu'])) {`	323	`if (isset($this->_cpu_loads['cpu'])) {`
317	`return $this->_cpu_loads['cpu'];`	324	`return $this->_cpu_loads['cpu'];`
318	`} else {`	325	`} else {`
319	`return null;`	326	`return null;`
320	`}`	327	`}`
321	`}`	328	`}`
322		329
323	`/**`	330	`/**`
324	`* Processor Load`	331	`* Processor Load`
325	`* optionally create a loadbar`	332	`* optionally create a loadbar`
326	`*`	333	`*`
327	`* @return void`	334	`* @return void`
328	`*/`	335	`*/`
329	`protected function loadavg()`	336	`protected function loadavg()`
330	`{`	337	`{`
331	`$s = $this->grabkey('vm.loadavg');`	338	`$s = $this->grabkey('vm.loadavg');`
332	`$s = preg_replace('/{ /', '', $s);`	339	`$s = preg_replace('/{ /', '', $s);`
333	`$s = preg_replace('/ }/', '', $s);`	340	`$s = preg_replace('/ }/', '', $s);`
-		341	`$s = str_replace(',', '.', $s);`
334	`$this->sys->setLoad($s);`	342	`$this->sys->setLoad($s);`
335		343
336	`if (PSI_LOAD_BAR) {`	344	`if (PSI_LOAD_BAR) {`
337	`$this->sys->setLoadPercent($this->cpuusage());`	345	`$this->sys->setLoadPercent($this->cpuusage());`
338	`}`	346	`}`
339	`}`	347	`}`
340		348
341	`/**`	349	`/**`
342	`* CPU information`	350	`* CPU information`
343	`*`	351	`*`
344	`* @return void`	352	`* @return void`
345	`*/`	353	`*/`
346	`protected function cpuinfo()`	354	`protected function cpuinfo()`
347	`{`	355	`{`
348	`$dev = new CpuDevice();`	356	`$dev = new CpuDevice();`
349	`$cpumodel = $this->grabkey('hw.model');`	357	`$cpumodel = $this->grabkey('hw.model');`
350	`$dev->setModel($cpumodel);`	358	`$dev->setModel($cpumodel);`
351	`if (defined('PSI_SHOW_VIRTUALIZER_INFO') && PSI_SHOW_VIRTUALIZER_INFO && preg_match('/^QEMU Virtual CPU version /', $cpumodel)) {`	359	`if (defined('PSI_SHOW_VIRTUALIZER_INFO') && PSI_SHOW_VIRTUALIZER_INFO && preg_match('/^QEMU Virtual CPU version /', $cpumodel)) {`
352	`$this->sys->setVirtualizer("cpuid:QEMU", false);`	360	`$this->sys->setVirtualizer("cpuid:QEMU", false);`
353	`}`	361	`}`
354		362
355	`$notwas = true;`	363	`$notwas = true;`
356	`foreach ($this->readdmesg() as $line) {`	364	`foreach ($this->readdmesg() as $line) {`
357	`if ($notwas) {`	365	`if ($notwas) {`
358	`$regexps = preg_split("/\n/", $this->_CPURegExp1, -1, PREG_SPLIT_NO_EMPTY); // multiple regexp separated by \n`	366	`$regexps = preg_split("/\n/", $this->_CPURegExp1, -1, PREG_SPLIT_NO_EMPTY); // multiple regexp separated by \n`
359	`foreach ($regexps as $regexp) {`	367	`foreach ($regexps as $regexp) {`
360	`if (preg_match($regexp, $line, $ar_buf) && (sizeof($ar_buf) > 2)) {`	368	`if (preg_match($regexp, $line, $ar_buf) && (sizeof($ar_buf) > 2)) {`
361	`if ($dev->getCpuSpeed() === 0) {`	369	`if ($dev->getCpuSpeed() == 0) {`
362	`$dev->setCpuSpeed(round($ar_buf[2]));`	370	`$dev->setCpuSpeed(round($ar_buf[2]));`
363	`}`	371	`}`
364	`$notwas = false;`	372	`$notwas = false;`
365	`break;`	373	`break;`
366	`}`	374	`}`
367	`}`	375	`}`
368	`} else {`	376	`} else {`
369	`if (preg_match("/^\s+Origin\| Features/", $line, $ar_buf)) {`	377	`if (preg_match("/^\s+Origin\| Features/", $line, $ar_buf)) {`
370	`if (preg_match("/^\s+Origin[ ]=[ ]\"(.+)\"/", $line, $ar_buf)) {`	378	`if (preg_match("/^\s+Origin[ ]=[ ]\"(.+)\"/", $line, $ar_buf)) {`
371	`$dev->setVendorId($ar_buf[1]);`	379	`$dev->setVendorId($ar_buf[1]);`
372	`} elseif (preg_match("/ Features2[ ]=.<(.+)>/", $line, $ar_buf)) {`	380	`} elseif (preg_match("/ Features2[ ]=.<(.+)>/", $line, $ar_buf)) {`
373	`$feats = preg_split("/,/", strtolower(trim($ar_buf[1])), -1, PREG_SPLIT_NO_EMPTY);`	381	`$feats = preg_split("/,/", strtolower(trim($ar_buf[1])), -1, PREG_SPLIT_NO_EMPTY);`
374	`foreach ($feats as $feat) {`	382	`foreach ($feats as $feat) {`
375	`if (($feat=="vmx") \|\| ($feat=="svm")) {`	383	`if (($feat=="vmx") \|\| ($feat=="svm")) {`
376	`$dev->setVirt($feat);`	384	`$dev->setVirt($feat);`
377	`} elseif ($feat=="hv") {`	385	`} elseif ($feat=="hv") {`
378	`if ($dev->getVirt() === null) {`	386	`if ($dev->getVirt() === null) {`
379	`$dev->setVirt('hypervisor');`	387	`$dev->setVirt('hypervisor');`
380	`}`	388	`}`
381	`if (defined('PSI_SHOW_VIRTUALIZER_INFO') && PSI_SHOW_VIRTUALIZER_INFO) {`	389	`if (defined('PSI_SHOW_VIRTUALIZER_INFO') && PSI_SHOW_VIRTUALIZER_INFO) {`
382	`$this->sys->setVirtualizer("hypervisor", false);`	390	`$this->sys->setVirtualizer("hypervisor", false);`
383	`}`	391	`}`
384	`}`	392	`}`
385	`}`	393	`}`
386	`}`	394	`}`
387	`} else break;`	395	`} else break;`
388	`}`	396	`}`
389	`}`	397	`}`
390		398
391	`$ncpu = $this->grabkey('hw.ncpu');`	399	`$ncpu = $this->grabkey('hw.ncpu');`
392	`if (($ncpu === "") \|\| !($ncpu >= 1)) {`	400	`if (($ncpu === "") \|\| !($ncpu >= 1)) {`
393	`$ncpu = 1;`	401	`$ncpu = 1;`
394	`}`	402	`}`
395	`if (($ncpu == 1) && PSI_LOAD_BAR) {`	403	`if (($ncpu == 1) && PSI_LOAD_BAR) {`
396	`$dev->setLoad($this->cpuusage());`	404	`$dev->setLoad($this->cpuusage());`
397	`}`	405	`}`
398	`for ($ncpu ; $ncpu > 0 ; $ncpu--) {`	406	`for ($ncpu ; $ncpu > 0 ; $ncpu--) {`
399	`$this->sys->setCpus($dev);`	407	`$this->sys->setCpus($dev);`
400	`}`	408	`}`
401	`}`	409	`}`
402		410
403	`/**`	411	`/**`
404	`* Machine information`	412	`* Machine information`
405	`*`	413	`*`
406	`* @return void`	414	`* @return void`
407	`*/`	415	`*/`
408	`private function machine()`	416	`private function machine()`
409	`{`	417	`{`
410	`if ((PSI_OS == 'NetBSD') \|\| (PSI_OS == 'OpenBSD')) {`	418	`if ((PSI_OS == 'NetBSD') \|\| (PSI_OS == 'OpenBSD')) {`
411	`$buffer = array();`	419	`$buffer = array();`
412	`if (PSI_OS == 'NetBSD') { // NetBSD`	420	`if (PSI_OS == 'NetBSD') { // NetBSD`
413	`$buffer['Manufacturer'] = $this->grabkey('machdep.dmi.system-vendor');`	421	`$buffer['Manufacturer'] = $this->grabkey('machdep.dmi.system-vendor');`
414	`$buffer['Model'] = $this->grabkey('machdep.dmi.system-product');`	422	`$buffer['Model'] = $this->grabkey('machdep.dmi.system-product');`
415	`$buffer['Product'] = $this->grabkey('machdep.dmi.board-product');`	423	`$buffer['Product'] = $this->grabkey('machdep.dmi.board-product');`
416	`$buffer['SMBIOSBIOSVersion'] = $this->grabkey('machdep.dmi.bios-version');`	424	`$buffer['SMBIOSBIOSVersion'] = $this->grabkey('machdep.dmi.bios-version');`
417	`$buffer['ReleaseDate'] = $this->grabkey('machdep.dmi.bios-date');`	425	`$buffer['ReleaseDate'] = $this->grabkey('machdep.dmi.bios-date');`
418	`} else { // OpenBSD`	426	`} else { // OpenBSD`
419	`$buffer['Manufacturer'] = $this->grabkey('hw.vendor');`	427	`$buffer['Manufacturer'] = $this->grabkey('hw.vendor');`
420	`$buffer['Model'] = $this->grabkey('hw.product');`	428	`$buffer['Model'] = $this->grabkey('hw.product');`
421	`$buffer['Product'] = "";`	429	`$buffer['Product'] = "";`
422	`$buffer['SMBIOSBIOSVersion'] = "";`	430	`$buffer['SMBIOSBIOSVersion'] = "";`
423	`$buffer['ReleaseDate'] = "";`	431	`$buffer['ReleaseDate'] = "";`
424	`}`	432	`}`
425	`if (defined('PSI_SHOW_VIRTUALIZER_INFO') && PSI_SHOW_VIRTUALIZER_INFO) {`	433	`if (defined('PSI_SHOW_VIRTUALIZER_INFO') && PSI_SHOW_VIRTUALIZER_INFO) {`
426	`$vendor_array = array();`	434	`$vendor_array = array();`
427	`$vendor_array[] = $buffer['Model'];`	435	`$vendor_array[] = $buffer['Model'];`
428	`$vendor_array[] = trim($buffer['Manufacturer']." ".$buffer['Model']);`	436	`$vendor_array[] = trim($buffer['Manufacturer']." ".$buffer['Model']);`
429	`if (PSI_OS == 'NetBSD') { // NetBSD`	437	`if (PSI_OS == 'NetBSD') { // NetBSD`
430	`$vendor_array[] = $this->grabkey('machdep.dmi.board-vendor');`	438	`$vendor_array[] = $this->grabkey('machdep.dmi.board-vendor');`
431	`$vendor_array[] = $this->grabkey('machdep.dmi.bios-vendor');`	439	`$vendor_array[] = $this->grabkey('machdep.dmi.bios-vendor');`
432	`}`	440	`}`
433	`$virt = CommonFunctions::decodevirtualizer($vendor_array);`	441	`$virt = CommonFunctions::decodevirtualizer($vendor_array);`
434	`if ($virt !== null) {`	442	`if ($virt !== null) {`
435	`$this->sys->setVirtualizer($virt);`	443	`$this->sys->setVirtualizer($virt);`
436	`}`	444	`}`
437	`}`	445	`}`
438		446
439	`$buf = "";`	447	`$buf = "";`
440	`if (($buffer['Manufacturer'] !== "") && !preg_match("/^To be filled by O\.E\.M\.$\|^System manufacturer$\|^Not Specified$/i", $buf2=trim($buffer['Manufacturer'])) && ($buf2 !== "")) {`	448	`if (($buffer['Manufacturer'] !== "") && !preg_match("/^To be filled by O\.E\.M\.$\|^System manufacturer$\|^Not Specified$/i", $buf2=trim($buffer['Manufacturer'])) && ($buf2 !== "")) {`
441	`$buf .= ' '.$buf2;`	449	`$buf .= ' '.$buf2;`
442	`}`	450	`}`
443		451
444	`if (($buffer['Model'] !== "") && !preg_match("/^To be filled by O\.E\.M\.$\|^System Product Name$\|^Not Specified$/i", $buf2=trim($buffer['Model'])) && ($buf2 !== "")) {`	452	`if (($buffer['Model'] !== "") && !preg_match("/^To be filled by O\.E\.M\.$\|^System Product Name$\|^Not Specified$/i", $buf2=trim($buffer['Model'])) && ($buf2 !== "")) {`
445	`$model = $buf2;`	453	`$model = $buf2;`
446	`$buf .= ' '.$buf2;`	454	`$buf .= ' '.$buf2;`
447	`}`	455	`}`
448	`if (($buffer['Product'] !== "") && !preg_match("/^To be filled by O\.E\.M\.$\|^BaseBoard Product Name$\|^Not Specified$\|^Default string$/i", $buf2=trim($buffer['Product'])) && ($buf2 !== "")) {`	456	`if (($buffer['Product'] !== "") && !preg_match("/^To be filled by O\.E\.M\.$\|^BaseBoard Product Name$\|^Not Specified$\|^Default string$/i", $buf2=trim($buffer['Product'])) && ($buf2 !== "")) {`
449	`if ($buf2 !== $model) {`	457	`if ($buf2 !== $model) {`
450	`$buf .= '/'.$buf2;`	458	`$buf .= '/'.$buf2;`
451	`} elseif (isset($buffer['SystemFamily']) && !preg_match("/^To be filled by O\.E\.M\.$\|^System Family$\|^Not Specified$/i", $buf2=trim($buffer['SystemFamily'])) && ($buf2 !== "")) {`	459	`} elseif (isset($buffer['SystemFamily']) && !preg_match("/^To be filled by O\.E\.M\.$\|^System Family$\|^Not Specified$/i", $buf2=trim($buffer['SystemFamily'])) && ($buf2 !== "")) {`
452	`$buf .= '/'.$buf2;`	460	`$buf .= '/'.$buf2;`
453	`}`	461	`}`
454	`}`	462	`}`
455		463
456	`$bver = "";`	464	`$bver = "";`
457	`$brel = "";`	465	`$brel = "";`
458	`if (($buf2=trim($buffer['SMBIOSBIOSVersion'])) !== "") {`	466	`if (($buf2=trim($buffer['SMBIOSBIOSVersion'])) !== "") {`
459	`$bver .= ' '.$buf2;`	467	`$bver .= ' '.$buf2;`
460	`}`	468	`}`
461	`if ($buffer['ReleaseDate'] !== "") {`	469	`if ($buffer['ReleaseDate'] !== "") {`
462	`if (preg_match("/^(\d{4})(\d{2})(\d{2})$/", $buffer['ReleaseDate'], $dateout)) {`	470	`if (preg_match("/^(\d{4})(\d{2})(\d{2})$/", $buffer['ReleaseDate'], $dateout)) {`
463	`$brel .= ' '.$dateout[2].'/'.$dateout[3].'/'.$dateout[1];`	471	`$brel .= ' '.$dateout[2].'/'.$dateout[3].'/'.$dateout[1];`
464	`} elseif (preg_match("/^\d{2}\/\d{2}\/\d{4}$/", $buffer['ReleaseDate'])) {`	472	`} elseif (preg_match("/^\d{2}\/\d{2}\/\d{4}$/", $buffer['ReleaseDate'])) {`
465	`$brel .= ' '.$buffer['ReleaseDate'];`	473	`$brel .= ' '.$buffer['ReleaseDate'];`
466	`}`	474	`}`
467	`}`	475	`}`
468	`if ((trim($bver) !== "") \|\| (trim($brel) !== "")) {`	476	`if ((trim($bver) !== "") \|\| (trim($brel) !== "")) {`
469	`$buf .= ', BIOS'.$bver.$brel;`	477	`$buf .= ', BIOS'.$bver.$brel;`
470	`}`	478	`}`
471		479
472	`if (trim($buf) !== "") {`	480	`if (trim($buf) !== "") {`
473	`$this->sys->setMachine(trim($buf));`	481	`$this->sys->setMachine(trim($buf));`
474	`}`	482	`}`
475	`} elseif ((PSI_OS == 'FreeBSD') && defined('PSI_SHOW_VIRTUALIZER_INFO') && PSI_SHOW_VIRTUALIZER_INFO) {`	483	`} elseif ((PSI_OS == 'FreeBSD') && defined('PSI_SHOW_VIRTUALIZER_INFO') && PSI_SHOW_VIRTUALIZER_INFO) {`
476	`$vendorid = $this->grabkey('hw.hv_vendor');`	484	`$vendorid = $this->grabkey('hw.hv_vendor');`
477	`if (trim($vendorid) === "") {`	485	`if (trim($vendorid) === "") {`
478	`foreach ($this->readdmesg() as $line) if (preg_match("/^Hypervisor: Origin = \"(.+)\"/", $line, $ar_buf)) {`	486	`foreach ($this->readdmesg() as $line) if (preg_match("/^Hypervisor: Origin = \"(.+)\"/", $line, $ar_buf)) {`
479	`if (trim($ar_buf[1]) !== "") {`	487	`if (trim($ar_buf[1]) !== "") {`
480	`$vendorid = $ar_buf[1];`	488	`$vendorid = $ar_buf[1];`
481	`}`	489	`}`
482	`break;`	490	`break;`
483	`}`	491	`}`
484	`}`	492	`}`
485	`if (trim($vendorid) !== "") {`	493	`if (trim($vendorid) !== "") {`
486	`$virt = CommonFunctions::decodevirtualizer($vendorid);`	494	`$virt = CommonFunctions::decodevirtualizer($vendorid);`
487	`if ($virt !== null) {`	495	`if ($virt !== null) {`
488	`$this->sys->setVirtualizer($virt);`	496	`$this->sys->setVirtualizer($virt);`
489	`} else {`	497	`} else {`
490	`$this->sys->setVirtualizer('unknown');`	498	`$this->sys->setVirtualizer('unknown');`
491	`}`	499	`}`
492	`}`	500	`}`

Subversion Repositories ALCASAR

(root)/web/acc/phpsysinfo/includes/os/class.BSDCommon.inc.php @ 2976 – Rev 3037 → 3100