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

  *    $sftp->put('filename.ext', 'hello, world!');
  *    print_r($sftp->nlist());
  * ?>
  * </code>
+ *
+ * @category  Net
+ * @package   SFTP
  * @author    Jim Wigginton <terrafrost@php.net>
  * @copyright 2009 Jim Wigginton
  * @license   http://www.opensource.org/licenses/mit-license.html  MIT License
  * @link      http://phpseclib.sourceforge.net
  */
 namespace phpseclib3\Net;
 use phpseclib3\Common\Functions\Strings;
 use phpseclib3\Exception\FileNotFoundException;
-use phpseclib3\Net\SFTP\Attribute;
-use phpseclib3\Net\SFTP\FileType;
-use phpseclib3\Net\SFTP\OpenFlag;
-use phpseclib3\Net\SFTP\OpenFlag5;
-use phpseclib3\Net\SFTP\PacketType as SFTPPacketType;
-use phpseclib3\Net\SFTP\StatusCode;
-use phpseclib3\Net\SSH2\MessageType as SSH2MessageType;
 /**
  * Pure-PHP implementations of SFTP.
+ *
+ * @package SFTP
  * @author  Jim Wigginton <terrafrost@php.net>
+ * @access  public
  */
 class SFTP extends SSH2
+{
     /**
      * SFTP channel constant
+     *
      * \phpseclib3\Net\SSH2::exec() uses 0 and \phpseclib3\Net\SSH2::read() / \phpseclib3\Net\SSH2::write() use 1.
+     *
      * @see \phpseclib3\Net\SSH2::send_channel_packet()
      * @see \phpseclib3\Net\SSH2::get_channel_packet()
+     * @access private
      */
     const CHANNEL = 0x100;
     /**
      * Reads data from a local file.
+     *
+     * @access public
      * @see \phpseclib3\Net\SFTP::put()
      */
     const SOURCE_LOCAL_FILE = 1;
     /**
      * Reads data from a string.
+     *
+     * @access public
      * @see \phpseclib3\Net\SFTP::put()
      */
     // this value isn't really used anymore but i'm keeping it reserved for historical reasons
     const SOURCE_STRING = 2;
     /**
      * Reads data from callback:
      * function callback($length) returns string to proceed, null for EOF
+     *
+     * @access public
      * @see \phpseclib3\Net\SFTP::put()
      */
     const SOURCE_CALLBACK = 16;
     /**
      * Resumes an upload
+     *
+     * @access public
      * @see \phpseclib3\Net\SFTP::put()
      */
     const RESUME = 4;
     /**
      * Append a local file to an already existing remote file
+     *
+     * @access public
      * @see \phpseclib3\Net\SFTP::put()
      */
     const RESUME_START = 8;
     /**
+     * Packet Types
+     *
+     * @see self::__construct()
+     * @var array
+     * @access private
+     */
+    private $packet_types = [];
+    /**
+     * Status Codes
+     *
+     * @see self::__construct()
+     * @var array
+     * @access private
+     */
+    private $status_codes = [];
+    /** @var array<int, string> */
+    private $attributes;
+    /** @var array<int, string> */
+    private $open_flags;
+    /** @var array<int, string> */
+    private $open_flags5;
+    /** @var array<int, string> */
+    private $file_types;
+    /**
      * The Request ID
+     *
      * The request ID exists in the off chance that a packet is sent out-of-order.  Of course, this library doesn't support
      * concurrent actions, so it's somewhat academic, here.
+     *
      * @var boolean
      * @see self::_send_sftp_packet()
+     * @access private
      */
     private $use_request_id = false;
     /**
      * The Packet Type
      * The request ID exists in the off chance that a packet is sent out-of-order.  Of course, this library doesn't support
      * concurrent actions, so it's somewhat academic, here.
+     *
      * @var int
      * @see self::_get_sftp_packet()
+     * @access private
      */
     private $packet_type = -1;
     /**
      * Packet Buffer
+     *
      * @var string
      * @see self::_get_sftp_packet()
+     * @access private
      */
     private $packet_buffer = '';
     /**
      * Extensions supported by the server
+     *
      * @var array
      * @see self::_initChannel()
+     * @access private
      */
     private $extensions = [];
     /**
      * Server SFTP version
+     *
      * @var int
      * @see self::_initChannel()
+     * @access private
      */
     private $version;
     /**
      * Default Server SFTP version
+     *
      * @var int
      * @see self::_initChannel()
+     * @access private
      */
     private $defaultVersion;
     /**
      * Preferred SFTP version
+     *
      * @var int
      * @see self::_initChannel()
+     * @access private
      */
     private $preferredVersion = 3;
     /**
      * Current working directory
+     *
      * @var string|bool
      * @see self::realpath()
      * @see self::chdir()
+     * @access private
      */
     private $pwd = false;
     /**
      * Packet Type Log
+     *
      * @see self::getLog()
      * @var array
+     * @access private
      */
     private $packet_type_log = [];
     /**
      * Packet Log
+     *
      * @see self::getLog()
      * @var array
+     * @access private
      */
     private $packet_log = [];
     /**
      * Error information
+     *
      * @see self::getSFTPErrors()
      * @see self::getLastSFTPError()
      * @var array
+     * @access private
      */
     private $sftp_errors = [];
     /**
      * Stat Cache
+     *
      * @see self::_update_stat_cache()
      * @see self::_remove_from_stat_cache()
      * @see self::_query_stat_cache()
      * @var array
+     * @access private
      */
     private $stat_cache = [];
     /**
      * Max SFTP Packet Size
+     *
      * @see self::__construct()
      * @see self::get()
      * @var int
+     * @access private
      */
     private $max_sftp_packet;
     /**
      * Stat Cache Flag
+     *
      * @see self::disableStatCache()
      * @see self::enableStatCache()
      * @var bool
+     * @access private
      */
     private $use_stat_cache = true;
     /**
      * Sort Options
+     *
      * @see self::_comparator()
      * @see self::setListOrder()
      * @var array
+     * @access private
      */
     protected $sortOptions = [];
     /**
      * Canonicalization Flag
+     *
      * @see self::enablePathCanonicalization()
      * @see self::disablePathCanonicalization()
      * @see self::realpath()
      * @var bool
+     * @access private
      */
     private $canonicalize_paths = true;
     /**
      * Request Buffers
+     *
      * @see self::_get_sftp_packet()
      * @var array
+     * @access private
      */
     private $requestBuffer = [];
     /**
      * Preserve timestamps on file downloads / uploads
+     *
      * @see self::get()
      * @see self::put()
      * @var bool
+     * @access private
      */
     private $preserveTime = false;
     /**
      * Arbitrary Length Packets Flag
      * 256 * 1024 bytes (SFTP_MAX_MSG_LENGTH from OpenSSH's sftp-common.h)
+     *
      * @see self::enableArbitraryLengthPackets()
      * @see self::_get_sftp_packet()
      * @var bool
+     * @access private
      */
     private $allow_arbitrary_length_packets = false;
     /**
      * Was the last packet due to the channels being closed or not?
+     *
      * @see self::get()
      * @see self::get_sftp_packet()
      * @var bool
+     * @access private
      */
     private $channel_close = false;
     /**
      * Has the SFTP channel been partially negotiated?
+     *
      * @var bool
+     * @access private
      */
     private $partial_init = false;
-    /** @var int */
-    private $queueSize = 32;
-    /** @var int */
-    private $uploadQueueSize = 1024;
     /**
      * Default Constructor.
+     *
      * Connects to an SFTP server
+     *
      * @param string $host
      * @param int $port
      * @param int $timeout
+     * @access public
      */
     public function __construct($host, $port = 22, $timeout = 10)
+    {
         parent::__construct($host, $port, $timeout);
         $this->max_sftp_packet = 1 << 15;
+        $this->packet_types = [
+ => 'NET_SFTP_INIT',
+ => 'NET_SFTP_VERSION',
+ => 'NET_SFTP_OPEN',
+ => 'NET_SFTP_CLOSE',
+ => 'NET_SFTP_READ',
+ => 'NET_SFTP_WRITE',
+ => 'NET_SFTP_LSTAT',
+ => 'NET_SFTP_SETSTAT',
+=> 'NET_SFTP_FSETSTAT',
+=> 'NET_SFTP_OPENDIR',
+=> 'NET_SFTP_READDIR',
+=> 'NET_SFTP_REMOVE',
+=> 'NET_SFTP_MKDIR',
+=> 'NET_SFTP_RMDIR',
+=> 'NET_SFTP_REALPATH',
+=> 'NET_SFTP_STAT',
+=> 'NET_SFTP_RENAME',
+=> 'NET_SFTP_READLINK',
+=> 'NET_SFTP_SYMLINK',
+=> 'NET_SFTP_LINK',
+=> 'NET_SFTP_STATUS',
+=> 'NET_SFTP_HANDLE',
+=> 'NET_SFTP_DATA',
+=> 'NET_SFTP_NAME',
+=> 'NET_SFTP_ATTRS',
+=> 'NET_SFTP_EXTENDED'
+        ];
+        $this->status_codes = [
+=> 'NET_SFTP_STATUS_OK',
+=> 'NET_SFTP_STATUS_EOF',
+=> 'NET_SFTP_STATUS_NO_SUCH_FILE',
+=> 'NET_SFTP_STATUS_PERMISSION_DENIED',
+=> 'NET_SFTP_STATUS_FAILURE',
+=> 'NET_SFTP_STATUS_BAD_MESSAGE',
+=> 'NET_SFTP_STATUS_NO_CONNECTION',
+=> 'NET_SFTP_STATUS_CONNECTION_LOST',
+=> 'NET_SFTP_STATUS_OP_UNSUPPORTED',
+=> 'NET_SFTP_STATUS_INVALID_HANDLE',
+=> 'NET_SFTP_STATUS_NO_SUCH_PATH',
+=> 'NET_SFTP_STATUS_FILE_ALREADY_EXISTS',
+=> 'NET_SFTP_STATUS_WRITE_PROTECT',
+=> 'NET_SFTP_STATUS_NO_MEDIA',
+=> 'NET_SFTP_STATUS_NO_SPACE_ON_FILESYSTEM',
+=> 'NET_SFTP_STATUS_QUOTA_EXCEEDED',
+=> 'NET_SFTP_STATUS_UNKNOWN_PRINCIPAL',
+=> 'NET_SFTP_STATUS_LOCK_CONFLICT',
+=> 'NET_SFTP_STATUS_DIR_NOT_EMPTY',
+=> 'NET_SFTP_STATUS_NOT_A_DIRECTORY',
+=> 'NET_SFTP_STATUS_INVALID_FILENAME',
+=> 'NET_SFTP_STATUS_LINK_LOOP',
+=> 'NET_SFTP_STATUS_CANNOT_DELETE',
+=> 'NET_SFTP_STATUS_INVALID_PARAMETER',
+=> 'NET_SFTP_STATUS_FILE_IS_A_DIRECTORY',
+=> 'NET_SFTP_STATUS_BYTE_RANGE_LOCK_CONFLICT',
+=> 'NET_SFTP_STATUS_BYTE_RANGE_LOCK_REFUSED',
+=> 'NET_SFTP_STATUS_DELETE_PENDING',
+=> 'NET_SFTP_STATUS_FILE_CORRUPT',
+=> 'NET_SFTP_STATUS_OWNER_INVALID',
+=> 'NET_SFTP_STATUS_GROUP_INVALID',
+=> 'NET_SFTP_STATUS_NO_MATCHING_BYTE_RANGE_LOCK'
+        ];
+        // http://tools.ietf.org/html/draft-ietf-secsh-filexfer-13#section-7.1
+        // the order, in this case, matters quite a lot - see \phpseclib3\Net\SFTP::_parseAttributes() to understand why
+        $this->attributes = [
+x00000001 => 'NET_SFTP_ATTR_SIZE',
+x00000002 => 'NET_SFTP_ATTR_UIDGID',          // defined in SFTPv3, removed in SFTPv4+
+x00000080 => 'NET_SFTP_ATTR_OWNERGROUP',      // defined in SFTPv4+
+x00000004 => 'NET_SFTP_ATTR_PERMISSIONS',
+x00000008 => 'NET_SFTP_ATTR_ACCESSTIME',
+x00000010 => 'NET_SFTP_ATTR_CREATETIME',      // SFTPv4+
+x00000020 => 'NET_SFTP_ATTR_MODIFYTIME',
+x00000040 => 'NET_SFTP_ATTR_ACL',
+x00000100 => 'NET_SFTP_ATTR_SUBSECOND_TIMES',
+x00000200 => 'NET_SFTP_ATTR_BITS',            // SFTPv5+
+x00000400 => 'NET_SFTP_ATTR_ALLOCATION_SIZE', // SFTPv6+
+x00000800 => 'NET_SFTP_ATTR_TEXT_HINT',
+x00001000 => 'NET_SFTP_ATTR_MIME_TYPE',
+x00002000 => 'NET_SFTP_ATTR_LINK_COUNT',
+x00004000 => 'NET_SFTP_ATTR_UNTRANSLATED_NAME',
+x00008000 => 'NET_SFTP_ATTR_CTIME',
+            // 0x80000000 will yield a floating point on 32-bit systems and converting floating points to integers
+            // yields inconsistent behavior depending on how php is compiled.  so we left shift -1 (which, in
+            // two's compliment, consists of all 1 bits) by 31.  on 64-bit systems this'll yield 0xFFFFFFFF80000000.
+            // that's not a problem, however, and 'anded' and a 32-bit number, as all the leading 1 bits are ignored.
+            (-1 << 31) & 0xFFFFFFFF => 'NET_SFTP_ATTR_EXTENDED'
+        ];
+        // http://tools.ietf.org/html/draft-ietf-secsh-filexfer-04#section-6.3
+        // the flag definitions change somewhat in SFTPv5+.  if SFTPv5+ support is added to this library, maybe name
+        // the array for that $this->open5_flags and similarly alter the constant names.
+        $this->open_flags = [
+x00000001 => 'NET_SFTP_OPEN_READ',
+x00000002 => 'NET_SFTP_OPEN_WRITE',
+x00000004 => 'NET_SFTP_OPEN_APPEND',
+x00000008 => 'NET_SFTP_OPEN_CREATE',
+x00000010 => 'NET_SFTP_OPEN_TRUNCATE',
+x00000020 => 'NET_SFTP_OPEN_EXCL',
+x00000040 => 'NET_SFTP_OPEN_TEXT' // defined in SFTPv4
+        ];
+        // SFTPv5+ changed the flags up:
+        // https://datatracker.ietf.org/doc/html/draft-ietf-secsh-filexfer-13#section-8.1.1.3
+        $this->open_flags5 = [
+            // when SSH_FXF_ACCESS_DISPOSITION is a 3 bit field that controls how the file is opened
+x00000000 => 'NET_SFTP_OPEN_CREATE_NEW',
+x00000001 => 'NET_SFTP_OPEN_CREATE_TRUNCATE',
+x00000002 => 'NET_SFTP_OPEN_OPEN_EXISTING',
+x00000003 => 'NET_SFTP_OPEN_OPEN_OR_CREATE',
+x00000004 => 'NET_SFTP_OPEN_TRUNCATE_EXISTING',
+            // the rest of the flags are not supported
+x00000008 => 'NET_SFTP_OPEN_APPEND_DATA', // "the offset field of SS_FXP_WRITE requests is ignored"
+x00000010 => 'NET_SFTP_OPEN_APPEND_DATA_ATOMIC',
+x00000020 => 'NET_SFTP_OPEN_TEXT_MODE',
+x00000040 => 'NET_SFTP_OPEN_BLOCK_READ',
+x00000080 => 'NET_SFTP_OPEN_BLOCK_WRITE',
+x00000100 => 'NET_SFTP_OPEN_BLOCK_DELETE',
+x00000200 => 'NET_SFTP_OPEN_BLOCK_ADVISORY',
+x00000400 => 'NET_SFTP_OPEN_NOFOLLOW',
+x00000800 => 'NET_SFTP_OPEN_DELETE_ON_CLOSE',
+x00001000 => 'NET_SFTP_OPEN_ACCESS_AUDIT_ALARM_INFO',
+x00002000 => 'NET_SFTP_OPEN_ACCESS_BACKUP',
+x00004000 => 'NET_SFTP_OPEN_BACKUP_STREAM',
+x00008000 => 'NET_SFTP_OPEN_OVERRIDE_OWNER',
+        ];
+        // http://tools.ietf.org/html/draft-ietf-secsh-filexfer-04#section-5.2
+        // see \phpseclib3\Net\SFTP::_parseLongname() for an explanation
+        $this->file_types = [
+=> 'NET_SFTP_TYPE_REGULAR',
+=> 'NET_SFTP_TYPE_DIRECTORY',
+=> 'NET_SFTP_TYPE_SYMLINK',
+=> 'NET_SFTP_TYPE_SPECIAL',
+=> 'NET_SFTP_TYPE_UNKNOWN',
+            // the following types were first defined for use in SFTPv5+
+            // http://tools.ietf.org/html/draft-ietf-secsh-filexfer-05#section-5.2
+=> 'NET_SFTP_TYPE_SOCKET',
+=> 'NET_SFTP_TYPE_CHAR_DEVICE',
+=> 'NET_SFTP_TYPE_BLOCK_DEVICE',
+=> 'NET_SFTP_TYPE_FIFO'
+        ];
+        $this->define_array(
+            $this->packet_types,
+            $this->status_codes,
+            $this->attributes,
+            $this->open_flags,
+            $this->open_flags5,
+            $this->file_types
+        );
-        if (defined('NET_SFTP_QUEUE_SIZE')) {
+        if (!defined('NET_SFTP_QUEUE_SIZE')) {
-            $this->queueSize = NET_SFTP_QUEUE_SIZE;
+            define('NET_SFTP_QUEUE_SIZE', 32);
+        }
-        if (defined('NET_SFTP_UPLOAD_QUEUE_SIZE')) {
+        if (!defined('NET_SFTP_UPLOAD_QUEUE_SIZE')) {
-            $this->uploadQueueSize = NET_SFTP_UPLOAD_QUEUE_SIZE;
+            define('NET_SFTP_UPLOAD_QUEUE_SIZE', 1024);
+        }
+    }
     /**
      * Check a few things before SFTP functions are called
+     *
      * @return bool
+     * @access public
      */
     private function precheck()
+    {
         if (!($this->bitmap & SSH2::MASK_LOGIN)) {
             return false;
     /**
      * Partially initialize an SFTP connection
+     *
      * @throws \UnexpectedValueException on receipt of unexpected packets
      * @return bool
+     * @access public
      */
     private function partial_init_sftp_connection()
+    {
         $this->window_size_server_to_client[self::CHANNEL] = $this->window_size;
         $packet = Strings::packSSH2(
             'CsN3',
-            SSH2MessageType::CHANNEL_OPEN,
+            NET_SSH2_MSG_CHANNEL_OPEN,
             'session',
             self::CHANNEL,
             $this->window_size,
 x4000
         );
         $this->send_binary_packet($packet);
-        $this->channel_status[self::CHANNEL] = SSH2MessageType::CHANNEL_OPEN;
+        $this->channel_status[self::CHANNEL] = NET_SSH2_MSG_CHANNEL_OPEN;
         $response = $this->get_channel_packet(self::CHANNEL, true);
         if ($response === true && $this->isTimeout()) {
             return false;
+        }
         $packet = Strings::packSSH2(
             'CNsbs',
-            SSH2MessageType::CHANNEL_REQUEST,
+            NET_SSH2_MSG_CHANNEL_REQUEST,
             $this->server_channels[self::CHANNEL],
             'subsystem',
             true,
             'sftp'
         );
         $this->send_binary_packet($packet);
-        $this->channel_status[self::CHANNEL] = SSH2MessageType::CHANNEL_REQUEST;
+        $this->channel_status[self::CHANNEL] = NET_SSH2_MSG_CHANNEL_REQUEST;
         $response = $this->get_channel_packet(self::CHANNEL, true);
         if ($response === false) {
             // from PuTTY's psftp.exe
             $command = "test -x /usr/lib/sftp-server && exec /usr/lib/sftp-server\n" .
                        "exec sftp-server";
             // we don't do $this->exec($command, false) because exec() operates on a different channel and plus the SSH_MSG_CHANNEL_OPEN that exec() does
             // is redundant
             $packet = Strings::packSSH2(
                 'CNsCs',
-                SSH2MessageType::CHANNEL_REQUEST,
+                NET_SSH2_MSG_CHANNEL_REQUEST,
                 $this->server_channels[self::CHANNEL],
                 'exec',
 ,
                 $command
             );
             $this->send_binary_packet($packet);
-            $this->channel_status[self::CHANNEL] = SSH2MessageType::CHANNEL_REQUEST;
+            $this->channel_status[self::CHANNEL] = NET_SSH2_MSG_CHANNEL_REQUEST;
             $response = $this->get_channel_packet(self::CHANNEL, true);
             if ($response === false) {
                 return false;
+            }
         } elseif ($response === true && $this->isTimeout()) {
             return false;
+        }
-        $this->channel_status[self::CHANNEL] = SSH2MessageType::CHANNEL_DATA;
+        $this->channel_status[self::CHANNEL] = NET_SSH2_MSG_CHANNEL_DATA;
-        $this->send_sftp_packet(SFTPPacketType::INIT, "\0\0\0\3");
+        $this->send_sftp_packet(NET_SFTP_INIT, "\0\0\0\3");
         $response = $this->get_sftp_packet();
-        if ($this->packet_type != SFTPPacketType::VERSION) {
+        if ($this->packet_type != NET_SFTP_VERSION) {
-            throw new \UnexpectedValueException('Expected PacketType::VERSION. '
+            throw new \UnexpectedValueException('Expected NET_SFTP_VERSION. '
                                               . 'Got packet type: ' . $this->packet_type);
+        }
         $this->use_request_id = true;
     /**
      * (Re)initializes the SFTP channel
+     *
      * @return bool
+     * @access private
      */
     private function init_sftp_connection()
+    {
         if (!$this->partial_init && !$this->partial_init_sftp_connection()) {
             return false;
                     if ($ver === $this->version) {
                         break;
+                    }
                     $this->version = (int) $ver;
                     $packet = Strings::packSSH2('ss', 'version-select', "$ver");
-                    $this->send_sftp_packet(SFTPPacketType::EXTENDED, $packet);
+                    $this->send_sftp_packet(NET_SFTP_EXTENDED, $packet);
                     $response = $this->get_sftp_packet();
-                    if ($this->packet_type != SFTPPacketType::STATUS) {
+                    if ($this->packet_type != NET_SFTP_STATUS) {
-                        throw new \UnexpectedValueException('Expected PacketType::STATUS. '
+                        throw new \UnexpectedValueException('Expected NET_SFTP_STATUS. '
                             . 'Got packet type: ' . $this->packet_type);
+                    }
                     list($status) = Strings::unpackSSH2('N', $response);
-                    if ($status != StatusCode::OK) {
+                    if ($status != NET_SFTP_STATUS_OK) {
                         $this->logError($response, $status);
-                        throw new \UnexpectedValueException('Expected StatusCode::OK. '
+                        throw new \UnexpectedValueException('Expected NET_SFTP_STATUS_OK. '
                             . ' Got ' . $status);
+                    }
                     break;
+                }
+            }
+    }
     /**
      * Disable the stat cache
+     *
+     * @access public
      */
     public function disableStatCache()
+    {
         $this->use_stat_cache = false;
+    }
     /**
      * Enable the stat cache
+     *
+     * @access public
      */
     public function enableStatCache()
+    {
         $this->use_stat_cache = true;
+    }
     /**
      * Clear the stat cache
+     *
+     * @access public
      */
     public function clearStatCache()
+    {
         $this->stat_cache = [];
+    }
     /**
      * Enable path canonicalization
+     *
+     * @access public
      */
     public function enablePathCanonicalization()
+    {
         $this->canonicalize_paths = true;
+    }
     /**
      * Enable path canonicalization
+     *
+     * @access public
      */
     public function disablePathCanonicalization()
+    {
         $this->canonicalize_paths = false;
+    }
     /**
      * Enable arbitrary length packets
+     *
+     * @access public
      */
     public function enableArbitraryLengthPackets()
+    {
         $this->allow_arbitrary_length_packets = true;
+    }
     /**
      * Disable arbitrary length packets
+     *
+     * @access public
      */
     public function disableArbitraryLengthPackets()
+    {
         $this->allow_arbitrary_length_packets = false;
+    }
     /**
      * Returns the current directory name
+     *
      * @return string|bool
+     * @access public
      */
     public function pwd()
+    {
         if (!$this->precheck()) {
             return false;
     /**
      * Logs errors
+     *
      * @param string $response
      * @param int $status
+     * @access private
      */
     private function logError($response, $status = -1)
+    {
         if ($status == -1) {
             list($status) = Strings::unpackSSH2('N', $response);
+        }
-        $error = StatusCode::getConstantNameByValue($status);
+        $error = $this->status_codes[$status];
         if ($this->version > 2) {
             list($message) = Strings::unpackSSH2('s', $response);
             $this->sftp_errors[] = "$error: $message";
         } else {
      * @see self::chdir()
      * @see self::disablePathCanonicalization()
      * @param string $path
      * @throws \UnexpectedValueException on receipt of unexpected packets
      * @return mixed
+     * @access public
      */
     public function realpath($path)
+    {
         if ($this->precheck() === false) {
             return false;
             return $path;
+        }
         if ($this->pwd === true) {
             // http://tools.ietf.org/html/draft-ietf-secsh-filexfer-13#section-8.9
-            $this->send_sftp_packet(SFTPPacketType::REALPATH, Strings::packSSH2('s', $path));
+            $this->send_sftp_packet(NET_SFTP_REALPATH, Strings::packSSH2('s', $path));
             $response = $this->get_sftp_packet();
             switch ($this->packet_type) {
-                case SFTPPacketType::NAME:
+                case NET_SFTP_NAME:
                     // although SSH_FXP_NAME is implemented differently in SFTPv3 than it is in SFTPv4+, the following
                     // should work on all SFTP versions since the only part of the SSH_FXP_NAME packet the following looks
                     // at is the first part and that part is defined the same in SFTP versions 3 through 6.
                     list(, $filename) = Strings::unpackSSH2('Ns', $response);
                     return $filename;
-                case SFTPPacketType::STATUS:
+                case NET_SFTP_STATUS:
                     $this->logError($response);
                     return false;
                 default:
-                    throw new \UnexpectedValueException('Expected PacketType::NAME or PacketType::STATUS. '
+                    throw new \UnexpectedValueException('Expected NET_SFTP_NAME or NET_SFTP_STATUS. '
                                                       . 'Got packet type: ' . $this->packet_type);
+            }
+        }
         if (!strlen($path) || $path[0] != '/') {
      * Changes the current directory
+     *
      * @param string $dir
      * @throws \UnexpectedValueException on receipt of unexpected packets
      * @return bool
+     * @access public
      */
     public function chdir($dir)
+    {
         if (!$this->precheck()) {
             return false;
         // we could do a stat on the alleged $dir to see if it's a directory but that doesn't tell us
         // the currently logged in user has the appropriate permissions or not. maybe you could see if
         // the file's uid / gid match the currently logged in user's uid / gid but how there's no easy
         // way to get those with SFTP
-        $this->send_sftp_packet(SFTPPacketType::OPENDIR, Strings::packSSH2('s', $dir));
+        $this->send_sftp_packet(NET_SFTP_OPENDIR, Strings::packSSH2('s', $dir));
         // see \phpseclib3\Net\SFTP::nlist() for a more thorough explanation of the following
         $response = $this->get_sftp_packet();
         switch ($this->packet_type) {
-            case SFTPPacketType::HANDLE:
+            case NET_SFTP_HANDLE:
                 $handle = substr($response, 4);
                 break;
-            case SFTPPacketType::STATUS:
+            case NET_SFTP_STATUS:
                 $this->logError($response);
                 return false;
             default:
-                throw new \UnexpectedValueException('Expected PacketType::HANDLE or PacketType::STATUS' .
+                throw new \UnexpectedValueException('Expected NET_SFTP_HANDLE or NET_SFTP_STATUS' .
                                                     'Got packet type: ' . $this->packet_type);
+        }
         if (!$this->close_handle($handle)) {
             return false;
      * Returns a list of files in the given directory
+     *
      * @param string $dir
      * @param bool $recursive
      * @return array|false
+     * @access public
      */
     public function nlist($dir = '.', $recursive = false)
+    {
         return $this->nlist_helper($dir, $recursive, '');
+    }
+     *
      * @param string $dir
      * @param bool $recursive
      * @param string $relativeDir
      * @return array|false
+     * @access private
      */
     private function nlist_helper($dir, $recursive, $relativeDir)
+    {
         $files = $this->readlist($dir, false);
      * Returns a detailed list of files in the given directory
+     *
      * @param string $dir
      * @param bool $recursive
      * @return array|false
+     * @access public
      */
     public function rawlist($dir = '.', $recursive = false)
+    {
         $files = $this->readlist($dir, true);
         if (!$recursive || $files === false) {
             if ($key != '.' && $key != '..') {
                 if ($this->use_stat_cache) {
                     $is_directory = is_array($this->query_stat_cache($this->realpath($dir . '/' . $key)));
                 } else {
                     $stat = $this->lstat($dir . '/' . $key);
-                    $is_directory = $stat && $stat['type'] === FileType::DIRECTORY;
+                    $is_directory = $stat && $stat['type'] === NET_SFTP_TYPE_DIRECTORY;
+                }
+            }
             if ($is_directory) {
                 $depth++;
+     *
      * @param string $dir
      * @param bool $raw
      * @return array|false
      * @throws \UnexpectedValueException on receipt of unexpected packets
+     * @access private
      */
     private function readlist($dir, $raw = true)
+    {
         if (!$this->precheck()) {
             return false;
         if ($dir === false) {
             return false;
+        }
         // http://tools.ietf.org/html/draft-ietf-secsh-filexfer-13#section-8.1.2
-        $this->send_sftp_packet(SFTPPacketType::OPENDIR, Strings::packSSH2('s', $dir));
+        $this->send_sftp_packet(NET_SFTP_OPENDIR, Strings::packSSH2('s', $dir));
         $response = $this->get_sftp_packet();
         switch ($this->packet_type) {
-            case SFTPPacketType::HANDLE:
+            case NET_SFTP_HANDLE:
                 // http://tools.ietf.org/html/draft-ietf-secsh-filexfer-13#section-9.2
                 // since 'handle' is the last field in the SSH_FXP_HANDLE packet, we'll just remove the first four bytes that
                 // represent the length of the string and leave it at that
                 $handle = substr($response, 4);
                 break;
-            case SFTPPacketType::STATUS:
+            case NET_SFTP_STATUS:
                 // presumably SSH_FX_NO_SUCH_FILE or SSH_FX_PERMISSION_DENIED
                 $this->logError($response);
                 return false;
             default:
-                throw new \UnexpectedValueException('Expected PacketType::HANDLE or PacketType::STATUS. '
+                throw new \UnexpectedValueException('Expected NET_SFTP_HANDLE or NET_SFTP_STATUS. '
                                                   . 'Got packet type: ' . $this->packet_type);
+        }
         $this->update_stat_cache($dir, []);
         $contents = [];
         while (true) {
             // http://tools.ietf.org/html/draft-ietf-secsh-filexfer-13#section-8.2.2
             // why multiple SSH_FXP_READDIR packets would be sent when the response to a single one can span arbitrarily many
             // SSH_MSG_CHANNEL_DATA messages is not known to me.
-            $this->send_sftp_packet(SFTPPacketType::READDIR, Strings::packSSH2('s', $handle));
+            $this->send_sftp_packet(NET_SFTP_READDIR, Strings::packSSH2('s', $handle));
             $response = $this->get_sftp_packet();
             switch ($this->packet_type) {
-                case SFTPPacketType::NAME:
+                case NET_SFTP_NAME:
                     list($count) = Strings::unpackSSH2('N', $response);
                     for ($i = 0; $i < $count; $i++) {
                         list($shortname) = Strings::unpackSSH2('s', $response);
                         // SFTPv4 "removed the long filename from the names structure-- it can now be
                         //         built from information available in the attrs structure."
                                 $attributes['type'] = $fileType;
+                            }
+                        }
                         $contents[$shortname] = $attributes + ['filename' => $shortname];
-                        if (isset($attributes['type']) && $attributes['type'] == FileType::DIRECTORY && ($shortname != '.' && $shortname != '..')) {
+                        if (isset($attributes['type']) && $attributes['type'] == NET_SFTP_TYPE_DIRECTORY && ($shortname != '.' && $shortname != '..')) {
                             $this->update_stat_cache($dir . '/' . $shortname, []);
                         } else {
                             if ($shortname == '..') {
                                 $temp = $this->realpath($dir . '/..') . '/.';
                             } else {
+                        }
                         // SFTPv6 has an optional boolean end-of-list field, but we'll ignore that, since the
                         // final SSH_FXP_STATUS packet should tell us that, already.
+                    }
                     break;
-                case SFTPPacketType::STATUS:
+                case NET_SFTP_STATUS:
                     list($status) = Strings::unpackSSH2('N', $response);
-                    if ($status != StatusCode::EOF) {
+                    if ($status != NET_SFTP_STATUS_EOF) {
                         $this->logError($response, $status);
                         return false;
+                    }
                     break 2;
                 default:
-                    throw new \UnexpectedValueException('Expected PacketType::NAME or PacketType::STATUS. '
+                    throw new \UnexpectedValueException('Expected NET_SFTP_NAME or NET_SFTP_STATUS. '
                                                       . 'Got packet type: ' . $this->packet_type);
+            }
+        }
         if (!$this->close_handle($handle)) {
      * Intended for use with uasort()
+     *
      * @param array $a
      * @param array $b
      * @return int
+     * @access private
      */
     private function comparator($a, $b)
+    {
         switch (true) {
             case $a['filename'] === '.' || $b['filename'] === '.':
             case $a['filename'] === '..' || $b['filename'] === '..':
                 if ($a['filename'] === $b['filename']) {
                     return 0;
+                }
                 return $a['filename'] === '..' ? -1 : 1;
-            case isset($a['type']) && $a['type'] === FileType::DIRECTORY:
+            case isset($a['type']) && $a['type'] === NET_SFTP_TYPE_DIRECTORY:
                 if (!isset($b['type'])) {
                     return 1;
+                }
                 if ($b['type'] !== $a['type']) {
                     return -1;
+                }
                 break;
-            case isset($b['type']) && $b['type'] === FileType::DIRECTORY:
+            case isset($b['type']) && $b['type'] === NET_SFTP_TYPE_DIRECTORY:
                 return 1;
+        }
         foreach ($this->sortOptions as $sort => $order) {
             if (!isset($a[$sort]) || !isset($b[$sort])) {
                 if (isset($a[$sort])) {
      *    Separates directories from files but doesn't do any sorting beyond that
      * $sftp->setListOrder();
      *    Don't do any sort of sorting
+     *
      * @param string ...$args
+     * @access public
      */
     public function setListOrder(...$args)
+    {
         $this->sortOptions = [];
         if (empty($args)) {
     /**
      * Save files / directories to cache
+     *
      * @param string $path
      * @param mixed $value
+     * @access private
      */
     private function update_stat_cache($path, $value)
+    {
         if ($this->use_stat_cache === false) {
             return;
     /**
      * Remove files / directories from cache
+     *
      * @param string $path
      * @return bool
+     * @access private
      */
     private function remove_from_stat_cache($path)
+    {
         $dirs = explode('/', preg_replace('#^/|/(?=/)|/$#', '', $path));
+     *
      * Mainly used by file_exists
+     *
      * @param string $path
      * @return mixed
+     * @access private
      */
     private function query_stat_cache($path)
+    {
         $dirs = explode('/', preg_replace('#^/|/(?=/)|/$#', '', $path));
+     *
      * Returns an array on success and false otherwise.
+     *
      * @param string $filename
      * @return array|false
+     * @access public
      */
     public function stat($filename)
+    {
         if (!$this->precheck()) {
             return false;
             if (is_object($result) && isset($result->stat)) {
                 return $result->stat;
+            }
+        }
-        $stat = $this->stat_helper($filename, SFTPPacketType::STAT);
+        $stat = $this->stat_helper($filename, NET_SFTP_STAT);
         if ($stat === false) {
             $this->remove_from_stat_cache($filename);
             return false;
+        }
         if (isset($stat['type'])) {
-            if ($stat['type'] == FileType::DIRECTORY) {
+            if ($stat['type'] == NET_SFTP_TYPE_DIRECTORY) {
                 $filename .= '/.';
+            }
             $this->update_stat_cache($filename, (object) ['stat' => $stat]);
             return $stat;
+        }
         $pwd = $this->pwd;
         $stat['type'] = $this->chdir($filename) ?
-            FileType::DIRECTORY :
+            NET_SFTP_TYPE_DIRECTORY :
-            FileType::REGULAR;
+            NET_SFTP_TYPE_REGULAR;
         $this->pwd = $pwd;
-        if ($stat['type'] == FileType::DIRECTORY) {
+        if ($stat['type'] == NET_SFTP_TYPE_DIRECTORY) {
             $filename .= '/.';
+        }
         $this->update_stat_cache($filename, (object) ['stat' => $stat]);
         return $stat;
+     *
      * Returns an array on success and false otherwise.
+     *
      * @param string $filename
      * @return array|false
+     * @access public
      */
     public function lstat($filename)
+    {
         if (!$this->precheck()) {
             return false;
             if (is_object($result) && isset($result->lstat)) {
                 return $result->lstat;
+            }
+        }
-        $lstat = $this->stat_helper($filename, SFTPPacketType::LSTAT);
+        $lstat = $this->stat_helper($filename, NET_SFTP_LSTAT);
         if ($lstat === false) {
             $this->remove_from_stat_cache($filename);
             return false;
+        }
         if (isset($lstat['type'])) {
-            if ($lstat['type'] == FileType::DIRECTORY) {
+            if ($lstat['type'] == NET_SFTP_TYPE_DIRECTORY) {
                 $filename .= '/.';
+            }
             $this->update_stat_cache($filename, (object) ['lstat' => $lstat]);
             return $lstat;
+        }
-        $stat = $this->stat_helper($filename, SFTPPacketType::STAT);
+        $stat = $this->stat_helper($filename, NET_SFTP_STAT);
         if ($lstat != $stat) {
-            $lstat = array_merge($lstat, ['type' => FileType::SYMLINK]);
+            $lstat = array_merge($lstat, ['type' => NET_SFTP_TYPE_SYMLINK]);
             $this->update_stat_cache($filename, (object) ['lstat' => $lstat]);
             return $stat;
+        }
         $pwd = $this->pwd;
         $lstat['type'] = $this->chdir($filename) ?
-            FileType::DIRECTORY :
+            NET_SFTP_TYPE_DIRECTORY :
-            FileType::REGULAR;
+            NET_SFTP_TYPE_REGULAR;
         $this->pwd = $pwd;
-        if ($lstat['type'] == FileType::DIRECTORY) {
+        if ($lstat['type'] == NET_SFTP_TYPE_DIRECTORY) {
             $filename .= '/.';
+        }
         $this->update_stat_cache($filename, (object) ['lstat' => $lstat]);
         return $lstat;
     /**
      * Returns general information about a file or symbolic link
+     *
      * Determines information without calling \phpseclib3\Net\SFTP::realpath().
-     * The second parameter can be either PacketType::STAT or PacketType::LSTAT.
+     * The second parameter can be either NET_SFTP_STAT or NET_SFTP_LSTAT.
+     *
      * @param string $filename
      * @param int $type
      * @throws \UnexpectedValueException on receipt of unexpected packets
      * @return array|false
+     * @access private
      */
     private function stat_helper($filename, $type)
+    {
         // SFTPv4+ adds an additional 32-bit integer field - flags - to the following:
         $packet = Strings::packSSH2('s', $filename);
         $this->send_sftp_packet($type, $packet);
         $response = $this->get_sftp_packet();
         switch ($this->packet_type) {
-            case SFTPPacketType::ATTRS:
+            case NET_SFTP_ATTRS:
                 return $this->parseAttributes($response);
-            case SFTPPacketType::STATUS:
+            case NET_SFTP_STATUS:
                 $this->logError($response);
                 return false;
+        }
-        throw new \UnexpectedValueException('Expected PacketType::ATTRS or PacketType::STATUS. '
+        throw new \UnexpectedValueException('Expected NET_SFTP_ATTRS or NET_SFTP_STATUS. '
                                           . 'Got packet type: ' . $this->packet_type);
+    }
     /**
      * Truncates a file to a given length
+     *
      * @param string $filename
      * @param int $new_size
      * @return bool
+     * @access public
      */
     public function truncate($filename, $new_size)
+    {
-        $attr = Strings::packSSH2('NQ', Attribute::SIZE, $new_size);
+        $attr = Strings::packSSH2('NQ', NET_SFTP_ATTR_SIZE, $new_size);
         return $this->setstat($filename, $attr, false);
+    }
     /**
      * @param string $filename
      * @param int $time
      * @param int $atime
      * @throws \UnexpectedValueException on receipt of unexpected packets
      * @return bool
+     * @access public
      */
     public function touch($filename, $time = null, $atime = null)
+    {
         if (!$this->precheck()) {
             return false;
         if (!isset($atime)) {
             $atime = $time;
+        }
         $attr = $this->version < 4 ?
-            pack('N3', Attribute::ACCESSTIME, $atime, $time) :
+            pack('N3', NET_SFTP_ATTR_ACCESSTIME, $atime, $time) :
-            Strings::packSSH2('NQ2', Attribute::ACCESSTIME | Attribute::MODIFYTIME, $atime, $time);
+            Strings::packSSH2('NQ2', NET_SFTP_ATTR_ACCESSTIME | NET_SFTP_ATTR_MODIFYTIME, $atime, $time);
         $packet = Strings::packSSH2('s', $filename);
         $packet .= $this->version >= 5 ?
-            pack('N2', 0, OpenFlag5::OPEN_EXISTING) :
+            pack('N2', 0, NET_SFTP_OPEN_OPEN_EXISTING) :
-            pack('N', OpenFlag::WRITE | OpenFlag::CREATE | OpenFlag::EXCL);
+            pack('N', NET_SFTP_OPEN_WRITE | NET_SFTP_OPEN_CREATE | NET_SFTP_OPEN_EXCL);
         $packet .= $attr;
-        $this->send_sftp_packet(SFTPPacketType::OPEN, $packet);
+        $this->send_sftp_packet(NET_SFTP_OPEN, $packet);
         $response = $this->get_sftp_packet();
         switch ($this->packet_type) {
-            case SFTPPacketType::HANDLE:
+            case NET_SFTP_HANDLE:
                 return $this->close_handle(substr($response, 4));
-            case SFTPPacketType::STATUS:
+            case NET_SFTP_STATUS:
                 $this->logError($response);
                 break;
             default:
-                throw new \UnexpectedValueException('Expected PacketType::HANDLE or PacketType::STATUS. '
+                throw new \UnexpectedValueException('Expected NET_SFTP_HANDLE or NET_SFTP_STATUS. '
                                                   . 'Got packet type: ' . $this->packet_type);
+        }
         return $this->setstat($filename, $attr, false);
+    }
+     *
      * @param string $filename
      * @param int|string $uid
      * @param bool $recursive
      * @return bool
+     * @access public
      */
     public function chown($filename, $uid, $recursive = false)
+    {
         /*
          quoting <https://datatracker.ietf.org/doc/html/draft-ietf-secsh-filexfer-13#section-7.5>,
        */
         $attr = $this->version < 4 ?
             // quoting <http://www.kernel.org/doc/man-pages/online/pages/man2/chown.2.html>,
             // "if the owner or group is specified as -1, then that ID is not changed"
-            pack('N3', Attribute::UIDGID, $uid, -1) :
+            pack('N3', NET_SFTP_ATTR_UIDGID, $uid, -1) :
             // quoting <https://datatracker.ietf.org/doc/html/draft-ietf-secsh-filexfer-13#section-7.5>,
             // "If either the owner or group field is zero length, the field should be
             //  considered absent, and no change should be made to that specific field
             //  during a modification operation"
-            Strings::packSSH2('Nss', Attribute::OWNERGROUP, $uid, '');
+            Strings::packSSH2('Nss', NET_SFTP_ATTR_OWNERGROUP, $uid, '');
         return $this->setstat($filename, $attr, $recursive);
+    }
     /**
+     *
      * @param string $filename
      * @param int|string $gid
      * @param bool $recursive
      * @return bool
+     * @access public
      */
     public function chgrp($filename, $gid, $recursive = false)
+    {
         $attr = $this->version < 4 ?
-            pack('N3', Attribute::UIDGID, -1, $gid) :
+            pack('N3', NET_SFTP_ATTR_UIDGID, -1, $gid) :
-            Strings::packSSH2('Nss', Attribute::OWNERGROUP, '', $gid);
+            Strings::packSSH2('Nss', NET_SFTP_ATTR_OWNERGROUP, '', $gid);
         return $this->setstat($filename, $attr, $recursive);
+    }
     /**
      * @param int $mode
      * @param string $filename
      * @param bool $recursive
      * @throws \UnexpectedValueException on receipt of unexpected packets
      * @return mixed
+     * @access public
      */
     public function chmod($mode, $filename, $recursive = false)
+    {
         if (is_string($mode) && is_int($filename)) {
             $temp = $mode;
             $mode = $filename;
             $filename = $temp;
+        }
-        $attr = pack('N2', Attribute::PERMISSIONS, $mode & 07777);
+        $attr = pack('N2', NET_SFTP_ATTR_PERMISSIONS, $mode & 07777);
         if (!$this->setstat($filename, $attr, $recursive)) {
             return false;
+        }
         if ($recursive) {
             return true;
         $filename = $this->realpath($filename);
         // rather than return what the permissions *should* be, we'll return what they actually are.  this will also
         // tell us if the file actually exists.
         // incidentally, SFTPv4+ adds an additional 32-bit integer field - flags - to the following:
         $packet = pack('Na*', strlen($filename), $filename);
-        $this->send_sftp_packet(SFTPPacketType::STAT, $packet);
+        $this->send_sftp_packet(NET_SFTP_STAT, $packet);
         $response = $this->get_sftp_packet();
         switch ($this->packet_type) {
-            case SFTPPacketType::ATTRS:
+            case NET_SFTP_ATTRS:
                 $attrs = $this->parseAttributes($response);
                 return $attrs['mode'];
-            case SFTPPacketType::STATUS:
+            case NET_SFTP_STATUS:
                 $this->logError($response);
                 return false;
+        }
-        throw new \UnexpectedValueException('Expected PacketType::ATTRS or PacketType::STATUS. '
+        throw new \UnexpectedValueException('Expected NET_SFTP_ATTRS or NET_SFTP_STATUS. '
                                           . 'Got packet type: ' . $this->packet_type);
+    }
     /**
      * Sets information about a file
      * @param string $filename
      * @param string $attr
      * @param bool $recursive
      * @throws \UnexpectedValueException on receipt of unexpected packets
      * @return bool
+     * @access private
      */
     private function setstat($filename, $attr, $recursive)
+    {
         if (!$this->precheck()) {
             return false;
             return $result;
+        }
         $packet = Strings::packSSH2('s', $filename);
         $packet .= $this->version >= 4 ?
-            pack('a*Ca*', substr($attr, 0, 4), FileType::UNKNOWN, substr($attr, 4)) :
+            pack('a*Ca*', substr($attr, 0, 4), NET_SFTP_TYPE_UNKNOWN, substr($attr, 4)) :
             $attr;
-        $this->send_sftp_packet(SFTPPacketType::SETSTAT, $packet);
+        $this->send_sftp_packet(NET_SFTP_SETSTAT, $packet);
         /*
          "Because some systems must use separate system calls to set various attributes, it is possible that a failure
           response will be returned, but yet some of the attributes may be have been successfully modified.  If possible,
           servers SHOULD avoid this situation; however, clients MUST be aware that this is possible."
           -- http://tools.ietf.org/html/draft-ietf-secsh-filexfer-13#section-8.6
         */
         $response = $this->get_sftp_packet();
-        if ($this->packet_type != SFTPPacketType::STATUS) {
+        if ($this->packet_type != NET_SFTP_STATUS) {
-            throw new \UnexpectedValueException('Expected PacketType::STATUS. '
+            throw new \UnexpectedValueException('Expected NET_SFTP_STATUS. '
                                               . 'Got packet type: ' . $this->packet_type);
+        }
         list($status) = Strings::unpackSSH2('N', $response);
-        if ($status != StatusCode::OK) {
+        if ($status != NET_SFTP_STATUS_OK) {
             $this->logError($response, $status);
             return false;
+        }
         return true;
+     *
      * @param string $path
      * @param string $attr
      * @param int $i
      * @return bool
+     * @access private
      */
     private function setstat_recursive($path, $attr, &$i)
+    {
         if (!$this->read_put_responses($i)) {
             return false;
             if (!isset($props['type'])) {
                 return false;
+            }
             $temp = $path . '/' . $filename;
-            if ($props['type'] == FileType::DIRECTORY) {
+            if ($props['type'] == NET_SFTP_TYPE_DIRECTORY) {
                 if (!$this->setstat_recursive($temp, $attr, $i)) {
                     return false;
+                }
             } else {
                 $packet = Strings::packSSH2('s', $temp);
                 $packet .= $this->version >= 4 ?
-                    pack('Ca*', FileType::UNKNOWN, $attr) :
+                    pack('Ca*', NET_SFTP_TYPE_UNKNOWN, $attr) :
                     $attr;
-                $this->send_sftp_packet(SFTPPacketType::SETSTAT, $packet);
+                $this->send_sftp_packet(NET_SFTP_SETSTAT, $packet);
                 $i++;
-                if ($i >= $this->queueSize) {
+                if ($i >= NET_SFTP_QUEUE_SIZE) {
                     if (!$this->read_put_responses($i)) {
                         return false;
+                    }
                     $i = 0;
+                }
+            }
+        }
         $packet = Strings::packSSH2('s', $path);
         $packet .= $this->version >= 4 ?
-            pack('Ca*', FileType::UNKNOWN, $attr) :
+            pack('Ca*', NET_SFTP_TYPE_UNKNOWN, $attr) :
             $attr;
-        $this->send_sftp_packet(SFTPPacketType::SETSTAT, $packet);
+        $this->send_sftp_packet(NET_SFTP_SETSTAT, $packet);
         $i++;
-        if ($i >= $this->queueSize) {
+        if ($i >= NET_SFTP_QUEUE_SIZE) {
             if (!$this->read_put_responses($i)) {
                 return false;
+            }
             $i = 0;
+        }
      * Return the target of a symbolic link
+     *
      * @param string $link
      * @throws \UnexpectedValueException on receipt of unexpected packets
      * @return mixed
+     * @access public
      */
     public function readlink($link)
+    {
         if (!$this->precheck()) {
             return false;
+        }
         $link = $this->realpath($link);
-        $this->send_sftp_packet(SFTPPacketType::READLINK, Strings::packSSH2('s', $link));
+        $this->send_sftp_packet(NET_SFTP_READLINK, Strings::packSSH2('s', $link));
         $response = $this->get_sftp_packet();
         switch ($this->packet_type) {
-            case SFTPPacketType::NAME:
+            case NET_SFTP_NAME:
                 break;
-            case SFTPPacketType::STATUS:
+            case NET_SFTP_STATUS:
                 $this->logError($response);
                 return false;
             default:
-                throw new \UnexpectedValueException('Expected PacketType::NAME or PacketType::STATUS. '
+                throw new \UnexpectedValueException('Expected NET_SFTP_NAME or NET_SFTP_STATUS. '
                                                   . 'Got packet type: ' . $this->packet_type);
+        }
         list($count) = Strings::unpackSSH2('N', $response);
         // the file isn't a symlink
+     *
      * @param string $target
      * @param string $link
      * @throws \UnexpectedValueException on receipt of unexpected packets
      * @return bool
+     * @access public
      */
     public function symlink($target, $link)
+    {
         if (!$this->precheck()) {
             return false;
            create hard links.  Also change it's packet number because many
            implementation implemented SYMLINK with the arguments reversed.
            Hopefully the new argument names make it clear which way is which.
         */
         if ($this->version == 6) {
-            $type = SFTPPacketType::LINK;
+            $type = NET_SFTP_LINK;
             $packet = Strings::packSSH2('ssC', $link, $target, 1);
         } else {
-            $type = SFTPPacketType::SYMLINK;
+            $type = NET_SFTP_SYMLINK;
             /* quoting http://bxr.su/OpenBSD/usr.bin/ssh/PROTOCOL#347 :
 .1. sftp: Reversal of arguments to SSH_FXP_SYMLINK
                When OpenSSH's sftp-server was implemented, the order of the arguments
                 Strings::packSSH2('ss', $link, $target);
+        }
         $this->send_sftp_packet($type, $packet);
         $response = $this->get_sftp_packet();
-        if ($this->packet_type != SFTPPacketType::STATUS) {
+        if ($this->packet_type != NET_SFTP_STATUS) {
-            throw new \UnexpectedValueException('Expected PacketType::STATUS. '
+            throw new \UnexpectedValueException('Expected NET_SFTP_STATUS. '
                                               . 'Got packet type: ' . $this->packet_type);
+        }
         list($status) = Strings::unpackSSH2('N', $response);
-        if ($status != StatusCode::OK) {
+        if ($status != NET_SFTP_STATUS_OK) {
             $this->logError($response, $status);
             return false;
+        }
         return true;
+     *
      * @param string $dir
      * @param int $mode
      * @param bool $recursive
      * @return bool
+     * @access public
      */
     public function mkdir($dir, $mode = -1, $recursive = false)
+    {
         if (!$this->precheck()) {
             return false;
      * Helper function for directory creation
+     *
      * @param string $dir
      * @param int $mode
      * @return bool
+     * @access private
      */
     private function mkdir_helper($dir, $mode)
+    {
         // send SSH_FXP_MKDIR without any attributes (that's what the \0\0\0\0 is doing)
-        $this->send_sftp_packet(SFTPPacketType::MKDIR, Strings::packSSH2('s', $dir) . "\0\0\0\0");
+        $this->send_sftp_packet(NET_SFTP_MKDIR, Strings::packSSH2('s', $dir) . "\0\0\0\0");
         $response = $this->get_sftp_packet();
-        if ($this->packet_type != SFTPPacketType::STATUS) {
+        if ($this->packet_type != NET_SFTP_STATUS) {
-            throw new \UnexpectedValueException('Expected PacketType::STATUS. '
+            throw new \UnexpectedValueException('Expected NET_SFTP_STATUS. '
                                               . 'Got packet type: ' . $this->packet_type);
+        }
         list($status) = Strings::unpackSSH2('N', $response);
-        if ($status != StatusCode::OK) {
+        if ($status != NET_SFTP_STATUS_OK) {
             $this->logError($response, $status);
             return false;
+        }
         if ($mode !== -1) {
      * Removes a directory.
+     *
      * @param string $dir
      * @throws \UnexpectedValueException on receipt of unexpected packets
      * @return bool
+     * @access public
      */
     public function rmdir($dir)
+    {
         if (!$this->precheck()) {
             return false;
         $dir = $this->realpath($dir);
         if ($dir === false) {
             return false;
+        }
-        $this->send_sftp_packet(SFTPPacketType::RMDIR, Strings::packSSH2('s', $dir));
+        $this->send_sftp_packet(NET_SFTP_RMDIR, Strings::packSSH2('s', $dir));
         $response = $this->get_sftp_packet();
-        if ($this->packet_type != SFTPPacketType::STATUS) {
+        if ($this->packet_type != NET_SFTP_STATUS) {
-            throw new \UnexpectedValueException('Expected PacketType::STATUS. '
+            throw new \UnexpectedValueException('Expected NET_SFTP_STATUS. '
                                               . 'Got packet type: ' . $this->packet_type);
+        }
         list($status) = Strings::unpackSSH2('N', $response);
-        if ($status != StatusCode::OK) {
+        if ($status != NET_SFTP_STATUS_OK) {
             // presumably SSH_FX_NO_SUCH_FILE or SSH_FX_PERMISSION_DENIED?
             $this->logError($response, $status);
             return false;
+        }
      * @param callable|null $progressCallback
      * @throws \UnexpectedValueException on receipt of unexpected packets
      * @throws \BadFunctionCallException if you're uploading via a callback and the callback function is invalid
      * @throws \phpseclib3\Exception\FileNotFoundException if you're uploading via a file and the file doesn't exist
      * @return bool
+     * @access public
      */
     public function put($remote_file, $data, $mode = self::SOURCE_STRING, $start = -1, $local_start = -1, $progressCallback = null)
+    {
         if (!$this->precheck()) {
             return false;
+        }
         $this->remove_from_stat_cache($remote_file);
         if ($this->version >= 5) {
-            $flags = OpenFlag5::OPEN_OR_CREATE;
+            $flags = NET_SFTP_OPEN_OPEN_OR_CREATE;
         } else {
-            $flags = OpenFlag::WRITE | OpenFlag::CREATE;
+            $flags = NET_SFTP_OPEN_WRITE | NET_SFTP_OPEN_CREATE;
-            // according to the SFTP specs, OpenFlag::APPEND should "force all writes to append data at the end of the file."
+            // according to the SFTP specs, NET_SFTP_OPEN_APPEND should "force all writes to append data at the end of the file."
             // in practice, it doesn't seem to do that.
-            //$flags|= ($mode & self::RESUME) ? OpenFlag::APPEND : OpenFlag::TRUNCATE;
+            //$flags|= ($mode & self::RESUME) ? NET_SFTP_OPEN_APPEND : NET_SFTP_OPEN_TRUNCATE;
+        }
         if ($start >= 0) {
             $offset = $start;
         } elseif ($mode & self::RESUME) {
-            // if OpenFlag::APPEND worked as it should _size() wouldn't need to be called
+            // if NET_SFTP_OPEN_APPEND worked as it should _size() wouldn't need to be called
             $size = $this->stat($remote_file)['size'];
             $offset = $size !== false ? $size : 0;
         } else {
             $offset = 0;
             if ($this->version >= 5) {
-                $flags = OpenFlag5::CREATE_TRUNCATE;
+                $flags = NET_SFTP_OPEN_CREATE_TRUNCATE;
             } else {
-                $flags |= OpenFlag::TRUNCATE;
+                $flags |= NET_SFTP_OPEN_TRUNCATE;
+            }
+        }
         $this->remove_from_stat_cache($remote_file);
         $packet = Strings::packSSH2('s', $remote_file);
         $packet .= $this->version >= 5 ?
             pack('N3', 0, $flags, 0) :
             pack('N2', $flags, 0);
-        $this->send_sftp_packet(SFTPPacketType::OPEN, $packet);
+        $this->send_sftp_packet(NET_SFTP_OPEN, $packet);
         $response = $this->get_sftp_packet();
         switch ($this->packet_type) {
-            case SFTPPacketType::HANDLE:
+            case NET_SFTP_HANDLE:
                 $handle = substr($response, 4);
                 break;
-            case SFTPPacketType::STATUS:
+            case NET_SFTP_STATUS:
                 $this->logError($response);
                 return false;
             default:
-                throw new \UnexpectedValueException('Expected PacketType::HANDLE or PacketType::STATUS. '
+                throw new \UnexpectedValueException('Expected NET_SFTP_HANDLE or NET_SFTP_STATUS. '
                                                   . 'Got packet type: ' . $this->packet_type);
+        }
         // http://tools.ietf.org/html/draft-ietf-secsh-filexfer-13#section-8.2.3
         $dataCallback = false;
                 // do nothing
                 break;
             case is_resource($data):
                 $mode = $mode & ~self::SOURCE_LOCAL_FILE;
                 $info = stream_get_meta_data($data);
-                if (isset($info['wrapper_type']) && $info['wrapper_type'] == 'PHP' && $info['stream_type'] == 'Input') {
+                if ($info['wrapper_type'] == 'PHP' && $info['stream_type'] == 'Input') {
                     $fp = fopen('php://memory', 'w+');
                     stream_copy_to_stream($data, $fp);
                     rewind($fp);
                 } else {
                     $fp = $data;
         $sent = 0;
         $size = $size < 0 ? ($size & 0x7FFFFFFF) + 0x80000000 : $size;
         $sftp_packet_size = $this->max_sftp_packet;
-        // make the SFTP packet be exactly the SFTP packet size by including the bytes in the PacketType::WRITE packets "header"
+        // make the SFTP packet be exactly the SFTP packet size by including the bytes in the NET_SFTP_WRITE packets "header"
         $sftp_packet_size -= strlen($handle) + 25;
         $i = $j = 0;
         while ($dataCallback || ($size === 0 || $sent < $size)) {
             if ($dataCallback) {
                 $temp = $dataCallback($sftp_packet_size);
+            }
             $subtemp = $offset + $sent;
             $packet = pack('Na*N3a*', strlen($handle), $handle, $subtemp / 4294967296, $subtemp, strlen($temp), $temp);
             try {
-                $this->send_sftp_packet(SFTPPacketType::WRITE, $packet, $j);
+                $this->send_sftp_packet(NET_SFTP_WRITE, $packet, $j);
             } catch (\Exception $e) {
                 if ($mode & self::SOURCE_LOCAL_FILE) {
                     fclose($fp);
+                }
                 throw $e;
                 $progressCallback($sent);
+            }
             $i++;
             $j++;
-            if ($i == $this->uploadQueueSize) {
+            if ($i == NET_SFTP_UPLOAD_QUEUE_SIZE) {
                 if (!$this->read_put_responses($i)) {
                     $i = 0;
                     break;
+                }
                 $i = 0;
+            }
             if ($this->preserveTime) {
                 $stat = stat($data);
                 $attr = $this->version < 4 ?
-                    pack('N3', Attribute::ACCESSTIME, $stat['atime'], $stat['mtime']) :
+                    pack('N3', NET_SFTP_ATTR_ACCESSTIME, $stat['atime'], $stat['time']) :
-                    Strings::packSSH2('NQ2', Attribute::ACCESSTIME | Attribute::MODIFYTIME, $stat['atime'], $stat['mtime']);
+                    Strings::packSSH2('NQ2', NET_SFTP_ATTR_ACCESSTIME | NET_SFTP_ATTR_MODIFYTIME, $stat['atime'], $stat['time']);
                 if (!$this->setstat($remote_file, $attr, false)) {
                     throw new \RuntimeException('Error setting file time');
+                }
+            }
+        }
      * SSH_FXP_WRITEs, in succession, and then reading $i responses.
+     *
      * @param int $i
      * @return bool
      * @throws \UnexpectedValueException on receipt of unexpected packets
+     * @access private
      */
     private function read_put_responses($i)
+    {
         while ($i--) {
             $response = $this->get_sftp_packet();
-            if ($this->packet_type != SFTPPacketType::STATUS) {
+            if ($this->packet_type != NET_SFTP_STATUS) {
-                throw new \UnexpectedValueException('Expected PacketType::STATUS. '
+                throw new \UnexpectedValueException('Expected NET_SFTP_STATUS. '
                                                   . 'Got packet type: ' . $this->packet_type);
+            }
             list($status) = Strings::unpackSSH2('N', $response);
-            if ($status != StatusCode::OK) {
+            if ($status != NET_SFTP_STATUS_OK) {
                 $this->logError($response, $status);
                 break;
+            }
+        }
      * Close handle
+     *
      * @param string $handle
      * @return bool
      * @throws \UnexpectedValueException on receipt of unexpected packets
+     * @access private
      */
     private function close_handle($handle)
+    {
-        $this->send_sftp_packet(SFTPPacketType::CLOSE, pack('Na*', strlen($handle), $handle));
+        $this->send_sftp_packet(NET_SFTP_CLOSE, pack('Na*', strlen($handle), $handle));
         // "The client MUST release all resources associated with the handle regardless of the status."
         //  -- http://tools.ietf.org/html/draft-ietf-secsh-filexfer-13#section-8.1.3
         $response = $this->get_sftp_packet();
-        if ($this->packet_type != SFTPPacketType::STATUS) {
+        if ($this->packet_type != NET_SFTP_STATUS) {
-            throw new \UnexpectedValueException('Expected PacketType::STATUS. '
+            throw new \UnexpectedValueException('Expected NET_SFTP_STATUS. '
                                               . 'Got packet type: ' . $this->packet_type);
+        }
         list($status) = Strings::unpackSSH2('N', $response);
-        if ($status != StatusCode::OK) {
+        if ($status != NET_SFTP_STATUS_OK) {
             $this->logError($response, $status);
             return false;
+        }
         return true;
      * @param string|bool|resource|callable $local_file
      * @param int $offset
      * @param int $length
      * @param callable|null $progressCallback
      * @throws \UnexpectedValueException on receipt of unexpected packets
-     * @return string|bool
+     * @return string|false
+     * @access public
      */
     public function get($remote_file, $local_file = false, $offset = 0, $length = -1, $progressCallback = null)
+    {
         if (!$this->precheck()) {
             return false;
             return false;
+        }
         $packet = Strings::packSSH2('s', $remote_file);
         $packet .= $this->version >= 5 ?
-            pack('N3', 0, OpenFlag5::OPEN_EXISTING, 0) :
+            pack('N3', 0, NET_SFTP_OPEN_OPEN_EXISTING, 0) :
-            pack('N2', OpenFlag::READ, 0);
+            pack('N2', NET_SFTP_OPEN_READ, 0);
-        $this->send_sftp_packet(SFTPPacketType::OPEN, $packet);
+        $this->send_sftp_packet(NET_SFTP_OPEN, $packet);
         $response = $this->get_sftp_packet();
         switch ($this->packet_type) {
-            case SFTPPacketType::HANDLE:
+            case NET_SFTP_HANDLE:
                 $handle = substr($response, 4);
                 break;
-            case SFTPPacketType::STATUS: // presumably SSH_FX_NO_SUCH_FILE or SSH_FX_PERMISSION_DENIED
+            case NET_SFTP_STATUS: // presumably SSH_FX_NO_SUCH_FILE or SSH_FX_PERMISSION_DENIED
                 $this->logError($response);
                 return false;
             default:
-                throw new \UnexpectedValueException('Expected PacketType::HANDLE or PacketType::STATUS. '
+                throw new \UnexpectedValueException('Expected NET_SFTP_HANDLE or NET_SFTP_STATUS. '
                                                   . 'Got packet type: ' . $this->packet_type);
+        }
         if (is_resource($local_file)) {
             $fp = $local_file;
         $start = $offset;
         $read = 0;
         while (true) {
             $i = 0;
-            while ($i < $this->queueSize && ($length < 0 || $read < $length)) {
+            while ($i < NET_SFTP_QUEUE_SIZE && ($length < 0 || $read < $length)) {
                 $tempoffset = $start + $read;
                 $packet_size = $length > 0 ? min($this->max_sftp_packet, $length - $read) : $this->max_sftp_packet;
                 $packet = Strings::packSSH2('sN3', $handle, $tempoffset / 4294967296, $tempoffset, $packet_size);
                 try {
-                    $this->send_sftp_packet(SFTPPacketType::READ, $packet, $i);
+                    $this->send_sftp_packet(NET_SFTP_READ, $packet, $i);
                 } catch (\Exception $e) {
                     if ($fclose_check) {
                         fclose($fp);
+                    }
                     throw $e;
                 } else {
                     $response = $this->get_sftp_packet($packets_sent - $i);
+                }
                 switch ($this->packet_type) {
-                    case SFTPPacketType::DATA:
+                    case NET_SFTP_DATA:
                         $temp = substr($response, 4);
                         $offset += strlen($temp);
                         if ($local_file === false) {
                             $content .= $temp;
                         } elseif (is_callable($local_file)) {
                         if (is_callable($progressCallback)) {
                             call_user_func($progressCallback, $offset);
+                        }
                         $temp = null;
                         break;
-                    case SFTPPacketType::STATUS:
+                    case NET_SFTP_STATUS:
                         // could, in theory, return false if !strlen($content) but we'll hold off for the time being
                         $this->logError($response);
                         $clear_responses = true; // don't break out of the loop yet, so we can read the remaining responses
                         break;
                     default:
                         if ($this->channel_close) {
                             $this->partial_init = false;
                             $this->init_sftp_connection();
                             return false;
                         } else {
-                            throw new \UnexpectedValueException('Expected PacketType::DATA or PacketType::STATUS. '
+                            throw new \UnexpectedValueException('Expected NET_SFTP_DATA or NET_SFTP_STATUS. '
                                                               . 'Got packet type: ' . $this->packet_type);
+                        }
+                }
                 $response = null;
+            }
+     *
      * @param string $path
      * @param bool $recursive
      * @return bool
      * @throws \UnexpectedValueException on receipt of unexpected packets
+     * @access public
      */
     public function delete($path, $recursive = true)
+    {
         if (!$this->precheck()) {
             return false;
         if ($path === false) {
             return false;
+        }
         // http://tools.ietf.org/html/draft-ietf-secsh-filexfer-13#section-8.3
-        $this->send_sftp_packet(SFTPPacketType::REMOVE, pack('Na*', strlen($path), $path));
+        $this->send_sftp_packet(NET_SFTP_REMOVE, pack('Na*', strlen($path), $path));
         $response = $this->get_sftp_packet();
-        if ($this->packet_type != SFTPPacketType::STATUS) {
+        if ($this->packet_type != NET_SFTP_STATUS) {
-            throw new \UnexpectedValueException('Expected PacketType::STATUS. '
+            throw new \UnexpectedValueException('Expected NET_SFTP_STATUS. '
                                               . 'Got packet type: ' . $this->packet_type);
+        }
         // if $status isn't SSH_FX_OK it's probably SSH_FX_NO_SUCH_FILE or SSH_FX_PERMISSION_DENIED
         list($status) = Strings::unpackSSH2('N', $response);
-        if ($status != StatusCode::OK) {
+        if ($status != NET_SFTP_STATUS_OK) {
             $this->logError($response, $status);
             if (!$recursive) {
                 return false;
+            }
      * Minimizes directory lookups and SSH_FXP_STATUS requests for speed.
+     *
      * @param string $path
      * @param int $i
      * @return bool
+     * @access private
      */
     private function delete_recursive($path, &$i)
+    {
         if (!$this->read_put_responses($i)) {
             return false;
         $entries = $this->readlist($path, true);
         // normally $entries would have at least . and .. but it might not if the directories
         // permissions didn't allow reading
         if (empty($entries)) {
-            $entries = [];
+            return false;
+        }
         unset($entries['.'], $entries['..']);
         foreach ($entries as $filename => $props) {
             if (!isset($props['type'])) {
                 return false;
+            }
             $temp = $path . '/' . $filename;
-            if ($props['type'] == FileType::DIRECTORY) {
+            if ($props['type'] == NET_SFTP_TYPE_DIRECTORY) {
                 if (!$this->delete_recursive($temp, $i)) {
                     return false;
+                }
             } else {
-                $this->send_sftp_packet(SFTPPacketType::REMOVE, Strings::packSSH2('s', $temp));
+                $this->send_sftp_packet(NET_SFTP_REMOVE, Strings::packSSH2('s', $temp));
                 $this->remove_from_stat_cache($temp);
                 $i++;
-                if ($i >= $this->queueSize) {
+                if ($i >= NET_SFTP_QUEUE_SIZE) {
                     if (!$this->read_put_responses($i)) {
                         return false;
+                    }
                     $i = 0;
+                }
+            }
+        }
-        $this->send_sftp_packet(SFTPPacketType::RMDIR, Strings::packSSH2('s', $path));
+        $this->send_sftp_packet(NET_SFTP_RMDIR, Strings::packSSH2('s', $path));
         $this->remove_from_stat_cache($path);
         $i++;
-        if ($i >= $this->queueSize) {
+        if ($i >= NET_SFTP_QUEUE_SIZE) {
             if (!$this->read_put_responses($i)) {
                 return false;
+            }
             $i = 0;
+        }
     /**
      * Checks whether a file or directory exists
+     *
      * @param string $path
      * @return bool
+     * @access public
      */
     public function file_exists($path)
+    {
         if ($this->use_stat_cache) {
             if (!$this->precheck()) {
     /**
      * Tells whether the filename is a directory
+     *
      * @param string $path
      * @return bool
+     * @access public
      */
     public function is_dir($path)
+    {
         $result = $this->get_stat_cache_prop($path, 'type');
         if ($result === false) {
             return false;
+        }
-        return $result === FileType::DIRECTORY;
+        return $result === NET_SFTP_TYPE_DIRECTORY;
+    }
     /**
      * Tells whether the filename is a regular file
+     *
      * @param string $path
      * @return bool
+     * @access public
      */
     public function is_file($path)
+    {
         $result = $this->get_stat_cache_prop($path, 'type');
         if ($result === false) {
             return false;
+        }
-        return $result === FileType::REGULAR;
+        return $result === NET_SFTP_TYPE_REGULAR;
+    }
     /**
      * Tells whether the filename is a symbolic link
+     *
      * @param string $path
      * @return bool
+     * @access public
      */
     public function is_link($path)
+    {
         $result = $this->get_lstat_cache_prop($path, 'type');
         if ($result === false) {
             return false;
+        }
-        return $result === FileType::SYMLINK;
+        return $result === NET_SFTP_TYPE_SYMLINK;
+    }
     /**
      * Tells whether a file exists and is readable
+     *
      * @param string $path
      * @return bool
+     * @access public
      */
     public function is_readable($path)
+    {
         if (!$this->precheck()) {
             return false;
+        }
-        $packet = Strings::packSSH2('sNN', $this->realpath($path), OpenFlag::READ, 0);
+        $packet = Strings::packSSH2('sNN', $this->realpath($path), NET_SFTP_OPEN_READ, 0);
-        $this->send_sftp_packet(SFTPPacketType::OPEN, $packet);
+        $this->send_sftp_packet(NET_SFTP_OPEN, $packet);
         $response = $this->get_sftp_packet();
         switch ($this->packet_type) {
-            case SFTPPacketType::HANDLE:
+            case NET_SFTP_HANDLE:
                 return true;
-            case SFTPPacketType::STATUS: // presumably SSH_FX_NO_SUCH_FILE or SSH_FX_PERMISSION_DENIED
+            case NET_SFTP_STATUS: // presumably SSH_FX_NO_SUCH_FILE or SSH_FX_PERMISSION_DENIED
                 return false;
             default:
-                throw new \UnexpectedValueException('Expected PacketType::HANDLE or PacketType::STATUS. '
+                throw new \UnexpectedValueException('Expected NET_SFTP_HANDLE or NET_SFTP_STATUS. '
                                                   . 'Got packet type: ' . $this->packet_type);
+        }
+    }
     /**
      * Tells whether the filename is writable
+     *
      * @param string $path
      * @return bool
+     * @access public
      */
     public function is_writable($path)
+    {
         if (!$this->precheck()) {
             return false;
+        }
-        $packet = Strings::packSSH2('sNN', $this->realpath($path), OpenFlag::WRITE, 0);
+        $packet = Strings::packSSH2('sNN', $this->realpath($path), NET_SFTP_OPEN_WRITE, 0);
-        $this->send_sftp_packet(SFTPPacketType::OPEN, $packet);
+        $this->send_sftp_packet(NET_SFTP_OPEN, $packet);
         $response = $this->get_sftp_packet();
         switch ($this->packet_type) {
-            case SFTPPacketType::HANDLE:
+            case NET_SFTP_HANDLE:
                 return true;
-            case SFTPPacketType::STATUS: // presumably SSH_FX_NO_SUCH_FILE or SSH_FX_PERMISSION_DENIED
+            case NET_SFTP_STATUS: // presumably SSH_FX_NO_SUCH_FILE or SSH_FX_PERMISSION_DENIED
                 return false;
             default:
                 throw new \UnexpectedValueException('Expected SSH_FXP_HANDLE or SSH_FXP_STATUS. '
                                                   . 'Got packet type: ' . $this->packet_type);
+        }
+     *
      * Alias of is_writable
+     *
      * @param string $path
      * @return bool
+     * @access public
      */
     public function is_writeable($path)
+    {
         return $this->is_writable($path);
+    }
     /**
      * Gets last access time of file
+     *
      * @param string $path
      * @return mixed
+     * @access public
      */
     public function fileatime($path)
+    {
         return $this->get_stat_cache_prop($path, 'atime');
+    }
     /**
      * Gets file modification time
+     *
      * @param string $path
      * @return mixed
+     * @access public
      */
     public function filemtime($path)
+    {
         return $this->get_stat_cache_prop($path, 'mtime');
+    }
     /**
      * Gets file permissions
+     *
      * @param string $path
      * @return mixed
+     * @access public
      */
     public function fileperms($path)
+    {
         return $this->get_stat_cache_prop($path, 'mode');
+    }
     /**
      * Gets file owner
+     *
      * @param string $path
      * @return mixed
+     * @access public
      */
     public function fileowner($path)
+    {
         return $this->get_stat_cache_prop($path, 'uid');
+    }
     /**
      * Gets file group
+     *
      * @param string $path
      * @return mixed
+     * @access public
      */
     public function filegroup($path)
+    {
         return $this->get_stat_cache_prop($path, 'gid');
+    }
     /**
      * Gets file size
+     *
      * @param string $path
      * @return mixed
+     * @access public
      */
     public function filesize($path)
+    {
         return $this->get_stat_cache_prop($path, 'size');
+    }
     /**
      * Gets file type
+     *
      * @param string $path
      * @return string|false
+     * @access public
      */
     public function filetype($path)
+    {
         $type = $this->get_stat_cache_prop($path, 'type');
         if ($type === false) {
             return false;
+        }
         switch ($type) {
-            case FileType::BLOCK_DEVICE:
+            case NET_SFTP_TYPE_BLOCK_DEVICE:
                 return 'block';
-            case FileType::CHAR_DEVICE:
+            case NET_SFTP_TYPE_CHAR_DEVICE:
                 return 'char';
-            case FileType::DIRECTORY:
+            case NET_SFTP_TYPE_DIRECTORY:
                 return 'dir';
-            case FileType::FIFO:
+            case NET_SFTP_TYPE_FIFO:
                 return 'fifo';
-            case FileType::REGULAR:
+            case NET_SFTP_TYPE_REGULAR:
                 return 'file';
-            case FileType::SYMLINK:
+            case NET_SFTP_TYPE_SYMLINK:
                 return 'link';
             default:
                 return false;
+        }
+    }
      * Uses cache if appropriate.
+     *
      * @param string $path
      * @param string $prop
      * @return mixed
+     * @access private
      */
     private function get_stat_cache_prop($path, $prop)
+    {
         return $this->get_xstat_cache_prop($path, $prop, 'stat');
+    }
      * Uses cache if appropriate.
+     *
      * @param string $path
      * @param string $prop
      * @return mixed
+     * @access private
      */
     private function get_lstat_cache_prop($path, $prop)
+    {
         return $this->get_xstat_cache_prop($path, $prop, 'lstat');
+    }
+     *
      * @param string $path
      * @param string $prop
      * @param string $type
      * @return mixed
+     * @access private
      */
     private function get_xstat_cache_prop($path, $prop, $type)
+    {
         if (!$this->precheck()) {
             return false;
+     *
      * @param string $oldname
      * @param string $newname
      * @return bool
      * @throws \UnexpectedValueException on receipt of unexpected packets
+     * @access public
      */
     public function rename($oldname, $newname)
+    {
         if (!$this->precheck()) {
             return false;
                    SSH_FXP_RENAME_NATIVE     0x00000004
                (none of these are currently supported) */
             $packet .= "\0\0\0\0";
+        }
-        $this->send_sftp_packet(SFTPPacketType::RENAME, $packet);
+        $this->send_sftp_packet(NET_SFTP_RENAME, $packet);
         $response = $this->get_sftp_packet();
-        if ($this->packet_type != SFTPPacketType::STATUS) {
+        if ($this->packet_type != NET_SFTP_STATUS) {
-            throw new \UnexpectedValueException('Expected PacketType::STATUS. '
+            throw new \UnexpectedValueException('Expected NET_SFTP_STATUS. '
                                               . 'Got packet type: ' . $this->packet_type);
+        }
         // if $status isn't SSH_FX_OK it's probably SSH_FX_NO_SUCH_FILE or SSH_FX_PERMISSION_DENIED
         list($status) = Strings::unpackSSH2('N', $response);
-        if ($status != StatusCode::OK) {
+        if ($status != NET_SFTP_STATUS_OK) {
             $this->logError($response, $status);
             return false;
+        }
         // don't move the stat cache entry over since this operation could very well change the
+     *
      * @param string $key
      * @param int $flags
      * @param string $response
      * @return array
+     * @access private
      */
     private function parseTime($key, $flags, &$response)
+    {
         $attr = [];
         list($attr[$key]) = Strings::unpackSSH2('Q', $response);
-        if ($flags & Attribute::SUBSECOND_TIMES) {
+        if ($flags & NET_SFTP_ATTR_SUBSECOND_TIMES) {
             list($attr[$key . '-nseconds']) = Strings::unpackSSH2('N', $response);
+        }
         return $attr;
+    }
+     *
      * See '7.  File Attributes' of draft-ietf-secsh-filexfer-13 for more info.
+     *
      * @param string $response
      * @return array
+     * @access private
      */
     protected function parseAttributes(&$response)
+    {
         if ($this->version >= 4) {
             list($flags, $attr['type']) = Strings::unpackSSH2('NC', $response);
         } else {
             list($flags) = Strings::unpackSSH2('N', $response);
+        }
-        foreach (Attribute::getConstants() as $value => $key) {
+        foreach ($this->attributes as $key => $value) {
             switch ($flags & $key) {
-                case Attribute::UIDGID:
+                case NET_SFTP_ATTR_UIDGID:
                     if ($this->version > 3) {
                         continue 2;
+                    }
                     break;
-                case Attribute::CREATETIME:
+                case NET_SFTP_ATTR_CREATETIME:
-                case Attribute::MODIFYTIME:
+                case NET_SFTP_ATTR_MODIFYTIME:
-                case Attribute::ACL:
+                case NET_SFTP_ATTR_ACL:
-                case Attribute::OWNERGROUP:
+                case NET_SFTP_ATTR_OWNERGROUP:
-                case Attribute::SUBSECOND_TIMES:
+                case NET_SFTP_ATTR_SUBSECOND_TIMES:
                     if ($this->version < 4) {
                         continue 2;
+                    }
                     break;
-                case Attribute::BITS:
+                case NET_SFTP_ATTR_BITS:
                     if ($this->version < 5) {
                         continue 2;
+                    }
                     break;
-                case Attribute::ALLOCATION_SIZE:
+                case NET_SFTP_ATTR_ALLOCATION_SIZE:
-                case Attribute::TEXT_HINT:
+                case NET_SFTP_ATTR_TEXT_HINT:
-                case Attribute::MIME_TYPE:
+                case NET_SFTP_ATTR_MIME_TYPE:
-                case Attribute::LINK_COUNT:
+                case NET_SFTP_ATTR_LINK_COUNT:
-                case Attribute::UNTRANSLATED_NAME:
+                case NET_SFTP_ATTR_UNTRANSLATED_NAME:
-                case Attribute::CTIME:
+                case NET_SFTP_ATTR_CTIME:
                     if ($this->version < 6) {
                         continue 2;
+                    }
+            }
             switch ($flags & $key) {
-                case Attribute::SIZE:             // 0x00000001
+                case NET_SFTP_ATTR_SIZE:             // 0x00000001
                     // The size attribute is defined as an unsigned 64-bit integer.
                     // The following will use floats on 32-bit platforms, if necessary.
                     // As can be seen in the BigInteger class, floats are generally
                     // IEEE 754 binary64 "double precision" on such platforms and
                     // as such can represent integers of at least 2^50 without loss
                     // of precision. Interpreted in filesize, 2^50 bytes = 1024 TiB.
                     list($attr['size']) = Strings::unpackSSH2('Q', $response);
                     break;
-                case Attribute::UIDGID: // 0x00000002 (SFTPv3 only)
+                case NET_SFTP_ATTR_UIDGID: // 0x00000002 (SFTPv3 only)
                     list($attr['uid'], $attr['gid']) = Strings::unpackSSH2('NN', $response);
                     break;
-                case Attribute::PERMISSIONS: // 0x00000004
+                case NET_SFTP_ATTR_PERMISSIONS: // 0x00000004
                     list($attr['mode']) = Strings::unpackSSH2('N', $response);
                     $fileType = $this->parseMode($attr['mode']);
                     if ($this->version < 4 && $fileType !== false) {
                         $attr += ['type' => $fileType];
+                    }
                     break;
-                case Attribute::ACCESSTIME: // 0x00000008
+                case NET_SFTP_ATTR_ACCESSTIME: // 0x00000008
                     if ($this->version >= 4) {
                         $attr += $this->parseTime('atime', $flags, $response);
                         break;
+                    }
                     list($attr['atime'], $attr['mtime']) = Strings::unpackSSH2('NN', $response);
                     break;
-                case Attribute::CREATETIME:       // 0x00000010 (SFTPv4+)
+                case NET_SFTP_ATTR_CREATETIME:       // 0x00000010 (SFTPv4+)
                     $attr += $this->parseTime('createtime', $flags, $response);
                     break;
-                case Attribute::MODIFYTIME:       // 0x00000020
+                case NET_SFTP_ATTR_MODIFYTIME:       // 0x00000020
                     $attr += $this->parseTime('mtime', $flags, $response);
                     break;
-                case Attribute::ACL:              // 0x00000040
+                case NET_SFTP_ATTR_ACL:              // 0x00000040
                     // access control list
                     // see https://datatracker.ietf.org/doc/html/draft-ietf-secsh-filexfer-04#section-5.7
                     // currently unsupported
                     list($count) = Strings::unpackSSH2('N', $response);
                     for ($i = 0; $i < $count; $i++) {
                         list($type, $flag, $mask, $who) = Strings::unpackSSH2('N3s', $result);
+                    }
                     break;
-                case Attribute::OWNERGROUP:       // 0x00000080
+                case NET_SFTP_ATTR_OWNERGROUP:       // 0x00000080
                     list($attr['owner'], $attr['$group']) = Strings::unpackSSH2('ss', $response);
                     break;
-                case Attribute::SUBSECOND_TIMES:  // 0x00000100
+                case NET_SFTP_ATTR_SUBSECOND_TIMES:  // 0x00000100
                     break;
-                case Attribute::BITS:             // 0x00000200 (SFTPv5+)
+                case NET_SFTP_ATTR_BITS:             // 0x00000200 (SFTPv5+)
                     // see https://datatracker.ietf.org/doc/html/draft-ietf-secsh-filexfer-05#section-5.8
                     // currently unsupported
                     // tells if you file is:
                     // readonly, system, hidden, case inensitive, archive, encrypted, compressed, sparse
                     // append only, immutable, sync
                     list($attrib_bits, $attrib_bits_valid) = Strings::unpackSSH2('N2', $response);
                     // if we were actually gonna implement the above it ought to be
                     // $attr['attrib-bits'] and $attr['attrib-bits-valid']
                     // eg. - instead of _
                     break;
-                case Attribute::ALLOCATION_SIZE:  // 0x00000400 (SFTPv6+)
+                case NET_SFTP_ATTR_ALLOCATION_SIZE:  // 0x00000400 (SFTPv6+)
                     // see https://datatracker.ietf.org/doc/html/draft-ietf-secsh-filexfer-13#section-7.4
                     // represents the number of bytes that the file consumes on the disk. will
                     // usually be larger than the 'size' field
                     list($attr['allocation-size']) = Strings::unpackSSH2('Q', $response);
                     break;
-                case Attribute::TEXT_HINT:        // 0x00000800
+                case NET_SFTP_ATTR_TEXT_HINT:        // 0x00000800
                     // https://datatracker.ietf.org/doc/html/draft-ietf-secsh-filexfer-13#section-7.10
                     // currently unsupported
                     // tells if file is "known text", "guessed text", "known binary", "guessed binary"
                     list($text_hint) = Strings::unpackSSH2('C', $response);
                     // the above should be $attr['text-hint']
                     break;
-                case Attribute::MIME_TYPE:        // 0x00001000
+                case NET_SFTP_ATTR_MIME_TYPE:        // 0x00001000
                     // see https://datatracker.ietf.org/doc/html/draft-ietf-secsh-filexfer-13#section-7.11
                     list($attr['mime-type']) = Strings::unpackSSH2('s', $response);
                     break;
-                case Attribute::LINK_COUNT:       // 0x00002000
+                case NET_SFTP_ATTR_LINK_COUNT:       // 0x00002000
                     // see https://datatracker.ietf.org/doc/html/draft-ietf-secsh-filexfer-13#section-7.12
                     list($attr['link-count']) = Strings::unpackSSH2('N', $response);
                     break;
-                case Attribute::UNTRANSLATED_NAME:// 0x00004000
+                case NET_SFTP_ATTR_UNTRANSLATED_NAME:// 0x00004000
                     // see https://datatracker.ietf.org/doc/html/draft-ietf-secsh-filexfer-13#section-7.13
                     list($attr['untranslated-name']) = Strings::unpackSSH2('s', $response);
                     break;
-                case Attribute::CTIME:            // 0x00008000
+                case NET_SFTP_ATTR_CTIME:            // 0x00008000
                     // 'ctime' contains the last time the file attributes were changed.  The
                     // exact meaning of this field depends on the server.
                     $attr += $this->parseTime('ctime', $flags, $response);
                     break;
-                case Attribute::EXTENDED: // 0x80000000
+                case NET_SFTP_ATTR_EXTENDED: // 0x80000000
                     list($count) = Strings::unpackSSH2('N', $response);
                     for ($i = 0; $i < $count; $i++) {
                         list($key, $value) = Strings::unpackSSH2('ss', $response);
                         $attr[$key] = $value;
+                    }
+     *
      * Quoting the SFTP RFC, "Implementations MUST NOT send bits that are not defined" but they seem to anyway
+     *
      * @param int $mode
      * @return int
+     * @access private
      */
     private function parseMode($mode)
+    {
         // values come from http://lxr.free-electrons.com/source/include/uapi/linux/stat.h#L12
         // see, also, http://linux.die.net/man/2/stat
         switch ($mode & 0170000) {// ie. 1111 0000 0000 0000
             case 0000000: // no file type specified - figure out the file type using alternative means
                 return false;
             case 0040000:
-                return FileType::DIRECTORY;
+                return NET_SFTP_TYPE_DIRECTORY;
             case 0100000:
-                return FileType::REGULAR;
+                return NET_SFTP_TYPE_REGULAR;
             case 0120000:
-                return FileType::SYMLINK;
+                return NET_SFTP_TYPE_SYMLINK;
             // new types introduced in SFTPv5+
             // http://tools.ietf.org/html/draft-ietf-secsh-filexfer-05#section-5.2
             case 0010000: // named pipe (fifo)
-                return FileType::FIFO;
+                return NET_SFTP_TYPE_FIFO;
             case 0020000: // character special
-                return FileType::CHAR_DEVICE;
+                return NET_SFTP_TYPE_CHAR_DEVICE;
             case 0060000: // block special
-                return FileType::BLOCK_DEVICE;
+                return NET_SFTP_TYPE_BLOCK_DEVICE;
             case 0140000: // socket
-                return FileType::SOCKET;
+                return NET_SFTP_TYPE_SOCKET;
             case 0160000: // whiteout
                 // "SPECIAL should be used for files that are of
                 //  a known type which cannot be expressed in the protocol"
-                return FileType::SPECIAL;
+                return NET_SFTP_TYPE_SPECIAL;
             default:
-                return FileType::UNKNOWN;
+                return NET_SFTP_TYPE_UNKNOWN;
+        }
+    }
     /**
      * Parse Longname
+     *
      * If the longname is in an unrecognized format bool(false) is returned.
+     *
      * @param string $longname
      * @return mixed
+     * @access private
      */
     private function parseLongname($longname)
+    {
         // http://en.wikipedia.org/wiki/Unix_file_types
         // http://en.wikipedia.org/wiki/Filesystem_permissions#Notation_of_traditional_Unix_permissions
         if (preg_match('#^[^/]([r-][w-][xstST-]){3}#', $longname)) {
             switch ($longname[0]) {
                 case '-':
-                    return FileType::REGULAR;
+                    return NET_SFTP_TYPE_REGULAR;
                 case 'd':
-                    return FileType::DIRECTORY;
+                    return NET_SFTP_TYPE_DIRECTORY;
                 case 'l':
-                    return FileType::SYMLINK;
+                    return NET_SFTP_TYPE_SYMLINK;
                 default:
-                    return FileType::SPECIAL;
+                    return NET_SFTP_TYPE_SPECIAL;
+            }
+        }
         return false;
+    }
      * @param string $data
      * @param int $request_id
      * @see self::_get_sftp_packet()
      * @see self::send_channel_packet()
      * @return void
+     * @access private
      */
     private function send_sftp_packet($type, $data, $request_id = 1)
+    {
         // in SSH2.php the timeout is cumulative per function call. eg. exec() will
         // timeout after 10s. but for SFTP.php it's cumulative per packet
         $start = microtime(true);
         $this->send_channel_packet(self::CHANNEL, $packet);
         $stop = microtime(true);
         if (defined('NET_SFTP_LOGGING')) {
-            $packet_type = sprintf(
+            $packet_type = '-> ' . $this->packet_types[$type] .
-                '-> %s (%ss)',
-                SFTPPacketType::getConstantNameByValue($type),
-                round($stop - $start, 4)
+                           ' (' . round($stop - $start, 4) . 's)';
-            );
             if (NET_SFTP_LOGGING == self::LOG_REALTIME) {
                 switch (PHP_SAPI) {
                     case 'cli':
                         $start = $stop = "\r\n";
                         break;
     /**
      * Resets a connection for re-use
+     *
      * @param int $reason
+     * @access private
      */
     protected function reset_connection($reason)
+    {
         parent::reset_connection($reason);
         $this->use_request_id = false;
      * There can be one SSH_MSG_CHANNEL_DATA messages containing two SFTP packets or there can be two SSH_MSG_CHANNEL_DATA
      * messages containing one SFTP packet.
+     *
      * @see self::_send_sftp_packet()
      * @return string
+     * @access private
      */
     private function get_sftp_packet($request_id = null)
+    {
         $this->channel_close = false;
         // SFTP packet length
         while (strlen($this->packet_buffer) < 4) {
             $temp = $this->get_channel_packet(self::CHANNEL, true);
             if ($temp === true) {
-                if ($this->channel_status[self::CHANNEL] === SSH2MessageType::CHANNEL_CLOSE) {
+                if ($this->channel_status[self::CHANNEL] === NET_SSH2_MSG_CHANNEL_CLOSE) {
                     $this->channel_close = true;
+                }
                 $this->packet_type = false;
                 $this->packet_buffer = '';
                 return false;
+        }
         $packet = Strings::shift($this->packet_buffer, $length);
         if (defined('NET_SFTP_LOGGING')) {
-            $packet_type = sprintf(
-                '<- %s (%ss)',
-                SFTPPacketType::getConstantNameByValue($this->packet_type),
+            $packet_type = '<- ' . $this->packet_types[$this->packet_type] .
-                round($stop - $start, 4)
+                           ' (' . round($stop - $start, 4) . 's)';
-            );
             if (NET_SFTP_LOGGING == self::LOG_REALTIME) {
                 switch (PHP_SAPI) {
                     case 'cli':
                         $start = $stop = "\r\n";
                         break;
+    }
     /**
      * Returns a log of the packets that have been sent and received.
+     *
-     * Returns a string if PacketType::LOGGING == self::LOG_COMPLEX, an array if PacketType::LOGGING == self::LOG_SIMPLE and false if !defined('NET_SFTP_LOGGING')
+     * Returns a string if NET_SFTP_LOGGING == self::LOG_COMPLEX, an array if NET_SFTP_LOGGING == self::LOG_SIMPLE and false if !defined('NET_SFTP_LOGGING')
+     *
+     * @access public
      * @return array|string
      */
     public function getSFTPLog()
+    {
         if (!defined('NET_SFTP_LOGGING')) {
     /**
      * Returns all errors
+     *
      * @return array
+     * @access public
      */
     public function getSFTPErrors()
+    {
         return $this->sftp_errors;
+    }
     /**
      * Returns the last error
+     *
      * @return string
+     * @access public
      */
     public function getLastSFTPError()
+    {
         return count($this->sftp_errors) ? $this->sftp_errors[count($this->sftp_errors) - 1] : '';
+    }
     /**
      * Get supported SFTP versions
+     *
      * @return array
+     * @access public
      */
     public function getSupportedVersions()
+    {
         if (!($this->bitmap & SSH2::MASK_LOGIN)) {
             return false;
     /**
      * Get supported SFTP versions
+     *
      * @return int|false
+     * @access public
      */
     public function getNegotiatedVersion()
+    {
         if (!$this->precheck()) {
             return false;
      * If you're preferred version isn't supported then the highest supported
      * version of SFTP will be utilized. Set to null or false or int(0) to
      * unset the preferred version
+     *
      * @param int $version
+     * @access public
      */
     public function setPreferredVersion($version)
+    {
         $this->preferredVersion = $version;
+    }
     /**
      * Disconnect
+     *
      * @param int $reason
      * @return false
+     * @access protected
      */
     protected function disconnect_helper($reason)
+    {
         $this->pwd = false;
         return parent::disconnect_helper($reason);
+    }
     /**
      * Enable Date Preservation
+     *
+     * @access public
      */
     public function enableDatePreservation()
+    {
         $this->preserveTime = true;
+    }
     /**
      * Disable Date Preservation
+     *
+     * @access public
      */
     public function disableDatePreservation()
+    {
         $this->preserveTime = false;
+    }

Subversion Repositories oidplus

oidplus/trunk/vendor/phpseclib/phpseclib/phpseclib/Net/SFTP.php – Rev 846 → 874