WebSVN – oidplus – Diff – /trunk/vendor/phpseclib/phpseclib/phpseclib/Net/SSH2.php

+     *
      * @see self::__construct()
      * @var array
      * @access private
      */
-    private $message_numbers = [];
+    private static $message_numbers = [];
     /**
      * Disconnection Message 'reason codes' defined in RFC4253
+     *
      * @see self::__construct()
      * @var array
      * @access private
      */
-    private $disconnect_reasons = [];
+    private static $disconnect_reasons = [];
     /**
      * SSH_MSG_CHANNEL_OPEN_FAILURE 'reason codes', defined in RFC4254
+     *
      * @see self::__construct()
      * @var array
      * @access private
      */
-    private $channel_open_failure_reasons = [];
+    private static $channel_open_failure_reasons = [];
     /**
      * Terminal Modes
+     *
      * @link http://tools.ietf.org/html/rfc4254#section-8
      * @see self::__construct()
      * @var array
      * @access private
      */
-    private $terminal_modes = [];
+    private static $terminal_modes = [];
     /**
      * SSH_MSG_CHANNEL_EXTENDED_DATA's data_type_codes
+     *
      * @link http://tools.ietf.org/html/rfc4254#section-5.2
      * @see self::__construct()
      * @var array
      * @access private
      */
-    private $channel_extended_data_type_codes = [];
+    private static $channel_extended_data_type_codes = [];
     /**
      * Send Sequence Number
+     *
      * See 'Section 6.4.  Data Integrity' of rfc4253 for more info.
      * @var array
      */
     protected $channel_status = [];
     /**
+     * The identifier of the interactive channel which was opened most recently
+     *
+     * @see self::getInteractiveChannelId()
+     * @var int
+     */
+    private $channel_id_last_interactive = 0;
+    /**
      * Packet Size
+     *
      * Maximum packet size indexed by channel
+     *
      * @see self::send_channel_packet()
      * @see self::enablePTY()
      */
     private $request_pty = false;
     /**
-     * Flag set while exec() is running when using enablePTY()
-     *
-     * @var bool
-     */
-    private $in_request_pty_exec = false;
-    /**
-     * Flag set after startSubsystem() is called
-     *
-     * @var bool
-     */
-    private $in_subsystem;
-    /**
      * Contents of stdError
+     *
      * @var string
      */
     private $stdErrorLog;
      * @param int $timeout
      * @see self::login()
      */
     public function __construct($host, $port = 22, $timeout = 10)
