resedit 1.3.1

data/lib/resedit/mz/mz.rb

@@ -0,0 +1,166 @@
+require 'resedit/mz/mz_header'
+require 'resedit/mz/mz_body'
+require 'resedit/mz/hexwriter'
+require 'resedit/mz/mzenv'
+
+module Resedit
+
+    class MZ
+        ZM = 0x4D5A
+
+        attr_reader :fname, :path, :name, :fsize
+        attr_reader :header, :body
+
+        def initialize(path, quiet = false)
+            raise "File not specified" if !path
+            @quiet = quiet
+            @path = path.downcase()
+            @fsize = File.size(path)
+            open(@path,"rb:ascii-8bit"){|f|
+                @header = MZHeader.new(self, f, fsize)
+                hsz = @header.headerSize()
+                @body = MZBody.new(self, f, @header.fileSize() - hsz)
+                save = f.read(2)
+                zm = save ? save.unpack('v')[0] : nil
+                if zm == ZM
+                    @header.loadChanges(f)
+                    @body.loadChanges(f)
+                    log("Change info loaded.")
+                end
+            }
+            @fname = File.basename(@path)
+            @name = File.basename(@path, ".*")
+            hi = @header.info()
+            env().set(:entry, hi[:CS].to_s+":"+hi[:IP].to_s)
+            env().set(:append, sprintf("%04X:0",@body.appSeg))
+        end
+
+
+        def close()
+        end
+
+
+        def log(fmt, *args)
+            App::get().log(fmt, *args) if !@quiet
+        end
+
+
+        def env() return MZEnv.instance() end
+        def s2i(str) return MZEnv.instance().s2i(str) end
+
+
+        def is?(id)
+            id = id.downcase
+            return id == @path || id == @fname || id == @name
+        end
+
+
+        def print(what, how=nil)
+            puts "Header changes:" if what=="changes"
+            res = @header.print(what, how)
+            puts "Code changes:" if what=="changes"
+            res |= @body.print(what, how)
+            raise "Don't know how to print: " + what if !res
+        end
+
+
+        def hex(ofs, size=nil, how=nil, disp=nil)
+            ofs = ofs ? s2i(ofs) : 0
+            size = size ? s2i(size) : 0x100
+            isfile = disp && (disp[0]=='f' || disp[0]=='F') ? true : false
+            wr = HexWriter.new(ofs)
+            how = @header.parseHow(how)
+            hsz = 0
+            if isfile
+                @header.mode(how)
+                hsz = @header.headerSize()
+                size = @header.hex(wr, ofs, size, how) if ofs < hsz
+                ofs -= hsz
+                ofs = 0 if ofs < 0
+            end
+            wr.setSegments(@body.segments, hsz)
+            @body.hex(wr, ofs, size, how) if size > 0
+            wr.finish()
+        end
+
+
+        def getValue(value, type)
+            s = env().value2bytes(value, type)
+            return s.force_encoding(Encoding::ASCII_8BIT)
+        end
+
+
+        def append(value, type=nil)
+            res = @body.append(getValue(value,type))
+            s = ""
+            res.each{|a|
+                if a.is_a?(Array)
+                    s += sprintf(" %04X:%04X", a[1], a[0])
+                else
+                    s += sprintf(" %08X", a)
+                end
+            }
+            log("Appended at %s",s)
+        end
+
+
+        def replace(value, type=nil)
+            @body.removeAppend()
+            return append(value,type)
+        end
+
+
+        def change(ofs, value, disp=nil, type=nil)
+            ofs = s2i(ofs)
+            isfile = disp && (disp[0]=='f' || disp[0]=='F') ? true : false
+            value = getValue(value, type)
+            if isfile
+                res = @header.change(ofs,value)
+            else
+                res = @body.change(ofs,value) + @header.headerSize()
+            end
+            log("Change added at %08X", res)
+        end
+
+
+        def dasm(ofs, size=nil, how=nil)
+            ofs = s2i(ofs ? ofs : "entry")
+            size = size ? s2i(size) : [0x20, @body.bytes.length-ofs].min
+            @body.dasm(ofs, size, how)
+        end
+
+
+        def valueof(str, type)
+            puts "value of " + str + " is:"
+            p getValue(str, type).unpack("H*")
+        end
+
+
+        def revert(what)
+            wid = env().s2i_nt(what)
+            what = wid[1] ? wid[0] : what
+            res = @header.revert(what)
+            res |= @body.revert(what)
+            raise "Don't know how to revert: "+what if !res
+            log("Reverted")
+        end
+
+
+        def save(filename, final=nil)
+            raise "Unknown final: " + final if final && final != "final"
+            raise "Filename expected." if !filename
+            open(filename, "wb:ascii-8bit"){|f|
+                @header.saveData(f)
+                @body.saveData(f)
+                if !final || final!='final'
+                    f.write([ZM].pack('v'))
+                    @header.saveChanges(f)
+                    @body.saveChanges(f)
+                end
+            }
+        end
+
+
+    end
+
+end

