sass-embedded 1.77.5 → 1.86.3

data/lib/sass/elf.rb

@@ -7,26 +7,33 @@ module Sass
   # @see https://github.com/torvalds/linux/blob/HEAD/include/uapi/linux/elf.h
   # @see https://github.com/torvalds/linux/blob/HEAD/kernel/kexec_elf.c
   class ELF
-    # rubocop:disable Naming/ConstantName
-
-    # 32-bit ELF base types.
-    Elf32_Addr  = :__u32
-    Elf32_Half  = :__u16
-    Elf32_Off   = :__u32
-    Elf32_Sword = :__s32
-    Elf32_Word  = :__u32
-
-    # 64-bit ELF base types.
-    Elf64_Addr   = :__u64
-    Elf64_Half   = :__u16
-    Elf64_SHalf  = :__s16
-    Elf64_Off    = :__u64
-    Elf64_Sword  = :__s32
-    Elf64_Word   = :__u32
-    Elf64_Xword  = :__u64
-    Elf64_Sxword = :__s64
-
-    # rubocop:enable Naming/ConstantName
+    # The {PackInfo} class.
+    class PackInfo
+      def initialize(format:, sizeof:, struct:)
+        @format_le = format.freeze
+        @format_be = format.tr('<', '>').freeze
+        @sizeof = sizeof.freeze
+        @struct = struct.freeze
+      end
+
+      attr_reader :sizeof
+
+      def pack(io, data, little_endian)
+        raise ArgumentError if io.write(data.values_at(*@struct).pack(format(little_endian))) != @sizeof
+      end
+
+      def unpack(io, little_endian)
+        @struct.zip(io.read(@sizeof).unpack(format(little_endian))).to_h
+      end
+
+      private
+
+      def format(little_endian)
+        little_endian ? @format_le : @format_be
+      end
+    end
+
+    private_constant :PackInfo
 
     # These constants are for the segment types stored in the image headers
     PT_NULL         = 0
@@ -41,10 +48,8 @@ module Sass
     PT_HIOS         = 0x6fffffff
     PT_LOPROC       = 0x70000000
     PT_HIPROC       = 0x7fffffff
-    PT_GNU_EH_FRAME = (PT_LOOS + 0x474e550)
-    PT_GNU_STACK    = (PT_LOOS + 0x474e551)
-    PT_GNU_RELRO    = (PT_LOOS + 0x474e552)
-    PT_GNU_PROPERTY = (PT_LOOS + 0x474e553)
+
+    PN_XNUM         = 0xffff
 
     # These constants define the different elf file types
     ET_NONE   = 0
@@ -57,65 +62,153 @@ module Sass
 
     EI_NIDENT = 16
 
