Subversion Repositories vnag

<?php

/*

      VNag - Nagios Framework for PHP                  (C) 2014-2023

      __     ___      _____ _     _       _     ____         __ _

      \ \   / (_) __ |_   _| |__ (_)_ __ | | __/ ___|  ___  / _| |_

       \ \ / /| |/ _` || | | '_ \| | '_ \| |/ /\___ \ / _ \| |_| __|

        \ V / | | (_| || | | | | | | | | |   <  ___) | (_) |  _| |_

         \_/  |_|\__,_||_| |_| |_|_|_| |_|_|\_\|____/ \___/|_|  \__|

      Developed by Daniel Marschall             www.viathinksoft.com

      Licensed under the terms of the Apache 2.0 license

      Revision 2023-10-13

*/

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

Introduction:

        VNag is a small framework for Nagios Plugin Developers who use PHP CLI scripts.

        The main purpose of VNag is to make the development of plugins as easy as possible, so that

        the developer can concentrate on the actual work. VNag will try to automate as much

        as possible.

        Please note that your script should include the +x chmod flag:

                chmod +x myscript.php

        Please see the the demo/ folder for a few examples how to use this framework.

Arguments:

        Example:

                $this->addExpectedArgument($argSilent = new VNagArgument('s', 'silent', VNagArgument::VALUE_FORBIDDEN, null,       'Description for the --silent output', $defaultValue));

                $this->addExpectedArgument($argHost   = new VNagArgument('H', 'host',   VNagArgument::VALUE_REQUIRED,  'hostname', 'Description for the --host output',   $defaultValue));

        In the example above, the two argument objects $argSilent and $argHost were created.

        With these objects of the type VNagArgument, you can query the argument's value,

        how often the argument was passed and if it is set:

                $argSilent->count();      // 1 if "-s" is passed, 2 if "-s -s" is passed etc.

                $argSilent->available();  // true if "-s" is passed, false otherwise

                $argHost->getValue();     // "example.com" if "-h example.com" is passed

        It is recommended that you pass every argument to $this->addExpectedArgument() .

        Using this way, VNag can generate a --help page for you, which lists all your arguments.

        Future version of VNag may also require to have a complete list of all valid arguments,

        since the Nagios Development Guidelines recommend to output the usage information if an illegal

        argument is passed. Due to PHP's horrible bad implementation of GNU's getopt(), this check for

        unknown arguments is currently not possible, and the developer of VNag does not want to use

        dirty hacks/workarounds, which would not match to all argument notation variations/styles.

        See: https://bugs.php.net/bug.php?id=68806

             https://bugs.php.net/bug.php?id=65673

             https://bugs.php.net/bug.php?id=26818

Setting the status:

        You can set the status with:

                $this->setStatus(VNag::STATUS_OK);

        If you don't set a status, the script will return Unknown instead.

        setStatus($status) will keep the most severe status, e.g.

                $this->setStatus(VNag::STATUS_CRITICAL);

                $this->setStatus(VNag::STATUS_OK);

        will result in a status "Critical".

        If you want to completely overwrite the status, use $force=true:

                $this->setStatus(VNag::STATUS_CRITICAL);

                $this->setStatus(VNag::STATUS_OK, true);

        The status will now be "OK".

        Possible status codes are:

                (For service plugins:)

                VNag::STATUS_OK       = 0;

                VNag::STATUS_WARNING  = 1;

                VNag::STATUS_CRITICAL = 2;

                VNag::STATUS_UNKNOWN  = 3;

                (For host plugins:)

                VNag::STATUS_UP       = 0;

                VNag::STATUS_DOWN     = 1;

