ruby_smb 3.1.1 → 3.1.2

data/lib/ruby_smb/server/share/provider/virtual_disk/virtual_pathname.rb

@@ -0,0 +1,196 @@
+module RubySMB
+  class Server
+    module Share
+      module Provider
+        class VirtualDisk < Disk
+          # This object emulates Ruby's builtin Pathname object but uses a virtual file system instead of the real local
+          # one.
+          class VirtualPathname
+            SEPARATOR = File::SEPARATOR
+            # see: https://ruby-doc.org/stdlib-3.1.1/libdoc/pathname/rdoc/Pathname.html
+            STAT_METHODS = %i[
+              atime
+              birthtime
+              blockdev?
+              chardev?
+              ctime
+              directory?
+              executable?
+              file?
+              ftype
+              grpowned?
+              mtime
+              owned?
+              pipe?
+              readable?
+              setgid?
+              setuid?
+              size
+              socket?
+              sticky?
+              symlink?
+              world_readable?
+              world_writable?
+              writable?
+              zero?
+            ]
+            private_constant :STAT_METHODS
+
+            attr_accessor :virtual_disk
+
+            # @param [Hash] disk The mapping of paths to objects representing the virtual file system.
+            # @param [String] path The path of this entry.
+            # @param [Boolean] exist? Whether or not this entry represents an existing entry in the virtual file system.
+            # @param [File::Stat] stat An explicit stat that represents this object. A default VirtualStat will be
+            #   created unless specified.
+            def initialize(disk, path, **kwargs)
+              @virtual_disk = disk
+              @path = path
+
+              if kwargs.fetch(:exist?, true)
+                if kwargs[:stat]
+                  if kwargs[:stat].is_a?(Hash)
+                    @stat = VirtualStat.new(**kwargs[:stat])
+                  else
+                    @stat = kwargs[:stat]
+                  end
+                else
+                  @stat = VirtualStat.new
+                end
+              else
+                raise ArgumentError.new('can not specify a stat object when exist? is false') if kwargs[:stat]
+                @stat = nil
+              end
+            end
+
+            def ==(other)
+              other.is_a?(self.class) && other.to_s == to_s
+            end
+
+            def <=>(other)
+              to_s <=> other.to_s
+            end
+
+            def exist?
+              !@stat.nil?
+            rescue Errno::ENOENT
+              false
+            end
+
+            def stat
+              raise Errno::ENOENT.new('No such file or directory') unless exist? && (@stat.file? || @stat.directory?)
+
+              @stat
+            end
+
+            def join(other)
+              # per the docs this Pathname#join doesn't touch the file system
+              # see: https://ruby-doc.org/stdlib-3.1.1/libdoc/pathname/rdoc/Pathname.html#class-Pathname-label-Core+methods
+              lookup_or_create(Pathname.new(to_s).join(other).to_s)
+            end
+
+            alias :+ :join
+            alias :/ :join
+
+            def to_s
+              @path
+            end
+
+            def absolute?
+              to_s.start_with?(SEPARATOR)
+            end
+
+            def relative?
+              !absolute?
+            end
+
+            def basename
+              lookup_or_create(self.class.basename(to_s))
+            end
+
+            def self.basename(*args)
+              File.basename(*args)
+            end
+
+            def dirname
+              lookup_or_create(self.class.dirname(to_s))
+            end
+
+            def self.dirname(*args)
+              File.dirname(*args)
+            end
+
+            def extname
+              File.extname(to_s)
+            end
+
+            def split
+              [dirname, basename]
+            end
+
+            alias :parent :dirname
+
+            def children(with_directory=true)
+              raise Errno::ENOTDIR.new("Not a directory @ dir_initialize - #{to_s}") unless directory?
+
+              @virtual_disk.each_value.select { |dent| dent.dirname == self && dent != self }.map { |dent| with_directory ? dent : dent.basename }
+            end
+
+            def entries
+              children(false)
+            end
+
+            def cleanpath(consider_symlink=false)
+              lookup_or_create(self.class.cleanpath(to_s), stat: (exist? ? stat : nil))
+            end
+
+            def self.cleanpath(path)
+              # per the docs this Pathname#cleanpath doesn't touch the file system
+              # see: https://ruby-doc.org/stdlib-3.1.1/libdoc/pathname/rdoc/Pathname.html#class-Pathname-label-Core+methods
+              Pathname.new(path).cleanpath.to_s
+            end
+
+            private
+
+            # Check the virtual file system to see if the entry exists. Return it if it does, otherwise create a new
+            # entry representing a non-existent path.
+            #
+            # @param [String] path The path to lookup in the virtual file system. It will be normalized using #cleanpath.
+            # @return [Pathname] The path object representing the specified string.
+            def lookup_or_create(path, **kwargs)
+              existing = @virtual_disk[self.class.cleanpath(path)]
+              return existing if existing
+
+              kwargs[:exist?] = false
+              VirtualPathname.new(@virtual_disk, path, **kwargs)
+            end
+
+            def method_missing(symbol, *args)
+              # should we forward to one of the stat methods
+              if STAT_METHODS.include?(symbol)
+                # if we have a stat object then forward it
+                return stat.send(symbol, *args) if exist?
+                # if we don't have a stat object, emulate what Pathname does when it does not exist
+
+                # these two methods return nil
+                return nil if %i[ world_readable? world_writable? ].include?(symbol)
+
+                # any of the other ?-suffixed methods return false
+                return false if symbol.to_s.end_with?('?')
+
+                # any other method raises a Errno::ENOENT exception
+                raise Errno::ENOENT.new('No such file or directory')
+              end
+
+              raise NoMethodError, "undefined method `#{symbol}' for #{self.class}"
+            end
+
+            def respond_to_missing?(symbol, include_private = false)
+              STAT_METHODS.include?(symbol)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_smb/server/share/provider/virtual_disk/virtual_stat.rb

