omnizip 0.3.4 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f138ecaafda0455b4a5d3abce1ce426dcbfc2fd851bcdf0e0b0892a9b9b4287
-  data.tar.gz: 1f94b97bd5e7b102abb907170d393edf4b192059c6aa5862d81b5b48ee354466
+  metadata.gz: 6a395e650c4db2554fed636efcec40fec1b1f77e77d2c778fbfbe336fe5fbcd8
+  data.tar.gz: 7846eed6f91af6b9e21cb0d17418bbbbe868c2c76109e1456a8db2a8eb561094
 SHA512:
-  metadata.gz: 946e0c8adee99dde0acbf309a1ca30765459f15d543775f1964ca603eee24bd1628582797aa7567ed367c46d0f6adf03f56541071e83dfe0ca91f476289f0166
-  data.tar.gz: 3e9760f59d981bd97976099dd46eae135ad569a1259d37205a51b4e8a081379ff3f53c08d262a680a131619ca16dd8cdeb27aec89e381e1347d4c2436ac24a62
+  metadata.gz: 32c4633a90fe9d134cea551c0dd2293d0e488d32650a136d1cc41d5c8b438fd762a181cdadaa212366fe10a0c6066b2fc27a162a9129dacbd5485906b130a6ce
+  data.tar.gz: dcc450866ff51cec1373009aee2dc1d4a7d37a061dd2dbcb3ceb9e50f34cdf8465b33a63261bf10f334d5dc6512940b7cb1d97392c0b33067d53f85a99b5679e

data/lib/omnizip/formats/ole/allocation_table.rb

@@ -188,6 +188,11 @@ module Omnizip
           temp.reverse
         end
 
+        # Truncate entries in place
+        def truncate_entries
+          @entries.replace(truncate)
+        end
+
         # Pack table to binary data
         #
         # @return [String] Binary data

data/lib/omnizip/formats/ole/dirent.rb

@@ -212,9 +212,15 @@ module Omnizip
           @reserved = values[13]
 
           # Decode name from UTF-16LE
-          name_data = @name_utf16[0...@name_len]
+          # name_len includes the null terminator
+          name_data = @name_utf16[0...@name_len] if @name_len.positive?
           @name = begin
-            Types::Variant.load(Types::Variant::VT_LPWSTR, name_data)
+            # Decode and strip null terminator
+            decoded = name_data.dup.force_encoding(Encoding::UTF_16LE)
+            # Remove trailing null character (UTF-16 null = 2 bytes)
+            null_char = "\x00".encode(Encoding::UTF_16LE)
+            decoded = decoded.chomp(null_char)
+            decoded.encode(Encoding::UTF_8)
           rescue StandardError
             ""
           end
@@ -248,11 +254,14 @@ module Omnizip
         #
         # @return [String] 128-byte binary data
         def pack
-          # Encode name to UTF-16LE
+          # Encode name to UTF-16LE with null terminator
           name_data = Types::Variant.dump(Types::Variant::VT_LPWSTR, @name)
-          name_data = name_data[0, 62] if name_data.length > 62
-          name_data += "\x00\x00".b
+          # Truncate to 62 bytes if needed (leaving room for null terminator)
+          name_data = name_data[0, 62] + "\x00\x00".b if name_data.length > 62
+          # Ensure null terminator exists
+          name_data += "\x00\x00".b unless name_data.end_with?("\x00\x00".b)
           @name_len = name_data.length
+          # Pad to 64 bytes total
           @name_utf16 = name_data + ("\x00".b * (64 - name_data.length))
 
           # Set type_id from type
@@ -291,6 +300,29 @@ module Omnizip
           bat.read(@first_block, @size)
         end
 
+        # Open stream for reading or writing
+        #
+        # @param mode [String] Open mode ('r' for read, 'w' for write)
+        # @yield [RangesIOMigrateable] IO object
+        # @return [RangesIOMigrateable]
+        # @raise [Errno::EISDIR] If entry is a directory
+        def open(mode = "r")
+          raise Errno::EISDIR unless file?
+
+          io = RangesIOMigrateable.new(self, mode)
+          @modify_time = Time.now if io.respond_to?(:writeable?) && io.writeable?
+
+          if block_given?
+            begin
+              yield io
+            ensure
+              io.close
+            end
+          else
+            io
+          end
+        end
+
         # Lookup child by name
         #
         # @param name [String] Child name

