ruby_smb 3.3.19 → 3.3.21

data/lib/ruby_smb/smb1/packet/trans2/set_information_level.rb

@@ -0,0 +1,35 @@
+module RubySMB
+  module SMB1
+    module Packet
+      module Trans2
+        # Information Level codes valid for Trans2 SET_PATH_INFORMATION and
+        # SET_FILE_INFORMATION requests. See
+        # [MS-CIFS 2.2.2.3.4 SET Information Level Codes](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-cifs/0321265e-312a-4721-90fa-cd40a443ed86).
+        #
+        # FSCC pass-through levels are defined in
+        # {RubySMB::Fscc::FileInformation} and require
+        # `SMB_INFO_PASSTHROUGH` to be added. The constants defined here are
+        # the CIFS UNIX Extensions info levels used by Samba servers that
+        # advertise UNIX extensions support in their negotiate response. These
+        # levels fall outside MS-CIFS; their wire format is defined by the
+        # CIFS UNIX Extensions draft and implemented by Samba's
+        # `smb_set_file_unix_link` handler at
+        # [source3/smbd/smb1_trans2.c:3643-3712](https://github.com/samba-team/samba/blob/33f516c06756e12a9d11f50e2bf309171cdf5c88/source3/smbd/smb1_trans2.c#L3643-L3712).
+        module SetInformationLevel
+          # Set the symbolic link target for a file. The Trans2 parameters
+          # block carries the path being created (the symlink itself); the
+          # Trans2 data block carries the target path as a null-terminated
+          # string.
+          SMB_SET_FILE_UNIX_LINK = 0x0201
+
+          # Create a hard link. Data block carries the existing file path.
+          SMB_SET_FILE_UNIX_HLINK = 0x0203
+
+          def self.name(value)
+            constants.select { |c| c.upcase == c }.find { |c| const_get(c) == value }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_smb/smb1/packet/trans2/set_path_information_request.rb

@@ -0,0 +1,75 @@
+module RubySMB
+  module SMB1
+    module Packet
+      module Trans2
+        # The Trans2 Parameter Block for a SET_PATH_INFORMATION request as
+        # defined in
+        # [MS-CIFS 2.2.6.7.1 Request](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-cifs/2ca0642a-1cd4-4e72-a16f-9e804a218262).
+        class SetPathInformationRequestTrans2Parameters < BinData::Record
+          endian :little
+
+          uint16     :information_level, label: 'Information Level'
+          uint32     :reserved,          label: 'Reserved'
+          choice     :filename, copy_on_change: true, selection: -> { parent.parent.smb_header.flags2.unicode } do
+            stringz16 1, label: 'FileName'
+            stringz   0, label: 'FileName'
+          end
+
+          # Returns the length of the Trans2Parameters struct
+          # in number of bytes
+          def length
+            do_num_bytes
+          end
+        end
+
+        # The Trans2 Data Block for a SET_PATH_INFORMATION request as defined
+        # in
+        # [MS-CIFS 2.2.6.7.1 Request](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-cifs/2ca0642a-1cd4-4e72-a16f-9e804a218262).
+        #
+        # The data layout depends on the Information Level being set, so the
+        # block carries an opaque byte buffer that the caller fills in for the
+        # target info level. SMB_SET_FILE_UNIX_LINK (0x0201) for example
+        # carries the symlink target as a null-terminated string.
+        class SetPathInformationRequestTrans2Data < BinData::Record
+          string :buffer, read_length: -> { parent.buffer_read_length }
+
+          # Returns the length of the Trans2Data struct
+          # in number of bytes
+          def length
+            do_num_bytes
+          end
+        end
+
+        # The {RubySMB::SMB1::DataBlock} specific to this packet type. See
+        # [MS-CIFS 2.2.6.7.1 Request](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-cifs/2ca0642a-1cd4-4e72-a16f-9e804a218262).
+        class SetPathInformationRequestDataBlock < RubySMB::SMB1::Packet::Trans2::DataBlock
+          uint8                                           :name,               label: 'Name', initial_value: 0x00
+          string                                          :pad1,               length: -> { pad1_length }
+          set_path_information_request_trans2_parameters  :trans2_parameters,  label: 'Trans2 Parameters'
+          string                                          :pad2,               length: -> { pad2_length }
+          set_path_information_request_trans2_data        :trans2_data,        label: 'Trans2 Data'
+        end
+
+        # A Trans2 SET_PATH_INFORMATION Request Packet as defined in
+        # [MS-CIFS 2.2.6.7.1 Request](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-cifs/2ca0642a-1cd4-4e72-a16f-9e804a218262).
+        # See also the subcommand overview at
+        # [MS-CIFS 2.2.6.7 TRANS2_SET_PATH_INFORMATION (0x0006)](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-cifs/a23483d9-6543-4aaa-a996-e7c9506f8b94).
+        class SetPathInformationRequest < RubySMB::GenericPacket
+          COMMAND = RubySMB::SMB1::Commands::SMB_COM_TRANSACTION2
+
+          class ParameterBlock < RubySMB::SMB1::Packet::Trans2::Request::ParameterBlock
+          end
+
+          smb_header                               :smb_header
+          parameter_block                          :parameter_block
+          set_path_information_request_data_block  :data_block
+
+          def initialize_instance
+            super
+            parameter_block.setup << RubySMB::SMB1::Packet::Trans2::Subcommands::SET_PATH_INFORMATION
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_smb/smb1/packet/trans2/set_path_information_response.rb