data/lib/resedit/mz/mz_body.rb

@@ -0,0 +1,141 @@
+require 'resedit/mz/changeable'
+begin
+    require 'crabstone'
+    include Crabstone
+    $nocrabstone = false
+rescue LoadError
+    $nocrabstone = true
+end
+
+
+module Resedit
+
+    class MZBody < Changeable
+
+        attr_reader :segments, :appSeg
+
+        def initialize(mz, file, size)
+            super(mz, file, size)
+            @segments = Set.new()
+            for i in 0..@mz.header.info[:NumberOfRelocations]-1
+                r = @mz.header.getRelocation(i)
+                @segments.add(r[1])
+                val = segData(r, 2).unpack('v')[0]
+                @segments.add(val)
+            end
+            @appSeg = (@realSize >> 4) + 1
+        end
+
+
+        def loadChanges(f)
+            super(f)
+            @appSeg = (@realSize >> 4) + 1
+            @segments.add(@appSeg)
+        end
+
+
+        def seg2Linear(a,s) (s << 4) + a end
+
+
+        def seg4Linear(linear)
+            linear >>= 4
+            min = @segments.sort.reverse.find{|e| e <= linear}
+            return min ? min : 0
+        end
+
+
+        def linear2seg(linear, inSegments=nil)
+            inSegments = [seg4Linear(linear)] if !inSegments
+            res = []
+            inSegments.each{|s|
+                raise sprintf("Linear %X less than segment %04X", inSegments[0], s) if linear < (s<<4)
+                a = linear - (s << 4)
+                res += [a,s]
+            }
+            return res
+        end
+
+
+        def segData(reloc, size, isStr=false)
+            ofs = seg2Linear(reloc[0], reloc[1])
+            return "None" if ofs>@bytes.length
+            return getData(ofs, size) if !isStr
+            return colVal(ofs, size)
+        end
+
+
+        def removeAppend()
+            @segments.each{|s|
+                @segments.delete(s) if (s << 4) > @realSize
+            }
+            super()
+        end
+
+
+        def revert(what)
+            @realOfs = @mz.header.headerSize()
+            super(what)
+        end
+
+
+        def append(bytes)
+            mode(HOW_ORIGINAL)
+            res = 0
+            addseg = false
+            if !@add
+                addseg = true
+                res = 0x10 - (@realSize % 0x10)
+                res = 0 if res == 0x10
+                bytes = ("\x90" * res).force_encoding(Encoding::ASCII_8BIT) + bytes if res > 0
+            end
+            res += super(bytes)
+            @mz.header.setCodeSize(@bytes.length + @add.length)
+            seg = linear2seg(res)
+            res = [res, seg]
+            if addseg
+                raise "Segs not match" if (@appSeg << 4) != res[0]
+                @segments.add(@appSeg)
+                res += [ [ 0, @appSeg] ]
+            end
+            return res
+        end
+
+
+        def print(what, how)
+            if what=="header"
+                puts "Known segments: " + @segments.sort.map{ |i| sprintf('%04X',i) }.join(", ")
+                return true
+            end
+            @realOfs = @mz.header.headerSize()
+            return super(what, how)
+        end
+
+
+        def dasm(ofs, size, how)
+            raise "Crabstone gem required to disasm." if $nocrabstone
+            mode(parseHow(how))
+            cs = Disassembler.new(ARCH_X86, MODE_16)
+            begin
+                while true
+                    begin
+                        d = getData(ofs,size)
+                        cs.disasm(d, ofs).each {|i|
+                            seg = linear2seg(i.address)
+                            bts = i.bytes.map { |b| sprintf("%02X",b) }.join
+                            inst = colStr(sprintf("%14s\t%s\t%s", bts, i.mnemonic, i.op_str), changed?(i.address, i.bytes.length))
+                            printf("%08X %04X:%04X%s\n",i.address, seg[1], seg[0], inst)
+                        }
+                        break
+                    rescue
+                        ofs-=1
+                    end
+                end
+
+            ensure
+                cs.close()
+            end
+        end
+
+
+    end
+end