data/lib/omnizip/formats/ole/ranges_io.rb

@@ -51,8 +51,12 @@ module Omnizip
         #
         # @param ranges [Array<Range, Array>] Byte ranges
         def ranges=(ranges)
-          # Convert Range objects to arrays
-          @ranges = ranges.map do |r|
+          ranges ||= []
+
+          # Convert Range objects to arrays, filtering out nils
+          @ranges = ranges.filter_map do |r|
+            next nil if r.nil?
+
             r.is_a?(Range) ? [r.begin, r.end - r.begin] : r
           end
 
@@ -259,6 +263,67 @@ module Omnizip
           @io.truncate(max_pos) if max_pos > @io.size
         end
       end
+
+      # RangesIO that can migrate between BAT and SBAT based on size
+      class RangesIOMigrateable < RangesIOResizeable
+        # @return [Dirent] Associated dirent
+        attr_reader :dirent
+
+        # Initialize migrateable RangesIO
+        #
+        # @param dirent [Dirent] Associated dirent
+        # @param mode [String] Open mode
+        def initialize(dirent, mode = "r")
+          @dirent = dirent
+          bat = dirent.ole.bat_for_size(dirent.size)
+          super(bat, first_block: dirent.first_block, size: dirent.size)
+          @mode = mode
+        end
+
+        # Check if writable
+        def writeable?
+          @mode.include?("w") || @mode.include?("a") || @mode.include?("+")
+        end
+
+        # Truncate with BAT migration support
+        #
+        # @param new_size [Integer] New size in bytes
+        def truncate(new_size)
+          new_bat = @dirent.ole.bat_for_size(new_size)
+
+          if new_bat.instance_of?(@bat.class)
+            super
+          else
+            # BAT migration needed
+            pos = [@pos, new_size].min
+            self.pos = 0
+            keep = read([@size, new_size].min)
+            super(0)
+
+            @bat = new_bat
+            @io = new_bat.io
+            super
+
+            self.pos = 0
+            write(keep)
+            self.pos = pos
+          end
+
+          # Update dirent's first_block and size after any resize
+          @dirent.first_block = @first_block
+          @dirent.size = new_size
+        end
+
+        # Forward first_block to dirent (for reading)
+        def first_block
+          @first_block
+        end
+
+        def first_block=(val)
+          @first_block = val
+          @dirent.first_block = val
+        end
+      end
     end
   end
 end

data/lib/omnizip/formats/ole/storage.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "set"
 require_relative "constants"
 require_relative "header"
 require_relative "allocation_table"
@@ -142,28 +143,178 @@ module Omnizip
         #
         # @param dirents [Array<Dirent>]
         # @param idx [Integer]
+        # @param visited [Set] Set of visited indices to detect cycles
         # @return [Array<Dirent>]
-        def build_tree(dirents, idx = 0)
+        def build_tree(dirents, idx = 0, visited = nil)
           return [] if idx == EOT
 
+          # Initialize visited set on first call
+          visited ||= Set.new
+
+          # Check for circular references
+          return [] if visited.include?(idx)
+
+          visited << idx
+
           dirent = dirents[idx]
+          return [] unless dirent
 
           # Build children recursively
-          build_tree(dirents, dirent.child).each { |child| dirent << child }
+          build_tree(dirents, dirent.child, visited).each { |child| dirent << child }
 
           # Set index
           dirent.idx = idx
 
           # Return list for tree building
-          build_tree(dirents, dirent.prev) + [dirent] + build_tree(dirents, dirent.next)
+          build_tree(dirents, dirent.prev, visited) + [dirent] + build_tree(dirents, dirent.next, visited)
         end
 
         # Close storage
         def close
           @sb_file&.close
+          flush if @writeable
           @io.close if @close_parent
         end
 
