check_openmanage

   1 #!/usr/bin/perl
   2 #
   3 # Nagios plugin
   4 #
   5 # Monitor Dell server hardware status using Dell OpenManage Server
   6 # Administrator, either locally via NRPE, or remotely via SNMP.
   7 #
   8 # $Id$
   9 #
  10 # Copyright (C) 2008-2011 Trond H. Amundsen
  11 #
  12 # This program is free software: you can redistribute it and/or modify
  13 # it under the terms of the GNU General Public License as published by
  14 # the Free Software Foundation, either version 3 of the License, or
  15 # (at your option) any later version.
  16 #
  17 # This program is distributed in the hope that it will be useful, but
  18 # WITHOUT ANY WARRANTY; without even the implied warranty of
  19 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20 # General Public License for more details.
  21 #
  22 # You should have received a copy of the GNU General Public License
  23 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24 #
  25
  26 require 5.006;  # Perl v5.6.0 or newer is required
  27 use strict;
  28 use warnings;
  29 use POSIX qw(isatty ceil);
  30 use Getopt::Long qw(:config no_ignore_case);
  31
  32 # Global (package) variables used throughout the code
  33 use vars qw( $NAME $VERSION $AUTHOR $CONTACT $E_OK $E_WARNING $E_CRITICAL
  34              $E_UNKNOWN $FW_LOCK $USAGE $HELP $LICENSE
  35              $snmp_session $snmp_error $omreport $globalstatus $global
  36              $linebreak $omopt_chassis $omopt_system $blade
  37              $exit_code $snmp
  38              %check %opt %reverse_exitcode %status2nagios
  39              %snmp_status %snmp_probestatus %probestatus2nagios %sysinfo
  40              %blacklist %nagios_alert_count %count %snmp_enclosure %snmp_controller
  41              @perl_warnings @controllers @enclosures @perfdata
  42              @report_storage @report_chassis @report_other
  43           );
  44
  45 #---------------------------------------------------------------------
  46 # Initialization and global variables
  47 #---------------------------------------------------------------------
  48
  49 # Collect perl warnings in an array
  50 $SIG{__WARN__} = sub { push @perl_warnings, [@_]; };
  51
  52 # Version and similar info
  53 $NAME    = 'check_openmanage';
  54 $VERSION = '3.7.0-alpha';
  55 $AUTHOR  = 'Trond H. Amundsen';
  56 $CONTACT = 't.h.amundsen@usit.uio.no';
  57
  58 # Exit codes
  59 $E_OK       = 0;
  60 $E_WARNING  = 1;
  61 $E_CRITICAL = 2;
  62 $E_UNKNOWN  = 3;
  63
  64 # Firmware update lock file [FIXME: location on Windows?]
  65 $FW_LOCK = '/var/lock/.spsetup';  # default on Linux
  66
  67 # Usage text
  68 $USAGE = <<"END_USAGE";
  69 Usage: $NAME [OPTION]...
  70 END_USAGE
  71
  72 # Help text
  73 $HELP = <<'END_HELP';
  74
  75 GENERAL OPTIONS:
  76
  77    -p, --perfdata       Output performance data [default=no]
  78    -t, --timeout        Plugin timeout in seconds [default=30]
  79    -c, --critical       Custom temperature critical limits
  80    -w, --warning        Custom temperature warning limits
  81    -d, --debug          Debug output, reports everything
  82    -h, --help           Display this help text
  83    -V, --version        Display version info
  84
  85 SNMP OPTIONS:
  86
  87    -H, --hostname       Hostname or IP (required for SNMP)
  88    -C, --community      SNMP community string [default=public]
  89    -P, --protocol       SNMP protocol version [default=2]
  90    --port               SNMP port number [default=161]
  91    -6, --ipv6           Use IPv6 instead of IPv4 [default=no]
  92    --tcp                Use TCP instead of UDP [default=no]
  93
  94 OUTPUT OPTIONS:
  95
  96    -i, --info           Prefix any alerts with the service tag
  97    -e, --extinfo        Append system info to alerts
  98    -s, --state          Prefix alerts with alert state
  99    -S, --short-state    Prefix alerts with alert state abbreviated
 100    -o, --okinfo         Verbosity when check result is OK
 101    -B, --show-blacklist Show blacklistings in OK output
 102    -I, --htmlinfo       HTML output with clickable links
 103
 104 CHECK CONTROL AND BLACKLISTING:
 105
 106    -a, --all            Check everything, even log content
 107    -b, --blacklist      Blacklist missing and/or failed components
 108    --only               Only check a certain component or alert type
 109    --check              Fine-tune which components are checked
 110    --no-storage         Don't check storage
 111
 112 For more information and advanced options, see the manual page or URL:
 113   http://folk.uio.no/trondham/software/check_openmanage.html
 114 END_HELP
 115
 116 # Version and license text
 117 $LICENSE = <<"END_LICENSE";
 118 $NAME $VERSION
 119 Copyright (C) 2008-2011 $AUTHOR
 120 License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
 121 This is free software: you are free to change and redistribute it.
 122 There is NO WARRANTY, to the extent permitted by law.
 123
 124 Written by $AUTHOR <$CONTACT>
 125 END_LICENSE
 126
 127 # Options with default values
 128 %opt = ( 'blacklist'         => [],       # blacklisting
 129          'check'             => [],       # check control
 130          'critical'          => [],       # temperature critical limits
 131          'warning'           => [],       # temperature warning limits
 132          'timeout'           => 30,       # default timeout is 30 seconds
 133          'debug'             => 0,        # debugging / verbose output
 134          'help'              => 0,        # display help output
 135          'perfdata'          => undef,    # output performance data
 136          'info'              => 0,        # display servicetag
 137          'extinfo'           => 0,        # display extra info
 138          'htmlinfo'          => undef,    # html tags in output
 139          'postmsg'           => undef,    # post message
 140          'state'             => 0,        # display alert type
 141          'short-state'       => 0,        # display alert type (short)
 142          'okinfo'            => 0,        # default "ok" output level
 143          'show_blacklist'    => 0,        # show blacklisted components
 144          'linebreak'         => undef,    # specify linebreak
 145          'version'           => 0,        # plugin version info
 146          'all'               => 0,        # check everything
 147          'only'              => undef,    # only one component
 148          'no_storage'        => 0,        # don't check storage
 149          'omreport'          => undef,    # omreport path
 150          'port'              => 161,      # default SNMP port
 151          'hostname'          => undef,    # hostname or IP
 152          'community'         => 'public', # SMNP v1 or v2c
 153          'protocol'          => 2,        # default SNMP protocol 2c
 154          'ipv6'              => 0,        # default is IPv4
 155          'tcp'               => 0,        # default is UDP
 156          'username'          => undef,    # SMNP v3
 157          'authpassword'      => undef,    # SMNP v3
 158          'authkey'           => undef,    # SMNP v3
 159          'authprotocol'      => undef,    # SMNP v3
 160          'privpassword'      => undef,    # SMNP v3
 161          'privkey'           => undef,    # SMNP v3
 162          'privprotocol'      => undef,    # SMNP v3
 163          'use_get_table'     => 0,        # hack for SNMPv3 on Windows with net-snmp
 164        );
 165
 166 # Get options
 167 GetOptions('b|blacklist=s'      => \@{ $opt{blacklist} },
 168            'check=s'            => \@{ $opt{check} },
 169            'c|critical=s'       => \@{ $opt{critical} },
 170            'w|warning=s'        => \@{ $opt{warning} },
 171            't|timeout=i'        => \$opt{timeout},
 172            'd|debug'            => \$opt{debug},
 173            'h|help'             => \$opt{help},
 174            'V|version'          => \$opt{version},
 175            'p|perfdata:s'       => \$opt{perfdata},
 176            'i|info'             => \$opt{info},
 177            'e|extinfo'          => \$opt{extinfo},
 178            'I|htmlinfo:s'       => \$opt{htmlinfo},
 179            'postmsg=s'          => \$opt{postmsg},
 180            's|state'            => \$opt{state},
 181            'S|short-state'      => \$opt{shortstate},
 182            'o|ok-info=i'        => \$opt{okinfo},
 183            'B|show-blacklist'   => \$opt{show_blacklist},
 184            'linebreak=s'        => \$opt{linebreak},
 185            'a|all'              => \$opt{all},
 186            'only=s'             => \$opt{only},
 187            'no-storage'         => \$opt{no_storage},
 188            'omreport=s'         => \$opt{omreport},
 189            'port=i'             => \$opt{port},
 190            'H|hostname=s'       => \$opt{hostname},
 191            'C|community=s'      => \$opt{community},
 192            'P|protocol=i'       => \$opt{protocol},
 193            '6|ipv6'             => \$opt{ipv6},
 194            'tcp'                => \$opt{tcp},
 195            'U|username=s'       => \$opt{username},
 196            'authpassword=s'     => \$opt{authpassword},
 197            'authkey=s'          => \$opt{authkey},
 198            'authprotocol=s'     => \$opt{authprotocol},
 199            'privpassword=s'     => \$opt{privpassword},
 200            'privkey=s'          => \$opt{privkey},
 201            'privprotocol=s'     => \$opt{privprotocol},
 202            'use-get_table'      => \$opt{use_get_table},
 203           ) or do { print $USAGE; exit $E_UNKNOWN };
 204
 205 # If user requested help
 206 if ($opt{help}) {
 207     print $USAGE, $HELP;
 208     exit $E_OK;
 209 }
 210
 211 # If user requested version info
 212 if ($opt{version}) {
 213     print $LICENSE;
 214     exit $E_OK;
 215 }
 216
 217 # Setting timeout
 218 $SIG{ALRM} = sub {
 219     print "PLUGIN TIMEOUT: $NAME timed out after $opt{timeout} seconds\n";
 220     exit $E_UNKNOWN;
 221 };
 222 alarm $opt{timeout};
 223
 224 # If we're using SNMP
 225 $snmp = defined $opt{hostname} ? 1 : 0;
 226
 227 # SNMP session variables
 228 $snmp_session = undef;
 229 $snmp_error   = undef;
 230
 231 # The omreport command
 232 $omreport = undef;
 233
 234 # Check flags, override available with the --check option
 235 %check = ( 'storage'     => 1,   # check storage subsystem
 236            'memory'      => 1,   # check memory (dimms)
 237            'fans'        => 1,   # check fan status
 238            'power'       => 1,   # check power supplies
 239            'temp'        => 1,   # check temperature
 240            'cpu'         => 1,   # check processors
 241            'voltage'     => 1,   # check voltage
 242            'batteries'   => 1,   # check battery probes
 243            'amperage'    => 1,   # check power consumption
 244            'intrusion'   => 1,   # check intrusion detection
 245            'sdcard'      => 1,   # check removable flash media (SD cards)
 246            'alertlog'    => 0,   # check the alert log
 247            'esmlog'      => 0,   # check the ESM log (hardware log)
 248            'esmhealth'   => 1,   # check the ESM log overall health
 249          );
 250
 251 # Default line break
 252 $linebreak = isatty(*STDOUT) ? "\n" : '<br/>';
 253
 254 # Line break from option
 255 if (defined $opt{linebreak}) {
 256     if ($opt{linebreak} eq 'REG') {
 257         $linebreak = "\n";
 258     }
 259     elsif ($opt{linebreak} eq 'HTML') {
 260         $linebreak = '<br/>';
 261     }
 262     else {
 263         $linebreak = $opt{linebreak};
 264     }
 265 }
 266
 267 # Exit with status=UNKNOWN if there is firmware upgrade in progress
 268 if (!$snmp && -f $FW_LOCK) {
 269     print "MONITORING DISABLED - Firmware update in progress ($FW_LOCK exists)\n";
 270     exit $E_UNKNOWN;
 271 }
 272
 273 # List of controllers and enclosures
 274 @controllers = ();  # controllers
 275 @enclosures  = ();  # enclosures
 276 %snmp_enclosure   = ();  # enclosures
 277
 278 # Messages
 279 @report_storage = ();  # messages with associated nagios level (storage)
 280 @report_chassis = ();  # messages with associated nagios level (chassis)
 281 @report_other   = ();  # messages with associated nagios level (other)
 282
 283 # Counters for everything
 284 %count
 285   = (
 286      'pdisk'  => 0, # number of physical disks
 287      'vdisk'  => 0, # number of logical drives (virtual disks)
 288      'temp'   => 0, # number of temperature probes
 289      'volt'   => 0, # number of voltage probes
 290      'amp'    => 0, # number of amperage probes
 291      'intr'   => 0, # number of intrusion probes
 292      'dimm'   => 0, # number of memory modules
 293      'mem'    => 0, # total memory
 294      'fan'    => 0, # number of fan probes
 295      'cpu'    => 0, # number of CPUs
 296      'bat'    => 0, # number of batteries
 297      'power'  => 0, # number of power supplies
 298      'sd'     => 0, # number of SD cards
 299      'esm'    => {
 300                   'Critical'     => 0, # critical entries in ESM log
 301                   'Non-Critical' => 0, # warning entries in ESM log
 302                   'Ok'           => 0, # ok entries in ESM log
 303                  },
 304      'alert'  => {
 305                   'Critical'     => 0, # critical entries in alert log
 306                   'Non-Critical' => 0, # warning entries in alert log
 307                   'Ok'           => 0, # ok entries in alert log
 308                  },
 309     );
 310
 311 # Performance data
 312 @perfdata = ();
 313
 314 # Global health status
 315 $global         = 1;      # default is to check global status
 316 $globalstatus   = $E_OK;  # default global health status is "OK"
 317
 318 # Nagios error levels reversed
 319 %reverse_exitcode
 320   = (
 321      $E_OK       => 'OK',
 322      $E_WARNING  => 'WARNING',
 323      $E_CRITICAL => 'CRITICAL',
 324      $E_UNKNOWN  => 'UNKNOWN',
 325     );
 326
 327 # OpenManage (omreport) and SNMP error levels
 328 %status2nagios
 329   = (
 330      'Unknown'         => $E_CRITICAL,
 331      'Critical'        => $E_CRITICAL,
 332      'Non-Critical'    => $E_WARNING,
 333      'Ok'              => $E_OK,
 334      'Non-Recoverable' => $E_CRITICAL,
 335      'Other'           => $E_CRITICAL,
 336     );
 337
 338 # Status via SNMP
 339 %snmp_status
 340   = (
 341      1 => 'Other',
 342      2 => 'Unknown',
 343      3 => 'Ok',
 344      4 => 'Non-Critical',
 345      5 => 'Critical',
 346      6 => 'Non-Recoverable',
 347     );
 348
 349 # Probe Status via SNMP
 350 %snmp_probestatus
 351   = (
 352      1  => 'Other',               # probe status is not one of the following:
 353      2  => 'Unknown',             # probe status is unknown (not known or monitored)
 354      3  => 'Ok',                  # probe is reporting a value within the thresholds
 355      4  => 'nonCriticalUpper',    # probe has crossed upper noncritical threshold
 356      5  => 'criticalUpper',       # probe has crossed upper critical threshold
 357      6  => 'nonRecoverableUpper', # probe has crossed upper non-recoverable threshold
 358      7  => 'nonCriticalLower',    # probe has crossed lower noncritical threshold
 359      8  => 'criticalLower',       # probe has crossed lower critical threshold
 360      9  => 'nonRecoverableLower', # probe has crossed lower non-recoverable threshold
 361      10 => 'failed',              # probe is not functional
 362     );
 363
 364 # Probe status translated to Nagios alarm levels
 365 %probestatus2nagios
 366   = (
 367      'Other'               => $E_CRITICAL,
 368      'Unknown'             => $E_CRITICAL,
 369      'Ok'                  => $E_OK,
 370      'nonCriticalUpper'    => $E_WARNING,
 371      'criticalUpper'       => $E_CRITICAL,
 372      'nonRecoverableUpper' => $E_CRITICAL,
 373      'nonCriticalLower'    => $E_WARNING,
 374      'criticalLower'       => $E_CRITICAL,
 375      'nonRecoverableLower' => $E_CRITICAL,
 376      'failed'              => $E_CRITICAL,
 377     );
 378
 379 # System information gathered
 380 %sysinfo
 381   = (
 382      'bios'     => 'N/A',  # BIOS version
 383      'biosdate' => 'N/A',  # BIOS release date
 384      'serial'   => 'N/A',  # serial number (service tag)
 385      'model'    => 'N/A',  # system model
 386      'rev'      => q{},    # system revision
 387      'osname'   => 'N/A',  # OS name
 388      'osver'    => 'N/A',  # OS version
 389      'om'       => 'N/A',  # OMSA version
 390      'bmc'      => 0,      # HAS baseboard management controller (BMC)
 391      'rac'      => 0,      # HAS remote access controller (RAC)
 392      'rac_name' => 'N/A',  # remote access controller (RAC)
 393      'bmc_fw'   => 'N/A',  # BMC firmware
 394      'rac_fw'   => 'N/A',  # RAC firmware
 395     );
 396
 397 # Adjust which checks to perform
 398 adjust_checks() if defined $opt{check};
 399
 400 # Blacklisted components
 401 %blacklist = defined $opt{blacklist} ? %{ get_blacklist() } : ();
 402
 403 # If blacklisting is in effect, don't check global health status
 404 if (scalar keys %blacklist > 0) {
 405     $global = 0;
 406 }
 407
 408 # Take into account new hardware and blades
 409 $omopt_chassis = 'chassis';  # default "chassis" option to omreport
 410 $omopt_system  = 'system';   # default "system" option to omreport
 411 $blade         = 0;          # if this is a blade system
 412
 413 # Some initializations and checking before we begin
 414 if ($snmp) {
 415     snmp_initialize();    # initialize SNMP
 416     snmp_check();         # check that SNMP works
 417     snmp_detect_blade();  # detect blade via SNMP
 418 }
 419 else {
 420     # Find the omreport binary
 421     find_omreport();
 422     # Check help output from omreport, see which options are available.
 423     # Also detecting blade via omreport.
 424     check_omreport_options();
 425 }
 426
 427
 428 #---------------------------------------------------------------------
 429 # Helper functions
 430 #---------------------------------------------------------------------
 431
 432 #
 433 # Store a message in one of the message arrays
 434 #
 435 sub report {
 436     my ($type, $msg, $exval, $id) = @_;
 437     defined $id or $id = q{};
 438
 439     my %type2array
 440       = (
 441          'storage' => \@report_storage,
 442          'chassis' => \@report_chassis,
 443          'other'   => \@report_other,
 444         );
 445
 446     return push @{ $type2array{$type} }, [ $msg, $exval, $id ];
 447 }
 448
 449
 450 #
 451 # Run command, put resulting output lines in an array and return a
 452 # pointer to that array
 453 #
 454 sub run_command {
 455     my $command = shift;
 456
 457     open my $CMD, '-|', $command
 458       or do { report('other', "Couldn't run command '$command': $!", $E_UNKNOWN)
 459                 and return [] };
 460     my @lines = <$CMD>;
 461     close $CMD
 462       or do { report('other', "Couldn't close filehandle for command '$command': $!", $E_UNKNOWN)
 463                 and return \@lines };
 464     return \@lines;
 465 }
 466
 467 #
 468 # Run command, put resulting output in a string variable and return it
 469 #
 470 sub slurp_command {
 471     my $command = shift;
 472
 473     open my $CMD, '-|', $command
 474       or do { report('other', "Couldn't run command '$command': $!", $E_UNKNOWN) and return };
 475     my $rawtext = do { local $/ = undef; <$CMD> }; # slurping
 476     close $CMD;
 477
 478     # NOTE: We don't check the return value of close() since omreport
 479     # does something weird sometimes.
 480
 481     return $rawtext;
 482 }
 483
 484 #
 485 # Initialize SNMP
 486 #
 487 sub snmp_initialize {
 488     # Legal SNMP v3 protocols
 489     my $snmp_v3_privprotocol = qr{\A des|aes|aes128|3des|3desde \z}xms;
 490     my $snmp_v3_authprotocol = qr{\A md5|sha \z}xms;
 491
 492     # Parameters to Net::SNMP->session()
 493     my %param
 494       = (
 495          '-port'     => $opt{port},
 496          '-hostname' => $opt{hostname},
 497          '-version'  => $opt{protocol},
 498         );
 499
 500     # Setting the domain (IP version and transport protocol)
 501     my $transport = $opt{tcp} ? 'tcp' : 'udp';
 502     my $ipversion = $opt{ipv6} ? 'ipv6' : 'ipv4';
 503     $param{'-domain'} = "$transport/$ipversion";
 504
 505     # Parameters for SNMP v3
 506     if ($opt{protocol} == 3) {
 507
 508         # Username is mandatory
 509         if (defined $opt{username}) {
 510             $param{'-username'} = $opt{username};
 511         }
 512         else {
 513             print "SNMP ERROR: With SNMPv3 the username must be specified\n";
 514             exit $E_UNKNOWN;
 515         }
 516
 517         # Authpassword is optional
 518         if (defined $opt{authpassword}) {
 519             $param{'-authpassword'} = $opt{authpassword};
 520         }
 521
 522         # Authkey is optional
 523         if (defined $opt{authkey}) {
 524             $param{'-authkey'} = $opt{authkey};
 525         }
 526
 527         # Privpassword is optional
 528         if (defined $opt{privpassword}) {
 529             $param{'-privpassword'} = $opt{privpassword};
 530         }
 531
 532         # Privkey is optional
 533         if (defined $opt{privkey}) {
 534             $param{'-privkey'} = $opt{privkey};
 535         }
 536
 537         # Privprotocol is optional
 538         if (defined $opt{privprotocol}) {
 539             if ($opt{privprotocol} =~ m/$snmp_v3_privprotocol/xms) {
 540                 $param{'-privprotocol'} = $opt{privprotocol};
 541             }
 542             else {
 543                 print "SNMP ERROR: Unknown privprotocol '$opt{privprotocol}', "
 544                   . "must be one of [des|aes|aes128|3des|3desde]\n";
 545                 exit $E_UNKNOWN;
 546             }
 547         }
 548
 549         # Authprotocol is optional
 550         if (defined $opt{authprotocol}) {
 551             if ($opt{authprotocol} =~ m/$snmp_v3_authprotocol/xms) {
 552                 $param{'-authprotocol'} = $opt{authprotocol};
 553             }
 554             else {
 555                 print "SNMP ERROR: Unknown authprotocol '$opt{authprotocol}', "
 556                   . "must be one of [md5|sha]\n";
 557                 exit $E_UNKNOWN;
 558             }
 559         }
 560     }
 561     # Parameters for SNMP v2c or v1
 562     elsif ($opt{protocol} == 2 or $opt{protocol} == 1) {
 563         $param{'-community'} = $opt{community};
 564     }
 565     else {
 566         print "SNMP ERROR: Unknown SNMP version '$opt{protocol}'\n";
 567         exit $E_UNKNOWN;
 568     }
 569
 570     # Try to initialize the SNMP session
 571     if ( eval { require Net::SNMP; 1 } ) {
 572         ($snmp_session, $snmp_error) = Net::SNMP->session( %param );
 573         if (!defined $snmp_session) {
 574             printf "SNMP: %s\n", $snmp_error;
 575             exit $E_UNKNOWN;
 576         }
 577     }
 578     else {
 579         print "ERROR: You need perl module Net::SNMP to run $NAME in SNMP mode\n";
 580         exit $E_UNKNOWN;
 581     }
 582     return;
 583 }
 584
 585 #
 586 # Checking if SNMP works by probing for "chassisModelName", which all
 587 # servers should have
 588 #
 589 sub snmp_check {
 590     my $chassisModelName = '1.3.6.1.4.1.674.10892.1.300.10.1.9.1';
 591     my $result = $snmp_session->get_request(-varbindlist => [$chassisModelName]);
 592
 593     # Typically if remote host isn't responding
 594     if (!defined $result) {
 595         printf "SNMP CRITICAL: %s\n", $snmp_session->error;
 596         exit $E_CRITICAL;
 597     }
 598
 599     # If OpenManage isn't installed or is not working
 600     if ($result->{$chassisModelName} =~ m{\A noSuch (Instance|Object) \z}xms) {
 601         print "ERROR: (SNMP) OpenManage is not installed or is not working correctly\n";
 602         exit $E_UNKNOWN;
 603     }
 604     return;
 605 }
 606
 607 #
 608 # Detecting blade via SNMP
 609 #
 610 sub snmp_detect_blade {
 611     my $DellBaseBoardType = '1.3.6.1.4.1.674.10892.1.300.80.1.7.1.1';
 612     my $result = $snmp_session->get_request(-varbindlist => [$DellBaseBoardType]);
 613
 614     # Identify blade. Older models (4th and 5th gen models) and/or old
 615     # OMSA (4.x) don't have this OID. If we get "noSuchInstance" or
 616     # similar, we assume that this isn't a blade
 617     if (exists $result->{$DellBaseBoardType} && $result->{$DellBaseBoardType} eq '3') {
 618         $blade = 1;
 619     }
 620     return;
 621 }
 622
 623 #
 624 # Locate the omreport binary
 625 #
 626 sub find_omreport {
 627     # If user has specified path to omreport
 628     if (defined $opt{omreport} and -x $opt{omreport}) {
 629         $omreport = qq{"$opt{omreport}"};
 630         return;
 631     }
 632
 633     # Possible full paths for omreport
 634     my @omreport_paths
 635       = (
 636          '/opt/dell/srvadmin/bin/omreport',              # default on Linux with OMSA >= 6.2.0
 637          '/usr/bin/omreport',                            # default on Linux with OMSA < 6.2.0
 638          '/opt/dell/srvadmin/oma/bin/omreport.sh',       # alternate on Linux
 639          '/opt/dell/srvadmin/oma/bin/omreport',          # alternate on Linux
 640          'C:\Program Files (x86)\Dell\SysMgt\oma\bin\omreport.exe', # default on Windows x64
 641          'C:\Program Files\Dell\SysMgt\oma\bin\omreport.exe',       # default on Windows x32
 642          'c:\progra~1\dell\sysmgt\oma\bin\omreport.exe', # 8bit legacy default on Windows x32
 643          'c:\progra~2\dell\sysmgt\oma\bin\omreport.exe', # 8bit legacy default on Windows x64
 644         );
 645
 646     # Find the one to use
 647   OMREPORT_PATH:
 648     foreach my $bin (@omreport_paths) {
 649         if (-x $bin) {
 650             $omreport = qq{"$bin"};
 651             last OMREPORT_PATH;
 652         }
 653     }
 654
 655     # Exit with status=UNKNOWN if OM is not installed, or we don't
 656     # have permission to execute the binary
 657     if (!defined $omreport) {
 658         print "ERROR: Dell OpenManage Server Administrator (OMSA) is not installed\n";
 659         exit $E_UNKNOWN;
 660     }
 661     return;
 662 }
 663
 664 #
 665 # Checks output from 'omreport -?' and searches for arguments to
 666 # omreport, to accommodate deprecated options "chassis" and "system"
 667 # (on newer hardware), as well as blade servers.
 668 #
 669 sub check_omreport_options {
 670     foreach (@{ run_command("$omreport -? 2>&1") }) {
 671        if (m/\A servermodule /xms) {
 672            # If "servermodule" argument to omreport exists, use it
 673            # instead of argument "system"
 674            $omopt_system = 'servermodule';
 675        }
 676        elsif (m/\A mainsystem /xms) {
 677            # If "mainsystem" argument to omreport exists, use it
 678            # instead of argument "chassis"
 679            $omopt_chassis = 'mainsystem';
 680        }
 681        elsif (m/\A modularenclosure /xms) {
 682            # If "modularenclusure" argument to omreport exists, assume
 683            # that this is a blade
 684            $blade = 1;
 685        }
 686     }
 687     return;
 688 }
 689
 690 #
 691 # Read the blacklist option and return a hash containing the
 692 # blacklisted components
 693 #
 694 sub get_blacklist {
 695     my @bl = ();
 696     my %blacklist = ();
 697
 698     if (scalar @{ $opt{blacklist} } >= 0) {
 699         foreach my $black (@{ $opt{blacklist} }) {
 700             my $tmp = q{};
 701             if (-f $black) {
 702                 open my $BL, '<', $black
 703                   or do { report('other', "Couldn't open blacklist file $black: $!", $E_UNKNOWN)
 704                             and return {} };
 705                 chomp($tmp = <$BL>);
 706                 close $BL;
 707             }
 708             else {
 709                 $tmp = $black;
 710             }
 711             push @bl, $tmp;
 712         }
 713     }
 714
 715     return {} if $#bl < 0;
 716
 717     # Parse blacklist string, put in hash
 718     foreach my $black (@bl) {
 719         my @comps = split m{/}xms, $black;
 720         foreach my $c (@comps) {
 721             next if $c !~ m/=/xms;
 722             my ($key, $val) = split /=/xms, $c;
 723             my @vals = split /,/xms, $val;
 724             $blacklist{$key} = \@vals;
 725         }
 726     }
 727
 728     return \%blacklist;
 729 }
 730
 731 #
 732 # Read the check option and adjust the hash %check, which is a rough
 733 # list of components to be checked
 734 #
 735 sub adjust_checks {
 736     my @cl = ();
 737
 738     # First, take the '--no-storage' option
 739     if ($opt{no_storage}) {
 740         $check{storage} = 0;
 741     }
 742
 743     # Adjust checking based on the '--all' option
 744     if ($opt{all}) {
 745         # Check option usage
 746         if (defined $opt{only} and $opt{only} !~ m{\A critical|warning \z}xms) {
 747             print qq{ERROR: Wrong simultaneous usage of the "--all" and "--only" options\n};
 748             exit $E_UNKNOWN;
 749         }
 750         if (scalar @{ $opt{check} } > 0) {
 751             print qq{ERROR: Wrong simultaneous usage of the "--all" and "--check" options\n};
 752             exit $E_UNKNOWN;
 753         }
 754
 755         # set the check hash to check everything
 756         map { $_ = 1 } values %check;
 757
 758         return;
 759     }
 760
 761     # Adjust checking based on the '--only' option
 762     if (defined $opt{only} and $opt{only} !~ m{\A critical|warning \z}xms) {
 763         # Check option usage
 764         if (scalar @{ $opt{check} } > 0) {
 765             print qq{ERROR: Wrong simultaneous usage of the "--only" and "--check" options\n};
 766             exit $E_UNKNOWN;
 767         }
 768         if (! exists $check{$opt{only}} && $opt{only} ne 'chassis') {
 769             print qq{ERROR: "$opt{only}" is not a known keyword for the "--only" option\n};
 770             exit $E_UNKNOWN;
 771         }
 772
 773         # reset the check hash
 774         map { $_ = 0 } values %check;
 775
 776         # adjust the check hash
 777         if ($opt{only} eq 'chassis') {
 778             map { $check{$_} = 1 } qw(memory fans power temp cpu voltage sdcard
 779                                       batteries amperage intrusion esmhealth);
 780         }
 781         else {
 782             $check{$opt{only}} = 1;
 783         }
 784
 785         return;
 786     }
 787
 788     # Adjust checking based on the '--check' option
 789     if (scalar @{ $opt{check} } >= 0) {
 790         foreach my $check (@{ $opt{check} }) {
 791             my $tmp = q{};
 792             if (-f $check) {
 793                 open my $CL, '<', $check
 794                   or do { report('other', "Couldn't open check file $check: $!", $E_UNKNOWN) and return };
 795                 chomp($tmp = <$CL>);
 796                 close $CL;
 797             }
 798             else {
 799                 $tmp = $check;
 800             }
 801             push @cl, $tmp;
 802         }
 803     }
 804
 805     return if $#cl < 0;
 806
 807     # Parse checklist string, put in hash
 808     foreach my $check (@cl) {
 809         my @checks = split /,/xms, $check;
 810         foreach my $c (@checks) {
 811             next if $c !~ m/=/xms;
 812             my ($key, $val) = split /=/xms, $c;
 813             $check{$key} = $val;
 814         }
 815     }
 816
 817     # Check if we should check global health status
 818   CHECK_KEY:
 819     foreach (keys %check) {
 820         next CHECK_KEY if $_ eq 'esmlog';   # not part of global status
 821         next CHECK_KEY if $_ eq 'alertlog'; # not part of global status
 822
 823         if ($check{$_} == 0) { # found something with checking turned off
 824             $global = 0;
 825             last CHECK_KEY;
 826         }
 827     }
 828
 829     return;
 830 }
 831
 832 #
 833 # Runs omreport and returns an array of anonymous hashes containing
 834 # the output.
 835 # Takes one argument: string containing parameters to omreport
 836 #
 837 sub run_omreport {
 838     my $command = shift;
 839     my @output  = ();
 840     my @keys    = ();
 841
 842     # Errors that are OK. Some low-end poweredge (and blades) models
 843     # don't have RAID controllers, intrusion detection sensor, or
 844     # redundant/instrumented power supplies etc.
 845     my $ok_errors
 846       = qr{
 847             Intrusion\sinformation\sis\snot\sfound\sfor\sthis\ssystem  # No intrusion probe
 848           | No\sinstrumented\spower\ssupplies\sfound\son\sthis\ssystem # No instrumented PS (blades/low-end)
 849           | No\sbattery\sprobes\sfound\son\sthis\ssystem               # No battery probes
 850           | Invalid\scommand:\spwrmonitoring                           # Old hardware
 851           | Hardware\sor\sfeature\snot\spresent\.                      # SD cards
 852           | Invalid\scommand:\sremovableflashmedia                     # SD cards with old OMSA
 853           | Error\sCorrection;                                         # Memory stuff. Not really an error (new in OMSA 6.4)
 854 #          | Current\sprobes\snot\sfound                                # OMSA + RHEL5.4 bug
 855 #          | No\scontrollers\sfound                                     # No RAID controller
 856         }xms;
 857
 858     # Errors that are OK on blade servers
 859     my $ok_blade_errors
 860       = qr{
 861               No\sfan\sprobes\sfound\son\sthis\ssystem   # No fan probes
 862       }xms;
 863
 864     # Run omreport and fetch output
 865     my $rawtext = slurp_command("$omreport $command -fmt ssv 2>&1");
 866     return [] if !defined $rawtext;
 867
 868     # Workaround for Openmanage BUG introduced in OMSA 5.5.0
 869     $rawtext =~ s{\n;}{;}gxms if $command eq 'storage controller';
 870
 871     # Report if no controllers found
 872     if ($command eq 'storage controller' and $rawtext =~ m{No\scontrollers\sfound}xms) {
 873         report('storage', 'Storage Error! No controllers found', $E_UNKNOWN);
 874     }
 875
 876     # Openmanage sometimes puts a linebreak between "Error" and the
 877     # actual error text
 878     $rawtext =~ s{^Error\s*\n}{Error: }xms;
 879
 880     # Parse output, store in array
 881     for ((split m{\n}xms, $rawtext)) {
 882         if (m{\AError}xms) {
 883             next if m{$ok_errors}xms;
 884             next if ($blade and m{$ok_blade_errors}xms);
 885             report('other', "Problem running 'omreport $command': $_", $E_UNKNOWN);
 886         }
 887
 888         next if !m/(.*?;){2}/xms;  # ignore lines with less than 3 fields
 889         my @vals = split /;/xms;
 890         if ($vals[0] =~ m/\A (Index|ID|Severity|Processor|Current\sSpeed|Connector\sName) \z/xms) {
 891             @keys = @vals;
 892         }
 893         else {
 894             my $i = 0;
 895             push @output, { map { $_ => $vals[$i++] } @keys };
 896         }
 897
 898     }
 899
 900     # Finally, return the collected information
 901     return \@output;
 902 }
 903
 904 #
 905 # Checks if a component is blacklisted. Returns 1 if the component is
 906 # blacklisted, 0 otherwise. Takes two arguments:
 907 #   arg1: component name
 908 #   arg2: component id or index
 909 #
 910 sub blacklisted {
 911     my $name = shift;  # component name
 912     my $id   = shift;  # component id
 913     my $ret  = 0;      # return value
 914
 915     if (defined $blacklist{$name}) {
 916         foreach my $comp (@{ $blacklist{$name} }) {
 917             if (defined $id and ($comp eq $id or uc($comp) eq 'ALL')) {
 918                 $ret = 1;
 919             }
 920         }
 921     }
 922
 923     return $ret;
 924 }
 925
 926 # Converts the NexusID from SNMP to our version
 927 sub convert_nexus {
 928     my $nexus = shift;
 929     $nexus =~ s{\A \\}{}xms;
 930     $nexus =~ s{\\}{:}gxms;
 931     return $nexus;
 932 }
 933
 934 # Sets custom temperature thresholds based on user supplied options
 935 sub custom_temperature_thresholds {
 936     my $type   = shift; # type of threshold, either w (warning) or c (critical)
 937     my %thres  = ();    # will contain the thresholds
 938     my @limits = ();    # holds the input
 939
 940     my @opt =  $type eq 'w' ? @{ $opt{warning} } : @{ $opt{critical} };
 941
 942     if (scalar @opt >= 0) {
 943         foreach my $t (@opt) {
 944             my $tmp = q{};
 945             if (-f $t) {
 946                 open my $F, '<', $t
 947                   or do { report('other', "Couldn't open temperature threshold file $t: $!",
 948                                  $E_UNKNOWN) and return {} };
 949                 $tmp = <$F>;
 950                 close $F;
 951             }
 952             else {
 953                 $tmp = $t;
 954             }
 955             push @limits, $tmp;
 956         }
 957     }
 958
 959     # Parse checklist string, put in hash
 960     foreach my $th (@limits) {
 961         my @tmp = split m{,}xms, $th;
 962         foreach my $t (@tmp) {
 963             next if $t !~ m{=}xms;
 964             my ($key, $val) = split m{=}xms, $t;
 965             if ($val =~ m{/}xms) {
 966                 my ($max, $min) = split m{/}xms, $val;
 967                 $thres{$key}{max} = $max;
 968                 $thres{$key}{min} = $min;
 969             }
 970             else {
 971                 $thres{$key}{max} = $val;
 972             }
 973         }
 974     }
 975
 976     return \%thres;
 977 }
 978
 979
 980 # Gets the output from SNMP result according to the OIDs checked
 981 sub get_snmp_output {
 982     my ($result,$oidref) = @_;
 983     my @temp   = ();
 984     my @output = ();
 985
 986     foreach my $oid (keys %{ $result }) {
 987         my $short = $oid;
 988         $short =~ s{\s}{}gxms;                   # remove whitespace
 989         $short =~ s{\A (.+) \. (\d+) \z}{$1}xms; # remove last number
 990         my $id = $2;
 991         if (exists $oidref->{$short}) {
 992             $temp[$id]{$oidref->{$short}} = $result->{$oid};
 993         }
 994     }
 995
 996     # Remove any empty indexes
 997     foreach my $out (@temp) {
 998         if (defined $out) {
 999             push @output, $out;
1000         }
1001     }
1002
1003     return \@output;
1004 }
1005
1006
1007 # Map the controller or other item in-place
1008 sub map_item {
1009     my ($key, $val, $list)  = @_;
1010
1011     foreach my $lst (@{ $list }) {
1012         if (!exists $lst->{$key}) {
1013             $lst->{$key} = $val;
1014         }
1015     }
1016     return;
1017 }
1018
1019 # Return the URL for official Dell documentation for a specific
1020 # PowerEdge server
1021 sub documentation_url {
1022     my $model = shift;
1023
1024     # create model short form, e.g. "r710"
1025     $model =~ s{\A PowerEdge \s (.+?) \z}{lc($1)}exms;
1026
1027     # special case for blades (e.g. M600, M710), they have common
1028     # documentation
1029     $model =~ s{\A m\d+ \z}{m}xms;
1030
1031     return 'http://support.dell.com/support/edocs/systems/pe' . $model . '/';
1032 }
1033
1034 # Return the URL for warranty information for a server with a given
1035 # serial number (servicetag)
1036 sub warranty_url {
1037     my $tag = shift;
1038
1039     # Dell support sites for different parts of the world
1040     my %supportsite
1041       = (
1042          'emea' => 'http://support.euro.dell.com/support/topics/topic.aspx/emea/shared/support/my_systems_info/',
1043          'ap'   => 'http://supportapj.dell.com/support/topics/topic.aspx/ap/shared/support/my_systems_info/en/details?',
1044          'glob' => 'http://support.dell.com/support/topics/global.aspx/support/my_systems_info/details?',
1045         );
1046
1047     # warranty URLs for different country codes
1048     my %url
1049       = (
1050          # EMEA
1051          'at' => $supportsite{emea} . 'de/details?c=at&l=de&ServiceTag=',  # Austria
1052          'be' => $supportsite{emea} . 'nl/details?c=be&l=nl&ServiceTag=',  # Belgium
1053          'cz' => $supportsite{emea} . 'cs/details?c=cz&l=cs&ServiceTag=',  # Czech Republic
1054          'de' => $supportsite{emea} . 'de/details?c=de&l=de&ServiceTag=',  # Germany
1055          'dk' => $supportsite{emea} . 'da/details?c=dk&l=da&ServiceTag=',  # Denmark
1056          'es' => $supportsite{emea} . 'es/details?c=es&l=es&ServiceTag=',  # Spain
1057          'fi' => $supportsite{emea} . 'fi/details?c=fi&l=fi&ServiceTag=',  # Finland
1058          'fr' => $supportsite{emea} . 'fr/details?c=fr&l=fr&ServiceTag=',  # France
1059          'gr' => $supportsite{emea} . 'en/details?c=gr&l=el&ServiceTag=',  # Greece
1060          'it' => $supportsite{emea} . 'it/details?c=it&l=it&ServiceTag=',  # Italy
1061          'il' => $supportsite{emea} . 'en/details?c=il&l=en&ServiceTag=',  # Israel
1062          'me' => $supportsite{emea} . 'en/details?c=me&l=en&ServiceTag=',  # Middle East
1063          'no' => $supportsite{emea} . 'no/details?c=no&l=no&ServiceTag=',  # Norway
1064          'nl' => $supportsite{emea} . 'nl/details?c=nl&l=nl&ServiceTag=',  # The Netherlands
1065          'pl' => $supportsite{emea} . 'pl/details?c=pl&l=pl&ServiceTag=',  # Poland
1066          'pt' => $supportsite{emea} . 'en/details?c=pt&l=pt&ServiceTag=',  # Portugal
1067          'ru' => $supportsite{emea} . 'ru/details?c=ru&l=ru&ServiceTag=',  # Russia
1068          'se' => $supportsite{emea} . 'sv/details?c=se&l=sv&ServiceTag=',  # Sweden
1069          'uk' => $supportsite{emea} . 'en/details?c=uk&l=en&ServiceTag=',  # United Kingdom
1070          'za' => $supportsite{emea} . 'en/details?c=za&l=en&ServiceTag=',  # South Africa
1071          # America
1072          'br' => $supportsite{glob} . 'c=br&l=pt&ServiceTag=',  # Brazil
1073          'ca' => $supportsite{glob} . 'c=ca&l=en&ServiceTag=',  # Canada
1074          'mx' => $supportsite{glob} . 'c=mx&l=es&ServiceTag=',  # Mexico
1075          'us' => $supportsite{glob} . 'c=us&l=en&ServiceTag=',  # USA
1076          # Asia/Pacific
1077          'au' => $supportsite{ap} . 'c=au&l=en&ServiceTag=',  # Australia
1078          'cn' => $supportsite{ap} . 'c=cn&l=zh&ServiceTag=',  # China
1079          'in' => $supportsite{ap} . 'c=in&l=en&ServiceTag=',  # India
1080          # default fallback
1081          'XX' => $supportsite{glob} . 'ServiceTag=',  # default
1082         );
1083
1084     if (exists $url{$opt{htmlinfo}}) {
1085         return $url{$opt{htmlinfo}} . $tag;
1086     }
1087     else {
1088         return $url{XX} . $tag;
1089     }
1090 }
1091
1092
1093 # This helper function returns the corresponding value of a hash key,
1094 # but takes into account that the key may not exist
1095 sub get_hashval {
1096     my $key  = shift || return undef;
1097     my $hash = shift;
1098     return defined $hash->{$key} ? $hash->{$key} : "Undefined value $key";
1099 }
1100
1101 # Find component status from hash
1102 sub get_snmp_status {
1103     my $key  = shift || return 'Unknown';
1104     return exists $snmp_status{$key} ? $snmp_status{$key} : 'Unknown';
1105 }
1106
1107 # Find component status from hash
1108 sub get_snmp_probestatus {
1109     my $key  = shift || return 'Unknown';
1110     return exists $snmp_probestatus{$key} ? $snmp_probestatus{$key} : 'Unknown';
1111 }
1112
1113 # Check that a hash entry is defined and not an empty string. Return a
1114 # chosen string (parameter) if these conditions are not met
1115 sub get_nonempty_string {
1116     my $key  = shift;  # key to check
1117     my $hash = shift;  # hash where the key belongs
1118     my $alt  = shift;  # alternate return value
1119     if (defined $hash->{$key} and $hash->{$key} ne q{}) {
1120         return $hash->{$key};
1121     }
1122     return $alt;
1123 }
1124
1125
1126 #---------------------------------------------------------------------
1127 # Check functions
1128 #---------------------------------------------------------------------
1129
1130 #-----------------------------------------
1131 # Check global health status
1132 #-----------------------------------------
1133 sub check_global {
1134     my $health = $E_OK;
1135
1136     if ($snmp) {
1137         #
1138         # Checks global status, i.e. both storage and chassis
1139         #
1140         my $systemStateGlobalSystemStatus = '1.3.6.1.4.1.674.10892.1.200.10.1.2.1';
1141         my $result = $snmp_session->get_request(-varbindlist => [$systemStateGlobalSystemStatus]);
1142         if (!defined $result) {
1143             printf "SNMP ERROR [global]: %s\n", $snmp_error;
1144             exit $E_UNKNOWN;
1145         }
1146         $health = $status2nagios{get_snmp_status($result->{$systemStateGlobalSystemStatus})};
1147     }
1148     else {
1149         #
1150         # NB! This does not check storage, only chassis...
1151         #
1152         foreach (@{ run_command("$omreport $omopt_system -fmt ssv") }) {
1153             next if !m/;/xms;
1154             next if m/\A SEVERITY;COMPONENT/xms;
1155             if (m/\A (.+?);Main\sSystem(\sChassis)? /xms) {
1156                 $health = $status2nagios{$1};
1157                 last;
1158             }
1159         }
1160     }
1161
1162     # Return the status
1163     return $health;
1164 }
1165
1166
1167 #-----------------------------------------
1168 # STORAGE: Check controllers
1169 #-----------------------------------------
1170 sub check_controllers {
1171     my $nexus    = undef;
1172     my $name     = undef;
1173     my $state    = undef;
1174     my $status   = undef;
1175     my $minfw    = undef;
1176     my $mindr    = undef;
1177     my $firmware = undef;
1178     my $driver   = undef;
1179     my $minstdr  = undef;  # Minimum required Storport driver version
1180     my $stdr     = undef;  # Storport driver version
1181     my @output   = ();
1182
1183     if ($snmp) {
1184         my %ctrl_oid
1185           = (
1186              '1.3.6.1.4.1.674.10893.1.20.130.1.1.1'  => 'controllerNumber',
1187              '1.3.6.1.4.1.674.10893.1.20.130.1.1.2'  => 'controllerName',
1188              '1.3.6.1.4.1.674.10893.1.20.130.1.1.5'  => 'controllerState',
1189              '1.3.6.1.4.1.674.10893.1.20.130.1.1.8'  => 'controllerFWVersion',
1190              '1.3.6.1.4.1.674.10893.1.20.130.1.1.38' => 'controllerComponentStatus',
1191              '1.3.6.1.4.1.674.10893.1.20.130.1.1.39' => 'controllerNexusID',
1192              '1.3.6.1.4.1.674.10893.1.20.130.1.1.41' => 'controllerDriverVersion',
1193              '1.3.6.1.4.1.674.10893.1.20.130.1.1.44' => 'controllerMinFWVersion',
1194              '1.3.6.1.4.1.674.10893.1.20.130.1.1.45' => 'controllerMinDriverVersion',
1195              '1.3.6.1.4.1.674.10893.1.20.130.1.1.55' => 'controllerStorportDriverVersion',
1196              '1.3.6.1.4.1.674.10893.1.20.130.1.1.56' => 'controllerMinRequiredStorportVer',
1197             );
1198
1199         # We use get_table() here for the odd case where a server has
1200         # two or more controllers, and where some OIDs are missing on
1201         # one of the controllers.
1202         my $controllerTable = '1.3.6.1.4.1.674.10893.1.20.130.1';
1203         my $result = $snmp_session->get_table(-baseoid => $controllerTable);
1204
1205         if (!defined $result) {
1206             report('storage', 'Storage Error! No controllers found', $E_UNKNOWN);
1207             return;
1208         }
1209
1210         @output = @{ get_snmp_output($result, \%ctrl_oid) };
1211     }
1212     else {
1213         @output = @{ run_omreport('storage controller') };
1214     }
1215
1216     my %ctrl_state
1217       = (
1218          0 => 'Unknown',
1219          1 => 'Ready',
1220          2 => 'Failed',
1221          3 => 'Online',
1222          4 => 'Offline',
1223          6 => 'Degraded',
1224         );
1225
1226   CTRL:
1227     foreach my $out (@output) {
1228         if ($snmp) {
1229             $name     = $out->{controllerName} || 'Unknown controller';
1230             $state    = get_hashval($out->{controllerState}, \%ctrl_state) || 'Unknown state';
1231             $status   = get_snmp_status($out->{controllerComponentStatus});
1232             $minfw    = $out->{controllerMinFWVersion} || undef;
1233             $mindr    = $out->{controllerMinDriverVersion} || undef;
1234             $firmware = $out->{controllerFWVersion} || 'N/A';
1235             $driver   = $out->{controllerDriverVersion} || 'N/A';
1236             $minstdr  = $out->{'controllerMinRequiredStorportVer'} || undef;
1237             $stdr     = $out->{controllerStorportDriverVersion} || undef;
1238             $nexus    = convert_nexus(($out->{controllerNexusID} || 9999));
1239         }
1240         else {
1241             $nexus    = get_nonempty_string('ID', $out, '9999');
1242             $name     = get_nonempty_string('Name', $out, 'Unknown controller');
1243             $state    = get_nonempty_string('State', $out, 'Unknown state');
1244             $status   = get_nonempty_string('Status', $out, 'Unknown');
1245             $minfw    = $out->{'Minimum Required Firmware Version'} ne 'Not Applicable'
1246               ? $out->{'Minimum Required Firmware Version'} : undef;
1247             $mindr    = $out->{'Minimum Required Driver Version'} ne 'Not Applicable'
1248               ? $out->{'Minimum Required Driver Version'} : undef;
1249             $firmware = $out->{'Firmware Version'} ne 'Not Applicable'
1250               ? $out->{'Firmware Version'} : 'N/A';
1251             $driver   = $out->{'Driver Version'} ne 'Not Applicable'
1252               ? $out->{'Driver Version'} : 'N/A';
1253             $minstdr  = (exists $out->{'Minimum Required Storport Driver Version'}
1254                          and $out->{'Minimum Required Storport Driver Version'} ne 'Not Applicable')
1255               ? $out->{'Minimum Required Storport Driver Version'} : undef;
1256             $stdr     = (exists $out->{'Storport Driver Version'}
1257                          and $out->{'Storport Driver Version'} ne 'Not Applicable')
1258               ? $out->{'Storport Driver Version'} : undef;
1259         }
1260
1261         $name =~ s{\s+\z}{}xms; # remove trailing whitespace
1262         push @controllers, $nexus;
1263
1264         # Collecting some storage info
1265         $sysinfo{'controller'}{$nexus}{'id'}       = $nexus;
1266         $sysinfo{'controller'}{$nexus}{'name'}     = $name;
1267         $sysinfo{'controller'}{$nexus}{'driver'}   = $driver;
1268         $sysinfo{'controller'}{$nexus}{'firmware'} = $firmware;
1269         $sysinfo{'controller'}{$nexus}{'storport'} = $stdr;
1270
1271         # Store controller info for future use (SNMP)
1272         if ($snmp) {
1273             $snmp_controller{$out->{controllerNumber}} = $nexus;
1274         }
1275
1276         next CTRL if blacklisted('ctrl', $nexus);
1277
1278         # Special case: old firmware
1279         if (!blacklisted('ctrl_fw', $nexus) && defined $minfw) {
1280             chomp $firmware;
1281             my $msg = sprintf q{Controller %d [%s]: Firmware '%s' is out of date},
1282               $nexus, $name, $firmware;
1283             report('storage', $msg, $E_WARNING, $nexus);
1284         }
1285         # Special case: old driver
1286         if (!blacklisted('ctrl_driver', $nexus) && defined $mindr) {
1287             chomp $driver;
1288             my $msg = sprintf q{Controller %d [%s]: Driver '%s' is out of date},
1289               $nexus, $name, $driver;
1290             report('storage', $msg, $E_WARNING, $nexus);
1291         }
1292         # Special case: old storport driver
1293         if (!blacklisted('ctrl_stdr', $nexus) && defined $minstdr) {
1294             chomp $stdr;
1295             my $msg = sprintf q{Controller %d [%s]: Storport driver '%s' is out of date},
1296               $nexus, $name, $stdr;
1297             report('storage', $msg, $E_WARNING, $nexus);
1298         }
1299         # Ok
1300         if ($status eq 'Ok' or ($status eq 'Non-Critical'
1301                                 and (defined $minfw or defined $mindr or defined $minstdr))) {
1302             my $msg = sprintf 'Controller %d [%s] is %s',
1303               $nexus, $name, $state;
1304             report('storage', $msg, $E_OK, $nexus);
1305         }
1306         # Default
1307         else {
1308             my $msg = sprintf 'Controller %d [%s] needs attention: %s',
1309               $nexus, $name, $state;
1310             report('storage', $msg, $status2nagios{$status}, $nexus);
1311         }
1312     }
1313     return;
1314 }
1315
1316
1317 #-----------------------------------------
1318 # STORAGE: Check physical drives
1319 #-----------------------------------------
1320 sub check_physical_disks {
1321     return if $#controllers == -1;
1322
1323     my $nexus    = undef;
1324     my $name     = undef;
1325     my $state    = undef;
1326     my $status   = undef;
1327     my $fpred    = undef;
1328     my $progr    = undef;
1329     my $ctrl     = undef;
1330     my $vendor   = undef;  # disk vendor
1331     my $product  = undef;  # product ID
1332     my $capacity = undef;  # disk length (size) in bytes
1333     my $media    = undef;  # media type (e.g. HDD, SSD)
1334     my $bus      = undef;  # bus protocol (e.g. SAS, SATA)
1335     my $spare    = undef;  # spare state (e.g. global hotspare)
1336     my $cert     = undef;  # if drive is certified or not
1337     my @output  = ();
1338
1339     if ($snmp) {
1340         my %pdisk_oid
1341           = (
1342              '1.3.6.1.4.1.674.10893.1.20.130.4.1.2'  => 'arrayDiskName',
1343              '1.3.6.1.4.1.674.10893.1.20.130.4.1.3'  => 'arrayDiskVendor',
1344              '1.3.6.1.4.1.674.10893.1.20.130.4.1.4'  => 'arrayDiskState',
1345              '1.3.6.1.4.1.674.10893.1.20.130.4.1.6'  => 'arrayDiskProductID',
1346              '1.3.6.1.4.1.674.10893.1.20.130.4.1.9'  => 'arrayDiskEnclosureID',
1347              '1.3.6.1.4.1.674.10893.1.20.130.4.1.10' => 'arrayDiskChannel',
1348              '1.3.6.1.4.1.674.10893.1.20.130.4.1.11' => 'arrayDiskLengthInMB',
1349              '1.3.6.1.4.1.674.10893.1.20.130.4.1.15' => 'arrayDiskTargetID',
1350              '1.3.6.1.4.1.674.10893.1.20.130.4.1.21' => 'arrayDiskBusType',
1351              '1.3.6.1.4.1.674.10893.1.20.130.4.1.22' => 'arrayDiskSpareState',
1352              '1.3.6.1.4.1.674.10893.1.20.130.4.1.24' => 'arrayDiskComponentStatus',
1353              '1.3.6.1.4.1.674.10893.1.20.130.4.1.26' => 'arrayDiskNexusID',
1354              '1.3.6.1.4.1.674.10893.1.20.130.4.1.31' => 'arrayDiskSmartAlertIndication',
1355              '1.3.6.1.4.1.674.10893.1.20.130.4.1.35' => 'arrayDiskMediaType',
1356              '1.3.6.1.4.1.674.10893.1.20.130.4.1.36' => 'arrayDiskDellCertified',
1357              '1.3.6.1.4.1.674.10893.1.20.130.5.1.7'  => 'arrayDiskEnclosureConnectionControllerNumber',
1358              '1.3.6.1.4.1.674.10893.1.20.130.6.1.7'  => 'arrayDiskChannelConnectionControllerNumber',
1359             );
1360         my $result = undef;
1361         if ($opt{use_get_table}) {
1362             my $arrayDiskTable = '1.3.6.1.4.1.674.10893.1.20.130.4';
1363             my $arrayDiskEnclosureConnectionControllerNumber = '1.3.6.1.4.1.674.10893.1.20.130.5.1.7';
1364             my $arrayDiskChannelConnectionControllerNumber = '1.3.6.1.4.1.674.10893.1.20.130.6.1.7';
1365
1366             $result  = $snmp_session->get_table(-baseoid => $arrayDiskTable);
1367             my $ext1 = $snmp_session->get_table(-baseoid => $arrayDiskEnclosureConnectionControllerNumber);
1368             my $ext2 = $snmp_session->get_table(-baseoid => $arrayDiskChannelConnectionControllerNumber);
1369
1370             if (defined $result) {
1371                 defined $ext1 && map { $$result{$_} = $$ext1{$_} } keys %{ $ext1 };
1372                 defined $ext2 && map { $$result{$_} = $$ext2{$_} } keys %{ $ext2 };
1373             }
1374         }
1375         else {
1376             $result = $snmp_session->get_entries(-columns => [keys %pdisk_oid]);
1377         }
1378
1379         if (!defined $result) {
1380             printf "SNMP ERROR [storage / pdisk]: %s.\n", $snmp_session->error;
1381             $snmp_session->close;
1382             exit $E_UNKNOWN;
1383         }
1384
1385         @output = @{ get_snmp_output($result, \%pdisk_oid) };
1386     }
1387     else {
1388         foreach my $c (@controllers) {
1389             # This blacklists disks with broken firmware, which includes
1390             # illegal XML characters that makes openmanage choke on itself
1391             next if blacklisted('ctrl_pdisk', $c);
1392
1393             push @output, @{ run_omreport("storage pdisk controller=$c") };
1394             map_item('ctrl', $c, \@output);
1395         }
1396     }
1397
1398     my %spare_state
1399       = (
1400          1  => 'VD member',    # disk is a member of a virtual disk
1401          2  => 'DG member',    # disk is a member of a disk group
1402          3  => 'Global HS',    # disk is a global hot spare
1403          4  => 'Dedicated HS', # disk is a dedicated hot spare
1404          5  => 'no',           # not a spare
1405          99 => 'n/a',          # not applicable
1406         );
1407
1408     my %media_type
1409       = (
1410          1 => 'unknown',
1411          2 => 'HDD',
1412          3 => 'SSD',
1413         );
1414
1415     my %bus_type
1416       = (
1417          1 => 'SCSI',
1418          2 => 'IDE',
1419          3 => 'Fibre Channel',
1420          4 => 'SSA',
1421          6 => 'USB',
1422          7 => 'SATA',
1423          8 => 'SAS',
1424         );
1425
1426     my %pdisk_state
1427       = (
1428          0  => 'Unknown',
1429          1  => 'Ready',
1430          2  => 'Failed',
1431          3  => 'Online',
1432          4  => 'Offline',
1433          6  => 'Degraded',
1434          7  => 'Recovering',
1435          11 => 'Removed',
1436          15 => 'Resynching',
1437          22 => 'Replacing', # FIXME: this one is not defined in the OMSA MIBs
1438          24 => 'Rebuilding',
1439          25 => 'No Media',
1440          26 => 'Formatting',
1441          28 => 'Diagnostics',
1442          34 => 'Predictive failure',
1443          35 => 'Initializing',
1444          39 => 'Foreign',
1445          40 => 'Clear',
1446          41 => 'Unsupported',
1447          53 => 'Incompatible',
1448         );
1449
1450     # Check physical disks on each of the controllers
1451   PDISK:
1452     foreach my $out (@output) {
1453         if ($snmp) {
1454             $name     = $out->{arrayDiskName} || 'Unknown disk';
1455             $state    = get_hashval($out->{arrayDiskState}, \%pdisk_state) || 'Unknown state';
1456             $status   = get_snmp_status($out->{arrayDiskComponentStatus});
1457             $fpred    = defined $out->{arrayDiskSmartAlertIndication}
1458               && $out->{arrayDiskSmartAlertIndication} == 2 ? 1 : 0;
1459             $progr    = q{};
1460             $nexus    = convert_nexus(($out->{arrayDiskNexusID} || 9999));
1461             $vendor   = $out->{arrayDiskVendor} || 'Unknown vendor';
1462             $product  = $out->{arrayDiskProductID} || 'Unknown product ID';
1463             $spare    = get_hashval($out->{arrayDiskSpareState}, \%spare_state) || q{};
1464             $bus      = get_hashval($out->{arrayDiskBusType}, \%bus_type);
1465             $media    = get_hashval($out->{arrayDiskMediaType}, \%media_type);
1466             $cert     = $out->{arrayDiskDellCertified} || 1;
1467             $capacity = exists $out->{arrayDiskLengthInMB}
1468               ? $out->{arrayDiskLengthInMB} * 1024**2 : -1;
1469
1470             # try to find the controller where the disk belongs
1471             if (exists $out->{arrayDiskEnclosureConnectionControllerNumber}) {
1472                 # for disks that are attached to an enclosure
1473                 $ctrl = $snmp_controller{$out->{arrayDiskEnclosureConnectionControllerNumber}};
1474             }
1475             elsif (exists $out->{arrayDiskChannelConnectionControllerNumber}) {
1476                 # for disks that are not attached to an enclosure
1477                 $ctrl = $snmp_controller{$out->{arrayDiskChannelConnectionControllerNumber}};
1478             }
1479             else {
1480                 # last resort... use the nexus id (old/broken hardware)
1481                 $ctrl = $nexus;
1482                 $ctrl =~ s{\A (\d+) : .* \z}{$1}xms;
1483             }
1484         }
1485         else {
1486             $name     = get_nonempty_string('Name', $out, 'Unknown disk');
1487             $state    = get_nonempty_string('State', $out, 'Unknown state');
1488             $status   = get_nonempty_string('Status', $out, 'Unknown');
1489             $fpred    = lc(get_nonempty_string('Failure Predicted', $out, q{})) eq 'yes' ? 1 : 0;
1490             $progr    = ' [' . get_nonempty_string('Progress', $out, q{}) . ']';
1491             $nexus    = join q{:}, $out->{ctrl}, $out->{'ID'};
1492             $vendor   = get_nonempty_string('Vendor ID', $out, 'Unknown Vendor');
1493             $product  = get_nonempty_string('Product ID', $out, 'Unknown Product ID');
1494             $media    = get_nonempty_string('Media', $out, undef);
1495             $bus      = get_nonempty_string('Bus Protocol', $out, undef);
1496             $spare    = get_nonempty_string('Hot Spare', $out, q{});
1497             $cert     = get_nonempty_string('Certified', $out, 1);
1498             $ctrl     = $out->{ctrl};
1499             $capacity = get_nonempty_string('Capacity', $out, q{});
1500             $capacity =~ s{\A .*? \((\d+) \s bytes\) \z}{$1}xms;
1501             if ($capacity eq 'Unavailable') {
1502                 $capacity = -1;
1503             }
1504             if ($cert eq 'Yes' or $cert eq 'Not Applicable') {
1505                 $cert = 1;
1506             }
1507             else {
1508                 $cert = 0;
1509             }
1510         }
1511
1512         $count{pdisk}++;
1513         next PDISK if blacklisted('pdisk', $nexus);
1514
1515         $vendor  =~ s{\s+\z}{}xms; # remove trailing whitespace
1516         $product =~ s{\s+\z}{}xms; # remove trailing whitespace
1517
1518         # If the disk is bad, the vendor field may be empty
1519         if ($vendor eq q{}) { $vendor = 'Unknown Vendor'; }
1520
1521         # Hot spare stuff
1522         if ($spare eq 'Global') { $spare = 'Global HS'; }
1523         elsif ($spare eq 'Dedicated') { $spare = 'Dedicated HS'; }
1524         elsif ($spare !~ m{\A Global|Dedicated}xms) { $spare = undef; }
1525
1526         # Calculate human readable capacity
1527         if ($capacity == -1) {
1528             # capacity is unknown
1529             $capacity = 'Unknown Size';
1530         }
1531         else {
1532             $capacity = ceil($capacity / 1000**3) >= 1000
1533               ? sprintf '%.1fTB', ($capacity / 1000**4)
1534                 : sprintf '%.0fGB', ($capacity / 1000**3);
1535             $capacity = '450GB' if $capacity eq '449GB';  # quick fix for 450GB disks
1536             $capacity = '300GB' if $capacity eq '299GB';  # quick fix for 300GB disks
1537             $capacity = '146GB' if $capacity eq '147GB';  # quick fix for 146GB disks
1538             $capacity = '100GB' if $capacity eq '99GB';   # quick fix for 100GB disks
1539         }
1540
1541         # Capitalize only the first letter of the vendor name
1542         $vendor = (substr $vendor, 0, 1) . lc (substr $vendor, 1, length $vendor);
1543
1544         # Remove unnecessary trademark rubbish from vendor name
1545         $vendor =~ s{\(tm\)\z}{}xms;
1546
1547         # bus and media aren't always defined
1548         my $busmedia = q{};
1549         if    (defined $bus && defined $media)   { $busmedia = "$bus-$media "; }
1550         elsif (defined $bus && ! defined $media) { $busmedia = "$bus ";        }
1551         elsif (! defined $bus && defined $media) { $busmedia = "$media ";      }
1552
1553         # Special case: Failure predicted
1554         if ($fpred) {
1555             my $msg = sprintf '%s [%s %s, %s] on ctrl %d needs attention: Failure Predicted',
1556               $name, $vendor, $product, $capacity, $ctrl;
1557             $msg .= " ($state)" if $state ne 'Predictive failure';
1558             report('storage', $msg,
1559                    ($status2nagios{$status} == $E_CRITICAL ? $E_CRITICAL : $E_WARNING), $nexus);
1560         }
1561         # Special case: Rebuilding / Replacing
1562         elsif ($state =~ m{\A Rebuilding|Replacing \z}xms) {
1563             my $msg = sprintf '%s [%s %s, %s] on ctrl %d is %s%s',
1564               $name, $vendor, $product, $capacity, $ctrl, $state, $progr;
1565             report('storage', $msg, $E_WARNING, $nexus);
1566         }
1567         # Special case: Uncertified disk
1568         elsif ($status eq 'Non-Critical' and !$cert) {
1569             my $msg = sprintf '%s [%s %s, %s] on ctrl %d is Not Certified',
1570               $name, $vendor, $product, $capacity, $ctrl;
1571             report('storage', $msg, $E_WARNING, $nexus);
1572         }
1573         # Default
1574         elsif ($status ne 'Ok') {
1575             my $msg =  sprintf '%s [%s %s, %s] on ctrl %d needs attention: %s',
1576               $name, $vendor, $product, $capacity, $ctrl, $state;
1577             report('storage', $msg, $status2nagios{$status}, $nexus);
1578         }
1579         # Ok
1580         else {
1581             my $msg = sprintf '%s [%s%s] on ctrl %d is %s',
1582               $name, $busmedia, $capacity, $ctrl, $state;
1583             if (defined $spare) { $msg .= " ($spare)"; }
1584             report('storage', $msg, $E_OK, $nexus);
1585         }
1586     }
1587     return;
1588 }
1589
1590
1591 #-----------------------------------------
1592 # STORAGE: Check logical drives
1593 #-----------------------------------------
1594 sub check_virtual_disks {
1595     return if $#controllers == -1;
1596
1597     my $name   = undef;
1598     my $nexus  = undef;
1599     my $dev    = undef;
1600     my $state  = undef;
1601     my $status = undef;
1602     my $layout = undef;
1603     my $size   = undef;
1604     my $progr  = undef;
1605     my $ctrl   = undef;
1606     my @output = ();
1607
1608     if ($snmp) {
1609         my %vdisk_oid
1610           = (
1611              '1.3.6.1.4.1.674.10893.1.20.140.1.1.3'  => 'virtualDiskDeviceName',
1612              '1.3.6.1.4.1.674.10893.1.20.140.1.1.4'  => 'virtualDiskState',
1613              '1.3.6.1.4.1.674.10893.1.20.140.1.1.6'  => 'virtualDiskLengthInMB',
1614              '1.3.6.1.4.1.674.10893.1.20.140.1.1.13' => 'virtualDiskLayout',
1615              '1.3.6.1.4.1.674.10893.1.20.140.1.1.20' => 'virtualDiskComponentStatus',
1616              '1.3.6.1.4.1.674.10893.1.20.140.1.1.21' => 'virtualDiskNexusID',
1617             );
1618         my $result = undef;
1619         if ($opt{use_get_table}) {
1620             my $virtualDiskTable = '1.3.6.1.4.1.674.10893.1.20.140.1';
1621             $result = $snmp_session->get_table(-baseoid => $virtualDiskTable);
1622         }
1623         else {
1624             $result = $snmp_session->get_entries(-columns => [keys %vdisk_oid]);
1625         }
1626
1627         # No logical drives is OK
1628         return if !defined $result;
1629
1630         @output = @{ get_snmp_output($result, \%vdisk_oid) };
1631     }
1632     else {
1633         foreach my $c (@controllers) {
1634             push @output, @{ run_omreport("storage vdisk controller=$c") };
1635             map_item('ctrl', $c, \@output);
1636         }
1637     }
1638
1639     my %vdisk_state
1640       = (
1641          0  => 'Unknown',
1642          1  => 'Ready',
1643          2  => 'Failed',
1644          3  => 'Online',
1645          4  => 'Offline',
1646          6  => 'Degraded',
1647          15 => 'Resynching',
1648          16 => 'Regenerating',
1649          24 => 'Rebuilding',
1650          26 => 'Formatting',
1651          32 => 'Reconstructing',
1652          35 => 'Initializing',
1653          36 => 'Background Initialization',
1654          38 => 'Resynching Paused',
1655          52 => 'Permanently Degraded',
1656          54 => 'Degraded Redundancy',
1657         );
1658
1659     my %vdisk_layout
1660       = (
1661          1  => 'Concatenated',
1662          2  => 'RAID-0',
1663          3  => 'RAID-1',
1664          4  => 'UNSUPPORTED:raid-2',
1665          5  => 'UNSUPPORTED:raid-3',
1666          6  => 'UNSUPPORTED:raid-4',
1667          7  => 'RAID-5',
1668          8  => 'RAID-6',
1669          9  => 'UNSUPPORTED:raid-7',
1670          10 => 'RAID-10',
1671          11 => 'UNSUPPORTED:raid-30',
1672          12 => 'RAID-50',
1673          13 => 'UNSUPPORTED:addSpares',
1674          14 => 'UNSUPPORTED:deleteLogical',
1675          15 => 'UNSUPPORTED:transformLogical',
1676          18 => 'UNSUPPORTED:raid-0-plus-1',
1677          19 => 'Concatenated RAID-1',
1678          20 => 'UNSUPPORTED:concatRaid-5',
1679          21 => 'UNSUPPORTED:noRaid',
1680          22 => 'UNSUPPORTED:volume',
1681          23 => 'UNSUPPORTED:raidMorph',
1682          24 => 'RAID-60',
1683          25 => 'CacheCade',
1684         );
1685
1686     # Check virtual disks on each of the controllers
1687   VDISK:
1688     foreach my $out (@output) {
1689         if ($snmp) {
1690             $dev    = $out->{virtualDiskDeviceName} || 'Unknown device';
1691             $state  = get_hashval($out->{virtualDiskState}, \%vdisk_state) || 'Unknown state';
1692             $layout = get_hashval($out->{virtualDiskLayout}, \%vdisk_layout) || 'Unknown layout';
1693             $status = get_snmp_status($out->{virtualDiskComponentStatus});
1694             $size   = sprintf '%.2f GB', ($out->{virtualDiskLengthInMB} || 0) / 1024;
1695             $progr  = q{};  # not available via SNMP
1696             $nexus  = convert_nexus(($out->{virtualDiskNexusID} || 9999));
1697         }
1698         else {
1699             $dev    = get_nonempty_string('Device Name', $out, 'Unknown device');
1700             $state  = get_nonempty_string('State', $out, 'Unknown state');
1701             $status = get_nonempty_string('Status', $out, 'Unknown');
1702             $layout = get_nonempty_string('Layout', $out, 'Unknown layout');
1703             $size   = get_nonempty_string('Size', $out, 'Unavailable');
1704             $size   =~ s{\A (.*GB).* \z}{$1}xms;
1705             $progr  = ' [' . get_nonempty_string('Progress', $out, q{}) . ']';
1706             $ctrl   = $out->{ctrl};
1707             $nexus  = join q{:}, $ctrl, get_nonempty_string('ID', $out, '9999');
1708         }
1709
1710         $count{vdisk}++;
1711         next VDISK if blacklisted('vdisk', $nexus);
1712
1713         # The device name is undefined sometimes
1714         $dev = q{} if !defined $dev;
1715
1716         # Special case: Regenerating
1717         if ($state eq 'Regenerating') {
1718             my $msg = sprintf q{Logical Drive '%s' [%s, %s] is %s%s},
1719               $dev, $layout, $size, $state, $progr;
1720             report('storage', $msg, $E_WARNING, $nexus);
1721         }
1722         # Default
1723         elsif ($status ne 'Ok') {
1724             my $msg = sprintf q{Logical Drive '%s' [%s, %s] needs attention: %s},
1725               $dev, $layout, $size, $state;
1726             report('storage', $msg, $status2nagios{$status}, $nexus);
1727         }
1728         # Ok
1729         else {
1730             my $msg = sprintf q{Logical Drive '%s' [%s, %s] is %s},
1731               $dev, $layout, $size, $state;
1732             report('storage', $msg, $E_OK, $nexus);
1733         }
1734     }
1735     return;
1736 }
1737
1738
1739 #-----------------------------------------
1740 # STORAGE: Check cache batteries
1741 #-----------------------------------------
1742 sub check_cache_battery {
1743     return if $#controllers == -1;
1744
1745     my $id     = undef;
1746     my $nexus  = undef;
1747     my $state  = undef;
1748     my $status = undef;
1749     my $ctrl   = undef;
1750     my $learn  = undef; # learn state
1751     my $pred   = undef; # battery's ability to be charged
1752     my @output = ();
1753
1754     if ($snmp) {
1755         my %bat_oid
1756           = (
1757              '1.3.6.1.4.1.674.10893.1.20.130.15.1.4'  => 'batteryState',
1758              '1.3.6.1.4.1.674.10893.1.20.130.15.1.6'  => 'batteryComponentStatus',
1759              '1.3.6.1.4.1.674.10893.1.20.130.15.1.9'  => 'batteryNexusID',
1760              '1.3.6.1.4.1.674.10893.1.20.130.15.1.10' => 'batteryPredictedCapacity',
1761              '1.3.6.1.4.1.674.10893.1.20.130.15.1.12' => 'batteryLearnState',
1762              '1.3.6.1.4.1.674.10893.1.20.130.16.1.5'  => 'batteryConnectionControllerNumber',
1763             );
1764         my $result = undef;
1765         if ($opt{use_get_table}) {
1766             my $batteryTable = '1.3.6.1.4.1.674.10893.1.20.130.15';
1767             my $batteryConnectionTable = '1.3.6.1.4.1.674.10893.1.20.130.16';
1768
1769             $result = $snmp_session->get_table(-baseoid => $batteryTable);
1770             my $ext = $snmp_session->get_table(-baseoid => $batteryConnectionTable);
1771
1772             if (defined $result) {
1773                 defined $ext && map { $$result{$_} = $$ext{$_} } keys %{ $ext };
1774             }
1775         }
1776         else {
1777             $result = $snmp_session->get_entries(-columns => [keys %bat_oid]);
1778         }
1779
1780         # No cache battery is OK
1781         return if !defined $result;
1782
1783         @output = @{ get_snmp_output($result, \%bat_oid) };
1784     }
1785     else {
1786         foreach my $c (@controllers) {
1787             push @output, @{ run_omreport("storage battery controller=$c") };
1788             map_item('ctrl', $c, \@output);
1789         }
1790     }
1791
1792     my %bat_state
1793       = (
1794          0  => 'Unknown',
1795          1  => 'Ready',
1796          2  => 'Failed',
1797          6  => 'Degraded',
1798          7  => 'Reconditioning',
1799          9  => 'High',
1800          10 => 'Power Low',
1801          12 => 'Charging',
1802          21 => 'Missing',
1803          36 => 'Learning',
1804         );
1805
1806     # Specifies the learn state activity of the battery
1807     my %bat_learn_state
1808       = (
1809          1  => 'Failed',
1810          2  => 'Active',
1811          4  => 'Timed out',
1812          8  => 'Requested',
1813          16 => 'Idle',
1814         );
1815
1816     # This property displays the battery's ability to be charged
1817     my %bat_pred_cap
1818       = (
1819          1 => 'Failed',  # The battery cannot be charged and needs to be replaced
1820          2 => 'Ready',   # The battery can be charged to full capacity
1821          4 => 'Unknown', # The battery is completing a Learn cycle. The charge capacity of the
1822                          # battery cannot be determined until the Learn cycle is complete
1823         );
1824
1825     # Check battery on each of the controllers
1826   BATTERY:
1827     foreach my $out (@output) {
1828         if ($snmp) {
1829             $status = get_snmp_status($out->{batteryComponentStatus});
1830             $state  = get_hashval($out->{batteryState}, \%bat_state) || 'Unknown state';
1831             $learn  = get_hashval($out->{batteryLearnState}, \%bat_learn_state) || 'Unknown learn state';
1832             $pred   = get_hashval($out->{batteryPredictedCapacity}, \%bat_pred_cap) || 'Unknown predicted capacity status';
1833             $ctrl   = ($out->{batteryConnectionControllerNumber} || 10000) - 1;
1834             $nexus  = convert_nexus(($out->{batteryNexusID} || 9999));
1835             $id     = $nexus;
1836             $id     =~ s{\A \d+:(\d+) \z}{$1}xms;
1837         }
1838         else {
1839             $id     = get_nonempty_string('ID', $out, 9999);
1840             $state  = get_nonempty_string('State', $out, 'Unknown state');
1841             $status = get_nonempty_string('Status', $out, 'Unknown');
1842             $learn  = get_nonempty_string('Learn State', $out, 'Unknown learn state');
1843             $pred   = get_nonempty_string('Predicted Capacity Status', $out, 'Unknown predicted capacity status');
1844             $ctrl   = $out->{'ctrl'};
1845             $nexus  = join q{:}, $out->{ctrl}, $id;
1846         }
1847
1848         next BATTERY if blacklisted('bat', $nexus);
1849
1850         # Special case: Charging
1851         if ($state eq 'Charging') {
1852             if ($pred eq 'Failed') {
1853                 my $msg = sprintf 'Cache Battery %d in controller %d is %s (%s) [replace battery]',
1854                   $id, $ctrl, $state, $pred;
1855                 report('storage', $msg, $E_CRITICAL, $nexus);
1856             }
1857             else {
1858                 next BATTERY if blacklisted('bat_charge', $nexus);
1859                 my $msg = sprintf 'Cache Battery %d in controller %d is %s (%s) [probably harmless]',
1860                   $id, $ctrl, $state, $pred;
1861                 report('storage', $msg, $E_WARNING, $nexus);
1862             }
1863         }
1864         # Special case: Learning (battery learns its capacity)
1865         elsif ($state eq 'Learning') {
1866             if ($learn eq 'Failed') {
1867                 my $msg = sprintf 'Cache Battery %d in controller %d is %s (%s)',
1868                   $id, $ctrl, $state, $learn;
1869                 report('storage', $msg, $E_CRITICAL, $nexus);
1870             }
1871             else {
1872                 next BATTERY if blacklisted('bat_charge', $nexus);
1873                 my $msg = sprintf 'Cache Battery %d in controller %d is %s (%s) [probably harmless]',
1874                   $id, $ctrl, $state, $learn;
1875                 report('storage', $msg, $E_WARNING, $nexus);
1876             }
1877         }
1878         # Special case: Power Low (first part of recharge cycle)
1879         elsif ($state eq 'Power Low') {
1880             next BATTERY if blacklisted('bat_charge', $nexus);
1881             my $msg = sprintf 'Cache Battery %d in controller %d is %s [probably harmless]',
1882               $id, $ctrl, $state;
1883             report('storage', $msg, $E_WARNING, $nexus);
1884         }
1885         # Special case: Degraded and Non-Critical (usually part of recharge cycle)
1886         elsif ($state eq 'Degraded' && $status eq 'Non-Critical') {
1887             next BATTERY if blacklisted('bat_charge', $nexus);
1888             my $msg = sprintf 'Cache Battery %d in controller %d is %s (%s) [probably harmless]',
1889               $id, $ctrl, $state, $status;
1890             report('storage', $msg, $E_WARNING, $nexus);
1891         }
1892         # Default
1893         else {
1894             my $msg = sprintf 'Cache Battery %d in controller %d is %s',
1895               $id, $ctrl, $state;
1896             report('storage', $msg, $status2nagios{$status}, $nexus);
1897         }
1898     }
1899     return;
1900 }
1901
1902
1903 #-----------------------------------------
1904 # STORAGE: Check connectors (channels)
1905 #-----------------------------------------
1906 sub check_connectors {
1907     return if $#controllers == -1;
1908
1909     my $nexus  = undef;
1910     my $name   = undef;
1911     my $state  = undef;
1912     my $status = undef;
1913     my $type   = undef;
1914     my $ctrl   = undef;
1915     my @output = ();
1916
1917     if ($snmp) {
1918         my %conn_oid
1919           = (
1920              '1.3.6.1.4.1.674.10893.1.20.130.2.1.2'  => 'channelName',
1921              '1.3.6.1.4.1.674.10893.1.20.130.2.1.3'  => 'channelState',
1922              '1.3.6.1.4.1.674.10893.1.20.130.2.1.8'  => 'channelComponentStatus',
1923              '1.3.6.1.4.1.674.10893.1.20.130.2.1.9'  => 'channelNexusID',
1924              '1.3.6.1.4.1.674.10893.1.20.130.2.1.11' => 'channelBusType',
1925             );
1926         my $result = undef;
1927         if ($opt{use_get_table}) {
1928             my $channelTable = '1.3.6.1.4.1.674.10893.1.20.130.2';
1929             $result = $snmp_session->get_table(-baseoid => $channelTable);
1930         }
1931         else {
1932             $result = $snmp_session->get_entries(-columns => [keys %conn_oid]);
1933         }
1934
1935         if (!defined $result) {
1936             printf "SNMP ERROR [storage / channel]: %s.\n", $snmp_session->error;
1937             $snmp_session->close;
1938             exit $E_UNKNOWN;
1939         }
1940
1941         @output = @{ get_snmp_output($result, \%conn_oid) };
1942     }
1943     else {
1944         foreach my $c (@controllers) {
1945             push @output, @{ run_omreport("storage connector controller=$c") };
1946             map_item('ctrl', $c, \@output);
1947         }
1948     }
1949
1950     my %conn_state
1951       = (
1952          0 => 'Unknown',
1953          1 => 'Ready',
1954          2 => 'Failed',
1955          3 => 'Online',
1956          4 => 'Offline',
1957          6 => 'Degraded',
1958         );
1959
1960     my %conn_bustype
1961       = (
1962          1 => 'SCSI',
1963          2 => 'IDE',
1964          3 => 'Fibre Channel',
1965          4 => 'SSA',
1966          6 => 'USB',
1967          7 => 'SATA',
1968          8 => 'SAS',
1969         );
1970
1971     # Check connectors on each of the controllers
1972   CHANNEL:
1973     foreach my $out (@output) {
1974         if ($snmp) {
1975             $name   = $out->{channelName} || 'Unknown channel';
1976             $status = get_snmp_status($out->{channelComponentStatus});
1977             $state  = get_hashval($out->{channelState}, \%conn_state) || 'Unknown state';
1978             $type   = get_hashval($out->{channelBusType}, \%conn_bustype) || 'Unknown type';
1979             $nexus  = convert_nexus(($out->{channelNexusID} || 9999));
1980             $ctrl   = $nexus;
1981             $ctrl   =~ s{(\d+):\d+}{$1}xms;
1982         }
1983         else {
1984             $name   = get_nonempty_string('Name', $out, 'Unknown channel');
1985             $state  = get_nonempty_string('State', $out, 'Unknown state');
1986             $status = get_nonempty_string('Status', $out, 'Unknown');
1987             $type   = get_nonempty_string('Connector Type', $out, 'Unknown type');
1988             $ctrl   = $out->{ctrl};
1989             $nexus  = join q{:}, $out->{ctrl}, $out->{'ID'};
1990         }
1991
1992         next CHANNEL if blacklisted('conn', $nexus);
1993
1994         my $msg = sprintf '%s [%s] on controller %d is %s',
1995           $name, $type, $ctrl, $state;
1996         report('storage', $msg, $status2nagios{$status}, $nexus);
1997     }
1998     return;
1999 }
2000
2001
2002 #-----------------------------------------
2003 # STORAGE: Check enclosures
2004 #-----------------------------------------
2005 sub check_enclosures {
2006     my $id       = undef;
2007     my $nexus    = undef;
2008     my $name     = undef;
2009     my $state    = undef;
2010     my $status   = undef;
2011     my $firmware = undef;
2012     my $ctrl     = undef;
2013     my $occupied_slots = undef; # number of occupied slots
2014     my $total_slots    = undef; # number of total slots
2015     my @output   = ();
2016
2017     if ($snmp) {
2018         my %encl_oid
2019           = (
2020              '1.3.6.1.4.1.674.10893.1.20.130.3.1.1'  => 'enclosureNumber',
2021              '1.3.6.1.4.1.674.10893.1.20.130.3.1.2'  => 'enclosureName',
2022              '1.3.6.1.4.1.674.10893.1.20.130.3.1.4'  => 'enclosureState',
2023              '1.3.6.1.4.1.674.10893.1.20.130.3.1.19' => 'enclosureChannelNumber',
2024              '1.3.6.1.4.1.674.10893.1.20.130.3.1.24' => 'enclosureComponentStatus',
2025              '1.3.6.1.4.1.674.10893.1.20.130.3.1.25' => 'enclosureNexusID',
2026              '1.3.6.1.4.1.674.10893.1.20.130.3.1.26' => 'enclosureFirmwareVersion',
2027              '1.3.6.1.4.1.674.10893.1.20.130.3.1.31' => 'enclosureOccupiedSlotCount', # new in OMSA 6.3.0
2028              '1.3.6.1.4.1.674.10893.1.20.130.3.1.32' => 'enclosureTotalSlots', # new in OMSA 6.3.0
2029             );
2030         my $result = undef;
2031         if ($opt{use_get_table}) {
2032             my $enclosureTable = '1.3.6.1.4.1.674.10893.1.20.130.3';
2033             $result = $snmp_session->get_table(-baseoid => $enclosureTable);
2034         }
2035         else {
2036             $result = $snmp_session->get_entries(-columns => [keys %encl_oid]);
2037         }
2038
2039         # No enclosures is OK
2040         return if !defined $result;
2041
2042         @output = @{ get_snmp_output($result, \%encl_oid) };
2043     }
2044     else {
2045         foreach my $c (@controllers) {
2046             push @output, @{ run_omreport("storage enclosure controller=$c") };
2047             map_item('ctrl', $c, \@output);
2048         }
2049     }
2050
2051     my %encl_state
2052       = (
2053          0 => 'Unknown',
2054          1 => 'Ready',
2055          2 => 'Failed',
2056          3 => 'Online',
2057          4 => 'Offline',
2058          6 => 'Degraded',
2059         );
2060
2061   ENCLOSURE:
2062     foreach my $out (@output) {
2063         if ($snmp) {
2064             $id       = ($out->{enclosureNumber} || 10000) - 1;
2065             $name     = $out->{enclosureName} || 'Unknown enclosure';
2066             $state    = get_hashval($out->{enclosureState}, \%encl_state) || 'Unknown state';
2067             $status   = get_snmp_status($out->{enclosureComponentStatus});
2068             $firmware = $out->{enclosureFirmwareVersion} || 'N/A';
2069             $nexus    = convert_nexus(($out->{enclosureNexusID} || 9999));
2070             $ctrl     = $nexus;
2071             $ctrl     =~ s{\A (\d+):.* \z}{$1}xms;
2072             # for the next two, a value of 9999 means feature not available
2073             $occupied_slots = defined $out->{enclosureOccupiedSlotCount}
2074               && $out->{enclosureOccupiedSlotCount} != 9999
2075                 ? $out->{enclosureOccupiedSlotCount} : undef;
2076             $total_slots    = defined $out->{enclosureTotalSlots}
2077               && $out->{enclosureTotalSlots} != 9999
2078                 ? $out->{enclosureTotalSlots} : undef;
2079         }
2080         else {
2081             $id       = get_nonempty_string('ID', $out, 9999);
2082             $name     = get_nonempty_string('Name', $out, 'Unknown enclosure');
2083             $state    = get_nonempty_string('State', $out, 'Unknown state');
2084             $status   = get_nonempty_string('Status', $out, 'Unknown');
2085             $firmware = get_nonempty_string('Firmware Version', $out, 'N/A');
2086             $firmware =~ s{Not\sApplicable}{N/A}xms;
2087             $nexus    = join q{:}, $out->{ctrl}, $id;
2088             $ctrl     = $out->{ctrl};
2089         }
2090
2091         $name     =~ s{\s+\z}{}xms; # remove trailing whitespace
2092         $firmware =~ s{\s+\z}{}xms; # remove trailing whitespace
2093
2094         # store enclosure data for future use
2095         if ($snmp) {
2096             $snmp_enclosure{$out->{enclosureNumber}}{id}    = $id;
2097             $snmp_enclosure{$out->{enclosureNumber}}{name}  = $name;
2098             $snmp_enclosure{$out->{enclosureNumber}}{nexus} = $nexus;
2099         }
2100         else {
2101             push @enclosures, { 'id'    => $id,
2102                                 'ctrl'  => $out->{ctrl},
2103                                 'name'  => $name };
2104         }
2105
2106         # Collecting some storage info
2107         $sysinfo{'enclosure'}{$nexus}{'id'}       = $nexus;
2108         $sysinfo{'enclosure'}{$nexus}{'name'}     = $name;
2109         $sysinfo{'enclosure'}{$nexus}{'firmware'} = $firmware;
2110
2111         next ENCLOSURE if blacklisted('encl', $nexus);
2112
2113         my $msg = q{};
2114         if (defined $occupied_slots && defined $total_slots) {
2115             $msg = sprintf 'Enclosure %s [%s, %d/%d slots occupied] on ctrl %d is %s',
2116               $nexus, $name, $occupied_slots, $total_slots, $ctrl, $state;
2117         }
2118         else {
2119             $msg = sprintf 'Enclosure %s [%s] on controller %d is %s',
2120               $nexus, $name, $ctrl, $state;
2121         }
2122         report('storage', $msg, $status2nagios{$status}, $nexus);
2123     }
2124     return;
2125 }
2126
2127
2128 #-----------------------------------------
2129 # STORAGE: Check enclosure fans
2130 #-----------------------------------------
2131 sub check_enclosure_fans {
2132     return if $#controllers == -1;
2133
2134     my $nexus     = undef;
2135     my $name      = undef;
2136     my $state     = undef;
2137     my $status    = undef;
2138     my $speed     = undef;
2139     my $encl_id   = undef;
2140     my $encl_name = undef;
2141     my @output    = ();
2142
2143     if ($snmp) {
2144         my %fan_oid
2145           = (
2146              '1.3.6.1.4.1.674.10893.1.20.130.7.1.2'  => 'fanName',
2147              '1.3.6.1.4.1.674.10893.1.20.130.7.1.4'  => 'fanState',
2148              '1.3.6.1.4.1.674.10893.1.20.130.7.1.11' => 'fanProbeCurrValue',
2149              '1.3.6.1.4.1.674.10893.1.20.130.7.1.15' => 'fanComponentStatus',
2150              '1.3.6.1.4.1.674.10893.1.20.130.7.1.16' => 'fanNexusID',
2151              '1.3.6.1.4.1.674.10893.1.20.130.8.1.4'  => 'fanConnectionEnclosureName',
2152              '1.3.6.1.4.1.674.10893.1.20.130.8.1.5'  => 'fanConnectionEnclosureNumber',
2153             );
2154         my $result = undef;
2155         if ($opt{use_get_table}) {
2156             my $fanTable = '1.3.6.1.4.1.674.10893.1.20.130.7';
2157             my $fanConnectionTable = '1.3.6.1.4.1.674.10893.1.20.130.8';
2158
2159             $result = $snmp_session->get_table(-baseoid => $fanTable);
2160             my $ext = $snmp_session->get_table(-baseoid => $fanConnectionTable);
2161
2162             if (defined $result) {
2163                 defined $ext && map { $$result{$_} = $$ext{$_} } keys %{ $ext };
2164             }
2165         }
2166         else {
2167             $result = $snmp_session->get_entries(-columns => [keys %fan_oid]);
2168         }
2169
2170         # No enclosure fans is OK
2171         return if !defined $result;
2172
2173         @output = @{ get_snmp_output($result, \%fan_oid) };
2174     }
2175     else {
2176         foreach my $enc (@enclosures) {
2177             push @output, @{ run_omreport("storage enclosure controller=$enc->{ctrl} enclosure=$enc->{id} info=fans") };
2178             map_item('ctrl', $enc->{ctrl}, \@output);
2179             map_item('encl_id', $enc->{id}, \@output);
2180             map_item('encl_name', $enc->{name}, \@output);
2181         }
2182     }
2183
2184     my %fan_state
2185       = (
2186          0  => 'Unknown',
2187          1  => 'Ready',
2188          2  => 'Failed',
2189          3  => 'Online',
2190          4  => 'Offline',
2191          6  => 'Degraded',
2192          21 => 'Missing',
2193         );
2194
2195     # Check fans on each of the enclosures
2196   FAN:
2197     foreach my $out (@output) {
2198         if ($snmp) {
2199             $name      = $out->{fanName} || 'Unknown fan';
2200             $state     = get_hashval($out->{fanState}, \%fan_state) || 'Unknown state';
2201             $status    = get_snmp_status($out->{fanComponentStatus});
2202             $speed     = $out->{fanProbeCurrValue} || 'N/A';
2203             $encl_name = $out->{fanConnectionEnclosureName} || 'Unknown enclosure';
2204             $encl_id   = $snmp_enclosure{$out->{fanConnectionEnclosureNumber}}{nexus};
2205             $nexus     = convert_nexus(($out->{fanNexusID} || 9999));
2206         }
2207         else {
2208             $name      = get_nonempty_string('Name', $out, 'Unknown fan');
2209             $state     = get_nonempty_string('State', $out, 'Unknown state');
2210             $status    = get_nonempty_string('Status', $out, 'Unknown');
2211             $speed     = get_nonempty_string('Speed', $out, 'N/A');
2212             $encl_id   = join q{:}, $out->{ctrl}, $out->{'encl_id'};
2213             $encl_name = $out->{encl_name};
2214             $nexus     = join q{:}, $out->{ctrl}, $out->{'encl_id'}, get_nonempty_string('ID', $out, '9999');
2215         }
2216
2217         next FAN if blacklisted('encl_fan', $nexus);
2218
2219         # Default
2220         if ($status ne 'Ok') {
2221             my $msg = sprintf '%s in enclosure %s [%s] needs attention: %s',
2222               $name, $encl_id, $encl_name, $state;
2223             report('storage', $msg, $status2nagios{$status}, $nexus);
2224         }
2225         # Ok
2226         else {
2227             my $msg = sprintf '%s in enclosure %s [%s] is %s (speed=%s)',
2228               $name, $encl_id, $encl_name, $state, $speed;
2229             report('storage', $msg, $E_OK, $nexus);
2230         }
2231     }
2232     return;
2233 }
2234
2235
2236 #-----------------------------------------
2237 # STORAGE: Check enclosure power supplies
2238 #-----------------------------------------
2239 sub check_enclosure_pwr {
2240     return if $#controllers == -1;
2241
2242     my $nexus     = undef;
2243     my $name      = undef;
2244     my $state     = undef;
2245     my $status    = undef;
2246     my $encl_id   = undef;
2247     my $encl_name = undef;
2248     my @output    = ();
2249
2250     if ($snmp) {
2251         my %ps_oid
2252           = (
2253              '1.3.6.1.4.1.674.10893.1.20.130.9.1.2'  => 'powerSupplyName',
2254              '1.3.6.1.4.1.674.10893.1.20.130.9.1.4'  => 'powerSupplyState',
2255              '1.3.6.1.4.1.674.10893.1.20.130.9.1.9'  => 'powerSupplyComponentStatus',
2256              '1.3.6.1.4.1.674.10893.1.20.130.9.1.10' => 'powerSupplyNexusID',
2257              '1.3.6.1.4.1.674.10893.1.20.130.10.1.4' => 'powerSupplyConnectionEnclosureName',
2258              '1.3.6.1.4.1.674.10893.1.20.130.10.1.5' => 'powerSupplyConnectionEnclosureNumber',
2259             );
2260         my $result = undef;
2261         if ($opt{use_get_table}) {
2262             my $powerSupplyTable = '1.3.6.1.4.1.674.10893.1.20.130.9';
2263             my $powerSupplyConnectionTable = '1.3.6.1.4.1.674.10893.1.20.130.10';
2264
2265             $result = $snmp_session->get_table(-baseoid => $powerSupplyTable);
2266             my $ext = $snmp_session->get_table(-baseoid => $powerSupplyConnectionTable);
2267
2268             if (defined $result) {
2269                 defined $ext && map { $$result{$_} = $$ext{$_} } keys %{ $ext };
2270             }
2271         }
2272         else {
2273             $result = $snmp_session->get_entries(-columns => [keys %ps_oid]);
2274         }
2275
2276         # No enclosure power supplies is OK
2277         return if !defined $result;
2278
2279         @output = @{ get_snmp_output($result, \%ps_oid) };
2280     }
2281     else {
2282         foreach my $enc (@enclosures) {
2283             push @output, @{ run_omreport("storage enclosure controller=$enc->{ctrl} enclosure=$enc->{id} info=pwrsupplies") };
2284             map_item('ctrl', $enc->{ctrl}, \@output);
2285             map_item('encl_id', $enc->{id}, \@output);
2286             map_item('encl_name', $enc->{name}, \@output);
2287         }
2288     }
2289
2290     my %ps_state
2291       = (
2292          0  => 'Unknown',
2293          1  => 'Ready',
2294          2  => 'Failed',
2295          5  => 'Not Installed',
2296          6  => 'Degraded',
2297          11 => 'Removed',
2298          21 => 'Missing',
2299         );
2300
2301     # Check power supplies on each of the enclosures
2302   PS:
2303     foreach my $out (@output) {
2304         if ($snmp) {
2305             $name      = $out->{powerSupplyName} || 'Unknown PSU';
2306             $state     = get_hashval($out->{powerSupplyState}, \%ps_state) || 'Unknown state';
2307             $status    = get_snmp_status($out->{powerSupplyComponentStatus});
2308             $encl_id   = $snmp_enclosure{$out->{powerSupplyConnectionEnclosureNumber}}{nexus};
2309             $encl_name = $out->{powerSupplyConnectionEnclosureName} || 'Unknown enclosure';
2310             $nexus     = convert_nexus(($out->{powerSupplyNexusID} || 9999));
2311         }
2312         else {
2313             $name      = get_nonempty_string('Name', $out, 'Unknown PSU');
2314             $state     = get_nonempty_string('State', $out, 'Unknown state');
2315             $status    = get_nonempty_string('Status', $out, 'Unknown');
2316             $encl_id   = join q{:}, $out->{ctrl}, $out->{'encl_id'};
2317             $encl_name = $out->{encl_name};
2318             $nexus     = join q{:}, $out->{ctrl}, $out->{'encl_id'}, get_nonempty_string('ID', $out, '9999');
2319         }
2320
2321         next PS if blacklisted('encl_ps', $nexus);
2322
2323         # Default
2324         if ($status ne 'Ok') {
2325             my $msg = sprintf '%s in enclosure %s [%s] needs attention: %s',
2326               $name, $encl_id, $encl_name, $state;
2327             report('storage', $msg, $status2nagios{$status}, $nexus);
2328         }
2329         # Ok
2330         else {
2331             my $msg = sprintf '%s in enclosure %s [%s] is %s',
2332               $name, $encl_id, $encl_name, $state;
2333             report('storage', $msg, $E_OK, $nexus);
2334         }
2335     }
2336     return;
2337 }
2338
2339
2340 #-----------------------------------------
2341 # STORAGE: Check enclosure temperatures
2342 #-----------------------------------------
2343 sub check_enclosure_temp {
2344     return if $#controllers == -1;
2345
2346     my $nexus     = undef;
2347     my $name      = undef;
2348     my $state     = undef;
2349     my $status    = undef;
2350     my $reading   = undef;
2351     my $unit      = undef;
2352     my $max_warn  = undef;
2353     my $max_crit  = undef;
2354     my $min_warn  = undef;
2355     my $min_crit  = undef;
2356     my $encl_id   = undef;
2357     my $encl_name = undef;
2358     my @output    = ();
2359
2360     if ($snmp) {
2361         my %temp_oid
2362           = (
2363              '1.3.6.1.4.1.674.10893.1.20.130.11.1.2'  => 'temperatureProbeName',
2364              '1.3.6.1.4.1.674.10893.1.20.130.11.1.4'  => 'temperatureProbeState',
2365              '1.3.6.1.4.1.674.10893.1.20.130.11.1.6'  => 'temperatureProbeUnit',
2366              '1.3.6.1.4.1.674.10893.1.20.130.11.1.7'  => 'temperatureProbeMinWarning',
2367              '1.3.6.1.4.1.674.10893.1.20.130.11.1.8'  => 'temperatureProbeMinCritical',
2368              '1.3.6.1.4.1.674.10893.1.20.130.11.1.9'  => 'temperatureProbeMaxWarning',
2369              '1.3.6.1.4.1.674.10893.1.20.130.11.1.10' => 'temperatureProbeMaxCritical',
2370              '1.3.6.1.4.1.674.10893.1.20.130.11.1.11' => 'temperatureProbeCurValue',
2371              '1.3.6.1.4.1.674.10893.1.20.130.11.1.13' => 'temperatureProbeComponentStatus',
2372              '1.3.6.1.4.1.674.10893.1.20.130.11.1.14' => 'temperatureProbeNexusID',
2373              '1.3.6.1.4.1.674.10893.1.20.130.12.1.4'  => 'temperatureConnectionEnclosureName',
2374              '1.3.6.1.4.1.674.10893.1.20.130.12.1.5'  => 'temperatureConnectionEnclosureNumber',
2375             );
2376         my $result = undef;
2377         if ($opt{use_get_table}) {
2378             my $temperatureProbeTable = '1.3.6.1.4.1.674.10893.1.20.130.11';
2379             my $temperatureConnectionTable = '1.3.6.1.4.1.674.10893.1.20.130.12';
2380
2381             $result = $snmp_session->get_table(-baseoid => $temperatureProbeTable);
2382             my $ext = $snmp_session->get_table(-baseoid => $temperatureConnectionTable);
2383
2384             if (defined $result) {
2385                 defined $ext && map { $$result{$_} = $$ext{$_} } keys %{ $ext };
2386             }
2387         }
2388         else {
2389             $result = $snmp_session->get_entries(-columns => [keys %temp_oid]);
2390         }
2391
2392         # No enclosure temperature probes is OK
2393         return if !defined $result;
2394
2395         @output = @{ get_snmp_output($result, \%temp_oid) };
2396     }
2397     else {
2398         foreach my $enc (@enclosures) {
2399             push @output, @{ run_omreport("storage enclosure controller=$enc->{ctrl} enclosure=$enc->{id} info=temps") };
2400             map_item('ctrl', $enc->{ctrl}, \@output);
2401             map_item('encl_id', $enc->{id}, \@output);
2402             map_item('encl_name', $enc->{name}, \@output);
2403         }
2404     }
2405
2406     my %temp_state
2407       = (
2408          0  => 'Unknown',
2409          1  => 'Ready',
2410          2  => 'Failed',
2411          4  => 'Offline',
2412          6  => 'Degraded',
2413          9  => 'Inactive',
2414          21 => 'Missing',
2415         );
2416
2417     # Check temperature probes on each of the enclosures
2418   TEMP:
2419     foreach my $out (@output) {
2420         if ($snmp) {
2421             $name      = $out->{temperatureProbeName} || 'Unknown temp probe';
2422             $state     = get_hashval($out->{temperatureProbeState}, \%temp_state) || 'Unknown state';
2423             $status    = get_snmp_probestatus($out->{temperatureProbeComponentStatus});
2424             $unit      = $out->{temperatureProbeUnit} || 'Unknown unit';
2425             $reading   = $out->{temperatureProbeCurValue} || '[N/A]';
2426             $max_warn  = $out->{temperatureProbeMaxWarning} || '[N/A]';
2427             $max_crit  = $out->{temperatureProbeMaxCritical} || '[N/A]';
2428             $min_warn  = $out->{temperatureProbeMinWarning} || '[N/A]';
2429             $min_crit  = $out->{temperatureProbeMinCritical} || '[N/A]';
2430             $encl_id   = $snmp_enclosure{$out->{temperatureConnectionEnclosureNumber}}{nexus};
2431             $encl_name = $out->{temperatureConnectionEnclosureName} || 'Unknown enclosure';
2432             $nexus     = convert_nexus(($out->{temperatureProbeNexusID} || 9999));
2433         }
2434         else {
2435             $name      = get_nonempty_string('Name', $out, 'Unknown temp probe');
2436             $state     = get_nonempty_string('State', $out, 'Unknown state');
2437             $status    = get_nonempty_string('Status', $out, 'Unknown');
2438             $unit      = 'FIXME';
2439             $reading   = get_nonempty_string('Reading', $out, '[N/A]');
2440             $max_warn  = get_nonempty_string('Maximum Warning Threshold', $out, '[N/A]');
2441             $max_crit  = get_nonempty_string('Maximum Failure Threshold', $out, '[N/A]');
2442             $min_warn  = get_nonempty_string('Minimum Warning Threshold', $out, '[N/A]');
2443             $min_crit  = get_nonempty_string('Minimum Failure Threshold', $out, '[N/A]');
2444             $encl_id   = join q{:}, $out->{ctrl}, $out->{'encl_id'};
2445             $encl_name = $out->{encl_name};
2446             $nexus     = join q{:}, $out->{ctrl}, $out->{'encl_id'}, get_nonempty_string('ID', $out, '9999');
2447         }
2448
2449         next TEMP if blacklisted('encl_temp', $nexus);
2450
2451         # Make sure these values are integers
2452         $reading  =~ s{\A \s* (-?\d+) \s* C? \s* \z}{$1}xms or $reading  = '[N/A]';
2453         $max_warn =~ s{\A \s* (-?\d+) \s* C? \s* \z}{$1}xms or $max_warn = '[N/A]';
2454         $max_crit =~ s{\A \s* (-?\d+) \s* C? \s* \z}{$1}xms or $max_crit = '[N/A]';
2455         $min_warn =~ s{\A \s* (-?\d+) \s* C? \s* \z}{$1}xms or $min_warn = '[N/A]';
2456         $min_crit =~ s{\A \s* (-?\d+) \s* C? \s* \z}{$1}xms or $min_crit = '[N/A]';
2457
2458         # Inactive temp probes
2459         if ($status eq 'Unknown' and $state eq 'Inactive') {
2460             my $msg = sprintf '%s in enclosure %s [%s] is %s',
2461               $name, $encl_id, $encl_name, $state;
2462             report('storage', $msg, $E_OK, $nexus);
2463         }
2464         elsif ($status ne 'Ok' and $max_crit ne '[N/A]' and $reading > $max_crit) {
2465             my $msg = sprintf '%s in enclosure %s [%s] is critically high at %d C',
2466               $name, $encl_id, $encl_name, $reading;
2467             my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
2468             report('chassis', $msg, $err, $nexus);
2469         }
2470         elsif ($status ne 'Ok' and $max_warn ne '[N/A]' and $reading > $max_warn) {
2471             my $msg = sprintf '%s in enclosure %s [%s] is too high at %d C',
2472               $name, $encl_id, $encl_name, $reading;
2473             my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
2474             report('chassis', $msg, $err, $nexus);
2475         }
2476         elsif ($status ne 'Ok' and $min_crit ne '[N/A]' and $reading < $min_crit) {
2477             my $msg = sprintf '%s in enclosure %s [%s] is critically low at %d C',
2478               $name, $encl_id, $encl_name, $reading;
2479             my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
2480             report('chassis', $msg, $err, $nexus);
2481         }
2482         elsif ($status ne 'Ok' and $min_warn ne '[N/A]' and $reading < $min_warn) {
2483             my $msg = sprintf '%s in enclosure %s [%s] is too low at %d C',
2484               $name, $encl_id, $encl_name, $reading;
2485             my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
2486             report('chassis', $msg, $err, $nexus);
2487         }
2488         # Default
2489         elsif ($status ne 'Ok') {
2490             my $msg = sprintf '%s in enclosure %s [%s] is %s',
2491               $name, $encl_id, $encl_name, $state;
2492             if (defined $reading && $reading =~ m{\A -?\d+ \z}xms) {
2493                 # take into account that with certain states the
2494                 # reading doesn't exist or is not an integer
2495                 $msg .= sprintf ' at %s C', $reading;
2496                 if ($min_warn eq '[N/A]' or $min_crit eq '[N/A]') {
2497                     $msg .= sprintf ' (max=%s/%s)', $max_warn, $max_crit;
2498                 }
2499                 else {
2500                     $msg .= sprintf ' (min=%s/%s, max=%s/%s)',
2501                       $min_warn, $min_crit, $max_warn, $max_crit;
2502                 }
2503             }
2504             my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
2505             report('storage', $msg, $err, $nexus);
2506         }
2507         # Ok
2508         else {
2509             my $msg = sprintf '%s in enclosure %s [%s]',
2510               $name, $encl_id, $encl_name;
2511             if (defined $reading && $reading ne '[N/A]') {
2512                 # take into account that with certain states the
2513                 # reading doesn't exist or is not an integer
2514                 $msg .= sprintf ' reads %d C', $reading;
2515                 if ($min_warn eq '[N/A]' or $min_crit eq '[N/A]') {
2516                     $msg .= sprintf ' (max=%s/%s)', $max_warn, $max_crit;
2517                 }
2518                 else {
2519                     $msg .= sprintf ' (min=%s/%s, max=%s/%s)',
2520                       $min_warn, $min_crit, $max_warn, $max_crit;
2521                 }
2522             }
2523             else {
2524                 $msg .= sprintf ' is %s', $state;
2525             }
2526             report('storage', $msg, $E_OK, $nexus);
2527         }
2528
2529         # Collect performance data
2530         if (defined $opt{perfdata} && $reading ne '[N/A]') {
2531             $name =~ s{\A Temperature\sProbe\s(\d+) \z}{temp_$1}gxms;
2532             my $label = "${name}";
2533             my $mini = $label;
2534             $mini =~ s{temp_}{t}xms;
2535             push @perfdata, {
2536                              type  => 'E',
2537                              id    => $encl_id,
2538                              unit  => 'C',
2539                              label => $label,
2540                              mini  => $mini,
2541                              value => $reading,
2542                              warn  => $max_warn,
2543                              crit  => $max_crit,
2544                             };
2545         }
2546     }
2547     return;
2548 }
2549
2550
2551 #-----------------------------------------
2552 # STORAGE: Check enclosure management modules (EMM)
2553 #-----------------------------------------
2554 sub check_enclosure_emms {
2555     return if $#controllers == -1;
2556
2557     my $nexus     = undef;
2558     my $name      = undef;
2559     my $state     = undef;
2560     my $status    = undef;
2561     my $encl_id   = undef;
2562     my $encl_name = undef;
2563     my @output    = ();
2564
2565     if ($snmp) {
2566         my %emms_oid
2567           = (
2568              '1.3.6.1.4.1.674.10893.1.20.130.13.1.2'  => 'enclosureManagementModuleName',
2569              '1.3.6.1.4.1.674.10893.1.20.130.13.1.4'  => 'enclosureManagementModuleState',
2570              '1.3.6.1.4.1.674.10893.1.20.130.13.1.11' => 'enclosureManagementModuleComponentStatus',
2571              '1.3.6.1.4.1.674.10893.1.20.130.13.1.12' => 'enclosureManagementModuleNexusID',
2572              '1.3.6.1.4.1.674.10893.1.20.130.14.1.4'  => 'enclosureManagementModuleConnectionEnclosureName',
2573              '1.3.6.1.4.1.674.10893.1.20.130.14.1.5'  => 'enclosureManagementModuleConnectionEnclosureNumber',
2574             );
2575         my $result = undef;
2576         if ($opt{use_get_table}) {
2577             my $enclosureManagementModuleTable = '1.3.6.1.4.1.674.10893.1.20.130.13';
2578             my $enclosureManagementModuleConnectionTable = '1.3.6.1.4.1.674.10893.1.20.130.14';
2579
2580             $result = $snmp_session->get_table(-baseoid => $enclosureManagementModuleTable);
2581             my $ext = $snmp_session->get_table(-baseoid => $enclosureManagementModuleConnectionTable);
2582
2583             if (defined $result) {
2584                 defined $ext && map { $$result{$_} = $$ext{$_} } keys %{ $ext };
2585             }
2586         }
2587         else {
2588             $result = $snmp_session->get_entries(-columns => [keys %emms_oid]);
2589         }
2590
2591         # No enclosure EMMs is OK
2592         return if !defined $result;
2593
2594         @output = @{ get_snmp_output($result, \%emms_oid) };
2595     }
2596     else {
2597         foreach my $enc (@enclosures) {
2598             push @output, @{ run_omreport("storage enclosure controller=$enc->{ctrl} enclosure=$enc->{id} info=emms") };
2599             map_item('ctrl', $enc->{ctrl}, \@output);
2600             map_item('encl_id', $enc->{id}, \@output);
2601             map_item('encl_name', $enc->{name}, \@output);
2602         }
2603     }
2604
2605     my %emms_state
2606       = (
2607          0  => 'Unknown',
2608          1  => 'Ready',
2609          2  => 'Failed',
2610          3  => 'Online',
2611          4  => 'Offline',
2612          5  => 'Not Installed',
2613          6  => 'Degraded',
2614          21 => 'Missing',
2615         );
2616
2617     # Check EMMs on each of the enclosures
2618   EMM:
2619     foreach my $out (@output) {
2620         if ($snmp) {
2621             $name      = $out->{enclosureManagementModuleName} || 'Unknown EMM';
2622             $state     = get_hashval($out->{enclosureManagementModuleState}, \%emms_state) || 'Unknown state';
2623             $status    = get_snmp_status($out->{enclosureManagementModuleComponentStatus});
2624             $encl_id   = $snmp_enclosure{$out->{enclosureManagementModuleConnectionEnclosureNumber}}{nexus};
2625             $encl_name = $out->{enclosureManagementModuleConnectionEnclosureName} || 'Unknown enclosure';
2626             $nexus     = convert_nexus(($out->{enclosureManagementModuleNexusID} || 9999));
2627         }
2628         else {
2629             $name      = get_nonempty_string('Name', $out, 'Unknown EMM');
2630             $state     = get_nonempty_string('State', $out, 'Unknown state');
2631             $status    = get_nonempty_string('Status', $out, 'Unknown');
2632             $encl_id   = join q{:}, $out->{ctrl}, $out->{'encl_id'};
2633             $encl_name = $out->{encl_name};
2634             $nexus     = join q{:}, $out->{ctrl}, $out->{'encl_id'}, get_nonempty_string('ID', $out, '9999');
2635         }
2636
2637         next EMM if blacklisted('encl_emm', $nexus);
2638
2639         # Not installed
2640         if ($status =~ m{\A Other|Unknown \z}xms and $state eq 'Not Installed') {
2641             my $msg = sprintf '%s in enclosure %s [%s] is %s',
2642               $name, $encl_id, $encl_name, $state;
2643             report('storage', $msg, $E_OK, $nexus);
2644         }
2645         # Default
2646         elsif ($status ne 'Ok') {
2647             my $msg = sprintf '%s in enclosure %s [%s] needs attention: %s',
2648               $name, $encl_id, $encl_name, $state;
2649             report('storage', $msg, $status2nagios{$status}, $nexus);
2650         }
2651         # Ok
2652         else {
2653             my $msg = sprintf '%s in enclosure %s [%s] is %s',
2654               $name, $encl_id, $encl_name, $state;
2655             report('storage', $msg, $E_OK, $nexus);
2656         }
2657     }
2658     return;
2659 }
2660
2661
2662 #-----------------------------------------
2663 # CHASSIS: Check memory modules
2664 #-----------------------------------------
2665 sub check_memory {
2666     my $index    = undef;
2667     my $status   = undef;
2668     my $location = undef;
2669     my $size     = undef;
2670     my $modes    = undef;
2671     my @failures = ();
2672     my @output   = ();
2673
2674     if ($snmp) {
2675         my %dimm_oid
2676           = (
2677              '1.3.6.1.4.1.674.10892.1.1100.50.1.2.1'  => 'memoryDeviceIndex',
2678              '1.3.6.1.4.1.674.10892.1.1100.50.1.5.1'  => 'memoryDeviceStatus',
2679              '1.3.6.1.4.1.674.10892.1.1100.50.1.8.1'  => 'memoryDeviceLocationName',
2680              '1.3.6.1.4.1.674.10892.1.1100.50.1.14.1' => 'memoryDeviceSize',
2681              '1.3.6.1.4.1.674.10892.1.1100.50.1.20.1' => 'memoryDeviceFailureModes',
2682             );
2683         my $result = undef;
2684         if ($opt{use_get_table}) {
2685             my $memoryDeviceTable = '1.3.6.1.4.1.674.10892.1.1100.50.1';
2686             $result = $snmp_session->get_table(-baseoid => $memoryDeviceTable);
2687         }
2688         else {
2689             $result = $snmp_session->get_entries(-columns => [keys %dimm_oid]);
2690         }
2691
2692         if (!defined $result) {
2693             printf "SNMP ERROR [memory]: %s.\n", $snmp_session->error;
2694             $snmp_session->close;
2695             exit $E_UNKNOWN;
2696         }
2697
2698         @output = @{ get_snmp_output($result, \%dimm_oid) };
2699     }
2700     else {
2701         @output = @{ run_omreport("$omopt_chassis memory") };
2702     }
2703
2704     # Note: These values are bit masks, so combination values are
2705     # possible. If value is 0 (zero), memory device has no faults.
2706     my %failure_mode
2707       = (
2708          1  => 'ECC single bit correction warning rate exceeded',
2709          2  => 'ECC single bit correction failure rate exceeded',
2710          4  => 'ECC multibit fault encountered',
2711          8  => 'ECC single bit correction logging disabled',
2712          16 => 'device disabled because of spare activation',
2713         );
2714
2715   DIMM:
2716     foreach my $out (@output) {
2717         @failures = ();  # Initialize
2718         if ($snmp) {
2719             $index    = ($out->{memoryDeviceIndex} || 10000) - 1;
2720             $status   = get_snmp_status($out->{memoryDeviceStatus});
2721             $location = $out->{memoryDeviceLocationName} || 'Unknown location';
2722             $size     = sprintf '%d MB', ($out->{memoryDeviceSize} || 0)/1024;
2723             $modes    = $out->{memoryDeviceFailureModes} || -9999;
2724             if ($modes > 0) {
2725                 foreach my $mask (sort keys %failure_mode) {
2726                     if (($modes & $mask) != 0) { push @failures, $failure_mode{$mask}; }
2727                 }
2728             }
2729             elsif ($modes == -9999) {
2730                 push @failures, q{ERROR: Failure modes not available via SNMP};
2731             }
2732         }
2733         else {
2734             my $type  = get_nonempty_string('Type', $out, q{});
2735             $index    = $type eq '[Not Occupied]' ? undef : get_nonempty_string('Index', $out, 9999);
2736             $status   = get_nonempty_string('Status', $out, 'Unknown');
2737             $location = get_nonempty_string('Connector Name', $out, 'Unknown location');
2738             $size     = get_nonempty_string('Size', $out, 0);
2739             if (defined $size) {
2740                 $size =~ s{\s\s}{ }gxms;
2741             }
2742             # Run 'omreport chassis memory index=X' to get the failures
2743             if ($status ne 'Ok' && defined $index) {
2744                 foreach (@{ run_command("$omreport $omopt_chassis memory index=$index -fmt ssv") }) {
2745                     if (m/\A Failures; (.+?) \z/xms) {
2746                         chop(my $fail = $1);
2747                         push @failures, split m{\.}xms, $fail;
2748                     }
2749                 }
2750             }
2751         }
2752         $location =~ s{\A \s*(.*?)\s* \z}{$1}xms;
2753
2754         # calculate total memory
2755         my $msize = defined $size ? $size : 0;
2756         $msize =~ s{\A (\d+) \s MB}{$1}xms;
2757         $count{mem} += $msize;
2758
2759         # Ignore empty memory slots
2760         next DIMM if !defined $index;
2761
2762         $count{dimm}++;
2763         next DIMM if blacklisted('dimm', $index);
2764
2765         if ($status ne 'Ok') {
2766             my $msg = undef;
2767             if (scalar @failures == 0) {
2768                 $msg = sprintf 'Memory module %d [%s, %s] needs attention (%s)',
2769                   $index, $location, $size, $status;
2770             }
2771             else {
2772                 $msg = sprintf 'Memory module %d [%s, %s] needs attention: %s',
2773                   $index, $location, $size, (join q{, }, @failures);
2774             }
2775
2776             report('chassis', $msg, $status2nagios{$status}, $index);
2777         }
2778         # Ok
2779         else {
2780             my $msg = sprintf 'Memory module %d [%s, %s] is %s',
2781               $index, $location, $size, $status;
2782             report('chassis', $msg, $E_OK, $index);
2783         }
2784     }
2785     return;
2786 }
2787
2788
2789 #-----------------------------------------
2790 # CHASSIS: Check fans
2791 #-----------------------------------------
2792 sub check_fans {
2793     my $index    = undef;
2794     my $status   = undef;
2795     my $reading  = undef;
2796     my $location = undef;
2797     my $max_crit = undef;
2798     my $max_warn = undef;
2799     my @output   = ();
2800
2801     if ($snmp) {
2802         my %cool_oid
2803           = (
2804              '1.3.6.1.4.1.674.10892.1.700.12.1.2.1'  => 'coolingDeviceIndex',
2805              '1.3.6.1.4.1.674.10892.1.700.12.1.5.1'  => 'coolingDeviceStatus',
2806              '1.3.6.1.4.1.674.10892.1.700.12.1.6.1'  => 'coolingDeviceReading',
2807              '1.3.6.1.4.1.674.10892.1.700.12.1.8.1'  => 'coolingDeviceLocationName',
2808              '1.3.6.1.4.1.674.10892.1.700.12.1.10.1' => 'coolingDeviceUpperCriticalThreshold',
2809              '1.3.6.1.4.1.674.10892.1.700.12.1.11.1' => 'coolingDeviceUpperNonCriticalThreshold',
2810             );
2811         my $result = undef;
2812         if ($opt{use_get_table}) {
2813             my $coolingDeviceTable = '1.3.6.1.4.1.674.10892.1.700.12.1';
2814             $result = $snmp_session->get_table(-baseoid => $coolingDeviceTable);
2815         }
2816         else {
2817             $result = $snmp_session->get_entries(-columns => [keys %cool_oid]);
2818         }
2819
2820         if ($blade && !defined $result) {
2821             return 0;
2822         }
2823         elsif (!$blade && !defined $result) {
2824             printf "SNMP ERROR [cooling]: %s.\n", $snmp_session->error;
2825             $snmp_session->close;
2826             exit $E_UNKNOWN;
2827         }
2828
2829         @output = @{ get_snmp_output($result, \%cool_oid) };
2830     }
2831     else {
2832         @output = @{ run_omreport("$omopt_chassis fans") };
2833     }
2834
2835   FAN:
2836     foreach my $out (@output) {
2837         if ($snmp) {
2838             $index    = ($out->{coolingDeviceIndex} || 10000) - 1;
2839             $status   = get_snmp_probestatus($out->{coolingDeviceStatus});
2840             $reading  = $out->{coolingDeviceReading} || 0;
2841             $location = $out->{coolingDeviceLocationName} || 'Unknown location';
2842             $max_crit = $out->{coolingDeviceUpperCriticalThreshold} || 0;
2843             $max_warn = $out->{coolingDeviceUpperNonCriticalThreshold} || 0;
2844         }
2845         else {
2846             $index    = get_nonempty_string('Index', $out, 9999);
2847             $status   = get_nonempty_string('Status', $out, 'Unknown');
2848             $reading  = get_nonempty_string('Reading', $out, 0);
2849             $location = get_nonempty_string('Probe Name', $out, 'Unknown location');
2850             $max_crit = get_nonempty_string('Maximum Failure Threshold', $out, 0);
2851             $max_warn = get_nonempty_string('Maximum Warning Threshold', $out, 0);
2852             if ($max_crit eq '[N/A]') { $max_crit = 0; }
2853             if ($max_warn eq '[N/A]') { $max_warn = 0; }
2854             $reading  =~ s{\A (\d+).* \z}{$1}xms;
2855             $max_warn =~ s{\A (\d+).* \z}{$1}xms;
2856             $max_crit =~ s{\A (\d+).* \z}{$1}xms;
2857         }
2858
2859         $count{fan}++;
2860         next FAN if blacklisted('fan', $index);
2861
2862         if ($status ne 'Ok') {
2863             my $msg = sprintf 'Chassis fan %d [%s] needs attention: %s',
2864               $index, $location, $status;
2865             my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
2866             report('chassis', $msg, $err, $index);
2867         }
2868         else {
2869             my $msg = sprintf 'Chassis fan %d [%s]: %s',
2870               $index, $location, $reading;
2871             report('chassis', $msg, $E_OK, $index);
2872         }
2873
2874         # Collect performance data
2875         if (defined $opt{perfdata}) {
2876             my $pname = $location;
2877             $pname =~ s{\s}{_}gxms;
2878             $pname =~ s{proc_}{cpu#}xms;
2879             $pname =~ s{_rpm\z}{}ixms;
2880             push @perfdata, {
2881                              type  => 'F',
2882                              id    => $index,
2883                              unit  => 'rpm',
2884                              label => $pname,
2885                              mini  => 'f',
2886                              value => $reading,
2887                              warn  => $max_warn,
2888                              crit  => $max_crit,
2889                             };
2890         }
2891     }
2892     return;
2893 }
2894
2895
2896 #-----------------------------------------
2897 # CHASSIS: Check power supplies
2898 #-----------------------------------------
2899 sub check_powersupplies {
2900     my $index    = undef;
2901     my $status   = undef;
2902     my $type     = undef;
2903     my $err_type = undef;
2904     my $state    = undef;
2905     my @states   = ();
2906     my @output   = ();
2907
2908     if ($snmp) {
2909         my %ps_oid
2910           = (
2911              '1.3.6.1.4.1.674.10892.1.600.12.1.2.1'  => 'powerSupplyIndex',
2912              '1.3.6.1.4.1.674.10892.1.600.12.1.5.1'  => 'powerSupplyStatus',
2913              '1.3.6.1.4.1.674.10892.1.600.12.1.7.1'  => 'powerSupplyType',
2914              '1.3.6.1.4.1.674.10892.1.600.12.1.11.1' => 'powerSupplySensorState',
2915              '1.3.6.1.4.1.674.10892.1.600.12.1.12.1' => 'powerSupplyConfigurationErrorType',
2916             );
2917         my $result = undef;
2918         if ($opt{use_get_table}) {
2919             my $powerDeviceTable = '1.3.6.1.4.1.674.10892.1.600.12.1';
2920             $result = $snmp_session->get_table(-baseoid => $powerDeviceTable);
2921         }
2922         else {
2923             $result = $snmp_session->get_entries(-columns => [keys %ps_oid]);
2924         }
2925
2926         # No instrumented PSU is OK (blades, low-end servers)
2927         return 0 if !defined $result;
2928
2929         @output = @{ get_snmp_output($result, \%ps_oid) };
2930     }
2931     else {
2932         @output = @{ run_omreport("$omopt_chassis pwrsupplies") };
2933     }
2934
2935     my %ps_type
2936       = (
2937          1  => 'Other',
2938          2  => 'Unknown',
2939          3  => 'Linear',
2940          4  => 'Switching',
2941          5  => 'Battery',
2942          6  => 'Uninterruptible Power Supply',
2943          7  => 'Converter',
2944          8  => 'Regulator',
2945          9  => 'AC',
2946          10 => 'DC',
2947          11 => 'VRM',
2948         );
2949
2950     my %ps_state
2951       = (
2952          1  => 'Presence detected',
2953          2  => 'Failure detected',
2954          4  => 'Predictive Failure',
2955          8  => 'AC lost',
2956          16 => 'AC lost or out-of-range',
2957          32 => 'AC out-of-range but present',
2958          64 => 'Configuration error',
2959         );
2960
2961     my %ps_config_error_type
2962       = (
2963          1 => 'Vendor mismatch',
2964          2 => 'Revision mismatch',
2965          3 => 'Processor missing',
2966         );
2967
2968   PS:
2969     foreach my $out (@output) {
2970         if ($snmp) {
2971             @states = ();  # contains states for the PS
2972
2973             $index    = ($out->{powerSupplyIndex} || 10000) - 1;
2974             $status   = get_snmp_status($out->{powerSupplyStatus});
2975             $type     = get_hashval($out->{powerSupplyType}, \%ps_type) || 'Unknown type';
2976             $err_type = get_hashval($out->{powerSupplyConfigurationErrorType}, \%ps_config_error_type);
2977
2978             # get the combined state from the StatusReading OID
2979             my $raw_state = $out->{powerSupplySensorState} || 0;
2980             foreach my $mask (sort keys %ps_state) {
2981                 if (($raw_state & $mask) != 0) {
2982                     push @states, $ps_state{$mask};
2983                 }
2984             }
2985
2986             # If configuration error, also include the error type
2987             if (defined $err_type) {
2988                 push @states, $err_type;
2989             }
2990
2991             # Finally, construct the state string
2992             $state = join q{, }, @states;
2993         }
2994         else {
2995             $index  = get_nonempty_string('Index', $out, 9999);
2996             $status = get_nonempty_string('Status', $out, 'Unknown');
2997             $type   = get_nonempty_string('Type', $out, 'Unknown type');
2998             $state  = get_nonempty_string('Online Status', $out, 'Unknown state');
2999         }
3000
3001         $count{power}++;
3002         next PS if blacklisted('ps', $index);
3003
3004         if ($status ne 'Ok') {
3005             my $msg = sprintf 'Power Supply %d [%s] needs attention: %s',
3006               $index, $type, $state;
3007             report('chassis', $msg, $status2nagios{$status}, $index);
3008         }
3009         else {
3010             my $msg = sprintf 'Power Supply %d [%s]: %s',
3011               $index, $type, $state;
3012             report('chassis', $msg, $E_OK, $index);
3013         }
3014     }
3015     return;
3016 }
3017
3018
3019 #-----------------------------------------
3020 # CHASSIS: Check temperatures
3021 #-----------------------------------------
3022 sub check_temperatures {
3023     my $index    = undef;
3024     my $status   = undef;
3025     my $reading  = undef;
3026     my $location = undef;
3027     my $max_crit = undef;
3028     my $max_warn = undef;
3029     my $min_warn = undef;
3030     my $min_crit = undef;
3031     my $type     = undef;
3032     my $discrete = undef;
3033     my @output = ();
3034
3035     # Getting custom temperature thresholds (user option)
3036     my %warn_threshold = %{ custom_temperature_thresholds('w') };
3037     my %crit_threshold = %{ custom_temperature_thresholds('c') };
3038
3039     if ($snmp) {
3040         my %temp_oid
3041           = (
3042              '1.3.6.1.4.1.674.10892.1.700.20.1.2.1'  => 'temperatureProbeIndex',
3043              '1.3.6.1.4.1.674.10892.1.700.20.1.5.1'  => 'temperatureProbeStatus',
3044              '1.3.6.1.4.1.674.10892.1.700.20.1.6.1'  => 'temperatureProbeReading',
3045              '1.3.6.1.4.1.674.10892.1.700.20.1.7.1'  => 'temperatureProbeType',
3046              '1.3.6.1.4.1.674.10892.1.700.20.1.8.1'  => 'temperatureProbeLocationName',
3047              '1.3.6.1.4.1.674.10892.1.700.20.1.10.1' => 'temperatureProbeUpperCriticalThreshold',
3048              '1.3.6.1.4.1.674.10892.1.700.20.1.11.1' => 'temperatureProbeUpperNonCriticalThreshold',
3049              '1.3.6.1.4.1.674.10892.1.700.20.1.12.1' => 'temperatureProbeLowerNonCriticalThreshold',
3050              '1.3.6.1.4.1.674.10892.1.700.20.1.13.1' => 'temperatureProbeLowerCriticalThreshold',
3051              '1.3.6.1.4.1.674.10892.1.700.20.1.16.1' => 'temperatureProbeDiscreteReading',
3052             );
3053         # this didn't work well for some reason
3054         #my $result = $snmp_session->get_entries(-columns => [keys %temp_oid]);
3055
3056         # Getting values using the table
3057         my $temperatureProbeTable = '1.3.6.1.4.1.674.10892.1.700.20';
3058         my $result = $snmp_session->get_table(-baseoid => $temperatureProbeTable);
3059
3060         if (!defined $result) {
3061             printf "SNMP ERROR [temperatures]: %s.\n", $snmp_session->error;
3062             $snmp_session->close;
3063             exit $E_UNKNOWN;
3064         }
3065
3066         @output = @{ get_snmp_output($result, \%temp_oid) };
3067     }
3068     else {
3069         @output = @{ run_omreport("$omopt_chassis temps") };
3070     }
3071
3072     my %probe_type
3073       = (
3074          1  => 'Other',      # type is other than following values
3075          2  => 'Unknown',    # type is unknown
3076          3  => 'AmbientESM', # type is Ambient Embedded Systems Management temperature probe
3077          16 => 'Discrete',   # type is temperature probe with discrete reading
3078         );
3079
3080   TEMP:
3081     foreach my $out (@output) {
3082         if ($snmp) {
3083             $index    = ($out->{temperatureProbeIndex} || 10000) - 1;
3084             $status   = get_snmp_probestatus($out->{temperatureProbeStatus});
3085             $location = $out->{temperatureProbeLocationName} || 'Unknown location';
3086             $type     = get_hashval($out->{temperatureProbeType}, \%probe_type);
3087             $reading  = $out->{temperatureProbeReading} || '[N/A]';
3088             $max_crit = $out->{temperatureProbeUpperCriticalThreshold} || '[N/A]';
3089             $max_warn = $out->{temperatureProbeUpperNonCriticalThreshold} || '[N/A]';
3090             $min_crit = $out->{temperatureProbeLowerCriticalThreshold} || '[N/A]';
3091             $min_warn = $out->{temperatureProbeLowerNonCriticalThreshold} || '[N/A]';
3092             $discrete = $out->{temperatureProbeDiscreteReading} || '[N/A]';
3093
3094             # If numeric values, i.e. not discrete
3095             $reading  /= 10 if $reading  =~ m{\A \d+ \z}xms;
3096             $max_crit /= 10 if $max_crit =~ m{\A \d+ \z}xms;
3097             $max_warn /= 10 if $max_warn =~ m{\A \d+ \z}xms;
3098             $min_crit /= 10 if $min_crit =~ m{\A \d+ \z}xms;
3099             $min_warn /= 10 if $min_warn =~ m{\A \d+ \z}xms;
3100
3101             # workaround for bad temp probes
3102             if ($type eq 'AmbientESM' and $reading !~ m{\A \d+(\.\d+)? \z}xms) {
3103                 $type = 'Discrete';
3104             }
3105         }
3106         else {
3107             $index    = get_nonempty_string('Index', $out, 9999);
3108             $status   = get_nonempty_string('Status', $out, 'Unknown');
3109             $location = get_nonempty_string('Probe Name', $out, 'Unknown location');
3110             $reading  = get_nonempty_string('Reading', $out, '[N/A]');
3111             $max_crit = get_nonempty_string('Maximum Failure Threshold', $out, '[N/A]');
3112             $max_warn = get_nonempty_string('Maximum Warning Threshold', $out, '[N/A]');
3113             $min_crit = get_nonempty_string('Minimum Failure Threshold', $out, '[N/A]');
3114             $min_warn = get_nonempty_string('Minimum Warning Threshold', $out, '[N/A]');
3115
3116             # Cleaning the temp readings
3117             $reading =~ s{\.0\s+C}{}xms;
3118             $max_crit =~ s{\.0\s+C}{}xms;
3119             $max_warn =~ s{\.0\s+C}{}xms;
3120             $min_crit =~ s{\.0\s+C}{}xms;
3121             $min_warn =~ s{\.0\s+C}{}xms;
3122
3123             $type     = $reading =~ m{\A\d+\z}xms ? 'AmbientESM' : 'Discrete';
3124             $discrete = $reading;
3125         }
3126
3127         $count{temp}++;
3128         next TEMP if blacklisted('temp', $index);
3129
3130         if ($type eq 'Discrete') {
3131             my $msg = sprintf 'Temperature probe %d [%s] is %s',
3132               $index, $location, $discrete;
3133             my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
3134             report('chassis', $msg, $err, $index);
3135         }
3136         else {
3137             # First check according to custom thresholds
3138             if (exists $crit_threshold{$index}{max} and $reading > $crit_threshold{$index}{max}) {
3139                 # Custom critical MAX
3140                 my $msg = sprintf 'Temperature Probe %d [%s] reads %d C (custom max=%d)',
3141                   $index, $location, $reading, $crit_threshold{$index}{max};
3142                 report('chassis', $msg, $E_CRITICAL, $index);
3143             }
3144             elsif (exists $warn_threshold{$index}{max} and $reading > $warn_threshold{$index}{max}) {
3145                 # Custom warning MAX
3146                 my $msg = sprintf 'Temperature Probe %d [%s] reads %d C (custom max=%d)',
3147                   $index, $location, $reading, $warn_threshold{$index}{max};
3148                 report('chassis', $msg, $E_WARNING, $index);
3149             }
3150             elsif (exists $crit_threshold{$index}{min} and $reading < $crit_threshold{$index}{min}) {
3151                 # Custom critical MIN
3152                 my $msg = sprintf 'Temperature Probe %d [%s] reads %d C (custom min=%d)',
3153                   $index, $location, $reading, $crit_threshold{$index}{min};
3154                 report('chassis', $msg, $E_CRITICAL, $index);
3155             }
3156             elsif (exists $warn_threshold{$index}{min} and $reading < $warn_threshold{$index}{min}) {
3157                 # Custom warning MIN
3158                 my $msg = sprintf 'Temperature Probe %d [%s] reads %d C (custom min=%d)',
3159                   $index, $location, $reading, $warn_threshold{$index}{min};
3160                 report('chassis', $msg, $E_WARNING, $index);
3161             }
3162             elsif ($status ne 'Ok' and $max_crit ne '[N/A]' and $reading > $max_crit) {
3163                 my $msg = sprintf 'Temperature Probe %d [%s] is critically high at %d C',
3164                   $index, $location, $reading;
3165                 my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
3166                 report('chassis', $msg, $err, $index);
3167             }
3168             elsif ($status ne 'Ok' and $max_warn ne '[N/A]' and $reading > $max_warn) {
3169                 my $msg = sprintf 'Temperature Probe %d [%s] is too high at %d C',
3170                   $index, $location, $reading;
3171                 my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
3172                 report('chassis', $msg, $err, $index);
3173             }
3174             elsif ($status ne 'Ok' and $min_crit ne '[N/A]' and $reading < $min_crit) {
3175                 my $msg = sprintf 'Temperature Probe %d [%s] is critically low at %d C',
3176                   $index, $location, $reading;
3177                 my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
3178                 report('chassis', $msg, $err, $index);
3179             }
3180             elsif ($status ne 'Ok' and $min_warn ne '[N/A]' and $reading < $min_warn) {
3181                 my $msg = sprintf 'Temperature Probe %d [%s] is too low at %d C',
3182                   $index, $location, $reading;
3183                 my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
3184                 report('chassis', $msg, $err, $index);
3185             }
3186             # Ok
3187             else {
3188                 my $msg = sprintf 'Temperature Probe %d [%s] reads %d C',
3189                   $index, $location, $reading;
3190                 if ($min_warn eq '[N/A]' and $min_crit eq '[N/A]') {
3191                     $msg .= sprintf ' (max=%s/%s)', $max_warn, $max_crit;
3192                 }
3193                 else {
3194                     $msg .= sprintf ' (min=%s/%s, max=%s/%s)',
3195                       $min_warn, $min_crit, $max_warn, $max_crit;
3196                 }
3197                 my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
3198                 report('chassis', $msg, $err, $index);
3199             }
3200
3201             # Collect performance data
3202             if (defined $opt{perfdata}) {
3203                 my $pname = $location;
3204                 $pname =~ s{\s}{_}gxms;
3205                 $pname =~ s{_temp\z}{}xms;
3206                 $pname =~ s{proc_}{cpu#}xms;
3207                 push @perfdata, {
3208                                  type  => 'T',
3209                                  id    => $index,
3210                                  unit  => 'C',
3211                                  label => $pname,
3212                                  mini  => 't',
3213                                  value => $reading,
3214                                  warn  => $max_warn,
3215                                  crit  => $max_crit,
3216                                 };
3217             }
3218         }
3219     }
3220     return;
3221 }
3222
3223
3224 #-----------------------------------------
3225 # CHASSIS: Check processors
3226 #-----------------------------------------
3227 sub check_processors {
3228     my $index   = undef;
3229     my $status  = undef;
3230     my $state   = undef;
3231     my $brand   = undef;
3232     my $family  = undef;
3233     my $man     = undef;
3234     my $speed   = undef;
3235     my @output = ();
3236
3237     if ($snmp) {
3238
3239         # NOTE: For some reason, older models don't have the
3240         # "Processor Device Status" OIDs. We check both the newer
3241         # (preferred) OIDs and the old ones.
3242
3243         my %cpu_oid
3244           = (
3245              '1.3.6.1.4.1.674.10892.1.1100.30.1.2.1'  => 'processorDeviceIndex',
3246              '1.3.6.1.4.1.674.10892.1.1100.30.1.5.1'  => 'processorDeviceStatus',
3247              '1.3.6.1.4.1.674.10892.1.1100.30.1.8.1'  => 'processorDeviceManufacturerName',
3248              '1.3.6.1.4.1.674.10892.1.1100.30.1.9.1'  => 'processorDeviceStatusState',
3249              '1.3.6.1.4.1.674.10892.1.1100.30.1.10.1' => 'processorDeviceFamily',
3250              '1.3.6.1.4.1.674.10892.1.1100.30.1.12.1' => 'processorDeviceCurrentSpeed',
3251              '1.3.6.1.4.1.674.10892.1.1100.30.1.23.1' => 'processorDeviceBrandName',
3252              '1.3.6.1.4.1.674.10892.1.1100.32.1.2.1'  => 'processorDeviceStatusIndex',
3253              '1.3.6.1.4.1.674.10892.1.1100.32.1.5.1'  => 'processorDeviceStatusStatus',
3254              '1.3.6.1.4.1.674.10892.1.1100.32.1.6.1'  => 'processorDeviceStatusReading',
3255             );
3256         my $result = undef;
3257         if ($opt{use_get_table}) {
3258             my $processorDeviceTable = '1.3.6.1.4.1.674.10892.1.1100.30.1';
3259             my $processorDeviceStatusTable = '1.3.6.1.4.1.674.10892.1.1100.32.1';
3260
3261             $result = $snmp_session->get_table(-baseoid => $processorDeviceTable);
3262             my $ext = $snmp_session->get_table(-baseoid => $processorDeviceStatusTable);
3263
3264             defined $ext && map { $$result{$_} = $$ext{$_} } keys %{ $ext };
3265         }
3266         else {
3267             $result = $snmp_session->get_entries(-columns => [keys %cpu_oid]);
3268         }
3269
3270         if (!defined $result) {
3271             printf "SNMP ERROR [processors]: %s.\n", $snmp_session->error;
3272             $snmp_session->close;
3273             exit $E_UNKNOWN;
3274         }
3275
3276         @output = @{ get_snmp_output($result, \%cpu_oid) };
3277     }
3278     else {
3279         @output = @{ run_omreport("$omopt_chassis processors") };
3280     }
3281
3282     my %cpu_state
3283       = (
3284          1 => 'Other',         # other than following values
3285          2 => 'Unknown',       # unknown
3286          3 => 'Enabled',       # enabled
3287          4 => 'User Disabled', # disabled by user via BIOS setup
3288          5 => 'BIOS Disabled', # disabled by BIOS (POST error)
3289          6 => 'Idle',          # idle
3290         );
3291
3292     my %cpu_reading
3293       = (
3294          1    => 'Internal Error',      # Internal Error
3295          2    => 'Thermal Trip',        # Thermal Trip
3296          32   => 'Configuration Error', # Configuration Error
3297          128  => 'Present',             # Processor Present
3298          256  => 'Disabled',            # Processor Disabled
3299          512  => 'Terminator Present',  # Terminator Present
3300          1024 => 'Throttled',           # Processor Throttled
3301         );
3302
3303     # Mapping between family numbers from SNMP and actual CPU family
3304     my %cpu_family
3305       = (
3306          1   => 'Other',                                2   => 'Unknown',
3307          3   => '8086',                                 4   => '80286',
3308          5   => '386',                                  6   => '486',
3309          7   => '8087',                                 8   => '80287',
3310          9   => '80387',                                10  => '80487',
3311          11  => 'Pentium',                              12  => 'Pentium Pro',
3312          13  => 'Pentium II',                           14  => 'Pentium with MMX',
3313          15  => 'Celeron',                              16  => 'Pentium II Xeon',
3314          17  => 'Pentium III',                          18  => 'Pentium III Xeon',
3315          19  => 'Pentium III',                          20  => 'Itanium',
3316          21  => 'Xeon',                                 22  => 'Pentium 4',
3317          23  => 'Xeon MP',                              24  => 'Itanium 2',
3318          25  => 'K5',                                   26  => 'K6',
3319          27  => 'K6-2',                                 28  => 'K6-3',
3320          29  => 'Athlon',                               30  => 'AMD2900',
3321          31  => 'K6-2+',                                32  => 'Power PC',
3322          33  => 'Power PC 601',                         34  => 'Power PC 603',
3323          35  => 'Power PC 603+',                        36  => 'Power PC 604',
3324          37  => 'Power PC 620',                         38  => 'Power PC x704',
3325          39  => 'Power PC 750',                         40  => 'Core Duo',
3326          41  => 'Core Duo mobile',                      42  => 'Core Solo mobile',
3327          43  => 'Intel Atom',                           44  => undef,
3328          45  => undef,                                  46  => undef,
3329          47  => undef,                                  48  => 'Alpha',
3330          49  => 'Alpha 21064',                          50  => 'Alpha 21066',
3331          51  => 'Alpha 21164',                          52  => 'Alpha 21164PC',
3332          53  => 'Alpha 21164a',                         54  => 'Alpha 21264',
3333          55  => 'Alpha 21364',                          56  => 'Turion II Ultra Dual-Core Mobile M',
3334          57  => 'Turion II Dual-Core Mobile M',         58  => 'Athlon II Dual-Core Mobile M ',
3335          59  => 'Opteron 6100',                         60  => 'Opteron 4100',
3336          61  => undef,                                  62  => undef,
3337          63  => undef,                                  64  => 'MIPS',
3338          65  => 'MIPS R4000',                           66  => 'MIPS R4200',
3339          67  => 'MIPS R4400',                           68  => 'MIPS R4600',
3340          69  => 'MIPS R10000',                          70  => undef,
3341          71  => undef,                                  72  => undef,
3342          73  => undef,                                  74  => undef,
3343          75  => undef,                                  76  => undef,
3344          77  => undef,                                  78  => undef,
3345          79  => undef,                                  80  => 'SPARC',
3346          81  => 'SuperSPARC',                           82  => 'microSPARC II',
3347          83  => 'microSPARC IIep',                      84  => 'UltraSPARC',
3348          85  => 'UltraSPARC II',                        86  => 'UltraSPARC IIi',
3349          87  => 'UltraSPARC III',                       88  => 'UltraSPARC IIIi',
3350          89  => undef,                                  90  => undef,
3351          91  => undef,                                  92  => undef,
3352          93  => undef,                                  94  => undef,
3353          95  => undef,                                  96  => '68040',
3354          97  => '68xxx',                                98  => '68000',
3355          99  => '68010',                                100 => '68020',
3356          101 => '68030',                                102 => undef,
3357          103 => undef,                                  104 => undef,
3358          105 => undef,                                  106 => undef,
3359          107 => undef,                                  108 => undef,
3360          109 => undef,                                  110 => undef,
3361          111 => undef,                                  112 => 'Hobbit',
3362          113 => undef,                                  114 => undef,
3363          115 => undef,                                  116 => undef,
3364          117 => undef,                                  118 => undef,
3365          119 => undef,                                  120 => 'Crusoe TM5000',
3366          121 => 'Crusoe TM3000',                        122 => 'Efficeon TM8000',
3367          123 => undef,                                  124 => undef,
3368          125 => undef,                                  126 => undef,
3369          127 => undef,                                  128 => 'Weitek',
3370          129 => undef,                                  130 => 'Celeron M',
3371          131 => 'Athlon 64',                            132 => 'Opteron',
3372          133 => 'Sempron',                              134 => 'Turion 64 Mobile',
3373          135 => 'Dual-Core Opteron',                    136 => 'Athlon 64 X2 DC',
3374          137 => 'Turion 64 X2 M',                       138 => 'Quad-Core Opteron',
3375          139 => '3rd gen Opteron',                      140 => 'AMD Phenom FX Quad-Core',
3376          141 => 'AMD Phenom X4 Quad-Core',              142 => 'AMD Phenom X2 Dual-Core',
3377          143 => 'AMD Athlon X2 Dual-Core',              144 => 'PA-RISC',
3378          145 => 'PA-RISC 8500',                         146 => 'PA-RISC 8000',
3379          147 => 'PA-RISC 7300LC',                       148 => 'PA-RISC 7200',
3380          149 => 'PA-RISC 7100LC',                       150 => 'PA-RISC 7100',
3381          151 => undef,                                  152 => undef,
3382          153 => undef,                                  154 => undef,
3383          155 => undef,                                  156 => undef,
3384          157 => undef,                                  158 => undef,
3385          159 => undef,                                  160 => 'V30',
3386          161 => 'Quad-Core Xeon 3200',                  162 => 'Dual-Core Xeon 3000',
3387          163 => 'Quad-Core Xeon 5300',                  164 => 'Dual-Core Xeon 5100',
3388          165 => 'Dual-Core Xeon 5000',                  166 => 'Dual-Core Xeon LV',
3389          167 => 'Dual-Core Xeon ULV',                   168 => 'Dual-Core Xeon 7100',
3390          169 => 'Quad-Core Xeon 5400',                  170 => 'Quad-Core Xeon',
3391          171 => 'Dual-Core Xeon 5200',                  172 => 'Dual-Core Xeon 7200',
3392          173 => 'Quad-Core Xeon 7300',                  174 => 'Quad-Core Xeon 7400',
3393          175 => 'Multi-Core Xeon 7400',                 176 => 'M1',
3394          177 => 'M2',                                   178 => undef,
3395          179 => 'Pentium 4 HT',                         180 => 'AS400',
3396          181 => undef,                                  182 => 'Athlon XP',
3397          183 => 'Athlon MP',                            184 => 'Duron',
3398          185 => 'Pentium M',                            186 => 'Celeron D',
3399          187 => 'Pentium D',                            188 => 'Pentium Extreme',
3400          189 => 'Core Solo',                            190 => 'Core2',
3401          191 => 'Core2 Duo',                            192 => 'Core2 Solo',
3402          193 => 'Core2 Extreme',                        194 => 'Core2 Quad',
3403          195 => 'Core2 Extreme mobile',                 196 => 'Core2 Duo mobile',
3404          197 => 'Core2 Solo mobile',                    198 => 'Core i7',
3405          199 => 'Dual-Core Celeron',                    200 => 'IBM390',
3406          201 => 'G4',                                   202 => 'G5',
3407          203 => 'ESA/390 G6',                           204 => 'z/Architectur',
3408          205 => 'Core i5',                              206 => 'Core i3',
3409          207 => undef,                                  208 => undef,
3410          209 => undef,                                  210 => 'C7-M',
3411          211 => 'C7-D',                                 212 => 'C7',
3412          213 => 'Eden',                                 214 => 'Multi-Core Xeon',
3413          215 => 'Dual-Core Xeon 3xxx',                  216 => 'Quad-Core Xeon 3xxx',
3414          217 => 'VIA Nano',                             218 => 'Dual-Core Xeon 5xxx',
3415          219 => 'Quad-Core Xeon 5xxx',                  220 => undef,
3416          221 => 'Dual-Core Xeon 7xxx',                  222 => 'Quad-Core Xeon 7xxx',
3417          223 => 'Multi-Core Xeon 7xxx',                 224 => 'Multi-Core Xeon 3400',
3418          225 => undef,                                  226 => undef,
3419          227 => undef,                                  228 => undef,
3420          229 => undef,                                  230 => 'Embedded AMD Opteron Quad-Core',
3421          231 => 'AMD Phenom Triple-Core',               232 => 'AMD Turion Ultra Dual-Core Mobile',
3422          233 => 'AMD Turion Dual-Core Mobile',          234 => 'AMD Athlon Dual-Core',
3423          235 => 'AMD Sempron SI',                       236 => 'AMD Phenom II',
3424          237 => 'AMD Athlon II',                        238 => 'Six-Core AMD Opteron',
3425          239 => 'AMD Sempron M',                        240 => undef,
3426          241 => undef,                                  242 => undef,
3427          243 => undef,                                  244 => undef,
3428          245 => undef,                                  246 => undef,
3429          247 => undef,                                  248 => undef,
3430          249 => undef,                                  250 => 'i860',
3431          251 => 'i960',
3432         );
3433
3434   CPU:
3435     foreach my $out (@output) {
3436         if ($snmp) {
3437             $index  = exists $out->{processorDeviceStatusIndex}
3438               ? ($out->{processorDeviceStatusIndex} || 10000) - 1
3439                 : ($out->{processorDeviceIndex} || 10000) - 1;
3440             $status = exists $out->{processorDeviceStatusStatus}
3441               ? get_snmp_status($out->{processorDeviceStatusStatus})
3442                 : get_snmp_status($out->{processorDeviceStatus});
3443             if (defined $out->{processorDeviceStatusReading}) {
3444                 my @states  = ();  # contains states for the CPU
3445
3446                 # get the combined state from the StatusReading OID
3447                 foreach my $mask (sort keys %cpu_reading) {
3448                     if (($out->{processorDeviceStatusReading} & $mask) != 0) {
3449                         push @states, $cpu_reading{$mask};
3450                     }
3451                 }
3452
3453                 # Finally, create the state string
3454                 $state = join q{, }, @states;
3455             }
3456             else {
3457                 $state  = get_hashval($out->{processorDeviceStatusState}, \%cpu_state) || 'Unknown state';
3458             }
3459             $man    = $out->{processorDeviceManufacturerName} || undef;
3460             $family = (defined $out->{processorDeviceFamily}
3461                        and defined $cpu_family{$out->{processorDeviceFamily}})
3462               ? $cpu_family{$out->{processorDeviceFamily}} : undef;
3463             $speed  = $out->{processorDeviceCurrentSpeed} || undef;
3464             $brand  = $out->{processorDeviceBrandName} || undef;
3465         }
3466         else {
3467             $index  = get_nonempty_string('Index', $out, 9999);
3468             $status = get_nonempty_string('Status', $out, 'Unknown');
3469             $state  = get_nonempty_string('State', $out, 'Unknown state');
3470             $brand  = get_nonempty_string('Processor Brand', $out, undef);
3471             $family = get_nonempty_string('Processor Family',  $out, undef);
3472             $man    = get_nonempty_string('Processor Manufacturer', $out, undef);
3473             $speed  = get_nonempty_string('Current Speed', $out, undef);
3474         }
3475
3476         # Ignore unoccupied CPU slots (omreport)
3477         next CPU if (defined $out->{'Processor Manufacturer'}
3478                      and $out->{'Processor Manufacturer'} eq '[Not Occupied]')
3479           or (defined $out->{'Processor Brand'} and $out->{'Processor Brand'} eq '[Not Occupied]');
3480
3481         # Ignore unoccupied CPU slots (snmp)
3482         if ($snmp and defined $out->{processorDeviceStatusReading}
3483             and $out->{processorDeviceStatusReading} == 0) {
3484             next CPU;
3485         }
3486
3487         $count{cpu}++;
3488         next CPU if blacklisted('cpu', $index);
3489
3490         if (defined $brand) {
3491             $brand =~ s{\s\s+}{ }gxms;
3492             $brand =~ s{\((R|tm)\)}{}gxms;
3493             $brand =~ s{\s(CPU|Processor)}{}xms;
3494             $brand =~ s{\s\@}{}xms;
3495         }
3496         elsif (defined $family and defined $man and defined $speed) {
3497             $speed =~ s{\A (\d+) .*}{$1}xms;
3498             $brand = sprintf '%s %s %.2fGHz', $man, $family, $speed / 1000;
3499         }
3500         else {
3501             $brand = "unknown";
3502         }
3503
3504         # Default
3505         if ($status ne 'Ok') {
3506             my $msg = sprintf 'Processor %d [%s] needs attention: %s',
3507               $index, $brand, $state;
3508             report('chassis', $msg, $status2nagios{$status}, $index);
3509         }
3510         # Ok
3511         else {
3512             my $msg = sprintf 'Processor %d [%s] is %s',
3513               $index, $brand, $state;
3514             report('chassis', $msg, $E_OK, $index);
3515         }
3516     }
3517     return;
3518 }
3519
3520
3521 #-----------------------------------------
3522 # CHASSIS: Check voltage probes
3523 #-----------------------------------------
3524 sub check_volts {
3525     my $index    = undef;
3526     my $status   = undef;
3527     my $reading  = undef;
3528     my $location = undef;
3529     my $max_crit = undef;
3530     my $max_warn = undef;
3531     my @output = ();
3532
3533     if ($snmp) {
3534         my %volt_oid
3535           = (
3536              '1.3.6.1.4.1.674.10892.1.600.20.1.2.1'  => 'voltageProbeIndex',
3537              '1.3.6.1.4.1.674.10892.1.600.20.1.5.1'  => 'voltageProbeStatus',
3538              '1.3.6.1.4.1.674.10892.1.600.20.1.6.1'  => 'voltageProbeReading',
3539              '1.3.6.1.4.1.674.10892.1.600.20.1.8.1'  => 'voltageProbeLocationName',
3540              '1.3.6.1.4.1.674.10892.1.600.20.1.16.1' => 'voltageProbeDiscreteReading',
3541             );
3542
3543         my $voltageProbeTable = '1.3.6.1.4.1.674.10892.1.600.20.1';
3544         my $result = $snmp_session->get_table(-baseoid => $voltageProbeTable);
3545
3546         if (!defined $result) {
3547             printf "SNMP ERROR [voltage]: %s.\n", $snmp_session->error;
3548             $snmp_session->close;
3549             exit $E_UNKNOWN;
3550         }
3551
3552         @output = @{ get_snmp_output($result, \%volt_oid) };
3553     }
3554     else {
3555         @output = @{ run_omreport("$omopt_chassis volts") };
3556     }
3557
3558     my %volt_discrete_reading
3559       = (
3560          1 => 'Good',
3561          2 => 'Bad',
3562         );
3563
3564   VOLT:
3565     foreach my $out (@output) {
3566         if ($snmp) {
3567             $index    = ($out->{voltageProbeIndex} || 10000) - 1;
3568             $status   = get_snmp_probestatus($out->{voltageProbeStatus});
3569             $reading  = defined $out->{voltageProbeReading}
3570               ? sprintf('%.3f V', $out->{voltageProbeReading}/1000)
3571                 : (get_hashval($out->{voltageProbeDiscreteReading}, \%volt_discrete_reading) || 'Unknown reading');
3572             $location = $out->{voltageProbeLocationName} || 'Unknown location';
3573             $max_crit = $out->{voltageProbeUpperCriticalThreshold} || 0;
3574             $max_warn = $out->{voltageProbeUpperNonCriticalThreshold} || 0;
3575         }
3576         else {
3577             $index    = get_nonempty_string('Index', $out, 9999);
3578             $status   = get_nonempty_string('Status', $out, 'Unknown');
3579             $reading  = get_nonempty_string('Reading', $out, 'Unknown reading');
3580             $location = get_nonempty_string('Probe Name', $out, 'Unknown location');
3581             $max_crit = get_nonempty_string('Maximum Failure Threshold', $out, 0);
3582             $max_warn = get_nonempty_string('Maximum Warning Threshold', $out, 0);
3583
3584             $max_crit = 0 if $max_crit eq '[N/A]';
3585             $max_warn = 0 if $max_warn eq '[N/A]';
3586         }
3587
3588         $count{volt}++;
3589         next VOLT if blacklisted('volt', $index);
3590
3591         my $msg = sprintf 'Voltage sensor %d [%s] is %s',
3592           $index, $location, $reading;
3593         my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
3594         report('chassis', $msg, $err, $index);
3595
3596         # Collect performance data
3597         if (defined $opt{perfdata}) {
3598             $reading =~ s{\s+V\z}{}xms;  # remove unit
3599             $reading =~ s{\.000\z}{}xms; # if integer
3600             next VOLT if $reading !~ m{\A \d+(\.\d+)? \z}xms; # discrete reading (not number)
3601             my $label = join q{_}, $location;
3602             $label =~ s{\s}{_}gxms;
3603             push @perfdata, {
3604                              type  => 'V',
3605                              id    => $index,
3606                              unit  => 'V',
3607                              label => $label,
3608                              mini  => 'v',
3609                              value => $reading,
3610                              warn  => 0,
3611                              crit  => 0,
3612                             };
3613         }
3614     }
3615     return;
3616 }
3617
3618
3619 #-----------------------------------------
3620 # CHASSIS: Check batteries
3621 #-----------------------------------------
3622 sub check_batteries {
3623     my $index    = undef;
3624     my $status   = undef;
3625     my $reading  = undef;
3626     my $location = undef;
3627     my @output = ();
3628
3629     if ($snmp) {
3630         my %bat_oid
3631           = (
3632              '1.3.6.1.4.1.674.10892.1.600.50.1.2.1' => 'batteryIndex',
3633              '1.3.6.1.4.1.674.10892.1.600.50.1.5.1' => 'batteryStatus',
3634              '1.3.6.1.4.1.674.10892.1.600.50.1.6.1' => 'batteryReading',
3635              '1.3.6.1.4.1.674.10892.1.600.50.1.7.1' => 'batteryLocationName',
3636             );
3637         my $result = undef;
3638         if ($opt{use_get_table}) {
3639             my $batteryTable = '1.3.6.1.4.1.674.10892.1.600.50.1';
3640             $result = $snmp_session->get_table(-baseoid => $batteryTable);
3641         }
3642         else {
3643             $result = $snmp_session->get_entries(-columns => [keys %bat_oid]);
3644         }
3645
3646         # No batteries is OK
3647         return 0 if !defined $result;
3648
3649         @output = @{ get_snmp_output($result, \%bat_oid) };
3650     }
3651     else {
3652         @output = @{ run_omreport("$omopt_chassis batteries") };
3653     }
3654
3655     my %bat_reading
3656       = (
3657          1 => 'Predictive Failure',
3658          2 => 'Failed',
3659          4 => 'Presence Detected',
3660         );
3661
3662   BATTERY:
3663     foreach my $out (@output) {
3664         if ($snmp) {
3665             $index    = ($out->{batteryIndex} || 10000) - 1;
3666             $status   = get_snmp_status($out->{batteryStatus});
3667             $reading  = get_hashval($out->{batteryReading}, \%bat_reading) || 'Unknown reading';
3668             $location = $out->{batteryLocationName} || 'Unknown location';
3669         }
3670         else {
3671             $index    = get_nonempty_string('Index', $out, 9999);
3672             $status   = get_nonempty_string('Status', $out, 'Unknown');
3673             $reading  = get_nonempty_string('Reading', $out, 'Unknown reading');
3674             $location = get_nonempty_string('Probe Name', $out, 'Unknown location');
3675         }
3676
3677         $count{bat}++;
3678         next BATTERY if blacklisted('bp', $index);
3679
3680         my $msg = sprintf 'Battery probe %d [%s] is %s',
3681           $index, $location, $reading;
3682         report('chassis', $msg, $status2nagios{$status}, $index);
3683     }
3684     return;
3685 }
3686
3687
3688 #-----------------------------------------
3689 # CHASSIS: Check amperage probes (power monitoring)
3690 #-----------------------------------------
3691 sub check_pwrmonitoring {
3692     my $index    = undef;
3693     my $status   = undef;
3694     my $reading  = undef;
3695     my $location = undef;
3696     my $max_crit = undef;
3697     my $max_warn = undef;
3698     my $unit     = undef;
3699     my $type     = undef;
3700     my @output = ();
3701
3702     if ($snmp) {
3703         my %amp_oid
3704           = (
3705              '1.3.6.1.4.1.674.10892.1.600.30.1.2.1'  => 'amperageProbeIndex',
3706              '1.3.6.1.4.1.674.10892.1.600.30.1.5.1'  => 'amperageProbeStatus',
3707              '1.3.6.1.4.1.674.10892.1.600.30.1.6.1'  => 'amperageProbeReading',
3708              '1.3.6.1.4.1.674.10892.1.600.30.1.7.1'  => 'amperageProbeType',
3709              '1.3.6.1.4.1.674.10892.1.600.30.1.8.1'  => 'amperageProbeLocationName',
3710              '1.3.6.1.4.1.674.10892.1.600.30.1.10.1' => 'amperageProbeUpperCriticalThreshold',
3711              '1.3.6.1.4.1.674.10892.1.600.30.1.11.1' => 'amperageProbeUpperNonCriticalThreshold',
3712              '1.3.6.1.4.1.674.10892.1.600.30.1.16.1' => 'amperageProbeDiscreteReading',
3713             );
3714         my $result = undef;
3715         if ($opt{use_get_table}) {
3716             my $amperageProbeTable = '1.3.6.1.4.1.674.10892.1.600.30.1';
3717             $result = $snmp_session->get_table(-baseoid => $amperageProbeTable);
3718         }
3719         else {
3720             $result = $snmp_session->get_entries(-columns => [keys %amp_oid]);
3721         }
3722
3723         # No pwrmonitoring is OK
3724         return 0 if !defined $result;
3725
3726         @output = @{ get_snmp_output($result, \%amp_oid) };
3727     }
3728     else {
3729         @output = @{ run_omreport("$omopt_chassis pwrmonitoring") };
3730     }
3731
3732     my %amp_type   # Amperage probe types
3733       = (
3734          1  => 'amperageProbeTypeIsOther',            # other than following values
3735          2  => 'amperageProbeTypeIsUnknown',          # unknown
3736          3  => 'amperageProbeTypeIs1Point5Volt',      # 1.5 amperage probe
3737          4  => 'amperageProbeTypeIs3Point3volt',      # 3.3 amperage probe
3738          5  => 'amperageProbeTypeIs5Volt',            # 5 amperage probe
3739          6  => 'amperageProbeTypeIsMinus5Volt',       # -5 amperage probe
3740          7  => 'amperageProbeTypeIs12Volt',           # 12 amperage probe
3741          8  => 'amperageProbeTypeIsMinus12Volt',      # -12 amperage probe
3742          9  => 'amperageProbeTypeIsIO',               # I/O probe
3743          10 => 'amperageProbeTypeIsCore',             # Core probe
3744          11 => 'amperageProbeTypeIsFLEA',             # FLEA (standby) probe
3745          12 => 'amperageProbeTypeIsBattery',          # Battery probe
3746          13 => 'amperageProbeTypeIsTerminator',       # SCSI Termination probe
3747          14 => 'amperageProbeTypeIs2Point5Volt',      # 2.5 amperage probe
3748          15 => 'amperageProbeTypeIsGTL',              # GTL (ground termination logic) probe
3749          16 => 'amperageProbeTypeIsDiscrete',         # amperage probe with discrete reading
3750          23 => 'amperageProbeTypeIsPowerSupplyAmps',  # Power Supply probe with reading in Amps
3751          24 => 'amperageProbeTypeIsPowerSupplyWatts', # Power Supply probe with reading in Watts
3752          25 => 'amperageProbeTypeIsSystemAmps',       # System probe with reading in Amps
3753          26 => 'amperageProbeTypeIsSystemWatts',      # System probe with reading in Watts
3754         );
3755
3756     my %amp_discrete
3757       = (
3758          1 => 'Good',
3759          2 => 'Bad',
3760         );
3761
3762     my %amp_unit
3763       = (
3764          'amperageProbeTypeIsPowerSupplyAmps'  => 'hA',  # tenths of Amps
3765          'amperageProbeTypeIsSystemAmps'       => 'hA',  # tenths of Amps
3766          'amperageProbeTypeIsPowerSupplyWatts' => 'W',   # Watts
3767          'amperageProbeTypeIsSystemWatts'      => 'W',   # Watts
3768          'amperageProbeTypeIsDiscrete'         => q{},   # discrete reading, no unit
3769         );
3770
3771   AMP:
3772     foreach my $out (@output) {
3773         if ($snmp) {
3774             $index    = ($out->{amperageProbeIndex} || 10000) - 1;
3775             $status   = get_snmp_probestatus($out->{amperageProbeStatus});
3776             $type     = get_hashval($out->{amperageProbeType}, \%amp_type);
3777             $reading  = $type eq 'amperageProbeTypeIsDiscrete'
3778               ? get_hashval($out->{amperageProbeDiscreteReading}, \%amp_discrete)
3779                 : ($out->{amperageProbeReading} || 0);
3780             $location = $out->{amperageProbeLocationName} || 'Unknown location';
3781             $max_crit = $out->{amperageProbeUpperCriticalThreshold} || 0;
3782             $max_warn = $out->{amperageProbeUpperNonCriticalThreshold} || 0;
3783             $unit     = exists $amp_unit{$amp_type{$out->{amperageProbeType}}}
3784               ? $amp_unit{$amp_type{$out->{amperageProbeType}}} : 'mA';
3785
3786             # calculate proper values and set unit for ampere probes
3787             if ($unit eq 'hA' and $type ne 'amperageProbeTypeIsDiscrete') {
3788                 $reading  /= 10;
3789                 $max_crit /= 10;
3790                 $max_warn /= 10;
3791                 $unit      = 'A';
3792             }
3793         }
3794         else {
3795             $index    = get_nonempty_string('Index', $out, 9999);
3796             $status   = get_nonempty_string('Status', $out, 'Unknown');
3797             $reading  = get_nonempty_string('Reading', $out, 'Unknown reading');
3798             $location = get_nonempty_string('Probe Name', $out, 'Unknown location');
3799             $max_crit = get_nonempty_string('Failure Threshold', $out, 0);
3800             $max_warn = get_nonempty_string('Warning Threshold', $out, 0);
3801
3802             $max_crit = 0 if $max_crit eq '[N/A]';
3803             $max_warn = 0 if $max_warn eq '[N/A]';
3804
3805             $reading  =~ s{\A (\d+.*?)\s+([a-zA-Z]+) \s*\z}{$1}xms;
3806             $unit     = $2 || 'unknown';
3807             $max_warn =~ s{\A (\d+.*?)\s+[a-zA-Z]+ \s*\z}{$1}xms;
3808             $max_crit =~ s{\A (\d+.*?)\s+[a-zA-Z]+ \s*\z}{$1}xms;
3809         }
3810
3811         next AMP if $index !~ m{\A \d+ \z}xms;
3812
3813         # Special case: Probe is present but unknown. This happens via
3814         # SNMP on some systems where power monitoring capability is
3815         # disabled due to non-redundant and/or non-instrumented power
3816         # supplies.
3817         # E.g. R410 with newer BMC firmware and 1 power supply
3818         if ($snmp && $status eq 'Unknown' && $reading == 0) {
3819             next AMP;
3820         }
3821
3822         $count{amp}++;
3823         next AMP if blacklisted('amp', $index);
3824
3825         # Special case: Discrete reading
3826         if (defined $type and $type eq 'amperageProbeTypeIsDiscrete') {
3827             my $msg = sprintf 'Amperage probe %d [%s] is %s',
3828               $index, $location, $reading;
3829             report('chassis', $msg, $status2nagios{$status}, $index);
3830         }
3831         # Default
3832         else {
3833             my $msg = sprintf 'Amperage probe %d [%s] reads %s %s',
3834               $index, $location, $reading, $unit;
3835             report('chassis', $msg, $status2nagios{$status}, $index);
3836         }
3837
3838         # Collect performance data
3839         if (defined $opt{perfdata}) {
3840             next AMP if $reading !~ m{\A \d+(\.\d+)? \z}xms; # discrete reading (not number)
3841             my $label = join q{_},  $location;
3842             $label =~ s{\s}{_}gxms;
3843             push @perfdata, {
3844                              type  => $unit,
3845                              id    => $index,
3846                              unit  => $unit,
3847                              label => $label,
3848                              mini  => lc $unit,
3849                              value => $reading,
3850                              warn  => $max_warn,
3851                              crit  => $max_crit,
3852                             };
3853         }
3854     }
3855
3856     # Collect EXTRA performance data not found at first run. This is a
3857     # rather ugly hack
3858     if (defined $opt{perfdata} && !$snmp) {
3859         my $found = 0;
3860         my $index = 0;
3861         my %used  = ();
3862
3863         # find used indexes
3864         foreach (@perfdata) {
3865             if ($_->{label} =~ m/\A [WA](\d+)/xms) {
3866                 $used{$1} = 1;
3867             }
3868         }
3869
3870       AMP2:
3871         foreach my $line (@{ run_command("$omreport $omopt_chassis pwrmonitoring -fmt ssv") }) {
3872             chop $line;
3873             if ($line eq 'Location;Reading') {
3874                 $found = 1;
3875                 next AMP2;
3876             }
3877             if ($line eq q{}) {
3878                 $found = 0;
3879                 next AMP2;
3880             }
3881             if ($found and $line =~ m/\A ([^;]+?) ; (\d*\.\d+) \s [AW] \z/xms) {
3882                 my $aname = lc $1;
3883                 my $aval = $2;
3884                 $aname =~ s{\s}{_}gxms;
3885
3886                 # don't use an existing index
3887                 while (exists $used{$index}) { ++$index; }
3888
3889                 push @perfdata, {
3890                                  label => "pwr_mon_${index}_${aname}",
3891                                  mini  => "p${index}a",
3892                                  value => $aval,
3893                                  warn  => 0,
3894                                  crit  => 0,
3895                                 };
3896                 ++$index;
3897             }
3898         }
3899     }
3900
3901     return;
3902 }
3903
3904
3905 #-----------------------------------------
3906 # CHASSIS: Check intrusion
3907 #-----------------------------------------
3908 sub check_intrusion {
3909     my $index    = undef;
3910     my $status   = undef;
3911     my $reading  = undef;
3912     my @output = ();
3913
3914     if ($snmp) {
3915         my %int_oid
3916           = (
3917              '1.3.6.1.4.1.674.10892.1.300.70.1.2.1' => 'intrusionIndex',
3918              '1.3.6.1.4.1.674.10892.1.300.70.1.5.1' => 'intrusionStatus',
3919              '1.3.6.1.4.1.674.10892.1.300.70.1.6.1' => 'intrusionReading',
3920             );
3921         my $result = undef;
3922         if ($opt{use_get_table}) {
3923             my $intrusionTable = '1.3.6.1.4.1.674.10892.1.300.70.1';
3924             $result = $snmp_session->get_table(-baseoid => $intrusionTable);
3925         }
3926         else {
3927             $result = $snmp_session->get_entries(-columns => [keys %int_oid]);
3928         }
3929
3930         # No intrusion is OK
3931         return 0 if !defined $result;
3932
3933         @output = @{ get_snmp_output($result, \%int_oid) };
3934     }
3935     else {
3936         @output = @{ run_omreport("$omopt_chassis intrusion") };
3937     }
3938
3939     my %int_reading
3940       = (
3941          1 => 'Not Breached',          # chassis not breached and no uncleared breaches
3942          2 => 'Breached',              # chassis currently breached
3943          3 => 'Breached Prior',        # chassis breached prior to boot and has not been cleared
3944          4 => 'Breach Sensor Failure', # intrusion sensor has failed
3945         );
3946
3947   INTRUSION:
3948     foreach my $out (@output) {
3949         if ($snmp) {
3950             $index    = ($out->{intrusionIndex} || 10000) - 1;
3951             $status   = get_snmp_status($out->{intrusionStatus});
3952             $reading  = get_hashval($out->{intrusionReading}, \%int_reading) || 'Unknown reading';
3953         }
3954         else {
3955             $index    = get_nonempty_string('Index', $out, 9999);
3956             $status   = get_nonempty_string('Status', $out, 'Unknown');
3957             $reading  = get_nonempty_string('State', $out, 'Unknown reading');
3958         }
3959
3960         $count{intr}++;
3961         next INTRUSION if blacklisted('intr', $index);
3962
3963         if ($status ne 'Ok') {
3964             my $msg = sprintf 'Chassis intrusion %d detected: %s',
3965               $index, $reading;
3966             report('chassis', $msg, $E_WARNING, $index);
3967         }
3968         # Ok
3969         else {
3970             my $msg = sprintf 'Chassis intrusion %d detection: %s (%s)',
3971               $index, $status, $reading;
3972             report('chassis', $msg, $E_OK, $index);
3973         }
3974     }
3975     return;
3976 }
3977
3978
3979 #-----------------------------------------
3980 # CHASSIS: Check SD Card Device
3981 #-----------------------------------------
3982 sub check_sdcard {
3983     my $index    = undef;
3984     my $status   = undef;
3985     my $state    = undef;
3986     my $location = undef;
3987     my $capacity = undef;
3988     my $setting  = undef;
3989     my @output = ();
3990
3991     if ($snmp) {
3992         my %sd_oid
3993           = (
3994              '1.3.6.1.4.1.674.10892.1.1100.112.1.2.1'  => 'sdCardDeviceIndex',
3995              '1.3.6.1.4.1.674.10892.1.1100.112.1.3.1'  => 'sdCardDeviceStatus',
3996              '1.3.6.1.4.1.674.10892.1.1100.112.1.4.1'  => 'sdCardDeviceType',
3997              '1.3.6.1.4.1.674.10892.1.1100.112.1.7.1'  => 'sdCardDeviceLocationName',
3998              '1.3.6.1.4.1.674.10892.1.1100.112.1.8.1'  => 'sdCardDeviceCardPresent',
3999              '1.3.6.1.4.1.674.10892.1.1100.112.1.9.1'  => 'sdCardDeviceCardState',
4000              '1.3.6.1.4.1.674.10892.1.1100.112.1.10.1' => 'sdCardDeviceCardStorageSize',
4001             );
4002         my $result = undef;
4003         if ($opt{use_get_table}) {
4004             my $sdCardDeviceTable = '1.3.6.1.4.1.674.10892.1.1100.112.1';
4005             $result = $snmp_session->get_table(-baseoid => $sdCardDeviceTable);
4006         }
4007         else {
4008             $result = $snmp_session->get_entries(-columns => [keys %sd_oid]);
4009         }
4010
4011         # No SD cards is OK
4012         return 0 if !defined $result;
4013
4014         @output = @{ get_snmp_output($result, \%sd_oid) };
4015     }
4016     else {
4017         @output = @{ run_omreport("$omopt_chassis removableflashmedia") };
4018     }
4019
4020     # Note: These values are bit fields, so combination values are possible.
4021     my %sd_state
4022       = (
4023          0   => 'None',            # state is none of the following:
4024          1   => 'Present',         # device is present
4025          2   => 'IPMI-ready',      # device is IPMI ready
4026          4   => 'Full-ready',      # device is full ready
4027          8   => 'Offline',         # device is offline
4028          16  => 'Failed',          # device is failed
4029          32  => 'Active',          # device is active
4030          64  => 'Bootable',        # device is bootable
4031          128 => 'Write-protected', # device is write-protected
4032          256 => 'Standby',         # device is in standby mode
4033         );
4034
4035     my $c = 0;
4036   SDCARD:
4037     foreach my $out (@output) {
4038         if ($snmp) {
4039             $index    = ($out->{sdCardDeviceIndex} || 10000) - 1;
4040             $status   = get_snmp_status($out->{sdCardDeviceStatus});
4041
4042             if (defined $out->{sdCardDeviceCardState}) {
4043                 my @states  = ();  # contains states SD card
4044
4045                 # get the combined state from the Device Status OID
4046                 foreach my $mask (sort keys %sd_state) {
4047                     if (($out->{sdCardDeviceCardState} & $mask) != 0) {
4048                         push @states, $sd_state{$mask};
4049                     }
4050                 }
4051
4052                 # Finally, create the state string
4053                 $state = join q{, }, @states;
4054
4055                 # special case: absent
4056                 if ($out->{sdCardDeviceCardState} % 2 == 0) {
4057                     $state = 'Absent';
4058                 }
4059             }
4060
4061             $location = $out->{sdCardDeviceLocationName} || 'Unknown location';
4062             $capacity = sprintf '%s MB', ($out->{sdCardDeviceCardStorageSize} || 'Unknown size');
4063         }
4064         else {
4065             $index    = $c++;
4066             $status   = get_nonempty_string('Status', $out, 'Ok');
4067             $state    = get_nonempty_string('State', $out, 'Unknown state');
4068             $location = get_nonempty_string('Connector Name', $out, 'Unknown location');
4069             $capacity = get_nonempty_string('Storage Size', $out, 'Unknown size');
4070
4071             $capacity =~ s{\[Not Available\]}{Unknown Size};
4072         }
4073
4074         $count{sd}++ if $state ne 'Absent';
4075         next SDCARD if blacklisted('sd', $index);
4076
4077         if ($status ne 'Ok') {
4078             my $msg = sprintf 'SD Card %d needs attention: %s',
4079               $index, $state;
4080             report('chassis', $msg, $E_WARNING, $index);
4081         }
4082         # Special case: Not Present
4083         elsif ($status eq 'Ok' and $state eq 'Absent') {
4084             my $msg = sprintf 'SD Card %d [%s] is %s',
4085               $index, $location, $state;
4086             report('chassis', $msg, $E_OK, $index);
4087         }
4088         # Ok
4089         else {
4090             my $msg = sprintf 'SD Card %d [%s, %s] is %s',
4091               $index, $location, $capacity, $state;
4092             report('chassis', $msg, $E_OK, $index);
4093         }
4094     }
4095     return;
4096 }
4097
4098
4099 #-----------------------------------------
4100 # CHASSIS: Check alert log
4101 #-----------------------------------------
4102 sub check_alertlog {
4103     return if $snmp; # Not supported with SNMP
4104
4105     my @output = @{ run_omreport("$omopt_system alertlog") };
4106     foreach my $out (@output) {
4107         ++$count{alert}{$out->{Severity}};
4108     }
4109
4110     # Create error messages and set exit value if appropriate
4111     my $err = 0;
4112     if ($count{alert}{'Critical'} > 0)        { $err = $E_CRITICAL; }
4113     elsif ($count{alert}{'Non-Critical'} > 0) { $err = $E_WARNING;  }
4114
4115     my $msg = sprintf 'Alert log content: %d critical, %d non-critical, %d ok',
4116       $count{alert}{'Critical'}, $count{alert}{'Non-Critical'}, $count{alert}{'Ok'};
4117     report('other', $msg, $err);
4118
4119     return;
4120 }
4121
4122 #-----------------------------------------
4123 # CHASSIS: Check ESM log overall health
4124 #-----------------------------------------
4125 sub check_esmlog_health {
4126     my $health = 'Ok';
4127
4128     if ($snmp) {
4129         my $systemStateEventLogStatus = '1.3.6.1.4.1.674.10892.1.200.10.1.41.1';
4130         my $result = $snmp_session->get_request(-varbindlist => [$systemStateEventLogStatus]);
4131         if (!defined $result) {
4132             my $msg = sprintf 'SNMP ERROR [esmhealth]: %s',
4133               $snmp_session->error;
4134             report('other', $msg, $E_UNKNOWN);
4135         }
4136         $health = get_snmp_status($result->{$systemStateEventLogStatus});
4137     }
4138     else {
4139         foreach (@{ run_command("$omreport $omopt_system esmlog -fmt ssv") }) {
4140             if (m/\A Health;(.+) \z/xms) {
4141                 $health = $1;
4142                 chop $health;
4143                 last;
4144             }
4145         }
4146     }
4147
4148     # If the overall health of the ESM log is other than "Ok", the
4149     # fill grade of the log is more than 80% and the log should be
4150     # cleared
4151     if ($health eq 'Ok') {
4152         my $msg = sprintf 'ESM log health is Ok (less than 80%% full)';
4153         report('other', $msg, $E_OK);
4154     }
4155     elsif ($health eq 'Critical') {
4156         my $msg = sprintf 'ESM log is 100%% full';
4157         report('other', $msg, $status2nagios{$health});
4158     }
4159     else {
4160         my $msg = sprintf 'ESM log is more than 80%% full';
4161         report('other', $msg, $status2nagios{$health});
4162     }
4163
4164     return;
4165 }
4166
4167 #-----------------------------------------
4168 # CHASSIS: Check ESM log
4169 #-----------------------------------------
4170 sub check_esmlog {
4171     my @output = ();
4172
4173     if ($snmp) {
4174         my %esm_oid
4175           = (
4176              '1.3.6.1.4.1.674.10892.1.300.40.1.7.1'  => 'eventLogSeverityStatus',
4177             );
4178         my $result = $snmp_session->get_entries(-columns => [keys %esm_oid]);
4179
4180         # No entries is OK
4181         return if !defined $result;
4182
4183         @output = @{ get_snmp_output($result, \%esm_oid) };
4184         foreach my $out (@output) {
4185             ++$count{esm}{$snmp_status{$out->{eventLogSeverityStatus}}};
4186         }
4187     }
4188     else {
4189         @output = @{ run_omreport("$omopt_system esmlog") };
4190         foreach my $out (@output) {
4191             ++$count{esm}{$out->{Severity}};
4192         }
4193     }
4194
4195     # Create error messages and set exit value if appropriate
4196     my $err = 0;
4197     if ($count{esm}{'Critical'} > 0)        { $err = $E_CRITICAL; }
4198     elsif ($count{esm}{'Non-Critical'} > 0) { $err = $E_WARNING;  }
4199
4200     my $msg = sprintf 'ESM log content: %d critical, %d non-critical, %d ok',
4201       $count{esm}{'Critical'}, $count{esm}{'Non-Critical'}, $count{esm}{'Ok'};
4202     report('other', $msg, $err);
4203
4204     return;
4205 }
4206
4207 #
4208 # Handy function for checking all storage components
4209 #
4210 sub check_storage {
4211     check_controllers();
4212     check_physical_disks();
4213     check_virtual_disks();
4214     check_cache_battery();
4215     check_connectors();
4216     check_enclosures();
4217     check_enclosure_fans();
4218     check_enclosure_pwr();
4219     check_enclosure_temp();
4220     check_enclosure_emms();
4221     return;
4222 }
4223
4224
4225
4226 #---------------------------------------------------------------------
4227 # Info functions
4228 #---------------------------------------------------------------------
4229
4230 #
4231 # Fetch output from 'omreport chassis info', put in sysinfo hash
4232 #
4233 sub get_omreport_chassis_info {
4234     if (open my $INFO, '-|', "$omreport $omopt_chassis info -fmt ssv") {
4235         my @lines = <$INFO>;
4236         close $INFO;
4237         foreach (@lines) {
4238             next if !m/\A (Chassis\sModel|Chassis\sService\sTag|Model|Service\sTag|System\sRevision)/xms;
4239             my ($key, $val) = split /;/xms;
4240             $key =~ s{\s+\z}{}xms; # remove trailing whitespace
4241             $val =~ s{\s+\z}{}xms; # remove trailing whitespace
4242             if ($key eq 'Chassis Model' or $key eq 'Model') {
4243                 $sysinfo{model}  = $val;
4244             }
4245             if ($key eq 'Chassis Service Tag' or $key eq 'Service Tag') {
4246                 $sysinfo{serial} = $val;
4247             }
4248             if ($key eq 'System Revision') {
4249                 $sysinfo{rev} = q{ } . $val;
4250             }
4251         }
4252     }
4253     return;
4254 }
4255
4256 #
4257 # Fetch output from 'omreport chassis bios', put in sysinfo hash
4258 #
4259 sub get_omreport_chassis_bios {
4260     if (open my $BIOS, '-|', "$omreport $omopt_chassis bios -fmt ssv") {
4261         my @lines = <$BIOS>;
4262         close $BIOS;
4263         foreach (@lines) {
4264             next if !m/;/xms;
4265             my ($key, $val) = split /;/xms;
4266             $key =~ s{\s+\z}{}xms; # remove trailing whitespace
4267             $val =~ s{\s+\z}{}xms; # remove trailing whitespace
4268             $sysinfo{bios}     = $val if $key eq 'Version';
4269             $sysinfo{biosdate} = $val if $key eq 'Release Date';
4270         }
4271     }
4272     return;
4273 }
4274
4275 #
4276 # Fetch output from 'omreport system operatingsystem', put in sysinfo hash
4277 #
4278 sub get_omreport_system_operatingsystem {
4279     if (open my $VER, '-|', "$omreport $omopt_system operatingsystem -fmt ssv") {
4280         my @lines = <$VER>;
4281         close $VER;
4282         foreach (@lines) {
4283             next if !m/;/xms;
4284             my ($key, $val) = split /;/xms;
4285             $key =~ s{\s+\z}{}xms; # remove trailing whitespace
4286             $val =~ s{\s+\z}{}xms; # remove trailing whitespace
4287             if ($key eq 'Operating System') {
4288                 $sysinfo{osname} = $val;
4289             }
4290             elsif ($key eq 'Operating System Version') {
4291                 $sysinfo{osver}  = $val;
4292             }
4293         }
4294     }
4295     return;
4296 }
4297
4298 #
4299 # Fetch output from 'omreport about', put in sysinfo hash
4300 #
4301 sub get_omreport_about {
4302     if (open my $OM, '-|', "$omreport about -fmt ssv") {
4303         my @lines = <$OM>;
4304         close $OM;
4305         foreach (@lines) {
4306             if (m/\A Version;(.+) \z/xms) {
4307                 $sysinfo{om} = $1;
4308                 chomp $sysinfo{om};
4309             }
4310         }
4311     }
4312     return;
4313 }
4314
4315 #
4316 # Fetch chassis info via SNMP, put in sysinfo hash
4317 #
4318 sub get_snmp_chassis_info {
4319     my %chassis_oid
4320       = (
4321          '1.3.6.1.4.1.674.10892.1.300.10.1.9.1'  => 'chassisModelName',
4322          '1.3.6.1.4.1.674.10892.1.300.10.1.11.1' => 'chassisServiceTagName',
4323          '1.3.6.1.4.1.674.10892.1.300.10.1.48.1' => 'chassisSystemRevisionName',
4324         );
4325
4326     my $chassisInformationTable = '1.3.6.1.4.1.674.10892.1.300.10.1';
4327     my $result = $snmp_session->get_table(-baseoid => $chassisInformationTable);
4328
4329     if (defined $result) {
4330         foreach my $oid (keys %{ $result }) {
4331             if (exists $chassis_oid{$oid} and $chassis_oid{$oid} eq 'chassisModelName') {
4332                 $sysinfo{model} = $result->{$oid};
4333                 $sysinfo{model} =~ s{\s+\z}{}xms; # remove trailing whitespace
4334             }
4335             elsif (exists $chassis_oid{$oid} and $chassis_oid{$oid} eq 'chassisServiceTagName') {
4336                 $sysinfo{serial} = $result->{$oid};
4337             }
4338             elsif (exists $chassis_oid{$oid} and $chassis_oid{$oid} eq 'chassisSystemRevisionName') {
4339                 $sysinfo{rev} = q{ } . $result->{$oid};
4340             }
4341         }
4342     }
4343     else {
4344         my $msg = sprintf 'SNMP ERROR getting chassis info: %s',
4345           $snmp_session->error;
4346         report('other', $msg, $E_UNKNOWN);
4347     }
4348     return;
4349 }
4350
4351 #
4352 # Fetch BIOS info via SNMP, put in sysinfo hash
4353 #
4354 sub get_snmp_chassis_bios {
4355     my %bios_oid
4356       = (
4357          '1.3.6.1.4.1.674.10892.1.300.50.1.7.1.1' => 'systemBIOSReleaseDateName',
4358          '1.3.6.1.4.1.674.10892.1.300.50.1.8.1.1' => 'systemBIOSVersionName',
4359         );
4360
4361     my $systemBIOSTable = '1.3.6.1.4.1.674.10892.1.300.50.1';
4362     my $result = $snmp_session->get_table(-baseoid => $systemBIOSTable);
4363
4364     if (defined $result) {
4365         foreach my $oid (keys %{ $result }) {
4366             if (exists $bios_oid{$oid} and $bios_oid{$oid} eq 'systemBIOSReleaseDateName') {
4367                 $sysinfo{biosdate} = $result->{$oid};
4368                 $sysinfo{biosdate} =~ s{\A (\d{4})(\d{2})(\d{2}).*}{$2/$3/$1}xms;
4369             }
4370             elsif (exists $bios_oid{$oid} and $bios_oid{$oid} eq 'systemBIOSVersionName') {
4371                 $sysinfo{bios} = $result->{$oid};
4372             }
4373         }
4374     }
4375     else {
4376         my $msg = sprintf 'SNMP ERROR getting BIOS info: %s',
4377           $snmp_session->error;
4378         report('other', $msg, $E_UNKNOWN);
4379     }
4380     return;
4381 }
4382
4383 #
4384 # Fetch OS info via SNMP, put in sysinfo hash
4385 #
4386 sub get_snmp_system_operatingsystem {
4387     my %os_oid
4388       = (
4389          '1.3.6.1.4.1.674.10892.1.400.10.1.6.1' => 'operatingSystemOperatingSystemName',
4390          '1.3.6.1.4.1.674.10892.1.400.10.1.7.1' => 'operatingSystemOperatingSystemVersionName',
4391         );
4392
4393     my $operatingSystemTable = '1.3.6.1.4.1.674.10892.1.400.10.1';
4394     my $result = $snmp_session->get_table(-baseoid => $operatingSystemTable);
4395
4396     if (defined $result) {
4397         foreach my $oid (keys %{ $result }) {
4398             if (exists $os_oid{$oid} and $os_oid{$oid} eq 'operatingSystemOperatingSystemName') {
4399                 $sysinfo{osname} = ($result->{$oid});
4400             }
4401             elsif (exists $os_oid{$oid} and $os_oid{$oid} eq 'operatingSystemOperatingSystemVersionName') {
4402                 $sysinfo{osver} = $result->{$oid};
4403             }
4404         }
4405     }
4406     else {
4407         my $msg = sprintf 'SNMP ERROR getting OS info: %s',
4408           $snmp_session->error;
4409         report('other', $msg, $E_UNKNOWN);
4410     }
4411     return;
4412 }
4413
4414 #
4415 # Fetch OMSA version via SNMP, put in sysinfo hash
4416 #
4417 sub get_snmp_about {
4418     # systemManagementSoftwareGlobalVersionName
4419     my $oid = '1.3.6.1.4.1.674.10892.1.100.10.0';
4420     my $result = $snmp_session->get_request(-varbindlist => [$oid]);
4421
4422     if (defined $result) {
4423         $sysinfo{om} = exists $result->{$oid} && $result->{$oid} ne q{}
4424           ? $result->{$oid} : 'unknown';
4425     }
4426     else {
4427         my $msg = sprintf 'SNMP ERROR: Getting OMSA version failed: %s', $snmp_session->error;
4428         report('other', $msg, $E_UNKNOWN);
4429     }
4430     return;
4431 }
4432
4433 #
4434 # Collects some information about the system
4435 #
4436 sub get_sysinfo
4437 {
4438     # Get system model and serial number
4439     $snmp ? get_snmp_chassis_info() : get_omreport_chassis_info();
4440
4441     # Get BIOS information. Only if needed
4442     if ( $opt{okinfo} >= 1
4443          or $opt{debug}
4444          or (defined $opt{postmsg} and $opt{postmsg} =~ m/[%][bd]/xms) ) {
4445         $snmp ? get_snmp_chassis_bios() : get_omreport_chassis_bios();
4446     }
4447
4448     # Get OMSA information. Only if needed
4449     if ($opt{okinfo} >= 3 or $opt{debug}) {
4450         $snmp ? get_snmp_about() : get_omreport_about();
4451     }
4452
4453     # Return now if debug
4454     return if $opt{debug};
4455
4456     # Get OS information. Only if needed
4457     if (defined $opt{postmsg} and $opt{postmsg} =~ m/[%][or]/xms) {
4458         $snmp ? get_snmp_system_operatingsystem() : get_omreport_system_operatingsystem();
4459     }
4460
4461     return;
4462 }
4463
4464
4465 # Helper function for running omreport when the results are strictly
4466 # name=value pairs.
4467 sub run_omreport_info {
4468     my $command = shift;
4469     my %output  = ();
4470     my @keys    = ();
4471
4472     # Run omreport and fetch output
4473     my $rawtext = slurp_command("$omreport $command -fmt ssv 2>&1");
4474
4475     # Parse output, store in array
4476     for ((split /\n/xms, $rawtext)) {
4477         if (m/\A Error/xms) {
4478             my $msg = "Problem running 'omreport $command': $_";
4479             report('other', $msg, $E_UNKNOWN);
4480         }
4481         next if !m/;/xms;  # ignore lines with less than two fields
4482         my @vals = split m/;/xms;
4483         $output{$vals[0]} = $vals[1];
4484     }
4485
4486     # Finally, return the collected information
4487     return \%output;
4488 }
4489
4490 # Get various firmware information (BMC, RAC)
4491 sub get_firmware_info {
4492     my @snmp_output = ();
4493     my %nrpe_output = ();
4494
4495     if ($snmp) {
4496         my %fw_oid
4497           = (
4498              '1.3.6.1.4.1.674.10892.1.300.60.1.7.1'  => 'firmwareType',
4499              '1.3.6.1.4.1.674.10892.1.300.60.1.8.1'  => 'firmwareTypeName',
4500              '1.3.6.1.4.1.674.10892.1.300.60.1.11.1' => 'firmwareVersionName',
4501             );
4502
4503         my $firmwareTable = '1.3.6.1.4.1.674.10892.1.300.60.1';
4504         my $result = $snmp_session->get_table(-baseoid => $firmwareTable);
4505
4506         # Some don't have this OID, this is ok
4507         if (!defined $result) {
4508             return;
4509         }
4510
4511         @snmp_output = @{ get_snmp_output($result, \%fw_oid) };
4512     }
4513     else {
4514         %nrpe_output = %{ run_omreport_info("$omopt_chassis info") };
4515     }
4516
4517     my %fw_type  # Firmware types
4518       = (
4519          1  => 'other',                              # other than following values
4520          2  => 'unknown',                            # unknown
4521          3  => 'systemBIOS',                         # System BIOS
4522          4  => 'embeddedSystemManagementController', # Embedded System Management Controller
4523          5  => 'powerSupplyParallelingBoard',        # Power Supply Paralleling Board
4524          6  => 'systemBackPlane',                    # System (Primary) Backplane
4525          7  => 'powerVault2XXSKernel',               # PowerVault 2XXS Kernel
4526          8  => 'powerVault2XXSApplication',          # PowerVault 2XXS Application
4527          9  => 'frontPanel',                         # Front Panel Controller
4528          10 => 'baseboardManagementController',      # Baseboard Management Controller
4529          11 => 'hotPlugPCI',                         # Hot Plug PCI Controller
4530          12 => 'sensorData',                         # Sensor Data Records
4531          13 => 'peripheralBay',                      # Peripheral Bay Backplane
4532          14 => 'secondaryBackPlane',                 # Secondary Backplane for ESM 2 systems
4533          15 => 'secondaryBackPlaneESM3And4',         # Secondary Backplane for ESM 3 and 4 systems
4534          16 => 'rac',                                # Remote Access Controller
4535          17 => 'iDRAC',                              # Integrated Dell Remote Access Controller
4536          19 => 'unifiedServerConfigurator',          # Unified Server Configurator
4537          20 => 'lifecycleController',                # Lifecycle Controller
4538         );
4539
4540
4541     if ($snmp) {
4542         foreach my $out (@snmp_output) {
4543             if ($fw_type{$out->{firmwareType}} eq 'baseboardManagementController') {
4544                 $sysinfo{'bmc'} = 1;
4545                 $sysinfo{'bmc_fw'} = $out->{firmwareVersionName};
4546             }
4547             elsif ($fw_type{$out->{firmwareType}} =~ m{\A rac|iDRAC \z}xms) {
4548                 my $name = $out->{firmwareTypeName}; $name =~ s/\s//gxms;
4549                 $sysinfo{'rac'} = 1;
4550                 $sysinfo{'rac_name'} = $name;
4551                 $sysinfo{'rac_fw'} = $out->{firmwareVersionName};
4552             }
4553         }
4554     }
4555     else {
4556         foreach my $key (keys %nrpe_output) {
4557             next if !defined $nrpe_output{$key};
4558             if ($key eq 'BMC Version' or $key eq 'Baseboard Management Controller Version') {
4559                 $sysinfo{'bmc'} = 1;
4560                 $sysinfo{'bmc_fw'} = $nrpe_output{$key};
4561             }
4562             elsif ($key =~ m{\A (i?DRAC)\s*(\d?)\s+Version}xms) {
4563                 my $name = "$1$2";
4564                 $sysinfo{'rac'} = 1;
4565                 $sysinfo{'rac_fw'} = $nrpe_output{$key};
4566                 $sysinfo{'rac_name'} = $name;
4567             }
4568         }
4569     }
4570
4571     return;
4572 }
4573
4574
4575
4576 #=====================================================================
4577 # Main program
4578 #=====================================================================
4579
4580 # Here we do the actual checking of components
4581 # Check global status if applicable
4582 if ($global) {
4583     $globalstatus = check_global();
4584 }
4585
4586 # Do multiple selected checks
4587 if ($check{storage})     { check_storage();       }
4588 if ($check{memory})      { check_memory();        }
4589 if ($check{fans})        { check_fans();          }
4590 if ($check{power})       { check_powersupplies(); }
4591 if ($check{temp})        { check_temperatures();  }
4592 if ($check{cpu})         { check_processors();    }
4593 if ($check{voltage})     { check_volts();         }
4594 if ($check{batteries})   { check_batteries();     }
4595 if ($check{amperage})    { check_pwrmonitoring(); }
4596 if ($check{intrusion})   { check_intrusion();     }
4597 if ($check{sdcard})      { check_sdcard();        }
4598 if ($check{alertlog})    { check_alertlog();      }
4599 if ($check{esmlog})      { check_esmlog();        }
4600 if ($check{esmhealth})   { check_esmlog_health(); }
4601
4602
4603 #---------------------------------------------------------------------
4604 # Finish up
4605 #---------------------------------------------------------------------
4606
4607 # Counter variable
4608 %nagios_alert_count
4609   = (
4610      'OK'       => 0,
4611      'WARNING'  => 0,
4612      'CRITICAL' => 0,
4613      'UNKNOWN'  => 0,
4614     );
4615
4616 # Get system information
4617 get_sysinfo();
4618
4619 # Get firmware info if requested via option
4620 if ($opt{okinfo} >= 1) {
4621     get_firmware_info();
4622 }
4623
4624 # Close SNMP session
4625 if ($snmp) {
4626     $snmp_session->close;
4627 }
4628
4629 # Print messages
4630 if ($opt{debug}) {
4631     # finding the mode of operation
4632     my $mode = 'local';
4633     if ($snmp) {
4634         # Setting the domain (IP version and transport protocol)
4635         my $transport = $opt{tcp} ? 'TCP' : 'UDP';
4636         my $ipversion = $opt{ipv6} ? 'IPv6' : 'IPv4';
4637         $mode = "SNMPv$opt{protocol} $transport/$ipversion";
4638     }
4639
4640     print "   System:      $sysinfo{model}$sysinfo{rev}";
4641     print q{ } x (25 - length "$sysinfo{model}$sysinfo{rev}"), "OMSA version:    $sysinfo{om}\n";
4642     print "   ServiceTag:  $sysinfo{serial}";
4643     print q{ } x (25 - length $sysinfo{serial}), "Plugin version:  $VERSION\n";
4644     print "   BIOS/date:   $sysinfo{bios} $sysinfo{biosdate}";
4645     print q{ } x (25 - length "$sysinfo{bios} $sysinfo{biosdate}"), "Checking mode:   $mode\n";
4646     if ($#report_storage >= 0) {
4647         print "-----------------------------------------------------------------------------\n";
4648         print "   Storage Components                                                        \n";
4649         print "=============================================================================\n";
4650         print "  STATE  |    ID    |  MESSAGE TEXT                                          \n";
4651         print "---------+----------+--------------------------------------------------------\n";
4652         foreach (@report_storage) {
4653             my ($msg, $level, $nexus) = @{$_};
4654             print q{ } x (8 - length $reverse_exitcode{$level}) . "$reverse_exitcode{$level} | "
4655               . q{ } x (8 - length $nexus) . "$nexus | $msg\n";
4656             $nagios_alert_count{$reverse_exitcode{$level}}++;
4657         }
4658     }
4659     if ($#report_chassis >= 0) {
4660         print "-----------------------------------------------------------------------------\n";
4661         print "   Chassis Components                                                        \n";
4662         print "=============================================================================\n";
4663         print "  STATE  |  ID  |  MESSAGE TEXT                                              \n";
4664         print "---------+------+------------------------------------------------------------\n";
4665         foreach (@report_chassis) {
4666             my ($msg, $level, $nexus) = @{$_};
4667             print q{ } x (8 - length $reverse_exitcode{$level}) . "$reverse_exitcode{$level} | "
4668               . q{ } x (4 - length $nexus) . "$nexus | $msg\n";
4669             $nagios_alert_count{$reverse_exitcode{$level}}++;
4670         }
4671     }
4672     if ($#report_other >= 0) {
4673         print "-----------------------------------------------------------------------------\n";
4674         print "   Other messages                                                            \n";
4675         print "=============================================================================\n";
4676         print "  STATE  |  MESSAGE TEXT                                                     \n";
4677         print "---------+-------------------------------------------------------------------\n";
4678         foreach (@report_other) {
4679             my ($msg, $level, $nexus) = @{$_};
4680             print q{ } x (8 - length $reverse_exitcode{$level}) . "$reverse_exitcode{$level} | $msg\n";
4681             $nagios_alert_count{$reverse_exitcode{$level}}++;
4682         }
4683     }
4684 }
4685 else {
4686     my $c = 0;  # counter to determine linebreaks
4687
4688     # Run through each message, sorted by severity level
4689   ALERT:
4690     foreach (sort {$a->[1] < $b->[1]} (@report_storage, @report_chassis, @report_other)) {
4691         my ($msg, $level, $nexus) = @{ $_ };
4692         next ALERT if $level == $E_OK;
4693
4694         if (defined $opt{only}) {
4695             # If user wants only critical alerts
4696             next ALERT if ($opt{only} eq 'critical' and $level == $E_WARNING);
4697
4698             # If user wants only warning alerts
4699             next ALERT if ($opt{only} eq 'warning' and $level == $E_CRITICAL);
4700         }
4701
4702         # Prefix with service tag if specified with option '-i|--info'
4703         if ($opt{info}) {
4704             if (defined $opt{htmlinfo}) {
4705                 $msg = '[<a href="' . warranty_url($sysinfo{serial})
4706                   . "\">$sysinfo{serial}</a>] " . $msg;
4707             }
4708             else {
4709                 $msg = "[$sysinfo{serial}] " . $msg;
4710             }
4711         }
4712
4713         # Prefix with nagios level if specified with option '--state'
4714         $msg = $reverse_exitcode{$level} . ": $msg" if $opt{state};
4715
4716         # Prefix with one-letter nagios level if specified with option '--short-state'
4717         $msg = (substr $reverse_exitcode{$level}, 0, 1) . ": $msg" if $opt{shortstate};
4718
4719         ($c++ == 0) ? print $msg : print $linebreak, $msg;
4720
4721         $nagios_alert_count{$reverse_exitcode{$level}}++;
4722     }
4723 }
4724
4725 # Determine our exit code
4726 $exit_code = $E_OK;
4727 $exit_code = $E_UNKNOWN  if $nagios_alert_count{'UNKNOWN'} > 0;
4728 $exit_code = $E_WARNING  if $nagios_alert_count{'WARNING'} > 0;
4729 $exit_code = $E_CRITICAL if $nagios_alert_count{'CRITICAL'} > 0;
4730
4731 # Global status via SNMP.. extra safety check
4732 if ($globalstatus != $E_OK && $exit_code == $E_OK && !defined $opt{only}) {
4733     print "OOPS! Something is wrong with this server, but I don't know what. ";
4734     print "The global system health status is $reverse_exitcode{$globalstatus}, ";
4735     print "but every component check is OK. This may be a bug in the Nagios plugin, ";
4736     print "please file a bug report.\n";
4737     exit $E_UNKNOWN;
4738 }
4739
4740 # Print OK message
4741 if ($exit_code == $E_OK && defined $opt{only} && $opt{only} !~ m{\A critical|warning|chassis \z}xms && !$opt{debug}) {
4742     my %okmsg
4743       = ( 'storage'     => "STORAGE OK - $count{pdisk} physical drives, $count{vdisk} logical drives",
4744           'fans'        => $count{fan} == 0 && $blade ? 'OK - blade system with no fan probes' : "FANS OK - $count{fan} fan probes checked",
4745           'temp'        => "TEMPERATURES OK - $count{temp} temperature probes checked",
4746           'memory'      => "MEMORY OK - $count{dimm} memory modules, $count{mem} MB total memory",
4747           'power'       => $count{power} == 0 ? 'OK - no instrumented power supplies found' : "POWER OK - $count{power} power supplies checked",
4748           'cpu'         => "PROCESSORS OK - $count{cpu} processors checked",
4749           'voltage'     => "VOLTAGE OK - $count{volt} voltage probes checked",
4750           'batteries'   => $count{bat} == 0 ? 'OK - no batteries found' : "BATTERIES OK - $count{bat} batteries checked",
4751           'amperage'    => $count{amp} == 0 ? 'OK - no power monitoring probes found' : "AMPERAGE OK - $count{amp} amperage (power monitoring) probes checked",
4752           'intrusion'   => $count{intr} == 0 ? 'OK - no intrusion detection probes found' : "INTRUSION OK - $count{intr} intrusion detection probes checked",
4753           'alertlog'    => $snmp ? 'OK - not supported via snmp' : "OK - Alert Log content: $count{alert}{Ok} ok, $count{alert}{'Non-Critical'} warning and $count{alert}{Critical} critical",
4754           'esmlog'      => "OK - ESM Log content: $count{esm}{Ok} ok, $count{esm}{'Non-Critical'} warning and $count{esm}{Critical} critical",
4755           'esmhealth'   => "ESM LOG OK - less than 80% used",
4756           'sdcard'      => "SD CARDS OK - $count{sd} SD cards installed",
4757         );
4758
4759     print $okmsg{$opt{only}};
4760
4761     # show blacklisted components
4762     if ($opt{show_blacklist} and %blacklist) {
4763         my @blstr = ();
4764         foreach (keys %blacklist) {
4765             push @blstr, "$_=" . join ',', @{ $blacklist{$_} };
4766         }
4767         print $linebreak;
4768         print "----- BLACKLISTED: " . join '/', @blstr;
4769     }
4770 }
4771 elsif ($exit_code == $E_OK && !$opt{debug}) {
4772     if (defined $opt{htmlinfo}) {
4773         printf q{OK - System: '<a href="%s">%s%s</a>', SN: '<a href="%s">%s</a>'},
4774           documentation_url($sysinfo{model}), $sysinfo{model}, $sysinfo{rev},
4775             warranty_url($sysinfo{serial}), $sysinfo{serial};
4776     }
4777     else {
4778         printf q{OK - System: '%s%s', SN: '%s'},
4779           $sysinfo{model}, $sysinfo{rev}, $sysinfo{serial};
4780     }
4781
4782     if ($check{memory}) {
4783         my $unit = 'MB';
4784         if ($count{mem} >= 1024) {
4785             $count{mem} /= 1024;
4786             $unit = 'GB';
4787         }
4788         printf ', %d %s ram (%d dimms)', $count{mem}, $unit, $count{dimm};
4789     }
4790     else {
4791         print ', not checking memory';
4792     }
4793
4794     if ($check{storage}) {
4795         printf ', %d logical drives, %d physical drives',
4796           $count{vdisk}, $count{pdisk};
4797     }
4798     else {
4799         print ', not checking storage';
4800     }
4801
4802     # show blacklisted components
4803     if ($opt{show_blacklist} and %blacklist) {
4804         my @blstr = ();
4805         foreach (keys %blacklist) {
4806             push @blstr, "$_=" . join ',', @{ $blacklist{$_} };
4807         }
4808         print $linebreak;
4809         print "----- BLACKLISTED: " . join '/', @blstr;
4810     }
4811
4812     if ($opt{okinfo} >= 1) {
4813         print $linebreak;
4814         printf q{----- BIOS='%s %s'}, $sysinfo{bios}, $sysinfo{biosdate};
4815
4816         if ($sysinfo{rac}) {
4817             printf q{, %s='%s'}, $sysinfo{rac_name}, $sysinfo{rac_fw};
4818         }
4819         if ($sysinfo{bmc}) {
4820             printf q{, BMC='%s'}, $sysinfo{bmc_fw};
4821         }
4822     }
4823
4824     if ($opt{okinfo} >= 2) {
4825         if ($check{storage}) {
4826             my @storageprint = ();
4827             foreach my $id (sort keys %{ $sysinfo{controller} }) {
4828                 chomp $sysinfo{controller}{$id}{driver};
4829                 my $msg = sprintf q{----- Ctrl %s [%s]: Fw='%s', Dr='%s'},
4830                   $sysinfo{controller}{$id}{id}, $sysinfo{controller}{$id}{name},
4831                     $sysinfo{controller}{$id}{firmware}, $sysinfo{controller}{$id}{driver};
4832                 if (defined $sysinfo{controller}{$id}{storport}) {
4833                     $msg .= sprintf q{, Storport: '%s'}, $sysinfo{controller}{$id}{storport};
4834                 }
4835                 push @storageprint, $msg;
4836             }
4837             foreach my $id (sort keys %{ $sysinfo{enclosure} }) {
4838                 push @storageprint, sprintf q{----- Encl %s [%s]: Fw='%s'},
4839                   $sysinfo{enclosure}{$id}->{id}, $sysinfo{enclosure}{$id}->{name},
4840                     $sysinfo{enclosure}{$id}->{firmware};
4841             }
4842
4843             # print stuff
4844             foreach my $line (@storageprint) {
4845                 print $linebreak, $line;
4846             }
4847         }
4848     }
4849
4850     if ($opt{okinfo} >= 3) {
4851         print "$linebreak----- OpenManage Server Administrator (OMSA) version: '$sysinfo{om}'";
4852     }
4853
4854 }
4855 else {
4856     if ($opt{extinfo}) {
4857         print $linebreak;
4858         if (defined $opt{htmlinfo}) {
4859             printf '------ SYSTEM: <a href="%s">%s%s</a>, SN: <a href="%s">%s</a>',
4860               documentation_url($sysinfo{model}), $sysinfo{model}, $sysinfo{rev},
4861                 warranty_url($sysinfo{serial}), $sysinfo{serial};
4862         }
4863         else {
4864             printf '------ SYSTEM: %s%s, SN: %s',
4865               $sysinfo{model}, $sysinfo{rev}, $sysinfo{serial};
4866         }
4867     }
4868     if (defined $opt{postmsg}) {
4869         my $post = undef;
4870         if (-f $opt{postmsg}) {
4871             open my $POST, '<', $opt{postmsg}
4872               or ( print $linebreak
4873                    and print "ERROR: Couldn't open post message file $opt{postmsg}: $!\n"
4874                    and exit $E_UNKNOWN );
4875             $post = <$POST>;
4876             close $POST;
4877             chomp $post;
4878         }
4879         else {
4880             $post = $opt{postmsg};
4881         }
4882         if (defined $post) {
4883             print $linebreak;
4884             $post =~ s{[%]s}{$sysinfo{serial}}gxms;
4885             $post =~ s{[%]m}{$sysinfo{model}$sysinfo{rev}}gxms;
4886             $post =~ s{[%]b}{$sysinfo{bios}}gxms;
4887             $post =~ s{[%]d}{$sysinfo{biosdate}}gxms;
4888             $post =~ s{[%]o}{$sysinfo{osname}}gxms;
4889             $post =~ s{[%]r}{$sysinfo{osver}}gxms;
4890             $post =~ s{[%]p}{$count{pdisk}}gxms;
4891             $post =~ s{[%]l}{$count{vdisk}}gxms;
4892             $post =~ s{[%]n}{$linebreak}gxms;
4893             $post =~ s{[%]{2}}{%}gxms;
4894             print $post;
4895         }
4896     }
4897 }
4898
4899 # Reset the WARN signal
4900 $SIG{__WARN__} = 'DEFAULT';
4901
4902 # Print any perl warnings that have occured
4903 if (@perl_warnings) {
4904     foreach (@perl_warnings) {
4905         chop @$_;
4906         print "${linebreak}INTERNAL ERROR: @$_";
4907     }
4908     $exit_code = $E_UNKNOWN;
4909 }
4910
4911 # Print performance data
4912 if (defined $opt{perfdata} && !$opt{debug} && @perfdata) {
4913     my $lb = $opt{perfdata} eq 'multiline' ? "\n" : q{ };  # line break for perfdata
4914     print q{|};
4915
4916     # Sort routine for performance data
4917     sub perfsort {
4918         my %order = ( 'T' => 0, 'W' => 1, 'A' => 2, 'V' => 3, 'F' => 4, 'E' => 5, );
4919
4920         # sort in this order:
4921         #  1. the type according to the hash "order" above
4922         #  2. the id (index) numerically
4923         #  3. the id (index) alphabetically
4924         #  4. the label
4925         return $order{$a->{type}} cmp $order{$b->{type}} ||
4926           ($a->{id} =~ m{\A\d+\z}xms and $a->{id} <=> $b->{id}) ||
4927             ($a->{id} !~ m{\A\d+\z}xms and $a->{id} cmp $b->{id}) ||
4928               $a->{label} cmp $b->{label};
4929     }
4930
4931     # Print performance data sorted
4932     my $type = $opt{perfdata} eq 'minimal' ? 'mini' : 'label';
4933     print join $lb, map { "$_->{type}$_->{id}_$_->{$type}=$_->{value}$_->{unit};$_->{warn};$_->{crit}" } sort perfsort @perfdata;
4934 }
4935
4936 # Print a linebreak at the end
4937 print "\n" if !$opt{debug};
4938
4939 # Exit with proper exit code
4940 exit $exit_code;