Output:

        After the callback function cbRun() of your job has finished,

        the framework will automatically output the results in the Nagios console output format,

        the visual HTML output and/or the invisible HTML output.

        In case of CLI invokation, the Shell exit code will be remembered and

        automatically returned by the shutdown handler once the script normally

        terminates. (In case you run different jobs, which is not recommended, the

        shutdown handler will output the baddest exit code).

        The Shell output format will be:

                <Service status text>: <Comma separates messages> | <whitespace separated primary performance data>

                "Verbose information:"

                <Multiline verbose output> | <Multiline secondary performance data>

        <Service status text> will be automatically created by VNag.

        Verbose information are printed below the first line. Most Nagios clients will only print the first line.

        If you have important output, use $this->setHeadline() instead.

        You can add verbose information with following method:

                $this->addVerboseMessage('foobar', $verbosity);

        Following verbosity levels are defined:

                VNag::VERBOSITY_SUMMARY                = 0; // always printed

                VNag::VERBOSITY_ADDITIONAL_INFORMATION = 1; // requires at least -v

                VNag::VERBOSITY_CONFIGURATION_DEBUG    = 2; // requiers at least -vv

                VNag::VERBOSITY_PLUGIN_DEBUG           = 3; // requiers at least -vvv

        All STDOUT outputs of your script (e.g. by echo) will be interpreted as "verbose" output

        and is automatically collected, so

                echo "foobar";

        has the same functionality as

                $this->addVerboseMessage('foobar', VNag::VERBOSITY_SUMMARY);

        You can set messages (which will be added into the first line, which is preferred for plugin outputs)

        using

                $this->setHeadline($msg, $append, $verbosity);

        Using the flag $append, you can choose if you want to append or replace the message.

        VNag will catch Exceptions of your script and will automatically end the plugin,

        returning a valid Nagios output.

Automatic handling of basic arguments:

        VNag will automatic handle of following CLI arguments:

                -?

                -V --version

                -h --help

                -v --verbose

                -t --timeout   (only works if you set declare(ticks=1) at the beginning of each of your scripts)

                -w --warning

                -c --critical

        You can performe range checking by using:

                $example_value = '10MB';

                $this->checkAgainstWarningRange($example_value);

        this is more or less the same as:

                $example_value = '10MB';

                $wr = $this->getWarningRange();

                if (isset($wr) && $wr->checkAlert($example_value)) {

                        $this->setStatus(VNag::STATUS_WARNING);

                }

        In case that your script allows ranges which can be relative and absolute, you can provide multiple arguments;

        $wr->checkAlert() will be true, as soon as one of the arguments is in the warning range.

        The check will be done in this way:

                $example_values = array('10MB', '5%');

                $this->checkAgainstWarningRange($example_values);

        this is more or less the same as:

                $example_values = array('10MB', '5%');

                $wr = $this->getWarningRange();

                if (isset($wr) && $wr->checkAlert($example_values)) {

                        $this->setStatus(VNag::STATUS_WARNING);

                }

        Note that VNag will automatically detect the UOM (Unit of Measurement) and is also able to convert them,

        e.g. if you use the range "-w 20MB:40MB", your script will be able to use $wr->checkAlert('3000KB')

        Please note that only following UOMs are accepted (as defined in the Plugin Development Guidelines):

        - no unit specified: assume a number (int or float) of things (eg, users, processes, load averages)

        - s, ms, us: seconds

        - %: percentage

        - B, KB, MB, TB: bytes  // NOTE: GB is not in the official development guidelines,probably due to an error, so I've added them anyway

        - c: a continous counter (such as bytes transmitted on an interface)

Multiple warning/critical ranges:

        The arguments -w and -c can have many different values, separated by comma.

        We can see this feature e.g. with the official plugin /usr/lib/nagios/plugins/check_ping:

        It has following syntax for the arguments -w and -c: <latency>,<packetloss>%

        When you are using checkAgainstWarningRange, you can set the fourth argument to the range number

        you would like to check (beginning with 0).

        Example:

                // -w 1MB:5MB,5%:10%

                $this->checkAgainstWarningRange('4MB', true, true, 0); // check value 4MB against range "1MB:5MB" (no warning)

                $this->checkAgainstWarningRange('15%', true, true, 1); // check value 15% gainst range "5%:10%" (gives warning)

Visual HTTP output:

        Can be enabled/disabled with $this->http_visual_output

        Valid values:

        VNag::OUTPUT_SPECIAL   = 1; // illegal usage / help page, version page

        VNag::OUTPUT_NORMAL    = 2;

        VNag::OUTPUT_EXCEPTION = 4;

        VNag::OUTPUT_ALWAYS    = 7;

        VNag::OUTPUT_NEVER     = 0;

