!C99Shell v. 1.0 pre-release build #13!

Software: Apache. PHP/5.5.15 

uname -a: Windows NT SVR-DMZ 6.1 build 7600 (Windows Server 2008 R2 Enterprise Edition) i586 

SYSTEM 

Safe-mode: OFF (not secure)

C:\dmz\php\pear\Console\   drwxrwxrwx
Free 4.08 GB of 39.52 GB (10.32%)
Detected drives: [ a ] [ c ] [ d ] [ e ] [ f ]
Home    Back    Forward    UPDIR    Refresh    Search    Buffer    Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Feedback    Self remove    Logout    


Viewing file:     Getopt.php (13.15 KB)      -rw-rw-rw-
Select action/file-type:
(+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
<?php
/* vim: set expandtab tabstop=4 shiftwidth=4: */
/**
 * PHP Version 5
 *
 * Copyright (c) 1997-2004 The PHP Group
 *
 * This source file is subject to version 3.0 of the PHP license,
 * that is bundled with this package in the file LICENSE, and is
 * available through the world-wide-web at the following url:
 * http://www.php.net/license/3_0.txt.
 * If you did not receive a copy of the PHP license and are unable to
 * obtain it through the world-wide-web, please send a note to
 * license@php.net so we can mail you a copy immediately.
 *
 * @category Console
 * @package  Console_Getopt
 * @author   Andrei Zmievski <andrei@php.net>
 * @license  http://www.php.net/license/3_0.txt PHP 3.0
 * @version  CVS: $Id: Getopt.php 306067 2010-12-08 00:13:31Z dufuz $
 * @link     http://pear.php.net/package/Console_Getopt
 */

require_once 'PEAR.php';

/**
 * Command-line options parsing class.
 *
 * @category Console
 * @package  Console_Getopt
 * @author   Andrei Zmievski <andrei@php.net>
 * @license  http://www.php.net/license/3_0.txt PHP 3.0
 * @link     http://pear.php.net/package/Console_Getopt
 */
class Console_Getopt
{

    
/**
     * Parses the command-line options.
     *
     * The first parameter to this function should be the list of command-line
     * arguments without the leading reference to the running program.
     *
     * The second parameter is a string of allowed short options. Each of the
     * option letters can be followed by a colon ':' to specify that the option
     * requires an argument, or a double colon '::' to specify that the option
     * takes an optional argument.
     *
     * The third argument is an optional array of allowed long options. The
     * leading '--' should not be included in the option name. Options that
     * require an argument should be followed by '=', and options that take an
     * option argument should be followed by '=='.
     *
     * The return value is an array of two elements: the list of parsed
     * options and the list of non-option command-line arguments. Each entry in
     * the list of parsed options is a pair of elements - the first one
     * specifies the option, and the second one specifies the option argument,
     * if there was one.
     *
     * Long and short options can be mixed.
     *
     * Most of the semantics of this function are based on GNU getopt_long().
     *
     * @param array  $args          an array of command-line arguments
     * @param string $short_options specifies the list of allowed short options
     * @param array  $long_options  specifies the list of allowed long options
     * @param boolean $skip_unknown suppresses Console_Getopt: unrecognized option
     *
     * @return array two-element array containing the list of parsed options and
     * the non-option arguments
     * @access public
     */
    
function getopt2($args$short_options$long_options null$skip_unknown false)
    {
        return 
Console_Getopt::doGetopt(2$args$short_options$long_options$skip_unknown);
    }

    
/**
     * This function expects $args to start with the script name (POSIX-style).
     * Preserved for backwards compatibility.
     *
     * @param array  $args          an array of command-line arguments
     * @param string $short_options specifies the list of allowed short options
     * @param array  $long_options  specifies the list of allowed long options
     *
     * @see getopt2()
     * @return array two-element array containing the list of parsed options and
     * the non-option arguments
     */
    
function getopt($args$short_options$long_options null$skip_unknown false)
    {
        return 
Console_Getopt::doGetopt(1$args$short_options$long_options$skip_unknown);
    }

    
/**
     * The actual implementation of the argument parsing code.
     *
     * @param int    $version       Version to use
     * @param array  $args          an array of command-line arguments
     * @param string $short_options specifies the list of allowed short options
     * @param array  $long_options  specifies the list of allowed long options
     * @param boolean $skip_unknown suppresses Console_Getopt: unrecognized option
     *
     * @return array
     */
    
function doGetopt($version$args$short_options$long_options null$skip_unknown false)
    {
        
// in case you pass directly readPHPArgv() as the first arg
        
if (PEAR::isError($args)) {
            return 
$args;
        }

        if (empty(
$args)) {
            return array(array(), array());
        }

        
$non_opts $opts = array();

        
settype($args'array');

        if (
$long_options) {
            
sort($long_options);
        }

        
/*
         * Preserve backwards compatibility with callers that relied on
         * erroneous POSIX fix.
         */
        
if ($version 2) {
            if (isset(
$args[0]{0}) && $args[0]{0} != '-') {
                
array_shift($args);
            }
        }

        
reset($args);
        while (list(
$i$arg) = each($args)) {
            
/* The special element '--' means explicit end of
               options. Treat the rest of the arguments as non-options
               and end the loop. */
            
if ($arg == '--') {
                
$non_opts array_merge($non_optsarray_slice($args$i 1));
                break;
            }

            if (
$arg{0} != '-' || (strlen($arg) > && $arg{1} == '-' && !$long_options)) {
                
$non_opts array_merge($non_optsarray_slice($args$i));
                break;
            } elseif (
strlen($arg) > && $arg{1} == '-') {
                
$error Console_Getopt::_parseLongOption(substr($arg2),
                                                          
$long_options,
                                                          
$opts,
                                                          
$args,
                                                          
$skip_unknown);
                if (
PEAR::isError($error)) {
                    return 
$error;
                }
            } elseif (
$arg == '-') {
                
// - is stdin
                
$non_opts array_merge($non_optsarray_slice($args$i));
                break;
            } else {
                
$error Console_Getopt::_parseShortOption(substr($arg1),
                                                           
$short_options,
                                                           
$opts,
                                                           
$args,
                                                           
$skip_unknown);
                if (
PEAR::isError($error)) {
                    return 
$error;
                }
            }
        }

        return array(
$opts$non_opts);
    }

    
/**
     * Parse short option
     *
     * @param string     $arg           Argument
     * @param string[]   $short_options Available short options
     * @param string[][] &$opts
     * @param string[]   &$args
     * @param boolean    $skip_unknown suppresses Console_Getopt: unrecognized option
     *
     * @access private
     * @return void
     */
    
function _parseShortOption($arg$short_options, &$opts, &$args$skip_unknown)
    {
        for (
$i 0$i strlen($arg); $i++) {
            
$opt     $arg{$i};
            
$opt_arg null;

            
/* Try to find the short option in the specifier string. */
            
if (($spec strstr($short_options$opt)) === false || $arg{$i} == ':') {
                if (
$skip_unknown === true) {
                    break;
                }

                
$msg "Console_Getopt: unrecognized option -- $opt";
                return 
PEAR::raiseError($msg);
            }

            if (
strlen($spec) > && $spec{1} == ':') {
                if (
strlen($spec) > && $spec{2} == ':') {
                    if (
$i strlen($arg)) {
                        
/* Option takes an optional argument. Use the remainder of
                           the arg string if there is anything left. */
                        
$opts[] = array($optsubstr($arg$i 1));
                        break;
                    }
                } else {
                    
/* Option requires an argument. Use the remainder of the arg
                       string if there is anything left. */
                    
if ($i strlen($arg)) {
                        
$opts[] = array($opt,  substr($arg$i 1));
                        break;
                    } else if (list(, 
$opt_arg) = each($args)) {
                        
/* Else use the next argument. */;
                        if (
Console_Getopt::_isShortOpt($opt_arg)
                            || 
Console_Getopt::_isLongOpt($opt_arg)) {
                            
$msg "option requires an argument --$opt";
                            return 
PEAR::raiseError("Console_Getopt:" $msg);
                        }
                    } else {
                        
$msg "option requires an argument --$opt";
                        return 
PEAR::raiseError("Console_Getopt:" $msg);
                    }
                }
            }

            
$opts[] = array($opt$opt_arg);
        }
    }

    
/**
     * Checks if an argument is a short option
     *
     * @param string $arg Argument to check
     *
     * @access private
     * @return bool
     */
    
function _isShortOpt($arg)
    {
        return 
strlen($arg) == && $arg[0] == '-'
               
&& preg_match('/[a-zA-Z]/'$arg[1]);
    }

    
/**
     * Checks if an argument is a long option
     *
     * @param string $arg Argument to check
     *
     * @access private
     * @return bool
     */
    
function _isLongOpt($arg)
    {
        return 
strlen($arg) > && $arg[0] == '-' && $arg[1] == '-' &&
               
preg_match('/[a-zA-Z]+$/'substr($arg2));
    }

    
/**
     * Parse long option
     *
     * @param string     $arg          Argument
     * @param string[]   $long_options Available long options
     * @param string[][] &$opts
     * @param string[]   &$args
     *
     * @access private
     * @return void|PEAR_Error
     */
    
function _parseLongOption($arg$long_options, &$opts, &$args$skip_unknown)
    {
        @list(
$opt$opt_arg) = explode('='$arg2);

        
$opt_len strlen($opt);

        for (
$i 0$i count($long_options); $i++) {
            
$long_opt  $long_options[$i];
            
$opt_start substr($long_opt0$opt_len);

            
$long_opt_name str_replace('='''$long_opt);

            
/* Option doesn't match. Go on to the next one. */
            
if ($long_opt_name != $opt) {
                continue;
            }

            
$opt_rest substr($long_opt$opt_len);

            
/* Check that the options uniquely matches one of the allowed
               options. */
            
if ($i count($long_options)) {
                
$next_option_rest substr($long_options[$i 1], $opt_len);
            } else {
                
$next_option_rest '';
            }

            if (
$opt_rest != '' && $opt{0} != '=' &&
                
$i count($long_options) &&
                
$opt == substr($long_options[$i+1], 0$opt_len) &&
                
$next_option_rest != '' &&
                
$next_option_rest{0} != '=') {

                
$msg "Console_Getopt: option --$opt is ambiguous";
                return 
PEAR::raiseError($msg);
            }

            if (
substr($long_opt, -1) == '=') {
                if (
substr($long_opt, -2) != '==') {
                    
/* Long option requires an argument.
                       Take the next argument if one wasn't specified. */
;
                    if (!
strlen($opt_arg) && !(list(, $opt_arg) = each($args))) {
                        
$msg "Console_Getopt: option requires an argument --$opt";
                        return 
PEAR::raiseError($msg);
                    }

                    if (
Console_Getopt::_isShortOpt($opt_arg)
                        || 
Console_Getopt::_isLongOpt($opt_arg)) {
                        
$msg "Console_Getopt: option requires an argument --$opt";
                        return 
PEAR::raiseError($msg);
                    }
                }
            } else if (
$opt_arg) {
                
$msg "Console_Getopt: option --$opt doesn't allow an argument";
                return 
PEAR::raiseError($msg);
            }

            
$opts[] = array('--' $opt$opt_arg);
            return;
        }

        if (
$skip_unknown === true) {
            return;
        }

        return 
PEAR::raiseError("Console_Getopt: unrecognized option --$opt");
    }

    
/**
     * Safely read the $argv PHP array across different PHP configurations.
     * Will take care on register_globals and register_argc_argv ini directives
     *
     * @access public
     * @return mixed the $argv PHP array or PEAR error if not registered
     */
    
function readPHPArgv()
    {
        global 
$argv;
        if (!
is_array($argv)) {
            if (!@
is_array($_SERVER['argv'])) {
                if (!@
is_array($GLOBALS['HTTP_SERVER_VARS']['argv'])) {
                    
$msg "Could not read cmd args (register_argc_argv=Off?)";
                    return 
PEAR::raiseError("Console_Getopt: " $msg);
                }
                return 
$GLOBALS['HTTP_SERVER_VARS']['argv'];
            }
            return 
$_SERVER['argv'];
        }
        return 
$argv;
    }

}

:: Command execute ::

Enter:
 
Select:
 

:: Search ::
  - regexp 

:: Upload ::
 
[ ok ]

:: Make Dir ::
 
[ ok ]
:: Make File ::
 
[ ok ]

:: Go Dir ::
 
:: Go File ::
 

--[ c99shell v. 1.0 pre-release build #13 powered by Captain Crunch Security Team | http://ccteam.ru | Generation time: 0.0312 ]--