@@ -0,0 +1,51 @@
+module RubySMB
+  module SMB1
+    module Packet
+      module Trans2
+        # The Trans2 Parameter Block for a SET_PATH_INFORMATION response as
+        # defined in
+        # [MS-CIFS 2.2.6.7.2 Response](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-cifs/cf1cd579-9687-465d-9274-08ebb5944cd3).
+        class SetPathInformationResponseTrans2Parameters < BinData::Record
+          endian :little
+
+          uint16 :ea_error_offset, label: 'Extended Attribute Error Offset'
+
+          # Returns the length of the Trans2Parameters struct
+          # in number of bytes
+          def length
+            do_num_bytes
+          end
+        end
+
+        # The {RubySMB::SMB1::DataBlock} specific to this packet type. See
+        # [MS-CIFS 2.2.6.7.2 Response](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-cifs/cf1cd579-9687-465d-9274-08ebb5944cd3).
+        class SetPathInformationResponseDataBlock < RubySMB::SMB1::Packet::Trans2::DataBlock
+          string                                           :pad1,               length: -> { pad1_length }
+          set_path_information_response_trans2_parameters  :trans2_parameters,  label: 'Trans2 Parameters'
+          # trans2_data: No data is sent by this message.
+        end
+
+        # A Trans2 SET_PATH_INFORMATION Response Packet as defined in
+        # [MS-CIFS 2.2.6.7.2 Response](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-cifs/cf1cd579-9687-465d-9274-08ebb5944cd3).
+        # See also the subcommand overview at
+        # [MS-CIFS 2.2.6.7 TRANS2_SET_PATH_INFORMATION (0x0006)](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-cifs/a23483d9-6543-4aaa-a996-e7c9506f8b94).
+        class SetPathInformationResponse < RubySMB::GenericPacket
+          COMMAND = RubySMB::SMB1::Commands::SMB_COM_TRANSACTION2
+
+          class ParameterBlock < RubySMB::SMB1::Packet::Trans2::Response::ParameterBlock
+          end
+
+          smb_header                                :smb_header
+          parameter_block                           :parameter_block
+          set_path_information_response_data_block  :data_block
+
+          def initialize_instance
+            super
+            parameter_block.setup << RubySMB::SMB1::Packet::Trans2::Subcommands::SET_PATH_INFORMATION
+            smb_header.flags.reply = 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_smb/smb1/packet/trans2.rb

@@ -7,6 +7,8 @@ module RubySMB
         require 'ruby_smb/smb1/packet/trans2/find_information_level'
         require 'ruby_smb/smb1/packet/trans2/query_information_level'
         require 'ruby_smb/smb1/packet/trans2/query_fs_information_level'
+        require 'ruby_smb/smb1/packet/trans2/set_information_level'
+        require 'ruby_smb/smb1/packet/trans2/set_fs_information_level'
         require 'ruby_smb/smb1/packet/trans2/data_block'
         require 'ruby_smb/smb1/packet/trans2/win9x_framing'
         require 'ruby_smb/smb1/packet/trans2/subcommands'
@@ -23,6 +25,12 @@ module RubySMB
         require 'ruby_smb/smb1/packet/trans2/set_file_information_response'
         require 'ruby_smb/smb1/packet/trans2/query_path_information_request'
         require 'ruby_smb/smb1/packet/trans2/query_path_information_response'
