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;
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             my $index = $name;
2532             $index =~ s{\A Temperature\sProbe\s(\d+) \z}{$1}gxms;
2533             push @perfdata, {
2534                              type  => 'E',
2535                              id    => $opt{perfdata} eq 'minimal' ? "${encl_id}_t${index}" : "${encl_id}_temp_${index}",
2536                              unit  => 'C',
2537                              label => q{},
2538                              value => $reading,
2539                              warn  => $max_warn,
2540                              crit  => $max_crit,
2541                             };
2542         }
2543     }
2544     return;
2545 }
2546
2547
2548 #-----------------------------------------
2549 # STORAGE: Check enclosure management modules (EMM)
2550 #-----------------------------------------
2551 sub check_enclosure_emms {
2552     return if $#controllers == -1;
2553
2554     my $nexus     = undef;
2555     my $name      = undef;
2556     my $state     = undef;
2557     my $status    = undef;
2558     my $encl_id   = undef;
2559     my $encl_name = undef;
2560     my @output    = ();
2561
2562     if ($snmp) {
2563         my %emms_oid
2564           = (
2565              '1.3.6.1.4.1.674.10893.1.20.130.13.1.2'  => 'enclosureManagementModuleName',
2566              '1.3.6.1.4.1.674.10893.1.20.130.13.1.4'  => 'enclosureManagementModuleState',
2567              '1.3.6.1.4.1.674.10893.1.20.130.13.1.11' => 'enclosureManagementModuleComponentStatus',
2568              '1.3.6.1.4.1.674.10893.1.20.130.13.1.12' => 'enclosureManagementModuleNexusID',
2569              '1.3.6.1.4.1.674.10893.1.20.130.14.1.4'  => 'enclosureManagementModuleConnectionEnclosureName',
2570              '1.3.6.1.4.1.674.10893.1.20.130.14.1.5'  => 'enclosureManagementModuleConnectionEnclosureNumber',
2571             );
2572         my $result = undef;
2573         if ($opt{use_get_table}) {
2574             my $enclosureManagementModuleTable = '1.3.6.1.4.1.674.10893.1.20.130.13';
2575             my $enclosureManagementModuleConnectionTable = '1.3.6.1.4.1.674.10893.1.20.130.14';
2576
2577             $result = $snmp_session->get_table(-baseoid => $enclosureManagementModuleTable);
2578             my $ext = $snmp_session->get_table(-baseoid => $enclosureManagementModuleConnectionTable);
2579
2580             if (defined $result) {
2581                 defined $ext && map { $$result{$_} = $$ext{$_} } keys %{ $ext };
2582             }
2583         }
2584         else {
2585             $result = $snmp_session->get_entries(-columns => [keys %emms_oid]);
2586         }
2587
2588         # No enclosure EMMs is OK
2589         return if !defined $result;
2590
2591         @output = @{ get_snmp_output($result, \%emms_oid) };
2592     }
2593     else {
2594         foreach my $enc (@enclosures) {
2595             push @output, @{ run_omreport("storage enclosure controller=$enc->{ctrl} enclosure=$enc->{id} info=emms") };
2596             map_item('ctrl', $enc->{ctrl}, \@output);
2597             map_item('encl_id', $enc->{id}, \@output);
2598             map_item('encl_name', $enc->{name}, \@output);
2599         }
2600     }
2601
2602     my %emms_state
2603       = (
2604          0  => 'Unknown',
2605          1  => 'Ready',
2606          2  => 'Failed',
2607          3  => 'Online',
2608          4  => 'Offline',
2609          5  => 'Not Installed',
2610          6  => 'Degraded',
2611          21 => 'Missing',
2612         );
2613
2614     # Check EMMs on each of the enclosures
2615   EMM:
2616     foreach my $out (@output) {
2617         if ($snmp) {
2618             $name      = $out->{enclosureManagementModuleName} || 'Unknown EMM';
2619             $state     = get_hashval($out->{enclosureManagementModuleState}, \%emms_state) || 'Unknown state';
2620             $status    = get_snmp_status($out->{enclosureManagementModuleComponentStatus});
2621             $encl_id   = $snmp_enclosure{$out->{enclosureManagementModuleConnectionEnclosureNumber}}{nexus};
2622             $encl_name = $out->{enclosureManagementModuleConnectionEnclosureName} || 'Unknown enclosure';
2623             $nexus     = convert_nexus(($out->{enclosureManagementModuleNexusID} || 9999));
2624         }
2625         else {
2626             $name      = get_nonempty_string('Name', $out, 'Unknown EMM');
2627             $state     = get_nonempty_string('State', $out, 'Unknown state');
2628             $status    = get_nonempty_string('Status', $out, 'Unknown');
2629             $encl_id   = join q{:}, $out->{ctrl}, $out->{'encl_id'};
2630             $encl_name = $out->{encl_name};
2631             $nexus     = join q{:}, $out->{ctrl}, $out->{'encl_id'}, get_nonempty_string('ID', $out, '9999');
2632         }
2633
2634         next EMM if blacklisted('encl_emm', $nexus);
2635
2636         # Not installed
2637         if ($status =~ m{\A Other|Unknown \z}xms and $state eq 'Not Installed') {
2638             my $msg = sprintf '%s in enclosure %s [%s] is %s',
2639               $name, $encl_id, $encl_name, $state;
2640             report('storage', $msg, $E_OK, $nexus);
2641         }
2642         # Default
2643         elsif ($status ne 'Ok') {
2644             my $msg = sprintf '%s in enclosure %s [%s] needs attention: %s',
2645               $name, $encl_id, $encl_name, $state;
2646             report('storage', $msg, $status2nagios{$status}, $nexus);
2647         }
2648         # Ok
2649         else {
2650             my $msg = sprintf '%s in enclosure %s [%s] is %s',
2651               $name, $encl_id, $encl_name, $state;
2652             report('storage', $msg, $E_OK, $nexus);
2653         }
2654     }
2655     return;
2656 }
2657
2658
2659 #-----------------------------------------
2660 # CHASSIS: Check memory modules
2661 #-----------------------------------------
2662 sub check_memory {
2663     my $index    = undef;
2664     my $status   = undef;
2665     my $location = undef;
2666     my $size     = undef;
2667     my $modes    = undef;
2668     my @failures = ();
2669     my @output   = ();
2670
2671     if ($snmp) {
2672         my %dimm_oid
2673           = (
2674              '1.3.6.1.4.1.674.10892.1.1100.50.1.2.1'  => 'memoryDeviceIndex',
2675              '1.3.6.1.4.1.674.10892.1.1100.50.1.5.1'  => 'memoryDeviceStatus',
2676              '1.3.6.1.4.1.674.10892.1.1100.50.1.8.1'  => 'memoryDeviceLocationName',
2677              '1.3.6.1.4.1.674.10892.1.1100.50.1.14.1' => 'memoryDeviceSize',
2678              '1.3.6.1.4.1.674.10892.1.1100.50.1.20.1' => 'memoryDeviceFailureModes',
2679             );
2680         my $result = undef;
2681         if ($opt{use_get_table}) {
2682             my $memoryDeviceTable = '1.3.6.1.4.1.674.10892.1.1100.50.1';
2683             $result = $snmp_session->get_table(-baseoid => $memoryDeviceTable);
2684         }
2685         else {
2686             $result = $snmp_session->get_entries(-columns => [keys %dimm_oid]);
2687         }
2688
2689         if (!defined $result) {
2690             printf "SNMP ERROR [memory]: %s.\n", $snmp_session->error;
2691             $snmp_session->close;
2692             exit $E_UNKNOWN;
2693         }
2694
2695         @output = @{ get_snmp_output($result, \%dimm_oid) };
2696     }
2697     else {
2698         @output = @{ run_omreport("$omopt_chassis memory") };
2699     }
2700
2701     # Note: These values are bit masks, so combination values are
2702     # possible. If value is 0 (zero), memory device has no faults.
2703     my %failure_mode
2704       = (
2705          1  => 'ECC single bit correction warning rate exceeded',
2706          2  => 'ECC single bit correction failure rate exceeded',
2707          4  => 'ECC multibit fault encountered',
2708          8  => 'ECC single bit correction logging disabled',
2709          16 => 'device disabled because of spare activation',
2710         );
2711
2712   DIMM:
2713     foreach my $out (@output) {
2714         @failures = ();  # Initialize
2715         if ($snmp) {
2716             $index    = ($out->{memoryDeviceIndex} || 10000) - 1;
2717             $status   = get_snmp_status($out->{memoryDeviceStatus});
2718             $location = $out->{memoryDeviceLocationName} || 'Unknown location';
2719             $size     = sprintf '%d MB', ($out->{memoryDeviceSize} || 0)/1024;
2720             $modes    = $out->{memoryDeviceFailureModes} || -9999;
2721             if ($modes > 0) {
2722                 foreach my $mask (sort keys %failure_mode) {
2723                     if (($modes & $mask) != 0) { push @failures, $failure_mode{$mask}; }
2724                 }
2725             }
2726             elsif ($modes == -9999) {
2727                 push @failures, q{ERROR: Failure modes not available via SNMP};
2728             }
2729         }
2730         else {
2731             my $type  = get_nonempty_string('Type', $out, q{});
2732             $index    = $type eq '[Not Occupied]' ? undef : get_nonempty_string('Index', $out, 9999);
2733             $status   = get_nonempty_string('Status', $out, 'Unknown');
2734             $location = get_nonempty_string('Connector Name', $out, 'Unknown location');
2735             $size     = get_nonempty_string('Size', $out, 0);
2736             if (defined $size) {
2737                 $size =~ s{\s\s}{ }gxms;
2738             }
2739             # Run 'omreport chassis memory index=X' to get the failures
2740             if ($status ne 'Ok' && defined $index) {
2741                 foreach (@{ run_command("$omreport $omopt_chassis memory index=$index -fmt ssv") }) {
2742                     if (m/\A Failures; (.+?) \z/xms) {
2743                         chop(my $fail = $1);
2744                         push @failures, split m{\.}xms, $fail;
2745                     }
2746                 }
2747             }
2748         }
2749         $location =~ s{\A \s*(.*?)\s* \z}{$1}xms;
2750
2751         # calculate total memory
2752         my $msize = defined $size ? $size : 0;
2753         $msize =~ s{\A (\d+) \s MB}{$1}xms;
2754         $count{mem} += $msize;
2755
2756         # Ignore empty memory slots
2757         next DIMM if !defined $index;
2758
2759         $count{dimm}++;
2760         next DIMM if blacklisted('dimm', $index);
2761
2762         if ($status ne 'Ok') {
2763             my $msg = undef;
2764             if (scalar @failures == 0) {
2765                 $msg = sprintf 'Memory module %d [%s, %s] needs attention (%s)',
2766                   $index, $location, $size, $status;
2767             }
2768             else {
2769                 $msg = sprintf 'Memory module %d [%s, %s] needs attention: %s',
2770                   $index, $location, $size, (join q{, }, @failures);
2771             }
2772
2773             report('chassis', $msg, $status2nagios{$status}, $index);
2774         }
2775         # Ok
2776         else {
2777             my $msg = sprintf 'Memory module %d [%s, %s] is %s',
2778               $index, $location, $size, $status;
2779             report('chassis', $msg, $E_OK, $index);
2780         }
2781     }
2782     return;
2783 }
2784
2785
2786 #-----------------------------------------
2787 # CHASSIS: Check fans
2788 #-----------------------------------------
2789 sub check_fans {
2790     my $index    = undef;
2791     my $status   = undef;
2792     my $reading  = undef;
2793     my $location = undef;
2794     my $max_crit = undef;
2795     my $max_warn = undef;
2796     my @output   = ();
2797
2798     if ($snmp) {
2799         my %cool_oid
2800           = (
2801              '1.3.6.1.4.1.674.10892.1.700.12.1.2.1'  => 'coolingDeviceIndex',
2802              '1.3.6.1.4.1.674.10892.1.700.12.1.5.1'  => 'coolingDeviceStatus',
2803              '1.3.6.1.4.1.674.10892.1.700.12.1.6.1'  => 'coolingDeviceReading',
2804              '1.3.6.1.4.1.674.10892.1.700.12.1.8.1'  => 'coolingDeviceLocationName',
2805              '1.3.6.1.4.1.674.10892.1.700.12.1.10.1' => 'coolingDeviceUpperCriticalThreshold',
2806              '1.3.6.1.4.1.674.10892.1.700.12.1.11.1' => 'coolingDeviceUpperNonCriticalThreshold',
2807             );
2808         my $result = undef;
2809         if ($opt{use_get_table}) {
2810             my $coolingDeviceTable = '1.3.6.1.4.1.674.10892.1.700.12.1';
2811             $result = $snmp_session->get_table(-baseoid => $coolingDeviceTable);
2812         }
2813         else {
2814             $result = $snmp_session->get_entries(-columns => [keys %cool_oid]);
2815         }
2816
2817         if ($blade && !defined $result) {
2818             return 0;
2819         }
2820         elsif (!$blade && !defined $result) {
2821             printf "SNMP ERROR [cooling]: %s.\n", $snmp_session->error;
2822             $snmp_session->close;
2823             exit $E_UNKNOWN;
2824         }
2825
2826         @output = @{ get_snmp_output($result, \%cool_oid) };
2827     }
2828     else {
2829         @output = @{ run_omreport("$omopt_chassis fans") };
2830     }
2831
2832   FAN:
2833     foreach my $out (@output) {
2834         if ($snmp) {
2835             $index    = ($out->{coolingDeviceIndex} || 10000) - 1;
2836             $status   = get_snmp_probestatus($out->{coolingDeviceStatus});
2837             $reading  = $out->{coolingDeviceReading} || 0;
2838             $location = $out->{coolingDeviceLocationName} || 'Unknown location';
2839             $max_crit = $out->{coolingDeviceUpperCriticalThreshold} || 0;
2840             $max_warn = $out->{coolingDeviceUpperNonCriticalThreshold} || 0;
2841         }
2842         else {
2843             $index    = get_nonempty_string('Index', $out, 9999);
2844             $status   = get_nonempty_string('Status', $out, 'Unknown');
2845             $reading  = get_nonempty_string('Reading', $out, 0);
2846             $location = get_nonempty_string('Probe Name', $out, 'Unknown location');
2847             $max_crit = get_nonempty_string('Maximum Failure Threshold', $out, 0);
2848             $max_warn = get_nonempty_string('Maximum Warning Threshold', $out, 0);
2849             if ($max_crit eq '[N/A]') { $max_crit = 0; }
2850             if ($max_warn eq '[N/A]') { $max_warn = 0; }
2851             $reading  =~ s{\A (\d+).* \z}{$1}xms;
2852             $max_warn =~ s{\A (\d+).* \z}{$1}xms;
2853             $max_crit =~ s{\A (\d+).* \z}{$1}xms;
2854         }
2855
2856         $count{fan}++;
2857         next FAN if blacklisted('fan', $index);
2858
2859         if ($status ne 'Ok') {
2860             my $msg = sprintf 'Chassis fan %d [%s] needs attention: %s',
2861               $index, $location, $status;
2862             my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
2863             report('chassis', $msg, $err, $index);
2864         }
2865         else {
2866             my $msg = sprintf 'Chassis fan %d [%s]: %s',
2867               $index, $location, $reading;
2868             report('chassis', $msg, $E_OK, $index);
2869         }
2870
2871         # Collect performance data
2872         if (defined $opt{perfdata}) {
2873             my $pname = $location;
2874             $pname =~ s{\s}{_}gxms;
2875             $pname =~ s{proc_}{cpu#}xms;
2876             $pname =~ s{_rpm\z}{}ixms;
2877             push @perfdata, {
2878                              type  => 'F',
2879                              id    => $index,
2880                              unit  => 'rpm',
2881                              label => $pname,
2882                              value => $reading,
2883                              warn  => $max_warn,
2884                              crit  => $max_crit,
2885                             };
2886         }
2887     }
2888     return;
2889 }
2890
2891
2892 #-----------------------------------------
2893 # CHASSIS: Check power supplies
2894 #-----------------------------------------
2895 sub check_powersupplies {
2896     my $index    = undef;
2897     my $status   = undef;
2898     my $type     = undef;
2899     my $err_type = undef;
2900     my $state    = undef;
2901     my @states   = ();
2902     my @output   = ();
2903
2904     if ($snmp) {
2905         my %ps_oid
2906           = (
2907              '1.3.6.1.4.1.674.10892.1.600.12.1.2.1'  => 'powerSupplyIndex',
2908              '1.3.6.1.4.1.674.10892.1.600.12.1.5.1'  => 'powerSupplyStatus',
2909              '1.3.6.1.4.1.674.10892.1.600.12.1.7.1'  => 'powerSupplyType',
2910              '1.3.6.1.4.1.674.10892.1.600.12.1.11.1' => 'powerSupplySensorState',
2911              '1.3.6.1.4.1.674.10892.1.600.12.1.12.1' => 'powerSupplyConfigurationErrorType',
2912             );
2913         my $result = undef;
2914         if ($opt{use_get_table}) {
2915             my $powerDeviceTable = '1.3.6.1.4.1.674.10892.1.600.12.1';
2916             $result = $snmp_session->get_table(-baseoid => $powerDeviceTable);
2917         }
2918         else {
2919             $result = $snmp_session->get_entries(-columns => [keys %ps_oid]);
2920         }
2921
2922         # No instrumented PSU is OK (blades, low-end servers)
2923         return 0 if !defined $result;
2924
2925         @output = @{ get_snmp_output($result, \%ps_oid) };
2926     }
2927     else {
2928         @output = @{ run_omreport("$omopt_chassis pwrsupplies") };
2929     }
2930
2931     my %ps_type
2932       = (
2933          1  => 'Other',
2934          2  => 'Unknown',
2935          3  => 'Linear',
2936          4  => 'Switching',
2937          5  => 'Battery',
2938          6  => 'Uninterruptible Power Supply',
2939          7  => 'Converter',
2940          8  => 'Regulator',
2941          9  => 'AC',
2942          10 => 'DC',
2943          11 => 'VRM',
2944         );
2945
2946     my %ps_state
2947       = (
2948          1  => 'Presence detected',
2949          2  => 'Failure detected',
2950          4  => 'Predictive Failure',
2951          8  => 'AC lost',
2952          16 => 'AC lost or out-of-range',
2953          32 => 'AC out-of-range but present',
2954          64 => 'Configuration error',
2955         );
2956
2957     my %ps_config_error_type
2958       = (
2959          1 => 'Vendor mismatch',
2960          2 => 'Revision mismatch',
2961          3 => 'Processor missing',
2962         );
2963
2964   PS:
2965     foreach my $out (@output) {
2966         if ($snmp) {
2967             @states = ();  # contains states for the PS
2968
2969             $index    = ($out->{powerSupplyIndex} || 10000) - 1;
2970             $status   = get_snmp_status($out->{powerSupplyStatus});
2971             $type     = get_hashval($out->{powerSupplyType}, \%ps_type) || 'Unknown type';
2972             $err_type = get_hashval($out->{powerSupplyConfigurationErrorType}, \%ps_config_error_type);
2973
2974             # get the combined state from the StatusReading OID
2975             my $raw_state = $out->{powerSupplySensorState} || 0;
2976             foreach my $mask (sort keys %ps_state) {
2977                 if (($raw_state & $mask) != 0) {
2978                     push @states, $ps_state{$mask};
2979                 }
2980             }
2981
2982             # If configuration error, also include the error type
2983             if (defined $err_type) {
2984                 push @states, $err_type;
2985             }
2986
2987             # Finally, construct the state string
2988             $state = join q{, }, @states;
2989         }
2990         else {
2991             $index  = get_nonempty_string('Index', $out, 9999);
2992             $status = get_nonempty_string('Status', $out, 'Unknown');
2993             $type   = get_nonempty_string('Type', $out, 'Unknown type');
2994             $state  = get_nonempty_string('Online Status', $out, 'Unknown state');
2995         }
2996
2997         $count{power}++;
2998         next PS if blacklisted('ps', $index);
2999
3000         if ($status ne 'Ok') {
3001             my $msg = sprintf 'Power Supply %d [%s] needs attention: %s',
3002               $index, $type, $state;
3003             report('chassis', $msg, $status2nagios{$status}, $index);
3004         }
3005         else {
3006             my $msg = sprintf 'Power Supply %d [%s]: %s',
3007               $index, $type, $state;
3008             report('chassis', $msg, $E_OK, $index);
3009         }
3010     }
3011     return;
3012 }
3013
3014
3015 #-----------------------------------------
3016 # CHASSIS: Check temperatures
3017 #-----------------------------------------
3018 sub check_temperatures {
3019     my $index    = undef;
3020     my $status   = undef;
3021     my $reading  = undef;
3022     my $location = undef;
3023     my $max_crit = undef;
3024     my $max_warn = undef;
3025     my $min_warn = undef;
3026     my $min_crit = undef;
3027     my $type     = undef;
3028     my $discrete = undef;
3029     my @output = ();
3030
3031     # Getting custom temperature thresholds (user option)
3032     my %warn_threshold = %{ custom_temperature_thresholds('w') };
3033     my %crit_threshold = %{ custom_temperature_thresholds('c') };
3034
3035     if ($snmp) {
3036         my %temp_oid
3037           = (
3038              '1.3.6.1.4.1.674.10892.1.700.20.1.2.1'  => 'temperatureProbeIndex',
3039              '1.3.6.1.4.1.674.10892.1.700.20.1.5.1'  => 'temperatureProbeStatus',
3040              '1.3.6.1.4.1.674.10892.1.700.20.1.6.1'  => 'temperatureProbeReading',
3041              '1.3.6.1.4.1.674.10892.1.700.20.1.7.1'  => 'temperatureProbeType',
3042              '1.3.6.1.4.1.674.10892.1.700.20.1.8.1'  => 'temperatureProbeLocationName',
3043              '1.3.6.1.4.1.674.10892.1.700.20.1.10.1' => 'temperatureProbeUpperCriticalThreshold',
3044              '1.3.6.1.4.1.674.10892.1.700.20.1.11.1' => 'temperatureProbeUpperNonCriticalThreshold',
3045              '1.3.6.1.4.1.674.10892.1.700.20.1.12.1' => 'temperatureProbeLowerNonCriticalThreshold',
3046              '1.3.6.1.4.1.674.10892.1.700.20.1.13.1' => 'temperatureProbeLowerCriticalThreshold',
3047              '1.3.6.1.4.1.674.10892.1.700.20.1.16.1' => 'temperatureProbeDiscreteReading',
3048             );
3049         # this didn't work well for some reason
3050         #my $result = $snmp_session->get_entries(-columns => [keys %temp_oid]);
3051
3052         # Getting values using the table
3053         my $temperatureProbeTable = '1.3.6.1.4.1.674.10892.1.700.20';
3054         my $result = $snmp_session->get_table(-baseoid => $temperatureProbeTable);
3055
3056         if (!defined $result) {
3057             printf "SNMP ERROR [temperatures]: %s.\n", $snmp_session->error;
3058             $snmp_session->close;
3059             exit $E_UNKNOWN;
3060         }
3061
3062         @output = @{ get_snmp_output($result, \%temp_oid) };
3063     }
3064     else {
3065         @output = @{ run_omreport("$omopt_chassis temps") };
3066     }
3067
3068     my %probe_type
3069       = (
3070          1  => 'Other',      # type is other than following values
3071          2  => 'Unknown',    # type is unknown
3072          3  => 'AmbientESM', # type is Ambient Embedded Systems Management temperature probe
3073          16 => 'Discrete',   # type is temperature probe with discrete reading
3074         );
3075
3076   TEMP:
3077     foreach my $out (@output) {
3078         if ($snmp) {
3079             $index    = ($out->{temperatureProbeIndex} || 10000) - 1;
3080             $status   = get_snmp_probestatus($out->{temperatureProbeStatus});
3081             $location = $out->{temperatureProbeLocationName} || 'Unknown location';
3082             $type     = get_hashval($out->{temperatureProbeType}, \%probe_type);
3083             $reading  = $out->{temperatureProbeReading} || '[N/A]';
3084             $max_crit = $out->{temperatureProbeUpperCriticalThreshold} || '[N/A]';
3085             $max_warn = $out->{temperatureProbeUpperNonCriticalThreshold} || '[N/A]';
3086             $min_crit = $out->{temperatureProbeLowerCriticalThreshold} || '[N/A]';
3087             $min_warn = $out->{temperatureProbeLowerNonCriticalThreshold} || '[N/A]';
3088             $discrete = $out->{temperatureProbeDiscreteReading} || '[N/A]';
3089
3090             # If numeric values, i.e. not discrete
3091             $reading  /= 10 if $reading  =~ m{\A \d+ \z}xms;
3092             $max_crit /= 10 if $max_crit =~ m{\A \d+ \z}xms;
3093             $max_warn /= 10 if $max_warn =~ m{\A \d+ \z}xms;
3094             $min_crit /= 10 if $min_crit =~ m{\A \d+ \z}xms;
3095             $min_warn /= 10 if $min_warn =~ m{\A \d+ \z}xms;
3096
3097             # workaround for bad temp probes
3098             if ($type eq 'AmbientESM' and $reading !~ m{\A \d+(\.\d+)? \z}xms) {
3099                 $type = 'Discrete';
3100             }
3101         }
3102         else {
3103             $index    = get_nonempty_string('Index', $out, 9999);
3104             $status   = get_nonempty_string('Status', $out, 'Unknown');
3105             $location = get_nonempty_string('Probe Name', $out, 'Unknown location');
3106             $reading  = get_nonempty_string('Reading', $out, '[N/A]');
3107             $max_crit = get_nonempty_string('Maximum Failure Threshold', $out, '[N/A]');
3108             $max_warn = get_nonempty_string('Maximum Warning Threshold', $out, '[N/A]');
3109             $min_crit = get_nonempty_string('Minimum Failure Threshold', $out, '[N/A]');
3110             $min_warn = get_nonempty_string('Minimum Warning Threshold', $out, '[N/A]');
3111
3112             # Cleaning the temp readings
3113             $reading =~ s{\.0\s+C}{}xms;
3114             $max_crit =~ s{\.0\s+C}{}xms;
3115             $max_warn =~ s{\.0\s+C}{}xms;
3116             $min_crit =~ s{\.0\s+C}{}xms;
3117             $min_warn =~ s{\.0\s+C}{}xms;
3118
3119             $type     = $reading =~ m{\A\d+\z}xms ? 'AmbientESM' : 'Discrete';
3120             $discrete = $reading;
3121         }
3122
3123         $count{temp}++;
3124         next TEMP if blacklisted('temp', $index);
3125
3126         if ($type eq 'Discrete') {
3127             my $msg = sprintf 'Temperature probe %d [%s] is %s',
3128               $index, $location, $discrete;
3129             my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
3130             report('chassis', $msg, $err, $index);
3131         }
3132         else {
3133             # First check according to custom thresholds
3134             if (exists $crit_threshold{$index}{max} and $reading > $crit_threshold{$index}{max}) {
3135                 # Custom critical MAX
3136                 my $msg = sprintf 'Temperature Probe %d [%s] reads %d C (custom max=%d)',
3137                   $index, $location, $reading, $crit_threshold{$index}{max};
3138                 report('chassis', $msg, $E_CRITICAL, $index);
3139             }
3140             elsif (exists $warn_threshold{$index}{max} and $reading > $warn_threshold{$index}{max}) {
3141                 # Custom warning MAX
3142                 my $msg = sprintf 'Temperature Probe %d [%s] reads %d C (custom max=%d)',
3143                   $index, $location, $reading, $warn_threshold{$index}{max};
3144                 report('chassis', $msg, $E_WARNING, $index);
3145             }
3146             elsif (exists $crit_threshold{$index}{min} and $reading < $crit_threshold{$index}{min}) {
3147                 # Custom critical MIN
3148                 my $msg = sprintf 'Temperature Probe %d [%s] reads %d C (custom min=%d)',
3149                   $index, $location, $reading, $crit_threshold{$index}{min};
3150                 report('chassis', $msg, $E_CRITICAL, $index);
3151             }
3152             elsif (exists $warn_threshold{$index}{min} and $reading < $warn_threshold{$index}{min}) {
3153                 # Custom warning MIN
3154                 my $msg = sprintf 'Temperature Probe %d [%s] reads %d C (custom min=%d)',
3155                   $index, $location, $reading, $warn_threshold{$index}{min};
3156                 report('chassis', $msg, $E_WARNING, $index);
3157             }
3158             elsif ($status ne 'Ok' and $max_crit ne '[N/A]' and $reading > $max_crit) {
3159                 my $msg = sprintf 'Temperature Probe %d [%s] is critically high at %d C',
3160                   $index, $location, $reading;
3161                 my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
3162                 report('chassis', $msg, $err, $index);
3163             }
3164             elsif ($status ne 'Ok' and $max_warn ne '[N/A]' and $reading > $max_warn) {
3165                 my $msg = sprintf 'Temperature Probe %d [%s] is too high at %d C',
3166                   $index, $location, $reading;
3167                 my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
3168                 report('chassis', $msg, $err, $index);
3169             }
3170             elsif ($status ne 'Ok' and $min_crit ne '[N/A]' and $reading < $min_crit) {
3171                 my $msg = sprintf 'Temperature Probe %d [%s] is critically low at %d C',
3172                   $index, $location, $reading;
3173                 my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
3174                 report('chassis', $msg, $err, $index);
3175             }
3176             elsif ($status ne 'Ok' and $min_warn ne '[N/A]' and $reading < $min_warn) {
3177                 my $msg = sprintf 'Temperature Probe %d [%s] is too low at %d C',
3178                   $index, $location, $reading;
3179                 my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
3180                 report('chassis', $msg, $err, $index);
3181             }
3182             # Ok
3183             else {
3184                 my $msg = sprintf 'Temperature Probe %d [%s] reads %d C',
3185                   $index, $location, $reading;
3186                 if ($min_warn eq '[N/A]' and $min_crit eq '[N/A]') {
3187                     $msg .= sprintf ' (max=%s/%s)', $max_warn, $max_crit;
3188                 }
3189                 else {
3190                     $msg .= sprintf ' (min=%s/%s, max=%s/%s)',
3191                       $min_warn, $min_crit, $max_warn, $max_crit;
3192                 }
3193                 my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
3194                 report('chassis', $msg, $err, $index);
3195             }
3196
3197             # Collect performance data
3198             if (defined $opt{perfdata}) {
3199                 my $pname = $location;
3200                 $pname =~ s{\s}{_}gxms;
3201                 $pname =~ s{_temp\z}{}xms;
3202                 $pname =~ s{proc_}{cpu#}xms;
3203                 push @perfdata, {
3204                                  type  => 'T',
3205                                  id    => $index,
3206                                  unit  => 'C',
3207                                  label => $pname,
3208                                  value => $reading,
3209                                  warn  => $max_warn,
3210                                  crit  => $max_crit,
3211                                 };
3212             }
3213         }
3214     }
3215     return;
3216 }
3217
3218
3219 #-----------------------------------------
3220 # CHASSIS: Check processors
3221 #-----------------------------------------
3222 sub check_processors {
3223     my $index   = undef;
3224     my $status  = undef;
3225     my $state   = undef;
3226     my $brand   = undef;
3227     my $family  = undef;
3228     my $man     = undef;
3229     my $speed   = undef;
3230     my @output = ();
3231
3232     if ($snmp) {
3233
3234         # NOTE: For some reason, older models don't have the
3235         # "Processor Device Status" OIDs. We check both the newer
3236         # (preferred) OIDs and the old ones.
3237
3238         my %cpu_oid
3239           = (
3240              '1.3.6.1.4.1.674.10892.1.1100.30.1.2.1'  => 'processorDeviceIndex',
3241              '1.3.6.1.4.1.674.10892.1.1100.30.1.5.1'  => 'processorDeviceStatus',
3242              '1.3.6.1.4.1.674.10892.1.1100.30.1.8.1'  => 'processorDeviceManufacturerName',
3243              '1.3.6.1.4.1.674.10892.1.1100.30.1.9.1'  => 'processorDeviceStatusState',
3244              '1.3.6.1.4.1.674.10892.1.1100.30.1.10.1' => 'processorDeviceFamily',
3245              '1.3.6.1.4.1.674.10892.1.1100.30.1.12.1' => 'processorDeviceCurrentSpeed',
3246              '1.3.6.1.4.1.674.10892.1.1100.30.1.23.1' => 'processorDeviceBrandName',
3247              '1.3.6.1.4.1.674.10892.1.1100.32.1.2.1'  => 'processorDeviceStatusIndex',
3248              '1.3.6.1.4.1.674.10892.1.1100.32.1.5.1'  => 'processorDeviceStatusStatus',
3249              '1.3.6.1.4.1.674.10892.1.1100.32.1.6.1'  => 'processorDeviceStatusReading',
3250             );
3251         my $result = undef;
3252         if ($opt{use_get_table}) {
3253             my $processorDeviceTable = '1.3.6.1.4.1.674.10892.1.1100.30.1';
3254             my $processorDeviceStatusTable = '1.3.6.1.4.1.674.10892.1.1100.32.1';
3255
3256             $result = $snmp_session->get_table(-baseoid => $processorDeviceTable);
3257             my $ext = $snmp_session->get_table(-baseoid => $processorDeviceStatusTable);
3258
3259             defined $ext && map { $$result{$_} = $$ext{$_} } keys %{ $ext };
3260         }
3261         else {
3262             $result = $snmp_session->get_entries(-columns => [keys %cpu_oid]);
3263         }
3264
3265         if (!defined $result) {
3266             printf "SNMP ERROR [processors]: %s.\n", $snmp_session->error;
3267             $snmp_session->close;
3268             exit $E_UNKNOWN;
3269         }
3270
3271         @output = @{ get_snmp_output($result, \%cpu_oid) };
3272     }
3273     else {
3274         @output = @{ run_omreport("$omopt_chassis processors") };
3275     }
3276
3277     my %cpu_state
3278       = (
3279          1 => 'Other',         # other than following values
3280          2 => 'Unknown',       # unknown
3281          3 => 'Enabled',       # enabled
3282          4 => 'User Disabled', # disabled by user via BIOS setup
3283          5 => 'BIOS Disabled', # disabled by BIOS (POST error)
3284          6 => 'Idle',          # idle
3285         );
3286
3287     my %cpu_reading
3288       = (
3289          1    => 'Internal Error',      # Internal Error
3290          2    => 'Thermal Trip',        # Thermal Trip
3291          32   => 'Configuration Error', # Configuration Error
3292          128  => 'Present',             # Processor Present
3293          256  => 'Disabled',            # Processor Disabled
3294          512  => 'Terminator Present',  # Terminator Present
3295          1024 => 'Throttled',           # Processor Throttled
3296         );
3297
3298     # Mapping between family numbers from SNMP and actual CPU family
3299     my %cpu_family
3300       = (
3301          1   => 'Other',                                2   => 'Unknown',
3302          3   => '8086',                                 4   => '80286',
3303          5   => '386',                                  6   => '486',
3304          7   => '8087',                                 8   => '80287',
3305          9   => '80387',                                10  => '80487',
3306          11  => 'Pentium',                              12  => 'Pentium Pro',
3307          13  => 'Pentium II',                           14  => 'Pentium with MMX',
3308          15  => 'Celeron',                              16  => 'Pentium II Xeon',
3309          17  => 'Pentium III',                          18  => 'Pentium III Xeon',
3310          19  => 'Pentium III',                          20  => 'Itanium',
3311          21  => 'Xeon',                                 22  => 'Pentium 4',
3312          23  => 'Xeon MP',                              24  => 'Itanium 2',
3313          25  => 'K5',                                   26  => 'K6',
3314          27  => 'K6-2',                                 28  => 'K6-3',
3315          29  => 'Athlon',                               30  => 'AMD2900',
3316          31  => 'K6-2+',                                32  => 'Power PC',
3317          33  => 'Power PC 601',                         34  => 'Power PC 603',
3318          35  => 'Power PC 603+',                        36  => 'Power PC 604',
3319          37  => 'Power PC 620',                         38  => 'Power PC x704',
3320          39  => 'Power PC 750',                         40  => 'Core Duo',
3321          41  => 'Core Duo mobile',                      42  => 'Core Solo mobile',
3322          43  => 'Intel Atom',                           44  => undef,
3323          45  => undef,                                  46  => undef,
3324          47  => undef,                                  48  => 'Alpha',
3325          49  => 'Alpha 21064',                          50  => 'Alpha 21066',
3326          51  => 'Alpha 21164',                          52  => 'Alpha 21164PC',
3327          53  => 'Alpha 21164a',                         54  => 'Alpha 21264',
3328          55  => 'Alpha 21364',                          56  => 'Turion II Ultra Dual-Core Mobile M',
3329          57  => 'Turion II Dual-Core Mobile M',         58  => 'Athlon II Dual-Core Mobile M ',
3330          59  => 'Opteron 6100',                         60  => 'Opteron 4100',
3331          61  => undef,                                  62  => undef,
3332          63  => undef,                                  64  => 'MIPS',
3333          65  => 'MIPS R4000',                           66  => 'MIPS R4200',
3334          67  => 'MIPS R4400',                           68  => 'MIPS R4600',
3335          69  => 'MIPS R10000',                          70  => undef,
3336          71  => undef,                                  72  => undef,
3337          73  => undef,                                  74  => undef,
3338          75  => undef,                                  76  => undef,
3339          77  => undef,                                  78  => undef,
3340          79  => undef,                                  80  => 'SPARC',
3341          81  => 'SuperSPARC',                           82  => 'microSPARC II',
3342          83  => 'microSPARC IIep',                      84  => 'UltraSPARC',
3343          85  => 'UltraSPARC II',                        86  => 'UltraSPARC IIi',
3344          87  => 'UltraSPARC III',                       88  => 'UltraSPARC IIIi',
3345          89  => undef,                                  90  => undef,
3346          91  => undef,                                  92  => undef,
3347          93  => undef,                                  94  => undef,
3348          95  => undef,                                  96  => '68040',
3349          97  => '68xxx',                                98  => '68000',
3350          99  => '68010',                                100 => '68020',
3351          101 => '68030',                                102 => undef,
3352          103 => undef,                                  104 => undef,
3353          105 => undef,                                  106 => undef,
3354          107 => undef,                                  108 => undef,
3355          109 => undef,                                  110 => undef,
3356          111 => undef,                                  112 => 'Hobbit',
3357          113 => undef,                                  114 => undef,
3358          115 => undef,                                  116 => undef,
3359          117 => undef,                                  118 => undef,
3360          119 => undef,                                  120 => 'Crusoe TM5000',
3361          121 => 'Crusoe TM3000',                        122 => 'Efficeon TM8000',
3362          123 => undef,                                  124 => undef,
3363          125 => undef,                                  126 => undef,
3364          127 => undef,                                  128 => 'Weitek',
3365          129 => undef,                                  130 => 'Celeron M',
3366          131 => 'Athlon 64',                            132 => 'Opteron',
3367          133 => 'Sempron',                              134 => 'Turion 64 Mobile',
3368          135 => 'Dual-Core Opteron',                    136 => 'Athlon 64 X2 DC',
3369          137 => 'Turion 64 X2 M',                       138 => 'Quad-Core Opteron',
3370          139 => '3rd gen Opteron',                      140 => 'AMD Phenom FX Quad-Core',
3371          141 => 'AMD Phenom X4 Quad-Core',              142 => 'AMD Phenom X2 Dual-Core',
3372          143 => 'AMD Athlon X2 Dual-Core',              144 => 'PA-RISC',
3373          145 => 'PA-RISC 8500',                         146 => 'PA-RISC 8000',
3374          147 => 'PA-RISC 7300LC',                       148 => 'PA-RISC 7200',
3375          149 => 'PA-RISC 7100LC',                       150 => 'PA-RISC 7100',
3376          151 => undef,                                  152 => undef,
3377          153 => undef,                                  154 => undef,
3378          155 => undef,                                  156 => undef,
3379          157 => undef,                                  158 => undef,
3380          159 => undef,                                  160 => 'V30',
3381          161 => 'Quad-Core Xeon 3200',                  162 => 'Dual-Core Xeon 3000',
3382          163 => 'Quad-Core Xeon 5300',                  164 => 'Dual-Core Xeon 5100',
3383          165 => 'Dual-Core Xeon 5000',                  166 => 'Dual-Core Xeon LV',
3384          167 => 'Dual-Core Xeon ULV',                   168 => 'Dual-Core Xeon 7100',
3385          169 => 'Quad-Core Xeon 5400',                  170 => 'Quad-Core Xeon',
3386          171 => 'Dual-Core Xeon 5200',                  172 => 'Dual-Core Xeon 7200',
3387          173 => 'Quad-Core Xeon 7300',                  174 => 'Quad-Core Xeon 7400',
3388          175 => 'Multi-Core Xeon 7400',                 176 => 'M1',
3389          177 => 'M2',                                   178 => undef,
3390          179 => 'Pentium 4 HT',                         180 => 'AS400',
3391          181 => undef,                                  182 => 'Athlon XP',
3392          183 => 'Athlon MP',                            184 => 'Duron',
3393          185 => 'Pentium M',                            186 => 'Celeron D',
3394          187 => 'Pentium D',                            188 => 'Pentium Extreme',
3395          189 => 'Core Solo',                            190 => 'Core2',
3396          191 => 'Core2 Duo',                            192 => 'Core2 Solo',
3397          193 => 'Core2 Extreme',                        194 => 'Core2 Quad',
3398          195 => 'Core2 Extreme mobile',                 196 => 'Core2 Duo mobile',
3399          197 => 'Core2 Solo mobile',                    198 => 'Core i7',
3400          199 => 'Dual-Core Celeron',                    200 => 'IBM390',
3401          201 => 'G4',                                   202 => 'G5',
3402          203 => 'ESA/390 G6',                           204 => 'z/Architectur',
3403          205 => 'Core i5',                              206 => 'Core i3',
3404          207 => undef,                                  208 => undef,
3405          209 => undef,                                  210 => 'C7-M',
3406          211 => 'C7-D',                                 212 => 'C7',
3407          213 => 'Eden',                                 214 => 'Multi-Core Xeon',
3408          215 => 'Dual-Core Xeon 3xxx',                  216 => 'Quad-Core Xeon 3xxx',
3409          217 => 'VIA Nano',                             218 => 'Dual-Core Xeon 5xxx',
3410          219 => 'Quad-Core Xeon 5xxx',                  220 => undef,
3411          221 => 'Dual-Core Xeon 7xxx',                  222 => 'Quad-Core Xeon 7xxx',
3412          223 => 'Multi-Core Xeon 7xxx',                 224 => 'Multi-Core Xeon 3400',
3413          225 => undef,                                  226 => undef,
3414          227 => undef,                                  228 => undef,
3415          229 => undef,                                  230 => 'Embedded AMD Opteron Quad-Core',
3416          231 => 'AMD Phenom Triple-Core',               232 => 'AMD Turion Ultra Dual-Core Mobile',
3417          233 => 'AMD Turion Dual-Core Mobile',          234 => 'AMD Athlon Dual-Core',
3418          235 => 'AMD Sempron SI',                       236 => 'AMD Phenom II',
3419          237 => 'AMD Athlon II',                        238 => 'Six-Core AMD Opteron',
3420          239 => 'AMD Sempron M',                        240 => undef,
3421          241 => undef,                                  242 => undef,
3422          243 => undef,                                  244 => undef,
3423          245 => undef,                                  246 => undef,
3424          247 => undef,                                  248 => undef,
3425          249 => undef,                                  250 => 'i860',
3426          251 => 'i960',
3427         );
3428
3429   CPU:
3430     foreach my $out (@output) {
3431         if ($snmp) {
3432             $index  = exists $out->{processorDeviceStatusIndex}
3433               ? ($out->{processorDeviceStatusIndex} || 10000) - 1
3434                 : ($out->{processorDeviceIndex} || 10000) - 1;
3435             $status = exists $out->{processorDeviceStatusStatus}
3436               ? get_snmp_status($out->{processorDeviceStatusStatus})
3437                 : get_snmp_status($out->{processorDeviceStatus});
3438             if (defined $out->{processorDeviceStatusReading}) {
3439                 my @states  = ();  # contains states for the CPU
3440
3441                 # get the combined state from the StatusReading OID
3442                 foreach my $mask (sort keys %cpu_reading) {
3443                     if (($out->{processorDeviceStatusReading} & $mask) != 0) {
3444                         push @states, $cpu_reading{$mask};
3445                     }
3446                 }
3447
3448                 # Finally, create the state string
3449                 $state = join q{, }, @states;
3450             }
3451             else {
3452                 $state  = get_hashval($out->{processorDeviceStatusState}, \%cpu_state) || 'Unknown state';
3453             }
3454             $man    = $out->{processorDeviceManufacturerName} || undef;
3455             $family = (defined $out->{processorDeviceFamily}
3456                        and defined $cpu_family{$out->{processorDeviceFamily}})
3457               ? $cpu_family{$out->{processorDeviceFamily}} : undef;
3458             $speed  = $out->{processorDeviceCurrentSpeed} || undef;
3459             $brand  = $out->{processorDeviceBrandName} || undef;
3460         }
3461         else {
3462             $index  = get_nonempty_string('Index', $out, 9999);
3463             $status = get_nonempty_string('Status', $out, 'Unknown');
3464             $state  = get_nonempty_string('State', $out, 'Unknown state');
3465             $brand  = get_nonempty_string('Processor Brand', $out, undef);
3466             $family = get_nonempty_string('Processor Family',  $out, undef);
3467             $man    = get_nonempty_string('Processor Manufacturer', $out, undef);
3468             $speed  = get_nonempty_string('Current Speed', $out, undef);
3469         }
3470
3471         # Ignore unoccupied CPU slots (omreport)
3472         next CPU if (defined $out->{'Processor Manufacturer'}
3473                      and $out->{'Processor Manufacturer'} eq '[Not Occupied]')
3474           or (defined $out->{'Processor Brand'} and $out->{'Processor Brand'} eq '[Not Occupied]');
3475
3476         # Ignore unoccupied CPU slots (snmp)
3477         if ($snmp and defined $out->{processorDeviceStatusReading}
3478             and $out->{processorDeviceStatusReading} == 0) {
3479             next CPU;
3480         }
3481
3482         $count{cpu}++;
3483         next CPU if blacklisted('cpu', $index);
3484
3485         if (defined $brand) {
3486             $brand =~ s{\s\s+}{ }gxms;
3487             $brand =~ s{\((R|tm)\)}{}gxms;
3488             $brand =~ s{\s(CPU|Processor)}{}xms;
3489             $brand =~ s{\s\@}{}xms;
3490         }
3491         elsif (defined $family and defined $man and defined $speed) {
3492             $speed =~ s{\A (\d+) .*}{$1}xms;
3493             $brand = sprintf '%s %s %.2fGHz', $man, $family, $speed / 1000;
3494         }
3495         else {
3496             $brand = "unknown";
3497         }
3498
3499         # Default
3500         if ($status ne 'Ok') {
3501             my $msg = sprintf 'Processor %d [%s] needs attention: %s',
3502               $index, $brand, $state;
3503             report('chassis', $msg, $status2nagios{$status}, $index);
3504         }
3505         # Ok
3506         else {
3507             my $msg = sprintf 'Processor %d [%s] is %s',
3508               $index, $brand, $state;
3509             report('chassis', $msg, $E_OK, $index);
3510         }
3511     }
3512     return;
3513 }
3514
3515
3516 #-----------------------------------------
3517 # CHASSIS: Check voltage probes
3518 #-----------------------------------------
3519 sub check_volts {
3520     my $index    = undef;
3521     my $status   = undef;
3522     my $reading  = undef;
3523     my $location = undef;
3524     my $max_crit = undef;
3525     my $max_warn = undef;
3526     my @output = ();
3527
3528     if ($snmp) {
3529         my %volt_oid
3530           = (
3531              '1.3.6.1.4.1.674.10892.1.600.20.1.2.1'  => 'voltageProbeIndex',
3532              '1.3.6.1.4.1.674.10892.1.600.20.1.5.1'  => 'voltageProbeStatus',
3533              '1.3.6.1.4.1.674.10892.1.600.20.1.6.1'  => 'voltageProbeReading',
3534              '1.3.6.1.4.1.674.10892.1.600.20.1.8.1'  => 'voltageProbeLocationName',
3535              '1.3.6.1.4.1.674.10892.1.600.20.1.16.1' => 'voltageProbeDiscreteReading',
3536             );
3537
3538         my $voltageProbeTable = '1.3.6.1.4.1.674.10892.1.600.20.1';
3539         my $result = $snmp_session->get_table(-baseoid => $voltageProbeTable);
3540
3541         if (!defined $result) {
3542             printf "SNMP ERROR [voltage]: %s.\n", $snmp_session->error;
3543             $snmp_session->close;
3544             exit $E_UNKNOWN;
3545         }
3546
3547         @output = @{ get_snmp_output($result, \%volt_oid) };
3548     }
3549     else {
3550         @output = @{ run_omreport("$omopt_chassis volts") };
3551     }
3552
3553     my %volt_discrete_reading
3554       = (
3555          1 => 'Good',
3556          2 => 'Bad',
3557         );
3558
3559   VOLT:
3560     foreach my $out (@output) {
3561         if ($snmp) {
3562             $index    = ($out->{voltageProbeIndex} || 10000) - 1;
3563             $status   = get_snmp_probestatus($out->{voltageProbeStatus});
3564             $reading  = defined $out->{voltageProbeReading}
3565               ? sprintf('%.3f V', $out->{voltageProbeReading}/1000)
3566                 : (get_hashval($out->{voltageProbeDiscreteReading}, \%volt_discrete_reading) || 'Unknown reading');
3567             $location = $out->{voltageProbeLocationName} || 'Unknown location';
3568             $max_crit = $out->{voltageProbeUpperCriticalThreshold} || 0;
3569             $max_warn = $out->{voltageProbeUpperNonCriticalThreshold} || 0;
3570         }
3571         else {
3572             $index    = get_nonempty_string('Index', $out, 9999);
3573             $status   = get_nonempty_string('Status', $out, 'Unknown');
3574             $reading  = get_nonempty_string('Reading', $out, 'Unknown reading');
3575             $location = get_nonempty_string('Probe Name', $out, 'Unknown location');
3576             $max_crit = get_nonempty_string('Maximum Failure Threshold', $out, 0);
3577             $max_warn = get_nonempty_string('Maximum Warning Threshold', $out, 0);
3578
3579             $max_crit = 0 if $max_crit eq '[N/A]';
3580             $max_warn = 0 if $max_warn eq '[N/A]';
3581         }
3582
3583         $count{volt}++;
3584         next VOLT if blacklisted('volt', $index);
3585
3586         my $msg = sprintf 'Voltage sensor %d [%s] is %s',
3587           $index, $location, $reading;
3588         my $err = $snmp ? $probestatus2nagios{$status} : $status2nagios{$status};
3589         report('chassis', $msg, $err, $index);
3590
3591         # Collect performance data
3592         if (defined $opt{perfdata}) {
3593             $reading =~ s{\s+V\z}{}xms;  # remove unit
3594             $reading =~ s{\.000\z}{}xms; # if integer
3595             next VOLT if $reading !~ m{\A \d+(\.\d+)? \z}xms; # discrete reading (not number)
3596             my $label = join q{_}, $location;
3597             $label =~ s{\s}{_}gxms;
3598             push @perfdata, {
3599                              type  => 'V',
3600                              id    => $index,
3601                              unit  => 'V',
3602                              label => $label,
3603                              value => $reading,
3604                              warn  => 0,
3605                              crit  => 0,
3606                             };
3607         }
3608     }
3609     return;
3610 }
3611
3612
3613 #-----------------------------------------
3614 # CHASSIS: Check batteries
3615 #-----------------------------------------
3616 sub check_batteries {
3617     my $index    = undef;
3618     my $status   = undef;
3619     my $reading  = undef;
3620     my $location = undef;
3621     my @output = ();
3622
3623     if ($snmp) {
3624         my %bat_oid
3625           = (
3626              '1.3.6.1.4.1.674.10892.1.600.50.1.2.1' => 'batteryIndex',
3627              '1.3.6.1.4.1.674.10892.1.600.50.1.5.1' => 'batteryStatus',
3628              '1.3.6.1.4.1.674.10892.1.600.50.1.6.1' => 'batteryReading',
3629              '1.3.6.1.4.1.674.10892.1.600.50.1.7.1' => 'batteryLocationName',
3630             );
3631         my $result = undef;
3632         if ($opt{use_get_table}) {
3633             my $batteryTable = '1.3.6.1.4.1.674.10892.1.600.50.1';
3634             $result = $snmp_session->get_table(-baseoid => $batteryTable);
3635         }
3636         else {
3637             $result = $snmp_session->get_entries(-columns => [keys %bat_oid]);
3638         }
3639
3640         # No batteries is OK
3641         return 0 if !defined $result;
3642
3643         @output = @{ get_snmp_output($result, \%bat_oid) };
3644     }
3645     else {
3646         @output = @{ run_omreport("$omopt_chassis batteries") };
3647     }
3648
3649     my %bat_reading
3650       = (
3651          1 => 'Predictive Failure',
3652          2 => 'Failed',
3653          4 => 'Presence Detected',
3654         );
3655
3656   BATTERY:
3657     foreach my $out (@output) {
3658         if ($snmp) {
3659             $index    = ($out->{batteryIndex} || 10000) - 1;
3660             $status   = get_snmp_status($out->{batteryStatus});
3661             $reading  = get_hashval($out->{batteryReading}, \%bat_reading) || 'Unknown reading';
3662             $location = $out->{batteryLocationName} || 'Unknown location';
3663         }
3664         else {
3665             $index    = get_nonempty_string('Index', $out, 9999);
3666             $status   = get_nonempty_string('Status', $out, 'Unknown');
3667             $reading  = get_nonempty_string('Reading', $out, 'Unknown reading');
3668             $location = get_nonempty_string('Probe Name', $out, 'Unknown location');
3669         }
3670
3671         $count{bat}++;
3672         next BATTERY if blacklisted('bp', $index);
3673
3674         my $msg = sprintf 'Battery probe %d [%s] is %s',
3675           $index, $location, $reading;
3676         report('chassis', $msg, $status2nagios{$status}, $index);
3677     }
3678     return;
3679 }
3680
3681
3682 #-----------------------------------------
3683 # CHASSIS: Check amperage probes (power monitoring)
3684 #-----------------------------------------
3685 sub check_pwrmonitoring {
3686     my $index    = undef;
3687     my $status   = undef;
3688     my $reading  = undef;
3689     my $location = undef;
3690     my $max_crit = undef;
3691     my $max_warn = undef;
3692     my $unit     = undef;
3693     my $type     = undef;
3694     my @output = ();
3695
3696     if ($snmp) {
3697         my %amp_oid
3698           = (
3699              '1.3.6.1.4.1.674.10892.1.600.30.1.2.1'  => 'amperageProbeIndex',
3700              '1.3.6.1.4.1.674.10892.1.600.30.1.5.1'  => 'amperageProbeStatus',
3701              '1.3.6.1.4.1.674.10892.1.600.30.1.6.1'  => 'amperageProbeReading',
3702              '1.3.6.1.4.1.674.10892.1.600.30.1.7.1'  => 'amperageProbeType',
3703              '1.3.6.1.4.1.674.10892.1.600.30.1.8.1'  => 'amperageProbeLocationName',
3704              '1.3.6.1.4.1.674.10892.1.600.30.1.10.1' => 'amperageProbeUpperCriticalThreshold',
3705              '1.3.6.1.4.1.674.10892.1.600.30.1.11.1' => 'amperageProbeUpperNonCriticalThreshold',
3706              '1.3.6.1.4.1.674.10892.1.600.30.1.16.1' => 'amperageProbeDiscreteReading',
3707             );
3708         my $result = undef;
3709         if ($opt{use_get_table}) {
3710             my $amperageProbeTable = '1.3.6.1.4.1.674.10892.1.600.30.1';
3711             $result = $snmp_session->get_table(-baseoid => $amperageProbeTable);
3712         }
3713         else {
3714             $result = $snmp_session->get_entries(-columns => [keys %amp_oid]);
3715         }
3716
3717         # No pwrmonitoring is OK
3718         return 0 if !defined $result;
3719
3720         @output = @{ get_snmp_output($result, \%amp_oid) };
3721     }
3722     else {
3723         @output = @{ run_omreport("$omopt_chassis pwrmonitoring") };
3724     }
3725
3726     my %amp_type   # Amperage probe types
3727       = (
3728          1  => 'amperageProbeTypeIsOther',            # other than following values
3729          2  => 'amperageProbeTypeIsUnknown',          # unknown
3730          3  => 'amperageProbeTypeIs1Point5Volt',      # 1.5 amperage probe
3731          4  => 'amperageProbeTypeIs3Point3volt',      # 3.3 amperage probe
3732          5  => 'amperageProbeTypeIs5Volt',            # 5 amperage probe
3733          6  => 'amperageProbeTypeIsMinus5Volt',       # -5 amperage probe
3734          7  => 'amperageProbeTypeIs12Volt',           # 12 amperage probe
3735          8  => 'amperageProbeTypeIsMinus12Volt',      # -12 amperage probe
3736          9  => 'amperageProbeTypeIsIO',               # I/O probe
3737          10 => 'amperageProbeTypeIsCore',             # Core probe
3738          11 => 'amperageProbeTypeIsFLEA',             # FLEA (standby) probe
3739          12 => 'amperageProbeTypeIsBattery',          # Battery probe
3740          13 => 'amperageProbeTypeIsTerminator',       # SCSI Termination probe
3741          14 => 'amperageProbeTypeIs2Point5Volt',      # 2.5 amperage probe
3742          15 => 'amperageProbeTypeIsGTL',              # GTL (ground termination logic) probe
3743          16 => 'amperageProbeTypeIsDiscrete',         # amperage probe with discrete reading
3744          23 => 'amperageProbeTypeIsPowerSupplyAmps',  # Power Supply probe with reading in Amps
3745          24 => 'amperageProbeTypeIsPowerSupplyWatts', # Power Supply probe with reading in Watts
3746          25 => 'amperageProbeTypeIsSystemAmps',       # System probe with reading in Amps
3747          26 => 'amperageProbeTypeIsSystemWatts',      # System probe with reading in Watts
3748         );
3749
3750     my %amp_discrete
3751       = (
3752          1 => 'Good',
3753          2 => 'Bad',
3754         );
3755
3756     my %amp_unit
3757       = (
3758          'amperageProbeTypeIsPowerSupplyAmps'  => 'hA',  # tenths of Amps
3759          'amperageProbeTypeIsSystemAmps'       => 'hA',  # tenths of Amps
3760          'amperageProbeTypeIsPowerSupplyWatts' => 'W',   # Watts
3761          'amperageProbeTypeIsSystemWatts'      => 'W',   # Watts
3762          'amperageProbeTypeIsDiscrete'         => q{},   # discrete reading, no unit
3763         );
3764
3765   AMP:
3766     foreach my $out (@output) {
3767         if ($snmp) {
3768             $index    = ($out->{amperageProbeIndex} || 10000) - 1;
3769             $status   = get_snmp_probestatus($out->{amperageProbeStatus});
3770             $type     = get_hashval($out->{amperageProbeType}, \%amp_type);
3771             $reading  = $type eq 'amperageProbeTypeIsDiscrete'
3772               ? get_hashval($out->{amperageProbeDiscreteReading}, \%amp_discrete)
3773                 : ($out->{amperageProbeReading} || 0);
3774             $location = $out->{amperageProbeLocationName} || 'Unknown location';
3775             $max_crit = $out->{amperageProbeUpperCriticalThreshold} || 0;
3776             $max_warn = $out->{amperageProbeUpperNonCriticalThreshold} || 0;
3777             $unit     = exists $amp_unit{$amp_type{$out->{amperageProbeType}}}
3778               ? $amp_unit{$amp_type{$out->{amperageProbeType}}} : 'mA';
3779
3780             # calculate proper values and set unit for ampere probes
3781             if ($unit eq 'hA' and $type ne 'amperageProbeTypeIsDiscrete') {
3782                 $reading  /= 10;
3783                 $max_crit /= 10;
3784                 $max_warn /= 10;
3785                 $unit      = 'A';
3786             }
3787         }
3788         else {
3789             $index    = get_nonempty_string('Index', $out, 9999);
3790             $status   = get_nonempty_string('Status', $out, 'Unknown');
3791             $reading  = get_nonempty_string('Reading', $out, 'Unknown reading');
3792             $location = get_nonempty_string('Probe Name', $out, 'Unknown location');
3793             $max_crit = get_nonempty_string('Failure Threshold', $out, 0);
3794             $max_warn = get_nonempty_string('Warning Threshold', $out, 0);
3795
3796             $max_crit = 0 if $max_crit eq '[N/A]';
3797             $max_warn = 0 if $max_warn eq '[N/A]';
3798
3799             $reading  =~ s{\A (\d+.*?)\s+([a-zA-Z]+) \s*\z}{$1}xms;
3800             $unit     = $2 || 'unknown';
3801             $max_warn =~ s{\A (\d+.*?)\s+[a-zA-Z]+ \s*\z}{$1}xms;
3802             $max_crit =~ s{\A (\d+.*?)\s+[a-zA-Z]+ \s*\z}{$1}xms;
3803         }
3804
3805         next AMP if $index !~ m{\A \d+ \z}xms;
3806
3807         # Special case: Probe is present but unknown. This happens via
3808         # SNMP on some systems where power monitoring capability is
3809         # disabled due to non-redundant and/or non-instrumented power
3810         # supplies.
3811         # E.g. R410 with newer BMC firmware and 1 power supply
3812         if ($snmp && $status eq 'Unknown' && $reading == 0) {
3813             next AMP;
3814         }
3815
3816         $count{amp}++;
3817         next AMP if blacklisted('amp', $index);
3818
3819         # Special case: Discrete reading
3820         if (defined $type and $type eq 'amperageProbeTypeIsDiscrete') {
3821             my $msg = sprintf 'Amperage probe %d [%s] is %s',
3822               $index, $location, $reading;
3823             report('chassis', $msg, $status2nagios{$status}, $index);
3824         }
3825         # Default
3826         else {
3827             my $msg = sprintf 'Amperage probe %d [%s] reads %s %s',
3828               $index, $location, $reading, $unit;
3829             report('chassis', $msg, $status2nagios{$status}, $index);
3830         }
3831
3832         # Collect performance data
3833         if (defined $opt{perfdata}) {
3834             next AMP if $reading !~ m{\A \d+(\.\d+)? \z}xms; # discrete reading (not number)
3835             my $label = join q{_},  $location;
3836             $label =~ s{\s}{_}gxms;
3837             push @perfdata, {
3838                              type  => $unit,
3839                              id    => $index,
3840                              unit  => $unit,
3841                              label => $label,
3842                              value => $reading,
3843                              warn  => $max_warn,
3844                              crit  => $max_crit,
3845                             };
3846         }
3847     }
3848
3849     # Collect EXTRA performance data not found at first run. This is a
3850     # rather ugly hack
3851     if (defined $opt{perfdata} && !$snmp) {
3852         my $found = 0;
3853         my $index = 0;
3854         my %used  = ();
3855
3856         # find used indexes
3857         foreach (@perfdata) {
3858             if ($_->{label} =~ m/\A [WA](\d+)/xms) {
3859                 $used{$1} = 1;
3860             }
3861         }
3862
3863       AMP2:
3864         foreach my $line (@{ run_command("$omreport $omopt_chassis pwrmonitoring -fmt ssv") }) {
3865             chop $line;
3866             if ($line eq 'Location;Reading') {
3867                 $found = 1;
3868                 next AMP2;
3869             }
3870             if ($line eq q{}) {
3871                 $found = 0;
3872                 next AMP2;
3873             }
3874             if ($found and $line =~ m/\A ([^;]+?) ; (\d*\.\d+) \s ([AW]) \z/xms) {
3875                 my $aname = $1;
3876                 my $aval  = $2;
3877                 my $aunit = $3;
3878                 $aname =~ s{\s}{_}gxms;
3879
3880                 # don't use an existing index
3881                 while (exists $used{$index}) { ++$index; }
3882
3883                 push @perfdata, {
3884                                  type  => $aunit,
3885                                  id    => $index,
3886                                  unit  => $aunit,
3887                                  label => $aname,
3888                                  value => $aval,
3889                                  warn  => 0,
3890                                  crit  => 0,
3891                                 };
3892                 ++$index;
3893             }
3894         }
3895     }
3896
3897     return;
3898 }
3899
3900
3901 #-----------------------------------------
3902 # CHASSIS: Check intrusion
3903 #-----------------------------------------
3904 sub check_intrusion {
3905     my $index    = undef;
3906     my $status   = undef;
3907     my $reading  = undef;
3908     my @output = ();
3909
3910     if ($snmp) {
3911         my %int_oid
3912           = (
3913              '1.3.6.1.4.1.674.10892.1.300.70.1.2.1' => 'intrusionIndex',
3914              '1.3.6.1.4.1.674.10892.1.300.70.1.5.1' => 'intrusionStatus',
3915              '1.3.6.1.4.1.674.10892.1.300.70.1.6.1' => 'intrusionReading',
3916             );
3917         my $result = undef;
3918         if ($opt{use_get_table}) {
3919             my $intrusionTable = '1.3.6.1.4.1.674.10892.1.300.70.1';
3920             $result = $snmp_session->get_table(-baseoid => $intrusionTable);
3921         }
3922         else {
3923             $result = $snmp_session->get_entries(-columns => [keys %int_oid]);
3924         }
3925
3926         # No intrusion is OK
3927         return 0 if !defined $result;
3928
3929         @output = @{ get_snmp_output($result, \%int_oid) };
3930     }
3931     else {
3932         @output = @{ run_omreport("$omopt_chassis intrusion") };
3933     }
3934
3935     my %int_reading
3936       = (
3937          1 => 'Not Breached',          # chassis not breached and no uncleared breaches
3938          2 => 'Breached',              # chassis currently breached
3939          3 => 'Breached Prior',        # chassis breached prior to boot and has not been cleared
3940          4 => 'Breach Sensor Failure', # intrusion sensor has failed
3941         );
3942
3943   INTRUSION:
3944     foreach my $out (@output) {
3945         if ($snmp) {
3946             $index    = ($out->{intrusionIndex} || 10000) - 1;
3947             $status   = get_snmp_status($out->{intrusionStatus});
3948             $reading  = get_hashval($out->{intrusionReading}, \%int_reading) || 'Unknown reading';
3949         }
3950         else {
3951             $index    = get_nonempty_string('Index', $out, 9999);
3952             $status   = get_nonempty_string('Status', $out, 'Unknown');
3953             $reading  = get_nonempty_string('State', $out, 'Unknown reading');
3954         }
3955
3956         $count{intr}++;
3957         next INTRUSION if blacklisted('intr', $index);
3958
3959         if ($status ne 'Ok') {
3960             my $msg = sprintf 'Chassis intrusion %d detected: %s',
3961               $index, $reading;
3962             report('chassis', $msg, $E_WARNING, $index);
3963         }
3964         # Ok
3965         else {
3966             my $msg = sprintf 'Chassis intrusion %d detection: %s (%s)',
3967               $index, $status, $reading;
3968             report('chassis', $msg, $E_OK, $index);
3969         }
3970     }
3971     return;
3972 }
3973
3974
3975 #-----------------------------------------
3976 # CHASSIS: Check SD Card Device
3977 #-----------------------------------------
3978 sub check_sdcard {
3979     my $index    = undef;
3980     my $status   = undef;
3981     my $state    = undef;
3982     my $location = undef;
3983     my $capacity = undef;
3984     my $setting  = undef;
3985     my @output = ();
3986
3987     if ($snmp) {
3988         my %sd_oid
3989           = (
3990              '1.3.6.1.4.1.674.10892.1.1100.112.1.2.1'  => 'sdCardDeviceIndex',
3991              '1.3.6.1.4.1.674.10892.1.1100.112.1.3.1'  => 'sdCardDeviceStatus',
3992              '1.3.6.1.4.1.674.10892.1.1100.112.1.4.1'  => 'sdCardDeviceType',
3993              '1.3.6.1.4.1.674.10892.1.1100.112.1.7.1'  => 'sdCardDeviceLocationName',
3994              '1.3.6.1.4.1.674.10892.1.1100.112.1.8.1'  => 'sdCardDeviceCardPresent',
3995              '1.3.6.1.4.1.674.10892.1.1100.112.1.9.1'  => 'sdCardDeviceCardState',
3996              '1.3.6.1.4.1.674.10892.1.1100.112.1.10.1' => 'sdCardDeviceCardStorageSize',
3997             );
3998         my $result = undef;
3999         if ($opt{use_get_table}) {
4000             my $sdCardDeviceTable = '1.3.6.1.4.1.674.10892.1.1100.112.1';
4001             $result = $snmp_session->get_table(-baseoid => $sdCardDeviceTable);
4002         }
4003         else {
4004             $result = $snmp_session->get_entries(-columns => [keys %sd_oid]);
4005         }
4006
4007         # No SD cards is OK
4008         return 0 if !defined $result;
4009
4010         @output = @{ get_snmp_output($result, \%sd_oid) };
4011     }
4012     else {
4013         @output = @{ run_omreport("$omopt_chassis removableflashmedia") };
4014     }
4015
4016     # Note: These values are bit fields, so combination values are possible.
4017     my %sd_state
4018       = (
4019          0   => 'None',            # state is none of the following:
4020          1   => 'Present',         # device is present
4021          2   => 'IPMI-ready',      # device is IPMI ready
4022          4   => 'Full-ready',      # device is full ready
4023          8   => 'Offline',         # device is offline
4024          16  => 'Failed',          # device is failed
4025          32  => 'Active',          # device is active
4026          64  => 'Bootable',        # device is bootable
4027          128 => 'Write-protected', # device is write-protected
4028          256 => 'Standby',         # device is in standby mode
4029         );
4030
4031     my $c = 0;
4032   SDCARD:
4033     foreach my $out (@output) {
4034         if ($snmp) {
4035             $index    = ($out->{sdCardDeviceIndex} || 10000) - 1;
4036             $status   = get_snmp_status($out->{sdCardDeviceStatus});
4037
4038             if (defined $out->{sdCardDeviceCardState}) {
4039                 my @states  = ();  # contains states SD card
4040
4041                 # get the combined state from the Device Status OID
4042                 foreach my $mask (sort keys %sd_state) {
4043                     if (($out->{sdCardDeviceCardState} & $mask) != 0) {
4044                         push @states, $sd_state{$mask};
4045                     }
4046                 }
4047
4048                 # Finally, create the state string
4049                 $state = join q{, }, @states;
4050
4051                 # special case: absent
4052                 if ($out->{sdCardDeviceCardState} % 2 == 0) {
4053                     $state = 'Absent';
4054                 }
4055             }
4056
4057             $location = $out->{sdCardDeviceLocationName} || 'Unknown location';
4058             $capacity = sprintf '%s MB', ($out->{sdCardDeviceCardStorageSize} || 'Unknown size');
4059         }
4060         else {
4061             $index    = $c++;
4062             $status   = get_nonempty_string('Status', $out, 'Ok');
4063             $state    = get_nonempty_string('State', $out, 'Unknown state');
4064             $location = get_nonempty_string('Connector Name', $out, 'Unknown location');
4065             $capacity = get_nonempty_string('Storage Size', $out, 'Unknown size');
4066
4067             $capacity =~ s{\[Not Available\]}{Unknown Size};
4068         }
4069
4070         $count{sd}++ if $state ne 'Absent';
4071         next SDCARD if blacklisted('sd', $index);
4072
4073         if ($status ne 'Ok') {
4074             my $msg = sprintf 'SD Card %d needs attention: %s',
4075               $index, $state;
4076             report('chassis', $msg, $E_WARNING, $index);
4077         }
4078         # Special case: Not Present
4079         elsif ($status eq 'Ok' and $state eq 'Absent') {
4080             my $msg = sprintf 'SD Card %d [%s] is %s',
4081               $index, $location, $state;
4082             report('chassis', $msg, $E_OK, $index);
4083         }
4084         # Ok
4085         else {
4086             my $msg = sprintf 'SD Card %d [%s, %s] is %s',
4087               $index, $location, $capacity, $state;
4088             report('chassis', $msg, $E_OK, $index);
4089         }
4090     }
4091     return;
4092 }
4093
4094
4095 #-----------------------------------------
4096 # CHASSIS: Check alert log
4097 #-----------------------------------------
4098 sub check_alertlog {
4099     return if $snmp; # Not supported with SNMP
4100
4101     my @output = @{ run_omreport("$omopt_system alertlog") };
4102     foreach my $out (@output) {
4103         ++$count{alert}{$out->{Severity}};
4104     }
4105
4106     # Create error messages and set exit value if appropriate
4107     my $err = 0;
4108     if ($count{alert}{'Critical'} > 0)        { $err = $E_CRITICAL; }
4109     elsif ($count{alert}{'Non-Critical'} > 0) { $err = $E_WARNING;  }
4110
4111     my $msg = sprintf 'Alert log content: %d critical, %d non-critical, %d ok',
4112       $count{alert}{'Critical'}, $count{alert}{'Non-Critical'}, $count{alert}{'Ok'};
4113     report('other', $msg, $err);
4114
4115     return;
4116 }
4117
4118 #-----------------------------------------
4119 # CHASSIS: Check ESM log overall health
4120 #-----------------------------------------
4121 sub check_esmlog_health {
4122     my $health = 'Ok';
4123
4124     if ($snmp) {
4125         my $systemStateEventLogStatus = '1.3.6.1.4.1.674.10892.1.200.10.1.41.1';
4126         my $result = $snmp_session->get_request(-varbindlist => [$systemStateEventLogStatus]);
4127         if (!defined $result) {
4128             my $msg = sprintf 'SNMP ERROR [esmhealth]: %s',
4129               $snmp_session->error;
4130             report('other', $msg, $E_UNKNOWN);
4131         }
4132         $health = get_snmp_status($result->{$systemStateEventLogStatus});
4133     }
4134     else {
4135         foreach (@{ run_command("$omreport $omopt_system esmlog -fmt ssv") }) {
4136             if (m/\A Health;(.+) \z/xms) {
4137                 $health = $1;
4138                 chop $health;
4139                 last;
4140             }
4141         }
4142     }
4143
4144     # If the overall health of the ESM log is other than "Ok", the
4145     # fill grade of the log is more than 80% and the log should be
4146     # cleared
4147     if ($health eq 'Ok') {
4148         my $msg = sprintf 'ESM log health is Ok (less than 80%% full)';
4149         report('other', $msg, $E_OK);
4150     }
4151     elsif ($health eq 'Critical') {
4152         my $msg = sprintf 'ESM log is 100%% full';
4153         report('other', $msg, $status2nagios{$health});
4154     }
4155     else {
4156         my $msg = sprintf 'ESM log is more than 80%% full';
4157         report('other', $msg, $status2nagios{$health});
4158     }
4159
4160     return;
4161 }
4162
4163 #-----------------------------------------
4164 # CHASSIS: Check ESM log
4165 #-----------------------------------------
4166 sub check_esmlog {
4167     my @output = ();
4168
4169     if ($snmp) {
4170         my %esm_oid
4171           = (
4172              '1.3.6.1.4.1.674.10892.1.300.40.1.7.1'  => 'eventLogSeverityStatus',
4173             );
4174         my $result = $snmp_session->get_entries(-columns => [keys %esm_oid]);
4175
4176         # No entries is OK
4177         return if !defined $result;
4178
4179         @output = @{ get_snmp_output($result, \%esm_oid) };
4180         foreach my $out (@output) {
4181             ++$count{esm}{$snmp_status{$out->{eventLogSeverityStatus}}};
4182         }
4183     }
4184     else {
4185         @output = @{ run_omreport("$omopt_system esmlog") };
4186         foreach my $out (@output) {
4187             ++$count{esm}{$out->{Severity}};
4188         }
4189     }
4190
4191     # Create error messages and set exit value if appropriate
4192     my $err = 0;
4193     if ($count{esm}{'Critical'} > 0)        { $err = $E_CRITICAL; }
4194     elsif ($count{esm}{'Non-Critical'} > 0) { $err = $E_WARNING;  }
4195
4196     my $msg = sprintf 'ESM log content: %d critical, %d non-critical, %d ok',
4197       $count{esm}{'Critical'}, $count{esm}{'Non-Critical'}, $count{esm}{'Ok'};
4198     report('other', $msg, $err);
4199
4200     return;
4201 }
4202
4203 #
4204 # Handy function for checking all storage components
4205 #
4206 sub check_storage {
4207     check_controllers();
4208     check_physical_disks();
4209     check_virtual_disks();
4210     check_cache_battery();
4211     check_connectors();
4212     check_enclosures();
4213     check_enclosure_fans();
4214     check_enclosure_pwr();
4215     check_enclosure_temp();
4216     check_enclosure_emms();
4217     return;
4218 }
4219
4220
4221
4222 #---------------------------------------------------------------------
4223 # Info functions
4224 #---------------------------------------------------------------------
4225
4226 #
4227 # Fetch output from 'omreport chassis info', put in sysinfo hash
4228 #
4229 sub get_omreport_chassis_info {
4230     if (open my $INFO, '-|', "$omreport $omopt_chassis info -fmt ssv") {
4231         my @lines = <$INFO>;
4232         close $INFO;
4233         foreach (@lines) {
4234             next if !m/\A (Chassis\sModel|Chassis\sService\sTag|Model|Service\sTag|System\sRevision)/xms;
4235             my ($key, $val) = split /;/xms;
4236             $key =~ s{\s+\z}{}xms; # remove trailing whitespace
4237             $val =~ s{\s+\z}{}xms; # remove trailing whitespace
4238             if ($key eq 'Chassis Model' or $key eq 'Model') {
4239                 $sysinfo{model}  = $val;
4240             }
4241             if ($key eq 'Chassis Service Tag' or $key eq 'Service Tag') {
4242                 $sysinfo{serial} = $val;
4243             }
4244             if ($key eq 'System Revision') {
4245                 $sysinfo{rev} = q{ } . $val;
4246             }
4247         }
4248     }
4249     return;
4250 }
4251
4252 #
4253 # Fetch output from 'omreport chassis bios', put in sysinfo hash
4254 #
4255 sub get_omreport_chassis_bios {
4256     if (open my $BIOS, '-|', "$omreport $omopt_chassis bios -fmt ssv") {
4257         my @lines = <$BIOS>;
4258         close $BIOS;
4259         foreach (@lines) {
4260             next if !m/;/xms;
4261             my ($key, $val) = split /;/xms;
4262             $key =~ s{\s+\z}{}xms; # remove trailing whitespace
4263             $val =~ s{\s+\z}{}xms; # remove trailing whitespace
4264             $sysinfo{bios}     = $val if $key eq 'Version';
4265             $sysinfo{biosdate} = $val if $key eq 'Release Date';
4266         }
4267     }
4268     return;
4269 }
4270
4271 #
4272 # Fetch output from 'omreport system operatingsystem', put in sysinfo hash
4273 #
4274 sub get_omreport_system_operatingsystem {
4275     if (open my $VER, '-|', "$omreport $omopt_system operatingsystem -fmt ssv") {
4276         my @lines = <$VER>;
4277         close $VER;
4278         foreach (@lines) {
4279             next if !m/;/xms;
4280             my ($key, $val) = split /;/xms;
4281             $key =~ s{\s+\z}{}xms; # remove trailing whitespace
4282             $val =~ s{\s+\z}{}xms; # remove trailing whitespace
4283             if ($key eq 'Operating System') {
4284                 $sysinfo{osname} = $val;
4285             }
4286             elsif ($key eq 'Operating System Version') {
4287                 $sysinfo{osver}  = $val;
4288             }
4289         }
4290     }
4291     return;
4292 }
4293
4294 #
4295 # Fetch output from 'omreport about', put in sysinfo hash
4296 #
4297 sub get_omreport_about {
4298     if (open my $OM, '-|', "$omreport about -fmt ssv") {
4299         my @lines = <$OM>;
4300         close $OM;
4301         foreach (@lines) {
4302             if (m/\A Version;(.+) \z/xms) {
4303                 $sysinfo{om} = $1;
4304                 chomp $sysinfo{om};
4305             }
4306         }
4307     }
4308     return;
4309 }
4310
4311 #
4312 # Fetch chassis info via SNMP, put in sysinfo hash
4313 #
4314 sub get_snmp_chassis_info {
4315     my %chassis_oid
4316       = (
4317          '1.3.6.1.4.1.674.10892.1.300.10.1.9.1'  => 'chassisModelName',
4318          '1.3.6.1.4.1.674.10892.1.300.10.1.11.1' => 'chassisServiceTagName',
4319          '1.3.6.1.4.1.674.10892.1.300.10.1.48.1' => 'chassisSystemRevisionName',
4320         );
4321
4322     my $chassisInformationTable = '1.3.6.1.4.1.674.10892.1.300.10.1';
4323     my $result = $snmp_session->get_table(-baseoid => $chassisInformationTable);
4324
4325     if (defined $result) {
4326         foreach my $oid (keys %{ $result }) {
4327             if (exists $chassis_oid{$oid} and $chassis_oid{$oid} eq 'chassisModelName') {
4328                 $sysinfo{model} = $result->{$oid};
4329                 $sysinfo{model} =~ s{\s+\z}{}xms; # remove trailing whitespace
4330             }
4331             elsif (exists $chassis_oid{$oid} and $chassis_oid{$oid} eq 'chassisServiceTagName') {
4332                 $sysinfo{serial} = $result->{$oid};
4333             }
4334             elsif (exists $chassis_oid{$oid} and $chassis_oid{$oid} eq 'chassisSystemRevisionName') {
4335                 $sysinfo{rev} = q{ } . $result->{$oid};
4336             }
4337         }
4338     }
4339     else {
4340         my $msg = sprintf 'SNMP ERROR getting chassis info: %s',
4341           $snmp_session->error;
4342         report('other', $msg, $E_UNKNOWN);
4343     }
4344     return;
4345 }
4346
4347 #
4348 # Fetch BIOS info via SNMP, put in sysinfo hash
4349 #
4350 sub get_snmp_chassis_bios {
4351     my %bios_oid
4352       = (
4353          '1.3.6.1.4.1.674.10892.1.300.50.1.7.1.1' => 'systemBIOSReleaseDateName',
4354          '1.3.6.1.4.1.674.10892.1.300.50.1.8.1.1' => 'systemBIOSVersionName',
4355         );
4356
4357     my $systemBIOSTable = '1.3.6.1.4.1.674.10892.1.300.50.1';
4358     my $result = $snmp_session->get_table(-baseoid => $systemBIOSTable);
4359
4360     if (defined $result) {
4361         foreach my $oid (keys %{ $result }) {
4362             if (exists $bios_oid{$oid} and $bios_oid{$oid} eq 'systemBIOSReleaseDateName') {
4363                 $sysinfo{biosdate} = $result->{$oid};
4364                 $sysinfo{biosdate} =~ s{\A (\d{4})(\d{2})(\d{2}).*}{$2/$3/$1}xms;
4365             }
4366             elsif (exists $bios_oid{$oid} and $bios_oid{$oid} eq 'systemBIOSVersionName') {
4367                 $sysinfo{bios} = $result->{$oid};
4368             }
4369         }
4370     }
4371     else {
4372         my $msg = sprintf 'SNMP ERROR getting BIOS info: %s',
4373           $snmp_session->error;
4374         report('other', $msg, $E_UNKNOWN);
4375     }
4376     return;
4377 }
4378
4379 #
4380 # Fetch OS info via SNMP, put in sysinfo hash
4381 #
4382 sub get_snmp_system_operatingsystem {
4383     my %os_oid
4384       = (
4385          '1.3.6.1.4.1.674.10892.1.400.10.1.6.1' => 'operatingSystemOperatingSystemName',
4386          '1.3.6.1.4.1.674.10892.1.400.10.1.7.1' => 'operatingSystemOperatingSystemVersionName',
4387         );
4388
4389     my $operatingSystemTable = '1.3.6.1.4.1.674.10892.1.400.10.1';
4390     my $result = $snmp_session->get_table(-baseoid => $operatingSystemTable);
4391
4392     if (defined $result) {
4393         foreach my $oid (keys %{ $result }) {
4394             if (exists $os_oid{$oid} and $os_oid{$oid} eq 'operatingSystemOperatingSystemName') {
4395                 $sysinfo{osname} = ($result->{$oid});
4396             }
4397             elsif (exists $os_oid{$oid} and $os_oid{$oid} eq 'operatingSystemOperatingSystemVersionName') {
4398                 $sysinfo{osver} = $result->{$oid};
4399             }
4400         }
4401     }
4402     else {
4403         my $msg = sprintf 'SNMP ERROR getting OS info: %s',
4404           $snmp_session->error;
4405         report('other', $msg, $E_UNKNOWN);
4406     }
4407     return;
4408 }
4409
4410 #
4411 # Fetch OMSA version via SNMP, put in sysinfo hash
4412 #
4413 sub get_snmp_about {
4414     # systemManagementSoftwareGlobalVersionName
4415     my $oid = '1.3.6.1.4.1.674.10892.1.100.10.0';
4416     my $result = $snmp_session->get_request(-varbindlist => [$oid]);
4417
4418     if (defined $result) {
4419         $sysinfo{om} = exists $result->{$oid} && $result->{$oid} ne q{}
4420           ? $result->{$oid} : 'unknown';
4421     }
4422     else {
4423         my $msg = sprintf 'SNMP ERROR: Getting OMSA version failed: %s', $snmp_session->error;
4424         report('other', $msg, $E_UNKNOWN);
4425     }
4426     return;
4427 }
4428
4429 #
4430 # Collects some information about the system
4431 #
4432 sub get_sysinfo
4433 {
4434     # Get system model and serial number
4435     $snmp ? get_snmp_chassis_info() : get_omreport_chassis_info();
4436
4437     # Get BIOS information. Only if needed
4438     if ( $opt{okinfo} >= 1
4439          or $opt{debug}
4440          or (defined $opt{postmsg} and $opt{postmsg} =~ m/[%][bd]/xms) ) {
4441         $snmp ? get_snmp_chassis_bios() : get_omreport_chassis_bios();
4442     }
4443
4444     # Get OMSA information. Only if needed
4445     if ($opt{okinfo} >= 3 or $opt{debug}) {
4446         $snmp ? get_snmp_about() : get_omreport_about();
4447     }
4448
4449     # Return now if debug
4450     return if $opt{debug};
4451
4452     # Get OS information. Only if needed
4453     if (defined $opt{postmsg} and $opt{postmsg} =~ m/[%][or]/xms) {
4454         $snmp ? get_snmp_system_operatingsystem() : get_omreport_system_operatingsystem();
4455     }
4456
4457     return;
4458 }
4459
4460
4461 # Helper function for running omreport when the results are strictly
4462 # name=value pairs.
4463 sub run_omreport_info {
4464     my $command = shift;
4465     my %output  = ();
4466     my @keys    = ();
4467
4468     # Run omreport and fetch output
4469     my $rawtext = slurp_command("$omreport $command -fmt ssv 2>&1");
4470
4471     # Parse output, store in array
4472     for ((split /\n/xms, $rawtext)) {
4473         if (m/\A Error/xms) {
4474             my $msg = "Problem running 'omreport $command': $_";
4475             report('other', $msg, $E_UNKNOWN);
4476         }
4477         next if !m/;/xms;  # ignore lines with less than two fields
4478         my @vals = split m/;/xms;
4479         $output{$vals[0]} = $vals[1];
4480     }
4481
4482     # Finally, return the collected information
4483     return \%output;
4484 }
4485
4486 # Get various firmware information (BMC, RAC)
4487 sub get_firmware_info {
4488     my @snmp_output = ();
4489     my %nrpe_output = ();
4490
4491     if ($snmp) {
4492         my %fw_oid
4493           = (
4494              '1.3.6.1.4.1.674.10892.1.300.60.1.7.1'  => 'firmwareType',
4495              '1.3.6.1.4.1.674.10892.1.300.60.1.8.1'  => 'firmwareTypeName',
4496              '1.3.6.1.4.1.674.10892.1.300.60.1.11.1' => 'firmwareVersionName',
4497             );
4498
4499         my $firmwareTable = '1.3.6.1.4.1.674.10892.1.300.60.1';
4500         my $result = $snmp_session->get_table(-baseoid => $firmwareTable);
4501
4502         # Some don't have this OID, this is ok
4503         if (!defined $result) {
4504             return;
4505         }
4506
4507         @snmp_output = @{ get_snmp_output($result, \%fw_oid) };
4508     }
4509     else {
4510         %nrpe_output = %{ run_omreport_info("$omopt_chassis info") };
4511     }
4512
4513     my %fw_type  # Firmware types
4514       = (
4515          1  => 'other',                              # other than following values
4516          2  => 'unknown',                            # unknown
4517          3  => 'systemBIOS',                         # System BIOS
4518          4  => 'embeddedSystemManagementController', # Embedded System Management Controller
4519          5  => 'powerSupplyParallelingBoard',        # Power Supply Paralleling Board
4520          6  => 'systemBackPlane',                    # System (Primary) Backplane
4521          7  => 'powerVault2XXSKernel',               # PowerVault 2XXS Kernel
4522          8  => 'powerVault2XXSApplication',          # PowerVault 2XXS Application
4523          9  => 'frontPanel',                         # Front Panel Controller
4524          10 => 'baseboardManagementController',      # Baseboard Management Controller
4525          11 => 'hotPlugPCI',                         # Hot Plug PCI Controller
4526          12 => 'sensorData',                         # Sensor Data Records
4527          13 => 'peripheralBay',                      # Peripheral Bay Backplane
4528          14 => 'secondaryBackPlane',                 # Secondary Backplane for ESM 2 systems
4529          15 => 'secondaryBackPlaneESM3And4',         # Secondary Backplane for ESM 3 and 4 systems
4530          16 => 'rac',                                # Remote Access Controller
4531          17 => 'iDRAC',                              # Integrated Dell Remote Access Controller
4532          19 => 'unifiedServerConfigurator',          # Unified Server Configurator
4533          20 => 'lifecycleController',                # Lifecycle Controller
4534         );
4535
4536
4537     if ($snmp) {
4538         foreach my $out (@snmp_output) {
4539             if ($fw_type{$out->{firmwareType}} eq 'baseboardManagementController') {
4540                 $sysinfo{'bmc'} = 1;
4541                 $sysinfo{'bmc_fw'} = $out->{firmwareVersionName};
4542             }
4543             elsif ($fw_type{$out->{firmwareType}} =~ m{\A rac|iDRAC \z}xms) {
4544                 my $name = $out->{firmwareTypeName}; $name =~ s/\s//gxms;
4545                 $sysinfo{'rac'} = 1;
4546                 $sysinfo{'rac_name'} = $name;
4547                 $sysinfo{'rac_fw'} = $out->{firmwareVersionName};
4548             }
4549         }
4550     }
4551     else {
4552         foreach my $key (keys %nrpe_output) {
4553             next if !defined $nrpe_output{$key};
4554             if ($key eq 'BMC Version' or $key eq 'Baseboard Management Controller Version') {
4555                 $sysinfo{'bmc'} = 1;
4556                 $sysinfo{'bmc_fw'} = $nrpe_output{$key};
4557             }
4558             elsif ($key =~ m{\A (i?DRAC)\s*(\d?)\s+Version}xms) {
4559                 my $name = "$1$2";
4560                 $sysinfo{'rac'} = 1;
4561                 $sysinfo{'rac_fw'} = $nrpe_output{$key};
4562                 $sysinfo{'rac_name'} = $name;
4563             }
4564         }
4565     }
4566
4567     return;
4568 }
4569
4570
4571
4572 #=====================================================================
4573 # Main program
4574 #=====================================================================
4575
4576 # Here we do the actual checking of components
4577 # Check global status if applicable
4578 if ($global) {
4579     $globalstatus = check_global();
4580 }
4581
4582 # Do multiple selected checks
4583 if ($check{storage})     { check_storage();       }
4584 if ($check{memory})      { check_memory();        }
4585 if ($check{fans})        { check_fans();          }
4586 if ($check{power})       { check_powersupplies(); }
4587 if ($check{temp})        { check_temperatures();  }
4588 if ($check{cpu})         { check_processors();    }
4589 if ($check{voltage})     { check_volts();         }
4590 if ($check{batteries})   { check_batteries();     }
4591 if ($check{amperage})    { check_pwrmonitoring(); }
4592 if ($check{intrusion})   { check_intrusion();     }
4593 if ($check{sdcard})      { check_sdcard();        }
4594 if ($check{alertlog})    { check_alertlog();      }
4595 if ($check{esmlog})      { check_esmlog();        }
4596 if ($check{esmhealth})   { check_esmlog_health(); }
4597
4598
4599 #---------------------------------------------------------------------
4600 # Finish up
4601 #---------------------------------------------------------------------
4602
4603 # Counter variable
4604 %nagios_alert_count
4605   = (
4606      'OK'       => 0,
4607      'WARNING'  => 0,
4608      'CRITICAL' => 0,
4609      'UNKNOWN'  => 0,
4610     );
4611
4612 # Get system information
4613 get_sysinfo();
4614
4615 # Get firmware info if requested via option
4616 if ($opt{okinfo} >= 1) {
4617     get_firmware_info();
4618 }
4619
4620 # Close SNMP session
4621 if ($snmp) {
4622     $snmp_session->close;
4623 }
4624
4625 # Print messages
4626 if ($opt{debug}) {
4627     # finding the mode of operation
4628     my $mode = 'local';
4629     if ($snmp) {
4630         # Setting the domain (IP version and transport protocol)
4631         my $transport = $opt{tcp} ? 'TCP' : 'UDP';
4632         my $ipversion = $opt{ipv6} ? 'IPv6' : 'IPv4';
4633         $mode = "SNMPv$opt{protocol} $transport/$ipversion";
4634     }
4635
4636     print "   System:      $sysinfo{model}$sysinfo{rev}";
4637     print q{ } x (25 - length "$sysinfo{model}$sysinfo{rev}"), "OMSA version:    $sysinfo{om}\n";
4638     print "   ServiceTag:  $sysinfo{serial}";
4639     print q{ } x (25 - length $sysinfo{serial}), "Plugin version:  $VERSION\n";
4640     print "   BIOS/date:   $sysinfo{bios} $sysinfo{biosdate}";
4641     print q{ } x (25 - length "$sysinfo{bios} $sysinfo{biosdate}"), "Checking mode:   $mode\n";
4642     if ($#report_storage >= 0) {
4643         print "-----------------------------------------------------------------------------\n";
4644         print "   Storage Components                                                        \n";
4645         print "=============================================================================\n";
4646         print "  STATE  |    ID    |  MESSAGE TEXT                                          \n";
4647         print "---------+----------+--------------------------------------------------------\n";
4648         foreach (@report_storage) {
4649             my ($msg, $level, $nexus) = @{$_};
4650             print q{ } x (8 - length $reverse_exitcode{$level}) . "$reverse_exitcode{$level} | "
4651               . q{ } x (8 - length $nexus) . "$nexus | $msg\n";
4652             $nagios_alert_count{$reverse_exitcode{$level}}++;
4653         }
4654     }
4655     if ($#report_chassis >= 0) {
4656         print "-----------------------------------------------------------------------------\n";
4657         print "   Chassis Components                                                        \n";
4658         print "=============================================================================\n";
4659         print "  STATE  |  ID  |  MESSAGE TEXT                                              \n";
4660         print "---------+------+------------------------------------------------------------\n";
4661         foreach (@report_chassis) {
4662             my ($msg, $level, $nexus) = @{$_};
4663             print q{ } x (8 - length $reverse_exitcode{$level}) . "$reverse_exitcode{$level} | "
4664               . q{ } x (4 - length $nexus) . "$nexus | $msg\n";
4665             $nagios_alert_count{$reverse_exitcode{$level}}++;
4666         }
4667     }
4668     if ($#report_other >= 0) {
4669         print "-----------------------------------------------------------------------------\n";
4670         print "   Other messages                                                            \n";
4671         print "=============================================================================\n";
4672         print "  STATE  |  MESSAGE TEXT                                                     \n";
4673         print "---------+-------------------------------------------------------------------\n";
4674         foreach (@report_other) {
4675             my ($msg, $level, $nexus) = @{$_};
4676             print q{ } x (8 - length $reverse_exitcode{$level}) . "$reverse_exitcode{$level} | $msg\n";
4677             $nagios_alert_count{$reverse_exitcode{$level}}++;
4678         }
4679     }
4680 }
4681 else {
4682     my $c = 0;  # counter to determine linebreaks
4683
4684     # Run through each message, sorted by severity level
4685   ALERT:
4686     foreach (sort {$a->[1] < $b->[1]} (@report_storage, @report_chassis, @report_other)) {
4687         my ($msg, $level, $nexus) = @{ $_ };
4688         next ALERT if $level == $E_OK;
4689
4690         if (defined $opt{only}) {
4691             # If user wants only critical alerts
4692             next ALERT if ($opt{only} eq 'critical' and $level == $E_WARNING);
4693
4694             # If user wants only warning alerts
4695             next ALERT if ($opt{only} eq 'warning' and $level == $E_CRITICAL);
4696         }
4697
4698         # Prefix with service tag if specified with option '-i|--info'
4699         if ($opt{info}) {
4700             if (defined $opt{htmlinfo}) {
4701                 $msg = '[<a href="' . warranty_url($sysinfo{serial})
4702                   . "\">$sysinfo{serial}</a>] " . $msg;
4703             }
4704             else {
4705                 $msg = "[$sysinfo{serial}] " . $msg;
4706             }
4707         }
4708
4709         # Prefix with nagios level if specified with option '--state'
4710         $msg = $reverse_exitcode{$level} . ": $msg" if $opt{state};
4711
4712         # Prefix with one-letter nagios level if specified with option '--short-state'
4713         $msg = (substr $reverse_exitcode{$level}, 0, 1) . ": $msg" if $opt{shortstate};
4714
4715         ($c++ == 0) ? print $msg : print $linebreak, $msg;
4716
4717         $nagios_alert_count{$reverse_exitcode{$level}}++;
4718     }
4719 }
4720
4721 # Determine our exit code
4722 $exit_code = $E_OK;
4723 $exit_code = $E_UNKNOWN  if $nagios_alert_count{'UNKNOWN'} > 0;
4724 $exit_code = $E_WARNING  if $nagios_alert_count{'WARNING'} > 0;
4725 $exit_code = $E_CRITICAL if $nagios_alert_count{'CRITICAL'} > 0;
4726
4727 # Global status via SNMP.. extra safety check
4728 if ($globalstatus != $E_OK && $exit_code == $E_OK && !defined $opt{only}) {
4729     print "OOPS! Something is wrong with this server, but I don't know what. ";
4730     print "The global system health status is $reverse_exitcode{$globalstatus}, ";
4731     print "but every component check is OK. This may be a bug in the Nagios plugin, ";
4732     print "please file a bug report.\n";
4733     exit $E_UNKNOWN;
4734 }
4735
4736 # Print OK message
4737 if ($exit_code == $E_OK && defined $opt{only} && $opt{only} !~ m{\A critical|warning|chassis \z}xms && !$opt{debug}) {
4738     my %okmsg
4739       = ( 'storage'     => "STORAGE OK - $count{pdisk} physical drives, $count{vdisk} logical drives",
4740           'fans'        => $count{fan} == 0 && $blade ? 'OK - blade system with no fan probes' : "FANS OK - $count{fan} fan probes checked",
4741           'temp'        => "TEMPERATURES OK - $count{temp} temperature probes checked",
4742           'memory'      => "MEMORY OK - $count{dimm} memory modules, $count{mem} MB total memory",
4743           'power'       => $count{power} == 0 ? 'OK - no instrumented power supplies found' : "POWER OK - $count{power} power supplies checked",
4744           'cpu'         => "PROCESSORS OK - $count{cpu} processors checked",
4745           'voltage'     => "VOLTAGE OK - $count{volt} voltage probes checked",
4746           'batteries'   => $count{bat} == 0 ? 'OK - no batteries found' : "BATTERIES OK - $count{bat} batteries checked",
4747           'amperage'    => $count{amp} == 0 ? 'OK - no power monitoring probes found' : "AMPERAGE OK - $count{amp} amperage (power monitoring) probes checked",
4748           'intrusion'   => $count{intr} == 0 ? 'OK - no intrusion detection probes found' : "INTRUSION OK - $count{intr} intrusion detection probes checked",
4749           '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",
4750           'esmlog'      => "OK - ESM Log content: $count{esm}{Ok} ok, $count{esm}{'Non-Critical'} warning and $count{esm}{Critical} critical",
4751           'esmhealth'   => "ESM LOG OK - less than 80% used",
4752           'sdcard'      => "SD CARDS OK - $count{sd} SD cards installed",
4753         );
4754
4755     print $okmsg{$opt{only}};
4756
4757     # show blacklisted components
4758     if ($opt{show_blacklist} and %blacklist) {
4759         my @blstr = ();
4760         foreach (keys %blacklist) {
4761             push @blstr, "$_=" . join ',', @{ $blacklist{$_} };
4762         }
4763         print $linebreak;
4764         print "----- BLACKLISTED: " . join '/', @blstr;
4765     }
4766 }
4767 elsif ($exit_code == $E_OK && !$opt{debug}) {
4768     if (defined $opt{htmlinfo}) {
4769         printf q{OK - System: '<a href="%s">%s%s</a>', SN: '<a href="%s">%s</a>'},
4770           documentation_url($sysinfo{model}), $sysinfo{model}, $sysinfo{rev},
4771             warranty_url($sysinfo{serial}), $sysinfo{serial};
4772     }
4773     else {
4774         printf q{OK - System: '%s%s', SN: '%s'},
4775           $sysinfo{model}, $sysinfo{rev}, $sysinfo{serial};
4776     }
4777
4778     if ($check{memory}) {
4779         my $unit = 'MB';
4780         if ($count{mem} >= 1024) {
4781             $count{mem} /= 1024;
4782             $unit = 'GB';
4783         }
4784         printf ', %d %s ram (%d dimms)', $count{mem}, $unit, $count{dimm};
4785     }
4786     else {
4787         print ', not checking memory';
4788     }
4789
4790     if ($check{storage}) {
4791         printf ', %d logical drives, %d physical drives',
4792           $count{vdisk}, $count{pdisk};
4793     }
4794     else {
4795         print ', not checking storage';
4796     }
4797
4798     # show blacklisted components
4799     if ($opt{show_blacklist} and %blacklist) {
4800         my @blstr = ();
4801         foreach (keys %blacklist) {
4802             push @blstr, "$_=" . join ',', @{ $blacklist{$_} };
4803         }
4804         print $linebreak;
4805         print "----- BLACKLISTED: " . join '/', @blstr;
4806     }
4807
4808     if ($opt{okinfo} >= 1) {
4809         print $linebreak;
4810         printf q{----- BIOS='%s %s'}, $sysinfo{bios}, $sysinfo{biosdate};
4811
4812         if ($sysinfo{rac}) {
4813             printf q{, %s='%s'}, $sysinfo{rac_name}, $sysinfo{rac_fw};
4814         }
4815         if ($sysinfo{bmc}) {
4816             printf q{, BMC='%s'}, $sysinfo{bmc_fw};
4817         }
4818     }
4819
4820     if ($opt{okinfo} >= 2) {
4821         if ($check{storage}) {
4822             my @storageprint = ();
4823             foreach my $id (sort keys %{ $sysinfo{controller} }) {
4824                 chomp $sysinfo{controller}{$id}{driver};
4825                 my $msg = sprintf q{----- Ctrl %s [%s]: Fw='%s', Dr='%s'},
4826                   $sysinfo{controller}{$id}{id}, $sysinfo{controller}{$id}{name},
4827                     $sysinfo{controller}{$id}{firmware}, $sysinfo{controller}{$id}{driver};
4828                 if (defined $sysinfo{controller}{$id}{storport}) {
4829                     $msg .= sprintf q{, Storport: '%s'}, $sysinfo{controller}{$id}{storport};
4830                 }
4831                 push @storageprint, $msg;
4832             }
4833             foreach my $id (sort keys %{ $sysinfo{enclosure} }) {
4834                 push @storageprint, sprintf q{----- Encl %s [%s]: Fw='%s'},
4835                   $sysinfo{enclosure}{$id}->{id}, $sysinfo{enclosure}{$id}->{name},
4836                     $sysinfo{enclosure}{$id}->{firmware};
4837             }
4838
4839             # print stuff
4840             foreach my $line (@storageprint) {
4841                 print $linebreak, $line;
4842             }
4843         }
4844     }
4845
4846     if ($opt{okinfo} >= 3) {
4847         print "$linebreak----- OpenManage Server Administrator (OMSA) version: '$sysinfo{om}'";
4848     }
4849
4850 }
4851 else {
4852     if ($opt{extinfo}) {
4853         print $linebreak;
4854         if (defined $opt{htmlinfo}) {
4855             printf '------ SYSTEM: <a href="%s">%s%s</a>, SN: <a href="%s">%s</a>',
4856               documentation_url($sysinfo{model}), $sysinfo{model}, $sysinfo{rev},
4857                 warranty_url($sysinfo{serial}), $sysinfo{serial};
4858         }
4859         else {
4860             printf '------ SYSTEM: %s%s, SN: %s',
4861               $sysinfo{model}, $sysinfo{rev}, $sysinfo{serial};
4862         }
4863     }
4864     if (defined $opt{postmsg}) {
4865         my $post = undef;
4866         if (-f $opt{postmsg}) {
4867             open my $POST, '<', $opt{postmsg}
4868               or ( print $linebreak
4869                    and print "ERROR: Couldn't open post message file $opt{postmsg}: $!\n"
4870                    and exit $E_UNKNOWN );
4871             $post = <$POST>;
4872             close $POST;
4873             chomp $post;
4874         }
4875         else {
4876             $post = $opt{postmsg};
4877         }
4878         if (defined $post) {
4879             print $linebreak;
4880             $post =~ s{[%]s}{$sysinfo{serial}}gxms;
4881             $post =~ s{[%]m}{$sysinfo{model}$sysinfo{rev}}gxms;
4882             $post =~ s{[%]b}{$sysinfo{bios}}gxms;
4883             $post =~ s{[%]d}{$sysinfo{biosdate}}gxms;
4884             $post =~ s{[%]o}{$sysinfo{osname}}gxms;
4885             $post =~ s{[%]r}{$sysinfo{osver}}gxms;
4886             $post =~ s{[%]p}{$count{pdisk}}gxms;
4887             $post =~ s{[%]l}{$count{vdisk}}gxms;
4888             $post =~ s{[%]n}{$linebreak}gxms;
4889             $post =~ s{[%]{2}}{%}gxms;
4890             print $post;
4891         }
4892     }
4893 }
4894
4895 # Reset the WARN signal
4896 $SIG{__WARN__} = 'DEFAULT';
4897
4898 # Print any perl warnings that have occured
4899 if (@perl_warnings) {
4900     foreach (@perl_warnings) {
4901         chop @$_;
4902         print "${linebreak}INTERNAL ERROR: @$_";
4903     }
4904     $exit_code = $E_UNKNOWN;
4905 }
4906
4907 # Print performance data
4908 if (defined $opt{perfdata} && !$opt{debug} && @perfdata) {
4909     my $lb = $opt{perfdata} eq 'multiline' ? "\n" : q{ };  # line break for perfdata
4910     print q{|};
4911
4912     # Sort routine for performance data
4913     sub perfsort {
4914         my %order = ( 'T' => 0, 'W' => 1, 'A' => 2, 'V' => 3, 'F' => 4, 'E' => 5, );
4915
4916         # sort in this order:
4917         #  1. the type according to the hash "order" above
4918         #  2. the id (index) numerically
4919         #  3. the id (index) alphabetically
4920         #  4. the label
4921         return $order{$a->{type}} cmp $order{$b->{type}} ||
4922           ($a->{id} =~ m{\A\d+\z}xms and $a->{id} <=> $b->{id}) ||
4923             ($a->{id} !~ m{\A\d+\z}xms and $a->{id} cmp $b->{id}) ||
4924               $a->{label} cmp $b->{label};
4925     }
4926
4927     # Print performance data sorted
4928     if ($opt{perfdata} eq 'minimal') {
4929         print join $lb, map { "$_->{type}$_->{id}=$_->{value}$_->{unit};$_->{warn};$_->{crit}" } sort perfsort @perfdata;
4930     }
4931     else {
4932         print join $lb, map { "$_->{type}$_->{id}_$_->{label}=$_->{value}$_->{unit};$_->{warn};$_->{crit}" } sort perfsort @perfdata;
4933     }
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;