Subversion Repositories computer_asset_manager_v1

<?php

   /*

    * function will attempt to make a constant ($value) safe for SQL depending on the type.

    * 

    * if $value is empty, $default is returned, as will happen if any of the

    * conversions (date, datetime, etc...) fail.

    * 

    * First, it will pass it through get_magic_quotes_gpc, 

    * then will run through mysql_real_escape_string

    * 

    * For strings, will encapsulate in quotes

    * Dates will attempt a conversion, then change to YYYY-MM-DD and encapsulate in quotes

    *    if default is the constant now(), will pass that through to MySQL

    * DateTime will perform the same, but change to YYYY-MM-DD HH:MM:SS

    * Integer and Floats are passed through builtins intval and floatval

    * Boolean only checks the first character, a '0', 'f' and 'n' denoting false

    *    all else denoting true. The result is converted based on the variable

    *    $falsetrue, with the first char denoting false and the second denoting true

    */

   function makeSafeSQLConstant ( $value, $type='S', $default='null', $falsetrue='10' ) {

      // return $default on undefined or empty values

      if ( ! isset( $value ) ) return $default;

      if (strlen($value) == 0) return $default;

      // print "Processing $value as $type with default $default<br>\n";

      switch ( strtolower( $type ) ) {

         case 'string' :

         case 's' : 

                  if ( get_magic_quotes_gpc() ) 

                     $value = stripslashes($value);

                  $value = mysql_real_escape_string( $value );

                  $value = strlen( $value ) > 0 ? "'$value'" : $default;

                  break;

         case 'date' :

         case 'd' :

                  if ( $value != 'null' && $value != 'now()' ) {

                     $result = strtotime( $value );

                     $value = ( $result === false ) ? $default : "'" . Date( 'Y-m-d', $result) . "'";

                  }

                  break;

         case 'datetime':

         case 'timestamp':

         case 'dt': 

                  if ( $value != 'null' && $value != 'now()' ) {

                     $result = strtotime( $value );

                     $value = ( $result === false ) ? $default : "'" . Date( 'Y-m-d H:i:s', $result) . "'";

                  }

                  break;

         case 'integer':

         case 'i' :  

                  $value = intval( $value );

                  break;

         case 'float':

         case 'f' :  

                  $value = floatval( $value );

                  break;

         case 'bool':

         case 'boolean':

         case 'b' :  // note, because of the way strpos works, you can not

                     // simply set $value based on the output; you MUST do

                     // as below; specifically check for false, then set the result

                     $value =  strpos( '0fn', strtolower(substr( $value, 0, 1 )) ) === false ? 0 : 1;

                     $value = substr( $falsetrue, $value, 0, 1 );

                     break;

      } // switch

      return $value;

   }

   /*

    * Trims a value, then compares it to several 'null' possibilities

    * if it is a null, returns empty string, otherwise returns value

    */

   function cleanUpDMIValue( $value ) {

      $value = trim( $value );

      switch (strtolower( $value )) {

         case 'unknown':

         case 'unspecified' :

         case 'not available':

         case 'to be filled by o.e.m.':

         case 'not specified': return '';

      }

      return $value;

   }

   /*

    * Read value from array of hash, return array of "$outputKey\tvalue" for each entry found

    * If nothing found, returns empty array

    * if $unique is true, returns first non-empty value found

    * if $outputKey is not defined, uses $key

    */

   function getDMIInformation( $data, $type, $key, $outputKey = '', $unique = true ) {

      $return = array();

      foreach ( $data[$type] as $handle ) {

         if ( isset( $handle[$key]) ) {

            $a = cleanUpDMIValue( $handle[$key] );

            if ( $a ) {

               $return[] = ( $outputKey ? $outputKey : $key ) . "\t" . $a;

               if ( $unique ) {

                  return $return;

               }

            }

         }

      }

      return $return;

   }

   /*

    * adds $value to array

    * if $value is scalar, simply adds it

    * if $value is array, adds every row

    * returns modified array

    */

   function mergeArrays( $array, $value ) {

      if ( $value ) {

         switch (gettype( $value ) ) {

            case 'array' : foreach ( $value as $thisVal ) {

                              $array[] = $thisVal;

                           }

                           break;

            case 'boolean' :

            case 'integer' :

            case 'double'  :

            case 'string'  : $array[] = $value;

         } // switch

      }

      return $array;

   } //mergeArrays

   /*

    * Function will take an array of lines representing the output of a dmidecode file

    * and pick and choose the values we want to put into CAMP attributes.

    * It will return an array of key/value pairs to be added into the attributes table

    *

    * NOTE: this is a summary of values we decided to store. dmidecode files have a lot of

    * additional information we chose not to include

    * 

    */

   function dmidecode2array( $contents ) {

   // allows us to group the dmi types by function. not implemented

   $dmiGroups = array(

         "bios" => "0,13",

         "system" => "1,12,15,23,32",

         "baseboard" => "2,10,41",

         "chassis" => "3",

         "processor" => "4",

         "memory" => "5,6,16,17",

         "cache" => "7",

         "connector" => "8",

         "slot" => "9"

   );

   // This contains the standard DMI types, ie no OEM stuff. For reference, not used in code

   $standardDMITypes = array( 

         "0" => "BIOS",

         "1" => "System",

         "2" => "Baseboard",

         "3" => "Chassis",

         "4" => "Processor",

         "5" => "Memory Controller",

         "6" => "Memory Module",

         "7" => "Cache",

         "8" => "Port Connector",

         "9" => "System Slots",

         "10" => "On Board Devices",

         "11" => "OEM Strings",

         "12" => "System Configuration Options",

         "13" => "BIOS Language",

         "14" => "Group Associations",

         "15" => "System Event Log",

         "16" => "Physical Memory Array",

         "17" => "Memory Device",

         "18" => "32-bit Memory Error",

         "19" => "Memory Array Mapped Address",

         "20" => "Memory Device Mapped Address",

         "21" => "Built-in Pointing Device",

         "22" => "Portable Battery",

         "23" => "System Reset",

         "24" => "Hardware Security",

         "25" => "System Power Controls",

         "26" => "Voltage Probe",

         "27" => "Cooling Device",

         "28" => "Temperature Probe",

         "29" => "Electrical Current Probe",

         "30" => "Out-of-band Remote Access",

         "31" => "Boot Integrity Services",

         "32" => "System Boot",

         "33" => "64-bit Memory Error",

         "34" => "Management Device",

         "35" => "Management Device Component",

         "36" => "Management Device Threshold Data",

         "37" => "Memory Channel",

         "38" => "IPMI Device",

         "39" => "Power Supply",

         "40" => "Additional Information",

         "41" => "Onboard Devices Extended Information",

         "42" => "Management Controller Host Interface"

   );

      // verify this is something we can work with, First line should be the version of dmidecode found

      if ( preg_match('/dmidecode ([0-9.]+)/', $contents[0], $results) ) {

         $dmidecodeVersion = $results[1];

      } else {

         return "Not a valid dmidecode file";

      }

      // first, let's parse it into a hash

      $currentHandle = '';

      $currentType;

      $data = array();

      for ( $i = 0; $i < count($contents); $i++ ) {

         if ( preg_match('/^Handle ([0-9a-zx]+).*DMI type[^0-9]*(\d+),/i', $contents[$i], $outputArray) ) {

            //print "matched\n"; print_r($outputArray); die;

            $currentType = $outputArray[2];

            $currentHandle = $outputArray[1];

            if ( isset( $standardDMITypes[$currentType] ) || array_key_exists( $currentType,$standardDMITypes ) ) {

               $name = $contents[$i+1];

               $data[$currentType][$currentHandle]['name'] = $name;

               $i += 2; // skip the line with the name, and go to the next line

            } else {

               $currentType = $currentHandle = '';

            }

         }

         if ( $currentHandle &&  preg_match('/^\s+(.*):\s+(.*)$/i', $contents[$i], $outputArray) ) {

            $data[$currentType][$currentHandle][$outputArray[1]] = $outputArray[2];

         }

      }

      # well, we have at least one entry, so let's go

      $return = array();

      // manufacturer info

      $return = mergeArrays( $return, getDMIInformation( $data, '1','Manufacturer' ) );

      $return = mergeArrays( $return, getDMIInformation( $data, '1','Product Name', 'Model' ) );

      $return = mergeArrays( $return, getDMIInformation( $data, '1','Serial Number' ) );

      $return = mergeArrays( $return, getDMIInformation( $data, '1','UUID' ) );

      // physical machine

      $return = mergeArrays( $return, getDMIInformation( $data, '3','Type', 'Enclosure Type' ) );

      $return = mergeArrays( $return, getDMIInformation( $data, '3','Asset Tag', 'Enclosure Asset Tag' ) );

      $return = mergeArrays( $return, getDMIInformation( $data, '3','Height', 'Enclosure Height' ) );

      // firmware version

      $return = mergeArrays( $return, getDMIInformation( $data, '0','Vendor', 'Firmware Vendor' ) );

      $return = mergeArrays( $return, getDMIInformation( $data, '0','Release Date', 'Firmware Release' ) );

      $return = mergeArrays( $return, getDMIInformation( $data, '0','Version', 'Firmware Version' ) );

      $return = mergeArrays( $return, getDMIInformation( $data, '0','Firmware Revision', 'Firmware Revision' ) );

      // processor information. NOTE: assumes all sockets populated and all processors the saem

      if ( isset( $data['4'] ) ) // count the number of sockets

         $return[] = "CPU Count\t" . count( $data['4'] );

      $return = mergeArrays( $return, getDMIInformation( $data, '4','Family', 'CPU Family' ) );

      $return = mergeArrays( $return, getDMIInformation( $data, '4','Manufacturer', 'CPU Manufacturer' ) );

      $return = mergeArrays( $return, getDMIInformation( $data, '4','Version', 'CPU Version' ) );

      $return = mergeArrays( $return, getDMIInformation( $data, '4','Current Speed', 'CPU Speed' ) );

      $return = mergeArrays( $return, getDMIInformation( $data, '4','Core Count', 'CPU Cores (ea)' ) );

      $return = mergeArrays( $return, getDMIInformation( $data, '4','Thread Count', 'CPU Threads (ea)' ) );

      /*

       * memory information. We want details on each slot for this, so we have to go through each entry, one at a time.

       * For readability, we also want to take several values and turn them into one human

       * readable string for each socket. So, we go through each entry in the memory socket, determine if it is populated

       * then concat it together for a pretty output

       */

      if ( isset( $data['17'] ) ) {

         $return[] = "Memory Slots\t" . count( $data['17'] );

         $totalRAM = 0; // we'll accumulate the total size as we find slots populated

         foreach ( $data['17'] as $entry ) { // type 17 has one entry for every DIMM slot

            $mem = array(); // fill this up with the values we want to turn into a string, then we'll implode it into the string

            $mem[] = trim($entry['Locator'] ? $entry['Locator'] : ($entry['Bank Locator'] ? $entry['Bank Locator'] : '' ));

            if ( $entry['Size'] == 'No Module Installed' ) {

               $mem[] = 'Unpopulated';

            } else {

               $mem[] = trim($entry['Size']); // size can be kilo, meg, gig, tera, so convert it to mega

               if ( preg_match('/(\d+)\s+(GB|MB|TB|kb)/i', $entry['Size'] , $outputArray) ) {

                  switch ( strtolower( $outputArray[2] ) ) {

                     case 'gb' :

                              $outputArray[1] *= 1024;

                              break;

                     case 'tb' : 

                              $outputArray[1] *= 1024 * 1024;

                              break;

                     case 'kb' : 

                              $outputArray[1] /= 1024;

                              break;

                  }

                  $totalRAM += $outputArray[1];

               }

               $mem[] = trim($entry['Form Factor']);

               $mem[] = trim($entry['Type']);

               $mem[] = trim($entry['Data Width']);

               if ( isset( $entry['Configured Clock Speed']) && isset($entry['Speed']) && cleanUpDMIValue($entry['Configured Clock Speed']) && cleanUpDMIValue($entry['Speed']) )

                  $mem[] = cleanUpDMIValue($entry['Configured Clock Speed'] . '/' . cleanUpDMIValue($entry['Speed']) );

               if ( isset($entry['Manufacturer']) && cleanUpDMIValue($entry['Manufacturer']) )

                  $mem[] = cleanUpDMIValue($entry['Manufacturer']);

               if ( isset($entry['Part Number']) && cleanUpDMIValue( $entry['Part Number'] ) )

                  $mem[] = 'p/n ' . cleanUpDMIValue($entry['Part Number']);

               if ( isset($entry['Serial Number']) && trim($entry['Serial Number']) != 'Not Specified' )

                  $mem[] = 's/n ' . cleanUpDMIValue($entry['Serial Number']);

            }

            $return[] = "Memory\t" . implode( ', ', $mem );

         }

         $return[] = "Memory Total\t$totalRAM MB";

      }

      /*

       * power supplies. Most workstations will not even have an entry here, but for servers we will have details on each individual

       * power supply, including the part number, serial number, etc..., so like memory, we want a detailed listing with a human

       * readable string for each psu

       */

      if ( isset( $data['39'] ) ) {

         $return[] = "Power Supply Count\t" . count( $data['39'] );

         foreach ( $data['39'] as $entry ) {

            if ( preg_match('/^Present/i', $entry['Status'] ) ) {

               $psu = array();

               $psu[] = trim($entry['Name']);

               $psu[] = trim($entry['Max Power Capacity']);

               $psu[] = trim($entry['Manufacturer']);

               $psu[] = 'p/n ' . trim($entry['Model Part Number']);

               $psu[] = 's/n ' . trim($entry['Serial Number']);

               $return[] = "Power Supply\t" . implode( ', ', $psu );

            }

         }

      }

      return array( $return );

   }  // dmidecode2array

   /*

    * Test code for dmidecode input

    */

   /*

   $filename = $argv[1];

   if ( $filename ) {

      $contents = file( $filename, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES );

      $out = dmidecode2array( $contents );

      print_r( $out );

   } else {

      print "You must pass the file as the first command line parameter\n";

   }

   */

   /****************************************************************************************

    * Functions to process an array the device_attrib table

    ***************************************************************************************/

   /*

    * takes a tab delimited array of lines and turns it into an array of array

    * Assumes first line contains the headers

    * turns the file

    * header1\theader2\theader3

    * value1\tvalue2\tvalue3

    *

    * into

    * [0]

    *    header1=>value1

    *    header2=>value2

    *    header3=>value3

    *

    * $contents is an array of lines, with each line having multiple

    * fields delimited by $delimiter

    * 

    */

   function tabDelimToArray($contents, $delimiter = "\t" ) {

      $rows = array();

      if ( gettype($contents) != 'array' )

         $contents = explode( "\n", $contents );

      $headers = explode( $delimiter, array_shift( $contents ) );

      for  ( $line = 0; $line < count( $contents ); $line++ ) {

         if ( $contents[$line] ) {

            $thisLine = explode( $delimiter, $contents[$line] );

            $thisLine = preg_replace( '/^\s+/', '', $thisLine );

            $thisLine = preg_replace( '/\s+$/', '', $thisLine );

            $columns = array();

            for ( $i = 0; $i < count( $headers ); $i++ ) {

               $columns[$headers[$i]] = $thisLine[$i];

            } // for

            $rows[] = $columns;

         } // if

      } // while

      return $rows;

   } // function

   /*

    * getDeviceID

    */

   function getDeviceID( $device, $createIfNotFound = false, $site = '', $client = '', $site_id = 0, $client_id = 0 ) {

      $device = makeSafeSQLConstant( $device, 's', '' );

      if ( ! $device ) return 0;

      $device_id = getOneDBValue( "select device_id from device where name = $device" );

      if ( $device_id ) return $device_id;

      if ( $createIfNotFound ) {

         if ( ! $site_id ) {

            $site_id = findSite( $site, $client, $site_id, $client_id );

         }

         if ( $site_id ) {

            $site_id = makeSafeSQLConstant( $site_id,'i','' );

            $result = queryDatabaseExtended( "insert into device (site_id,device_type_id,name,added_date,removed_date) values( $site_id,1,$device,now(),null )" );

            if ( $result['insert_id'] )

               return $result[insert_id];

         }

      }

      return 0;

   } // getDeviceID

   function getAttributeID( $attribute, $createIfNotFound = false ) {

      $attribute = makeSafeSQLConstant( $attribute, 's', '' );

      if ( ! $attribute ) return 0;

      $return = getOneDBValue( "select attrib_id from attrib where name = $attribute" );

      if ( ! $return && $createIfNotFound ) {

         $return = queryDatabaseExtended( "insert into attrib( name, added_date, removed_date ) values ( $attribute, now(), null )" );

         return $result['insert_id'] ? $result['insert_id'] : 0;

      }

      return $return;

   }

   /*

    * returns true if the value is empty or null

    */

   function nullOrEmpty( $str ) {

      return ( !isset( $str) || trim($str) === '');

   }

   /*

    * Takes a two dimensional array and adds/updates the values in device_attrib

    * 

    * $contents is an array of array, where they keys for each sub-array is the field name of the table to insert/update

    * $unique if true will replace any existing key for the device in question

    * $createDeviceIfNotFound, if true, will create any device name found if it doesn't exist

    * $device_id is used for the insert/update unless $device_id is a key in any row in the array

    * $site_id is used to A) uniquely identify a device or B) create the device if $createDeviceIfNotFound is true and device not foudn

    * $client_id is used the same way as $site_id

    *

    * $contents is assumed to be

    * [0] => {

    *           [value]     => string to be set/added to device_attrib table

    *           [attrib_id] => key from attrib table

    *           [attribute] => string matching name from attrib table

    *           [device_id] => key from device table

    *           [device]    => string matching name from device table

    *           [site_id]   => key from site table

    *           [site]      => string matching name from site table

    *           [client_id] => key from client table

    *           [client]    => string matching name from client table

    *         }

    * [1] =>  { another set of values the same as above }

    *

    * The only required values are attrib_id (or attribute) and value. If this is the case, it will be added to the device from

    * parameter $device_id

    *

    * If [something_id] is found, that is used. If it is null (or doesn't exist), an attempt is made to determine the proper

    * id from the database by looking for the string. If that is null, the parameter passed to this function is used. If all of

    * that fails, the row is returned to the caller.

    *

    */

   function parseTabDelimFile ( $contents, $createAttributeIfNotFound = false, $createDeviceIfNotFound = false, $default_device_id='', $default_site_id='', $default_client_id='' ) {

      $data = tabDelimToArray( $contents );

      // we'll put our SQL into an array, then dump it.

      $sql = array();

      // the following two arrays will store attributes and devices as we find them

      // we can then FIRST look them up here, in memory, and go to database only when we don't know them

      $attributesFromDatabase = array(); // uniquely store our attributes here

      $deviceFromDatabase = array();

      for ( $i = 0; $i < count( $data ); $i++ ) {  // go through each line and grab fields we need

         // get device_id

         if ( ! $data[$i]['device_id'] ) {

            if ( $data[$i]['device'] ) {

               if ( isset( $deviceFromDatabase[$data[$i]['device']] ) ) {

                  $data[$i]['device_id'] = $deviceFromDatabase[$data[$i]['device']];

               } else {

                  $data[$i]['device_id'] = getDeviceID( $data[$i]['device'], $createDeviceIfNotFound, $default_site_id, $default_client_id );

               }

               if ( $data[$i]['device_id'] )

                  $deviceFromDatabase[$data[$i]['device']] = $data[$i]['device_id'];

            }

            if ( ! $data[$i]['device_id'] ) {

               if ( $default_device_id ) {

                  $data[$i]['device_id'] = $default_device_id;

               } else {

                  $sql[] = "/* Can not locate device in line $i */";

                  continue;

               }

            }

         }

         // get attribute_id

         if ( ! $data[$i]['attrib_id'] ) {

            if ( $data[$i]['attribute'] ) {

               if ( isset( $attributesFromDatabase[$data[$i]['attribute']] ) ) {

                  $data[$i]['attrib_id'] = $attributesFromDatabase[$data[$i]['attribute']];

               } else {

                  $data[$i]['attrib_id'] = getAttributeID( $data[$i]['attribute'], $createAttributeIfNotFound );

               }

               if ( $data[$i]['attrib_id'] )

                  $attributesFromDatabase[$data[$i]['attribute']] = $data[$i]['attrib_id'];

            }

            if ( ! $data[$i]['attrib_id'] ) {

               $sql[] = "/* Can not locate attribute in line $i */";

               continue;

            }

         }

         if ( ! $data[$i]['value'] ) {

            $sql[] = "/* No Value given for line $i, skipped */";

            continue;

         }

         $value = makeSafeSQLConstant( $data[$i]['value'] );

         $attrib_id = makeSafeSQLConstant( $data[$i]['attrib_id'], 'i' );

         $device_id = makeSafeSQLConstant( $data[$i]['device_id'],'i' );

         // standard SQL that does an insert if the value doesn't already exist.

         $sql[] =

            "insert into attrib_device ( device_id, attrib_id,value, added_date )

               select $device_id,$attrib_id, $value, now()

               from dual

               where

                  not exists (

                     select * from attrib_device join device using (device_id) join attrib using (attrib_id) where device_id = $device_id and attrib_id = $attrib_id

                     );";

      }

      return $sql;

   }

   /*

    * following block of code is duplicated from the files module. It should instead be placed in root/include/library.php or something

    */

   /*

    * function designed to handle input from a form. If the input is

    * unset, will retrun the $default value.

    * Otherwise, will filter the value based on $filter

    * Some common filters are:

    *    FILTER_SANITIZE_SPECIAL_CHARS - clean up text so no HTML

    *    FILTER_SANITIZE_EMAIL         - email addresses

    *    FILTER_SANITIZE_NUMBER_FLOAT  - floating point numbers

    *    FILTER_SANITIZE_NUMBER_INT    - integers

    *    FILTER_SANITIZE_URL           - A URL

    * http://php.net/manual/en/filter.filters.sanitize.php

    */

   function cleanInput ( $value, $default = '', $filter = FILTER_DEFAULT ) {

      // unset or empty values just get the default

      if ( ! isset( $value ) || strlen( trim( $value ) ) == 0 ) return $default;

      return filter_var( trim( $value ), $filter );

   }

   function return_bytes($val) {

       $val = trim($val);

       $last = strtolower($val[strlen($val)-1]);

       switch($last) 

       {

           case 'g':

           $val *= 1024;

           case 'm':

           $val *= 1024;

           case 'k':

           $val *= 1024;

       }

       return $val;

   } // return_bytes

   function prettyPrintBytes( $value ) {

      $sizes = array( '', 'kilo', 'mega', 'giga', 'tera' );

      while ( $value > 1024 ) {

         $value /= 1024;

         $index++;

      }

      return intval( $value ) . ' ' . $sizes[$index] . 'bytes';

   }

   function maxUploadFileSize () {

       //select maximum upload size

       $max_upload = return_bytes(ini_get('upload_max_filesize'));

       //select post limit

       $max_post = return_bytes(ini_get('post_max_size'));

       //select memory limit

       $memory_limit = return_bytes(ini_get('memory_limit'));

       // return the smallest of them, this defines the real limit

       return prettyPrintBytes( min($max_upload, $max_post, $memory_limit) );

    } // maxUploadFileSize

    function getFileUploadError( $error ) {

       $message = '';

       switch ( $error ) {

          case 0 : $message = 'There is no error, the file uploaded with success';

                   break;

          case 1 : $message = 'The uploaded file exceeds the upload_max_filesize directive in php.ini';

                   break;

          case 2 : $message = 'The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form';

                   break;

          case 3 : $message = 'The uploaded file was only partially uploaded';

                   break;

          case 4 : $message = 'No file was uploaded';

                   break;

          case 6 : $message = 'Missing a temporary folder';

                   break;

          case 7 : $message = 'Failed to write file to disk.';

                   break;

          case 8 : $message = 'A PHP extension stopped the file upload.';

       }

       return array( 'valid' => $error == 0, 'message' => $message );

    } // getFileUploadError

   function uploadFile ( $source, $nameOnDisk ) {

      $saveTo = getAbsolutePath( $nameOnDisk );

      if ( makePath( $saveTo ) ) {

         logIt( "Path Made - $saveTo" );

         logIt( "moving $source to $saveTo" );

         $result['valid'] = move_uploaded_file( $source, $saveTo );

      } else {

         $result = array( 'valid'=>false, 'message' => print_r(error_get_last(), true) );

      } // if move_uploaded_file .. else

      return $result;

   } // uploadFile

?>

?>