+        # Flush all changes to disk
+        #
+        # Writes all metadata (dirents, allocation tables, header) to the file.
+        # This is the main "save" method for OLE documents.
+        def flush
+          return unless @writeable
+
+          # Update root dirent
+          @root.name = "Root Entry"
+          @root.first_block = @sb_file.first_block
+          @root.size = @sb_file.size
+
+          # Flatten dirent tree
+          @dirents = @root.flatten
+
+          # Serialize dirents using bbat
+          dirent_io = RangesIOResizeable.new(@bbat, first_block: @header.dirent_start)
+          dirent_io.write(@dirents.map(&:pack).join)
+          # Pad to block boundary
+          padding = ((dirent_io.size / @bbat.block_size.to_f).ceil * @bbat.block_size) - dirent_io.size
+          dirent_io.write("\x00".b * padding) if padding.positive?
+          @header.dirent_start = dirent_io.first_block
+          dirent_io.close
+
+          # Serialize sbat
+          sbat_io = RangesIOResizeable.new(@bbat, first_block: @header.sbat_start)
+          sbat_io.write(@sbat.pack)
+          @header.sbat_start = sbat_io.first_block
+          @header.num_sbat = @bbat.chain(@header.sbat_start).length
+          sbat_io.close
+
+          # Clear BAT/META_BAT markers
+          @bbat.entries.each_with_index do |val, idx|
+            if [BAT, META_BAT].include?(val)
+              @bbat.entries[idx] = AVAIL
+            end
+          end
+
+          # Calculate and allocate BAT blocks
+          write_bat_blocks
+
+          # Write header
+          @io.seek(0)
+          @io.write(@header.pack)
+          @io.write(@bbat_chain.pack("V*"))
+          @io.flush
+        end
+
+        private
+
+        # Write BAT (Block Allocation Table) blocks
+        def write_bat_blocks
+          # Truncate bbat to remove trailing AVAILs
+          @bbat.entries.replace(@bbat.entries.reject { |e| e == AVAIL }.push(AVAIL))
+
+          # Calculate space needed for BAT
+          num_mbat_blocks = 0
+          io = RangesIOResizeable.new(@bbat, first_block: EOC)
+
+          @bbat.truncate_entries
+          @io.truncate(@bbat.block_size * (@bbat.length + 1))
+
+          # Iteratively calculate BAT/MBAT space
+          loop do
+            bbat_data_len = ((@bbat.length + num_mbat_blocks) * 4 / @bbat.block_size.to_f).ceil * @bbat.block_size
+            new_num_mbat_blocks = calculate_mbat_blocks(bbat_data_len)
+
+            if new_num_mbat_blocks != num_mbat_blocks
+              num_mbat_blocks = new_num_mbat_blocks
+            elsif io.size != bbat_data_len
+              io.truncate(bbat_data_len)
+            else
+              break
+            end
+          end
+
+          # Get BAT chain and mark blocks
+          @bbat_chain = @bbat.chain(io.first_block)
+          io.close
+
+          @bbat_chain.each { |b| @bbat.entries[b] = BAT }
+          @header.num_bat = @bbat_chain.length
+
+          # Allocate MBAT blocks if needed
+          mbat_blocks = allocate_mbat_blocks(num_mbat_blocks)
+          @header.mbat_start = mbat_blocks.first || EOC
+          @header.num_mbat = num_mbat_blocks
+
+          # Write BAT data
+          RangesIO.open(@io, @bbat.ranges(@bbat_chain)) do |f|
+            f.write(@bbat.pack)
+          end
+
+          # Write MBAT if present
+          write_mbat_blocks(mbat_blocks, num_mbat_blocks) if num_mbat_blocks.positive?
+
+          # Pad BAT chain to 109 entries in header
+          @bbat_chain += [AVAIL] * [109 - @bbat_chain.length, 0].max
+        end
+
+        # Calculate number of MBAT blocks needed
+        def calculate_mbat_blocks(bbat_data_len)
+          excess_bat_blocks = (bbat_data_len / @bbat.block_size) - 109
+          return 0 if excess_bat_blocks <= 0
+
+          (excess_bat_blocks * 4 / (@bbat.block_size - 4).to_f).ceil
+        end
+
+        # Allocate MBAT blocks
+        def allocate_mbat_blocks(count)
+          (0...count).map do
+            block = @bbat.free_block
+            @bbat.entries[block] = META_BAT
+            block
+          end
+        end
+
+        # Write MBAT blocks
+        def write_mbat_blocks(mbat_blocks, _num_mbat)
+          # Get BAT entries beyond the first 109
+          mbat_data = @bbat_chain[109..] || []
+
+          # Add linked list pointers
+          entries_per_block = (@bbat.block_size / 4) - 1
+          mbat_data = mbat_data.each_slice(entries_per_block).to_a
+
+          mbat_data.zip(mbat_blocks[1..] + [nil]).each_with_index do |(entries, next_block), idx|
+            block_data = entries + (next_block ? [next_block] : [])
+            # Pad to block size
+            block_data += [AVAIL] * ((@bbat.block_size / 4) - block_data.length)
+
+            RangesIO.open(@io, @bbat.ranges([mbat_blocks[idx]])) do |f|
+              f.write(block_data.pack("V*"))
+            end
+          end
+        end
+
+        public
+
         # Get appropriate BAT for size
         #
         # @param size [Integer] File size

