ruby_smb 3.0.6 → 3.1.2

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

@@ -1,430 +1,24 @@
-require 'zlib'
-require 'ruby_smb/server/share/provider/processor'
+require 'ruby_smb/server/share/provider/disk/file_system'
+require 'ruby_smb/server/share/provider/disk/processor'
 
 module RubySMB
   class Server
     module Share
       module Provider
+        # This is a share provider that exposes the local file system.
         class Disk < Base
           TYPE = TYPE_DISK
-          class Processor < Processor::Base
-            Handle = Struct.new(:remote_path, :local_path, :durable?)
-            def initialize(provider, server_client, session)
-              super
-              @handles = {}
-              @query_directory_context = {}
-            end
-
-            def maximal_access(path=nil)
-              RubySMB::SMB2::BitField::FileAccessMask.new(
-                read_attr: 1,
-                read_data: 1
-              )
-            end
-
-            def do_close_smb2(request)
-              local_path = get_local_path(request.file_id)
-              if local_path.nil?
-                response = RubySMB::SMB2::Packet::ErrorPacket.new
-                response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_FILE_CLOSED
-                return response
-              end
-
-              @handles.delete(request.file_id.to_binary_s)
-              response = RubySMB::SMB2::Packet::CloseResponse.new
-              set_common_info(response, local_path)
-              response.flags = 1
-              response
-            end
-
-            def do_create_smb2(request)
-              unless request.create_disposition == RubySMB::Dispositions::FILE_OPEN
-                logger.warn("Can not handle CREATE request for disposition: #{request.create_disposition}")
-                raise NotImplementedError
-              end
-
-              # process the delayed io fields
-              request.name.read_now!
-              unless request.contexts_offset == 0
-                request.contexts.read_now!
-                request.contexts.each do |context|
-                  context.name.read_now!
-                  context.data.read_now!
-                end
-              end
-
-              path = request.name.snapshot
-              path = path.encode.gsub('\\', File::SEPARATOR)
-              local_path = get_local_path(path)
-              unless local_path && (local_path.file? || local_path.directory?)
-                logger.warn("Requested path does not exist: #{local_path}")
-                response = RubySMB::SMB2::Packet::ErrorPacket.new
-                response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_OBJECT_NAME_NOT_FOUND
-                return response
-              end
-
-              durable = false
-              response = RubySMB::SMB2::Packet::CreateResponse.new
-              response.create_action = RubySMB::CreateActions::FILE_OPENED
-              set_common_info(response, local_path)
-              response.file_id.persistent = Zlib::crc32(path)
-              response.file_id.volatile = rand(0xffffffff)
-
-              request.contexts.each do |req_ctx|
-                case req_ctx.name
-                when SMB2::CreateContext::CREATE_DURABLE_HANDLE
-                  # see: https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/9adbc354-5fad-40e7-9a62-4a4b6c1ff8a0
-                  next if request.contexts.any? { |ctx| ctx.name == SMB2::CreateContext::CREATE_DURABLE_HANDLE_RECONNECT }
-
-                  if request.contexts.any? { |ctx| [ SMB2::CreateContext::CREATE_DURABLE_HANDLE_V2, SMB2::CreateContext::CREATE_DURABLE_HANDLE_RECONNECT_v2 ].include?(ctx.name) }
-                    response = RubySMB::SMB2::Packet::ErrorPacket.new
-                    response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_PARAMETER
-                    return response
-                  end
-
-                  durable = true
-                  res_ctx = SMB2::CreateContext::CreateDurableHandleResponse.new
-                when SMB2::CreateContext::CREATE_DURABLE_HANDLE_V2
-                  # see: https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/33e6800a-adf5-4221-af27-7e089b9e81d1
-                  if request.contexts.any? { |ctx| [ SMB2::CreateContext::CREATE_DURABLE_HANDLE, SMB2::CreateContext::CREATE_DURABLE_HANDLE_RECONNECT, SMB2::CreateContext::CREATE_DURABLE_HANDLE_RECONNECT_v2 ].include?(ctx.name) }
-                    response = RubySMB::SMB2::Packet::ErrorPacket.new
-                    response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_PARAMETER
-                    return response
-                  end
-
-                  durable = true
-                  res_ctx = SMB2::CreateContext::CreateDurableHandleV2Response.new(
-                    timeout: 1000,
-                    flags: req_ctx.data.flags
-                  )
-                when SMB2::CreateContext::CREATE_QUERY_MAXIMAL_ACCESS
-                  res_ctx = SMB2::CreateContext::CreateQueryMaximalAccessResponse.new(
-                    maximal_access: maximal_access(path)
-                  )
-                when SMB2::CreateContext::CREATE_QUERY_ON_DISK_ID
-                  res_ctx = SMB2::CreateContext::CreateQueryOnDiskIdResponse.new(
-                    disk_file_id: local_path.stat.ino,
-                    volume_id: local_path.stat.dev
-                  )
-                else
-                  logger.warn("Can not handle CREATE context: #{req_ctx.name}")
-                  next
-                end
-
-                response.contexts << SMB2::CreateContext::CreateContextResponse.new(name: res_ctx.class::NAME, data: res_ctx)
-              end
-
-              if response.contexts.length > 0
-                # fixup the offsets
-                response.contexts[0...-1].each do |ctx|
-                  ctx.next_offset = ctx.num_bytes
-                end
-                response.contexts[-1].next_offset = 0
-                response.contexts_offset = response.buffer.abs_offset
-                response.contexts_length = response.buffer.num_bytes
-              else
-                response.contexts_offset = 0
-                response.contexts_length = 0
-              end
-
-              @handles[response.file_id.to_binary_s] = Handle.new(path, local_path, durable)
-              response
-            end
-
-            def do_query_directory_smb2(request)
-              local_path = get_local_path(request.file_id)
-              if local_path.nil?
-                response = RubySMB::SMB2::Packet::ErrorPacket.new
-                response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_FILE_CLOSED
-                return response
-              end
-
-              # see: https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/29dfcc9b-3aec-406b-abb5-0b4fe96712e2
-              info_class = request.file_information_class.snapshot
-              begin
-                # probe #build_info to see if it supports the requested info class
-                build_info(Pathname.new(__FILE__), info_class)
-              rescue NotImplementedError
-                logger.warn("Can not handle QUERY_DIRECTORY request for class: #{info_class}")
-                raise
-              end
-
-              unless local_path.directory?
-                response = SMB2::Packet::ErrorPacket.new
-                response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_PARAMETER
-                return response
-              end
-
-              search_pattern = request.name.snapshot.dup.encode
-              begin
-                search_regex = wildcard_to_regex(search_pattern)
-              rescue NotImplementedError
-                logger.warn("Can not handle QUERY_DIRECTORY wildcard pattern: #{search_pattern}")
-                raise
-              end
-
-              return_single = request.flags.return_single == 1
-
-              align = 8
-              infos = []
-              total_size = 0
-
-              if @query_directory_context[request.file_id.to_binary_s].nil? || request.flags.reopen == 1 || request.flags.restart_scans == 1
-                dirents = local_path.children.sort.to_a
-                dirents.unshift(local_path.parent) unless local_path.parent == local_path
-                dirents.unshift(local_path)
-                @query_directory_context[request.file_id.to_binary_s] = dirents
-              else
-                dirents = @query_directory_context[request.file_id.to_binary_s]
-              end
-
-              while dirents.length > 0
-                dirent = dirents.shift
-                next unless dirent.file? || dirent.directory? # filter out everything but files and directories
-
-                case dirent
-                when local_path
-                  dirent_name = '.'
-                when local_path.parent
-                  dirent_name = '..'
-                else
-                  dirent_name = dirent.basename.to_s
-                end
-                next unless search_regex.match?(dirent_name)
-
-                info = build_info(dirent, info_class, rename: dirent_name)
-                info_size = info.num_bytes + ((align - info.num_bytes % align) % align)
-                if total_size + info_size > request.output_length
-                  dirents.unshift(dirent) # no space left for this one so put it back
-                  break
-                end
-
-                infos << info
-                total_size += info_size
-                break if return_single
-              end
-
-              if infos.length == 0
-                response = SMB2::Packet::QueryDirectoryResponse.new
-                response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_NO_MORE_FILES
-                return response
-              end
-
-              response = SMB2::Packet::QueryDirectoryResponse.new
-              infos.last.next_offset = 0 if infos.last
-              buffer = ""
-              infos.each do |info|
-                info = info.to_binary_s
-                buffer << info + "\x00".b * ((align - info.length % align) % align)
-              end
-              response.buffer = buffer
-              response
-            end
-
-            def do_query_info_smb2(request)
-              local_path = get_local_path(request.file_id)
-              if local_path.nil?
-                response = RubySMB::SMB2::Packet::ErrorPacket.new
-                response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_FILE_CLOSED
-                return response
-              end
-
-              case request.info_type
-              when SMB2::SMB2_INFO_FILE
-                info = query_info_smb2_file(request, local_path)
-              when SMB2::SMB2_INFO_FILESYSTEM
-                info = query_info_smb2_filesystem(request, local_path)
-              else
-                logger.warn("Can not handle QUERY_INFO request for type: #{request.info_type}, class: #{request.file_information_class}")
-                raise NotImplementedError
-              end
-
-              response = SMB2::Packet::QueryInfoResponse.new
-              response.buffer = info.to_binary_s
-              response
-            end
-
-            def do_read_smb2(request)
-              local_path = get_local_path(request.file_id)
-              if local_path.nil?
-                response = RubySMB::SMB2::Packet::ErrorPacket.new
-                response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_FILE_CLOSED
-                return response
-              end
-
-              raise NotImplementedError unless request.channel == SMB2::SMB2_CHANNEL_NONE
-
-              buffer = nil
-              local_path.open do |file|
-                file.seek(request.offset.snapshot)
-                buffer = file.read(request.read_length)
-              end
-
-              # see: https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/21e8b343-34e9-4fca-8d93-03dd2d3e961e
-              if buffer.nil? || buffer.length == 0 || buffer.length < request.min_bytes
-                response = SMB2::Packet::ErrorPacket.new
-                response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_END_OF_FILE
-                return response
-              end
-
-              response = SMB2::Packet::ReadResponse.new
-              response.data_length = buffer.length
-              response.buffer = buffer
-              response
-            end
-
-            private
-
-            def build_file_attributes(path)
-              file_attributes = Fscc::FileAttributes.new
-              if path.file?
-                file_attributes.normal = 1
-              elsif path.directory?
-                file_attributes.directory = 1
-              end
-              file_attributes
-            end
-
-            def build_info(path, info_class, rename: nil)
-              case info_class
-              when Fscc::FileInformation::FILE_ID_BOTH_DIRECTORY_INFORMATION
-                info = Fscc::FileInformation::FileIdBothDirectoryInformation.new
-                set_common_info(info, path)
-                info.file_name = rename || path.basename.to_s
-              when Fscc::FileInformation::FILE_FULL_DIRECTORY_INFORMATION
-                info = Fscc::FileInformation::FileFullDirectoryInformation.new
-                set_common_info(info, path)
-                info.file_name = rename || path.basename.to_s
-              else
-                raise NotImplementedError, "unsupported info class: #{info_class}"
-              end
-
-              align = 8
-              info.next_offset = info.num_bytes + ((align - info.num_bytes % align) % align)
-              info
-            end
-
-            def get_allocation_size(path)
-              (path.size + (4095 - (path.size + 4095) % 4096))
-            end
-
-            def get_local_path(path)
-              case path
-              when Field::Smb2Fileid
-                local_path = @handles[path.to_binary_s]&.local_path
-              when ::String
-                local_path = (provider.path + path.encode).cleanpath
-                # TODO: report / handle directory traversal issues more robustly
-                raise RuntimeError unless local_path == provider.path || local_path.to_s.start_with?(provider.path.to_s + '/')
-              else
-                raise NotImplementedError, "Can not get the local path for: #{path.inspect}"
-              end
-
-              local_path
-            end
-
-            def query_info_smb2_file(request, local_path)
-              raise ArgumentError unless request.info_type == SMB2::SMB2_INFO_FILE
-
-              case request.file_information_class
-              when Fscc::FileInformation::FILE_EA_INFORMATION
-                info = Fscc::FileInformation::FileEaInformation.new
-              when Fscc::FileInformation::FILE_NETWORK_OPEN_INFORMATION
-                info = Fscc::FileInformation::FileNetworkOpenInformation.new
-                set_common_info(info, local_path)
-              when Fscc::FileInformation::FILE_NORMALIZED_NAME_INFORMATION
-                info = Fscc::FileInformation::FileNameInformation.new(file_name: @handles[request.file_id.to_binary_s].remote_path)
-              when Fscc::FileInformation::FILE_STREAM_INFORMATION
-                raise NotImplementedError unless local_path.file?
-
-                info = Fscc::FileInformation::FileStreamInformation.new(
-                  stream_size: local_path.size,
-                  stream_allocation_size: get_allocation_size(local_path),
-                  stream_name: '::$DATA'
-                )
-              else
-                logger.warn("Can not handle QUERY_INFO request for type: #{request.info_type}, class: #{request.file_information_class}")
-                raise NotImplementedError
-              end
-
-              info
-            end
-
-            def query_info_smb2_filesystem(request, local_path)
-              raise ArgumentError unless request.info_type == SMB2::SMB2_INFO_FILESYSTEM
-
-              case request.file_information_class
-              when Fscc::FileSystemInformation::FILE_FS_ATTRIBUTE_INFORMATION
-                # emulate NTFS just like Samba does
-                info = Fscc::FileSystemInformation::FileFsAttributeInformation.new(
-                  file_system_attributes: {
-                    file_case_sensitive_search: 1,
-                    file_case_preserved_names: 1,
-                    file_unicode_on_disk: 1,
-                    file_supports_object_ids: 1,
-                  },
-                  maximum_component_name_length: 255,
-                  file_system_name: 'NTFS'
-                )
-              when Fscc::FileSystemInformation::FILE_FS_VOLUME_INFORMATION
-                info = Fscc::FileSystemInformation::FileFsVolumeInformation.new(
-                  volume_serial_number: provider.path.stat.ino,
-                  volume_label: provider.name
-                )
-              else
-                logger.warn("Can not handle QUERY_INFO request for type: #{request.info_type}, class: #{request.file_information_class}")
-                raise NotImplementedError
-              end
-
-              info
-            end
-
-            # A bunch of structures have these common fields with the same meaning, so set them all here
-            def set_common_info(info, path)
-              begin
-                info.create_time = path.birthtime
-              rescue NotImplementedError
-                logger.warn("The file system does not support #birthtime for #{path}")
-              end
-
-              info.last_access = path.atime
-              info.last_write = path.mtime
-              info.last_change = path.ctime
-              if path.file?
-                info.end_of_file = path.size
-                info.allocation_size = get_allocation_size(path)
-              end
-              info.file_attributes = build_file_attributes(path)
-            end
-
-            # Turn a wildcard expression into a regex. Not all wildcard
-            # characters are supported. Wildcards that can not be converted will
-            # raise a NotImplementedError.
-            #
-            # @param [String] wildcard The wildcard expression to convert.
-            # @return [Regexp] The converted expression.
-            # @raise [NotImplementedError] Raised when the wildcard can not be
-            #   converted.
-            def wildcard_to_regex(wildcard)
-              return Regexp.new('.*') if ['*.*', ''].include?(wildcard)
-
-              if wildcard.each_char.any? { |c| c == '<' || c == '>' }
-                # the < > wildcard operators are not supported
-                raise NotImplementedError
-              end
-
-              wildcard = Regexp.escape(wildcard)
-              wildcard = wildcard.gsub(/(\\\?)+$/) { |match| ".{0,#{match.length / 2}}"}
-              wildcard = wildcard.gsub('\?', '.')
-              wildcard = wildcard.gsub('\*', '.*')
-              wildcard = wildcard.gsub('"', '\.')
-              Regexp.new('^' + wildcard + '$')
-            end
-          end
+          # emulate NTFS just like Samba does
+          FILE_SYSTEM = FileSystem::NTFS
 