Encryption and Decryption:

        In case you are emitting machine-readable code in your HTTP output

        (can be enabled/disabled by $this->http_invisible_output),

        you can encrypt the machine-readable part of your HTTP output by

        setting $this->password_out . If you want to read the information,

        you need to set $this->password_in at the web-reader plugin.

        The visual output is not encrypted. So, if you want to hide the information,

        then you must not enable visual HTML output.

        If you don't want to encrypt the machine-readable output,

        please set $this->password_out to null or empty string.

        Attention!

        - Encryption and decryption require the OpenSSL extension in PHP.

Digital signature:

        You can sign the output by setting $this->privkey with a filename containing

        a private key created by OpenSSL. If it is encrypted, please also set

        $this->privkey_password .

        To check the signature, set $this->pubkey at your web-reader plugin with

        the filename of the public key file.

        Attention!

        - Signatures require the OpenSSL extension in PHP.

Performance data:

        You can add performance data using

                $this->addPerformanceData(new VNagPerformanceData($label, $value, $warn, $crit, $min, $max));

        or by the alternative constructor

                $this->addPerformanceData(VNagPerformanceData::createByString("'XYZ'=100;120;130;0;500"));

        $value may contain an UOM, e.g. "10MB". All other parameters may not contain an UOM.

Guidelines:

        This framework currently supports meets following guidelines:

        - https://nagios-plugins.org/doc/guidelines.html#PLUGOUTPUT (Plugin Output for Nagios)

        - https://nagios-plugins.org/doc/guidelines.html#AEN33 (Print only one line of text)

        - https://nagios-plugins.org/doc/guidelines.html#AEN41 (Verbose output)

        - https://nagios-plugins.org/doc/guidelines.html#AEN78 (Plugin Return Codes)

        - https://nagios-plugins.org/doc/guidelines.html#THRESHOLDFORMAT (Threshold and ranges)

        - https://nagios-plugins.org/doc/guidelines.html#AEN200 (Performance data)

        - https://nagios-plugins.org/doc/guidelines.html#PLUGOPTIONS (Plugin Options)

        - https://nagios-plugins.org/doc/guidelines.html#AEN302 (Option Processing)

          Note: The screen output of the help page will (mostly) be limited to 80 characters width; but the max recommended length of 23 lines cannot be guaranteed.

        This framework does currently NOT support following guidelines:

        - https://nagios-plugins.org/doc/guidelines.html#AEN74 (Screen Output)

        - https://nagios-plugins.org/doc/guidelines.html#AEN239 (Translations)

        - https://nagios-plugins.org/doc/guidelines.html#AEN293 (Use DEFAULT_SOCKET_TIMEOUT)

        - https://nagios-plugins.org/doc/guidelines.html#AEN296 (Add alarms to network plugins)

        - https://nagios-plugins.org/doc/guidelines.html#AEN245 (Don't execute system commands without specifying their full path)

        - https://nagios-plugins.org/doc/guidelines.html#AEN249 (Use spopen() if external commands must be executed)

        - https://nagios-plugins.org/doc/guidelines.html#AEN253 (Don't make temp files unless absolutely required)

        - https://nagios-plugins.org/doc/guidelines.html#AEN259 (Validate all input)

        - https://nagios-plugins.org/doc/guidelines.html#AEN317 (Plugins with more than one type of threshold, or with threshold ranges)

        We will intentionally NOT follow the following guidelines:

        - https://nagios-plugins.org/doc/guidelines.html#AEN256 (Don't be tricked into following symlinks)

          Reason: We believe that this guideline is contraproductive.

                  Nagios plugins usually run as user 'nagios'. It is the task of the system administrator

                  to ensure that the user 'nagios' must not read/write to files which are not intended

                  for access by the Nagios service. Symlinks, on the other hand, are useful for several tasks.

                  See also https://stackoverflow.com/questions/27112949/nagios-plugins-why-not-following-symlinks