+    {
+        if (empty(self::$message_numbers)) {
-        $this->message_numbers = [
+            self::$message_numbers = [
 => 'NET_SSH2_MSG_DISCONNECT',
 => 'NET_SSH2_MSG_IGNORE',
 => 'NET_SSH2_MSG_UNIMPLEMENTED',
 => 'NET_SSH2_MSG_DEBUG',
 => 'NET_SSH2_MSG_SERVICE_REQUEST',
 => 'NET_SSH2_MSG_CHANNEL_CLOSE',
 => 'NET_SSH2_MSG_CHANNEL_REQUEST',
 => 'NET_SSH2_MSG_CHANNEL_SUCCESS',
 => 'NET_SSH2_MSG_CHANNEL_FAILURE'
-        ];
+            ];
-        $this->disconnect_reasons = [
+            self::$disconnect_reasons = [
 => 'NET_SSH2_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT',
 => 'NET_SSH2_DISCONNECT_PROTOCOL_ERROR',
 => 'NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED',
 => 'NET_SSH2_DISCONNECT_RESERVED',
 => 'NET_SSH2_DISCONNECT_MAC_ERROR',
 => 'NET_SSH2_DISCONNECT_TOO_MANY_CONNECTIONS',
 => 'NET_SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER',
 => 'NET_SSH2_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE',
 => 'NET_SSH2_DISCONNECT_ILLEGAL_USER_NAME'
-        ];
+            ];
-        $this->channel_open_failure_reasons = [
+            self::$channel_open_failure_reasons = [
 => 'NET_SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED'
-        ];
+            ];
-        $this->terminal_modes = [
+            self::$terminal_modes = [
 => 'NET_SSH2_TTY_OP_END'
-        ];
+            ];
-        $this->channel_extended_data_type_codes = [
+            self::$channel_extended_data_type_codes = [
 => 'NET_SSH2_EXTENDED_DATA_STDERR'
-        ];
+            ];
-        $this->define_array(
+            self::define_array(
-            $this->message_numbers,
+                self::$message_numbers,
-            $this->disconnect_reasons,
+                self::$disconnect_reasons,
-            $this->channel_open_failure_reasons,
+                self::$channel_open_failure_reasons,
-            $this->terminal_modes,
+                self::$terminal_modes,
-            $this->channel_extended_data_type_codes,
+                self::$channel_extended_data_type_codes,
-            [60 => 'NET_SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ'],
+                [60 => 'NET_SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ'],
-            [60 => 'NET_SSH2_MSG_USERAUTH_PK_OK'],
+                [60 => 'NET_SSH2_MSG_USERAUTH_PK_OK'],
-            [60 => 'NET_SSH2_MSG_USERAUTH_INFO_REQUEST',
+                [60 => 'NET_SSH2_MSG_USERAUTH_INFO_REQUEST',
 => 'NET_SSH2_MSG_USERAUTH_INFO_RESPONSE'],
-            // RFC 4419 - diffie-hellman-group-exchange-sha{1,256}
+                // RFC 4419 - diffie-hellman-group-exchange-sha{1,256}
 => 'NET_SSH2_MSG_KEXDH_GEX_REQUEST'],
-            // RFC 5656 - Elliptic Curves (for curve25519-sha256@libssh.org)
+                // RFC 5656 - Elliptic Curves (for curve25519-sha256@libssh.org)
-            [30 => 'NET_SSH2_MSG_KEX_ECDH_INIT',
+                [30 => 'NET_SSH2_MSG_KEX_ECDH_INIT',
 => 'NET_SSH2_MSG_KEX_ECDH_REPLY']
-        );
+            );
+        }
         /**
          * Typehint is required due to a bug in Psalm: https://github.com/vimeo/psalm/issues/7508
          * @var \WeakReference<SSH2>|SSH2
          */
         if (!$this->isAuthenticated()) {
             return false;
+        }
-        if ($this->in_request_pty_exec) {
+        if ($this->isPTYOpen()) {
             throw new \RuntimeException('If you want to run multiple exec()\'s you will need to disable (and re-enable if appropriate) a PTY for each one.');
+        }
         // RFC4254 defines the (client) window size as "bytes the other party can send before it must wait for the window to
         // be adjusted".  0x7FFFFFFF is, at 2GB, the max size.  technically, it should probably be decremented, but,
             $this->channel_status[self::CHANNEL_EXEC] = NET_SSH2_MSG_CHANNEL_REQUEST;
             if (!$this->get_channel_packet(self::CHANNEL_EXEC)) {
                 $this->disconnect_helper(NET_SSH2_DISCONNECT_BY_APPLICATION);
                 throw new \RuntimeException('Unable to request pseudo-terminal');
+            }
-            $this->in_request_pty_exec = true;
+        }
         // sending a pty-req SSH_MSG_CHANNEL_REQUEST message is unnecessary and, in fact, in most cases, slows things
         // down.  the one place where it might be desirable is if you're doing something like \phpseclib3\Net\SSH2::exec('ping localhost &').
         // with a pty-req SSH_MSG_CHANNEL_REQUEST, exec() will return immediately and the ping process will then
             return false;
+        }
         $this->channel_status[self::CHANNEL_EXEC] = NET_SSH2_MSG_CHANNEL_DATA;
-        if ($this->in_request_pty_exec) {
+        if ($this->request_pty === true) {
+            $this->channel_id_last_interactive = self::CHANNEL_EXEC;
             return true;
+        }
         $output = '';
         while (true) {
+    }
     /**
      * Creates an interactive shell
+     *
+     * Returns bool(true) if the shell was opened.
+     * Returns bool(false) if the shell was already open.
+     *
+     * @see self::isShellOpen()
      * @see self::read()
      * @see self::write()
      * @return bool
+     * @throws InsufficientSetupException if not authenticated
      * @throws \UnexpectedValueException on receipt of unexpected packets
      * @throws \RuntimeException on other errors
      */
-    private function initShell()
+    public function openShell()
+    {
-        if ($this->in_request_pty_exec === true) {
+        if ($this->isShellOpen()) {
-            return true;
+            return false;
+        }
+        if (!$this->isAuthenticated()) {
+            throw new InsufficientSetupException('Operation disallowed prior to login()');
+        }
         $this->window_size_server_to_client[self::CHANNEL_SHELL] = $this->window_size;
         $packet_size = 0x4000;
             throw new \RuntimeException('Unable to request shell');
+        }
         $this->channel_status[self::CHANNEL_SHELL] = NET_SSH2_MSG_CHANNEL_DATA;
+        $this->channel_id_last_interactive = self::CHANNEL_SHELL;
         $this->bitmap |= self::MASK_SHELL;
         return true;
+    }
     /**
-     * Return the channel to be used with read() / write()
+     * Return the channel to be used with read(), write(), and reset(), if none were specified
+     * @deprecated for lack of transparency in intended channel target, to be potentially replaced
+     *             with method which guarantees open-ness of all yielded channels and throws
-     *
+     *             error for multiple open channels
      * @see self::read()
      * @see self::write()
      * @return int
      */
     private function get_interactive_channel()
+    {
         switch (true) {
-            case $this->in_subsystem:
+            case $this->is_channel_status_data(self::CHANNEL_SUBSYSTEM):
                 return self::CHANNEL_SUBSYSTEM;
-            case $this->in_request_pty_exec:
+            case $this->is_channel_status_data(self::CHANNEL_EXEC):
                 return self::CHANNEL_EXEC;
             default:
                 return self::CHANNEL_SHELL;
+        }
+    }
     /**
+     * Indicates the DATA status on the given channel
+     *
+     * @param int $channel The channel number to evaluate
+     * @return bool
+     */
+    private function is_channel_status_data($channel)
+    {
+        return isset($this->channel_status[$channel]) && $this->channel_status[$channel] == NET_SSH2_MSG_CHANNEL_DATA;
+    }
+    /**
      * Return an available open channel
+     *
      * @return int
      */
     private function get_open_channel()
      * Returns the output of an interactive shell
+     *
      * Returns when there's a match for $expect, which can take the form of a string literal or,
      * if $mode == self::READ_REGEX, a regular expression.
+     *
+     * If not specifying a channel, an open interactive channel will be selected, or, if there are
+     * no open channels, an interactive shell will be created. If there are multiple open
+     * interactive channels, a legacy behavior will apply in which channel selection prioritizes
+     * an active subsystem, the exec pty, and, lastly, the shell. If using multiple interactive
+     * channels, callers are discouraged from relying on this legacy behavior and should specify
+     * the intended channel.
+     *
      * @see self::write()
      * @param string $expect
-     * @param int $mode
+     * @param int $mode One of the self::READ_* constants
+     * @param int|null $channel Channel id returned by self::getInteractiveChannelId()
      * @return string|bool|null
      * @throws \RuntimeException on connection error
+     * @throws InsufficientSetupException on unexpected channel status, possibly due to closure
      */
-    public function read($expect = '', $mode = self::READ_SIMPLE)
+    public function read($expect = '', $mode = self::READ_SIMPLE, $channel = null)
+    {
         $this->curTimeout = $this->timeout;
         $this->is_timeout = false;
-        if (!$this->isAuthenticated()) {
+        if ($channel === null) {
-            throw new InsufficientSetupException('Operation disallowed prior to login()');
+            $channel = $this->get_interactive_channel();
+        }
-        if (!($this->bitmap & self::MASK_SHELL) && !$this->initShell()) {
+        if (!$this->isInteractiveChannelOpen($channel)) {
+            if ($channel != self::CHANNEL_SHELL) {
+                throw new InsufficientSetupException('Data is not available on channel');
+            } elseif (!$this->openShell()) {
-            throw new \RuntimeException('Unable to initiate an interactive shell session');
+                throw new \RuntimeException('Unable to initiate an interactive shell session');
+            }
-        $channel = $this->get_interactive_channel();
+        }
         if ($mode == self::READ_NEXT) {
             return $this->get_channel_packet($channel);
+        }
             if ($pos !== false) {
                 return Strings::shift($this->interactiveBuffer, $pos + strlen($match));
+            }
             $response = $this->get_channel_packet($channel);
             if ($response === true) {
-                $this->in_request_pty_exec = false;
                 return Strings::shift($this->interactiveBuffer, strlen($this->interactiveBuffer));
+            }
             $this->interactiveBuffer .= $response;
+        }
+    }
     /**
      * Inputs a command into an interactive shell.
+     *
+     * If not specifying a channel, an open interactive channel will be selected, or, if there are
+     * no open channels, an interactive shell will be created. If there are multiple open
+     * interactive channels, a legacy behavior will apply in which channel selection prioritizes
+     * an active subsystem, the exec pty, and, lastly, the shell. If using multiple interactive
+     * channels, callers are discouraged from relying on this legacy behavior and should specify
+     * the intended channel.
+     *
      * @see SSH2::read()
      * @param string $cmd
+     * @param int|null $channel Channel id returned by self::getInteractiveChannelId()
      * @return void
      * @throws \RuntimeException on connection error
+     * @throws InsufficientSetupException on unexpected channel status, possibly due to closure
      */
-    public function write($cmd)
+    public function write($cmd, $channel = null)
+    {
-        if (!$this->isAuthenticated()) {
+        if ($channel === null) {
-            throw new InsufficientSetupException('Operation disallowed prior to login()');
+            $channel = $this->get_interactive_channel();
+        }
-        if (!($this->bitmap & self::MASK_SHELL) && !$this->initShell()) {
+        if (!$this->isInteractiveChannelOpen($channel)) {
+            if ($channel != self::CHANNEL_SHELL) {
+                throw new InsufficientSetupException('Data is not available on channel');
+            } elseif (!$this->openShell()) {
-            throw new \RuntimeException('Unable to initiate an interactive shell session');
+                throw new \RuntimeException('Unable to initiate an interactive shell session');
+            }
+        }
-        $this->send_channel_packet($this->get_interactive_channel(), $cmd);
+        $this->send_channel_packet($channel, $cmd);
+    }
     /**
      * Start a subsystem.
+     *
             return false;
+        }
         $this->channel_status[self::CHANNEL_SUBSYSTEM] = NET_SSH2_MSG_CHANNEL_DATA;
-        $this->bitmap |= self::MASK_SHELL;
+        $this->channel_id_last_interactive = self::CHANNEL_SUBSYSTEM;
-        $this->in_subsystem = true;
         return true;
+    }
     /**
      * @see self::startSubsystem()
      * @return bool
      */
     public function stopSubsystem()
+    {
-        $this->in_subsystem = false;
+        if ($this->isInteractiveChannelOpen(self::CHANNEL_SUBSYSTEM)) {
-        $this->close_channel(self::CHANNEL_SUBSYSTEM);
+            $this->close_channel(self::CHANNEL_SUBSYSTEM);
+        }
         return true;
+    }
     /**
      * Closes a channel
+     *
      * If read() timed out you might want to just close the channel and have it auto-restart on the next read() call
+     *
+     * If not specifying a channel, an open interactive channel will be selected. If there are
+     * multiple open interactive channels, a legacy behavior will apply in which channel selection
+     * prioritizes an active subsystem, the exec pty, and, lastly, the shell. If using multiple
+     * interactive channels, callers are discouraged from relying on this legacy behavior and
+     * should specify the intended channel.
+     *
+     * @param int|null $channel Channel id returned by self::getInteractiveChannelId()
+     * @return void
      */
-    public function reset()
+    public function reset($channel = null)
+    {
+        if ($channel === null) {
-        $this->close_channel($this->get_interactive_channel());
+            $channel = $this->get_interactive_channel();
+        }
+        if ($this->isInteractiveChannelOpen($channel)) {
+            $this->close_channel($channel);
+        }
+    }
     /**
      * Is timeout?
+     *
+    {
         return (bool) ($this->bitmap & self::MASK_LOGIN);
+    }
     /**
+     * Is the interactive shell active?
+     *
+     * @return bool
+     */
+    public function isShellOpen()
+    {
+        return $this->isInteractiveChannelOpen(self::CHANNEL_SHELL);
+    }
+    /**
+     * Is the exec pty active?
+     *
+     * @return bool
+     */
+    public function isPTYOpen()
+    {
+        return $this->isInteractiveChannelOpen(self::CHANNEL_EXEC);
+    }
+    /**
+     * Is the given interactive channel active?
+     *
+     * @param int $channel Channel id returned by self::getInteractiveChannelId()
+     * @return bool
+     */
+    public function isInteractiveChannelOpen($channel)
+    {
+        return $this->isAuthenticated() && $this->is_channel_status_data($channel);
+    }
+    /**
+     * Returns a channel identifier, presently of the last interactive channel opened, regardless of current status.
+     * Returns 0 if no interactive channel has been opened.
+     *
+     * @see self::isInteractiveChannelOpen()
+     * @return int
+     */
+    public function getInteractiveChannelId()
+    {
+        return $this->channel_id_last_interactive;
+    }
+    /**
      * Pings a server connection, or tries to reconnect if the connection has gone down
+     *
      * Inspired by http://php.net/manual/en/mysqli.ping.php
+     *
      * @return bool
         $this->get_seq_no++;
         if (defined('NET_SSH2_LOGGING')) {
             $current = microtime(true);
-            $message_number = isset($this->message_numbers[ord($payload[0])]) ? $this->message_numbers[ord($payload[0])] : 'UNKNOWN (' . ord($payload[0]) . ')';
+            $message_number = isset(self::$message_numbers[ord($payload[0])]) ? self::$message_numbers[ord($payload[0])] : 'UNKNOWN (' . ord($payload[0]) . ')';
             $message_number = '<- ' . $message_number .
                               ' (since last: ' . round($current - $this->last_packet, 4) . ', network: ' . round($stop - $start, 4) . 's)';
             $this->append_log($message_number, $payload);
             $this->last_packet = $current;
+        }
+    {
         switch (ord($payload[0])) {
             case NET_SSH2_MSG_DISCONNECT:
                 Strings::shift($payload, 1);
                 list($reason_code, $message) = Strings::unpackSSH2('Ns', $payload);
-                $this->errors[] = 'SSH_MSG_DISCONNECT: ' . $this->disconnect_reasons[$reason_code] . "\r\n$message";
+                $this->errors[] = 'SSH_MSG_DISCONNECT: ' . static::$disconnect_reasons[$reason_code] . "\r\n$message";
                 $this->bitmap = 0;
                 return false;
             case NET_SSH2_MSG_IGNORE:
                 $payload = $this->get_binary_packet($skip_channel_filter);
                 break;
      * Disable request-pty when using exec()
+     *
      */
     public function disablePTY()
+    {
-        if ($this->in_request_pty_exec) {
+        if ($this->isPTYOpen()) {
             $this->close_channel(self::CHANNEL_EXEC);
-            $this->in_request_pty_exec = false;
+        }
         $this->request_pty = false;
+    }
     /**
+     *
      * - the server closes the channel
      * - if the connection times out
      * - if the channel status is CHANNEL_OPEN and the response was CHANNEL_OPEN_CONFIRMATION
      * - if the channel status is CHANNEL_REQUEST and the response was CHANNEL_SUCCESS
+     * - if the channel status is CHANNEL_CLOSE and the response was CHANNEL_CLOSE
+     *
      * bool(false) is returned if:
+     *
      * - if the channel status is CHANNEL_REQUEST and the response was CHANNEL_FAILURE
+     *
                             default:
                                 $this->disconnect_helper(NET_SSH2_DISCONNECT_BY_APPLICATION);
                                 throw new \RuntimeException('Unable to fulfill channel request');
+                        }
                     case NET_SSH2_MSG_CHANNEL_CLOSE:
+                        if ($client_channel == $channel && $type == NET_SSH2_MSG_CHANNEL_CLOSE) {
+                            return true;
+                        }
-                        return $type == NET_SSH2_MSG_CHANNEL_CLOSE ? true : $this->get_channel_packet($client_channel, $skip_extended);
+                        return $this->get_channel_packet($client_channel, $skip_extended);
+                }
+            }
             // ie. $this->channel_status[$channel] == NET_SSH2_MSG_CHANNEL_DATA
                     $this->channel_buffers[$channel][] = chr($type) . $data;
                     break;
                 case NET_SSH2_MSG_CHANNEL_CLOSE:
                     $this->curTimeout = 5;
-                    if ($this->bitmap & self::MASK_SHELL) {
-                        $this->bitmap &= ~self::MASK_SHELL;
+                    $this->close_channel_bitmap($channel);
-                    }
                     if ($this->channel_status[$channel] != NET_SSH2_MSG_CHANNEL_EOF) {
                         $this->send_binary_packet(pack('CN', NET_SSH2_MSG_CHANNEL_CLOSE, $this->server_channels[$channel]));
+                    }
                     $this->channel_status[$channel] = NET_SSH2_MSG_CHANNEL_CLOSE;
         $sent = @fputs($this->fsock, $packet);
         $stop = microtime(true);
         if (defined('NET_SSH2_LOGGING')) {
             $current = microtime(true);
-            $message_number = isset($this->message_numbers[ord($logged[0])]) ? $this->message_numbers[ord($logged[0])] : 'UNKNOWN (' . ord($logged[0]) . ')';
+            $message_number = isset(self::$message_numbers[ord($logged[0])]) ? self::$message_numbers[ord($logged[0])] : 'UNKNOWN (' . ord($logged[0]) . ')';
             $message_number = '-> ' . $message_number .
                               ' (since last: ' . round($current - $this->last_packet, 4) . ', network: ' . round($stop - $start, 4) . 's)';
             $this->append_log($message_number, $logged);
             $this->last_packet = $current;
+        }
         $this->curTimeout = 5;
         while (!is_bool($this->get_channel_packet($client_channel))) {
+        }
-        if ($this->is_timeout) {
-            $this->disconnect();
-        }
         if ($want_reply) {
             $this->send_binary_packet(pack('CN', NET_SSH2_MSG_CHANNEL_CLOSE, $this->server_channels[$client_channel]));
+        }
+        $this->close_channel_bitmap($client_channel);
+    }
+    /**
+     * Maintains execution state bitmap in response to channel closure
+     *
+     * @param int $client_channel The channel number to maintain closure status of
+     * @return void
+     */
+    private function close_channel_bitmap($client_channel)
+    {
+        switch ($client_channel) {
+            case self::CHANNEL_SHELL:
+                // Shell status has been maintained in the bitmap for backwards
+                //  compatibility sake, but can be removed going forward
-        if ($this->bitmap & self::MASK_SHELL) {
+                if ($this->bitmap & self::MASK_SHELL) {
-            $this->bitmap &= ~self::MASK_SHELL;
+                    $this->bitmap &= ~self::MASK_SHELL;
+                }
+                break;
+        }
+    }
     /**
      * Disconnect
+     *
      * If any of the constants that would be defined already exists, none of the constants will be defined.
+     *
      * @param mixed[] ...$args
      * @access protected
      */
-    protected function define_array(...$args)
+    protected static function define_array(...$args)
+    {
         foreach ($args as $arg) {
             foreach ($arg as $key => $value) {
                 if (!defined($value)) {
                     define($value, $key);

Subversion Repositories oidplus

oidplus/trunk/vendor/phpseclib/phpseclib/phpseclib/Net/SSH2.php – Rev 1114 → 1117