[BACK]Return to check_hw_sensors CVS log [TXT][DIR] Up to [local] / nagios / check_hw_sensors

Diff for /nagios/check_hw_sensors/check_hw_sensors between version 1.25 and 1.26

version 1.25, 2008/03/10 17:21:53 version 1.26, 2009/11/09 21:25:07
Line 1 
Line 1 
 #!/usr/bin/perl -T  #!/usr/bin/perl -T
 # $RedRiver: check_hw_sensors,v 1.24 2007/02/14 21:59:10 andrew Exp $  # $RedRiver: check_hw_sensors,v 1.25 2008/03/10 16:21:53 andrew Exp $
 ########################################################################  ########################################################################
 # check_hw_sensors *** A nagios check for OpenBSD hw.sensors  # check_hw_sensors *** A nagios check for OpenBSD sysctl hw.sensors
 #  #
 # 2006.05.01 #*#*# andrew fresh <andrew@mad-techies.org>  # 2006.05.01 #*#*# andrew fresh <andrew@mad-techies.org>
 ########################################################################  ########################################################################
 # TODO:  
 #   Really need real documentation.  
 #   allow checking of hw.sensors on a remote host with ssh somehow  
 ########################################################################  
 use strict;  use strict;
 use warnings;  use warnings;
   
Line 16 
Line 12 
   
 use constant NAGIOS_OUTPUT => 1;  use constant NAGIOS_OUTPUT => 1;
   
   my $License = <<'EOL';
   Copyright (c) 2009 Andrew Fresh <andrew@afresh1.com>
   Permission to use, copy, modify, and distribute this software for any
   purpose with or without fee is hereby granted, provided that the above
   copyright notice and this permission notice appear in all copies.
   
   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   EOL
   
 use POSIX;  use POSIX;
 use Config;  use Config;
 use lib "/usr/local/libexec/nagios";  use lib "/usr/local/libexec/nagios";
 use utils qw($TIMEOUT %ERRORS &print_revision &support);  use utils qw($TIMEOUT %ERRORS &support);
   
 use Getopt::Long;  use Getopt::Long;
 Getopt::Long::Configure('bundling');  Getopt::Long::Configure('bundling');
   
 my $PROGNAME = "check_hw_sensors";  my $PROGNAME = "check_hw_sensors";
   
 my $SYSCTL = '/sbin/sysctl';  my $SYSCTL         = '/sbin/sysctl';
 my $GETCAP = '/usr/bin/getcap';  my $GETCAP         = '/usr/bin/getcap';
 my $BASE   = 'hw.sensors';  my $BASE           = 'hw.sensors';
 my $DEFAULT_CONFIG = '/etc/sensorsd.conf';  my $DEFAULT_CONFIG = '/etc/sensorsd.conf';
 my $OSVer = $Config{'osvers'} || 0;  my $OSVer          = $Config{'osvers'} || 0;
   
 my $state = 'UNKNOWN'; # tells whether the it is warning, critical, or OK  my $state = 'UNKNOWN';    # tells whether the it is warning, critical, or OK
 my %states; # This stores the count of states;  my %states;               # This stores the count of states;
 my $filename;  my $filename;
 my $ignore_status;  my $ignore_status;
 my $sensor;  my $sensor;