VNag over HTTP:

        A script that uses the VNag framework can run as CLI script (normal Nagios plugin) or as web site (or both).

        Having the script run as website, you can include a Nagios information combined with a human friendly HTML output which can

        include colors, graphics (like charts) etc.

        For example:

        A script that measures traffic can have a website which shows graphs,

        and has a hidden Nagios output included, which can be read by a Nagios plugin that

        converts the hidden information on that website into an output that Nagios can evaluate.

        Here is a comparison of the usage and behavior of VNag in regards to CLI and HTTP calls:

        ------------------------------------------------------------------------------------------

          CLI script                                 HTTP script

        ------------------------------------------------------------------------------------------

        * "echo" will be discarded.                  * "echo" output will be discarded.

        * Exceptions will be handled.                * Exceptions will be handled.

        * outputHTML() will be ignored.              * outputHTML() will be handled.

          (This allows you to have the same script

          running as CLI and HTML)

        * Arguments are passed via CLI.              * Arguments are passed via $_REQUEST

                                                       (i.e. GET or POST)

        * Arguments: "-vvv"                          * Arguments: GET ?v[]=&v[]=&v[]= or POST

        * When run() has finished, the program       * When run() has finished, the program

          flow continues, although it is not           flow continues.

          recommended that you do anything after it.

          (The exit code is remembered for the

           shutdown handler)

        * Exactly 1 job must be called, resulting     * You can call as many jobs as you want.

          in a single output of that job.               A website can include more than one

                                                        Nagios output which are enumerated with

                                                        a serial number (0,1,2,3,...) or manual ID.

        ------------------------------------------------------------------------------------------

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

if (!VNag::is_http_mode()) error_reporting(E_ALL);

# If you want to use -t/--timeout with your module, you must add following line in your module code:

// WONTFIX: declare(ticks=1) is deprecated? http://www.hackingwithphp.com/4/21/0/the-declare-function-and-ticks

// WONTFIX: check is the main script used declare(ticks=1). (Not possible in PHP)

declare(ticks=1);

# Attention: The -t/--timeout parameter does not respect the built-in set_time_limit() of PHP.

# PHP should set this time limit to infinite.

set_time_limit(0);

define('VNAG_JSONDATA_V1', 'oid:1.3.6.1.4.1.37476.2.3.1.1'); // {iso(1) identified-organization(3) dod(6) internet(1) private(4) enterprise(1) 37476 products(2) vnag(3) jsondata(1) v1(1)}

// Set this to an array to overwrite getopt() and $_REQUEST[], respectively.

// Useful for mock tests.

$OVERWRITE_ARGUMENTS = null;

function _empty($x) {

        // Returns true for '' or null. Does not return true for value 0 or '0' (like empty() does)

        return is_null($x) || (trim($x) == '');

}

abstract class VNag {

        /*public*/ const VNAG_VERSION = '2023-10-13';

        // Status 0..3 for STATUSMODEL_SERVICE (the default status model):

        # The guideline states: "Higher-level errors (such as name resolution errors, socket timeouts, etc) are outside of the control of plugins and should generally NOT be reported as UNKNOWN states."

        # We choose 4 as exitcode. The plugin developer is free to return any other status.

        /*public*/ const STATUS_OK       = 0;

        /*public*/ const STATUS_WARNING  = 1;

        /*public*/ const STATUS_CRITICAL = 2;

        /*public*/ const STATUS_UNKNOWN  = 3;

        /*public*/ const STATUS_ERROR    = 4; // and upwards

        // Status 0..1 for STATUSMODEL_HOST:

        // The page https://blog.centreon.com/good-practices-how-to-develop-monitoring-plugin-nagios/

        // states that host plugins may return following status codes:

        // 0=UP, 1=DOWN, Other=Maintains last known state

        /*public*/ const STATUS_UP       = 0;

        /*public*/ const STATUS_DOWN     = 1;

        /*public*/ const STATUS_MAINTAIN = 2; // and upwards

        /*public*/ const VERBOSITY_SUMMARY                = 0;

        /*public*/ const VERBOSITY_ADDITIONAL_INFORMATION = 1;

        /*public*/ const VERBOSITY_CONFIGURATION_DEBUG    = 2;

        /*public*/ const VERBOSITY_PLUGIN_DEBUG           = 3;

        /*public*/ const MAX_VERBOSITY = self::VERBOSITY_PLUGIN_DEBUG;