+          # @param [String] name The name of this share.
+          # @param [String, Pathname] path The local file system path to share. This path must be an absolute path to an existing
+          #   directory.
           def initialize(name, path)
-            path = Pathname.new(File.expand_path(path))
-            raise ArgumentError unless path.directory?
+            path = Pathname.new(File.expand_path(path)) if path.is_a?(String)
+            raise ArgumentError.new('path must be a directory') unless path.directory? # it needs to exist
+            raise ArgumentError.new('path must be absolute') unless path.absolute? # it needs to be absolute so it is independent of the cwd
+
             @path = path
             super(name)
           end

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

@@ -6,12 +6,12 @@ module RubySMB
       module Provider
         class Pipe < Base
           TYPE = TYPE_PIPE
-          class Processor < Processor::Base
+          class Processor < Provider::Processor::Base
           end
         end
 
         class IpcPipe < Pipe
-          class Processor < Processor::Base
+          class Processor < Provider::Processor::Base
             def maximal_access(path=nil)
               RubySMB::SMB2::BitField::DirectoryAccessMask.read([0x001f00a9].pack('V'))
             end

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

@@ -25,6 +25,22 @@ module RubySMB
             def disconnect!
             end
 
+            def do_close_smb1(request)
+              raise NotImplementedError
+            end
+
+            def do_nt_create_andx_smb1(request)
+              raise NotImplementedError
+            end
+
+            def do_read_andx_smb1(request)
+              raise NotImplementedError
+            end
+
+            def do_transactions2_smb1(request)
+              raise NotImplementedError
+            end
+
             def do_close_smb2(request)
               raise NotImplementedError
             end

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