-    # rubocop:disable Naming/ConstantName
-
-    Elf32_Ehdr = [
-      [:unsigned_char, :e_ident, EI_NIDENT],
-      [Elf32_Half,     :e_type],
-      [Elf32_Half,     :e_machine],
-      [Elf32_Word,     :e_version],
-      [Elf32_Addr,     :e_entry],
-      [Elf32_Off,      :e_phoff],
-      [Elf32_Off,      :e_shoff],
-      [Elf32_Word,     :e_flags],
-      [Elf32_Half,     :e_ehsize],
-      [Elf32_Half,     :e_phentsize],
-      [Elf32_Half,     :e_phnum],
-      [Elf32_Half,     :e_shentsize],
-      [Elf32_Half,     :e_shnum],
-      [Elf32_Half,     :e_shstrndx]
-    ].freeze
-
-    Elf64_Ehdr = [
-      [:unsigned_char, :e_ident, EI_NIDENT],
-      [Elf64_Half,     :e_type],
-      [Elf64_Half,     :e_machine],
-      [Elf64_Word,     :e_version],
-      [Elf64_Addr,     :e_entry],
-      [Elf64_Off,      :e_phoff],
-      [Elf64_Off,      :e_shoff],
-      [Elf64_Word,     :e_flags],
-      [Elf64_Half,     :e_ehsize],
-      [Elf64_Half,     :e_phentsize],
-      [Elf64_Half,     :e_phnum],
-      [Elf64_Half,     :e_shentsize],
-      [Elf64_Half,     :e_shnum],
-      [Elf64_Half,     :e_shstrndx]
-    ].freeze
-
-    Elf32_Phdr = [
-      [Elf32_Word, :p_type],
-      [Elf32_Off,  :p_offset],
-      [Elf32_Addr, :p_vaddr],
-      [Elf32_Addr, :p_paddr],
-      [Elf32_Word, :p_filesz],
-      [Elf32_Word, :p_memsz],
-      [Elf32_Word, :p_flags],
-      [Elf32_Word, :p_align]
-    ].freeze
-
-    Elf64_Phdr = [
-      [Elf64_Word,  :p_type],
-      [Elf64_Word,  :p_flags],
-      [Elf64_Off,   :p_offset],
-      [Elf64_Addr,  :p_vaddr],
-      [Elf64_Addr,  :p_paddr],
-      [Elf64_Xword, :p_filesz],
-      [Elf64_Xword, :p_memsz],
-      [Elf64_Xword, :p_align]
-    ].freeze
-
-    # rubocop:enable Naming/ConstantName
+    Elf32_Ehdr = PackInfo.new(
+      format: "a#{EI_NIDENT}S<2L<5S<6",
+      sizeof: 52,
+      struct: %i[
+        e_ident
+        e_type
+        e_machine
+        e_version
+        e_entry
+        e_phoff
+        e_shoff
+        e_flags
+        e_ehsize
+        e_phentsize
+        e_phnum
+        e_shentsize
+        e_shnum
+        e_shstrndx
+      ]
+    ).freeze
+
+    Elf64_Ehdr = PackInfo.new(
+      format: "a#{EI_NIDENT}S<2L<Q<3L<S<6",
+      sizeof: 64,
+      struct: %i[
+        e_ident
+        e_type
+        e_machine
+        e_version
+        e_entry
+        e_phoff
+        e_shoff
+        e_flags
+        e_ehsize
+        e_phentsize
+        e_phnum
+        e_shentsize
+        e_shnum
+        e_shstrndx
+      ]
+    ).freeze
+
+    # These constants define the permissions on sections in the program header, p_flags.
+    PF_R = 0x4
+    PF_W = 0x2
+    PF_X = 0x1
+
+    Elf32_Phdr = PackInfo.new(
+      format: 'L<8',
+      sizeof: 32,
+      struct: %i[
+        p_type
+        p_offset
+        p_vaddr
+        p_paddr
+        p_filesz
+        p_memsz
+        p_flags
+        p_align
+      ]
+    ).freeze
+
+    Elf64_Phdr = PackInfo.new(
+      format: 'L<2Q<6',
+      sizeof: 56,
+      struct: %i[
+        p_type
+        p_flags
+        p_offset
+        p_vaddr
+        p_paddr
+        p_filesz
+        p_memsz
+        p_align
+      ]
+    ).freeze
+
+    # sh_type
+    SHT_NULL     = 0
+    SHT_PROGBITS = 1
+    SHT_SYMTAB   = 2
+    SHT_STRTAB   = 3
+    SHT_RELA     = 4
+    SHT_HASH     = 5
+    SHT_DYNAMIC  = 6
+    SHT_NOTE     = 7
+    SHT_NOBITS   = 8
+    SHT_REL      = 9
+    SHT_SHLIB    = 10
+    SHT_DYNSYM   = 11
+    SHT_NUM      = 12
+    SHT_LOPROC   = 0x70000000
+    SHT_HIPROC   = 0x7fffffff
+    SHT_LOUSER   = 0x80000000
+    SHT_HIUSER   = 0xffffffff
+
+    # sh_flags
+    SHF_WRITE          = 0x1
+    SHF_ALLOC          = 0x2
+    SHF_EXECINSTR      = 0x4
+    SHF_RELA_LIVEPATCH = 0x00100000
+    SHF_RO_AFTER_INIT  = 0x00200000
+    SHF_MASKPROC       = 0xf0000000
+
+    # special section indexes
+    SHN_UNDEF     = 0
+    SHN_LORESERVE = 0xff00
+    SHN_LOPROC    = 0xff00
+    SHN_HIPROC    = 0xff1f
+    SHN_LIVEPATCH = 0xff20
+    SHN_ABS       = 0xfff1
+    SHN_COMMON    = 0xfff2
+    SHN_HIRESERVE = 0xffff
+
+    Elf32_Shdr = PackInfo.new(
+      format: 'L<10',
+      sizeof: 40,
+      struct: %i[
+        sh_name
+        sh_type
+        sh_flags
+        sh_addr
+        sh_offset
+        sh_size
+        sh_link
+        sh_info
+        sh_addralign
+        sh_entsize
+      ]
+    ).freeze
+
+    Elf64_Shdr = PackInfo.new(
+      format: 'L<2Q<4L<2Q<2',
+      sizeof: 64,
+      struct: %i[
+        sh_name
+        sh_type
+        sh_flags
+        sh_addr
+        sh_offset
+        sh_size
+        sh_link
+        sh_info
+        sh_addralign
+        sh_entsize
+      ]
+    ).freeze
 
     # e_ident[] indexes
     EI_MAG0    = 0
