

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: check_mailq</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>#!/usr/bin/perl -w

# check_mailq - check to see how many messages are in the smtp queue awating
#   transmittal.  
#
# Initial version support sendmail&#039;s mailq command
#  Support for multiple sendmail queues (Carlos Canau)
#  Support for qmail (Benjamin Schmid)

# License Information:
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
# MA 02110-1301, USA 
#
############################################################################

use POSIX;
use strict;
use Getopt::Long;
use vars qw($opt_V $opt_h $opt_v $verbose $PROGNAME $opt_w $opt_c $opt_t $opt_s $opt_d
					$opt_M $mailq $status $state $msg $msg_q $msg_p $opt_W $opt_C $mailq $mailq_args
					@lines %srcdomains %dstdomains);
use FindBin;
use lib &quot;$FindBin::Bin&quot;;
use lib &#039;/usr/lib64/nagios/plugins&#039;;
use utils qw(%ERRORS &amp;print_revision &amp;support &amp;usage );

my ($sudo);

sub print_help ();
sub print_usage ();
sub process_arguments ();

$ENV{&#039;PATH&#039;}=&#039;/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin&#039;;
$ENV{&#039;BASH_ENV&#039;}=&#039;&#039;; 
$ENV{&#039;ENV&#039;}=&#039;&#039;;
$PROGNAME = &quot;check_mailq&quot;;
$mailq = &#039;sendmail&#039;;	# default
$msg_q = 0 ;
$msg_p = 0 ;
# If appended, must start with a space
$mailq_args = &#039;&#039; ;
$state = $ERRORS{&#039;UNKNOWN&#039;};

Getopt::Long::Configure(&#039;bundling&#039;);
$status = process_arguments();
if ($status){
	print &quot;ERROR: processing arguments\n&quot;;
	exit $ERRORS{&quot;UNKNOWN&quot;};
}

if ($opt_d) {
	$mailq_args = $mailq_args . &#039; -C &#039; . $opt_d;
}

if ($opt_s) {
	if ($utils::PATH_TO_SUDO ne &quot;&quot;) {
		if (-x $utils::PATH_TO_SUDO) {
			$sudo = $utils::PATH_TO_SUDO;
		} else {
			print &quot;ERROR: Cannot execute sudo\n&quot;;
			exit $ERRORS{&#039;UNKNOWN&#039;};
		}
	}
} else {
	$sudo = &quot;&quot;;
}

$SIG{&#039;ALRM&#039;} = sub {
	print (&quot;ERROR: timed out waiting for $utils::PATH_TO_MAILQ \n&quot;);
	exit $ERRORS{&quot;WARNING&quot;};
};
alarm($opt_t);

# switch based on MTA

if ($mailq eq &quot;sendmail&quot;) {

	## open mailq 
	if ( defined $utils::PATH_TO_MAILQ &amp;&amp; -x $utils::PATH_TO_MAILQ ) {
		if (! open (MAILQ, &quot;$sudo $utils::PATH_TO_MAILQ | &quot; ) ) {
			print &quot;ERROR: could not open $utils::PATH_TO_MAILQ \n&quot;;
			exit $ERRORS{&#039;UNKNOWN&#039;};
		}
	}elsif( defined $utils::PATH_TO_MAILQ){
		unless (-x $utils::PATH_TO_MAILQ) {
			print &quot;ERROR: $utils::PATH_TO_MAILQ is not executable by (uid $&gt;:gid($)))\n&quot;;
			exit $ERRORS{&#039;UNKNOWN&#039;};
		}
	} else {
		print &quot;ERROR: \$utils::PATH_TO_MAILQ is not defined\n&quot;;
		exit $ERRORS{&#039;UNKNOWN&#039;};
	}
#  single queue empty
##/var/spool/mqueue is empty
#  single queue: 1
##                /var/spool/mqueue (1 request)
##----Q-ID---- --Size-- -----Q-Time----- ------------Sender/Recipient------------
##h32E30p01763     2782 Wed Apr  2 15:03 &lt;silvaATkpnqwest.pt&gt;
##      8BITMIME
##                                       &lt;silvaATeunet.pt&gt;

#  multi queue empty
##/var/spool/mqueue/q0/df is empty
##/var/spool/mqueue/q1/df is empty
##/var/spool/mqueue/q2/df is empty
##/var/spool/mqueue/q3/df is empty
##/var/spool/mqueue/q4/df is empty
##/var/spool/mqueue/q5/df is empty
##/var/spool/mqueue/q6/df is empty
##/var/spool/mqueue/q7/df is empty
##/var/spool/mqueue/q8/df is empty
##/var/spool/mqueue/q9/df is empty
##/var/spool/mqueue/qA/df is empty
##/var/spool/mqueue/qB/df is empty
##/var/spool/mqueue/qC/df is empty
##/var/spool/mqueue/qD/df is empty
##/var/spool/mqueue/qE/df is empty
##/var/spool/mqueue/qF/df is empty
##                Total Requests: 0
#  multi queue: 1
##/var/spool/mqueue/q0/df is empty
##/var/spool/mqueue/q1/df is empty
##/var/spool/mqueue/q2/df is empty
##                /var/spool/mqueue/q3/df (1 request)
##----Q-ID---- --Size-- -----Q-Time----- ------------Sender/Recipient------------
##h32De2f23534*      48 Wed Apr  2 14:40 nocol
##                                       nouserATEUnet.pt
##                                       canau
##/var/spool/mqueue/q4/df is empty
##/var/spool/mqueue/q5/df is empty
##/var/spool/mqueue/q6/df is empty
##/var/spool/mqueue/q7/df is empty
##/var/spool/mqueue/q8/df is empty
##/var/spool/mqueue/q9/df is empty
##/var/spool/mqueue/qA/df is empty
##/var/spool/mqueue/qB/df is empty
##/var/spool/mqueue/qC/df is empty
##/var/spool/mqueue/qD/df is empty
##/var/spool/mqueue/qE/df is empty
##/var/spool/mqueue/qF/df is empty
##                Total Requests: 1

	
	while (&lt;MAILQ&gt;) {
	
		# match email addr on queue listing
		if ( (/&lt;.*@.*\.(\w+\.\w+)&gt;/) || (/&lt;.*@(\w+\.\w+)&gt;/) ) {
			my $domain = $1;
			if (/^\w+/) {
	  		print &quot;$utils::PATH_TO_MAILQ = srcdomain = $domain \n&quot; if $verbose ;
		    $srcdomains{$domain} ++;
			}
			next;
		}
	
		#
		# ...
		# sendmail considers a message with more than one destiny, say N, to the same MX 
		# to have N messages in queue.
		# we will only consider one in this code
		if (( /\s\(reply:\sread\serror\sfrom\s.*\.(\w+\.\w+)\.$/ ) || ( /\s\(reply:\sread\serror\sfrom\s(\w+\.\w+)\.$/ ) ||
			( /\s\(timeout\swriting\smessage\sto\s.*\.(\w+\.\w+)\.:/ ) || ( /\s\(timeout\swriting\smessage\sto\s(\w+\.\w+)\.:/ ) ||
			( /\s\(host\smap:\slookup\s\(.*\.(\w+\.\w+)\):/ ) || ( /\s\(host\smap:\slookup\s\((\w+\.\w+)\):/ ) || 
			( /\s\(Deferred:\s.*\s.*\.(\w+\.\w+)\.\)/ ) || ( /\s\(Deferred:\s.*\s(\w+\.\w+)\.\)/ ) ) {
	
			print &quot;$utils::PATH_TO_MAILQ = dstdomain = $1 \n&quot; if $verbose ;
			$dstdomains{$1} ++;
		}
	
		if (/\s+\(I\/O\serror\)/) {
			print &quot;$utils::PATH_TO_MAILQ = dstdomain = UNKNOWN \n&quot; if $verbose ;
			$dstdomains{&#039;UNKNOWN&#039;} ++;
		}

		# Finally look at the overall queue length
		#
		if (/mqueue/) {
			print &quot;$utils::PATH_TO_MAILQ = $_ &quot;if $verbose ;
			if (/ \((\d+) request/) {
	    	#
		    # single queue: first line
		    # multi queue: one for each queue. overwrite on multi queue below
	  	  $msg_q = $1 ;
			}
		} elsif (/^\s+Total\sRequests:\s(\d+)$/i) {
			print &quot;$utils::PATH_TO_MAILQ = $_ \n&quot; if $verbose ;
			#
			# multi queue: last line
			$msg_q = $1 ;
		}
	
	}
	

	## close mailq

	close (MAILQ); 

	if ( $? ) {
		print &quot;CRITICAL: Error code &quot;.($?&gt;&gt;8).&quot; returned from $utils::PATH_TO_MAILQ&quot;,$/;
		exit $ERRORS{CRITICAL};
	}

	## shut off the alarm
	alarm(0);


	## now check the queue length(s)

	if ($msg_q == 0) {
		$msg = &quot;OK: $mailq mailq is empty&quot;;
		$state = $ERRORS{&#039;OK&#039;};
	} else {
		print &quot;msg_q = $msg_q warn=$opt_w crit=$opt_c\n&quot; if $verbose;
	
		# overall queue length
		if ($msg_q &lt; $opt_w) {
			$msg = &quot;OK: $mailq mailq ($msg_q) is below threshold ($opt_w/$opt_c)&quot;;
			$state = $ERRORS{&#039;OK&#039;};
		}elsif ($msg_q &gt;= $opt_w  &amp;&amp; $msg_q &lt; $opt_c) {
			$msg = &quot;WARNING: $mailq mailq is $msg_q (threshold w = $opt_w)&quot;;
			$state = $ERRORS{&#039;WARNING&#039;};
		}else {
			$msg = &quot;CRITICAL: $mailq mailq is $msg_q (threshold c = $opt_c)&quot;;
			$state = $ERRORS{&#039;CRITICAL&#039;};
		}

		# check for domain specific queue lengths if requested
		if (defined $opt_W) {
		
			# Apply threshold to queue lengths FROM domain
			my @srckeys = sort { $srcdomains{$b} &lt;=&gt; $srcdomains{$a} } keys %srcdomains;
  	  my $srcmaxkey = $srckeys[0];
    	print &quot;src max is $srcmaxkey with $srcdomains{$srcmaxkey} messages\n&quot; if $verbose;
		
			if ($srcdomains{$srcmaxkey} &gt;= $opt_W &amp;&amp; $srcdomains{$srcmaxkey} &lt; $opt_C) {
				if ($state == $ERRORS{&#039;OK&#039;}) {
					$msg = &quot;WARNING: $srcdomains{$srcmaxkey} messages in queue FROM $srcmaxkey (threshold W = $opt_W)&quot;;
					$state = $ERRORS{&#039;WARNING&#039;};
				} elsif (($state == $ERRORS{&#039;WARNING&#039;}) || ($state == $ERRORS{&#039;CRITICAL&#039;})){
		    	$msg .= &quot; -and- $srcdomains{$srcmaxkey} messages in queue FROM $srcmaxkey (threshold W = $opt_W)&quot;;
				} else {
					$msg = &quot;WARNING: $srcdomains{$srcmaxkey} messages in queue FROM $srcmaxkey (threshold W = $opt_W)&quot;;
					$state = $ERRORS{&#039;WARNING&#039;};
				}
  	  } elsif ($srcdomains{$srcmaxkey} &gt;= $opt_C) {
				if ($state == $ERRORS{&#039;OK&#039;}) {
					$msg = &quot;CRITICAL: $srcdomains{$srcmaxkey} messages in queue FROM $srcmaxkey (threshold C = $opt_C)&quot;;
					$state = $ERRORS{&#039;CRITICAL&#039;};
				} elsif ($state == $ERRORS{&#039;WARNING&#039;}) {
					$msg = &quot;CRITICAL: $srcdomains{$srcmaxkey} messages in queue FROM $srcmaxkey (threshold C = $opt_C) -and- &quot; . $msg;
					$msg =~ s/WARNING: //;
				} elsif ($state == $ERRORS{&#039;CRITICAL&#039;}) {
					$msg .= &quot; -and- $srcdomains{$srcmaxkey} messages in queue FROM $srcmaxkey (threshold W = $opt_W)&quot;;
				} else {
					$msg = &quot;CRITICAL: $srcdomains{$srcmaxkey} messages in queue FROM $srcmaxkey (threshold W = $opt_W)&quot;;
					$state = $ERRORS{&#039;CRITICAL&#039;};
				}
	    } else {
				if ($srcdomains{$srcmaxkey} &gt; 0) {
					$msg .= &quot; $srcdomains{$srcmaxkey} msgs. FROM $srcmaxkey is below threshold ($opt_W/$opt_C)&quot;;
				}
			}

			# Apply threshold to queue lengths TO domain
			my @dstkeys = sort { $dstdomains{$b} &lt;=&gt; $dstdomains{$a} } keys %dstdomains;
	    my $dstmaxkey = $dstkeys[0];
  	  print &quot;dst max is $dstmaxkey with $dstdomains{$dstmaxkey} messages\n&quot; if $verbose;
		
			if ($dstdomains{$dstmaxkey} &gt;= $opt_W &amp;&amp; $dstdomains{$dstmaxkey} &lt; $opt_C) {
				if ($state == $ERRORS{&#039;OK&#039;}) {
					$msg = &quot;WARNING: $dstdomains{$dstmaxkey} messages in queue TO $dstmaxkey (threshold W = $opt_W)&quot;;
					$state = $ERRORS{&#039;WARNING&#039;};
				} elsif (($state == $ERRORS{&#039;WARNING&#039;}) || ($state == $ERRORS{&#039;CRITICAL&#039;})){
					$msg .= &quot; -and- $dstdomains{$dstmaxkey} messages in queue TO $dstmaxkey (threshold W = $opt_W)&quot;;
				} else {
					$msg = &quot;WARNING: $dstdomains{$dstmaxkey} messages in queue TO $dstmaxkey (threshold W = $opt_W)&quot;;
					$state = $ERRORS{&#039;WARNING&#039;};
				}
			} elsif ($dstdomains{$dstmaxkey} &gt;= $opt_C) {
				if ($state == $ERRORS{&#039;OK&#039;}) {
					$msg = &quot;CRITICAL: $dstdomains{$dstmaxkey} messages in queue TO $dstmaxkey (threshold C = $opt_C)&quot;;
					$state = $ERRORS{&#039;CRITICAL&#039;};
				} elsif ($state == $ERRORS{&#039;WARNING&#039;}) {
					$msg = &quot;CRITICAL: $dstdomains{$dstmaxkey} messages in queue TO $dstmaxkey (threshold C = $opt_C) -and- &quot; . $msg;
					$msg =~ s/WARNING: //;
				} elsif ($state == $ERRORS{&#039;CRITICAL&#039;}) {
					$msg .= &quot; -and- $dstdomains{$dstmaxkey} messages in queue TO $dstmaxkey (threshold W = $opt_W)&quot;;
				} else {
					$msg = &quot;CRITICAL: $dstdomains{$dstmaxkey} messages in queue TO $dstmaxkey (threshold W = $opt_W)&quot;;
					$state = $ERRORS{&#039;CRITICAL&#039;};
				}
			} else {
				if ($dstdomains{$dstmaxkey} &gt; 0) {
					$msg .= &quot; $dstdomains{$dstmaxkey} msgs. TO $dstmaxkey is below threshold ($opt_W/$opt_C)&quot;;
				}
			}

		} # End of queue length thresholds

	}

} # end of ($mailq eq &quot;sendmail&quot;)
elsif ( $mailq eq &quot;postfix&quot; ) {

     ## open mailq
	if ( defined $utils::PATH_TO_MAILQ ) {
		if (-x $utils::PATH_TO_MAILQ) {
			if (! open (MAILQ, &quot;$utils::PATH_TO_MAILQ$mailq_args 2&gt;&amp;1 | &quot;)) {
				print &quot;ERROR: $utils::PATH_TO_MAILQ$mailq_args returned an error\n&quot;;
				exit $ERRORS{&#039;UNKNOWN&#039;};
			}
		}
		else {
			if ( $sudo ne &quot;&quot; ) {
				if (! open (MAILQ, &quot;$sudo $utils::PATH_TO_MAILQ$mailq_args 2&gt;&amp;1 | &quot; ) ) {
					print &quot;ERROR: $utils::PATH_TO_MAILQ$mailq_args is not executable with sudo by (uid $&gt;:gid($)))\n&quot;;
					exit $ERRORS{&#039;UNKNOWN&#039;};
				}
			} else {
				print &quot;ERROR: $utils::PATH_TO_MAILQ$mailq_args is not executable by (uid $&gt;:gid($))) and sudo is not set in utils.pm\n&quot;;
				exit $ERRORS{&#039;UNKNOWN&#039;};
			}
		}
	} else {
		print &quot;ERROR: \$utils::PATH_TO_MAILQ is not defined in utils.pm\n&quot;;
		exit $ERRORS{&#039;UNKNOWN&#039;};
	}


	@lines = reverse &lt;MAILQ&gt;;
	
	close(MAILQ);

        if ( $? ) {
		print &quot;CRITICAL: Error code &quot;.($?&gt;&gt;8).&quot; returned from $utils::PATH_TO_MAILQ$mailq_args&quot;,$/;
		exit $ERRORS{CRITICAL};
        }

        ## shut off the alarm
        alarm(0);

        # check queue length
        if ($lines[0]=~/Kbytes in (\d+)/) {
                $msg_q = $1 ;
	}elsif ($lines[0]=~/Mail queue is empty/) {
		$msg_q = 0;
        }else{
                print &quot;Couldn&#039;t match $utils::PATH_TO_MAILQ$mailq_args output\n&quot;;
                exit   $ERRORS{&#039;UNKNOWN&#039;};
        }

        # check messages not processed
        #if ($lines[1]=~/^messages in queue but not yet preprocessed: (\d+)/) {
        #        my $msg_p = $1;
        #}else{
        #        print &quot;Couldn&#039;t match $utils::PATH_TO_MAILQ output\n&quot;;
        #        exit  $ERRORS{&#039;UNKNOWN&#039;};
        #}

        # check queue length(s)
        if ($msg_q == 0){
                $msg = &quot;OK: $mailq mailq reports queue is empty&quot;;
                $state = $ERRORS{&#039;OK&#039;};
        } else {
                print &quot;msg_q = $msg_q warn=$opt_w crit=$opt_c\n&quot; if $verbose;

                # overall queue length
                if ($msg_q &lt; $opt_w) {
                        $msg = &quot;OK: $mailq mailq ($msg_q) is below threshold ($opt_w/$opt_c)&quot;;
                        $state = $ERRORS{&#039;OK&#039;};
                }elsif  ($msg_q &gt;= $opt_w  &amp;&amp; $msg_q &lt; $opt_c) {
                        $msg = &quot;WARNING: $mailq mailq is $msg_q (threshold w = $opt_w)&quot;;
                        $state = $ERRORS{&#039;WARNING&#039;};
                }else {
                        $msg = &quot;CRITICAL: $mailq mailq is $msg_q (threshold c = $opt_c)&quot;;
                        $state = $ERRORS{&#039;CRITICAL&#039;};
                }

                # check messages not yet preprocessed (only compare is $opt_W and $opt_C
                # are defined)

                #if (defined $opt_W) {
                #        $msg .= &quot;[Preprocessed = $msg_p]&quot;;
                #        if ($msg_p &gt;= $opt_W &amp;&amp; $msg_p &lt; $opt_C ) {
                #                $state = $state == $ERRORS{&quot;CRITICAL&quot;} ? $ERRORS{&quot;CRITICAL&quot;} : $ERRORS{&quot;WARNING&quot;}  ;
                #        }elsif ($msg_p &gt;= $opt_C ) {
                #                $state = $ERRORS{&quot;CRITICAL&quot;} ;
                #        }
                #}
        }
} # end of ($mailq eq &quot;postfix&quot;)
elsif ( $mailq eq &quot;qmail&quot; ) {

	# open qmail-qstat 
	if ( defined $utils::PATH_TO_QMAIL_QSTAT &amp;&amp; -x $utils::PATH_TO_QMAIL_QSTAT ) {
		if (! open (MAILQ, &quot;$sudo $utils::PATH_TO_QMAIL_QSTAT | &quot; ) ) {
			print &quot;ERROR: could not open $utils::PATH_TO_QMAIL_QSTAT \n&quot;;
			exit $ERRORS{&#039;UNKNOWN&#039;};
		}
	}elsif( defined $utils::PATH_TO_QMAIL_QSTAT){
		unless (-x $utils::PATH_TO_QMAIL_QSTAT) {
			print &quot;ERROR: $utils::PATH_TO_QMAIL_QSTAT is not executable by (uid $&gt;:gid($)))\n&quot;;
			exit $ERRORS{&#039;UNKNOWN&#039;};
		}
	} else {
		print &quot;ERROR: \$utils::PATH_TO_QMAIL_QSTAT is not defined\n&quot;;
		exit $ERRORS{&#039;UNKNOWN&#039;};
	}

	@lines = &lt;MAILQ&gt;;

	# close qmail-qstat
	close MAILQ;

	if ( $? ) {
		print &quot;CRITICAL: Error code &quot;.($?&gt;&gt;8).&quot; returned from $utils::PATH_TO_MAILQ&quot;,$/;
		exit $ERRORS{CRITICAL};
	}

	## shut off the alarm
	alarm(0);

	# check queue length
	if ($lines[0]=~/^messages in queue: (\d+)/) {
		$msg_q = $1 ;
	}else{
		print &quot;Couldn&#039;t match $utils::PATH_TO_QMAIL_QSTAT output\n&quot;;
		exit   $ERRORS{&#039;UNKNOWN&#039;};
	}

	# check messages not processed
	if ($lines[1]=~/^messages in queue but not yet preprocessed: (\d+)/) {
		my $msg_p = $1;
	}else{
		print &quot;Couldn&#039;t match $utils::PATH_TO_QMAIL_QSTAT output\n&quot;;
		exit  $ERRORS{&#039;UNKNOWN&#039;};
	}


	# check queue length(s)
	if ($msg_q == 0){
		$msg = &quot;OK: qmail-qstat reports queue is empty&quot;;
		$state = $ERRORS{&#039;OK&#039;};
	} else {
		print &quot;msg_q = $msg_q warn=$opt_w crit=$opt_c\n&quot; if $verbose;
		
		# overall queue length
		if ($msg_q &lt; $opt_w) {
			$msg = &quot;OK: $mailq mailq ($msg_q) is below threshold ($opt_w/$opt_c)&quot;;
			$state = $ERRORS{&#039;OK&#039;};
		}elsif ($msg_q &gt;= $opt_w  &amp;&amp; $msg_q &lt; $opt_c) {
			$msg = &quot;WARNING: $mailq mailq is $msg_q (threshold w = $opt_w)&quot;;
			$state = $ERRORS{&#039;WARNING&#039;};
		}else {
			$msg = &quot;CRITICAL: $mailq mailq is $msg_q (threshold c = $opt_c)&quot;;
			$state = $ERRORS{&#039;CRITICAL&#039;};
		}

		# check messages not yet preprocessed (only compare is $opt_W and $opt_C
		# are defined)
		
		if (defined $opt_W) {
			$msg .= &quot;[Preprocessed = $msg_p]&quot;;
			if ($msg_p &gt;= $opt_W &amp;&amp; $msg_p &lt; $opt_C ) {
				$state = $state == $ERRORS{&quot;CRITICAL&quot;} ? $ERRORS{&quot;CRITICAL&quot;} : $ERRORS{&quot;WARNING&quot;}  ;
			}elsif ($msg_p &gt;= $opt_C ) {
				$state = $ERRORS{&quot;CRITICAL&quot;} ;
			}
		}
	}				
		

} # end of ($mailq eq &quot;qmail&quot;)
elsif ( $mailq eq &quot;exim&quot; ) {
	## open mailq 
	if ( defined $utils::PATH_TO_MAILQ &amp;&amp; -x $utils::PATH_TO_MAILQ ) {
		if (! open (MAILQ, &quot;$sudo $utils::PATH_TO_MAILQ | &quot; ) ) {
			print &quot;ERROR: could not open $utils::PATH_TO_MAILQ \n&quot;;
			exit $ERRORS{&#039;UNKNOWN&#039;};
		}
	}elsif( defined $utils::PATH_TO_MAILQ){
		unless (-x $utils::PATH_TO_MAILQ) {
			print &quot;ERROR: $utils::PATH_TO_MAILQ is not executable by (uid $&gt;:gid($)))\n&quot;;
			exit $ERRORS{&#039;UNKNOWN&#039;};
		}
	} else {
		print &quot;ERROR: \$utils::PATH_TO_MAILQ is not defined\n&quot;;
		exit $ERRORS{&#039;UNKNOWN&#039;};
	}

	while (&lt;MAILQ&gt;) {
	    #22m  1.7K 19aEEr-0007hx-Dy &lt;&gt; *** frozen ***
            #root@exlixams.glups.fr

	    if (/\s[\w\d]{6}-[\w\d]{6}-[\w\d]{2}\s/) { # message id 19aEEr-0007hx-Dy
		$msg_q++ ;
	    }
	}
	close(MAILQ) ;

	if ( $? ) {
		print &quot;CRITICAL: Error code &quot;.($?&gt;&gt;8).&quot; returned from $utils::PATH_TO_MAILQ&quot;,$/;
		exit $ERRORS{CRITICAL};
	}
	if ($msg_q &lt; $opt_w) {
		$msg = &quot;OK: $mailq mailq ($msg_q) is below threshold ($opt_w/$opt_c)&quot;;
		$state = $ERRORS{&#039;OK&#039;};
	}elsif ($msg_q &gt;= $opt_w  &amp;&amp; $msg_q &lt; $opt_c) {
		$msg = &quot;WARNING: $mailq mailq is $msg_q (threshold w = $opt_w)&quot;;
		$state = $ERRORS{&#039;WARNING&#039;};
	}else {
		$msg = &quot;CRITICAL: $mailq mailq is $msg_q (threshold c = $opt_c)&quot;;
		$state = $ERRORS{&#039;CRITICAL&#039;};
	}
} # end of ($mailq eq &quot;exim&quot;)
elsif ( $mailq eq &quot;opensmtpd&quot; ) {
	## open smtpctl
	if ( defined $utils::PATH_TO_SMTPCTL &amp;&amp; -x $utils::PATH_TO_SMTPCTL ) {
		if (! open (MAILQ, &quot;$sudo $utils::PATH_TO_SMTPCTL show queue | &quot; ) ) {
			print &quot;ERROR: could not open $utils::PATH_TO_SMTPCTL \n&quot;;
			exit $ERRORS{&#039;UNKNOWN&#039;};
		}
	}elsif( defined $utils::PATH_TO_SMTPCTL){
		unless (-x $utils::PATH_TO_SMTPCTL) {
			print &quot;ERROR: $utils::PATH_TO_SMTPCTL is not executable by (uid $&gt;:gid($)))\n&quot;;
			exit $ERRORS{&#039;UNKNOWN&#039;};
		}
	} else {
		print &quot;ERROR: \$utils::PATH_TO_SMTPCTL is not defined\n&quot;;
		exit $ERRORS{&#039;UNKNOWN&#039;};
	}

	while (&lt;MAILQ&gt;) {

		# 34357f5b3f589feb|inet4|mta||f.someone@domaina.org|no-reply@domainb.com|no-reply@domainb.com|1498235412|1498581012|0|25|pending|17168|Network error on destination MXs
		if (/^.*|.*|.*|.*|.*|.*|.*|.*|.*|.*|.*|.*|.*|.*$/) {
			$msg_q++ ;
		}
	}
	close(MAILQ);

	if ( $? ) {
		print &quot;CRITICAL: Error code &quot;.($?&gt;&gt;8).&quot; returned from $utils::PATH_TO_SMTPCTL&quot;,$/;
		exit $ERRORS{CRITICAL};
	}
	if ($msg_q &lt; $opt_w) {
		$msg = &quot;OK: $mailq mailq ($msg_q) is below threshold ($opt_w/$opt_c)&quot;;
		$state = $ERRORS{&#039;OK&#039;};
	}elsif ($msg_q &gt;= $opt_w  &amp;&amp; $msg_q &lt; $opt_c) {
		$msg = &quot;WARNING: $mailq mailq is $msg_q (threshold w = $opt_w)&quot;;
		$state = $ERRORS{&#039;WARNING&#039;};
	}else {
		$msg = &quot;CRITICAL: $mailq mailq is $msg_q (threshold c = $opt_c)&quot;;
		$state = $ERRORS{&#039;CRITICAL&#039;};
	}
} # end of ($mailq eq &quot;opensmtpd&quot;)
elsif ( $mailq eq &quot;nullmailer&quot; ) {
	## open mailq
	if ( defined $utils::PATH_TO_MAILQ &amp;&amp; -x $utils::PATH_TO_MAILQ ) {
		if (! open (MAILQ, &quot;$sudo $utils::PATH_TO_MAILQ | &quot; ) ) {
			print &quot;ERROR: could not open $utils::PATH_TO_MAILQ \n&quot;;
			exit $ERRORS{&#039;UNKNOWN&#039;};
		}
	}elsif( defined $utils::PATH_TO_MAILQ){
		unless (-x $utils::PATH_TO_MAILQ) {
			print &quot;ERROR: $utils::PATH_TO_MAILQ is not executable by (uid $&gt;:gid($)))\n&quot;;
			exit $ERRORS{&#039;UNKNOWN&#039;};
		}
	} else {
		print &quot;ERROR: \$utils::PATH_TO_MAILQ is not defined\n&quot;;
		exit $ERRORS{&#039;UNKNOWN&#039;};
	}

	while (&lt;MAILQ&gt;) {
	    #2006-06-22 16:00:00  282 bytes

	    if (/^[1-9][0-9]*-[01][0-9]-[0-3][0-9]\s[0-2][0-9]\:[0-5][0-9]\:[0-5][0-9]\s{1,2}[0-9]+\sbytes$/) {
		$msg_q++ ;
	    }
	}
	close(MAILQ) ;
	if ($msg_q &lt; $opt_w) {
		$msg = &quot;OK: $mailq mailq ($msg_q) is below threshold ($opt_w/$opt_c)&quot;;
		$state = $ERRORS{&#039;OK&#039;};
	}elsif ($msg_q &gt;= $opt_w  &amp;&amp; $msg_q &lt; $opt_c) {
		$msg = &quot;WARNING: $mailq mailq is $msg_q (threshold w = $opt_w)&quot;;
		$state = $ERRORS{&#039;WARNING&#039;};
	}else {
		$msg = &quot;CRITICAL: $mailq mailq is $msg_q (threshold c = $opt_c)&quot;;
		$state = $ERRORS{&#039;CRITICAL&#039;};
	}
} # end of ($mailq eq &quot;nullmailer&quot;)

elsif ( $mailq eq &quot;opensmtp&quot; ) {
	## open mailq
	if ( defined $utils::PATH_TO_MAILQ &amp;&amp; -x $utils::PATH_TO_MAILQ ) {
		if (! open (MAILQ, &quot;$sudo $utils::PATH_TO_MAILQ | &quot; ) ) {
			print &quot;ERROR: could not open $utils::PATH_TO_MAILQ \n&quot;;
			exit $ERRORS{&#039;UNKNOWN&#039;};
		}
	}elsif( defined $utils::PATH_TO_MAILQ){
		unless (-x $utils::PATH_TO_MAILQ) {
			print &quot;ERROR: $utils::PATH_TO_MAILQ is not executable by (uid $&gt;:gid($)))\n&quot;;
			exit $ERRORS{&#039;UNKNOWN&#039;};
		}
	} else {
		print &quot;ERROR: \$utils::PATH_TO_MAILQ is not defined\n&quot;;
		exit $ERRORS{&#039;UNKNOWN&#039;};
	}

	$msg_q++ while (&lt;MAILQ&gt;);

	close(MAILQ) ;
	if ($msg_q &lt; $opt_w) {
		$msg = &quot;OK: $mailq mailq ($msg_q) is below threshold ($opt_w/$opt_c)&quot;;
		$state = $ERRORS{&#039;OK&#039;};
	}elsif ($msg_q &gt;= $opt_w  &amp;&amp; $msg_q &lt; $opt_c) {
		$msg = &quot;WARNING: $mailq mailq is $msg_q (threshold w = $opt_w)&quot;;
		$state = $ERRORS{&#039;WARNING&#039;};
	}else {
		$msg = &quot;CRITICAL: $mailq mailq is $msg_q (threshold c = $opt_c)&quot;;
		$state = $ERRORS{&#039;CRITICAL&#039;};
	}
} # end of ($mailq eq &quot;opensmtp&quot;)


# Perfdata support
print &quot;$msg|unsent=$msg_q;$opt_w;$opt_c;0\n&quot;;
exit $state;


#####################################
#### subs


sub process_arguments(){
	GetOptions
		(&quot;V&quot;   =&gt; \$opt_V, &quot;version&quot;	=&gt; \$opt_V,
		 &quot;v&quot;   =&gt; \$opt_v, &quot;verbose&quot;	=&gt; \$opt_v,
		 &quot;h&quot;   =&gt; \$opt_h, &quot;help&quot;		=&gt; \$opt_h,
		 &quot;M:s&quot; =&gt; \$opt_M, &quot;mailserver:s&quot; =&gt; \$opt_M, # mailserver (default	sendmail)
		 &quot;w=i&quot; =&gt; \$opt_w, &quot;warning=i&quot;  =&gt; \$opt_w,   # warning if above this number
		 &quot;c=i&quot; =&gt; \$opt_c, &quot;critical=i&quot; =&gt; \$opt_c,	  # critical if above this number
		 &quot;t=i&quot; =&gt; \$opt_t, &quot;timeout=i&quot;  =&gt; \$opt_t,
		 &quot;s&quot;   =&gt; \$opt_s, &quot;sudo&quot;       =&gt; \$opt_s,
		 &quot;d:s&quot; =&gt; \$opt_d, &quot;configdir:s&quot; =&gt; \$opt_d
		 );

	if ($opt_V) {
		print_revision($PROGNAME,&#039;2.4.9&#039;);
		exit $ERRORS{&#039;OK&#039;};
	}

	if ($opt_h) {
		print_help();
		exit $ERRORS{&#039;OK&#039;};
	}

	if (defined $opt_v ){
		$verbose = $opt_v;
	}

	unless (defined $opt_t) {
		$opt_t = $utils::TIMEOUT ;	# default timeout
	}

	unless (  defined $opt_w &amp;&amp;  defined $opt_c ) {
		print_usage();
		exit $ERRORS{&#039;UNKNOWN&#039;};
	}

	if ( $opt_w &gt;= $opt_c) {
		print &quot;Warning (-w) cannot be greater than Critical (-c)!\n&quot;;
		exit $ERRORS{&#039;UNKNOWN&#039;};
	}

	if (defined $opt_W &amp;&amp; ! defined !$opt_C) {
		print &quot;Need -C if using -W\n&quot;;
		exit $ERRORS{&#039;UNKNOWN&#039;};
	}elsif(defined $opt_W &amp;&amp; defined $opt_C) {
		if ($opt_W &gt;= $opt_C) {
			print &quot;Warning (-W) cannot be greater than Critical (-C)!\n&quot;;
			exit $ERRORS{&#039;UNKNOWN&#039;};
		}
	}

	if (defined $opt_M) {
		if ($opt_M =~ /^(sendmail|qmail|postfix|exim|nullmailer|opensmtpd)$/) {
			$mailq = $opt_M ;
		}elsif( $opt_M eq &#039;&#039;){
			$mailq = &#039;sendmail&#039;;
		}else{
			print &quot;-M: $opt_M is not supported\n&quot;;
			exit $ERRORS{&#039;UNKNOWN&#039;};
		}
	}else{
		if (defined $utils::PATH_TO_QMAIL_QSTAT
		    &amp;&amp; -x $utils::PATH_TO_QMAIL_QSTAT)
		{
			$mailq = &#039;qmail&#039;;
		}
		elsif (-d &#039;/var/lib/postfix&#039; || -d &#039;/var/local/lib/postfix&#039;
		       || -e &#039;/usr/sbin/postfix&#039; || -e &#039;/usr/local/sbin/postfix&#039;)
		{
			$mailq = &#039;postfix&#039;;
		}
		elsif (-d &#039;/usr/lib/exim4&#039; || -d &#039;/usr/local/lib/exim4&#039;
		       || -e &#039;/usr/sbin/exim&#039; || -e &#039;/usr/local/sbin/exim&#039;)
		{
			$mailq = &#039;exim&#039;;
		}
		elsif (-d &#039;/usr/lib/nullmailer&#039; || -d &#039;/usr/local/lib/nullmailer&#039;
		       || -e &#039;/usr/sbin/nullmailer-send&#039;
		       || -e &#039;/usr/local/sbin/nullmailer-send&#039;)
		{
			$mailq = &#039;nullmailer&#039;;
		}
		elsif (defined $utils::PATH_TO_SMTPCTL &amp;&amp; -x $utils::PATH_TO_SMTPCTL)
		{
			$mailq = &#039;opensmtpd&#039;;
		}
		else {
			$mailq = &#039;sendmail&#039;;
		}
	}
		
	return $ERRORS{&#039;OK&#039;};
}

sub print_usage () {
	print &quot;Usage: $PROGNAME -w &lt;warn&gt; -c &lt;crit&gt; [-W &lt;warn&gt;] [-C &lt;crit&gt;] [-M &lt;MTA&gt;] [-t &lt;timeout&gt;] [-s] [-d &lt;CONFIGDIR&gt;] [-v]\n&quot;;
}

sub print_help () {
	print_revision($PROGNAME,&#039;2.4.9&#039;);
	print &quot;Copyright (c) 2002 Subhendu Ghosh/Carlos Canau/Benjamin Schmid\n&quot;;
	print &quot;\n&quot;;
	print_usage();
	print &quot;\n&quot;;
	print &quot;   Checks the number of messages in the mail queue (supports multiple sendmail queues, qmail)\n&quot;;
	print &quot;   Feedback/patches to support non-sendmail mailqueue welcome\n\n&quot;;
	print &quot;-w (--warning)   = Min. number of messages in queue to generate warning\n&quot;;
	print &quot;-c (--critical)  = Min. number of messages in queue to generate critical alert ( w &lt; c )\n&quot;;
	print &quot;-W (--Warning)   = Min. number of messages for same domain in queue to generate warning\n&quot;;
	print &quot;-C (--Critical)  = Min. number of messages for same domain in queue to generate critical alert ( W &lt; C )\n&quot;;
	print &quot;-t (--timeout)   = Plugin timeout in seconds (default = $utils::TIMEOUT)\n&quot;;
	print &quot;-M (--mailserver) = [ sendmail | qmail | postfix | exim | nullmailer | opensmtpd ] (default = autodetect)\n&quot;;
	print &quot;-h (--help)\n&quot;;
	print &quot;-V (--version)\n&quot;;
	print &quot;-v (--verbose)   = debugging output\n&quot;;
	print &quot;\n\n&quot;;
	print &quot;Note: -w and -c are required arguments.  -W and -C are optional.\n&quot;;
	print &quot; -W and -C are applied to domains listed on the queues - both FROM and TO. (sendmail)\n&quot;;
	print &quot; -W and -C are applied message not yet preproccessed. (qmail)\n&quot;;
	print &quot; This plugin tries to autodetect which mailserver you are running,\n&quot;;
	print &quot; you can override the autodetection with -M.\n&quot;;
	print &quot; This plugin uses the system mailq command (sendmail) or qmail-stat (qmail)\n&quot;;
	print &quot; to look at the queues. Mailq can usually only be accessed by root or \n&quot;;
	print &quot; a TrustedUser. You will have to set appropriate permissions for the plugin to work.\n&quot;;
	print &quot;&quot;;
	print &quot;\n\n&quot;;
	support();
}
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/lib64/nagios/plugins/check_mailq'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Fusr%2Flib64%2Fnagios%2Fplugins' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>