@@ -0,0 +1,175 @@
+module RubySMB
+  class Server
+    module Share
+      module Provider
+        class VirtualDisk < Disk
+          # This object emulates Ruby's builtin File::Stat object but uses a virtual file system instead of the real
+          # local one. The current implementation is limited to only representing directories and standard files. All
+          # attributes are read-only and once the object is created, it is immutable.
+          class VirtualStat
+
+            # All of the keyword arguments are the keys of the attributes to set. The names are left as is, maintaining
+            # a direct 1 to 1 relationship. See the Ruby docs for File::Stat
+            # (https://ruby-doc.org/core-3.0.2/File/Stat.html) for a list of all the attributes that can be set. Some
+            # values are calculated based on others such as the mode readable? being calculated based on the mode.
+            def initialize(**kwargs)
+              # directory and file both default to being the opposite of each other, one or both can be specified
+              # but they can not both be true at the same time
+              is_dir = !!kwargs.fetch(:directory?, !kwargs.fetch(:file?, false)) # defaults to not file which defaults to false
+              is_fil = !!kwargs.fetch(:file?, !kwargs.fetch(:directory?, true)) # defaults to not directory which defaults to true
+              raise ArgumentError.new('must be either a file or a directory') unless is_dir ^ is_fil
+
+              @values = kwargs.dup
+              # the default is a directory
+              @values[:directory?] = !@values.delete(:file?) if @values.key?(:file?) # normalize on directory? if file? was specified.
+
+              @birthtime = kwargs[:birthtime] || Time.now
+            end
+
+            def blksize
+              @values.fetch(:blksize, 4096)
+            end
+
+            def blockdev?
+              false
+            end
+
+            def blocks
+              @values.fetch(:blocks, 0)
+            end
+
+            def chardev?
+              false
+            end
+
+            def pipe?
+              false
+            end
+
+            def socket?
+              false
+            end
+
+            def symlink?
+              false
+            end
+
+            def directory?
+              @values.fetch(:directory?, true)
+            end
+
+            def file?
+              !directory?
+            end
+
+            def ftype
+              raise Errno::ENOENT.new('No such file or directory') unless file? || directory?
+
+              file? ? 'file' : 'directory'
+            end
+
+            def size
+              @values.fetch(:size, 0)
+            end
+
+            def zero?
+              file? && size == 0
+            end
+
+            def nlink
+              @values.fetch(:nlink, 0)
+            end
+
+            def dev
+              @values[:dev] ||= rand(1..0xfe)
+            end
+
+            def ino
+              @values[:ino] ||= rand(1..0xfffe)
+            end
+
+            def gid
+              @values.fetch(:gid, Process.gid)
+            end
+
+            def grpowned?
+              gid == Process.gid
+            end
+
+            def uid
+              @values.fetch(:uid, Process.uid)
+            end
+
+            def owned?
+              uid == Process.uid
+            end
+
+            # last access time
+            def atime
+              @values.fetch(:atime, @birthtime)
+            end
+
+            # modification time
+            def mtime
+              @values.fetch(:mtime, @birthtime)
+            end
+
+            # change time
+            def ctime
+              @values.fetch(:ctime, @birthtime)
+            end
+
+            # the permission bits, normalized based on the standard GNU representation,
+            # see: https://www.gnu.org/software/libc/manual/html_node/Permission-Bits.html
+            def mode
+              @values.fetch(:mode, (file? ? 0o644 : 0o755))
+            end
+
+            def setuid?
+              mode & 0o04000 != 0
+            end
+
+            def setgid?
+              mode & 0o02000 != 0
+            end
+
+            def sticky?
+              mode & 0o01000 != 0
+            end
+
+            def readable?
+              return true if owned? && (mode & 1 << 8 != 0)
+              return true if grpowned? && (mode & 1 << 5 != 0)
+              return true if world_readable?
+              return false
+            end
+
+            def world_readable?
+              mode & 1 << 2 != 0
+            end
+
+            def writable?
+              return true if owned? && (mode & 1 << 7 != 0)
+              return true if grpowned? && (mode & 1 << 4 != 0)
+              return true if world_writable?
+              return false
+            end
+
+            def world_writable?
+              mode & 1 << 1 != 0
+            end
+
+            def executable?
+              return true if owned? && (mode & 1 << 6 != 0)
+              return true if grpowned? && (mode & 1 << 3 != 0)
+              return true if mode & 1 != 0
+              return false
+            end
+
+            attr_reader :birthtime
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_smb/server/share/provider/virtual_disk.rb