data/lib/omnizip/formats/ole/types/variant.rb

@@ -42,9 +42,12 @@ module Omnizip
           def self.load(str)
             return new("") if str.nil? || str.empty?
 
-            # Decode UTF-16LE to UTF-8, strip null terminator
-            decoded = str.encode(Encoding::UTF_8, Encoding::UTF_16LE)
-            new(decoded.chomp("\x00"))
+            # Force binary data to UTF-16LE encoding, then transcode to UTF-8
+            # Strip null terminator (UTF-16 null = 2 bytes)
+            decoded = str.dup.force_encoding(Encoding::UTF_16LE)
+            decoded = decoded.chomp("\x00".encode(Encoding::UTF_16LE))
+            decoded = decoded.encode(Encoding::UTF_8)
+            new(decoded)
           end
 
           # Dump to UTF-16LE binary data

data/lib/omnizip/formats/rpm/writer.rb

@@ -0,0 +1,546 @@
+# frozen_string_literal: true
+
+require "set"
+require "zlib"
+require "stringio"
+require "digest"
+require_relative "constants"
+require_relative "lead"
+require_relative "header"
+require_relative "tag"
+require_relative "../cpio/writer"
+
+module Omnizip
+  module Formats
+    module Rpm
+      # RPM package writer
+      #
+      # Creates RPM packages with binary payload (CPIO archive).
+      # Supports gzip compression for the payload.
+      #
+      # @example Create an RPM package
+      #   writer = Rpm::Writer.new(
+      #     name: "myapp",
+      #     version: "1.0.0",
+      #     release: "1",
+      #     arch: "x86_64"
+      #   )
+      #   writer.add_file("/usr/bin/myapp", content, mode: 0755)
+      #   writer.add_directory("/etc/myapp")
+      #   writer.add_file("/etc/myapp/config.yml", config_content)
+      #   writer.write("myapp-1.0.0-1.x86_64.rpm")
+      #
+      class Writer
+        include Constants
+
+        # Architecture mapping
+        ARCHITECTURES = {
+          "noarch" => 0,
+          "i386" => 1,
+          "i486" => 2,
+          "i586" => 3,
+          "i686" => 4,
+          "x86_64" => 9,
+          "amd64" => 9,
+          "ia64" => 11,
+          "ppc" => 5,
+          "ppc64" => 16,
+          "sparc" => 6,
+          "sparc64" => 7,
+          "alpha" => 8,
+          "s390" => 14,
+          "s390x" => 15,
+          "arm" => 12,
+          "aarch64" => 19,
+        }.freeze
+
+        # Tag ID mapping (reverse of Tag::TAG_IDS)
+        TAG_NAMES = {
+          # Header tags
+          name: 1000,
+          version: 1001,
+          release: 1002,
+          epoch: 1003,
+          summary: 1004,
+          description: 1005,
+          buildtime: 1006,
+          buildhost: 1007,
+          size: 1009,
+          distribution: 1010,
+          vendor: 1011,
+          license: 1014,
+          packager: 1015,
+          group: 1016,
+          url: 1020,
+          os: 1021,
+          arch: 1022,
+          prein: 1023,
+          postin: 1024,
+          preun: 1025,
+          postun: 1026,
+          filesizes: 1028,
+          filemodes: 1030,
+          fileuids: 1031,
+          filegids: 1032,
+          filemtimes: 1034,
+          filedigests: 1035,
+          filelinktos: 1036,
+          fileflags: 1037,
+          fileusername: 1039,
+          filegroupname: 1040,
+          archivesize: 1046,
+          rpmversion: 1064,
+          dirindexes: 1116,
+          basenames: 1117,
+          dirnames: 1118,
+          payloadformat: 1124,
+          payloadcompressor: 1125,
+          payloadflags: 1126,
+
+          # Signature tags
+          sigsize: 257,
+          sha1header: 269,
+        }.freeze
+
+        # @return [String] Package name
+        attr_reader :name
+
+        # @return [String] Package version
+        attr_reader :version
+
+        # @return [String] Package release
+        attr_reader :release
+
+        # @return [String, nil] Package epoch
+        attr_reader :epoch
+
+        # @return [String] Architecture
+        attr_reader :arch
+
+        # @return [Hash<String, String>] File contents
+        attr_reader :files
+
+        # @return [Hash] Additional metadata
+        attr_reader :metadata
+
+        # Initialize RPM writer
+        #
+        # @param name [String] Package name
+        # @param version [String] Package version
+        # @param release [String] Package release
+        # @param arch [String] Architecture (default: "noarch")
+        # @param epoch [String, nil] Optional epoch
+        # @param metadata [Hash] Additional metadata
+        def initialize(name:, version:, release:, arch: "noarch", epoch: nil, **metadata)
+          @name = name
+          @version = version
+          @release = release
+          @arch = arch
+          @epoch = epoch
+          @metadata = metadata
+          @files = []
+          @directories = []
+          @compression = :gzip
+        end
+
+        # Add file to package
+        #
+        # @param path [String] File path in package (absolute path)
+        # @param content [String] File content
+        # @param mode [Integer] File permissions (default: 0644)
+        # @param owner [String] File owner (default: "root")
+        # @param group [String] File group (default: "root")
+        # @param mtime [Integer] Modification time (default: now)
+        def add_file(path, content, mode: 0o644, owner: "root", group: "root", mtime: nil)
+          @files << {
+            path: path,
+            content: content,
+            mode: mode,
+            owner: owner,
+            group: group,
+            mtime: mtime || Time.now.to_i,
+          }
+        end
+
+        # Add directory to package
+        #
+        # @param path [String] Directory path in package (absolute path)
+        # @param mode [Integer] Directory permissions (default: 0755)
+        # @param owner [String] Directory owner (default: "root")
+        # @param group [String] Directory group (default: "root")
+        def add_directory(path, mode: 0o755, owner: "root", group: "root")
+          @directories << {
+            path: path,
+            mode: mode,
+            owner: owner,
+            group: group,
+          }
+        end
+
+        # Write RPM package to file
+        #
+        # @param output_path [String] Output file path
+        # @return [String] Output path
+        def write(output_path)
+          File.open(output_path, "wb") do |io|
+            write_to_io(io)
+          end
+          output_path
+        end
+
+        # Write RPM package to IO
+        #
+        # @param io [IO] Output IO
+        def write_to_io(io)
+          # Build payload (compressed CPIO)
+          payload_io = StringIO.new("".b)
+          cpio_data = build_cpio_payload
+          compress_payload(cpio_data, payload_io)
+          payload_io.rewind
+          payload_data = payload_io.read
+
+          # Build headers
+          main_header = build_main_header(payload_data.bytesize)
+          sig_header = build_signature_header(main_header.bytesize, payload_data.bytesize)
+
+          # Build lead
+          lead = build_lead
+
+          # Write RPM in order
+          io.write(lead)
+          io.write(sig_header)
+          io.write(main_header)
+          io.write(payload_data)
+        end
+
+        private
+
+        # Build lead (96 bytes)
+        #
+        # @return [String] Packed lead
+        def build_lead
+          name_field = "#{@name}-#{@version}-#{@release}"
+          name_field = name_field[0, 65] # Truncate to 65 chars + null
+          name_padded = name_field.ljust(66, "\0")
+
+          arch_num = ARCHITECTURES.fetch(@arch.downcase, 0)
+
+          # Pack format:
+          # A4 = magic (4 bytes)
+          # CC = major/minor version (2 bytes)
+          # n = package type (2 bytes, 0 = binary)
+          # n = architecture (2 bytes)
+          # A66 = name (66 bytes)
+          # n = os (2 bytes, 1 = Linux)
+          # n = signature type (2 bytes, 5 = signed)
+          # A16 = reserved (16 bytes)
+          [LEAD_MAGIC, 3, 0, PACKAGE_BINARY, arch_num, name_padded, 1,
+           HEADER_SIGNED_TYPE, "\0" * 16].pack("A4 CC n n A66 n n A16")
+        end
+
+        # Build signature header
+        #
+        # @param header_size [Integer] Main header size
+        # @param payload_size [Integer] Payload size
+        # @return [String] Packed signature header
+        def build_signature_header(header_size, payload_size)
+          tags = [
+            { id: TAG_NAMES[:sigsize], type: TYPE_INT32, value: [header_size + payload_size] },
+            { id: TAG_NAMES[:sha1header], type: TYPE_STRING, value: "" },
+          ]
+          build_header_data(tags)
+        end
+
+        # Build main header
+        #
+        # @param payload_size [Integer] Payload size (uncompressed)
+        # @return [String] Packed main header
+        def build_main_header(payload_size)
+          # Build file lists
+          dirnames = []
+          basenames = []
+          dirindexes = []
+          filemodes = []
+          filesizes = []
+          fileowners = []
+          filegroups = []
+          filemtimes = []
+          filedigests = []
+          filelinktos = []
+          fileflags = []
+
+          # Process directories first
+          dir_set = Set.new
+          @directories.each do |dir|
+            dir_path = dir[:path]
+            parent = File.dirname(dir_path.sub(%r{/+$}, ""))
+            dir_name = File.basename(dir_path.sub(%r{/+$}, ""))
+
+            dir_set.size
+            dir_set << dir_path
+
+            # Parent directory for relative path
+            parent_dir = parent == "." ? "/" : parent
+            dirnames.size
+            dirnames << parent_dir unless dirnames.include?(parent_dir)
+            parent_index = dirnames.index(parent_dir)
+
+            basenames << dir_name
+            dirindexes << parent_index
+            filemodes << (dir[:mode] | 0o040000) # Directory flag
+            filesizes << 4096 # Typical directory size
+            fileowners << dir[:owner]
+            filegroups << dir[:group]
+            filemtimes << Time.now.to_i
+            filedigests << ""
+            filelinktos << ""
+            fileflags << 0
+          end
+
+          # Process files
+          @files.each do |file|
+            file_path = file[:path]
+            parent_dir = File.dirname(file_path)
+            base_name = File.basename(file_path)
+
+            # Ensure directory is in list
+            dir_index = dirnames.index(parent_dir)
+            dir_index ||= dirnames.size.tap { dirnames << parent_dir }
+
+            basenames << base_name
+            dirindexes << dir_index
+            filemodes << file[:mode]
+            filesizes << file[:content].bytesize
+            fileowners << file[:owner]
+            filegroups << file[:group]
+            filemtimes << file[:mtime]
+            filedigests << Digest::MD5.hexdigest(file[:content])
+            filelinktos << ""
+            fileflags << 0
+          end
+
+          tags = [
+            { id: TAG_NAMES[:name], type: TYPE_STRING, value: @name },
+            { id: TAG_NAMES[:version], type: TYPE_STRING, value: @version },
+            { id: TAG_NAMES[:release], type: TYPE_STRING, value: @release },
+            { id: TAG_NAMES[:arch], type: TYPE_STRING, value: @arch },
+            { id: TAG_NAMES[:os], type: TYPE_STRING, value: "linux" },
+            { id: TAG_NAMES[:rpmversion], type: TYPE_STRING, value: "4.16.0" },
+            { id: TAG_NAMES[:payloadformat], type: TYPE_STRING, value: "cpio" },
+            { id: TAG_NAMES[:payloadcompressor], type: TYPE_STRING, value: "gzip" },
+            { id: TAG_NAMES[:payloadflags], type: TYPE_STRING, value: "9" },
+            { id: TAG_NAMES[:archivesize], type: TYPE_INT32, value: [payload_size] },
+            { id: TAG_NAMES[:dirnames], type: TYPE_STRING_ARRAY, value: dirnames },
+            { id: TAG_NAMES[:basenames], type: TYPE_STRING_ARRAY, value: basenames },
+            { id: TAG_NAMES[:dirindexes], type: TYPE_INT32, value: dirindexes },
+            { id: TAG_NAMES[:filemodes], type: TYPE_INT16, value: filemodes },
+            { id: TAG_NAMES[:filesizes], type: TYPE_INT32, value: filesizes },
+            { id: TAG_NAMES[:fileusername], type: TYPE_STRING_ARRAY, value: fileowners },
+            { id: TAG_NAMES[:filegroupname], type: TYPE_STRING_ARRAY, value: filegroups },
+            { id: TAG_NAMES[:filemtimes], type: TYPE_INT32, value: filemtimes },
+            { id: TAG_NAMES[:filedigests], type: TYPE_STRING_ARRAY, value: filedigests },
+            { id: TAG_NAMES[:filelinktos], type: TYPE_STRING_ARRAY, value: filelinktos },
+            { id: TAG_NAMES[:fileflags], type: TYPE_INT32, value: fileflags },
+          ]
+
+          # Add optional metadata
+          {
+            summary: TYPE_STRING,
+            description: TYPE_STRING,
+            license: TYPE_STRING,
+            group: TYPE_STRING,
+            url: TYPE_STRING,
+            vendor: TYPE_STRING,
+            packager: TYPE_STRING,
+          }.each do |key, type|
+            value = @metadata[key]
+            tags << { id: TAG_NAMES[key], type: type, value: value } if value
+          end
+
+          tags << { id: TAG_NAMES[:epoch], type: TYPE_INT32, value: [@epoch.to_i] } if @epoch
+
+          build_header_data(tags)
+        end
+
+        # Build header data structure
+        #
+        # @param tags [Array<Hash>] Array of tag definitions
+        # @return [String] Packed header
+        def build_header_data(tags)
+          # Build data blob and tag entries
+          data_blob = "".b
+          tag_entries = []
+
+          tags.each do |tag_def|
+            offset = data_blob.bytesize
+            value = tag_def[:value]
+            type = tag_def[:type]
+
+            packed_data = pack_tag_value(type, value)
+            data_blob << packed_data
+
+            count = case type
+                    when TYPE_STRING_ARRAY
+                      value.is_a?(Array) ? value.size : 1
+                    when TYPE_STRING
+                      1
+                    else
+                      value.is_a?(Array) ? value.size : 1
+                    end
+
+            tag_entries << [tag_def[:id], type, offset, count].pack("NNNN")
+          end
+
+          # Build complete header
+          entry_count = tags.size
+          data_length = data_blob.bytesize
+
+          # Pad data blob to 8-byte boundary
+          padding = (8 - (data_length % 8)) % 8
+          data_blob << ("\0" * padding)
+
+          # Header header: magic (8) + entry_count (4) + data_length (4)
+          header_header = [HEADER_MAGIC, entry_count, data_blob.bytesize].pack("A8 NN")
+
+          header_header + tag_entries.join + data_blob
+        end
+
+        # Pack tag value based on type
+        #
+        # @param type [Integer] Tag type
+        # @param value [Object] Value to pack
+        # @return [String] Packed data
+        def pack_tag_value(type, value)
+          case type
+          when TYPE_STRING
+            "#{value}\0".b
+          when TYPE_STRING_ARRAY
+            value.map { |v| "#{v}\0" }.join.b
+          when TYPE_INT8
+            [value].flatten.pack("C*")
+          when TYPE_INT16
+            [value].flatten.pack("n*")
+          when TYPE_INT32
+            [value].flatten.pack("N*")
+          when TYPE_INT64
+            [value].flatten.pack("Q>")
+          when TYPE_BINARY
+            value.b
+          else
+            value.to_s.b
+          end
+        end
+
+        # Build CPIO payload
+        #
+        # @return [String] CPIO archive data
+        def build_cpio_payload
+          cpio_io = StringIO.new("".b)
+
+          # Write directories
+          @directories.each do |dir|
+            entry_data = build_cpio_directory_entry(dir)
+            cpio_io.write(entry_data)
+          end
+
+          # Write files
+          @files.each do |file|
+            entry_data = build_cpio_file_entry(file)
+            cpio_io.write(entry_data)
+          end
+
+          # Write trailer
+          cpio_io.write(build_cpio_trailer)
+
+          cpio_io.string
+        end
+
+        # Build CPIO directory entry
+        #
+        # @param dir [Hash] Directory info
+        # @return [String] Packed CPIO entry
+        def build_cpio_directory_entry(dir)
+          mode = dir[:mode] | 0o040000 # Directory flag
+          path = dir[:path].sub(%r{/+$}, "") # Remove trailing slashes
+
+          build_cpio_entry(path, "", mode)
+        end
+
+        # Build CPIO file entry
+        #
+        # @param file [Hash] File info
+        # @return [String] Packed CPIO entry
+        def build_cpio_file_entry(file)
+          build_cpio_entry(file[:path], file[:content], file[:mode])
+        end
+
+        # Build CPIO entry (newc format)
+        #
+        # @param path [String] Entry path
+        # @param data [String] Entry data
+        # @param mode [Integer] File mode
+        # @return [String] Packed CPIO entry
+        def build_cpio_entry(path, data, mode)
+          name = path.start_with?("/") ? path[1..] : path
+          namesize = name.bytesize + 1
+          filesize = data.bytesize
+
+          inode = @inode_counter ||= 1
+          @inode_counter += 1
+
+          # Build header (110 bytes for newc)
+          header = format(
+            "070701%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%s\x00",
+            inode,           # inode
+            mode,            # mode
+            0,               # uid
+            0,               # gid
+            1,               # nlink
+            Time.now.to_i,   # mtime
+            filesize,        # filesize
+            0,               # devmajor
+            0,               # devminor
+            0,               # rdevmajor
+            0,               # rdevminor
+            namesize,        # namesize
+            0,               # checksum (0 for newc)
+            name, # name
+          )
+
+          # Pad header to 4-byte boundary
+          header_padding = (4 - (header.bytesize % 4)) % 4
+          header << ("\0" * header_padding)
+
+          # Pad data to 4-byte boundary
+          data_padding = (4 - (filesize % 4)) % 4
+
+          header + data + ("\0" * data_padding)
+        end
+
+        # Build CPIO trailer
+        #
+        # @return [String] Trailer entry
+        def build_cpio_trailer
+          build_cpio_entry("TRAILER!!!", "", 0)
+        end
+
+        # Compress payload
+        #
+        # @param data [String] Uncompressed data
+        # @param output [IO] Output IO for compressed data
+        def compress_payload(data, output)
+          case @compression
+          when :gzip
+            gz = Zlib::GzipWriter.new(output, 9)
+            gz.write(data)
+            gz.finish
+          when :none
+            output.write(data)
+          else
+            raise ArgumentError, "Unsupported compression: #{@compression}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rpm.rb

