From 6ab29a7ec498d3893dd602b881ae4d354a784b10 Mon Sep 17 00:00:00 2001
From: itsme <itsme@xs4all.nl>
Date: Wed, 7 Jul 2021 10:25:29 +0200
Subject: several updates:

 * added 'readrec' method to Datafile
 * case insensitive filename matching
 * added 'destruct' option to decode top level stru information.
---
 crodump.py | 133 ++++++++++++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 110 insertions(+), 23 deletions(-)

diff --git a/crodump.py b/crodump.py
index 7a9d9f3..f50f45b 100644
--- a/crodump.py
+++ b/crodump.py
@@ -4,6 +4,8 @@ import struct
 from binascii import b2a_hex
 from hexdump import hexdump, asasc, tohex, unhex
 from koddecoder import kodecode
+from readers import ByteReader
+
 """
 python3 crodump.py crodump chechnya_proverki_ul_2012
 python3 crodump.py kodump -s 6   -o 0x4cc9 -e 0x5d95 chechnya_proverki_ul_2012/CroStru.dat
@@ -28,10 +30,12 @@ def enumunreferenced(ranges, filesize):
 
 class Datafile:
     """ Represent a single .dat with it's .tad index file """
-    def __init__(self, dat, tad):
+    def __init__(self, dat, tad, need_decode=False):
         self.dat = dat
         self.tad = tad
 
+        self.need_decode = need_decode
+
         self.readtad()
 
         self.dat.seek(0, io.SEEK_END)
@@ -48,9 +52,40 @@ class Datafile:
         self.dat.seek(ofs)
         return self.dat.read(size)
 
+    def readrec(self, idx):
+        ofs, ln, chk = self.tabidx[idx-1]
+        if ln==0xFFFFFFFF:
+            # deleted record
+            return
+
+        flags = ln>>24
+
+        ln &= 0xFFFFFFF
+        dat = self.readdata(ofs, ln)
+
+        if not dat:
+            # empty record
+            encdat = dat
+        elif self.need_decode and not flags:
+            extofs, extlen = struct.unpack("<LL", dat[:8])
+            encdat = dat[8:]
+            while len(encdat)<extlen:
+                dat = self.readdata(extofs, 0x200)
+                extofs, = struct.unpack("<L", dat[:4])
+                encdat += dat[4:]
+            encdat = encdat[:extlen]
+        else:
+            encdat = dat
+
+        if not self.need_decode:
+            return encdat
+        else:
+            return kodecode(idx, encdat)
+
+
     def dump(self, args, nodecode=False):
         print("tadhdr: %08x %08x" % tuple(self.tadhdr))
-        ranges = []
+        ranges = []  # keep track of used bytes in the .dat file.
         for i, (ofs, ln, chk) in enumerate(self.tadidx):
             if ln==0xFFFFFFFF:
                 print("%5d: %08x %08x %08x" % (i, ofs, ln, chk))
@@ -60,11 +95,14 @@ class Datafile:
             ln &= 0xFFFFFFF
             dat = self.readdata(ofs, ln)
             ranges.append((ofs, ofs+ln, "item #%d" % i))
-            plain = b''
             decflag = ' '
             infostr = ""
             tail = b''
-            if not nodecode and not flags:
+
+            if not dat:
+                # empty record
+                encdat = dat
+            elif not nodecode and not flags:
                 extofs, extlen = struct.unpack("<LL", dat[:8])
                 infostr = "%08x;%08x" % (extofs, extlen)
                 encdat = dat[8:]
@@ -101,19 +139,48 @@ class Database:
     def __init__(self, dbdir):
         self.dbdir = dbdir
 
-        self.stru = self.getfile("Stru")
+        self.stru = self.getfile("Stru", need_decode=True)
         self.index = self.getfile("Index")
         self.bank  = self.getfile("Bank")
-        self.sys = self.getfile("Sys")
+        self.sys = self.getfile("Sys", need_decode=True)
+        # BankTemp, Int
 
-    def getfile(self, name):
+
+    def getfile(self, name, need_decode=False):
         try:
-            return Datafile(open(self.getname(name, "dat"), "rb"), open(self.getname(name, "tad"), "rb"))
+            datname = self.getname(name, "dat")
+            tadname = self.getname(name, "tad")
+            if datname and tadname:
+                return Datafile(open(datname, "rb"), open(tadname, "rb"), need_decode)
         except IOError:
             return
 
     def getname(self, name, ext):
-        return os.path.join(self.dbdir, "Cro%s.%s" % (name, ext))
+        """
+        get a case-insensitive filename match for 'name.ext'.
+        Returns None when no matching file was not found.
+        """
+        basename = "Cro%s.%s" % (name, ext)
+        for fn in os.scandir(self.dbdir):
+            if basename.lower() == fn.name.lower():
+                return os.path.join(self.dbdir, fn.name)
+
+    def dump(self, args):
+        if self.stru:
+            print("stru")
+            self.stru.dump(args)
+        if args.struonly:
+            return
+        if self.index:
+            print("index")
+            self.index.dump(args)
+        if self.bank:
+            print("bank")
+            self.bank.dump(args)
+        if self.sys:
+            print("sys")
+            self.sys.dump(args)
+
 
 def incdata(data, s):
     """
@@ -179,22 +246,38 @@ def cro_dump(args):
     """ handle 'crodump' subcommand """
     db = Database(args.dbdir)
 
-    if db.stru:
-        print("stru")
-        db.stru.dump(args)
-    if args.struonly:
-        return
-    if db.index:
-        print("index")
-        db.index.dump(args, nodecode=True)
-    if db.bank:
-        print("bank")
-        db.bank.dump(args, nodecode=True)
-    if db.sys:
-        print("sys")
-        db.sys.dump(args)
+    db.dump(args)
 
 
+def destruct(args):
+    """
+    decode the index#1 structure information record
+    Takes hex input from stdin.
+    """
+    import sys
+    data = sys.stdin.buffer.read()
+    data = unhex(data)
+
+    d = dict()
+
+    rd = ByteReader(data)
+
+    o = 0
+    startbyte = rd.readbyte()
+    while not rd.eof():
+        keylen = rd.readbyte()
+        keyname = rd.readbytes(keylen).decode('ascii')
+        if keyname in d:
+            print("duplicate key: %s" % keyname)
+
+        index_or_length = rd.readdword()
+        if index_or_length >> 31:
+            d[keyname] = rd.readbytes(index_or_length & 0x7FFFFFFF)
+            print("%-20s - %s" % (keyname, toout(args, d[keyname])))
+        else:
+            d[keyname] = index_or_length
+            print("%-20s -> %s" % (keyname, d[keyname]))
+
 def main():
     import argparse
     parser = argparse.ArgumentParser(description='CRO hexdumper')
@@ -222,6 +305,10 @@ def main():
     cro.add_argument('dbdir', type=str)
     cro.set_defaults(handler=cro_dump)
 
+    des = subparsers.add_parser('destruct', help='Stru dumper')
+    des.add_argument('--ascdump', '-a', action='store_true')
+    des.set_defaults(handler=destruct)
+
     args = parser.parse_args()
 
     if args.handler:
-- 
cgit v1.2.3