+        require 'ruby_smb/smb1/packet/trans2/set_path_information_request'
+        require 'ruby_smb/smb1/packet/trans2/set_path_information_response'
+        require 'ruby_smb/smb1/packet/trans2/query_fs_information_request'
+        require 'ruby_smb/smb1/packet/trans2/query_fs_information_response'
+        require 'ruby_smb/smb1/packet/trans2/set_fs_information_request'
+        require 'ruby_smb/smb1/packet/trans2/set_fs_information_response'
       end
     end
   end

data/lib/ruby_smb/smb1/tree.rb

@@ -195,6 +195,66 @@ module RubySMB
         results
       end
 
+      # Create a UNIX symbolic link on the remote share using the CIFS UNIX
+      # Extensions SMB_SET_FILE_UNIX_LINK information level (0x0201) via a
+      # Trans2 SET_PATH_INFORMATION request.
+      #
+      # @example
+      #   tree = client.tree_connect("\\\\samba\\writable")
+      #   tree.set_unix_link(symlink: 'escape', target: '../../../../etc')
+      #
+      # @param symlink [String] the path, relative to the share, where the
+      #   symbolic link file will be created
+      # @param target [String] the destination the symbolic link points to
+      # @return [WindowsError::ErrorCode] the NTStatus returned by the server
+      # @raise [RubySMB::Error::InvalidPacket] if the response is not a Trans2
+      #   SET_PATH_INFORMATION response
+      # @raise [RubySMB::Error::UnexpectedStatusCode] if the response NTStatus
+      #   is not STATUS_SUCCESS
+      def set_unix_link(symlink:, target:)
+        # Samba gates SMB_SET_FILE_UNIX_LINK behind a per-session CIFS UNIX
+        # Extensions handshake: query server capabilities, then echo them
+        # back via SMB_SET_CIFS_UNIX_INFO. Without this, Samba responds to
+        # the symlink request with STATUS_INVALID_LEVEL even when
+        # `unix extensions = yes` is set server-side.
+        enable_cifs_unix_extensions
+
+        request = RubySMB::SMB1::Packet::Trans2::SetPathInformationRequest.new
+        request = set_header_fields(request)
+        # CIFS UNIX Extensions paths are raw byte strings, not UTF-16. Clear
+        # flags2.unicode so the filename parameter and target data block are
+        # emitted as bytes — Samba rejects the UTF-16 variant with
+        # STATUS_INVALID_LEVEL.
+        request.smb_header.flags2.unicode = 0
+
+        t2_params = request.data_block.trans2_parameters
+        t2_params.information_level = RubySMB::SMB1::Packet::Trans2::SetInformationLevel::SMB_SET_FILE_UNIX_LINK
+        t2_params.filename = symlink
+
+        encoded_target = target.dup.force_encoding(Encoding::ASCII_8BIT)
+        encoded_target << "\x00".b unless encoded_target.end_with?("\x00".b)
+        request.data_block.trans2_data.buffer = encoded_target
+
+        request.parameter_block.total_parameter_count = request.parameter_block.parameter_count
+        request.parameter_block.total_data_count      = request.parameter_block.data_count
+        request.parameter_block.max_parameter_count   = request.parameter_block.parameter_count
+        request.parameter_block.max_data_count        = 0
+
+        raw_response = client.send_recv(request)
+        response = RubySMB::SMB1::Packet::Trans2::SetPathInformationResponse.read(raw_response)
+        unless response.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB1::Packet::Trans2::SetPathInformationResponse::COMMAND,
+            packet:         response
+          )
+        end
+        unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
+          raise RubySMB::Error::UnexpectedStatusCode, response.status_code
+        end
+        response.status_code
+      end
+
       # Sets a few preset header fields that will always be set the same
       # way for Tree operations. This is, the TreeID and Extended Attributes.
       #
@@ -206,8 +266,72 @@ module RubySMB
         request
       end
 
+      # Perform the CIFS UNIX Extensions handshake on this tree: query the
+      # server's supported extensions (SMB_QUERY_CIFS_UNIX_INFO) and then
+      # echo the version and capability bits back via SMB_SET_CIFS_UNIX_INFO.
+      # Samba requires this round-trip to have completed on the current
+      # session before it will honor UNIX-extension info levels such as
+      # SMB_SET_FILE_UNIX_LINK.
+      #
+      # @return [WindowsError::ErrorCode] NTStatus of the SET reply
+      # @raise [RubySMB::Error::UnexpectedStatusCode] if either leg fails
+      def enable_cifs_unix_extensions
+        major, minor, capabilities = query_cifs_unix_info
+        set_cifs_unix_info(major: major, minor: minor, capabilities: capabilities)
+      end
+
       private
 