@@ -12,7 +12,7 @@ module Omnizip
   module Formats
     # RPM package format support
     #
-    # Provides read access to RPM packages, extracting metadata
+    # Provides read and write access to RPM packages, extracting metadata
     # and file contents from the payload.
     #
     # @example Open RPM and list files
@@ -22,7 +22,17 @@ module Omnizip
     #
     # @example Extract RPM contents
     #   Omnizip::Formats::Rpm.extract('package.rpm', 'output/')
+    #
+    # @example Create an RPM package
+    #   writer = Omnizip::Formats::Rpm::Writer.new(
+    #     name: "mypkg",
+    #     version: "1.0.0",
+    #     release: "1"
+    #   )
+    #   writer.add_file("/usr/bin/app", "#!/bin/sh\necho hello")
+    #   writer.write("mypkg.rpm")
     module Rpm
+      autoload :Writer, "omnizip/formats/rpm/writer"
       class << self
         # Open RPM package
         #
@@ -302,6 +312,19 @@ module Omnizip
           extract_cpio(decompressor, output_dir)
         end
 
+        # Get raw payload data
+        #
+        # Returns the compressed payload as-is (without decompression).
+        # Useful for saving the payload as a file (e.g., fonts.src.cpio.gz).
+        #
+        # @return [String] Raw compressed payload data
+        def raw_payload
+          raise "RPM not opened" unless @file
+
+          payload_io = payload
+          payload_io.read
+        end
+
         private
 
         def parse!

