import struct, sys

def read(off, n):
    with open('/dev/sda3', 'rb', buffering=0) as f:
        f.seek(off)
        return f.read(n)

sb = read(1024, 1024)
BS = 1024 << struct.unpack_from('<I', sb, 24)[0]
ipg = struct.unpack_from('<I', sb, 40)[0]
isz = struct.unpack_from('<H', sb, 88)[0]
fdb = struct.unpack_from('<I', sb, 20)[0]
dsz = struct.unpack_from('<H', sb, 254)[0]
dsz2 = dsz if dsz >= 32 else 32

def inode(ino):
    grp = (ino - 1) // ipg
    idx = (ino - 1) % ipg
    desc = read((fdb + 1) * BS + grp * dsz2, 64)
    itab = struct.unpack_from('<I', desc, 8)[0]
    if dsz2 >= 64:
        itab |= struct.unpack_from('<I', desc, 40)[0] << 32
    return read(itab * BS + idx * isz, 256)

def blocks(ino):
    inod = inode(ino)
    out = []
    def parse(node):
        if len(node) < 12:
            return
        magic, ents, max_ents, depth = struct.unpack_from('<HHHH', node, 0)
        if magic != 0xF30A:
            return
        for k in range(ents):
            off = 12 + 12 * k
            if off + 12 > len(node):
                break
            if depth == 0:
                eblk, elen, ehi, elo = struct.unpack_from('<IHHI', node, off)
                p = (ehi << 32) | elo
                for i in range(elen & 0x7FFF):
                    out.append(p + i)
            else:
                eblk, leaf_lo, leaf_hi, _ = struct.unpack_from('<IIHH', node, off)
                child_p = (leaf_hi << 32) | leaf_lo
                parse(read(child_p * BS, BS))
    parse(inod[40:100])
    if not out:
        for k in range(12):
            p = struct.unpack_from('<I', inod, 40 + 4 * k)[0]
            if p:
                out.append(p)
    return out

def fsize(ino):
    return struct.unpack_from('<I', inode(ino), 4)[0]

def readfile(ino):
    size = fsize(ino)
    data = b''
    for pb in blocks(ino):
        data += read(pb * BS, BS)
        if len(data) >= size:
            break
    return data[:size]

def dirents(ino):
    res = []
    for pb in blocks(ino):
        blk = read(pb * BS, BS)
        off = 0
        while off + 8 <= len(blk):
            e_ino, reclen, namelen, ftype = struct.unpack_from('<IHBB', blk, off)
            if reclen < 8 or off + reclen > len(blk):
                break
            if e_ino:
                res.append((blk[off + 8:off + 8 + namelen].decode('latin1'), e_ino, ftype))
            off += reclen
    return res

def lookup(path):
    ino = 2
    for part in path.strip('/').split('/'):
        f = None
        for nm, i, t in dirents(ino):
            if nm == part:
                f = i
                break
        if f is None:
            return None
        ino = f
    return ino

if __name__ == '__main__':
    if len(sys.argv) < 2:
        print("Usage: pathread.py <path> [tail_bytes]")
        sys.exit(1)
    p = sys.argv[1]
    tail = int(sys.argv[2]) if len(sys.argv) > 2 else 4000
    ino = lookup(p)
    print('== %s ino=%s ==' % (p, ino), flush=True)
    if ino:
        data = readfile(ino)
        print(data[-tail:].decode('latin1'), flush=True)