        /*public*/ const STATUSMODEL_SERVICE = 0;

        /*public*/ const STATUSMODEL_HOST    = 1;

        private $initialized = false;

        private $status = null;

        private $messages = array(); // array of messages which are all put together into the headline, comma separated

        private $verbose_info = ''; // all other lines

        private $warningRanges = array();

        private $criticalRanges = array();

        private $performanceDataObjects = array();

        private static $exitcode = 0;

        private $helpObj = null;

        private $argHandler = null;

        /*public*/ const OUTPUT_NEVER     = 0;

        /*public*/ const OUTPUT_SPECIAL   = 1; // illegal usage / help page, version page

        /*public*/ const OUTPUT_NORMAL    = 2;

        /*public*/ const OUTPUT_EXCEPTION = 4;

        /*public*/ const OUTPUT_ALWAYS    = 7; // = OUTPUT_SPECIAL+OUTPUT_NORMAL+OUTPUT_EXCEPTION

        public $http_visual_output    = self::OUTPUT_ALWAYS; // show a human-readable panel? ...

        public $http_invisible_output = self::OUTPUT_ALWAYS; // ... and/or output an invisible machine-readable tag?

        // $html_before and $html_after contain the output HTML which were sent by the user

        // before and after the visual output

        protected $html_before = '';

        protected $html_after = '';

        protected $statusmodel = self::STATUSMODEL_SERVICE;

        protected $show_status_in_headline = true;

        protected $default_status = self::STATUS_UNKNOWN;

        protected $default_warning_range = null;

        protected $default_critical_range = null;

        protected $argWarning;

        protected $argCritical;

        protected $argVersion;

        protected $argVerbosity;

        protected $argTimeout;

        protected $argHelp;

        protected $argUsage;

        // -----------------------------------------------------------

        // The ID will be used for writing AND reading of the machine-readable

        // Nagios output embedded in a website. (A web-reader acts as proxy, so the

        // input and output ID will be equal)

        // Attention: Once you run run(), $id will be "used" and resetted to null.

        // The ID can be any string, e.g. a GUID, an OID, a package name or something else.

        // It should be unique. If you don't set an ID, a serial number (0, 1, 2, 3, ...) will be

        // used for your outputs.

        public $id = null;

        protected static $http_serial_number = 0;

        // -----------------------------------------------------------

        // Private key: Optional feature used in writeInvisibleHTML (called by run in HTTP mode) in order to sign/encrypt the output

        public $privkey = null;

        public $privkey_password = null;

        public $sign_algo = null; // default: OPENSSL_ALGO_SHA256

        // Public key: Optional feature used in a web-reader [readInvisibleHTML) to check the integrity of a message

        public $pubkey = null;

        // -----------------------------------------------------------

        // These settings should be set by derivated classes where the user intuitively expects the

        // warning (w) or critical (c) parameter to mean something else than defined in the development guidelines.

        // Usually, the single value "-w X" means the same like "-w X:X", which means everything except X is bad.

        // This behavior is VNag::SINGLEVALUE_RANGE_DEFAULT.

        // But for plugins e.g. for checking disk space, the user expects the argument "-w X" to mean

        // "everything below X is bad" (if X is defined as free disk space).

        // So we would choose the setting VNag::SINGLEVALUE_RANGE_VAL_LT_X_BAD.

        // Note: This setting is implemented as array, so that each range number (in case you want to have more

        //       than one range, like in the PING plugin that checks latency and package loss)

        //       can have its individual behavior for single values.

        protected $warningSingleValueRangeBehaviors  = array(self::SINGLEVALUE_RANGE_DEFAULT);

        protected $criticalSingleValueRangeBehaviors = array(self::SINGLEVALUE_RANGE_DEFAULT);

        // Default behavior according to the development guidelines:

        //  x means  x:x, which means, everything except x% is bad.

        // @x means @x:x, which means, x is bad and everything else is good.

        const SINGLEVALUE_RANGE_DEFAULT = 0;

        // The single value x means, everything > x is bad. @x is not defined.

        const SINGLEVALUE_RANGE_VAL_GT_X_BAD = 1;

        // The single value x means, everything >= x is bad. @x is not defined.

