first commit
This commit is contained in:
renjianbo
@@ -0,0 +1,465 @@
|
||||
<?php
|
||||
/**
|
||||
* BSDCommon Class
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version SVN: $Id: class.BSDCommon.inc.php 287 2009-06-26 12:11:59Z bigmichi1 $
|
||||
* @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_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version Release: 3.0
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
abstract class BSDCommon extends OS
|
||||
{
|
||||
/**
|
||||
* content of the syslog
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
private $_dmesg = array();
|
||||
|
||||
/**
|
||||
* 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 = "";
|
||||
|
||||
/**
|
||||
* regexp1 for pci information out of the syslog
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_PCIRegExp1 = "";
|
||||
|
||||
/**
|
||||
* regexp1 for pci information out of the syslog
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_PCIRegExp2 = "";
|
||||
|
||||
/**
|
||||
* call parent constructor
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
parent::__construct();
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 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 (count($this->_dmesg) === 0) {
|
||||
if (!PHP_OS == "Darwin") {
|
||||
if (CommonFunctions::rfts('/var/run/dmesg.boot', $buf)) {
|
||||
$parts = preg_split("/rebooting/", $buf, -1, PREG_SPLIT_NO_EMPTY);
|
||||
$this->_dmesg = preg_split("/\n/", $parts[count($parts) - 1], -1, PREG_SPLIT_NO_EMPTY);
|
||||
}
|
||||
}
|
||||
}
|
||||
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 === true) {
|
||||
$this->sys->setHostname(getenv('SERVER_NAME'));
|
||||
} else {
|
||||
if (CommonFunctions::executeProgram('hostname', '', $buf, PSI_DEBUG)) {
|
||||
$this->sys->setHostname($buf);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* IP of the Canonical Host Name
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
protected function ip()
|
||||
{
|
||||
if (PSI_USE_VHOST === true) {
|
||||
$this->sys->setIp(gethostbyname($this->_hostname()));
|
||||
} else {
|
||||
if (!($result = getenv('SERVER_ADDR'))) {
|
||||
$this->sys->setIp(gethostbyname($this->_hostname()));
|
||||
} else {
|
||||
$this->sys->setIp($result);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Kernel Version
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
protected function kernel()
|
||||
{
|
||||
$s = $this->grabkey('kern.version');
|
||||
$a = preg_split('/:/', $s);
|
||||
$this->sys->setKernel($a[0].$a[1].':'.$a[2]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Number of Users
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
protected function users()
|
||||
{
|
||||
if (CommonFunctions::executeProgram('who', '| wc -l', $buf, PSI_DEBUG)) {
|
||||
$this->sys->setUsers($buf);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Processor Load
|
||||
* optionally create a loadbar
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
protected function loadavg()
|
||||
{
|
||||
$s = $this->grabkey('vm.loadavg');
|
||||
$s = ereg_replace('{ ', '', $s);
|
||||
$s = ereg_replace(' }', '', $s);
|
||||
$this->sys->setLoad($s);
|
||||
if (PSI_LOAD_BAR) {
|
||||
if ($fd = $this->grabkey('kern.cp_time')) {
|
||||
// Find out the CPU load
|
||||
// user + sys = load
|
||||
// total = total
|
||||
preg_match($this->_CPURegExp2, $fd, $res);
|
||||
$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');
|
||||
preg_match($this->_CPURegExp2, $fd, $res);
|
||||
$load2 = $res[2] + $res[3] + $res[4];
|
||||
$total2 = $res[2] + $res[3] + $res[4] + $res[5];
|
||||
$this->sys->setLoadPercent((100 * ($load2 - $load)) / ($total2 - $total));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* CPU information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
protected function cpuinfo()
|
||||
{
|
||||
$dev = new CpuDevice();
|
||||
$dev->setModel($this->grabkey('hw.model'));
|
||||
foreach ($this->readdmesg() as $line) {
|
||||
if (preg_match("/".$this->_CPURegExp1."/", $line, $ar_buf)) {
|
||||
$dev->setCpuSpeed(round($ar_buf[2]));
|
||||
break;
|
||||
}
|
||||
}
|
||||
$this->sys->setCpus($dev);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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)) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($ar_buf[1]);
|
||||
$this->sys->setScsiDevices($dev);
|
||||
} elseif (preg_match("/".$this->_SCSIRegExp2."/", $line, $ar_buf)) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($ar_buf[1]);
|
||||
$dev->setCapacity($ar_buf[2] * 2048 * 1.049);
|
||||
$this->sys->setScsiDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* PCI devices
|
||||
* get the pci device information out of dmesg
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
protected function pci()
|
||||
{
|
||||
if (!(is_array($results = Parser::lspci()) || is_array($results = Parser::pciconf()))) {
|
||||
foreach ($this->readdmesg() as $line) {
|
||||
if (preg_match("/".$this->_PCIRegExp1."/", $line, $ar_buf)) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($ar_buf[1].": ".$ar_buf[2]);
|
||||
$results[] = $dev;
|
||||
} elseif (preg_match("/".$this->_PCIRegExp2."/", $line, $ar_buf)) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($ar_buf[1].": ".$ar_buf[2]);
|
||||
$results[] = $dev;
|
||||
}
|
||||
}
|
||||
}
|
||||
foreach ($results as $device) {
|
||||
$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]);
|
||||
$dev->setCapacity($ar_buf[2] * 1024);
|
||||
$this->sys->setIdeDevices($dev);
|
||||
} elseif (preg_match('/^(acd[0-9]+): (.*) <(.*)> (.*)/', $line, $ar_buf)) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($ar_buf[1]);
|
||||
$this->sys->setIdeDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Physical memory information and Swap Space information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
protected function memory()
|
||||
{
|
||||
if (PHP_OS == 'FreeBSD' || PHP_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 (PHP_OS == 'NetBSD' || PHP_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 (((PHP_OS == 'OpenBSD' || PHP_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') {
|
||||
$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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* get the information
|
||||
*
|
||||
* @see PSI_Interface_OS::build()
|
||||
*
|
||||
* @return Void
|
||||
*/
|
||||
function build()
|
||||
{
|
||||
$this->distro();
|
||||
$this->memory();
|
||||
$this->ide();
|
||||
$this->pci();
|
||||
$this->cpuinfo();
|
||||
$this->filesystems();
|
||||
$this->kernel();
|
||||
$this->users();
|
||||
$this->loadavg();
|
||||
$this->hostname();
|
||||
$this->ip();
|
||||
$this->scsi();
|
||||
}
|
||||
}
|
||||
?>
|
||||
247
ZeedFramework/library/3rd/PSI/includes/os/class.Darwin.inc.php
Normal file
247
ZeedFramework/library/3rd/PSI/includes/os/class.Darwin.inc.php
Normal file
@@ -0,0 +1,247 @@
|
||||
<?php
|
||||
/**
|
||||
* Darwin System Class
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version SVN: $Id: class.Darwin.inc.php 287 2009-06-26 12:11:59Z bigmichi1 $
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
/**
|
||||
* Darwin sysinfo class
|
||||
* get all the required information from Darwin system
|
||||
* information may be incomplete
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version Release: 3.0
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
class Darwin extends BSDCommon
|
||||
{
|
||||
/**
|
||||
* define the regexp for log parser
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
parent::__construct();
|
||||
$this->error->addWarning("The Darwin version of phpSysInfo is work in progress, some things currently don't work!");
|
||||
$this->setCPURegExp1("CPU: (.*) \((.*)-MHz (.*)\)");
|
||||
$this->setCPURegExp2("/(.*) ([0-9]+) ([0-9]+) ([0-9]+) ([0-9]+)/");
|
||||
$this->setSCSIRegExp1("^(.*): <(.*)> .*SCSI.*device");
|
||||
}
|
||||
|
||||
/**
|
||||
* get a value from sysctl command
|
||||
*
|
||||
* @param string $key key of the value to get
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
protected function grabkey($key)
|
||||
{
|
||||
if (CommonFunctions::executeProgram('sysctl', $key, $s, PSI_DEBUG)) {
|
||||
$s = ereg_replace($key.': ', '', $s);
|
||||
$s = ereg_replace($key.' = ', '', $s);
|
||||
return $s;
|
||||
} else {
|
||||
return '';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* get a value from ioreg command
|
||||
*
|
||||
* @param string $key key of the value to get
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
private function _grabioreg($key)
|
||||
{
|
||||
if (CommonFunctions::executeProgram('ioreg', '-cls "'.$key.'" | grep "'.$key.'"', $s, PSI_DEBUG)) {
|
||||
$s = ereg_replace('\|', '', $s);
|
||||
$s = ereg_replace('\+\-\o', '', $s);
|
||||
$s = ereg_replace('[ ]+', '', $s);
|
||||
$s = ereg_replace('<[^>]+>', '', $s);
|
||||
return $s;
|
||||
} else {
|
||||
return '';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* UpTime
|
||||
* time the system is running
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _uptime()
|
||||
{
|
||||
if (CommonFunctions::executeProgram('sysctl', '-n kern.boottime', $a, PSI_DEBUG)) {
|
||||
$this->sys->setUptime(time() - $a);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* get CPU information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
protected function cpuinfo()
|
||||
{
|
||||
$dev = new CpuDevice();
|
||||
if (CommonFunctions::executeProgram('hostinfo', '| grep "Processor type"', $buf, PSI_DEBUG)) {
|
||||
if (CommonFunctions::rfts(APP_ROOT.'/data/ModelTranslation.txt', $buffer)) {
|
||||
$buffer = preg_split("/\n/", $buffer, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($buffer as $line) {
|
||||
$ar_buf = preg_split("/:/", $line, 2);
|
||||
if (trim($buf) === trim($ar_buf[0])) {
|
||||
$dev->setModel(trim($ar_buf[1]));
|
||||
}
|
||||
}
|
||||
}
|
||||
$dev->setModel(ereg_replace('Processor type: ', '', $buf));
|
||||
}
|
||||
$dev->setCpuSpeed(round($this->grabkey('hw.cpufrequency') / 1000000));
|
||||
$dev->setBusSpeed(round($this->grabkey('hw.busfrequency') / 1000000));
|
||||
$dev->setCache(round($this->grabkey('hw.l2cachesize')));
|
||||
}
|
||||
|
||||
/**
|
||||
* get the pci device information out of ioreg
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
protected function pci()
|
||||
{
|
||||
$s = $this->_grabioreg('IOPCIDevice');
|
||||
$lines = preg_split("/\n/", $s, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($lines as $line) {
|
||||
$ar_buf = preg_split("/\s+/", $line, 19);
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($ar_buf[0]);
|
||||
$this->sys->setIdeDevices($dev);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* get the ide device information out of ioreg
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
protected function ide()
|
||||
{
|
||||
$s = $this->_grabioreg('IOATABlockStorageDevice');
|
||||
$lines = preg_split("/\n/", $s, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($lines as $line) {
|
||||
$ar_buf = preg_split("/\/\//", $line, 19);
|
||||
if (isset($ar_buf[1]) && $ar_buf[1] == 'class IOMedia' && preg_match('/Media/', $ar_buf[0])) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($ar_buf[0]);
|
||||
$this->sys->setIdeDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* get memory and swap information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
protected function memory()
|
||||
{
|
||||
$s = $this->grabkey('hw.memsize');
|
||||
if (CommonFunctions::executeProgram('vm_stat', '', $pstat, PSI_DEBUG)) {
|
||||
$lines = preg_split("/\n/", $pstat, -1, PREG_SPLIT_NO_EMPTY);
|
||||
$ar_buf = preg_split("/\s+/", $lines[1], 19);
|
||||
// calculate free memory from page sizes (each page = 4MB)
|
||||
$this->sys->setMemTotal($s);
|
||||
$this->sys->setMemFree($ar_buf[2] * 4 * 1024);
|
||||
$this->sys->setMemUsed($this->sys->getMemTotal() - $this->sys->getMemFree());
|
||||
|
||||
if (CommonFunctions::executeProgram('sysctl', 'vm.swapusage | colrm 1 22', $swapBuff, PSI_DEBUG)) {
|
||||
$swap1 = preg_split('/M/', $swapBuff);
|
||||
$swap2 = preg_split('/=/', $swap1[1]);
|
||||
$swap3 = preg_split('/=/', $swap1[2]);
|
||||
$dev = new DiskDevice();
|
||||
$dev->setName('SWAP');
|
||||
$dev->setFsType('swap');
|
||||
$dev->setTotal($swap1[0] * 1024 * 1024);
|
||||
$dev->setUsed($swap2[1] * 1024 * 1024);
|
||||
$dev->setFree($swap3[1] * 1024 * 1024);
|
||||
$this->sys->setSwapDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* get network information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _network()
|
||||
{
|
||||
if (CommonFunctions::executeProgram('netstat', '-nbdi | cut -c1-24,42- | grep Link', $netstat, PSI_DEBUG)) {
|
||||
$lines = preg_split("/\n/", $netstat, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($lines as $line) {
|
||||
$ar_buf = preg_split("/\s+/", $line, 10);
|
||||
if (! empty($ar_buf[0])) {
|
||||
$dev = new NetDevice();
|
||||
$dev->setName($ar_buf[0]);
|
||||
$dev->setTxBytes($ar_buf[8]);
|
||||
$dev->setRxBytes($ar_buf[5]);
|
||||
$dev->setErrors($ar_buf[4] + $ar_buf[7]);
|
||||
if (isset($ar_buf[10])) {
|
||||
$dev->setDrops($ar_buf[10]);
|
||||
}
|
||||
$this->sys->setNetDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* get icon name
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
protected function distro()
|
||||
{
|
||||
$this->sys->setDistributionIcon('Darwin.png');
|
||||
if (!CommonFunctions::executeProgram('system_profiler', 'SPSoftwareDataType', $buffer, PSI_DEBUG)) {
|
||||
parent::distro();
|
||||
} else {
|
||||
$arrBuff = preg_split("/\n/", $buffer, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($arrBuff as $line) {
|
||||
$arrLine = preg_split("/:/", $line, -1, PREG_SPLIT_NO_EMPTY);
|
||||
if (trim($arrLine[0]) === "System Version") {
|
||||
$this->sys->setDistribution(trim($arrLine[1]));
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* get the information
|
||||
*
|
||||
* @see PSI_Interface_OS::build()
|
||||
*
|
||||
* @return Void
|
||||
*/
|
||||
function build()
|
||||
{
|
||||
parent::build();
|
||||
$this->_uptime();
|
||||
$this->_network();
|
||||
}
|
||||
}
|
||||
?>
|
||||
@@ -0,0 +1,125 @@
|
||||
<?php
|
||||
/**
|
||||
* DragonFly System Class
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version SVN: $Id: class.DragonFly.inc.php 287 2009-06-26 12:11:59Z bigmichi1 $
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
/**
|
||||
* DragonFly sysinfo class
|
||||
* get all the required information from DragonFly system
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version Release: 3.0
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
class DragonFly extends BSDCommon
|
||||
{
|
||||
/**
|
||||
* define the regexp for log parser
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
parent::__construct();
|
||||
$this->setCPURegExp1("^cpu(.*)\, (.*) MHz");
|
||||
$this->setCPURegExp2("^(.*) at scsibus.*: <(.*)> .*");
|
||||
$this->setSCSIRegExp2("^(da[0-9]): (.*)MB ");
|
||||
$this->setPCIRegExp1("/(.*): <(.*)>(.*) (pci|legacypci)[0-9]$/");
|
||||
$this->setPCIRegExp2("/(.*): <(.*)>.* at [0-9\.]+$/");
|
||||
}
|
||||
|
||||
/**
|
||||
* UpTime
|
||||
* time the system is running
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _uptime()
|
||||
{
|
||||
$a = $this->grab_key('kern.boottime');
|
||||
preg_match("/sec = ([0-9]+)/", $a, $buf);
|
||||
$this->sys->setUptime(time() - $buf[1]);
|
||||
}
|
||||
|
||||
/**
|
||||
* get network information
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
private function _network()
|
||||
{
|
||||
CommonFunctions::executeProgram('netstat', '-nbdi | cut -c1-25,44- | grep "^[a-z]*[0-9][ \t].*Link"', $netstat_b);
|
||||
CommonFunctions::executeProgram('netstat', '-ndi | cut -c1-25,44- | grep "^[a-z]*[0-9][ \t].*Link"', $netstat_n);
|
||||
$lines_b = preg_split("/\n/", $netstat_b, -1, PREG_SPLIT_NO_EMPTY);
|
||||
$lines_n = preg_split("/\n/", $netstat_n, -1, PREG_SPLIT_NO_EMPTY);
|
||||
for ($i = 0, $max = sizeof($lines_b); $i < $max; $i++) {
|
||||
$ar_buf_b = preg_split("/\s+/", $lines_b[$i]);
|
||||
$ar_buf_n = preg_split("/\s+/", $lines_n[$i]);
|
||||
if (! empty($ar_buf_b[0]) && ! empty($ar_buf_n[3])) {
|
||||
$dev = new NetDevice();
|
||||
$dev->setName($ar_buf_b[0]);
|
||||
$dev->setTxBytes($ar_buf_b[8]);
|
||||
$dev->setRxBytes($ar_buf_b[5]);
|
||||
$dev->setErrors($ar_buf_n[4] + $ar_buf_n[6]);
|
||||
$dev->setDrops($ar_buf_n[8]);
|
||||
$this->sys->setNetDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* get the ide information
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
protected function ide()
|
||||
{
|
||||
foreach ($this->readdmesg() as $line) {
|
||||
if (preg_match('/^(.*): (.*) <(.*)> at (ata[0-9]\-(.*)) (.*)/', $line, $ar_buf)) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($ar_buf[1]);
|
||||
if (!preg_match("/^acd[0-9](.*)/", $ar_buf[1])) {
|
||||
$dev->setCapacity($ar_buf[2] * 1024);
|
||||
}
|
||||
$this->sys->setIdeDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* get icon name
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _distroicon()
|
||||
{
|
||||
$this->sys->setDistributionIcon('DragonFly.png');
|
||||
}
|
||||
|
||||
/**
|
||||
* get the information
|
||||
*
|
||||
* @see BSDCommon::build()
|
||||
*
|
||||
* @return Void
|
||||
*/
|
||||
function build()
|
||||
{
|
||||
parent::build();
|
||||
$this->_distroicon();
|
||||
$this->_network();
|
||||
$this->_uptime();
|
||||
}
|
||||
}
|
||||
?>
|
||||
127
ZeedFramework/library/3rd/PSI/includes/os/class.FreeBSD.inc.php
Normal file
127
ZeedFramework/library/3rd/PSI/includes/os/class.FreeBSD.inc.php
Normal file
@@ -0,0 +1,127 @@
|
||||
<?php
|
||||
/**
|
||||
* FreeBSD System Class
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version SVN: $Id: class.FreeBSD.inc.php 287 2009-06-26 12:11:59Z bigmichi1 $
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
/**
|
||||
* FreeBSD sysinfo class
|
||||
* get all the required information from FreeBSD system
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version Release: 3.0
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
class FreeBSD extends BSDCommon
|
||||
{
|
||||
/**
|
||||
* define the regexp for log parser
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
parent::__construct();
|
||||
$this->setCPURegExp1("CPU: (.*) \((.*)-MHz (.*)\)");
|
||||
$this->setCPURegExp2("/(.*) ([0-9]+) ([0-9]+) ([0-9]+) ([0-9]+)/");
|
||||
$this->setSCSIRegExp1("^(.*): <(.*)> .*SCSI.*device");
|
||||
$this->setSCSIRegExp2("^(da[0-9]): (.*)MB ");
|
||||
$this->setPCIRegExp1("/(.*): <(.*)>(.*) pci[0-9]$/");
|
||||
$this->setPCIRegExp2("/(.*): <(.*)>.* at [.0-9]+ irq/");
|
||||
}
|
||||
|
||||
/**
|
||||
* UpTime
|
||||
* time the system is running
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _uptime()
|
||||
{
|
||||
$s = preg_split('/ /', $this->grabkey('kern.boottime'));
|
||||
$a = ereg_replace('{ ', '', $s[3]);
|
||||
$this->sys->setUptime(time() - $a);
|
||||
}
|
||||
|
||||
/**
|
||||
* get network information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _network()
|
||||
{
|
||||
if (CommonFunctions::executeProgram('netstat', '-nibd | grep Link', $netstat, PSI_DEBUG)) {
|
||||
$lines = preg_split("/\n/", $netstat, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($lines as $line) {
|
||||
$ar_buf = preg_split("/\s+/", $line);
|
||||
if (! empty($ar_buf[0])) {
|
||||
$dev = new NetDevice();
|
||||
$dev->setName($ar_buf[0]);
|
||||
if (strlen($ar_buf[3]) < 15) {
|
||||
$dev->setTxBytes($ar_buf[8]);
|
||||
$dev->setRxBytes($ar_buf[5]);
|
||||
$dev->setDrops($ar_buf[10]);
|
||||
$dev->setErrors($ar_buf[4] + $ar_buf[7]);
|
||||
} else {
|
||||
$dev->setTxBytes($ar_buf[9]);
|
||||
$dev->setRxBytes($ar_buf[6]);
|
||||
$dev->setErrors($ar_buf[5] + $ar_buf[8]);
|
||||
$dev->setDrops($ar_buf[11]);
|
||||
}
|
||||
$this->sys->setNetDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* get icon name
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _distroicon()
|
||||
{
|
||||
$this->sys->setDistributionIcon('FreeBSD.png');
|
||||
}
|
||||
|
||||
/**
|
||||
* extend the memory information with additional values
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _memoryadditional()
|
||||
{
|
||||
$pagesize = $this->grabkey("hw.pagesize");
|
||||
$this->sys->setMemCache($this->grabkey("vm.stats.vm.v_cache_count") * $pagesize);
|
||||
$this->sys->setMemApplication($this->grabkey("vm.stats.vm.v_active_count") * $pagesize);
|
||||
$this->sys->setMemBuffer($this->sys->getMemTotal() - $this->sys->getMemApplication() - $this->sys->getMemCache());
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* get the information
|
||||
*
|
||||
* @see BSDCommon::build()
|
||||
*
|
||||
* @return Void
|
||||
*/
|
||||
function build()
|
||||
{
|
||||
parent::build();
|
||||
$this->_memoryadditional();
|
||||
$this->_distroicon();
|
||||
$this->_network();
|
||||
$this->_uptime();
|
||||
}
|
||||
}
|
||||
?>
|
||||
405
ZeedFramework/library/3rd/PSI/includes/os/class.HPUX.inc.php
Normal file
405
ZeedFramework/library/3rd/PSI/includes/os/class.HPUX.inc.php
Normal file
@@ -0,0 +1,405 @@
|
||||
<?php
|
||||
/**
|
||||
* HP-UX System Class
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version SVN: $Id: class.HPUX.inc.php 287 2009-06-26 12:11:59Z bigmichi1 $
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
/**
|
||||
* HP-UX sysinfo class
|
||||
* get all the required information from HP-UX system
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version Release: 3.0
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
class HPUX extends OS
|
||||
{
|
||||
/**
|
||||
* Virtual Host Name
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _hostname()
|
||||
{
|
||||
if (PSI_USE_VHOST === true) {
|
||||
$this->sys->setHostname(getenv('SERVER_NAME'));
|
||||
} else {
|
||||
if (CommonFunctions::executeProgram('hostname', '', $ret)) {
|
||||
$this->sys->setHostname($ret);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* IP of the Virtual Host Name
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _ip()
|
||||
{
|
||||
if (PSI_USE_VHOST === true) {
|
||||
$this->sys->setIp(gethostbyname($this->_hostname()));
|
||||
} else {
|
||||
if (!($result = getenv('SERVER_ADDR'))) {
|
||||
$this->sys->setIp(gethostbyname($this->_hostname()));
|
||||
} else {
|
||||
$this->sys->setIp($result);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* HP-UX Version
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _kernel()
|
||||
{
|
||||
if (CommonFunctions::executeProgram('uname', '-srvm', $ret)) {
|
||||
$this->sys->setKernel($ret);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* UpTime
|
||||
* time the system is running
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _uptime()
|
||||
{
|
||||
if (CommonFunctions::executeProgram('uptime', '', $buf)) {
|
||||
if (preg_match("/up (\d+) days,\s*(\d+):(\d+),/", $buf, $ar_buf)) {
|
||||
$min = $ar_buf[3];
|
||||
$hours = $ar_buf[2];
|
||||
$days = $ar_buf[1];
|
||||
$this->sys->setUptime($days * 86400 + $hours * 3600 + $min * 60);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Number of Users
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _users()
|
||||
{
|
||||
if (CommonFunctions::executeProgram('who', '-q', $ret)) {
|
||||
$who = preg_split('/=/', $ret, -1, PREG_SPLIT_NO_EMPTY);
|
||||
$this->sys->setUsers($who[1]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Processor Load
|
||||
* optionally create a loadbar
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _loadavg()
|
||||
{
|
||||
if (CommonFunctions::executeProgram('uptime', '', $buf)) {
|
||||
if (preg_match("/average: (.*), (.*), (.*)$/", $buf, $ar_buf)) {
|
||||
$this->sys->setLoad($ar_buf[1].' '.$ar_buf[2].' '.$ar_buf[3]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* CPU information
|
||||
* All of the tags here are highly architecture dependant
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _cpuinfo()
|
||||
{
|
||||
if (CommonFunctions::rfts('/proc/cpuinfo', $bufr)) {
|
||||
$processors = preg_split('/\s?\n\s?\n/', trim($bufr));
|
||||
foreach ($processors as $processor) {
|
||||
$dev = new CpuDevice();
|
||||
$details = preg_split("/\n/", $processor, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($details as $detail) {
|
||||
$arrBuff = preg_split('/\s+:\s+/', trim($detail));
|
||||
if (count($arrBuff) == 2) {
|
||||
switch (strtolower($arrBuff[0])) {
|
||||
case 'model name':
|
||||
case 'cpu':
|
||||
$dev->setModel($arrBuff[1]);
|
||||
break;
|
||||
case 'cpu mhz':
|
||||
case 'clock':
|
||||
$dev->setCpuSpeed($arrBuff[1]);
|
||||
break;
|
||||
case 'cycle frequency [hz]':
|
||||
$dev->setCpuSpeed($arrBuff[1] / 1000000);
|
||||
break;
|
||||
case 'cpu0clktck':
|
||||
$dev->setCpuSpeed(hexdec($arrBuff[1]) / 1000000); // Linux sparc64
|
||||
break;
|
||||
case 'l2 cache':
|
||||
case 'cache size':
|
||||
$dev->setCache(preg_replace("/[a-zA-Z]/", "", $arrBuff[1]) * 1024);
|
||||
break;
|
||||
case 'bogomips':
|
||||
case 'cpu0bogo':
|
||||
$dev->setBogomips($arrBuff[1]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* PCI devices
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _pci()
|
||||
{
|
||||
if (CommonFunctions::rfts('/proc/pci', $bufr)) {
|
||||
$bufe = preg_split("/\n/", $bufr, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($bufe as $buf) {
|
||||
if (preg_match('/Bus/', $buf)) {
|
||||
$device = true;
|
||||
continue;
|
||||
}
|
||||
if ($device) {
|
||||
list($key, $value) = preg_split('/: /', $buf, 2);
|
||||
if (!preg_match('/bridge/i', $key) && !preg_match('/USB/i', $key)) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName(preg_replace('/\([^\)]+\)\.$/', '', trim($value)));
|
||||
$this->sys->setPciDevices($dev);
|
||||
}
|
||||
$device = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* IDE devices
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _ide()
|
||||
{
|
||||
$bufd = CommonFunctions::gdc('/proc/ide', false);
|
||||
foreach ($bufd as $file) {
|
||||
if (preg_match('/^hd/', $file)) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName(trim($file));
|
||||
if (CommonFunctions::rfts("/proc/ide/".$file."/media", $buf, 1)) {
|
||||
if (trim($buf) == 'disk') {
|
||||
if (CommonFunctions::rfts("/proc/ide/".$file."/capacity", $buf, 1, 4096, false)) {
|
||||
$dev->setCapacity(trim($buf) * 512 / 1024);
|
||||
}
|
||||
}
|
||||
}
|
||||
$this->sys->setIdeDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* SCSI devices
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _scsi()
|
||||
{
|
||||
$get_type = false;
|
||||
if (CommonFunctions::rfts('/proc/scsi/scsi', $bufr, 0, 4096, PSI_DEBUG)) {
|
||||
$bufe = preg_split("/\n/", $bufr, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($bufe as $buf) {
|
||||
if (preg_match('/Vendor: (.*) Model: (.*) Rev: (.*)/i', $buf, $dev)) {
|
||||
$get_type = true;
|
||||
continue;
|
||||
}
|
||||
if ($get_type) {
|
||||
preg_match('/Type:\s+(\S+)/i', $buf, $dev_type);
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($dev[1].' '.$dev[2].' ('.$dev_type[1].')');
|
||||
$this->sys->setScsiDevices($dev);
|
||||
$get_type = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* USB devices
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _usb()
|
||||
{
|
||||
if (CommonFunctions::rfts('/proc/bus/usb/devices', $bufr, 0, 4096, false)) {
|
||||
$bufe = preg_split("/\n/", $bufr, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($bufe as $buf) {
|
||||
if (preg_match('/^T/', $buf)) {
|
||||
$devnum += 1;
|
||||
$results[$devnum] = "";
|
||||
} elseif (preg_match('/^S:/', $buf)) {
|
||||
list($key, $value) = preg_split('/: /', $buf, 2);
|
||||
list($key, $value2) = preg_split('/=/', $value, 2);
|
||||
if (trim($key) != "SerialNumber") {
|
||||
$results[$devnum] .= " ".trim($value2);
|
||||
}
|
||||
}
|
||||
}
|
||||
foreach ($results as $var) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($var);
|
||||
$this->sys->setUsbDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Network devices
|
||||
* includes also rx/tx bytes
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _network()
|
||||
{
|
||||
if (CommonFunctions::executeProgram('netstat', '-ni | tail -n +2', $netstat)) {
|
||||
$lines = preg_split("/\n/", $netstat, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($lines as $line) {
|
||||
$ar_buf = preg_split("/\s+/", $line);
|
||||
if (! empty($ar_buf[0]) && ! empty($ar_buf[3])) {
|
||||
$dev = new NetDevice();
|
||||
$dev->setName($ar_buf[0]);
|
||||
$dev->setRxBytes($ar_buf[4]);
|
||||
$dev->setTxBytes($ar_buf[6]);
|
||||
$dev->setErrors($ar_buf[5] + $ar_buf[7]);
|
||||
$dev->setDrops($ar_buf[8]);
|
||||
$this->sys->setNetDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Physical memory information and Swap Space information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _memory()
|
||||
{
|
||||
if (CommonFunctions::rfts('/proc/meminfo', $bufr)) {
|
||||
$bufe = preg_split("/\n/", $bufr, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($bufe as $buf) {
|
||||
if (preg_match('/Mem:\s+(.*)$/', $buf, $ar_buf)) {
|
||||
$ar_buf = preg_split('/\s+/', $ar_buf[1], 6);
|
||||
$this->sys->setMemTotal($ar_buf[0]);
|
||||
$this->sys->setMemUsed($ar_buf[1]);
|
||||
$this->sys->setMemFree($ar_buf[2]);
|
||||
$this->sys->setMemApplication($ar_buf[3]);
|
||||
$this->sys->setMemBuffer($ar_buf[4]);
|
||||
$this->sys->setMemCache($ar_buf[5]);
|
||||
}
|
||||
// Get info on individual swap files
|
||||
if (CommonFunctions::rfts('/proc/swaps', $swaps)) {
|
||||
$swapdevs = preg_split("/\n/", $swaps, -1, PREG_SPLIT_NO_EMPTY);
|
||||
for ($i = 1, $max = (sizeof($swapdevs) - 1); $i < $max; $i++) {
|
||||
$ar_buf = preg_split('/\s+/', $swapdevs[$i], 6);
|
||||
$dev = new DiskDevice();
|
||||
$dev->setMountPoint($ar_buf[0]);
|
||||
$dev->setName("SWAP");
|
||||
$dev->setFsType('swap');
|
||||
$dev->setTotal($ar_buf[2] * 1024);
|
||||
$dev->setUsed($ar_buf[3] * 1024);
|
||||
$dev->setFree($dev->getTotal() - $dev->getUsed());
|
||||
$this->sys->setSwapDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* filesystem information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _filesystems()
|
||||
{
|
||||
if (CommonFunctions::executeProgram('df', '-kP', $df, PSI_DEBUG)) {
|
||||
$mounts = preg_split("/\n/", $df, -1, PREG_SPLIT_NO_EMPTY);
|
||||
if (CommonFunctions::executeProgram('mount', '-v', $s, PSI_DEBUG)) {
|
||||
$lines = preg_split("/\n/", $s, -1, PREG_SPLIT_NO_EMPTY);
|
||||
while (list(, $line) = each($lines)) {
|
||||
$a = preg_split('/ /', $line, -1, PREG_SPLIT_NO_EMPTY);
|
||||
$fsdev[$a[0]] = $a[4];
|
||||
}
|
||||
}
|
||||
foreach ($mounts as $mount) {
|
||||
$ar_buf = preg_split("/\s+/", $mount, 6);
|
||||
$dev = new DiskDevice();
|
||||
$dev->setName($ar_buf[0]);
|
||||
$dev->setTotal($ar_buf[1] * 1024);
|
||||
$dev->setUsed($ar_buf[2] * 1024);
|
||||
$dev->setFree($ar_buf[3] * 1024);
|
||||
$dev->setMountPoint($ar_buf[5]);
|
||||
if (isset($fsdev[$ar_buf[0]])) {
|
||||
$dev->setFsType($fsdev[$ar_buf[0]]);
|
||||
}
|
||||
$this->sys->setDiskDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Distribution
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _distro()
|
||||
{
|
||||
$this->sys->setDistribution('HP-UX');
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* get the information
|
||||
*
|
||||
* @see PSI_Interface_OS::build()
|
||||
*
|
||||
* @return Void
|
||||
*/
|
||||
function build()
|
||||
{
|
||||
$this->_distro();
|
||||
$this->_ip();
|
||||
$this->_hostname();
|
||||
$this->_kernel();
|
||||
$this->_uptime();
|
||||
$this->_users();
|
||||
$this->_loadavg();
|
||||
$this->_cpuinfo();
|
||||
$this->_pci();
|
||||
$this->_ide();
|
||||
$this->_scsi();
|
||||
$this->_usb();
|
||||
$this->_network();
|
||||
$this->_memory();
|
||||
$this->_filesystems();
|
||||
}
|
||||
}
|
||||
?>
|
||||
565
ZeedFramework/library/3rd/PSI/includes/os/class.Linux.inc.php
Normal file
565
ZeedFramework/library/3rd/PSI/includes/os/class.Linux.inc.php
Normal file
@@ -0,0 +1,565 @@
|
||||
<?php
|
||||
/**
|
||||
* Linux System Class
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version SVN: $Id: class.Linux.inc.php 329 2009-09-07 11:21:44Z bigmichi1 $
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
/**
|
||||
* Linux sysinfo class
|
||||
* get all the required information from Linux system
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version Release: 3.0
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
class Linux extends OS
|
||||
{
|
||||
/**
|
||||
* call parent constructor
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
parent::__construct();
|
||||
}
|
||||
/**
|
||||
* Hostname
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _hostname()
|
||||
{
|
||||
if (PSI_USE_VHOST === true) {
|
||||
$this->sys->setHostname(getenv('SERVER_NAME'));
|
||||
} else {
|
||||
if (CommonFunctions::rfts('/proc/sys/kernel/hostname', $result, 1)) {
|
||||
$result = trim($result);
|
||||
$ip = gethostbyname($result);
|
||||
if ($ip != $result) {
|
||||
$this->sys->setHostname(gethostbyaddr($ip));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* IP
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _ip()
|
||||
{
|
||||
if (PSI_USE_VHOST === true) {
|
||||
$this->sys->setIp(gethostbyname($this->_hostname()));
|
||||
} else {
|
||||
if (!($result = $_SERVER['SERVER_ADDR'])) {
|
||||
$this->sys->setIp(gethostbyname($this->_hostname()));
|
||||
} else {
|
||||
$this->sys->setIp($result);
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Kernel Version
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _kernel()
|
||||
{
|
||||
if (CommonFunctions::executeProgram('uname', '-r', $strBuf, PSI_DEBUG)) {
|
||||
$result = trim($strBuf);
|
||||
if (CommonFunctions::executeProgram('uname', '-v', $strBuf, PSI_DEBUG)) {
|
||||
if (preg_match('/SMP/', $strBuf)) {
|
||||
$result .= ' (SMP)';
|
||||
}
|
||||
}
|
||||
if (CommonFunctions::executeProgram('uname', '-m', $strBuf, PSI_DEBUG)) {
|
||||
$result .= ' '.trim($strBuf);
|
||||
}
|
||||
$this->sys->setKernel($result);
|
||||
} else {
|
||||
if (CommonFunctions::rfts('/proc/version', $strBuf, 1)) {
|
||||
if (preg_match('/version (.*?) /', $strBuf, $ar_buf)) {
|
||||
$result = $ar_buf[1];
|
||||
if (preg_match('/SMP/', $strBuf)) {
|
||||
$result .= ' (SMP)';
|
||||
}
|
||||
$this->sys->setKernel($result);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* UpTime
|
||||
* time the system is running
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _uptime()
|
||||
{
|
||||
CommonFunctions::rfts('/proc/uptime', $buf, 1);
|
||||
$ar_buf = preg_split('/ /', $buf);
|
||||
$this->sys->setUptime(trim($ar_buf[0]));
|
||||
}
|
||||
/**
|
||||
* Number of Users
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _users()
|
||||
{
|
||||
if (CommonFunctions::executeProgram('who', '-q', $strBuf, PSI_DEBUG)) {
|
||||
$arrWho = preg_split('/=/', $strBuf);
|
||||
$this->sys->setUsers($arrWho[1]);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Processor Load
|
||||
* optionally create a loadbar
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _loadavg()
|
||||
{
|
||||
if (CommonFunctions::rfts('/proc/loadavg', $buf)) {
|
||||
$result = preg_split("/\s/", $buf, 4);
|
||||
// don't need the extra values, only first three
|
||||
unset($result[3]);
|
||||
$this->sys->setLoad(implode(' ', $result));
|
||||
}
|
||||
if (PSI_LOAD_BAR) {
|
||||
$this->sys->setLoadPercent($this->_parseProcStat('cpu'));
|
||||
}
|
||||
}
|
||||
/**
|
||||
* fill the load for a individual cpu, through parsing /proc/stat for the specified cpu
|
||||
*
|
||||
* @param String $cpuline cpu for which load should be meassured
|
||||
*
|
||||
* @return Integer
|
||||
*/
|
||||
private function _parseProcStat($cpuline)
|
||||
{
|
||||
$load = 0;
|
||||
$load2 = 0;
|
||||
$total = 0;
|
||||
$total2 = 0;
|
||||
if (CommonFunctions::rfts('/proc/stat', $buf)) {
|
||||
$lines = preg_split("/\n/", $buf, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($lines as $line) {
|
||||
if (preg_match('/^'.$cpuline.' (.*)/', $line, $matches)) {
|
||||
$ab = 0;
|
||||
$ac = 0;
|
||||
$ad = 0;
|
||||
$ae = 0;
|
||||
sscanf($buf, "%*s %Ld %Ld %Ld %Ld", $ab, $ac, $ad, $ae);
|
||||
$load = $ab + $ac + $ad; // cpu.user + cpu.sys
|
||||
$total = $ab + $ac + $ad + $ae; // cpu.total
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
// we need a second value, wait 1 second befor getting (< 1 second no good value will occour)
|
||||
sleep(1);
|
||||
if (CommonFunctions::rfts('/proc/stat', $buf)) {
|
||||
$lines = preg_split("/\n/", $buf, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($lines as $line) {
|
||||
if (preg_match('/^'.$cpuline.' (.*)/', $line, $matches)) {
|
||||
$ab = 0;
|
||||
$ac = 0;
|
||||
$ad = 0;
|
||||
$ae = 0;
|
||||
sscanf($buf, "%*s %Ld %Ld %Ld %Ld", $ab, $ac, $ad, $ae);
|
||||
$load2 = $ab + $ac + $ad;
|
||||
$total2 = $ab + $ac + $ad + $ae;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if ($total > 0 && $total2 > 0 && $load > 0 && $load2 > 0 && $total2 != $total && $load2 != $load) {
|
||||
return (100 * ($load2 - $load)) / ($total2 - $total);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
/**
|
||||
* CPU information
|
||||
* All of the tags here are highly architecture dependant.
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _cpuinfo()
|
||||
{
|
||||
if (CommonFunctions::rfts('/proc/cpuinfo', $bufr)) {
|
||||
$processors = preg_split('/\s?\n\s?\n/', trim($bufr));
|
||||
foreach ($processors as $processor) {
|
||||
$dev = new CpuDevice();
|
||||
$details = preg_split("/\n/", $processor, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($details as $detail) {
|
||||
$arrBuff = preg_split('/\s+:\s+/', trim($detail));
|
||||
if (count($arrBuff) == 2) {
|
||||
switch (strtolower($arrBuff[0])) {
|
||||
case 'processor':
|
||||
$dev->setLoad($this->_parseProcStat('cpu'.trim($arrBuff[1])));
|
||||
break;
|
||||
case 'model name':
|
||||
case 'cpu':
|
||||
$dev->setModel($arrBuff[1]);
|
||||
break;
|
||||
case 'cpu mhz':
|
||||
case 'clock':
|
||||
$dev->setCpuSpeed($arrBuff[1]);
|
||||
break;
|
||||
case 'cycle frequency [hz]':
|
||||
$dev->setCpuSpeed($arrBuff[1] / 1000000);
|
||||
break;
|
||||
case 'cpu0clktck':
|
||||
$dev->setCpuSpeed(hexdec($arrBuff[1]) / 1000000); // Linux sparc64
|
||||
break;
|
||||
case 'l2 cache':
|
||||
case 'cache size':
|
||||
$dev->setCache(preg_replace("/[a-zA-Z]/", "", $arrBuff[1]) * 1024);
|
||||
break;
|
||||
case 'bogomips':
|
||||
case 'cpu0bogo':
|
||||
$dev->setBogomips($arrBuff[1]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
// sparc64 specific code follows
|
||||
// This adds the ability to display the cache that a CPU has
|
||||
// Originally made by Sven Blumenstein <bazik@gentoo.org> in 2004
|
||||
// Modified by Tom Weustink <freshy98@gmx.net> in 2004
|
||||
$sparclist = array('SUNW,UltraSPARC@0,0', 'SUNW,UltraSPARC-II@0,0', 'SUNW,UltraSPARC@1c,0', 'SUNW,UltraSPARC-IIi@1c,0', 'SUNW,UltraSPARC-II@1c,0', 'SUNW,UltraSPARC-IIe@0,0');
|
||||
foreach ($sparclist as $name) {
|
||||
if (CommonFunctions::rfts('/proc/openprom/'.$name.'/ecache-size', $buf, 1, 32, false)) {
|
||||
$dev->setCache(base_convert($buf, 16, 10));
|
||||
}
|
||||
}
|
||||
// sparc64 specific code ends
|
||||
|
||||
// XScale detection code
|
||||
if ($dev->getModel() === "") {
|
||||
foreach ($details as $detail) {
|
||||
$arrBuff = preg_split('/\s*:\s*/', trim($buf), 2);
|
||||
if (count($arrBuff) == 2) {
|
||||
switch (strtolower($arrBuff[0])) {
|
||||
case 'Processor':
|
||||
$dev->setModel($arrBuff[1]);
|
||||
break;
|
||||
case 'BogoMIPS':
|
||||
$dev->setCpuSpeed($arrBuff[1]); //BogoMIPS are not BogoMIPS on this CPU, it's the speed, no BogoMIPS available
|
||||
break;
|
||||
case 'I size':
|
||||
case 'D size':
|
||||
if ($dev->getCache() === null) {
|
||||
$dev->setCache($arrBuff[1] * 1024);
|
||||
} else {
|
||||
$dev->setCache($dev->getCache() + ($arrBuff[1] * 1024));
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (CommonFunctions::rfts('/proc/acpi/thermal_zone/THRM/temperature', $buf, 1, 4096, false)) {
|
||||
$dev->setTemp(substr($buf, 25, 2));
|
||||
}
|
||||
$this->sys->setCpus($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* PCI devices
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _pci()
|
||||
{
|
||||
if (!$arrResults = Parser::lspci()) {
|
||||
if (CommonFunctions::rfts('/proc/pci', $strBuf, 0, 4096, false)) {
|
||||
$booDevice = false;
|
||||
$arrBuf = preg_split("/\n/", $strBuf, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($arrBuf as $strLine) {
|
||||
if (preg_match('/Bus/', $strLine)) {
|
||||
$booDevice = true;
|
||||
continue;
|
||||
}
|
||||
if ($booDevice) {
|
||||
list($strKey, $strValue) = preg_split('/: /', $strLine, 2);
|
||||
if (!preg_match('/bridge/i', $strKey) && !preg_match('/USB/i ', $strKey)) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName(preg_replace('/\([^\)]+\)\.$/', '', trim($strValue)));
|
||||
$this->sys->setPciDevices($dev);
|
||||
}
|
||||
$booDevice = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
foreach ($arrResults as $dev) {
|
||||
$this->sys->setPciDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* IDE devices
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _ide()
|
||||
{
|
||||
$bufd = CommonFunctions::gdc('/proc/ide', false);
|
||||
foreach ($bufd as $file) {
|
||||
if (preg_match('/^hd/', $file)) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName(trim($file));
|
||||
if (CommonFunctions::rfts("/proc/ide/".$file."/media", $buf, 1)) {
|
||||
if (trim($buf) == 'disk') {
|
||||
if (CommonFunctions::rfts("/proc/ide/".$file."/capacity", $buf, 1, 4096, false) || CommonFunctions::rfts("/sys/block/".$file."/size", $buf, 1, 4096, false)) {
|
||||
$dev->setCapacity(trim($buf) * 512 / 1024);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (CommonFunctions::rfts("/proc/ide/".$file."/model", $buf, 1)) {
|
||||
$dev->setName($dev->getName().": ".trim($buf));
|
||||
}
|
||||
$this->sys->setIdeDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* SCSI devices
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _scsi()
|
||||
{
|
||||
$get_type = false;
|
||||
$device = null;
|
||||
if (CommonFunctions::executeProgram('lsscsi', '-c', $bufr, PSI_DEBUG) || CommonFunctions::rfts('/proc/scsi/scsi', $bufr, 0, 4096, PSI_DEBUG)) {
|
||||
$bufe = preg_split("/\n/", $bufr, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($bufe as $buf) {
|
||||
if (preg_match('/Vendor: (.*) Model: (.*) Rev: (.*)/i', $buf, $devices)) {
|
||||
$get_type = true;
|
||||
$device = $devices;
|
||||
continue;
|
||||
}
|
||||
if ($get_type) {
|
||||
preg_match('/Type:\s+(\S+)/i', $buf, $dev_type);
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($device[1].' '.$device[2].' ('.$dev_type[1].')');
|
||||
$this->sys->setScsiDevices($dev);
|
||||
$get_type = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* USB devices
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
private function _usb()
|
||||
{
|
||||
$devnum = -1;
|
||||
if (!CommonFunctions::executeProgram('lsusb', '', $bufr, PSI_DEBUG)) {
|
||||
if (CommonFunctions::rfts('/proc/bus/usb/devices', $bufr, 0, 4096, false)) {
|
||||
$bufe = preg_split("/\n/", $bufr, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($bufe as $buf) {
|
||||
if (preg_match('/^T/', $buf)) {
|
||||
$devnum += 1;
|
||||
$results[$devnum] = "";
|
||||
} elseif (preg_match('/^S:/', $buf)) {
|
||||
list($key, $value) = preg_split('/: /', $buf, 2);
|
||||
list($key, $value2) = preg_split('/=/', $value, 2);
|
||||
if (trim($key) != "SerialNumber") {
|
||||
$results[$devnum] .= " ".trim($value2);
|
||||
}
|
||||
}
|
||||
}
|
||||
foreach ($results as $var) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($var);
|
||||
$this->sys->setUsbDevices($dev);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
$bufe = preg_split("/\n/", $bufr, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($bufe as $buf) {
|
||||
$device = preg_split("/ /", $buf, 7);
|
||||
if (isset($device[6]) && trim($device[6]) != "") {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName(trim($device[6]));
|
||||
$this->sys->setUsbDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Network devices
|
||||
* includes also rx/tx bytes
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _network()
|
||||
{
|
||||
if (CommonFunctions::rfts('/proc/net/dev', $bufr)) {
|
||||
$bufe = preg_split("/\n/", $bufr, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($bufe as $buf) {
|
||||
if (preg_match('/:/', $buf)) {
|
||||
list($dev_name, $stats_list) = preg_split('/:/', $buf, 2);
|
||||
$stats = preg_split('/\s+/', trim($stats_list));
|
||||
$dev = new NetDevice();
|
||||
$dev->setName(trim($dev_name));
|
||||
$dev->setRxBytes($stats[0]);
|
||||
$dev->setTxBytes($stats[8]);
|
||||
$dev->setErrors($stats[2] + $stats[10]);
|
||||
$dev->setDrops($stats[3] + $stats[11]);
|
||||
$this->sys->setNetDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Physical memory information and Swap Space information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _memory()
|
||||
{
|
||||
if (CommonFunctions::rfts('/proc/meminfo', $bufr)) {
|
||||
$bufe = preg_split("/\n/", $bufr, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($bufe as $buf) {
|
||||
if (preg_match('/^MemTotal:\s+(.*)\s*kB/i', $buf, $ar_buf)) {
|
||||
$this->sys->setMemTotal($ar_buf[1] * 1024);
|
||||
} elseif (preg_match('/^MemFree:\s+(.*)\s*kB/i', $buf, $ar_buf)) {
|
||||
$this->sys->setMemFree($ar_buf[1] * 1024);
|
||||
} elseif (preg_match('/^Cached:\s+(.*)\s*kB/i', $buf, $ar_buf)) {
|
||||
$this->sys->setMemCache($ar_buf[1] * 1024);
|
||||
} elseif (preg_match('/^Buffers:\s+(.*)\s*kB/i', $buf, $ar_buf)) {
|
||||
$this->sys->setMemBuffer($ar_buf[1] * 1024);
|
||||
}
|
||||
}
|
||||
$this->sys->setMemUsed($this->sys->getMemTotal() - $this->sys->getMemFree());
|
||||
// values for splitting memory usage
|
||||
if ($this->sys->getMemCache() !== null && $this->sys->getMemBuffer() !== null) {
|
||||
$this->sys->setMemApplication($this->sys->getMemUsed() - $this->sys->getMemCache() - $this->sys->getMemBuffer());
|
||||
}
|
||||
if (CommonFunctions::rfts('/proc/swaps', $bufr)) {
|
||||
$swaps = preg_split("/\n/", $bufr, -1, PREG_SPLIT_NO_EMPTY);
|
||||
unset($swaps[0]);
|
||||
foreach ($swaps as $swap) {
|
||||
$ar_buf = preg_split('/\s+/', $swap, 5);
|
||||
$dev = new DiskDevice();
|
||||
$dev->setMountPoint($ar_buf[0]);
|
||||
$dev->setName("SWAP");
|
||||
$dev->setTotal($ar_buf[2] * 1024);
|
||||
$dev->setUsed($ar_buf[3] * 1024);
|
||||
$dev->setFree($dev->getTotal() - $dev->getUsed());
|
||||
$this->sys->setSwapDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* filesystem information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _filesystems()
|
||||
{
|
||||
$arrResult = Parser::df("-P");
|
||||
foreach ($arrResult as $dev) {
|
||||
$this->sys->setDiskDevices($dev);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Distribution
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _distro()
|
||||
{
|
||||
$list = @parse_ini_file(APP_ROOT."/data/distros.ini", true);
|
||||
if (!$list) {
|
||||
return;
|
||||
}
|
||||
// We have the '2> /dev/null' because Ubuntu gives an error on this command which causes the distro to be unknown
|
||||
if (CommonFunctions::executeProgram('lsb_release', '-a 2> /dev/null', $distro_info, PSI_DEBUG)) {
|
||||
$distro_tmp = preg_split("/\n/", $distro_info, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($distro_tmp as $info) {
|
||||
$info_tmp = preg_split('/:/', $info, 2);
|
||||
$distro[$info_tmp[0]] = trim($info_tmp[1]);
|
||||
if (isset($distro['Distributor ID']) && isset($list[$distro['Distributor ID']]['Image'])) {
|
||||
$this->sys->setDistributionIcon($list[$distro['Distributor ID']]['Image']);
|
||||
}
|
||||
if (isset($distro['Description'])) {
|
||||
$this->sys->setDistribution($distro['Description']);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Fall back in case 'lsb_release' does not exist ;)
|
||||
foreach ($list as $section=>$distribution) {
|
||||
if (!isset($distribution["Files"])) {
|
||||
continue;
|
||||
} else {
|
||||
foreach (preg_split("/;/", $distribution["Files"], -1, PREG_SPLIT_NO_EMPTY) as $filename) {
|
||||
if (file_exists($filename)) {
|
||||
CommonFunctions::rfts($filename, $buf);
|
||||
if (isset($distribution["Image"])) {
|
||||
$this->sys->setDistributionIcon($distribution["Image"]);
|
||||
}
|
||||
if (isset($distribution["Name"])) {
|
||||
if ($distribution["Name"] == 'Synology') {
|
||||
$this->sys->setDistribution($distribution["Name"]);
|
||||
} else {
|
||||
$this->sys->setDistribution($distribution["Name"]." ".trim($buf));
|
||||
}
|
||||
} else {
|
||||
$this->sys->setDistribution(trim($buf));
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* get the information
|
||||
*
|
||||
* @see PSI_Interface_OS::build()
|
||||
*
|
||||
* @return Void
|
||||
*/
|
||||
function build()
|
||||
{
|
||||
$this->_distro();
|
||||
$this->_ip();
|
||||
$this->_hostname();
|
||||
$this->_kernel();
|
||||
$this->_uptime();
|
||||
$this->_users();
|
||||
$this->_cpuinfo();
|
||||
$this->_pci();
|
||||
$this->_ide();
|
||||
$this->_scsi();
|
||||
$this->_usb();
|
||||
$this->_network();
|
||||
$this->_memory();
|
||||
$this->_filesystems();
|
||||
$this->_loadavg();
|
||||
}
|
||||
}
|
||||
?>
|
||||
130
ZeedFramework/library/3rd/PSI/includes/os/class.NetBSD.inc.php
Normal file
130
ZeedFramework/library/3rd/PSI/includes/os/class.NetBSD.inc.php
Normal file
@@ -0,0 +1,130 @@
|
||||
<?php
|
||||
/**
|
||||
* NetBSD System Class
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version SVN: $Id: class.NetBSD.inc.php 287 2009-06-26 12:11:59Z bigmichi1 $
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
/**
|
||||
* NetBSD sysinfo class
|
||||
* get all the required information from NetBSD systems
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version Release: 3.0
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
class NetBSD extends BSDCommon
|
||||
{
|
||||
/**
|
||||
* define the regexp for log parser
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
parent::__construct();
|
||||
$this->setCPURegExp1("^cpu(.*)\, (.*) MHz");
|
||||
$this->setCPURegExp2("/user = (.*), nice = (.*), sys = (.*), intr = (.*), idle = (.*)/");
|
||||
$this->setSCSIRegExp1("^(.*) at scsibus.*: <(.*)> .*");
|
||||
$this->setSCSIRegExp2("^(da[0-9]): (.*)MB ");
|
||||
$this->setPCIRegExp1("/(.*) at pci[0-9] dev [0-9]* function [0-9]*: (.*)$/");
|
||||
$this->setPCIRegExp2("/\"(.*)\" (.*).* at [.0-9]+ irq/");
|
||||
}
|
||||
|
||||
/**
|
||||
* UpTime
|
||||
* time the system is running
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _uptime()
|
||||
{
|
||||
$a = $this->grabkey('kern.boottime');
|
||||
$this->sys->setUptime(time() - $a);
|
||||
}
|
||||
|
||||
/**
|
||||
* get network information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _network()
|
||||
{
|
||||
CommonFunctions::executeProgram('netstat', '-nbdi | cut -c1-25,44- | grep "^[a-z]*[0-9][ \t].*Link"', $netstat_b);
|
||||
CommonFunctions::executeProgram('netstat', '-ndi | cut -c1-25,44- | grep "^[a-z]*[0-9][ \t].*Link"', $netstat_n);
|
||||
$lines_b = preg_split("/\n/", $netstat_b, -1, PREG_SPLIT_NO_EMPTY);
|
||||
$lines_n = preg_split("/\n/", $netstat_n, -1, PREG_SPLIT_NO_EMPTY);
|
||||
for ($i = 0, $max = sizeof($lines_b); $i < $max; $i++) {
|
||||
$ar_buf_b = preg_split("/\s+/", $lines_b[$i]);
|
||||
$ar_buf_n = preg_split("/\s+/", $lines_n[$i]);
|
||||
if (! empty($ar_buf_b[0]) && ! empty($ar_buf_n[3])) {
|
||||
$dev = new NetDevice();
|
||||
$dev->setName($ar_buf_b[0]);
|
||||
$dev->setTxBytes($ar_buf_b[4]);
|
||||
$dev->setRxBytes($ar_buf_b[3]);
|
||||
$dev->setDrops($ar_buf_n[8]);
|
||||
$dev->setErrors($ar_buf_n[4] + $ar_buf_n[6]);
|
||||
$this->sys->setNetDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* IDE information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
protected function ide()
|
||||
{
|
||||
foreach ($this->readdmesg() as $line) {
|
||||
if (preg_match('/^(.*) at (pciide|wdc|atabus|atapibus)[0-9] (.*): <(.*)>/', $line, $ar_buf)) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($ar_buf[1]);
|
||||
// now loop again and find the capacity
|
||||
foreach ($this->readdmesg() as $line2) {
|
||||
if (preg_match("/^(".$ar_buf[1]."): (.*), (.*), (.*)MB, .*$/", $line2, $ar_buf_n)) {
|
||||
$dev->setCapacity($ar_buf_n[4] * 2048 * 1.049);
|
||||
} elseif (preg_match("/^(".$ar_buf[1]."): (.*) MB, (.*), (.*), .*$/", $line2, $ar_buf_n)) {
|
||||
$dev->setCapacity($ar_buf_n[2] * 2048);
|
||||
}
|
||||
}
|
||||
$this->sys->setIdeDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* get icon name
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _distroicon()
|
||||
{
|
||||
$this->sys->setDistributionIcon('NetBSD.png');
|
||||
}
|
||||
|
||||
/**
|
||||
* get the information
|
||||
*
|
||||
* @see BSDCommon::build()
|
||||
*
|
||||
* @return Void
|
||||
*/
|
||||
function build()
|
||||
{
|
||||
parent::build();
|
||||
$this->_distroicon();
|
||||
$this->_network();
|
||||
$this->_uptime();
|
||||
}
|
||||
}
|
||||
?>
|
||||
74
ZeedFramework/library/3rd/PSI/includes/os/class.OS.inc.php
Normal file
74
ZeedFramework/library/3rd/PSI/includes/os/class.OS.inc.php
Normal file
@@ -0,0 +1,74 @@
|
||||
<?php
|
||||
/**
|
||||
* Basic OS Class
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version SVN: $Id: class.OS.inc.php 263 2009-06-22 13:01:52Z bigmichi1 $
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
/**
|
||||
* Basic OS functions for all OS classes
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version Release: 3.0
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
abstract class OS implements PSI_Interface_OS
|
||||
{
|
||||
/**
|
||||
* object for error handling
|
||||
*
|
||||
* @var Error
|
||||
*/
|
||||
protected $error;
|
||||
|
||||
/**
|
||||
* @var System
|
||||
*/
|
||||
protected $sys;
|
||||
|
||||
/**
|
||||
* build the global Error object
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
$this->error = Error::singleton();
|
||||
$this->sys = new System();
|
||||
}
|
||||
|
||||
/**
|
||||
* get os specific encoding
|
||||
*
|
||||
* @see PSI_Interface_OS::getEncoding()
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getEncoding()
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* get the filled or unfilled (with default values) System object
|
||||
*
|
||||
* @see PSI_Interface_OS::getSys()
|
||||
*
|
||||
* @return System
|
||||
*/
|
||||
public final function getSys()
|
||||
{
|
||||
$this->build();
|
||||
return $this->sys;
|
||||
}
|
||||
}
|
||||
?>
|
||||
142
ZeedFramework/library/3rd/PSI/includes/os/class.OpenBSD.inc.php
Normal file
142
ZeedFramework/library/3rd/PSI/includes/os/class.OpenBSD.inc.php
Normal file
@@ -0,0 +1,142 @@
|
||||
<?php
|
||||
/**
|
||||
* OpenBSD System Class
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version SVN: $Id: class.OpenBSD.inc.php 287 2009-06-26 12:11:59Z bigmichi1 $
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
/**
|
||||
* OpenBSD sysinfo class
|
||||
* get all the required information from OpenBSD systems
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version Release: 3.0
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
class OpenBSD extends BSDCommon
|
||||
{
|
||||
/**
|
||||
* define the regexp for log parser
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
parent::__construct();
|
||||
$this->setCPURegExp1("^cpu(.*) (.*) MHz");
|
||||
$this->setCPURegExp2("/(.*),(.*),(.*),(.*),(.*)/");
|
||||
$this->setSCSIRegExp1("^(.*) at scsibus.*: <(.*)> .*");
|
||||
$this->setSCSIRegExp2("^(da[0-9]): (.*)MB ");
|
||||
$this->setPCIRegExp1("/(.*) at pci[0-9] .* \"(.*)\"/");
|
||||
$this->setPCIRegExp2("/\"(.*)\" (.*).* at [.0-9]+ irq/");
|
||||
}
|
||||
|
||||
/**
|
||||
* UpTime
|
||||
* time the system is running
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _uptime()
|
||||
{
|
||||
$a = $this->grabkey('kern.boottime');
|
||||
$this->sys->setUptime(time() - $a);
|
||||
}
|
||||
|
||||
/**
|
||||
* get network information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _network()
|
||||
{
|
||||
CommonFunctions::executeProgram('netstat', '-nbdi | cut -c1-25,44- | grep Link | grep -v \'* \'', $netstat_b, PSI_DEBUG);
|
||||
CommonFunctions::executeProgram('netstat', '-ndi | cut -c1-25,44- | grep Link | grep -v \'* \'', $netstat_n, PSI_DEBUG);
|
||||
$lines_b = preg_split("/\n/", $netstat_b, -1, PREG_SPLIT_NO_EMPTY);
|
||||
$lines_n = preg_split("/\n/", $netstat_n, -1, PREG_SPLIT_NO_EMPTY);
|
||||
for ($i = 0, $max = sizeof($lines_b); $i < $max; $i++) {
|
||||
$ar_buf_b = preg_split("/\s+/", $lines_b[$i]);
|
||||
$ar_buf_n = preg_split("/\s+/", $lines_n[$i]);
|
||||
if (! empty($ar_buf_b[0]) && ! empty($ar_buf_n[3])) {
|
||||
$dev = new NetDevice();
|
||||
$dev->setName($ar_buf_b[0]);
|
||||
$dev->setTxBytes($ar_buf_b[4]);
|
||||
$dev->setRxBytes($ar_buf_b[3]);
|
||||
$dev->setErrors($ar_buf_n[4] + $ar_buf_n[6]);
|
||||
$dev->setDrops($ar_buf_n[8]);
|
||||
$this->sys->setNetDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* IDE information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
protected function ide()
|
||||
{
|
||||
foreach ($this->readdmesg() as $line) {
|
||||
if (preg_match('/^(.*) at pciide[0-9] (.*): <(.*)>/', $line, $ar_buf)) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($ar_buf[0]);
|
||||
// now loop again and find the capacity
|
||||
foreach ($this->readdmesg() as $line2) {
|
||||
if (preg_match("/^(".$ar_buf[0]."): (.*), (.*), (.*)MB, .*$/", $line2, $ar_buf_n)) {
|
||||
$dev->setCapacity($ar_buf_n[4] * 2048 * 1.049);
|
||||
}
|
||||
}
|
||||
$this->sys->setIdeDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* get CPU information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
protected function cpuinfo()
|
||||
{
|
||||
$dev = new CpuDevice();
|
||||
$dev->setModel($this->grabkey('hw.model'));
|
||||
$dev->setCpuSpeed($this->grabkey('hw.cpuspeed'));
|
||||
$this->sys->setCpus($dev);
|
||||
}
|
||||
|
||||
/**
|
||||
* get icon name
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _distroicon()
|
||||
{
|
||||
$this->sys->setDistributionIcon('OpenBSD.png');
|
||||
}
|
||||
|
||||
/**
|
||||
* get the information
|
||||
*
|
||||
* @see BSDCommon::build()
|
||||
*
|
||||
* @return Void
|
||||
*/
|
||||
function build()
|
||||
{
|
||||
parent::buil();
|
||||
$this->_distroicon();
|
||||
$this->_network();
|
||||
$this->_uptime();
|
||||
}
|
||||
}
|
||||
?>
|
||||
281
ZeedFramework/library/3rd/PSI/includes/os/class.SunOS.inc.php
Normal file
281
ZeedFramework/library/3rd/PSI/includes/os/class.SunOS.inc.php
Normal file
@@ -0,0 +1,281 @@
|
||||
<?php
|
||||
/**
|
||||
* SunOS System Class
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version SVN: $Id: class.SunOS.inc.php 287 2009-06-26 12:11:59Z bigmichi1 $
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
/**
|
||||
* SunOS sysinfo class
|
||||
* get all the required information from SunOS systems
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version Release: 3.0
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
class SunOS extends OS
|
||||
{
|
||||
/**
|
||||
* add warning to errors
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
$this->error->addError("WARN", "The SunOS version of phpSysInfo is work in progress, some things currently don't work");
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract kernel values via kstat() interface
|
||||
*
|
||||
* @param string $key key for kstat programm
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
private function _kstat($key)
|
||||
{
|
||||
if (CommonFunctions::executeProgram('kstat', '-p d '.$key, $m, PSI_DEBUG)) {
|
||||
list($key, $value) = preg_split("/\t/", trim($m), 2);
|
||||
return $value;
|
||||
} else {
|
||||
return '';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Virtual Host Name
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _hostname()
|
||||
{
|
||||
if (PSI_USE_VHOST === true) {
|
||||
$this->sys->setHostname(getenv('SERVER_NAME'));
|
||||
} else {
|
||||
if (CommonFunctions::executeProgram('uname', '-n', $result, PSI_DEBUG)) {
|
||||
$ip = gethostbyname($result);
|
||||
if ($ip != $result) {
|
||||
$this->sys->setHostname(gethostbyaddr($ip));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* IP of the Virtual Host Name
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _ip()
|
||||
{
|
||||
if (PSI_USE_VHOST === true) {
|
||||
$this->sys->setIp(gethostbyname($this->_hostname()));
|
||||
} else {
|
||||
if (!($result = getenv('SERVER_ADDR'))) {
|
||||
$this->sys->setIp(gethostbyname($this->_hostname()));
|
||||
} else {
|
||||
$this->sys->setIp($result);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Kernel Version
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _kernel()
|
||||
{
|
||||
if (CommonFunctions::executeProgram('uname', '-s', $os, PSI_DEBUG)) {
|
||||
if (CommonFunctions::executeProgram('uname', '-r', $version, PSI_DEBUG)) {
|
||||
$this->sys->setKernel($os.' '.$version);
|
||||
} else {
|
||||
$this->sys->setKernel($os);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* UpTime
|
||||
* time the system is running
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _uptime()
|
||||
{
|
||||
$this->sys->setUptime(time() - $this->_kstat('unix:0:system_misc:boot_time'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Number of Users
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _users()
|
||||
{
|
||||
if (CommonFunctions::executeProgram('who', '-q', $buf, PSI_DEBUG)) {
|
||||
$who = preg_split('/=/', $buf);
|
||||
$this->sys->setUsers($who[1]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Processor Load
|
||||
* optionally create a loadbar
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _loadavg()
|
||||
{
|
||||
$load1 = $this->_kstat('unix:0:system_misc:avenrun_1min');
|
||||
$load5 = $this->_kstat('unix:0:system_misc:avenrun_5min');
|
||||
$load15 = $this->_kstat('unix:0:system_misc:avenrun_15min');
|
||||
$this->sys->setLoad(round($load1 / 256, 2).' '.round($load5 / 256, 2).' '.round($load15 / 256, 2));
|
||||
}
|
||||
|
||||
/**
|
||||
* CPU information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _cpuinfo()
|
||||
{
|
||||
$dev = new CpuDevice();
|
||||
if (CommonFunctions::executeProgram('uname', '-i', $buf, PSI_DEBUG)) {
|
||||
$dev->setModel(trim($buf));
|
||||
}
|
||||
$dev->setCpuSpeed($this->_kstat('cpu_info:0:cpu_info0:clock_MHz'));
|
||||
$dev->setCache($this->_kstat('cpu_info:0:cpu_info0:cpu_type') * 1024);
|
||||
$this->sys->setCpus($dev);
|
||||
}
|
||||
|
||||
/**
|
||||
* Network devices
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _network()
|
||||
{
|
||||
if (CommonFunctions::executeProgram('netstat', '-ni | awk \'(NF ==10){print;}\'', $netstat, PSI_DEBUG)) {
|
||||
$lines = preg_split("/\n/", $netstat, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($lines as $line) {
|
||||
$ar_buf = preg_split("/\s+/", $line);
|
||||
if (! empty($ar_buf[0]) && $ar_buf[0] !== 'Name') {
|
||||
$dev = new NetDevice();
|
||||
$dev->setName($ar_buf[0]);
|
||||
$results[$ar_buf[0]]['errs'] = $ar_buf[5] + $ar_buf[7];
|
||||
preg_match('/^(\D+)(\d+)$/', $ar_buf[0], $intf);
|
||||
$prefix = $intf[1].':'.$intf[2].':'.$intf[1].$intf[2].':';
|
||||
$cnt = $this->_kstat($prefix.'drop');
|
||||
if ($cnt > 0) {
|
||||
$dev->setDrops($cnt);
|
||||
}
|
||||
$cnt = $this->_kstat($prefix.'obytes64');
|
||||
if ($cnt > 0) {
|
||||
$dev->setTxBytes($cnt);
|
||||
}
|
||||
$cnt = $this->_kstat($prefix.'rbytes64');
|
||||
if ($cnt > 0) {
|
||||
$dev->setRxBytes($cnt);
|
||||
}
|
||||
$this->sys->setNetDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Physical memory information and Swap Space information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _memory()
|
||||
{
|
||||
$pagesize = $this->_kstat('unix:0:seg_cache:slab_size');
|
||||
$this->sys->setMemTotal($this->_kstat('unix:0:system_pages:pagestotal') * $pagesize);
|
||||
$this->sys->setMemUsed($this->_kstat('unix:0:system_pages:pageslocked') * $pagesize);
|
||||
$this->sys->setMemFree($this->_kstat('unix:0:system_pages:pagesfree') * $pagesize);
|
||||
$dev = new DiskDevice();
|
||||
$dev->setName('SWAP');
|
||||
$dev->setFsType('swap');
|
||||
$dev->setTotal($this->_kstat('unix:0:vminfo:swap_avail') / 1024);
|
||||
$dev->setUsed($this->_kstat('unix:0:vminfo:swap_alloc') / 1024);
|
||||
$dev->setFree($this->_kstat('unix:0:vminfo:swap_free') / 1024);
|
||||
$this->sys->setSwapDevices($dev);
|
||||
}
|
||||
|
||||
/**
|
||||
* filesystem information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _filesystems()
|
||||
{
|
||||
if (CommonFunctions::executeProgram('df', '-k', $df, PSI_DEBUG)) {
|
||||
$mounts = preg_split("/\n/", $df, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($mounts as $mount) {
|
||||
$ar_buf = preg_split('/\s+/', $mount, 6);
|
||||
$dev = new DiskDevice();
|
||||
$dev->setName($ar_buf[0]);
|
||||
$dev->setTotal($ar_buf[1] * 1024);
|
||||
$dev->setUsed($ar_buf[2] * 1024);
|
||||
$dev->setFree($ar_buf[3] * 1024);
|
||||
$dev->setMountPoint($ar_buf[5]);
|
||||
if (CommonFunctions::executeProgram('df', '-n', $dftypes, PSI_DEBUG)) {
|
||||
$mounttypes = preg_split("/\n/", $dftypes, -1, PREG_SPLIT_NO_EMPTY);
|
||||
foreach ($mounttypes as $type) {
|
||||
$ty_buf = preg_split('/:/', $type, 2);
|
||||
if ($ty_buf == $dev->getName()) {
|
||||
$dev->setFsType($ty_buf[1]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
$this->sys->setDiskDevices($dev);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Distribution Icon
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _distro()
|
||||
{
|
||||
$this->sys->setDistribution('SunOS');
|
||||
$this->sys->setDistributionIcon('SunOS.png');
|
||||
}
|
||||
|
||||
/**
|
||||
* get the information
|
||||
*
|
||||
* @see PSI_Interface_OS::build()
|
||||
*
|
||||
* @return Void
|
||||
*/
|
||||
function build()
|
||||
{
|
||||
$this->_ip();
|
||||
$this->_hostname();
|
||||
$this->_distro();
|
||||
$this->_kernel();
|
||||
$this->_uptime();
|
||||
$this->_users();
|
||||
$this->_loadavg();
|
||||
$this->_cpuinfo();
|
||||
$this->_network();
|
||||
$this->_memory();
|
||||
$this->_filesystems();
|
||||
}
|
||||
}
|
||||
?>
|
||||
450
ZeedFramework/library/3rd/PSI/includes/os/class.WINNT.inc.php
Normal file
450
ZeedFramework/library/3rd/PSI/includes/os/class.WINNT.inc.php
Normal file
@@ -0,0 +1,450 @@
|
||||
<?php
|
||||
/**
|
||||
* WINNT System Class
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version SVN: $Id: class.WINNT.inc.php 329 2009-09-07 11:21:44Z bigmichi1 $
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
/**
|
||||
* WINNT sysinfo class
|
||||
* get all the required information from WINNT systems
|
||||
* information are retrieved through the WMI interface
|
||||
*
|
||||
* @category PHP
|
||||
* @package PSI_OS
|
||||
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
||||
* @copyright 2009 phpSysInfo
|
||||
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
||||
* @version Release: 3.0
|
||||
* @link http://phpsysinfo.sourceforge.net
|
||||
*/
|
||||
class WINNT extends OS
|
||||
{
|
||||
/**
|
||||
* holds the COM object that we pull all the WMI data from
|
||||
*
|
||||
* @var Object
|
||||
*/
|
||||
private $_wmi;
|
||||
|
||||
/**
|
||||
* holds all devices, which are in the system
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
private $_wmidevices;
|
||||
|
||||
/**
|
||||
* store language encoding of the system to convert some output to utf-8
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_charset = "";
|
||||
|
||||
/**
|
||||
* build the global Error object and create the WMI connection
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
parent::__construct();
|
||||
// don't set this params for local connection, it will not work
|
||||
$strHostname = '';
|
||||
$strUser = '';
|
||||
$strPassword = '';
|
||||
|
||||
// initialize the wmi object
|
||||
$objLocator = new COM('WbemScripting.SWbemLocator');
|
||||
if ($strHostname == "") {
|
||||
$this->_wmi = $objLocator->ConnectServer();
|
||||
} else {
|
||||
$this->_wmi = $objLocator->ConnectServer($strHostname, 'rootcimv2', $strHostname.'\\'.$strUser, $strPassword);
|
||||
}
|
||||
$this->_getCodeSet();
|
||||
}
|
||||
|
||||
/**
|
||||
* store the codepage of the os for converting some strings to utf-8
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _getCodeSet()
|
||||
{
|
||||
$buffer = $this->_getWMI('Win32_OperatingSystem', array('CodeSet'));
|
||||
$this->_charset = 'windows-'.$buffer[0]['CodeSet'];
|
||||
}
|
||||
|
||||
/**
|
||||
* function for getting a list of values in the specified context
|
||||
* optionally filter this list, based on the list from second parameter
|
||||
*
|
||||
* @param string $strClass name of the class where the values are stored
|
||||
* @param array $strValue filter out only needed values, if not set all values of the class are returned
|
||||
*
|
||||
* @return array content of the class stored in an array
|
||||
*/
|
||||
private function _getWMI($strClass, $strValue = array())
|
||||
{
|
||||
$arrData = array();
|
||||
$value = "";
|
||||
try {
|
||||
$objWEBM = $this->_wmi->Get($strClass);
|
||||
$arrProp = $objWEBM->Properties_;
|
||||
$arrWEBMCol = $objWEBM->Instances_();
|
||||
foreach ($arrWEBMCol as $objItem) {
|
||||
if (is_array($arrProp)) {
|
||||
reset($arrProp);
|
||||
}
|
||||
$arrInstance = array();
|
||||
foreach ($arrProp as $propItem) {
|
||||
eval("\$value = \$objItem->".$propItem->Name.";");
|
||||
if ( empty($strValue)) {
|
||||
$arrInstance[$propItem->Name] = trim($value);
|
||||
} else {
|
||||
if (in_array($propItem->Name, $strValue)) {
|
||||
$arrInstance[$propItem->Name] = trim($value);
|
||||
}
|
||||
}
|
||||
}
|
||||
$arrData[] = $arrInstance;
|
||||
}
|
||||
}
|
||||
catch(Exception $e) {
|
||||
if (PSI_DEBUG) {
|
||||
$this->error->addError($e->getCode(), $e->getMessage());
|
||||
}
|
||||
}
|
||||
return $arrData;
|
||||
}
|
||||
|
||||
/**
|
||||
* retrieve different device types from the system based on selector
|
||||
*
|
||||
* @param string $strType type of the devices that should be returned
|
||||
*
|
||||
* @return array list of devices of the specified type
|
||||
*/
|
||||
private function _devicelist($strType)
|
||||
{
|
||||
if ( empty($this->_wmidevices)) {
|
||||
$this->_wmidevices = $this->_getWMI('Win32_PnPEntity', array('Name', 'PNPDeviceID'));
|
||||
}
|
||||
$list = array();
|
||||
foreach ($this->_wmidevices as $device) {
|
||||
if (substr($device['PNPDeviceID'], 0, strpos($device['PNPDeviceID'], "\\") + 1) == ($strType."\\")) {
|
||||
$list[] = $device['Name'];
|
||||
}
|
||||
}
|
||||
return $list;
|
||||
}
|
||||
|
||||
/**
|
||||
* Host Name
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _hostname()
|
||||
{
|
||||
if (PSI_USE_VHOST === true) {
|
||||
$this->sys->setHostname(getenv('SERVER_NAME'));
|
||||
} else {
|
||||
$buffer = $this->_getWMI('Win32_ComputerSystem', array('Name'));
|
||||
$result = $buffer[0]['Name'];
|
||||
$ip = gethostbyname($result);
|
||||
if ($ip != $result) {
|
||||
$this->sys->setHostname(gethostbyaddr($ip));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* IP of the Canonical Host Name
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _ip()
|
||||
{
|
||||
if (PSI_USE_VHOST === true) {
|
||||
$this->sys->setIp(gethostbyname($this->_hostname()));
|
||||
} else {
|
||||
$buffer = $this->_getWMI('Win32_ComputerSystem', array('Name'));
|
||||
$result = $buffer[0]['Name'];
|
||||
$this->sys->setIp(gethostbyname($result));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* UpTime
|
||||
* time the system is running
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _uptime()
|
||||
{
|
||||
$result = 0;
|
||||
date_default_timezone_set('UTC');
|
||||
$buffer = $this->_getWMI('Win32_OperatingSystem', array('LastBootUpTime', 'LocalDateTime'));
|
||||
$byear = intval(substr($buffer[0]['LastBootUpTime'], 0, 4));
|
||||
$bmonth = intval(substr($buffer[0]['LastBootUpTime'], 4, 2));
|
||||
$bday = intval(substr($buffer[0]['LastBootUpTime'], 6, 2));
|
||||
$bhour = intval(substr($buffer[0]['LastBootUpTime'], 8, 2));
|
||||
$bminute = intval(substr($buffer[0]['LastBootUpTime'], 10, 2));
|
||||
$bseconds = intval(substr($buffer[0]['LastBootUpTime'], 12, 2));
|
||||
$lyear = intval(substr($buffer[0]['LocalDateTime'], 0, 4));
|
||||
$lmonth = intval(substr($buffer[0]['LocalDateTime'], 4, 2));
|
||||
$lday = intval(substr($buffer[0]['LocalDateTime'], 6, 2));
|
||||
$lhour = intval(substr($buffer[0]['LocalDateTime'], 8, 2));
|
||||
$lminute = intval(substr($buffer[0]['LocalDateTime'], 10, 2));
|
||||
$lseconds = intval(substr($buffer[0]['LocalDateTime'], 12, 2));
|
||||
$boottime = mktime($bhour, $bminute, $bseconds, $bmonth, $bday, $byear);
|
||||
$localtime = mktime($lhour, $lminute, $lseconds, $lmonth, $lday, $lyear);
|
||||
$result = $localtime - $boottime;
|
||||
$this->sys->setUptime($result);
|
||||
}
|
||||
|
||||
/**
|
||||
* Number of Users
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _users()
|
||||
{
|
||||
$users = 0;
|
||||
$buffer = $this->_getWMI('Win32_Process', array('Caption'));
|
||||
foreach ($buffer as $process) {
|
||||
if (strtoupper($process['Caption']) == strtoupper('explorer.exe')) {
|
||||
$users++;
|
||||
}
|
||||
}
|
||||
$this->sys->setUsers($users);
|
||||
}
|
||||
|
||||
/**
|
||||
* Distribution
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _distro()
|
||||
{
|
||||
$buffer = $this->_getWMI('Win32_OperatingSystem', array('Version', 'ServicePackMajorVersion'));
|
||||
$kernel = $buffer[0]['Version'];
|
||||
if ($buffer[0]['ServicePackMajorVersion'] > 0) {
|
||||
$kernel .= ' SP'.$buffer[0]['ServicePackMajorVersion'];
|
||||
}
|
||||
$this->sys->setKernel($kernel);
|
||||
|
||||
$buffer = $this->_getWMI('Win32_OperatingSystem', array('Caption'));
|
||||
$this->sys->setDistribution($buffer[0]['Caption']);
|
||||
|
||||
if ($kernel[0] == 6) {
|
||||
$icon = 'vista.png';
|
||||
} else {
|
||||
$icon = 'xp.png';
|
||||
}
|
||||
$this->sys->setDistributionIcon($icon);
|
||||
}
|
||||
|
||||
/**
|
||||
* Processor Load
|
||||
* optionally create a loadbar
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _loadavg()
|
||||
{
|
||||
$loadavg = "";
|
||||
$sum = 0;
|
||||
$buffer = $this->_getWMI('Win32_Processor', array('LoadPercentage'));
|
||||
foreach ($buffer as $load) {
|
||||
$value = $load['LoadPercentage'];
|
||||
$loadavg .= $value.' ';
|
||||
$sum += $value;
|
||||
}
|
||||
$this->sys->setLoad(trim($loadavg));
|
||||
if (PSI_LOAD_BAR) {
|
||||
$this->sys->setLoadPercent($sum / count($buffer));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* CPU information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _cpuinfo()
|
||||
{
|
||||
$allCpus = $this->_getWMI('Win32_Processor', array('Name', 'L2CacheSize', 'CurrentClockSpeed', 'ExtClock', 'NumberOfCores'));
|
||||
foreach ($allCpus as $oneCpu) {
|
||||
$coreCount = 1;
|
||||
if (isset($oneCpu['NumberOfCores'])) {
|
||||
$coreCount = $oneCpu['NumberOfCores'];
|
||||
}
|
||||
for ($i = 0; $i < $coreCount; $i++) {
|
||||
$cpu = new CpuDevice();
|
||||
$cpu->setModel($oneCpu['Name']);
|
||||
$cpu->setCache($oneCpu['L2CacheSize'] * 1024);
|
||||
$cpu->setCpuSpeed($oneCpu['CurrentClockSpeed']);
|
||||
$cpu->setBusSpeed($oneCpu['ExtClock']);
|
||||
$this->sys->setCpus($cpu);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Hardwaredevices
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _hardware()
|
||||
{
|
||||
foreach ($this->_devicelist('PCI') as $pciDev) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($pciDev);
|
||||
$this->sys->setPciDevices($dev);
|
||||
}
|
||||
|
||||
foreach ($this->_devicelist('IDE') as $ideDev) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($ideDev);
|
||||
$this->sys->setIdeDevices($dev);
|
||||
}
|
||||
|
||||
foreach ($this->_devicelist('SCSI') as $scsiDev) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($scsiDev);
|
||||
$this->sys->setScsiDevices($dev);
|
||||
}
|
||||
|
||||
foreach ($this->_devicelist('USB') as $usbDev) {
|
||||
$dev = new HWDevice();
|
||||
$dev->setName($usbDev);
|
||||
$this->sys->setUsbDevices($dev);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Network devices
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _network()
|
||||
{
|
||||
foreach ($this->_getWMI('Win32_PerfRawData_Tcpip_NetworkInterface') as $device) {
|
||||
$dev = new NetDevice();
|
||||
$dev->setName($device['Name']);
|
||||
// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/wmisdk/wmi/win32_perfrawdata_tcpip_networkinterface.asp
|
||||
// there is a possible bug in the wmi interfaceabout uint32 and uint64: http://www.ureader.com/message/1244948.aspx, so that
|
||||
// magative numbers would occour, try to calculate the nagative value from total - positive number
|
||||
$txbytes = $device['BytesSentPersec'];
|
||||
if ($txbytes < 0) {
|
||||
$txbytes = $device['BytesTotalPersec'] - $device['BytesReceivedPersec'];
|
||||
|
||||
}
|
||||
$dev->setTxBytes($txbytes);
|
||||
$rxbytes = $device['BytesReceivedPersec'];
|
||||
if ($rxbytes < 0) {
|
||||
$rxbytes = $device['BytesTotalPersec'] - $device['BytesSentPersec'];
|
||||
}
|
||||
$dev->setRxBytes($rxbytes);
|
||||
$dev->setErrors($device['PacketsReceivedErrors']);
|
||||
$dev->setDrops($device['PacketsReceivedDiscarded']);
|
||||
$this->sys->setNetDevices($dev);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Physical memory information and Swap Space information
|
||||
*
|
||||
* @link http://msdn2.microsoft.com/En-US/library/aa394239.aspx
|
||||
* @link http://msdn2.microsoft.com/en-us/library/aa394246.aspx
|
||||
* @return void
|
||||
*/
|
||||
private function _memory()
|
||||
{
|
||||
$buffer = $this->_getWMI("Win32_OperatingSystem", array('TotalVisibleMemorySize', 'FreePhysicalMemory'));
|
||||
$this->sys->setMemTotal($buffer[0]['TotalVisibleMemorySize'] * 1024);
|
||||
$this->sys->setMemFree($buffer[0]['FreePhysicalMemory'] * 1024);
|
||||
$this->sys->setMemUsed($this->sys->getMemTotal() - $this->sys->getMemFree());
|
||||
|
||||
$buffer = $this->_getWMI('Win32_PageFileUsage');
|
||||
foreach ($buffer as $swapdevice) {
|
||||
$dev = new DiskDevice();
|
||||
$dev->setName("SWAP");
|
||||
$dev->setMountPoint($swapdevice['Name']);
|
||||
$dev->setTotal($swapdevice['AllocatedBaseSize'] * 1024 * 1024);
|
||||
$dev->setUsed($swapdevice['CurrentUsage'] * 1024 * 1024);
|
||||
$dev->setFree($dev->getTotal() - $dev->getUsed());
|
||||
$dev->setFsType('swap');
|
||||
$this->sys->setSwapDevices($dev);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* filesystem information
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function _filesystems()
|
||||
{
|
||||
$typearray = array('Unknown', 'No Root Directory', 'Removable Disk', 'Local Disk', 'Network Drive', 'Compact Disc', 'RAM Disk');
|
||||
$floppyarray = array('Unknown', '5 1/4 in.', '3 1/2 in.', '3 1/2 in.', '3 1/2 in.', '3 1/2 in.', '5 1/4 in.', '5 1/4 in.', '5 1/4 in.', '5 1/4 in.', '5 1/4 in.', 'Other', 'HD', '3 1/2 in.', '3 1/2 in.', '5 1/4 in.', '5 1/4 in.', '3 1/2 in.', '3 1/2 in.', '5 1/4 in.', '3 1/2 in.', '3 1/2 in.', '8 in.');
|
||||
$buffer = $this->_getWMI('Win32_LogicalDisk', array('Name', 'Size', 'FreeSpace', 'FileSystem', 'DriveType', 'MediaType'));
|
||||
foreach ($buffer as $filesystem) {
|
||||
$dev = new DiskDevice();
|
||||
$dev->setMountPoint($filesystem['Name']);
|
||||
$dev->setFsType($filesystem['FileSystem']);
|
||||
if ($filesystem['Size'] > 0) {
|
||||
$dev->setTotal($filesystem['Size']);
|
||||
$dev->setFree($filesystem['FreeSpace']);
|
||||
$dev->setUsed($filesystem['Size'] - $filesystem['FreeSpace']);
|
||||
}
|
||||
if ($filesystem['MediaType'] != "" && $filesystem['DriveType'] == 2) {
|
||||
$dev->setName($typearray[$filesystem['DriveType']]." (".$floppyarray[$filesystem['MediaType']].")");
|
||||
} else {
|
||||
$dev->setName($typearray[$filesystem['DriveType']]);
|
||||
}
|
||||
$this->sys->setDiskDevices($dev);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* get os specific encoding
|
||||
*
|
||||
* @see OS::getEncoding()
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
function getEncoding()
|
||||
{
|
||||
return $this->_charset;
|
||||
}
|
||||
|
||||
/**
|
||||
* get the information
|
||||
*
|
||||
* @see PSI_Interface_OS::build()
|
||||
*
|
||||
* @return Void
|
||||
*/
|
||||
function build()
|
||||
{
|
||||
$this->_ip();
|
||||
$this->_hostname();
|
||||
$this->_distro();
|
||||
$this->_users();
|
||||
$this->_uptime();
|
||||
$this->_cpuinfo();
|
||||
$this->_network();
|
||||
$this->_hardware();
|
||||
$this->_filesystems();
|
||||
$this->_memory();
|
||||
$this->_loadavg();
|
||||
}
|
||||
}
|
||||
?>
|
||||
Reference in New Issue
Block a user