@@ -130,9 +223,9 @@ module Sass
 
     # EI_MAG
     ELFMAG0 = 0x7f
-    ELFMAG1 = 'E'.ord
-    ELFMAG2 = 'L'.ord
-    ELFMAG3 = 'F'.ord
+    ELFMAG1 = 0x45
+    ELFMAG2 = 0x4c
+    ELFMAG3 = 0x46
     ELFMAG  = [ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3].pack('C*')
     SELFMAG = 4
 
@@ -147,13 +240,106 @@ module Sass
     ELFDATA2LSB = 1
     ELFDATA2MSB = 2
 
-    def initialize(buffer)
-      @buffer = buffer
-      @ehdr = read_ehdr
-      @buffer.seek(@ehdr[:e_phoff], IO::SEEK_SET)
-      @proghdrs = Array.new(@ehdr[:e_phnum]) do
-        read_phdr
+    def initialize(io, program_headers: true, section_headers: false)
+      io.rewind
+      e_ident = io.read(EI_NIDENT).unpack('C*')
+      raise ArgumentError unless e_ident.slice(EI_MAG0, SELFMAG).pack('C*') == ELFMAG
+
+      case e_ident[EI_CLASS]
+      when ELFCLASS32
+        elf_ehdr = Elf32_Ehdr
+        elf_phdr = Elf32_Phdr
+        elf_shdr = Elf32_Shdr
+      when ELFCLASS64
+        elf_ehdr = Elf64_Ehdr
+        elf_phdr = Elf64_Phdr
+        elf_shdr = Elf64_Shdr
+      else
+        raise EncodingError
       end
+
+      case e_ident[EI_DATA]
+      when ELFDATA2LSB
+        little_endian = true
+      when ELFDATA2MSB
+        little_endian = false
+      else
+        raise EncodingError
+      end
+
+      io.rewind
+      ehdr = elf_ehdr.unpack(io, little_endian)
+      ehdr[:e_ident] = e_ident
+
+      phdrs = if program_headers && ehdr[:e_phnum].positive?
+                io.seek(ehdr[:e_phoff], IO::SEEK_SET)
+                Array.new(ehdr[:e_phnum]) do
+                  elf_phdr.unpack(io, little_endian)
+                end
+              else
+                []
+              end
+
+      shdrs = if section_headers && ehdr[:e_shnum].positive?
+                io.seek(ehdr[:e_shoff], IO::SEEK_SET)
+                Array.new(ehdr[:e_shnum]) do
+                  elf_shdr.unpack(io, little_endian)
+                end
+              else
+                []
+              end
+
+      @io = io
+      @ehdr = ehdr
+      @phdrs = phdrs
+      @shdrs = shdrs
+    end
+
+    def dump(io)
+      e_ident = @ehdr[:e_ident]
+      raise ArgumentError unless e_ident.slice(EI_MAG0, SELFMAG).pack('C*') == ELFMAG
+
+      ehdr = @ehdr.dup
+      ehdr[:e_ident] = e_ident.pack('C*')
+      phdrs = @phdrs
+      shdrs = @shdrs
+
+      case e_ident[EI_CLASS]
+      when ELFCLASS32
+        elf_ehdr = Elf32_Ehdr
+        elf_phdr = Elf32_Phdr
+        elf_shdr = Elf32_Shdr
+      when ELFCLASS64
+        elf_ehdr = Elf64_Ehdr
+        elf_phdr = Elf64_Phdr
+        elf_shdr = Elf64_Shdr
+      else
+        raise EncodingError
+      end
+
+      case e_ident[EI_DATA]
+      when ELFDATA2LSB
+        little_endian = true
+      when ELFDATA2MSB
+        little_endian = false
+      else
+        raise EncodingError
+      end
+
+      io.rewind
+      elf_ehdr.pack(io, ehdr, little_endian)
+
+      io.seek(ehdr[:e_phoff], IO::SEEK_SET) if ehdr[:e_phnum].positive?
+      phdrs.each do |phdr|
+        elf_phdr.pack(io, phdr, little_endian)
+      end
+
+      io.seek(ehdr[:e_shoff], IO::SEEK_SET) if ehdr[:e_shnum].positive?
+      shdrs.each do |shdr|
+        elf_shdr.pack(io, shdr, little_endian)
+      end
+
+      io.flush
     end
 
     def relocatable?