+      def query_cifs_unix_info
+        request = RubySMB::SMB1::Packet::Trans2::QueryFsInformationRequest.new
+        request = set_header_fields(request)
+        request.smb_header.flags2.unicode = 0
+        request.data_block.trans2_parameters.information_level =
+          RubySMB::SMB1::Packet::Trans2::QueryFsInformationLevel::SMB_QUERY_CIFS_UNIX_INFO
+        request.parameter_block.total_parameter_count = request.parameter_block.parameter_count
+        request.parameter_block.total_data_count      = 0
+        request.parameter_block.max_parameter_count   = 0
+        request.parameter_block.max_data_count        = 560
+
+        raw_response = client.send_recv(request)
+        response = RubySMB::SMB1::Packet::Trans2::QueryFsInformationResponse.read(raw_response)
+        unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
+          raise RubySMB::Error::UnexpectedStatusCode, response.status_code
+        end
+        info = RubySMB::SMB1::Packet::Trans2::QueryFsInformationLevel::QueryFsCifsUnixInfo.read(
+          response.data_block.trans2_data.buffer
+        )
+        [info.major_version.to_i, info.minor_version.to_i, info.capabilities.to_i]
+      end
+
+      def set_cifs_unix_info(major:, minor:, capabilities:)
+        request = RubySMB::SMB1::Packet::Trans2::SetFsInformationRequest.new
+        request = set_header_fields(request)
+        request.smb_header.flags2.unicode = 0
+        request.data_block.trans2_parameters.fid               = 0
+        request.data_block.trans2_parameters.information_level =
+          RubySMB::SMB1::Packet::Trans2::SetFsInformationLevel::SMB_SET_CIFS_UNIX_INFO
+
+        info = RubySMB::SMB1::Packet::Trans2::QueryFsInformationLevel::QueryFsCifsUnixInfo.new
+        info.major_version = major
+        info.minor_version = minor
+        info.capabilities  = capabilities
+        request.data_block.trans2_data.buffer = info.to_binary_s
+
+        request.parameter_block.total_parameter_count = request.parameter_block.parameter_count
+        request.parameter_block.total_data_count      = request.parameter_block.data_count
+        request.parameter_block.max_parameter_count   = request.parameter_block.parameter_count
+        request.parameter_block.max_data_count        = 0
+
+        raw_response = client.send_recv(request)
+        response = RubySMB::SMB1::Packet::Trans2::SetFsInformationResponse.read(raw_response)
+        unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
+          raise RubySMB::Error::UnexpectedStatusCode, response.status_code
+        end
+        response.status_code
+      end
+
+
       def _open(filename:, flags: nil, options: nil, disposition: RubySMB::Dispositions::FILE_OPEN,
                 impersonation: RubySMB::ImpersonationLevels::SEC_IMPERSONATE, read: true, write: false, delete: false)
         unless client.server_supports_nt_smbs

data/lib/ruby_smb/version.rb

@@ -1,3 +1,3 @@
 module RubySMB
-  VERSION = '3.3.19'.freeze
+  VERSION = '3.3.21'.freeze
 end

data/spec/lib/ruby_smb/smb1/packet/trans2/query_fs_information_request_spec.rb

@@ -40,7 +40,12 @@ RSpec.describe RubySMB::SMB1::Packet::Trans2::QueryFsInformationRequest do
 
     it { is_expected.to respond_to :name }
     it { is_expected.to respond_to :trans2_parameters }
-    it { is_expected.to_not respond_to :trans2_data }
+    it { is_expected.to respond_to :trans2_data }
+
+    it '#trans2_data is a zero-length placeholder (this request carries no data payload)' do
+      expect(data_block.trans2_data).to be_a BinData::String
+      expect(data_block.trans2_data.num_bytes).to eq 0
+    end
 
     it 'should keep #trans2_parameters 4-byte aligned' do
       expect(data_block.trans2_parameters.abs_offset % 4).to eq 0

