resedit 1.8 → 1.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d5bb82eb4e37c29d800e45d61d1fd8359afb224d
-  data.tar.gz: 206c81a15f6e4bc8f50893ce9c8900fb89ec4ad4
+  metadata.gz: 7e951763342994ca2eb391febf485c7af0b61b6d
+  data.tar.gz: 46699aaad4668d939f3a8bf5475d141aead053e4
 SHA512:
-  metadata.gz: c28f9d26f1e08a3980b254ada58e772a2a65efec98ca6e4b9008625ca1f7790a61777d9dd882a618c001abcfa3a71b9d07ecacaf321c176fcfcbcb3f90d713cd
-  data.tar.gz: 05c2a94a3fba256b35e624d2477678d3210a3009f994fa347f500afae29dbbb7eabe79789ade857336e9ed1ecb9ab872da30d58b6ebe1d3bcf3c93de71716ce0
+  metadata.gz: e51ae58c40d9aa5ea3704696256c5f8d1fa408dca322c77e3dd1264f776a0dcceb2ed27c2a1e2bb60b386f0f20375ea705a328ef68257b009c09ca6e8bc07316
+  data.tar.gz: 2561a3233ec457ac8de1035549228eeb3bead6ead35687c1fff12df9c3efb630572f08fb48767744128287b80d790c29df4ffcb78df8d54b25181377959ff60e

data/lib/resedit.rb

@@ -25,5 +25,5 @@ require 'resedit/mz/multiexe'
 
 
 module Resedit
-    VERSION = "1.8"
+    VERSION = "1.8.1"
 end

data/lib/resedit/app/mz_command.rb

@@ -23,11 +23,14 @@ module Resedit
                 "append"=>[method(:append), "add bytes to current file", {"value" => "value", "type" => "value type", "where" => "append offset. default: above ss:sp"}],
                 "replace"=>[method(:replace), "replace added bytes", {"value" => "value", "type"=>"value type"}],
                 "change"=>[method(:change), "change bytes at offset", {"ofs" => "data ofset", "value" => "value", "disp" => "code/file", "type"=>"value type"}],
-                "reloc"=>[method(:reloc), "add relocation", {"value" => "value"}],
+                "reloc"=>[method(:reloc), "add relocation", {"offset" => "reloc offset", "target" => "address reloc points to"}],
                 "revert"=>[method(:revert), "revert changes", {"ofs"=>"change offset/all"}],
                 "hex"=>[method(:hex), "print hex file", {"ofs" => "data offset", "size" => "data size", "how"=>"original/modified", "disp" => "code/file"}],
                 "dasm"=>[method(:dasm), "print disasm", {"ofs" => "data offset", "size" => "data size", "how"=>"original/modified"}],
                 "eval"=>[method(:expr), "print expression", {"expr" => "expression"}],
+                "dump"=>[method(:dump), "dump exe parts", {"out" => "output filename", "parts"=>"list of parts", "how"=>"original/modified"}],
+                "relocfind"=>[method(:relocfind), "find relocation with value", {"value" => "value", "type"=>"value type"}],
+                "stringfind"=>[method(:stringfind), "search for strings in exe", {"size"=>"min string size"}],
             }
             @shorters = {"p"=>"print", "e"=>"eval"}
             @files = []
@@ -144,7 +147,15 @@ module Resedit
         end
 
         def reloc(params)
-            cur().reloc(params['value'])
+            cur().reloc(params['offset'],params['target'])
+        end
+
+        def relocfind(params)
+            cur().relocfind(params['value'], params['type'])
+        end
+
+        def stringfind(params)
+            cur().stringfind(params['size'])
         end
 
         def revert(params)
@@ -166,6 +177,10 @@ module Resedit
             puts env.s2i(params['expr'])
         end
 
+        def dump(params)
+            cur().dump(params['out'], params['parts'], params['how'])
+        end
+
 
         def job(params)
             cmd = params['cmd']

data/lib/resedit/app/text_convert.rb

@@ -1,24 +1,41 @@
 require 'resedit/app/io_commands'
+require 'resedit/app/app_command'
 
 module Resedit
 
+    class ITextConvert < AppCommand
+        attr_accessor :text
+        def initialize(resname, params)
+            @resname, @params = resname, params
+        end
+        def mktext(file, format, encoding); raise "NotImplemented" end
+        def expectedLines(file); raise "NotImplemented" end
+        def pack(file, outstream); raise "NotImplemented" end
+        def unpack(file); raise "NotImplemented" end
+    end
+
     class TextConvertCommand < ConvertCommand
 