@@ -173,89 +359,16 @@ module Sass
     end
 
     def interpreter
-      phdr = @proghdrs.find { |p| p[:p_type] == PT_INTERP }
+      phdr = @phdrs.find { |p| p[:p_type] == PT_INTERP }
       return if phdr.nil?
 
-      @buffer.seek(phdr[:p_offset], IO::SEEK_SET)
-      interpreter = @buffer.read(phdr[:p_filesz])
-      raise ArgumentError unless interpreter.end_with?("\0")
+      @io.seek(phdr[:p_offset], IO::SEEK_SET)
+      interpreter = @io.read(phdr[:p_filesz])
+      raise EncodingError unless interpreter.end_with?("\0")
 
       interpreter.chomp!("\0")
     end
 
-    private
-
-    def file_class
-      @ehdr[:e_ident][EI_CLASS]
-    end
-
-    def data_encoding
-      @ehdr[:e_ident][EI_DATA]
-    end
-
-    def read_ehdr
-      @ehdr = { e_ident: @buffer.read(EI_NIDENT).unpack('C*') }
-      raise ArgumentError unless @ehdr[:e_ident].slice(EI_MAG0, SELFMAG).pack('C*') == ELFMAG
-
-      case file_class
-      when ELFCLASS32
-        Elf32_Ehdr
-      when ELFCLASS64
-        Elf64_Ehdr
-      else
-        raise ArgumentError
-      end.drop(1).to_h do |field|
-        [field[1], read1(field[0])]
-      end.merge!(@ehdr)
-    end
-
-    def read_phdr
-      case file_class
-      when ELFCLASS32
-        Elf32_Phdr
-      when ELFCLASS64
-        Elf64_Phdr
-      else
-        raise ArgumentError
-      end.to_h do |field|
-        [field[1], read1(field[0])]
-      end
-    end
-
-    def explicit_endian
-      case data_encoding
-      when ELFDATA2LSB
-        '<'
-      when ELFDATA2MSB
-        '>'
-      else
-        raise ArgumentError
-      end
-    end
-
-    def read1(type)
-      case type
-      when :__u8
-        @buffer.read(1).unpack1('C')
-      when :__u16
-        @buffer.read(2).unpack1("S#{explicit_endian}")
-      when :__u32
-        @buffer.read(4).unpack1("L#{explicit_endian}")
-      when :__u64
-        @buffer.read(8).unpack1("Q#{explicit_endian}")
-      when :__s8
-        @buffer.read(1).unpack1('c')
-      when :__s16
-        @buffer.read(2).unpack1("s#{explicit_endian}")
-      when :__s32
-        @buffer.read(4).unpack1("l#{explicit_endian}")
-      when :__s64
-        @buffer.read(8).unpack1("q#{explicit_endian}")
-      else
-        raise ArgumentError
-      end
-    end
-
     INTERPRETER = begin
       proc_self_exe = '/proc/self/exe'
       if File.exist?(proc_self_exe)
@@ -269,7 +382,7 @@ module Sass
           end
         end
       end
-    end
+    end.freeze
   end
 
   private_constant :ELF

data/lib/sass/embedded/version.rb

@@ -2,6 +2,6 @@
 
 module Sass
   module Embedded