        const SINGLEVALUE_RANGE_VAL_GE_X_BAD = 2;

        // The single value x means, everything < x is bad. @x is not defined.

        const SINGLEVALUE_RANGE_VAL_LT_X_BAD = 3;

        // The single value x means, everything <= x is bad. @x is not defined.

        const SINGLEVALUE_RANGE_VAL_LE_X_BAD = 4;

        // -----------------------------------------------------------

        // Encryption password: Optional feature used in writeInvisibleHTML (called by run in HTTP mode)

        public $password_out = null;

        // Decryption password: Used in readInvisibleHTML to decrypt an encrypted machine-readable info

        public $password_in = null;

        // -----------------------------------------------------------

        public static function is_http_mode() {

                return php_sapi_name() !== 'cli';

        }

        public function getHelpManager() {

                return $this->helpObj;

        }

        public function getArgumentHandler() {

                return $this->argHandler;

        }

        public function outputHTML($text, $after_visual_output=true) {

                if ($this->is_http_mode()) {

                        if ($this->initialized) {

                                if ($after_visual_output) {

                                        $this->html_after .= $text;

                                } else {

                                        $this->html_before .= $text;

                                }

                        } else {

                                echo $text;

                        }

                }

        }

        protected function resetArguments() {

                $this->argWarning   = null;

                $this->argCritical  = null;

                $this->argVersion   = null;

                $this->argVerbosity = null;

                $this->argTimeout   = null;

                $this->argHelp      = null;

                // $this->argUsage  = null;

                // Also remove cache

                $this->argWarning   = null;

                $this->argCritical  = null;

        }

        // e.g. $args = "wcVvht"

        public function registerExpectedStandardArguments($args) {

                $this->resetArguments();

                for ($i=0; $i<strlen($args); $i++) {

                        switch ($args[$i]) {

                                case 'w':

                                        $this->addExpectedArgument($this->argWarning   = new VNagArgument('w', 'warning',  VNagArgument::VALUE_REQUIRED,  VNagLang::$argname_value, VNagLang::$warning_range));

                                        break;

                                case 'c':

                                        $this->addExpectedArgument($this->argCritical  = new VNagArgument('c', 'critical', VNagArgument::VALUE_REQUIRED,  VNagLang::$argname_value, VNagLang::$critical_range));

                                        break;

                                case 'V':

                                        $this->addExpectedArgument($this->argVersion   = new VNagArgument('V', 'version',  VNagArgument::VALUE_FORBIDDEN, null, VNagLang::$prints_version));

                                        break;

                                case 'v':

                                        // In HTTP: -vvv is &v[]=&v[]=&v[]=

                                        $this->addExpectedArgument($this->argVerbosity = new VNagArgument('v', 'verbose',  VNagArgument::VALUE_FORBIDDEN, null, VNagLang::$verbosity_helptext));

                                        break;

                                case 't':

                                        // Attention: not every plugin supports it because of declare(ticks=1) needs to be written in the main script

                                        $this->addExpectedArgument($this->argTimeout   = new VNagArgument('t', 'timeout',  VNagArgument::VALUE_REQUIRED,  VNagLang::$argname_seconds, VNagLang::$timeout_helptext));

                                        break;

                                // case '?':

                                case 'h':

                                        $this->addExpectedArgument($this->argHelp      = new VNagArgument('h', 'help',     VNagArgument::VALUE_FORBIDDEN, null, VNagLang::$help_helptext));

                                        break;

                                default:

                                        $letter = $args[$i];

                                        throw new VNagInvalidStandardArgument(sprintf(VNagLang::$no_standard_arguments_with_letter, $letter));

                                        #break;

                        }

                }

        }

        public function addExpectedArgument($argObj) {

                // Emulate C++ "friend" access to hidden functions

                // $this->helpObj->_addOption($argObj);

                $helpObjAddEntryMethod = new ReflectionMethod($this->helpObj, '_addOption');

                $helpObjAddEntryMethod->setAccessible(true);

                $helpObjAddEntryMethod->invoke($this->helpObj, $argObj);

                // $this->argHandler->_addExpectedArgument($argObj);

                $argHandlerAddEntryMethod = new ReflectionMethod($this->argHandler, '_addExpectedArgument');

                $argHandlerAddEntryMethod->setAccessible(true);

                $argHandlerAddEntryMethod->invoke($this->argHandler, $argObj);

        }