@@ -0,0 +1,85 @@
+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
+        class VirtualDisk < Disk
+          # A dynamic file is one whose contents are generated by the specified
+          # block.
+          class VirtualDynamicFile < VirtualPathname
+            # @param [Hash] disk The mapping of paths to objects representing the virtual file system.
+            # @param [String] path The path of this entry.
+            # @param [File::Stat] stat An explicit stat object describing the file.
+            def initialize(disk, path, stat: nil, &block)
+              raise ArgumentError.new('a generation block must be specified') if block.nil?
+
+              @content_generator = block
+              super(disk, path)
+              @stat = stat
+            end
+
+            def generate(server_client, session)
+              content = @content_generator.call(server_client, session)
+              VirtualStaticFile.new(@virtual_disk, @path, content, stat: @stat)
+            end
+          end
+
+          # A static file is one whose contents are known at creation time and
+          # do not change.
+          class VirtualStaticFile < VirtualPathname
+            # @param [Hash] disk The mapping of paths to objects representing the virtual file system.
+            # @param [String] path The path of this entry.
+            # @param [String] content The static content of this file.
+            # @param [File::Stat] stat An explicit stat object describing the file.
+            def initialize(disk, path, content, stat: nil)
+              stat = stat || VirtualStat.new(file?: true, size: content.size)
+              raise ArgumentError.new('stat is not a file') unless stat.file?
+
+              @content = content
+              super(disk, path, stat: stat)
+            end
+
+            def open(mode = 'r', &block)
+              file = StringIO.new(@content)
+              block_given? ? block.call(file) : file
+            end
+
+            attr_reader :content
+          end
+
+          # 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.
+          class VirtualMappedFile < VirtualPathname
+            # @param [Hash] disk The mapping of paths to objects representing the virtual file system.
+            # @param [String] path The path of this entry.
+            # @param [String, Pathname] mapped_path The path on the local file system to map into the virtual file system.
+            def initialize(disk, path, mapped_path)
+              mapped_path = Pathname.new(File.expand_path(mapped_path)) if mapped_path.is_a?(String)
+              raise ArgumentError.new('mapped_path must be absolute') unless mapped_path.absolute? # it needs to be absolute so it is independent of the cwd
+
+              @virtual_disk = disk
+              @path = path
+              @mapped_path = mapped_path
+            end
+
+            def exist?
+              # filter out anything that's not a directory but allow the file to be missing, this prevents exposing
+              # directories which could yield path confusion errors
+              @mapped_path.exist? && @mapped_path.file?
+            end
+
+            def stat
+              @mapped_path.stat
+            end
+
+            def open(mode = 'r', &block)
+              @mapped_path.open(mode, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end