Line 48 
Line 59 
   
 #Option checking  #Option checking
 my $status = GetOptions(  my $status = GetOptions(
         "version|V"       => \$opt_V,      "version|V"       => \$opt_V,
         "filename|f:s"    => \$filename,      "filename|f:s"    => \$filename,
         "ignore-status|i" => \$ignore_status,      "ignore-status|i" => \$ignore_status,
         "sensor|s=s"      => \$sensor,      "sensor|s=s"      => \$sensor,
         "warning|w=s"     => \$warning,      "warning|w=s"     => \$warning,
         "critical|c=s"    => \$critical,      "critical|c=s"    => \$critical,
 );  );
   
 # set the default this way so it only happens if someone typed -f or --filename  # set the default this way so it only happens if someone typed -f or --filename
 $filename = $DEFAULT_CONFIG if (defined $filename && $filename eq '');  $filename = $DEFAULT_CONFIG if ( defined $filename && $filename eq '' );
   
 # Stuff is output in this file by print_sensor()  # Stuff is output in this file by print_sensor()
 # http://www.openbsd.org/cgi-bin/cvsweb/src/sbin/sysctl/sysctl.c  # http://www.openbsd.org/cgi-bin/cvsweb/src/sbin/sysctl/sysctl.c
 my @Type_Map = (  my @Type_Map = (
         {      {   type  => 'temp',
                 type  => 'temp',          regex => qr/\sdegC$/,
                 regex => qr/\sdegC$/,      },
         },      {   type  => 'fanrpm',
         {          regex => qr/\sRPM$/,
                 type  => 'fanrpm',      },
                 regex => qr/\sRPM$/,      {   type  => 'volts_dc',
         },          regex => qr/\sV\sDC$/,
         {      },
                 type  => 'volts_dc',      {   type  => 'amps',
                 regex => qr/\sV\sDC$/,          regex => qr/\sA$/,
         },      },
         {      {   type  => 'watthour',
                 type  => 'amps',          regex => qr/\sWh$/,
                 regex => qr/\sA$/,      },
         },      {   type  => 'amphour',
         {          regex => qr/\sAh$/,
                 type  => 'watthour',      },
                 regex => qr/\sWh$/,      {   type  => 'indicator',
         },          regex => qr/^(On|Off)$/,
         {      },
                 type  => 'amphour',      {   type  => 'integer',
                 regex => qr/\sAh$/,          regex => qr/\sraw$/,
         },      },
         {      {   type  => 'percent',
                 type  => 'indicator',          regex => qr/\s\%$/,
                 regex => qr/^(On|Off)$/,      },
         },      {   type  => 'lux',
         {          regex => qr/\slx$/,
                 type  => 'integer',      },
                 regex => qr/\sraw$/,      {   type  => 'drive',
         },          regex => qr/^drive\s/,
         {      },
                 type  => 'percent',      {   type  => 'timedelta',
                 regex => qr/\s\%$/,          regex => qr/\ssecs$/,
         },      },
         {  );
                 type  => 'lux',  
                 regex => qr/\slx$/,  
         },  
         {  
                 type  => 'drive',  
                 regex => qr/^drive\s/,  
         },  
         {  
                 type  => 'timedelta',  
                 regex => qr/\ssecs$/,  
         },  
 );  
   
 if ($status == 0) {  if ( $status == 0 ) {
         print_help() ;      print_help();
         exit $ERRORS{'OK'};      exit $ERRORS{'OK'};
 }  }
   
 if ($opt_V) {  if ($opt_V) {
         print_revision($PROGNAME,'$Revision$ ');      print_revision( $PROGNAME, '$Revision$ ' );
         exit $ERRORS{'OK'};      exit $ERRORS{'OK'};
 }  }
   
 unless (  if (
         (      $opt_h
                 defined $filename ||      || ( ( !defined $filename ) && ( !defined $sensor ) )
                 (not defined $ignore_status) ||      #|| ( defined $sensor && !( $warning || $critical ) )
                 (defined $sensor && ($warning || $critical))      )
          ) &&  {
          ( (!defined $filename) || (!defined $sensor) )      print_help();
 ) {      exit $ERRORS{'OK'};
         print_help();  
         exit $ERRORS{'OK'};  
 }  }
   
   if ( defined $sensor ) {
       if ( $sensor !~ /^$BASE/ ) {
           $sensor = $BASE . '.' . $sensor;
       }
       $CHECK_SENSOR = $sensor;
   
 if (defined $sensor) {      $CHECKS{$sensor}{'warn'} = $warning  if defined $warning;
         if ($sensor !~ /^$BASE/) {      $CHECKS{$sensor}{'crit'} = $critical if defined $critical;
                 $sensor = $BASE . '.' . $sensor;  
         }  
         $CHECK_SENSOR = $sensor;  
   
         $CHECKS{$sensor}{'warn'} = $warning  if defined $warning;  
         $CHECKS{$sensor}{'crit'} = $critical if defined $critical;  
   
 } elsif (defined $filename) {  
         %CHECKS = parse_file($filename);  
 }  }
   elsif ( defined $filename ) {
       %CHECKS = parse_file($filename);
   }
   
 open my $sysctl, "-|", $SYSCTL, $CHECK_SENSOR  open my $sysctl, "-|", $SYSCTL, $CHECK_SENSOR
     or die "Couldn't open sysctl: $!";      or die "Couldn't open sysctl: $!";
 while (<$sysctl>) {  while (<$sysctl>) {
 #while (<>) {  
         chomp;  
         my ($id, $output) = split /=/;  
         my @s = split /\./, $id;  
         my @o = split /,\s*/, $output;  
   
         my ($type, $source, $descr, $data, $status);      #while (<>) {
       chomp;
       my ( $id, $output ) = split /=/;
       my @s = split /\./,   $id;
       my @o = split /,\s*/, $output;
   
         $source = $o[0];      my ( $type, $source, $descr, $data, $status );
         $descr  = $o[1];  
   
         if ($OSVer >= 4.1) {      $source = $o[0];
                 $data   = $o[0];      $descr  = $o[1];
                 if ($data =~ s/\s+\((.*)\).*$//) {  
                         $descr = $1;  
                 }  
                 $status = $o[1];  
                 ($source, $type) = $id =~ /([^\.]+)\.([^\.]+?)\d+$/;  
         } elsif ($OSVer >= 4.0) {  
                 $data   = $o[2];  
                 $status = $o[3];  
                 foreach my $t (@Type_Map) {  
                         if ($data =~ /$t->{'regex'}/) {  
                                 $type = $t->{'type'};  
                                 last;  
                         }  
                 }  
         }  else {  
                 $data   = $o[-1];  
                 $status = $o[2] if @o == 5;  
                 $type   = $o[-2];  
         }  
   
         $type ||= 'unknown';      if ( $OSVer >= 4.1 ) {
           $data = $o[0];
           if ( $data =~ s/\s+\((.*)\).*$// ) {
               $descr = $1;
           }
           $status = $o[1];
           ( $source, $type ) = $id =~ /([^\.]+)\.([^\.]+?)\d+$/;
       }
       elsif ( $OSVer >= 4.0 ) {
           $data   = $o[2];
           $status = $o[3];
           foreach my $t (@Type_Map) {
               if ( $data =~ /$t->{'regex'}/ ) {
                   $type = $t->{'type'};
                   last;
               }
           }
       }
       else {
           $data   = $o[-1];
           $status = $o[2] if @o == 5;
           $type   = $o[-2];
       }
   
         $SENSORS{$id} = {      $type ||= 'unknown';
                 id          => $id,  
                 output      => $output,      $SENSORS{$id} = {
                 source      => $source,          id          => $id,
                 description => $descr,          output      => $output,
                 status      => $status,          source      => $source,
                 type        => $type,          description => $descr,
                 data        => $data,          status      => $status,
         };          type        => $type,
           data        => $data,
       };
   
 }  }
 close $sysctl;  close $sysctl;
   
 sub as_if_numeric {  sub as_if_numeric {
         my $_a = $a;      my $_a = $a;
         my $_b = $b;      my $_b = $b;
         $_a =~ s/\D//g;      $_a =~ s/\D//g;
         $_b =~ s/\D//g;      $_b =~ s/\D//g;
         $_a <=> $_b;      $_a <=> $_b;
 }  }
   
 foreach my $s (sort as_if_numeric keys %SENSORS) {  foreach my $s ( sort as_if_numeric keys %SENSORS ) {
         my ($r, $data);      my ( $r, $data );
         if (exists $CHECKS{$s}) {      if ( exists $CHECKS{$s} ) {
                 $r    = check_sensor($SENSORS{$s}, $CHECKS{$s});          $r = check_sensor( $SENSORS{$s}, $CHECKS{$s} );
                 $data = $s . '=' . $SENSORS{$s}{'output'};          $data = $s . '=' . $SENSORS{$s}{'output'};
         } elsif (not $ignore_status) {      }
                 $r = check_sensor($SENSORS{$s});      elsif ( not $ignore_status ) {
                 $data = $s . '=' . $SENSORS{$s}{'output'};          $r    = check_sensor( $SENSORS{$s} );
         } else {          $data = $s . '=' . $SENSORS{$s}{'output'};
                 # ignore this sensor      }
         }      else {
         next unless defined $r;  
         push @{ $states{ $r } }, $data;          # ignore this sensor
       }
       next unless defined $r;
       push @{ $states{$r} }, $data;
 }  }
   
 $state = 'OK';  $state = 'OK';
 my $have_results = 0;  my $have_results = 0;
 foreach my $error (sort { $ERRORS{$a} <=> $ERRORS{$b} } keys %ERRORS) {  foreach my $error ( sort { $ERRORS{$a} <=> $ERRORS{$b} } keys %ERRORS ) {
         if (exists $states{$error}) {      if ( exists $states{$error} ) {
                 $have_results++;          $have_results++;
                 $state = $error;          $state = $error;
         }      }
 }  }
 foreach my $error (sort { $ERRORS{$b} <=> $ERRORS{$a} } keys %ERRORS) {  foreach my $error ( sort { $ERRORS{$b} <=> $ERRORS{$a} } keys %ERRORS ) {
         if (exists $states{$error}) {      if ( exists $states{$error} ) {
                 if (NAGIOS_OUTPUT) {          if (NAGIOS_OUTPUT) {
                         print "$error (" . scalar(@{ $states{ $error } }) . ")";              print "$error (" . scalar( @{ $states{$error} } ) . ")";
                         unless ($error eq 'OK') {              if ( $error ne 'OK' ) {
                                 print '<br>';                  print '<br>';
                                 print map {" - $_<br>"} @{ $states{ $error } };                  print map {" - $_<br>"} @{ $states{$error} };
                         }              }
                 } else {          }
                         print "$error (" . scalar(@{ $states{ $error } }) . "):\n";          else {
                         foreach (@{ $states{ $error } }) {              print "$error (" . scalar( @{ $states{$error} } ) . "):\n";
                                 print "   $_\n";              foreach ( @{ $states{$error} } ) {
                         }                  print "   $_\n";
                 }              }
         }          }
       }
 }  }
 if ($have_results == 0) {  if ( $have_results == 0 ) {
         print "No results found\n";      print "No results found\n";
 }  }
 exit $ERRORS{$state};  exit $ERRORS{$state};
   
   
 sub parse_file {  sub parse_file {
         my $filename = shift;      my $filename = shift;
         my %contents;      my %contents;
   
         die "file '$filename' does not exist." unless -e $filename;  
   
         open my $fh, '-|', $GETCAP, '-a', '-f', $filename      die "file '$filename' does not exist." unless -e $filename;
                 or die "Couldn't open FILE '$GETCAP -a -f $filename': $!";  
         LINE: while (<$fh>) {  
                 chomp;  
                 my ($key, @c) = split /\:/;  
                 foreach (@c) {  
                         my ($k, $v) = split /\=/;  
                         if (lc($k) eq 'ignore') {  
                                 $contents{$key}{'IGNORE'} = 1;  
                         } elsif (lc($k) eq 'status') {  
                                 $contents{$key}{'STATUS'} = 1;  
                         } else {  
                                 $contents{$key}{$k} = $v;  
                         }  
                 }  
         }  
         close $fh;  
   
         return %contents;      open my $fh, '-|', $GETCAP, '-a', '-f', $filename
           or die "Couldn't open FILE '$GETCAP -a -f $filename': $!";
       while (<$fh>) {
           chomp;
           my ( $key, @c ) = split /\:/;
           foreach (@c) {
               my ( $k, $v ) = split /\=/;
               if ( lc($k) eq 'ignore' ) {
                   $contents{$key}{'IGNORE'} = 1;
               }
               elsif ( lc($k) eq 'status' ) {
                   $contents{$key}{'STATUS'} = 1;
               }
               else {
                   $contents{$key}{$k} = $v;
               }
           }
       }
       close $fh;
   
       return %contents;
 }  }
   
 sub parse_check {  sub parse_check {
         my $type  = shift;      my $check = shift;
         my $check = shift;  
   
         return undef unless $check;      return unless $check;
         return undef    if $check->{'STATUS'};      return if $check->{'STATUS'};
         return 'IGNORE' if $check->{'IGNORE'};      return 'IGNORE' if $check->{'IGNORE'};
   
         foreach my $code ('crit', 'warn') {      foreach my $code ( 'crit', 'warn' ) {
                 if (defined $check->{$code} && $check->{$code} =~ /:/) {          if ( defined $check->{$code} && $check->{$code} =~ /:/ ) {
                         if (my ($low, $high) = split /:/, $check->{$code}) {              if ( my ( $low, $high ) = split /:/, $check->{$code} ) {
                                 $check->{$code . '.low'}  = $low;                  $check->{ $code . '.low' }  = $low  if length $low;
                                 $check->{$code . '.high'} = $high;                  $check->{ $code . '.high' } = $high if length $high;
                         }              }
                         delete $check->{$code};              delete $check->{$code};
                 }          }
   
                 foreach my $severity ('low', 'high') {          foreach my $severity ( 'low', 'high' ) {
                         if (defined $check->{$severity}) {              if ( defined $check->{$severity} ) {
                                 $check->{ $code . '.' . $severity } = $check->{$severity}                  $check->{ $code . '.' . $severity } = $check->{$severity}
                                         unless defined $check->{ $code . '.' . $severity };                      if !defined $check->{ $code . '.' . $severity };
                         }              }
                 }          }
                 no warnings 'uninitialized';          no warnings 'uninitialized';
                 $check->{$code} = [ split /,\s*/, $check->{$code} ];          $check->{$code} = [ split /,\s*/, $check->{$code} ];
         }      }
   
         return $check;      return $check;
 }  }
   
 sub check_sensor {  sub check_sensor {
         my $sensor = shift;      my $sensor = shift;
         my $check  = shift;      my $check  = shift;
         my $result = 'UNKNOWN';      my $result = 'UNKNOWN';
         my %errors = (      my %errors = (
                 'warn' => 'WARNING',          'warn' => 'WARNING',
                 'crit' => 'CRITICAL',          'crit' => 'CRITICAL',
         );      );
   
         return $result unless ref $sensor eq 'HASH';      return $result unless ref $sensor eq 'HASH';
         $check = parse_check($sensor->{'type'}, $check) if $check;      $check = parse_check($check) if $check;
   
         # It looks like doing this should be safe, from      if (! $check) {
         # src/sbin/sysctl/sysctl.c          # It looks like doing this should be safe, from
         return $sensor->{'status'} unless $check;          # src/sbin/sysctl/sysctl.c
           return $sensor->{'status'} if $sensor->{'status'};
   
         return undef if $check eq 'IGNORE';          return;
       }
       elsif ($check eq 'IGNORE') {
           return;
       }
   
         $result = 'OK';      use YAML;
         foreach my $code ('warn', 'crit') {      print Dump $check;
                 if (  
                         $sensor->{'type'} eq 'fan'      ||  
                         $sensor->{'type'} eq 'fanrpm'   ||  
                         $sensor->{'type'} eq 'volt'     ||  
                         $sensor->{'type'} eq 'volts_dc' ||  
                         $sensor->{'type'} eq 'amps'     ||  
                         $sensor->{'type'} eq 'watthour' ||  
                         $sensor->{'type'} eq 'amphour'  ||  
                         $sensor->{'type'} eq 'integer'  ||  
                         $sensor->{'type'} eq 'raw'      ||  
                         $sensor->{'type'} eq 'percent'  ||  
                         $sensor->{'type'} eq 'lux'      ||  
                         $sensor->{'type'} eq 'timedelta'  
                 ) {  
                         my $data = $sensor->{'data'};  
                         $data =~ s/[^\d\.]//g;  
                         unless (length $data) {  
                                 warn "INVALID DATA ($sensor->{'data'}) for '$sensor->{'id'}'";  
                                 next;  
                         }  
   
                         if (      $result = 'OK';
                                 defined $check->{$code . ".low"} ||      foreach my $code ( 'warn', 'crit' ) {
                                 defined $check->{$code . ".high"}          if (   $sensor->{'type'} eq 'fan'
                         ) {              || $sensor->{'type'} eq 'fanrpm'
                                 if (defined $check->{$code . ".low"}) {              || $sensor->{'type'} eq 'volt'
                                         my $c =  $check->{$code . ".low"};              || $sensor->{'type'} eq 'volts_dc'
                                         $c =~ s/[^\d\.]//g;              || $sensor->{'type'} eq 'amps'
               || $sensor->{'type'} eq 'watthour'
                                         unless (length $c) {              || $sensor->{'type'} eq 'amphour'
                                                 warn "INVALID CHECK (" . $check->{$code . ".low"} .              || $sensor->{'type'} eq 'integer'
                                                       ") for '$sensor->{'id'}:$code.low'";              || $sensor->{'type'} eq 'raw'
                                                 next;              || $sensor->{'type'} eq 'percent'
                                         }              || $sensor->{'type'} eq 'lux'
               || $sensor->{'type'} eq 'timedelta' )
           {
               my $data = $sensor->{'data'};
               $data =~ s/[^\d\.]//g;
               if (! length $data ) {
                   warn "INVALID DATA ($sensor->{'data'}) for '$sensor->{'id'}'";
                   next;
               }
   
                                         $result = $errors{$code}              if (   defined $check->{ $code . ".low" }
                                                 if ($c >= $data);                  || defined $check->{ $code . ".high" } )
                                 }              {
                                 if (defined $check->{$code . ".high"}) {                  if ( defined $check->{ $code . ".low" } ) {
                                         my $c =  $check->{$code . ".high"};                      my $c = $check->{ $code . ".low" };
                                         $c =~ s/[^\d\.]//g;                      $c =~ s/[^\d\.]//g;
                                         unless (length $c) {  
                                                 warn "INVALID CHECK (" . $check->{$code . ".high"} .  
                                                       ") for '$sensor->{'id'}:$code.high'";  
                                                 next;  
                                         }  
   
                                         $result = $errors{$code}                      if (! length $c ) {
                                                 if ($c <= $data);                          warn "INVALID CHECK ("
                                 }                              . $check->{ $code . ".low" }
                         } elsif (@{ $check->{$code} }) {                              . ") for '$sensor->{'id'}:$code.low'";
                                 my $matched = 0;                          next;
                                 foreach my $c (@{ $check->{$code} }) {                      }
                                         $c =~ s/[^\d\.]//g;  
                                         unless (length $c) {  
                                                 warn "INVALID CHECK (" . $c .  
                                                       ") for '$sensor->{'id'}:$code'";  
                                                 next;  
                                         }  
   
                                         if ($c eq $data) {                      $result = $errors{$code}
                                                 $matched = 1;                          if ( $c >= $data );
                                                 last;                  }
                                         }                  if ( defined $check->{ $code . ".high" } ) {
                                 }                      my $c = $check->{ $code . ".high" };
                                 $result = $errors{$code} unless $matched;                      $c =~ s/[^\d\.]//g;
                         }                      if (! length $c ) {
                           warn "INVALID CHECK ("
                               . $check->{ $code . ".high" }
                               . ") for '$sensor->{'id'}:$code.high'";
                           next;
                       }
   
                 } elsif ($sensor->{'type'} eq 'temp') {                      $result = $errors{$code}
                         my ($degC, $degF) = split /\//, $sensor->{'data'};                          if ( $c <= $data );
                         $degC =~ s/[^\d\.]//g;                  }
                         $degF ||= $degC * 9 / 5 + 32;              }
                         $degF =~ s/[^\d\.]//g;              elsif ( @{ $check->{$code} } ) {
                         if (                  my $matched = 0;
                                 defined $check->{$code . ".low"} ||                  foreach my $c ( @{ $check->{$code} } ) {
                                 defined $check->{$code . ".high"}                      $c =~ s/[^\d\.]//g;
                         ) {                      if (! length $c ) {
                                 if (defined $check->{$code . ".low"}) {                          warn "INVALID CHECK (" . $c
                                         my $c =  $check->{$code . ".low"};                              . ") for '$sensor->{'id'}:$code'";
                                         my $data = $degC;                          next;
                       }
   
                                         $data = $degF if ($c =~ /F/i);                      if ( $c eq $data ) {
                                         unless (length $data) {                          $matched = 1;
                                                 warn "INVALID DATA (" . $sensor->{'data'} .                          last;
                                                           ") for '$sensor->{'id'}'";                      }
                                                 next;                  }
                                         }                  $result = $errors{$code} unless $matched;
               }
   
                                         $c =~ s/[^\d\.]//g;          }
                                         unless (length $c) {          elsif ( $sensor->{'type'} eq 'temp' ) {
                                                 warn "INVALID CHECK (" . $check->{$code . ".low"} .              my ( $degC, $degF ) = split /\//, $sensor->{'data'};
                                                          ") for '$sensor->{'id'}':$code.low";              $degC =~ s/[^\d\.]//g;
                                                 next;              $degF ||= $degC * 9 / 5 + 32;
                                         }              $degF =~ s/[^\d\.]//g;
               if (   defined $check->{ $code . ".low" }
                   || defined $check->{ $code . ".high" } )
               {
                   if ( defined $check->{ $code . ".low" } ) {
                       my $c    = $check->{ $code . ".low" };
                       my $data = $degC;
   
                                         $result = $errors{$code}                      $data = $degF if ( $c =~ /F/i );
                                                 if ($c >= $data);                      if (! length $data ) {
                                 }                          warn "INVALID DATA ("
                                 if (defined $check->{$code . ".high"}) {                              . $sensor->{'data'}
                                         my $c =  $check->{$code . ".high"};                              . ") for '$sensor->{'id'}'";
                           next;
                       }
   
                                         my $data = $degC;                      $c =~ s/[^\d\.]//g;
                                         $data = $degF if ($c =~ /F/i);                      if (! length $c ) {
                                         unless (length $data) {                          warn "INVALID CHECK ("
                                                 warn "INVALID DATA (" . $sensor->{'data'} .                              . $check->{ $code . ".low" }
                                                           ") for '$sensor->{'id'}'";                              . ") for '$sensor->{'id'}':$code.low";
                                                 next;                          next;
                                         }                      }
   
                                         $c =~ s/[^\d\.]//g;                      $result = $errors{$code}
                                         unless (length $c) {                          if ( $c >= $data );
                                                 warn "INVALID CHECK (" . $check->{$code . ".high"} .                  }
                                                          ") for '$sensor->{'id'}:$code.high'";                  if ( defined $check->{ $code . ".high" } ) {
                                                 next;                      my $c = $check->{ $code . ".high" };
                                         }  
   
                                         $result = $errors{$code}                      my $data = $degC;
                                                 if ($c <= $data);                      $data = $degF if ( $c =~ /F/i );
                                 }                      if (! length $data ) {
                         } elsif (@{ $check->{$code} }) {                          warn "INVALID DATA ("
                               . $sensor->{'data'}
                               . ") for '$sensor->{'id'}'";
                           next;
                       }
   
                                 my $matched = 0;                      $c =~ s/[^\d\.]//g;
                                 foreach my $c (@{ $check->{$code} }) {                      if (! length $c ) {
                                         my $data = $degC;                          warn "INVALID CHECK ("
                               . $check->{ $code . ".high" }
                               . ") for '$sensor->{'id'}:$code.high'";
                           next;
                       }
   
                                         $data = $degF if ($c =~ /F/i);                      $result = $errors{$code}
                                         unless (length $data) {                          if ( $c <= $data );
                                                 warn "INVALID DATA (" . $sensor->{'data'} .                  }
                                                           ") for '$sensor->{'id'}'";              }
                                                 next;              elsif ( @{ $check->{$code} } ) {
                                         }  
   
                                         $c =~ s/[^\d\.]//g;                  my $matched = 0;
                                         unless (length $c) {                  foreach my $c ( @{ $check->{$code} } ) {
                                                 warn "INVALID CHECK (" . $c .                      my $data = $degC;
                                                          ") for '$sensor->{'id'}':$code";  
                                                 next;  
                                         }  
   
                                         if ($c eq $data) {                      $data = $degF if ( $c =~ /F/i );
                                                 $matched = 1;                      if (! length $data ) {
                                                 last;                          warn "INVALID DATA ("
                                         }                              . $sensor->{'data'}
                                 }                              . ") for '$sensor->{'id'}'";
                                 $result = $errors{$code} unless $matched;                          next;
                         }                      }
   
                 } elsif (                      $c =~ s/[^\d\.]//g;
                         $sensor->{'type'} eq 'drive' ||                      if (! length $c ) {
                         $sensor->{'type'} eq 'indicator'                          warn "INVALID CHECK (" . $c
                 ) {                              . ") for '$sensor->{'id'}':$code";
                         $sensor->{'data'} =~ s/^drive\s+//;                          next;
                         if (@{ $check->{$code} }) {                      }
                                 my $matched = 0;  
                                 foreach (@{ $check->{$code} }) {  
                                         if ($_ eq $sensor->{'data'}) {  
                                                 $matched = 1;  
                                                 last;  
                                         }  
                                 }  
                                 $result = $errors{$code} unless $matched;  
                         }  
   
                 } else {                      if ( $c eq $data ) {
                         print STDERR 'Unknown Sensor Type: ',                          $matched = 1;
                             $sensor->{'id'},                          last;
                             '=',                      }
                             $sensor->{'type'},                  }
                             "\n";                  $result = $errors{$code} unless $matched;
                         $result = 'UNKNOWN';              }
                 }  
   
         }          }
           elsif ($sensor->{'type'} eq 'drive'
               || $sensor->{'type'} eq 'indicator' )
           {
               $sensor->{'data'} =~ s/^drive\s+//;
               if ( @{ $check->{$code} } ) {
                   my $matched = 0;
                   foreach ( @{ $check->{$code} } ) {
                       if ( $_ eq $sensor->{'data'} ) {
                           $matched = 1;
                           last;
                       }
                   }
                   $result = $errors{$code} unless $matched;
               }
   
         return $result;          }
           else {
               print STDERR 'Unknown Sensor Type: ',
                   $sensor->{'id'},
                   '=',
                   $sensor->{'type'},
                   "\n";
               $result = 'UNKNOWN';
           }
   
       }
   
       return $result;
 }  }
   
 sub print_help {  sub print_help {
         print <<EOL;      print <<"EOL";
 $PROGNAME plugin for Nagios monitors sysctl hw.sensors on OpenBSD  $PROGNAME - monitors sysctl hw.sensors on OpenBSD
     $PROGNAME [-i] (-f [<FILENAME>]|(-s <hw.sensors id> [-w limit] [-c limit]))      $PROGNAME [-i] (-f [<FILENAME>]|(-s <hw.sensors id> [-w limit] [-c limit]))
   
 Usage:  Usage:
     -i, --ignore-status      -i, --ignore-status
         Don't check the status of sensors that report it.          Don't automatically check the status of sensors that report it.
     -f, --filename=FILE      -f, --filename=FILE
         FILE to load checks from (defaults to /etc/sensorsd.conf)          FILE to load checks from (defaults to /etc/sensorsd.conf)
     -s, --sensor=ID      -s, --sensor=ID
         ID of a single sensor.  "-s 0" means hw.sensors.0.          ID of a single sensor.  "-s kate0.temp0" means hw.sensors.kate0.temp0
     -w, --warning=RANGE or single ENTRY      -w, --warning=RANGE or single ENTRY
         Exit with WARNING status if outside of RANGE or if != ENTRY          Exit with WARNING status if outside of RANGE or if != ENTRY
     -c, --critical=RANGE or single ENTRY      -c, --critical=RANGE or single ENTRY
Line 525 
Line 545 
   
 FILE is in the same format as sensorsd.conf(5) plus some additional  FILE is in the same format as sensorsd.conf(5) plus some additional
 entries.  These additional entries in the file are ignored by  entries.  These additional entries in the file are ignored by
 sensorsd(8).  sensorsd(8) this means you can use the same config file for $PROGNAME
   as well as sensorsd(8).
   
 $PROGNAME understands the following entries:  $PROGNAME understands the following entries:
   
Line 556 
Line 577 
   
 A RANGE is a low ENTRY and a high ENTRY separated by a colon (:).  A RANGE is a low ENTRY and a high ENTRY separated by a colon (:).
 It can also be low: or :high with the other side left blank to only  It can also be low: or :high with the other side left blank to only
 make the single check..  make the single check.
   
 An entry marked "ignore" will cause that sensor to be skipped.  An entry marked "ignore" will cause that sensor to be skipped.
 Generally used with state checking of all sensors to ignore sensors you  Generally used with state checking of all sensors to ignore sensors you
Line 567 
Line 588 
   
 EOL  EOL
   
         print_revision($PROGNAME, '$Revision$');      print_revision( $PROGNAME, '$Revision$' );
   
       print $License;
 }  }
   
   
   sub print_revision {
       my ($prog, $rev) = @_;
       $rev =~ s/^\D+([\d\.]+)\D+$/v$1/xms;
   
       print "$prog $rev\n";
   }
   
   
   
Legend:
Removed from v.1.25  
changed lines
  Added in v.1.26
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>