data/spec/lib/ruby_smb/smb1/packet/trans2/set_fs_information_request_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::SMB1::Packet::Trans2::SetFsInformationRequest do
+  subject(:packet) { described_class.new }
+
+  describe '#smb_header' do
+    subject(:header) { packet.smb_header }
+
+    it { is_expected.to be_a RubySMB::SMB1::SMBHeader }
+
+    it 'has the command set to SMB_COM_TRANSACTION2' do
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_TRANSACTION2
+    end
+  end
+
+  describe '#parameter_block' do
+    subject(:parameter_block) { packet.parameter_block }
+
+    it { is_expected.to be_a RubySMB::SMB1::Packet::Trans2::Request::ParameterBlock }
+
+    it 'uses the SET_FS_INFORMATION subcommand' do
+      expect(parameter_block.setup[0]).to eq RubySMB::SMB1::Packet::Trans2::Subcommands::SET_FS_INFORMATION
+    end
+  end
+
+  describe '#data_block' do
+    subject(:data_block) { packet.data_block }
+
+    it { is_expected.to respond_to :trans2_parameters }
+    it { is_expected.to respond_to :trans2_data }
+
+    describe '#trans2_parameters' do
+      subject(:parameters) { data_block.trans2_parameters }
+
+      it { is_expected.to respond_to :fid }
+      it { is_expected.to respond_to :information_level }
+
+      it 'is 4 bytes on the wire (fid + information_level)' do
+        parameters.fid = 0
+        parameters.information_level = RubySMB::SMB1::Packet::Trans2::SetFsInformationLevel::SMB_SET_CIFS_UNIX_INFO
+        expect(parameters.to_binary_s.bytesize).to eq 4
+      end
+    end
+
+    describe '#trans2_data' do
+      it 'carries an opaque byte buffer whose contents depend on the information level' do
+        data_block.trans2_data.buffer = "\x01\x00\x00\x00".b + "\x00".b * 8
+        expect(data_block.trans2_data.buffer.bytesize).to eq 12
+      end
+    end
+  end
+end

data/spec/lib/ruby_smb/smb1/packet/trans2/set_fs_information_response_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::SMB1::Packet::Trans2::SetFsInformationResponse do
+  subject(:packet) { described_class.new }
+
+  describe '#smb_header' do
+    subject(:header) { packet.smb_header }
+
+    it { is_expected.to be_a RubySMB::SMB1::SMBHeader }
+
+    it 'has the command set to SMB_COM_TRANSACTION2' do
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_TRANSACTION2
+    end
+
+    it 'sets the reply flag' do
+      expect(header.flags.reply).to eq 1
+    end
+  end
+
+  describe '#parameter_block' do
+    subject(:parameter_block) { packet.parameter_block }
+
+    it { is_expected.to be_a RubySMB::SMB1::Packet::Trans2::Response::ParameterBlock }
+
+    it 'uses the SET_FS_INFORMATION subcommand' do
+      expect(parameter_block.setup[0]).to eq RubySMB::SMB1::Packet::Trans2::Subcommands::SET_FS_INFORMATION
+    end
+  end
+end

data/spec/lib/ruby_smb/smb1/packet/trans2/set_path_information_request_spec.rb