        protected function createArgumentHandler() {

                $this->argHandler = new VNagArgumentHandler();

        }

        protected function createHelpObject() {

                $this->helpObj = new VNagHelp();

        }

        protected function checkInitialized() {

                if (!$this->initialized) throw new VNagFunctionCallOutsideSession();

        }

        protected function getVerbosityLevel() {

                $this->checkInitialized(); // if (!$this->initialized) return false;

                if (!isset($this->argVerbosity)) {

                        //The verbose argument is always optional

                        //throw new VNagRequiredArgumentNotRegistered('-v');

                        return self::VERBOSITY_SUMMARY;

                } else {

                        $level = $this->argVerbosity->count();

                        if ($level > self::MAX_VERBOSITY) $level = self::MAX_VERBOSITY;

                        return $level;

                }

        }

        public function getWarningRange($argumentNumber=0) {

                $this->checkInitialized(); // if (!$this->initialized) return false;

                if (!isset($this->warningRanges[$argumentNumber])) {

                        if (!is_null($this->argWarning)) {

                                $warning = $this->argWarning->getValue();

                                if (!is_null($warning)) {

                                        $vals = explode(',',$warning);

                                        foreach ($vals as $number => $val) {

                                                if (_empty($val)) {

                                                        $this->warningRanges[$number] = null;

                                                } else {

                                                        $singleValueBehavior = isset($this->warningSingleValueRangeBehaviors[$number]) ? $this->warningSingleValueRangeBehaviors[$number] : VNag::SINGLEVALUE_RANGE_DEFAULT;

                                                        $this->warningRanges[$number] = new VNagRange($val, $singleValueBehavior);

                                                }

                                        }

                                } else {

                                        $this->warningRanges[0] = $this->default_warning_range;

                                }

                        } else {

                                return null;

                        }

                }

                if (isset($this->warningRanges[$argumentNumber])) {

                        return $this->warningRanges[$argumentNumber];

                } else {

                        return null;

                }

        }

        public function getCriticalRange($argumentNumber=0) {

                $this->checkInitialized(); // if (!$this->initialized) return false;

                if (!isset($this->criticalRanges[$argumentNumber])) {

                        if (!is_null($this->argCritical)) {

                                $critical = $this->argCritical->getValue();

                                if (!is_null($critical)) {

                                        $vals = explode(',',$critical);

                                        foreach ($vals as $number => $val) {

                                                $singleValueBehavior = isset($this->criticalSingleValueRangeBehaviors[$number]) ? $this->criticalSingleValueRangeBehaviors[$number] : VNag::SINGLEVALUE_RANGE_DEFAULT;

                                                $this->criticalRanges[$number] = new VNagRange($val, $singleValueBehavior);

                                        }

                                } else {

                                        $this->criticalRanges[0] = $this->default_critical_range;

                                }

                        } else {

                                return null;

                        }

                }

                if (isset($this->criticalRanges[$argumentNumber])) {

                        return $this->criticalRanges[$argumentNumber];

                } else {

                        return null;

                }

        }

        public function checkAgainstWarningRange($values, $force=true, $autostatus=true, $argumentNumber=0) {

                $this->checkInitialized(); // if (!$this->initialized) return;

                if (!$this->getArgumentHandler()->isArgRegistered('w')) {

                        // Developer's mistake: The argument is not in the list of expected arguments

                        throw new VNagRequiredArgumentNotRegistered('-w');

                }

                $wr = $this->getWarningRange($argumentNumber);

                if (isset($wr)) {

                        if ($wr->checkAlert($values)) {

                                if ($autostatus) $this->setStatus(VNag::STATUS_WARNING);

                                return true;

                        } else {

                                if ($autostatus) $this->setStatus(VNag::STATUS_OK);

                                return false;

                        }

                } else {

                        if ($force) {

                                // User's mistake: They did not pass the argument to the plugin

                                if (($argumentNumber > 0) && (count($this->warningRanges) > 0)) {

                                        throw new VNagInvalidArgumentException(sprintf(VNagLang::$too_few_warning_ranges, $argumentNumber+1));

                                } else {

                                        throw new VNagRequiredArgumentMissing('-w');

                                }

                        }

                }

        }