-    VERSION = '1.77.5'
+    VERSION = '1.86.3'
   end
 end

data/lib/sass/embedded.rb

@@ -53,47 +53,8 @@ module Sass
       @mutex.synchronize do
         return @compiler if @compiler
 
-        compiler = Class.new(Compiler) do
-          def initialize
-            @channel = Compiler.const_get(:Channel).new(Class.new(Compiler.const_get(:Dispatcher)) do
-              def initialize
-                super
-
-                idle_timeout = 10
-                @last_accessed_time = current_time
-
-                Thread.new do
-                  Thread.current.name = 'sass-embedded-process-reaper'
-                  duration = idle_timeout
-                  loop do
-                    sleep(duration.negative? ? idle_timeout : duration)
-                    break if @mutex.synchronize do
-                      raise Errno::EBUSY if _closed?
-
-                      duration = idle_timeout - (current_time - @last_accessed_time)
-                      duration.negative? && _idle? && _close
-                    end
-                  end
-                  close
-                rescue Errno::EBUSY
-                  # do nothing
-                end
-              end
-
-              private
-
-              def _idle
-                super
-
-                @last_accessed_time = current_time
-              end
-
-              def current_time
-                Process.clock_gettime(Process::CLOCK_MONOTONIC)
-              end
-            end)
-          end
-        end.new
+        compiler = Compiler.allocate
+        compiler.instance_variable_set(:@channel, Compiler.const_get(:Channel).new(idle_timeout: 10))
 
         at_exit do
           compiler.close

data/lib/sass/exception.rb

@@ -51,8 +51,12 @@ module Sass
           font-family: monospace, monospace;
           white-space: pre;
           content: #{Serializer.serialize_quoted_string(content).gsub(/[^[:ascii:]][\h\t ]?/) do |match|
-            replacement = "\\#{match.ord.to_s(16)}"
-            replacement << " #{match[1]}" if match.length > 1
+            ordinal = match.ord
+            replacement = "\\#{ordinal.to_s(16)}"
+            if match.length > 1
+              replacement << ' ' if ordinal < 0x100000
+              replacement << match[1]
+            end
             replacement
           end};
         }
@@ -62,6 +66,7 @@ module Sass
 
   # An exception thrown by Sass Script.
   class ScriptError < StandardError
+    # @!visibility private
     def initialize(message, name = nil)
       super(name.nil? ? message : "$#{name}: #{message}")
     end

data/lib/sass/serializer.rb

@@ -5,17 +5,11 @@ module Sass
   module Serializer
     module_function
 
-    CSS_ESCAPE = {
-      "\0" => "\uFFFD",
-      '\\' => '\\\\',
-      '"' => '\\"',
-      "'" => "\\'",
-      **[*"\x01".."\x08", *"\x0A".."\x1F", "\x7F"].product(
-        [*'0'..'9', *'a'..'f', *'A'..'F', "\t", ' ', nil]
-      ).to_h do |c, x|
-        ["#{c}#{x}".freeze, "\\#{c.ord.to_s(16)}#{" #{x}" if x}".freeze]
-      end
-    }.freeze
+    CSS_ESCAPE = [*"\x01".."\x08", *"\x0A".."\x1F", "\x7F"]
+                 .product([*'0'..'9', *'a'..'f', *'A'..'F', "\t", ' ', nil])
+                 .each_with_object({ "\0" => "\uFFFD", '\\' => '\\\\', '"' => '\\"', "'" => "\\'" }) do |(c, x), h|
+                   h["#{c}#{x}".freeze] = "\\#{c.ord.to_s(16)}#{" #{x}" if x}".freeze
+                 end.freeze
 
     private_constant :CSS_ESCAPE
 

data/lib/sass/value/argument_list.rb

@@ -15,7 +15,6 @@ module Sass
       def initialize(contents = [], keywords = {}, separator = ',')
         super(contents, separator:)
 
-        @id = 0
         @keywords_accessed = false
         @keywords = keywords.freeze
       end
@@ -25,13 +24,6 @@ module Sass
         @keywords_accessed = true
         @keywords
       end
-
-      private
-
-      def initialize_dup(orig)
-        @id = 0
-        super
-      end
     end
   end
 end