/* lefile.cpp --

   This file is part of the UPX executable compressor.

   Copyright (C) 1996-2025 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 1996-2025 Laszlo Molnar

   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them

   and/or modify them under the terms of the GNU General Public License as

   published by the Free Software Foundation; either version 2 of

   the License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; see the file COPYING.

   If not, write to the Free Software Foundation, Inc.,

   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

   Markus F.X.J. Oberhumer              Laszlo Molnar

   <markus@oberhumer.com>               <ezerotven+github@gmail.com>

 */

#include "conf.h"

#include "file.h"

#include "lefile.h"

LeFile::LeFile(InputFile *f) noexcept : fif(f) {

    COMPILE_TIME_ASSERT(sizeof(le_header_t) == 196)

    COMPILE_TIME_ASSERT(sizeof(le_object_table_entry_t) == 24)

    COMPILE_TIME_ASSERT(sizeof(le_pagemap_entry_t) == 4)

    mem_clear(&ih);

    mem_clear(&oh);

}

LeFile::~LeFile() noexcept {

    delete[] iobject_table;

    delete[] oobject_table;

    delete[] ifpage_table;

    delete[] ofpage_table;

    delete[] ipm_entries;

    delete[] opm_entries;

    delete[] ires_names;

    delete[] ores_names;

    delete[] ifixups;

    delete[] ofixups;

    delete[] inonres_names;

    delete[] ononres_names;

    delete[] ientries;

    delete[] oentries;

}

#define objects ih.object_table_entries

#define pages   ih.memory_pages

#define mps     ih.memory_page_size

void LeFile::readObjectTable() {

    soobject_table = objects;

    iobject_table = New(le_object_table_entry_t, soobject_table);

    fif->seek(le_offset + ih.object_table_offset, SEEK_SET);

    fif->readx(iobject_table, sizeof(*iobject_table) * objects);

}

void LeFile::writeObjectTable() {

    if (fof && oobject_table)

        fof->write(oobject_table, sizeof(*iobject_table) * soobject_table);

}

void LeFile::readPageMap() {

    sopm_entries = pages;

    ipm_entries = New(le_pagemap_entry_t, sopm_entries);

    fif->seek(le_offset + ih.object_pagemap_offset, SEEK_SET);

    fif->readx(ipm_entries, sizeof(*ipm_entries) * pages);

    for (unsigned ic = 0; ic < pages; ic++)

        if ((ipm_entries[ic].type & 0xC0) != 0 && (ipm_entries[ic].type & 0xC0) != 0xC0)

            throwCantPack("unexpected value in page map table");

}

void LeFile::writePageMap() {

    if (fof && opm_entries)

        fof->write(opm_entries, sizeof(*ipm_entries) * sopm_entries);

}

void LeFile::readResidentNames() {

    sores_names = ih.entry_table_offset - ih.resident_names_offset;

    ires_names = New(byte, sores_names);

    fif->seek(le_offset + ih.resident_names_offset, SEEK_SET);

    fif->readx(ires_names, sores_names);

}

void LeFile::writeResidentNames() {

    if (fof && ores_names)

        fof->write(ores_names, sores_names);

}

void LeFile::readEntryTable() {

    soentries = ih.fixup_page_table_offset - ih.entry_table_offset;

    fif->seek(le_offset + ih.entry_table_offset, SEEK_SET);

    ientries = New(byte, soentries);

    fif->readx(ientries, soentries);

}

void LeFile::writeEntryTable() {

    if (fof && oentries)

        fof->write(oentries, soentries);

}

void LeFile::readFixupPageTable() {

    sofpage_table = 1 + pages;

    ifpage_table = New(unsigned, sofpage_table);

    fif->seek(le_offset + ih.fixup_page_table_offset, SEEK_SET);

    fif->readx(ifpage_table, 4 * sofpage_table);

}

void LeFile::writeFixupPageTable() {

    if (fof && ofpage_table)

        fof->write(ofpage_table, 4 * sofpage_table);

}

void LeFile::readFixups() {

    sofixups = get_le32(ifpage_table + pages) - get_le32(ifpage_table);

    ifixups = New(byte, sofixups);

    fif->seek(le_offset + ih.fixup_record_table_offset, SEEK_SET);

    fif->readx(ifixups, sofixups);

}

void LeFile::writeFixups() {

    if (fof && ofixups)

        fof->write(ofixups, sofixups);

}

unsigned LeFile::getImageSize() const {

    unsigned n = 0;

    if (ih.memory_pages > 0) {

        n = (ih.memory_pages - 1) * ih.memory_page_size;

        n += ih.bytes_on_last_page;

    }

    return n;

}

void LeFile::readImage() {

    soimage = mem_size(mps, pages); // assert size

    if (!soimage)                   // late detection, but protect against .alloc(0)

        throwCantPack("no soimage");

    mb_iimage.alloc(soimage);

    mb_iimage.clear();

    iimage = mb_iimage; // => now a SPAN_S

    unsigned ic, jc;

    for (ic = jc = 0; ic < pages; ic++) {

        if ((ipm_entries[ic].type & 0xC0) == 0) {

            fif->seek(ih.data_pages_offset + exe_offset +

                          (ipm_entries[ic].m * 0x100 + ipm_entries[ic].l - 1) * mps,

                      SEEK_SET);

            unsigned bytes = ic != pages - 1 ? mps : ih.bytes_on_last_page;

            fif->readx(iimage + jc, bytes);

        }

        jc += mps;

    }

}

void LeFile::writeImage() {

    if (fof && oimage != nullptr)

        fof->write(oimage, soimage);

}