@@ -0,0 +1,116 @@
+require 'ruby_smb/server/share/provider/disk'
+require 'ruby_smb/server/share/provider/virtual_disk/virtual_file'
+require 'ruby_smb/server/share/provider/virtual_disk/virtual_pathname'
+require 'ruby_smb/server/share/provider/virtual_disk/virtual_stat'
+
+module RubySMB
+  class Server
+    module Share
+      module Provider
+        # This is a share provider that exposes a virtual file system whose entries do not exist on disk.
+        # @since 3.1.1
+        class VirtualDisk < Disk
+          HASH_METHODS = %i[ [] each each_key each_value keys length values ]
+          private_constant :HASH_METHODS
+
+          # @param [String] name The name of this share.
+          def initialize(name)
+            @vfs = {}
+            super(name, add(VirtualPathname.new(self, File::SEPARATOR)))
+          end
+
+          # Add a dynamic file to the virtual file system. A dynamic file is one whose contents are generated by the
+          # specified block. The contents are generated when the share is opened.
+          #
+          # @param [String] path The path of the file to add, relative to the share root.
+          # @param [File::Stat] stat An explicit stat object describing the file.
+          # @yield The content generation routine.
+          # @yieldreturn [String] The generated file content.
+          def add_dynamic_file(path, stat: nil, &block)
+            raise ArgumentError.new('a block must be specified for dynamic files') unless block_given?
+            path = VirtualPathname.cleanpath(path)
+            path = File::SEPARATOR + path unless path.start_with?(File::SEPARATOR)
+            raise ArgumentError.new('must be a file') if stat && !stat.file?
+
+            vf = VirtualDynamicFile.new(self, path, stat: stat, &block)
+            add(vf)
+          end
+
+          # Add a mapped file to the virtual file system. A mapped file is one who is backed by an entry on
+          # disk. The path need not be present, but if it does exist, it must be a file.
+          #
+          # @param [String] path The path of the file to add, relative to the share root.
+          # @param [String, Pathname] mapped_path The path on the local file system to map into the virtual file system.
+          def add_mapped_file(path, mapped_path)
+            path = VirtualPathname.cleanpath(path)
+            path = File::SEPARATOR + path unless path.start_with?(File::SEPARATOR)
+
+            vf = VirtualMappedFile.new(self, path, mapped_path)
+            add(vf)
+          end
+
+          # Add a static file to the virtual file system. A static file is one whose contents are known at creation time
+          # and do not change. If *content* is a file-like object that responds to #read, the data will be read using
+          # that method. Likewise, if *content* has a #stat attribute and *stat* was not specified, then the value of
+          # content's #stat attribute will be used.
+          #
+          # @param [String] path The path of the file to add, relative to the share root.
+          # @param [String, #read, #stat] content The static content to add.
+          # @param [File::Stat] stat An explicit stat object describing the file.
+          def add_static_file(path, content, stat: nil)
+            path = VirtualPathname.cleanpath(path)
+            path = File::SEPARATOR + path unless path.start_with?(File::SEPARATOR)
+            raise ArgumentError.new('must be a file') if stat && !stat.file?
+
+            stat = content.stat if content.respond_to?(:stat) && stat.nil?
+            content = content.read if content.respond_to?(:read)
+            vf = VirtualStaticFile.new(self, path, content, stat: stat)
+            add(vf)
+          end
+
+          def add(virtual_pathname)
+            raise ArgumentError.new('paths must be absolute') unless virtual_pathname.absolute?
+
+            path = virtual_pathname.to_s
+            raise ArgumentError.new('paths must be normalized') unless VirtualPathname.cleanpath(path) == path
+
+            path_parts = path.split(VirtualPathname::SEPARATOR)
+            2.upto(path_parts.length - 1) do |idx|
+              ancestor = path_parts[0...idx].join(path[VirtualPathname::SEPARATOR])
+              next if @vfs[ancestor]&.directory?
+
+              @vfs[ancestor] = VirtualPathname.new(self, ancestor, stat: VirtualStat.new(directory?: true))
+            end
+
+            @vfs[path] = virtual_pathname
+          end
+
+          def new_processor(server_client, session)
+            scoped_virtual_disk = self.class.new(@name)
+            @vfs.each_value do |path|
+              path = path.dup
+              path.virtual_disk = scoped_virtual_disk if path.is_a?(VirtualPathname)
+              path = path.generate(server_client, session) if path.is_a?(VirtualDynamicFile)
+              scoped_virtual_disk.add(path)
+            end
+            self.class::Processor.new(scoped_virtual_disk, server_client, session)
+          end
+
+          private
+
+          def method_missing(symbol, *args)
+            if HASH_METHODS.include?(symbol)
+              return @vfs.send(symbol, *args)
+            end
+
+            raise NoMethodError, "undefined method `#{symbol}' for #{self.class}"
+          end
+
+          def respond_to_missing?(symbol, include_private = false)
+            HASH_METHODS.include?(symbol)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_smb/server/share/provider.rb