data/lib/omnizip/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Omnizip
-  VERSION = "0.3.4"
+  VERSION = "0.3.5"
 end

data/lib/omnizip.rb

@@ -96,6 +96,16 @@ require_relative "omnizip/formats/xar"
 # ISO 9660 CD-ROM format (Weeks 11-14)
 require_relative "omnizip/formats/iso"
 
+# CPIO, RPM, and OLE formats (autoload for lazy loading)
+# These formats benefit most from autoload since they are less commonly used
+module Omnizip
+  module Formats
+    autoload :Cpio, "omnizip/formats/cpio"
+    autoload :Rpm, "omnizip/formats/rpm"
+    autoload :Ole, "omnizip/formats/ole"
+  end
+end
+
 # Platform-specific features (Weeks 11-14)
 require_relative "omnizip/platform"
 require_relative "omnizip/platform/ntfs_streams"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: omnizip
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-20 00:00:00.000000000 Z
+date: 2026-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -449,6 +449,7 @@ files:
 - lib/omnizip/formats/rpm/header.rb
 - lib/omnizip/formats/rpm/lead.rb
 - lib/omnizip/formats/rpm/tag.rb
+- lib/omnizip/formats/rpm/writer.rb
 - lib/omnizip/formats/seven_zip.rb
 - lib/omnizip/formats/seven_zip/bcj2_stream_decompressor.rb
 - lib/omnizip/formats/seven_zip/coder_chain.rb