data/lib/resedit/mz/mz_header.rb

@@ -0,0 +1,123 @@
+require 'resedit/mz/changeable'
+
+module Resedit
+
+    class MZHeader < Changeable
+        MAGIC = 0x5a4D
+        BLK = 0x200
+        PARA = 0x10
+        HSIZE = 0x1C
+
+        attr_reader :info
+
+        def initialize(mz, file, size)
+            raise "Not MZ file" if size < HSIZE
+            super(mz, file, HSIZE)
+            @fsize = size
+            @_infoOrig = loadInfo()
+            @_info = nil
+            @info = @_infoOrig
+            raise "Not MZ file" if MAGIC != @info[:Magic]
+            readMore(file, headerSize() - HSIZE)
+        end
+
+
+        def mode(how)
+            super(how)
+            if @mode == HOW_ORIGINAL
+                @info = @_infoOrig
+            else
+                @_info = loadInfo() if  !@_info
+                @info = @_info
+            end
+        end
+
+
+        def change(ofs, bytes)
+            super(ofs, bytes)
+            @_info = nil if (ofs < HSIZE)
+        end
+
+
+        def loadInfo()
+            v = getData(0, HSIZE).unpack('v*')
+            return  {:Magic => v[0], :BytesInLastBlock => v[1], :BlocksInFile => v[2], :NumberOfRelocations => v[3],
+                     :HeaderParagraphs => v[4], :MinExtraParagraphs => v[5], :MaxExtraParagraphs => v[6],
+                     :SS => v[7], :SP => v[8], :Checksum => v[9], :IP => v[10], :CS => v[11],
+                     :RelocTableOffset => v[12], :OverlayNumber => v[13]
+                     }
+        end
+
+
+        def setCodeSize(size)
+            mode(HOW_CHANGED)
+            size += headerSize()
+            mod = size % BLK
+            ch = [mod, size / BLK + (mod ? 1 : 0)]
+            change(2, ch.pack('vv'))
+        end
+
+
+        def headerSize()
+            return @info[:HeaderParagraphs] * PARA
+        end
+
+
+        def fileSize()
+            sz = @info[:BlocksInFile] * BLK
+            if @info[:BytesInLastBlock] != 0
+                sz -= BLK - @info[:BytesInLastBlock]
+            end
+            return sz
+        end
+
+
+        def getRelocation(idx)
+            raise "Wrong relocation index " if idx<0 || idx>@info[:NumberOfRelocations]
+            return getData(@info[:RelocTableOffset] + idx * 4, 4).unpack('vv')
+        end
+
+
+        def freeSpace(middle = false)
+            return @info[:RelocTableOffset] - HSIZE  if middle
+            return headerSize() - HSIZE - @info[:NumberOfRelocations] * 4
+        end
+
+
+        def print(what, how)
+            mode(parseHow(how))
+            if what == "header"
+                ofs=0
+                @info.each{|k,v|
+                    printf("%20s:\t%s\n", k.to_s, colVal(ofs, 2))
+                    ofs+=2
+                }
+                puts
+                fsz = fileSize()
+                hsz = headerSize()
+                s = colStr(sprintf("%d (%X)", fsz,fsz), changed?(2,4))
+                printf("mz file size: %s\treal file size: %d (0x%X)\n", s, @fsize, @fsize)
+                printf("header size: %s\n", colStr(hsz, changed?(8)))
+                printf("code size: %s\n", colStr(fsz - hsz, @mz.body.add != nil))
+                printf("reloc table size: %s\n", colStr(@info[:NumberOfRelocations] * 4, changed?(6)))
+                printf("free space in header: before relocs 0x%X,  after relocs 0x%X\n", freeSpace(true), freeSpace())
+                return true
+            end
+            if what == "reloc"
+                ofs = @info[:RelocTableOffset]
+                for i in 0..@info[:NumberOfRelocations]-1
+                    s1 = colVal(ofs,2)
+                    s2 = colVal(ofs+2,2)
+                    s3 = @mz.body.segData(getRelocation(i), 2, true)
+                    printf("%08X\t%s:%s\t= %s\n", ofs, s2, s1, s3)
+                    ofs += 4
+                end
+                return true
+            end
+            return super(what, how)
+        end
+
+
+    end
+
+end