@@ -0,0 +1,114 @@
+RSpec.describe RubySMB::SMB1::Packet::Trans2::SetPathInformationRequest do
+  subject(:packet) { described_class.new }
+
+  describe '#smb_header' do
+    subject(:header) { packet.smb_header }
+
+    it 'is a standard SMB Header' do
+      expect(header).to be_a RubySMB::SMB1::SMBHeader
+    end
+
+    it 'should have the command set to SMB_COM_TRANSACTION2' do
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_TRANSACTION2
+    end
+
+    it 'should not have the response flag set' do
+      expect(header.flags.reply).to eq 0
+    end
+  end
+
+  describe '#parameter_block' do
+    subject(:parameter_block) { packet.parameter_block }
+
+    it 'is a standard ParameterBlock' do
+      expect(parameter_block).to be_a RubySMB::SMB1::Packet::Trans2::Request::ParameterBlock
+    end
+
+    it 'should have the setup set to the SET_PATH_INFORMATION subcommand' do
+      expect(parameter_block.setup).to include RubySMB::SMB1::Packet::Trans2::Subcommands::SET_PATH_INFORMATION
+    end
+  end
+
+  describe '#data_block' do
+    subject(:data_block) { packet.data_block }
+
+    it 'is a standard DataBlock' do
+      expect(data_block).to be_a RubySMB::SMB1::DataBlock
+    end
+
+    it { is_expected.to respond_to :name }
+    it { is_expected.to respond_to :trans2_parameters }
+    it { is_expected.to respond_to :trans2_data }
+
+    it 'should keep #trans2_parameters 4-byte aligned' do
+      expect(data_block.trans2_parameters.abs_offset % 4).to eq 0
+    end
+
+    describe '#trans2_parameters' do
+      subject(:parameters) { data_block.trans2_parameters }
+
+      it { is_expected.to respond_to :information_level }
+      it { is_expected.to respond_to :reserved }
+      it { is_expected.to respond_to :filename }
+
+      describe '#information_level' do
+        it 'is a 16-bit field' do
+          expect(parameters.information_level).to be_a BinData::Uint16le
+        end
+      end
+
+      describe '#reserved' do
+        it 'is a 32-bit field' do
+          expect(parameters.reserved).to be_a BinData::Uint32le
+        end
+      end
+
+      describe '#filename' do
+        it 'is a BinData::Choice' do
+          expect(parameters.filename).to be_a BinData::Choice
+        end
+
+        it 'encodes the filename as OEM when the unicode flag is cleared' do
+          packet.smb_header.flags2.unicode = 0
+          parameters.filename = 'link'
+          expect(parameters.filename.to_binary_s).to eq "link\x00".b
+        end
+
+        it 'encodes the filename as UTF-16LE when the unicode flag is set' do
+          packet.smb_header.flags2.unicode = 1
+          parameters.filename = 'link'
+          expect(parameters.filename.to_binary_s).to eq "link\x00".encode('UTF-16LE').b
+        end
+      end
+    end
+
+    describe '#trans2_data' do
+      subject(:data) { data_block.trans2_data }
+
+      it { is_expected.to respond_to :buffer }
+
+      it 'carries an opaque byte buffer for the info-level-specific payload' do
+        data.buffer = "target\x00"
+        expect(data.buffer.to_binary_s).to eq "target\x00".b
+      end
+    end
+  end
+
+  describe 'encoded bytes for an SMB_SET_FILE_UNIX_LINK request' do
+    it 'encodes the information level, filename and target in the expected positions' do
+      packet.smb_header.flags2.unicode = 1
+      packet.data_block.trans2_parameters.information_level =
+        RubySMB::SMB1::Packet::Trans2::SetInformationLevel::SMB_SET_FILE_UNIX_LINK
+      packet.data_block.trans2_parameters.filename = 'foo'
+      packet.data_block.trans2_data.buffer = "bar\x00".encode('UTF-16LE')
+
+      raw = packet.to_binary_s
+      # Information level (little-endian 0x0201)
+      expect(raw).to include("\x01\x02".b)
+      # Filename in UTF-16LE with null terminator
+      expect(raw).to include("foo\x00".encode('UTF-16LE').b)
+      # Target in UTF-16LE with null terminator
+      expect(raw).to include("bar\x00".encode('UTF-16LE').b)
+    end
+  end
+end

data/spec/lib/ruby_smb/smb1/packet/trans2/set_path_information_response_spec.rb

@@ -0,0 +1,54 @@
+RSpec.describe RubySMB::SMB1::Packet::Trans2::SetPathInformationResponse do
+  subject(:packet) { described_class.new }
+
+  describe '#smb_header' do
+    subject(:header) { packet.smb_header }
+
+    it 'is a standard SMB Header' do
+      expect(header).to be_a RubySMB::SMB1::SMBHeader
+    end
+
+    it 'should have the command set to SMB_COM_TRANSACTION2' do
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_TRANSACTION2
+    end
+
+    it 'should have the response flag set' do
+      expect(header.flags.reply).to eq 1
+    end
+  end
+
+  describe '#parameter_block' do
+    subject(:parameter_block) { packet.parameter_block }
+
+    it 'should have the setup set to the SET_PATH_INFORMATION subcommand' do
+      expect(parameter_block.setup).to include RubySMB::SMB1::Packet::Trans2::Subcommands::SET_PATH_INFORMATION
+    end
+  end
+
+  describe '#data_block' do
+    subject(:data_block) { packet.data_block }
+
+    it 'is a standard DataBlock' do
+      expect(data_block).to be_a RubySMB::SMB1::DataBlock
+    end
+
+    it { is_expected.to respond_to :trans2_parameters }
+    it { is_expected.to_not respond_to :trans2_data }
+
+    it 'should keep #trans2_parameters 4-byte aligned' do
+      expect(data_block.trans2_parameters.abs_offset % 4).to eq 0
+    end
+
+    describe '#trans2_parameters' do
+      subject(:parameters) { data_block.trans2_parameters }
+
+      it { is_expected.to respond_to :ea_error_offset }
+
+      describe '#ea_error_offset' do
+        it 'is a 16-bit field' do
+          expect(parameters.ea_error_offset).to be_a BinData::Uint16le
+        end
+      end
+    end
+  end
+end