@@ -36,3 +36,4 @@ end
 
 require 'ruby_smb/server/share/provider/disk'
 require 'ruby_smb/server/share/provider/pipe'
+require 'ruby_smb/server/share/provider/virtual_disk'

data/lib/ruby_smb/server.rb

@@ -14,8 +14,10 @@ module RubySMB
     Connection = Struct.new(:client, :thread)
 
     # @param server_sock the socket on which the server should listen
-    # @param [Gss::Provider] the authentication provider
-    def initialize(server_sock: nil, gss_provider: nil, logger: nil)
+    # @param [Gss::Provider] gss_provider the authentication provider
+    # @param [::Logger] logger the logger to use for diagnostic messages
+    # @param thread_factory a block to create threads for serving clients
+    def initialize(server_sock: nil, gss_provider: nil, logger: nil, thread_factory: nil)
       server_sock = ::TCPServer.new(445) if server_sock.nil?
 
       @guid = Random.new.bytes(16)
@@ -36,6 +38,14 @@ module RubySMB
         @logger = logger
       end
 
+      if thread_factory.nil?
+        # the default thread factory uses Ruby's standard Thread#new
+        thread_factory = Proc.new do |_server_client, &block|
+          Thread.new(&block)
+        end
+      end
+      @thread_factory = thread_factory
+
       # share name => provider instance
       @shares = {
         'IPC$' => Share::Provider::IpcPipe.new
@@ -53,7 +63,7 @@ module RubySMB
       loop do
         sock = @socket.accept
         server_client = ServerClient.new(self, RubySMB::Dispatcher::Socket.new(sock, read_timeout: nil))
-        @connections << Connection.new(server_client, Thread.new { server_client.run })
+        @connections << Connection.new(server_client, @thread_factory.call(server_client) { server_client.run })
 
         break unless block.nil? || block.call(server_client)
       end

data/lib/ruby_smb/smb2/tree.rb

@@ -237,6 +237,7 @@ module RubySMB
 
         if read
           create_request.share_access.read_access = 1
+          create_request.desired_access.read_attr = 1
           create_request.desired_access.read_data = 1
         end
 

data/lib/ruby_smb/version.rb

@@ -1,3 +1,3 @@
 module RubySMB
-  VERSION = '3.1.1'.freeze
+  VERSION = '3.1.2'.freeze
 end

data/spec/lib/ruby_smb/fscc/file_information/file_access_information_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::Fscc::FileInformation::FileAccessInformation do
+  it 'references the correct class level' do
+    expect(described_class).to be_const_defined(:CLASS_LEVEL)
+    expect(described_class::CLASS_LEVEL).to be RubySMB::Fscc::FileInformation::FILE_ACCESS_INFORMATION
+  end
+
+  subject(:struct) { described_class.new }
+
+  it { should respond_to :access_flags }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  it 'tracks the access flags in a Uint32 field' do
+    expect(struct.access_flags).to be_a BinData::Uint32le
+  end
+
+end

data/spec/lib/ruby_smb/fscc/file_information/file_alignment_information_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::Fscc::FileInformation::FileAlignmentInformation do
+  it 'references the correct class level' do
+    expect(described_class).to be_const_defined(:CLASS_LEVEL)
+    expect(described_class::CLASS_LEVEL).to be RubySMB::Fscc::FileInformation::FILE_ALIGNMENT_INFORMATION
+  end
+
+  subject(:struct) { described_class.new }
+
+  it { should respond_to :alignment_requirement }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  it 'tracks the alignment requirement in a Uint32 field' do
+    expect(struct.alignment_requirement).to be_a BinData::Uint32le
+  end
+
+end

data/spec/lib/ruby_smb/fscc/file_information/file_all_information_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::Fscc::FileInformation::FileAllInformation do
+  it 'references the correct class level' do
+    expect(described_class).to be_const_defined(:CLASS_LEVEL)
+    expect(described_class::CLASS_LEVEL).to be RubySMB::Fscc::FileInformation::FILE_ALL_INFORMATION
+  end
+
+  subject(:struct) { described_class.new }
+
+ it { should respond_to :basic_information }
+ it { should respond_to :standard_information }
+ it { should respond_to :internal_information }
+ it { should respond_to :ea_information }
+ it { should respond_to :access_information }
+ it { should respond_to :position_information }
+ it { should respond_to :mode_information }
+ it { should respond_to :alignment_information }
+ it { should respond_to :name_information }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  it 'tracks the basic information in a FileBasicInformation field' do
+    expect(struct.basic_information).to be_a RubySMB::Fscc::FileInformation::FileBasicInformation
+  end
+
+  it 'tracks the standard information in a FileStandardInformation field' do
+    expect(struct.standard_information).to be_a RubySMB::Fscc::FileInformation::FileStandardInformation
+  end
+
+  it 'tracks the internal information in a FileInternalInformation field' do
+    expect(struct.internal_information).to be_a RubySMB::Fscc::FileInformation::FileInternalInformation
+  end
+
+  it 'tracks the ea information in a FileEaInformation field' do
+    expect(struct.ea_information).to be_a RubySMB::Fscc::FileInformation::FileEaInformation
+  end
+
+  it 'tracks the access information in a FileAccessInformation field' do
+    expect(struct.access_information).to be_a RubySMB::Fscc::FileInformation::FileAccessInformation
+  end
+
+  it 'tracks the position information in a FilePositionInformation field' do
+    expect(struct.position_information).to be_a RubySMB::Fscc::FileInformation::FilePositionInformation
+  end
+
+  it 'tracks the mode information in a FileModeInformation field' do
+    expect(struct.mode_information).to be_a RubySMB::Fscc::FileInformation::FileModeInformation
+  end
+
+  it 'tracks the alignment information in a FileAlignmentInformation field' do
+    expect(struct.alignment_information).to be_a RubySMB::Fscc::FileInformation::FileAlignmentInformation
+  end
+
+  it 'tracks the name information in a FileNameInformation field' do
+    expect(struct.name_information).to be_a RubySMB::Fscc::FileInformation::FileNameInformation
+  end
+end
+

data/spec/lib/ruby_smb/fscc/file_information/file_basic_information_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::Fscc::FileInformation::FileBasicInformation do
+  it 'references the correct class level' do
+    expect(described_class).to be_const_defined(:CLASS_LEVEL)
+    expect(described_class::CLASS_LEVEL).to be RubySMB::Fscc::FileInformation::FILE_BASIC_INFORMATION
+  end
+
+  subject(:struct) { described_class.new }
+
+  it { should respond_to :create_time }
+  it { should respond_to :last_access }
+  it { should respond_to :last_write }
+  it { should respond_to :last_change }
+  it { should respond_to :file_attributes }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  it 'tracks the create time in a FileTime field' do
+    expect(struct.create_time).to be_a RubySMB::Field::FileTime
+  end
+
+  it 'tracks the last access time in a FileTime field' do
+    expect(struct.last_access).to be_a RubySMB::Field::FileTime
+  end
+
+  it 'tracks the last write time in a FileTime field' do
+    expect(struct.last_write).to be_a RubySMB::Field::FileTime
+  end
+
+  it 'tracks the last modified time in a FileTime field' do
+    expect(struct.last_change).to be_a RubySMB::Field::FileTime
+  end
+
+  it 'tracks the file attributes in a FileAttributes field' do
+    expect(struct.file_attributes).to be_a RubySMB::Fscc::FileAttributes
+  end
+
+end