data/lib/resedit/mz/mzenv.rb

@@ -0,0 +1,82 @@
+require 'singleton'
+
+module Resedit
+
+    class MZEnv
+
+        include Singleton
+
+        def set(name,value)
+            MZEnv.class_eval{
+                define_method(name){ s2i(value) }
+            }
+        end
+
+        def s2i_nt(str)
+            return [s2i(str), true]
+        rescue Exception
+            return [0, false]
+        end
+
+        def s2i(str)
+            ss=str.split(':')
+            if ss.length == 2
+                ss[0] = '0x'+ss[0] if ss[0][0,2]!='0x'
+                ss[1] = '0x'+ss[1] if ss[1][0,2]!='0x'
+                return (s2i(ss[0]) << 4) + s2i(ss[1])
+            end
+            return eval(str, binding())
+        end
+
+
+        def valueHex(s, type)
+            s = s[0..-2] if s[-1] == 'h'
+            s = s[2..-1] if s[0,2] == '0x'
+            return nil if s.length == 0
+            sz = type[1]
+            sz = s.length / 2 + s.length % 2 if !sz || sz==0
+            hx = eval('0x'+s, binding())
+            s=""
+            for i in 0..sz-1
+                s += sprintf("%02X", hx & 0xFF)
+                hx >>= 8
+            end
+            return valueBytes(s)
+        rescue SyntaxError
+            return nil
+        end
+
+        def valueBytes(str)
+            return nil if str[0,2] == '0x' || str[0,2]=='0X'
+            return nil if str.length % 2 == 1
+            return nil if str[/\H/]
+            return [str].pack('H*')
+        rescue
+            return nil
+        end
+
+        def value2bytes(str, type)
+            tp = [nil, nil]
+            if type && type.length > 0
+                tp[0] = type[0]
+                t = type[1..-1]
+                t = t[1..-1] while t.length > 0 && (t[0]<'0' || t[0]>'9')
+                tp[1] = t.to_i
+            end
+            if tp[0]=='f' || (File.exists?(str) && !tp[0])
+                return File.read(str)
+            end
+            res = valueBytes(str) if !tp[0] || tp[0] == "b"
+            res = valueHex(str, tp) if !res && (!tp[0] || tp[0] == "h")
+            res = eval(str, binding()) if !res
+            return res if res.is_a?(String)
+            res = valueHex(res.to_s(16), tp)
+            raise str if !res
+            return res
+        rescue Exception => e
+            raise "Bad value: "+e.to_s
+        end
+
+    end
+
+end