void LeFile::readNonResidentNames() {

    if (ih.non_resident_name_table_length) {

        sononres_names = ih.non_resident_name_table_length;

        inonres_names = New(byte, sononres_names);

        fif->seek(exe_offset + ih.non_resident_name_table_offset, SEEK_SET);

        fif->readx(inonres_names, sononres_names);

    }

}

void LeFile::writeNonResidentNames() {

    if (fof && ononres_names)

        fof->write(ononres_names, sononres_names);

}

bool LeFile::readFileHeader() {

#define H(x) get_le16(header + (2 * (x)))

    byte header[0x40];

    le_offset = exe_offset = 0;

    int ic;

    for (ic = 0; ic < 20; ic++) {

        fif->seek(le_offset, SEEK_SET);

        fif->readx(header, sizeof(header));

        if (memcmp(header, "MZ", 2) == 0) // normal dos exe

        {

            exe_offset = le_offset;

            if (H(0x18 / 2) >= 0x40 && memcmp(header + 0x19, "TIPPACH", 7)) // new format exe

                le_offset += H(0x3c / 2) + H(0x3e / 2) * 65536;

            else {

                le_offset += H(2) * 512 + H(1);

                if (H(1))

                    le_offset -= 512;

                else if (H(2) == 0)

                    return false;

            }

        } else if (memcmp(header, "BW", 2) == 0) // used in dos4gw.exe

            le_offset += H(2) * 512 + H(1);

        else if (memcmp(header, "LE", 2) == 0)

            break; // success

        else if (memcmp(header, "PMW1", 4) == 0)

            throwCantPack("already packed with PMWLITE");

        else

            return false;

    }

    if (ic == 20)

        return false;

    fif->seek(le_offset, SEEK_SET);

    fif->readx(&ih, sizeof(ih));

    if (mps < 512 || mps > 2097152 || (mps & (mps - 1)) != 0)

        throwCantPack("LE file header invalid page size %u", (unsigned) mps);

    if (ih.bytes_on_last_page > mps || pages == 0)

        throwCantPack("bad LE file header");

    if (!mem_size_valid(mps, pages) || exe_offset > le_offset)

        throwCantPack("bad LE file header");

    return true;

#undef H

}

void LeFile::writeFile(OutputFile *f, bool le) {

    fof = f;

    memcpy(&oh, &ih,

           (charptr) &oh.memory_pages - (charptr) &oh); // copy some members of the orig. header

    oh.memory_page_size = mps;

    oh.object_table_offset = sizeof(oh);

    oh.object_table_entries = soobject_table;

    oh.object_pagemap_offset = oh.object_table_offset + soobject_table * sizeof(*iobject_table);

    oh.resident_names_offset = oh.object_pagemap_offset + sopm_entries * sizeof(*ipm_entries);

    oh.entry_table_offset = oh.resident_names_offset + sores_names;

    oh.fixup_page_table_offset = oh.entry_table_offset + soentries;

    oh.fixup_record_table_offset = oh.fixup_page_table_offset + sofpage_table * 4;

    oh.imported_modules_name_table_offset = oh.fixup_record_table_offset + sofixups - FIXUP_EXTRA;

    oh.imported_procedures_name_table_offset = oh.imported_modules_name_table_offset;

    oh.data_pages_offset =

        oh.fixup_record_table_offset + sofixups + (le ? 0 : le_offset - exe_offset);

    if (ih.non_resident_name_table_length) {

        oh.non_resident_name_table_offset = oh.data_pages_offset + soimage;

        oh.non_resident_name_table_length = sononres_names;

    }

    oh.fixup_size = sofixups + 4 * sofpage_table;

    oh.loader_size = oh.fixup_size + oh.fixup_page_table_offset - sizeof(oh);

    fof->write(&oh, sizeof(oh));

    writeObjectTable();

    writePageMap();

    writeResidentNames();

    writeEntryTable();

    writeFixupPageTable();

    writeFixups();

    writeImage();

    writeNonResidentNames();

}

void LeFile::countFixups(unsigned *counts) const {

    const unsigned o = objects;

    memset(counts, 0, mem_size(sizeof(unsigned), o + 2));

    // counts[0..objects-1] - # of 32-bit offset relocations in for that objects

    // counts[objects]      - # of selector fixups

    // counts[objects+1]    - # of self-relative fixups

    const byte *fix = ifixups;

    const unsigned sfixups = get_le32(ifpage_table + pages);

    unsigned ll;

    while (ptr_udiff_bytes(fix, ifixups) < sfixups) {

        if ((fix[1] & ~0x10) != 0)

            throwCantPack("unsupported fixup record");

        switch (*fix) {

        case 2: // selector fixup

            counts[o] += 9;

            fix += 5;

            break;

        case 0x12: // alias selector

            throwCantPack("16-bit selector alias fixup not yet supported");

        case 5: // 16-bit offset

            fix += (fix[1] & 0x10) ? 9 : 7;

            break;

        case 6: // 16:32 pointer

            counts[o] += 9;

            // fall through

        case 7: // 32-bit offset

            counts[fix[4] - 1] += 4;

            fix += (fix[1] & 0x10) ? 9 : 7;

            break;

        case 0x27: // 32-bit offset list

            ll = fix[2];

            counts[fix[3] - 1] += ll * 4;

            fix += (fix[1] & 0x10) ? 6 : 4;

            fix += ll * 2;

            break;

        case 8: // 32-bit self relative fixup

            counts[o + 1] += 4;

            fix += (fix[1] & 0x10) ? 9 : 7;

            break;

        default:

            throwCantPack("unsupported fixup record");

        }

    }

    counts[o]++;        // extra space for 'ret'

    counts[o + 1] += 4; // extra space for 0xFFFFFFFF

}

/* vim:set ts=4 sw=4 et: */