+
+        attr_accessor :text
         def initialize(fname, cmdname='text')
             super(cmdname, fname)
-            @font = nil
+            @text = nil
             addOption('format','f',nil,'output file format')
             addOption('encoding','e',nil,'output file encoding')
         end
 
+        def getInterface(resname, params); self end
+
         def import(inname)
+            @iface = getInterface(@resname, @params)
             logd("importing text #{inname} to #{@resname}")
             back = backup()
             File.open(back,"rb"){|file|
-                @text = mktext(file, @params['format'], @params['encoding'])
-                @text.load(inname, expectedLines())
+                @iface.text = @iface.mktext(file, @params['format'], @params['encoding'])
+                @iface.text.load(inname, @iface.expectedLines())
                 StringIO.open("","w+b"){|stream|
-                    pack(file, stream)
+                    @iface.pack(file, stream)
                     stream.seek(0)
                     File.open(@resname,"wb"){|out|
                         out.write(stream.read())
@@ -29,13 +46,14 @@ module Resedit
 
 
         def export(outname)
+            @iface = getInterface(@resname, @params)
             logd("exporting text #{@resname} to #{outname}")
             File.open(@resname, "rb"){|file|
-                @text = mktext(file, @params['format'], @params['encoding'])
-                unpack(file) if @text
+                @iface.text = @iface.mktext(file, @params['format'], @params['encoding'])
+                @iface.unpack(file) if @iface.text
             }
-            raise "Text not unpacked" if !@text
-            @text.save(outname)
+            raise "Text not unpacked" if !@iface.text
+            @iface.text.save(outname)
         end
 
 

data/lib/resedit/classes/config.rb

@@ -6,24 +6,58 @@ module Resedit
 
         attr_accessor :cfg
         def initialize(fname, section=nil)
-            @fname, @section = fname, section
+            @fname = fname
+            @section = section ? section : []
+            @section = [@section] if !@section.is_a?(Array)
             @cfg = load()
-            @cfg = (@cfg[@section] or {}) if @section
+            @section.each{|s|
+                @cfg = (@cfg[s] or {})
+            }
         end
 
         def [](nm); @cfg[nm] end
         def []=(nm, value); @cfg[nm]=value end
+        def each(&block);@cfg.each(&block) end
+        def length; @cfg.length end
+
+        def enter(section, createOnAbsent = true)
+            section = [section] if !section.is_a?(Array)
+            section.each{|s|
+                raise "Config section not found #{s} at #{@section}" if !@cfg[s] && !createOnAbsent
+                @cfg = @cfg[s] or {}
+                @section += [s]
+            }
+        end
+
+        def enterOnFile(path)
+            ret = nil
+            ent = ''
+            @cfg.each{|k, _|
+                fn = File.join(path, k)
+                ret = fn if File.exists?(fn)
+                ent = k if ret
+                break if ret
+            }
+            raise "Config not found for files at #{path}" if !ret
+            enter(ent, false)
+            return ret
+        end
 
         def load();
             File.exists?(@fname) ? JSON.parse(File.read(@fname)) : {}
         end
 
         def save()
-            if @section
+            if @section.length>0
                 c = load()
-                c[@section] = @cfg
+                cur = c
+                @section[0..-2].each{|s|
+                    cur[s] = {} if !cur[s]
+                    cur = cur[s]
+                }
+                cur[@section[-1]]=@cfg
             else
-                c = cfg
+                c = @cfg
             end
             open(@fname, "w"){|f|
                 f.write(JSON.pretty_generate(c))

data/lib/resedit/classes/env.rb

@@ -83,6 +83,8 @@ module Resedit
                 t = t[1..-1] while t.length > 0 && (t[0]<'0' || t[0]>'9')
                 tp[1] = t.to_i
             end
+            return str if tp[0] == "s"
+            return str+"\x00" if tp[0] == "z"
             if tp[0]=='f' || (File.exists?(str) && !tp[0])
                 return File.read(str)
             end
@@ -91,10 +93,10 @@ module Resedit
             res = eval(str, binding()) if !res
             return res if res.is_a?(String)
             res = valueHex(res.to_s(16), tp)
-            raise str if !res
+            raise str if res==nil
             return res
-        rescue Exception => e
-            raise "Bad value: "+e.to_s
+            #rescue Exception => e
+            #    raise "Bad value: "+e.to_s
         end
 
     end

data/lib/resedit/classes/exefile.rb

@@ -25,6 +25,7 @@ module Resedit
             raise "Not EXE file" if fsize < self.class::HSIZE
             @exe = exe
             super(file, self.class::HSIZE)
+            @hdrtbl = nil
             @_infoOrig = loadInfo()
             @_info = nil
             @info = @_infoOrig
@@ -47,7 +48,7 @@ module Resedit
 
         def change(ofs, bytes)
             super(ofs, bytes)
-            @_info = nil if (ofs < HSIZE)
+            @_info = nil if (ofs < self.class::HSIZE)
         end
 
 
@@ -56,16 +57,50 @@ module Resedit
             ret = self.class::HDRDESCR.map.with_index { |x, i| [x, v[i]] }.to_h
             return ret
         end
+
         def loadTables(file); end
         def loadTail(file);
             addData(file, headerSize() - self.class::HSIZE)
         end
 
+        def _headerTable()
+            return @hdrtbl if @hdrtbl
+            @hdrtbl = []
+            sz = ["acC","vnsS","VNlL","qQ"]
+            ofs = 0
+            len = self.class::HDRDESCR.length
+            self.class::HDRUNPACK.scan(/[a-zA-Z][\d*]*/).each{|s|
+                size = sz.index{|v| v.include?(s[0])}
+                raise "Unsupported header descr #{s}" if size==nil
+                size = 1 << size
+                cnt = s.length>1 && s[1]!='*' ? s[1..-1].to_i : 1
+                if s[0]=='a'
+                    cnt = self.class::HSIZE - ofs if s[1]=='*'
+                    @hdrtbl += [[ofs, cnt, s]]
+                    ofs += cnt
+                    next
+                end
+                cnt = len - @hdrtbl.length if s[1]=='*'
+                cnt.times{
+                    @hdrtbl += [[ofs, size, s[0]]]
+                    ofs += size
+                }
+            }
+            raise "Header descr unmatch #{@hdrtbl} #{self.class::HDRDESCR}" if @hdrtbl.length!=len
+            return @hdrtbl
+        end
+
+        def fieldOffset(field); return _headerTable()[self.class::HDRDESCR.index(field)][0] end
+        def fieldSize(field); return _headerTable()[self.class::HDRDESCR.index(field)][1] end
 
-        def setInfo(field, values, pack="v*")
+        def setInfo(field, values)
             raise "Unknown header field #{field}" if !self.class::HDRDESCR.include?(field)
+            tbl = _headerTable()
             values = [values] if !values.is_a?(Array)
-            change(self.class::HDRDESCR.index(field)*2, values.pack(pack))
+            ofs = 0
+            idx = self.class::HDRDESCR.index(field)
+            pack = tbl[idx, values.length].map{|v| v[2]}.join('')
+            change(tbl[idx][0], values.pack(pack))
         end
 
         def setBodySize(size); setFileSize(size + headerSize()) end
@@ -73,13 +108,10 @@ module Resedit
         def headerSize(); self.class::HSIZE end
 
         def print(what, how)
-            return false if what!="header"
+            return super(what, how) if what!="header"
             mode(parseHow(how))
-            ofs=0
-            wsz = @exe.wsize
             @info.each{|k,v|
-                printf("%20s:\t%s\n", k.to_s, colStr(v, changed?(ofs,wsz)))
-                ofs+=2
+                printf("%20s:\t%s\n", k.to_s, colStr(v, changed?(fieldOffset(k),fieldSize(k))))
             }
             puts
             return true
@@ -89,6 +121,7 @@ module Resedit
         def fileSize(); raise "NotImplemented"  end
         def setFileSize(size); raise "NotImplemented" end
         def entry(size); raise "NotImplemented" end
+        def addReloc(ofs, value); raise "NotImplemented" end
     end
 
 
@@ -102,12 +135,6 @@ module Resedit
             @addsz = 0
         end
 
-        def removeAppend()
-            mode(HOW_CHANGED)
-            undo(0) if @root.obuf.length==0
-            @addsz = 0
-        end
-
         def revert(what)
             super(what)
             @addsz = 0
@@ -158,11 +185,33 @@ module Resedit
             end
         end
 
+        def textAt(pos, minlen, rexp=nil)
+            rexp = /^[[:print:][:space:]]+$/ if !rexp
+            sz = size
+            ln = [minlen+64, sz-pos].min
+            return nil if ln<minlen
+            data = getData(pos, ln)
+            prev = 0
+            while true
+                zpos = data.index("\x00")
+                return nil if zpos!=nil && zpos<minlen
+                data = data[0,zpos] if zpos!=nil
+                return nil if (data[prev..-1] =~ rexp) != 0
+                return data if zpos != nil
+                prev = data.length
+                return nil if pos+prev+64 > size
+                data += getData(pos+prev, 64)
+            end
+        end
+
+        def addrFormatter(hofs); nil end
         def raw2addr(ofs); raise "Not implemented" end
         def addr2raw(addr); raise "Not implemented" end
         def append(bytes, where=nil); raise "NotImplemented" end
-        def addrFormatter(hofs); nil end
+        def removeAppend(); raise "Not Implemented" end
         def readRelocated(ofs, size); raise "NotImplemented" end
+        def findRelocValue(value);  raise "NotImplemented" end
+        def findStrings(minsize); raise "NotImplemented" end
     end
 
     class ExeFile
@@ -287,8 +336,6 @@ module Resedit
             log("Change added at %08X", res) if res
         end
 
-        def reloc(ofs); raise "NotImplemented" end
-
         def readRelocated(ofs, size); @body.readRelocated(ofs, size) end
 
         def dasm(ofs, size=nil, how=nil)
@@ -298,7 +345,7 @@ module Resedit
         end
 
 
-        def valueof(str, type)
+        def valueof(str, type=nil)
             puts "value of " + str + " is:"
             p getValue(str, type).unpack("H*")
         end
@@ -325,15 +372,48 @@ module Resedit
             @body.saveData(f)
         end
 
-        def save(filename)
+        def save(filename, final=nil)
+            raise "Wrong 'final' word" if final and final != 'final'
             raise "Filename expected." if !filename
             open(filename, "wb:ascii-8bit"){|f|
                 saveFile(f)
             }
+            return if final
             open(filename+CFGEXT, "w"){|f|
                 f.write(JSON.pretty_generate(saveConfig()))
             }
         end
+
+        def reloc(ofs, target=nil)
+            ofs = s2i(ofs)
+            trg = s2i(target) if target
+            res = @header.addReloc(ofs, trg)
+            log((res ? "Relocation added %08X" : "Relocation %08X already exists"), ofs)
+            return res
+        end
+
+        def relocfind(value, type=nil);
+            value = getValue(value, type)
+            res = @body.findRelocValue(value)
+            log("relocs not found") if !res
+            return nil if !res
+            res.each{|k,v|
+                log("found at #{k.to_s(16)} relocs: #{v.map{|a| a.to_s(16)}}")
+            }
+            return res
+        end
+
+        def stringfind(size=nil)
+            size = (size==nil || size=='') ? 3 : s2i(size)
+            res = @body.findStrings(size)
+            log("strings not found") if !res
+            return nil if !res
+            log("%d strings found:\n", res.length)
+            res.each{|a|
+                log("%s at %08X relocs: #{a[2].map{|v| v.to_s(16)}}", a[0], a[1])
+            }
+            return res
+        end
     end
 
 end

data/lib/resedit/mz/bw.rb

@@ -9,7 +9,7 @@ module Resedit
                     :RuntimeGdtSize, :MAKEPMVer, :NextHeaderPos, :CVInfoOffset, :LastSelUsed, :PMemAlloc, :AllocIncr, :Reserved4, :Options,
                     :TransStackSel, :ExpFlags, :ProgramSize, :GdtImageSize, :FirstSelector, :DefaultMemStrategy, :Reserved5, :TransferBufferSize,
                     :Reserved6, :ExpPath]
-        HDRUNPACK = "v14V2v3s6v6HHvs48a64"
+        HDRUNPACK = "v14VVv3a6v6CCva48a64"
 
         # unsigned_16 signature;          /* BW signature to mark valid file  */
         # unsigned_16 last_page_bytes;    /* length of image mod 512          */

data/lib/resedit/mz/le.rb

@@ -9,63 +9,11 @@ module Resedit
                     :PageSize, :PageShift, :FixupSize, :FixupCsum, :LoaderSize, :LoaderCsum, :ObjectTableOfs, :ObjectsInModule,
                     :ObjectPageOfs, :ObjectIterOfs, :ResourceTableOfs, :ResourceTableEntries, :ResidentTableOfs, :EntryTableOfs,
                     :ModuleDirectivesOfs, :ModuleDirectives, :FixupPageOfs, :FixupRecordOfs, :ImportTblOfs, :ImportEntries, :ImportProcOfs,
-                    :PerPageCsum, :DataPagesOfs, :PreloadPages, :NonResTableOfs, :NonResTableLen, :NonResTableCsum, :AutoDSObject,
+                    :PerPageCsumOfs, :DataPagesOfs, :PreloadPages, :NonResTableOfs, :NonResTableLen, :NonResTableCsum, :AutoDSObject,
                     :DebugInfoOfs, :DebugInfoLen, :InstancePreload, :InstanceDemand, :Heapsize]
-        HDRUNPACK = "vHHVvvV40"
-
-        #    00h | "L"   "X" |B-ORD|W-ORD|     FORMAT LEVEL      |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 08h | CPU TYPE  |  OS TYPE  |    MODULE VERSION     |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 10h |     MODULE FLAGS      |   MODULE # OF PAGES   |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 18h |     EIP OBJECT #      |          EIP          |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 20h |     ESP OBJECT #      |          ESP          |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 28h |       PAGE SIZE       |   PAGE OFFSET SHIFT / LE: last page bytes !!!  |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 30h |  FIXUP SECTION SIZE   | FIXUP SECTION CHECKSUM|
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 38h |  LOADER SECTION SIZE  |LOADER SECTION CHECKSUM|
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 40h |    OBJECT TABLE OFF   |  # OBJECTS IN MODULE  |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 48h | OBJECT PAGE TABLE OFF | OBJECT ITER PAGES OFF |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 50h | RESOURCE TABLE OFFSET |#RESOURCE TABLE ENTRIES|
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 58h | RESIDENT NAME TBL OFF |   ENTRY TABLE OFFSET  |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 60h | MODULE DIRECTIVES OFF | # MODULE DIRECTIVES   |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 68h | FIXUP PAGE TABLE OFF  |FIXUP RECORD TABLE OFF |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 70h | IMPORT MODULE TBL OFF | # IMPORT MOD ENTRIES  |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 78h |  IMPORT PROC TBL OFF  | PER-PAGE CHECKSUM OFF |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 80h |   DATA PAGES OFFSET FROM MZ !!!  |    #PRELOAD PAGES     |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 88h | NON-RES NAME TBL OFF  | NON-RES NAME TBL LEN  |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 90h | NON-RES NAME TBL CKSM |   AUTO DS OBJECT #    |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 98h |    DEBUG INFO OFF     |    DEBUG INFO LEN     |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # A0h |   #INSTANCE PRELOAD   |   #INSTANCE DEMAND    |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # A8h |       HEAPSIZE        |
-        #
-
-        # Object Table
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 00h |     VIRTUAL SIZE      |    RELOC BASE ADDR    |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 08h |     OBJECT FLAGS      |    PAGE TABLE INDEX   |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
-        # 10h |  # PAGE TABLE ENTRIES |       RESERVED        |
-        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        HDRUNPACK = "vCCVvvV*"
+        HDR_OFFSETS = [:ObjectTableOfs, :ObjectPageOfs, :ObjectIterOfs, :ResourceTableOfs,:ResidentTableOfs, :EntryTableOfs, :ModuleDirectivesOfs,
+                     :FixupPageOfs, :FixupRecordOfs, :ImportTblOfs, :ImportProcOfs, :PerPageCsumOfs, :DataPagesOfs, :NonResTableOfs, :DebugInfoOfs]
 
         attr_reader :tables
 
@@ -103,28 +51,6 @@ module Resedit
             addData(file, headerSize() + @sofs - file.tell())
         end
 
-        def readRelocs()
-            def read(pos,cnt, unp); [getData(@info[:FixupRecordOfs]+pos, cnt).unpack(unp),pos+cnt] end
-            ret = {}
-            pgs = getData(@info[:FixupPageOfs], 4*(@info[:ModulePages]+1)).unpack("V*")
-            for i in 0..@info[:ModulePages]-1
-                pos = pgs[i]
-                op = @tables[:Pages][i]
-                pgofs = ((op>>16) + ((op>>8) & 0xFF) -1) * @info[:PageSize]
-                ret[pgofs] = {}
-                while pos<pgs[i+1]
-                    v,pos = read(pos, 5, "CCvC")
-                    raise "Unknown fixup type #{v[0]} #{v[1]}" if (v[0]!=7 && v[0]!=2) || (v[1] & ~0x10 !=0 )
-                    trg, pos=read(pos, v[1]==0x10 ? 4 : 2,v[1]==0x10 ? "V" : "v")
-                    next if v[2]>0x7FFF
-                    ofs = pgofs+v[2]
-                    ret[pgofs][pgofs+v[2]] = @tables[:Objects][v[3]-1][1]+trg[0]
-                end
-            end
-            return ret
-        end
-
-
         def mode(how)
             super(how)
             if @mode == HOW_ORIGINAL
@@ -135,11 +61,143 @@ module Resedit
             end
         end
 
-        def headerSize(); @info[:DataPagesOfs]-@exe.mzSize end
 
+        def headerSize(); @info[:DataPagesOfs]-@exe.mzSize end
         def fileSize(); headerSize()+(@info[:ModulePages]-1)*@info[:PageSize]+@info[:PageShift] end
         def entry; sprintf("0x%08X", @info[:EIP]) end
 
+        def pageRelocs(pageId, fixOfs=nil, fixObj=nil, fixVal=nil)
+            def read(pos,cnt, unp); [getData(@info[:FixupRecordOfs]+pos, cnt).unpack(unp), pos+cnt] end
+            pgs = getData(@info[:FixupPageOfs]+4*pageId, 8).unpack("V*")
+            pgofs = pageId * @info[:PageSize]
+            ret = {}
+            pos = pgs[0]
+            while pos<pgs[1]
+                v,pos = read(pos, 5, "CCs<C")
+                raise "Unknown fixup type #{v[0]} #{v[1]}" if (v[0]!=7 && v[0]!=2) || (v[1] & ~0x10 !=0 )
+                trg, pos=read(pos, v[1]==0x10 ? 4 : 2,v[1]==0x10 ? "V" : "v")
+                next if fixOfs!=nil && (v[2]!=fixOfs || (v[1]==0 && fixVal>0xFF))
+                if fixOfs
+                    buf = [fixObj, fixVal].pack("C" + v[1]==0x10 ? "V" : "v")
+                    change(@info[:FixupRecordOfs]+pos-1, buf)       #change fixup object & value
+                    return true
+                end
+                next if v[2]<0
+                ret[pgofs+v[2]] = @tables[:Objects][v[3]-1][1]+trg[0]
+            end
+            return false if fixOfs
+            return ret
+        end
+
+
+        def addPageReloc(pageId, ofs, obj, val)
+            return true if pageRelocs(pageId, ofs, obj, val)
+            #extend page fixups
+            buf = [7, 0x10, ofs, obj, val].pack("CCs<CV")
+            #change fixups offsets
+            pgs = getData(@info[:FixupPageOfs]+4*(pageId+1), (@info[:ModulePages]-pageId)*4).unpack("V*")
+            d = buf.length
+            insert(@info[:FixupRecordOfs]+pgs[0], buf)
+            pgs = pgs.map{|v| v+d} #fixup sizes change
+            change(@info[:FixupPageOfs]+4*(pageId+1), pgs.pack("V*"))
+            #fix header
+            fixOffsets(@info[:FixupRecordOfs], d)
+            @info[:FixupSize]+=d
+            setInfo(:FixupSize, @info[:FixupSize])
+            @info[:LoaderSize]+=d
+            setInfo(:LoaderSize, @info[:LoaderSize])
+            @_tables = nil
+            mode(HOW_CHANGED)
+            rels = pageRelocs(pageId)
+        end
+
+
+        def readRelocs()
+            ret = {}
+            for i in 0..@info[:ModulePages]-1
+                pgofs = i * @info[:PageSize]
+                ret[pgofs] = pageRelocs(i)
+            end
+            return ret
+        end
+
+
+        def fixOffsets(after, val)
+            HDR_OFFSETS.each{|ofs|
+                next if @info[ofs]==0 or @info[ofs]<=after
+                @info[ofs]+=val
+                setInfo(ofs, @info[ofs])
+            }
+        end
+
+
+        def addSegment(size)
+            mode(HOW_CHANGED)
+            psz = @info[:PageSize]
+            tail = size % psz
+            pgs = size / psz + (tail==0 ? 0 : 1)
+            tail = psz if tail==0
+
+            #add new object
+            last = @tables[:Objects][-1]
+            virt = last[1]+last[0]  #lastobject virt base+size
+            virt = (virt+psz-1) & ~(psz-1) #align vbase to page size
+            obj = [psz*pgs, virt, 0x2047, last[3]+last[4], pgs, 0].pack("V*")  # 32b rwx preloaded object
+            insert(@info[:ObjectTableOfs] + 0x18*@info[:ObjectsInModule], obj)
+            fixOffsets(@info[:ObjectTableOfs], 0x18)
+            setInfo(:ObjectsInModule, @info[:ObjectsInModule]+1)
+
+            #add pages info
+            pinfo = ''
+            pgs.times{|i|
+                pid = @info[:ModulePages]+i+1
+                pinfo+=[(pid*@info[:PageSize])<<4].pack("V")
+            }
+            insert(@info[:ObjectPageOfs]+@info[:ModulePages]*4, pinfo)
+            fixOffsets(@info[:ObjectPageOfs], pinfo.length)
+
+            #add empty fixups
+            fixofs = 4*@info[:ModulePages]
+            fixval = getData(@info[:FixupPageOfs]+fixofs, 4).unpack("V")[0]
+            pinfo = [fixval].pack("V") * pgs #end of fixup table <added pages> times
+            insert(@info[:FixupPageOfs]+fixofs+4, pinfo)
+            fixOffsets(@info[:FixupPageOfs], pinfo.length)
+            setInfo(:FixupSize, @info[:FixupSize]+pinfo.length)
+
+            #change pages and tail, fix loader size
+            setInfo(:ModulePages, @info[:ModulePages]+pgs)
+            setInfo(:PageShift, tail)
+            setInfo(:LoaderSize, @info[:ImportTblOfs]-@info[:ObjectTableOfs]+1)
+
+            @_tables = nil
+            #reload tables
+            mode(HOW_CHANGED)
+
+            return (@info[:ModulePages]-pgs)*@info[:PageSize]
+        end
+
+
+        def addReloc(ofs, trg=nil)
+            mode(HOW_CHANGED)
+            trg = trg ? @exe.body.raw2addr(trg) : getData(ofs, 4)
+            obj = val = -1
+            @tables[:Objects].each_with_index{|o,i|
+                obj,val = [i+1,trg-o[1]] if o[1]<=trg && o[0]+o[1]>trg
+            }
+            raise "Target not found for offset: #{trg.to_i(trg)}" if obj==-1
+            psz = @info[:PageSize]
+            pgid = ofs / psz
+            #puts "Adding reloc #{ofs.to_s(16)} -> #{trg.to_s(16)} #{obj}:#{val.to_s(16)} #{pgid}"
+            ofs = ofs % psz
+            addPageReloc(pgid, ofs, obj, val)
+            addPageReloc(pgid+1, ofs-psz, obj, val) if ofs+4>psz
+            @_tables = nil
+            mode(HOW_CHANGED)
+            @exe.body.clearRelocs()
+            return true
+        end
+
+
         def print(what, how=nil)
             ret = super(what, how)
             if what=="tables"
@@ -172,6 +230,8 @@ module Resedit
             @sex
         end
 
+        def clearRelocs; @relocs=nil end
+
         def relocations()
             if !@relocs
                 @relocs = @exe.header.readRelocs().sort_by{|k,v| k}.reverse.to_h
@@ -192,8 +252,9 @@ module Resedit
             return s[0]+ofs-s[1]
         end
 
-        def addr2raw(addr)
+        def addr2raw(addr, raiseOnError=true)
             s = sections.find{|s| s[0]<=addr && s[0]+s[2]>addr}
+            return nil if !s && !raiseOnError
             raise "Not virtual address #{addr.to_s(16)}" if !s
             return s[1]+addr-s[0]
         end
@@ -214,6 +275,66 @@ module Resedit
             return d[0,size]
         end
 
+        def append(bytes, where=nil)
+            @relocs = nil
+            mode(HOW_CHANGED)
+            pos = @exe.header.addSegment(bytes.length)
+            sz = size
+            insert(sz, "\x00"*(pos-sz))
+            insert(pos, bytes)
+            return [raw2addr(pos), pos]
+        end
+
+        def findRelocValue(value)
+            rel = relocations()
+            cnt = rel.length
+            ret={}
+            vlen = value.length
+            i = 1
+            fsz = size
+            rel.each{|o,r|
+                r.each{|k,v|
+                    raw = addr2raw(v, false)
+                    next if raw==nil || raw+vlen>fsz
+                    vl = getData(raw, vlen)
+                    next if vl!=value
+                    ret[v] = [] if !ret[v]
+                    ret[v] += [raw2addr(k)]
+                }
+            }
+            return nil if ret.length==0
+            return ret
+        end
+
+        def findStrings(minsize)
+            rel = relocations()
+            cnt = rel.length
+            fsz = size
+            proced = {}
+            i = 1
+            ret = []
+            rel.each{|o,r|
+                r.each{|k,v|
+                    if proced[v]!=nil
+                        ret[proced[v]][2]+=[raw2addr(k)] if proced[v]>=0
+                        next
+                    end
+                    raw = addr2raw(v, false)
+                    if raw==nil || raw+minsize>fsz
+                        proced[v] = -1
+                        next
+                    end
+                    txt = textAt(raw, minsize)
+                    if txt != nil
+                        ret+= [[txt, v, [raw2addr(k)]]]
+                    end
+                    proced[v] = txt==nil ? -1 : ret.length-1
+                }
+            }
+            return nil if ret.length==0
+            return ret
+        end
+
     end
 
 

data/lib/resedit/mz/multiexe.rb

@@ -39,6 +39,18 @@ module Resedit
             }
         end
 
+        def dump(out, parts, how=nil)
+            prts = eval(parts)
+            open(out,"wb"){|f|
+                prts.each{|i|
+                    pr = @parts[i]
+                    pr.header.mode(pr.header.parseHow(how))
+                    pr.body.mode(pr.header.parseHow(how))
+                    pr.saveFile(f)
+                }
+            }
+        end
+
         def header; @cur.header end
         def body; @cur.body end
         def env; @cur.env end
@@ -62,7 +74,9 @@ module Resedit
         def append(value, type=nil, where=nil); @cur.append(value, type, where) end
         def replace(value, type=nil, where=nil); @cur.replace(value, type, where) end
         def change(ofs, value, disp=nil, type=nil); @cur.change(ofs, value, disp, type) end
-        def reloc(ofs); @cur.reloc(ofs) end
+        def reloc(ofs, target=nil); @cur.reloc(ofs, target) end
+        def relocfind(value, type=nil); @cur.relocfind(value, type) end
+        def stringfind(size=nil); @cur.stringfind(size) end
         def dasm(ofs, size=nil, how=nil) @cur.dasm(ofs, size, how) end
         def valueof(str, type); @cur.valueof(str, type) end
         def revert(what); @cur.revert(what) end

data/lib/resedit/mz/mz.rb

@@ -104,7 +104,7 @@ module Resedit
             mode(HOW_CHANGED)
         end
 
-        def addReloc(ofs)
+        def addReloc(ofs, trg)
             mode(HOW_CHANGED)
             #check relocation exists
             for i in 0..@info[:NumberOfRelocations]-1
@@ -250,6 +250,13 @@ module Resedit
             return res
         end
 
+        def removeAppend()
+            mode(HOW_CHANGED)
+            undo(0) if @root.obuf.length==0
+            @addsz = 0
+        end
+
+
 
         def print(what, how)
             if what=="header"
@@ -272,13 +279,6 @@ module Resedit
     class MZ < ExeFile
         HDRCLASS = MZHeader
         BODYCLASS = MZBody
-
-        def reloc(ofs)
-            ofs = s2i(ofs)
-            res = @header.addReloc(ofs)
-            log((res ? "Relocation added %08X" : "Relocation %08X already exists"), ofs)
-        end
-
     end
 
 end

data/lib/resedit/text/escaper.rb

@@ -31,7 +31,7 @@ module Resedit
                 inc=1
                 if ntbl[val]
                     ntbl[val].each{|v,b|
-                        next if str.length < pos+v.length+1
+                        next if str.length < pos+v.length
                         if v==str[pos,v.length]
                             val=b.chr
                             inc=v.length

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: resedit
 version: !ruby/object:Gem::Version
-  version: '1.8'
+  version: 1.8.1
 platform: ruby
 authors:
 - bjfn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-11 00:00:00.000000000 Z
+date: 2017-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chunky_png