        public function checkAgainstCriticalRange($values, $force=true, $autostatus=true, $argumentNumber=0) {

                $this->checkInitialized(); // if (!$this->initialized) return;

                if (!$this->getArgumentHandler()->isArgRegistered('c')) {

                        // Developer's mistake: The argument is not in the list of expected arguments

                        throw new VNagRequiredArgumentNotRegistered('-c');

                }

                $cr = $this->getCriticalRange($argumentNumber);

                if (isset($cr)) {

                        if ($cr->checkAlert($values)) {

                                if ($autostatus) $this->setStatus(VNag::STATUS_CRITICAL);

                                return true;

                        } else {

                                if ($autostatus) $this->setStatus(VNag::STATUS_OK);

                                return false;

                        }

                } else {

                        if ($force) {

                                // User's mistake: They did not pass the argument to the plugin

                                if (($argumentNumber > 0) && (count($this->warningRanges) > 0)) {

                                        throw new VNagInvalidArgumentException(sprintf(VNagLang::$too_few_critical_ranges, $argumentNumber+1));

                                } else {

                                        throw new VNagRequiredArgumentMissing('-c');

                                }

                        }

                }

        }

        protected static function getBaddestExitcode($code1, $code2) {

                return max($code1, $code2);

        }

        # DO NOT CALL MANUALLY

        # Unfortunately, this function has to be public, otherwise register_shutdown_function() wouldn't work

        public static function _shutdownHandler() {

                if (!self::is_http_mode()) {

                        exit((int)self::$exitcode);

                }

        }

        protected function _exit($code) {

                self::$exitcode = $this->getBaddestExitcode($code, self::$exitcode);

        }

        private $constructed = false;

        function __construct() {

                $this->createHelpObject();

                $this->createArgumentHandler();

                $this->addExpectedArgument($this->argUsage = new VNagArgument('?', '', VNagArgument::VALUE_FORBIDDEN, null, VNagLang::$prints_usage));

                $this->constructed = true;

        }

        function __destruct() {

                if (Timeouter::started()) {

                        Timeouter::end();

                }

        }

        public function run() {

                global $inside_vnag_run;

                $inside_vnag_run = true;

                try {

                        if (!$this->constructed) {

                                throw new VNagNotConstructed(VNagLang::$notConstructed);

                        }

                        try {

                                $this->initialized = true;

                                $this->html_before = '';

                                $this->html_after = '';

                                $this->setStatus(null, true);

                                $this->messages = array();

                                register_shutdown_function(array($this, '_shutdownHandler'));

                                if ($this->argHandler->illegalUsage()) {

                                        $content = $this->helpObj->printUsagePage();

                                        $this->setStatus(VNag::STATUS_UNKNOWN);

                                        if ($this->is_http_mode()) {

                                                echo $this->html_before;

                                                if ($this->http_visual_output    & VNag::OUTPUT_SPECIAL) echo $this->writeVisualHTML($content);

                                                if ($this->http_invisible_output & VNag::OUTPUT_SPECIAL) echo $this->writeInvisibleHTML($content);

                                                echo $this->html_after;

                                                return; // cancel

                                        } else {

                                                echo $content;

                                                return $this->_exit($this->status);

                                        }

                                }

                                if (!is_null($this->argVersion) && ($this->argVersion->available())) {

                                        $content = $this->helpObj->printVersionPage();

                                        $this->setStatus(VNag::STATUS_UNKNOWN);

                                        if ($this->is_http_mode()) {

                                                echo $this->html_before;

                                                if ($this->http_visual_output    & VNag::OUTPUT_SPECIAL) echo $this->writeVisualHTML($content);

                                                if ($this->http_invisible_output & VNag::OUTPUT_SPECIAL) echo $this->writeInvisibleHTML($content);

                                                echo $this->html_after;

                                                return; // cancel

                                        } else {

                                                echo $content;

                                                return $this->_exit($this->status);