/* p_djgpp2.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 "filter.h"
#include "packer.h"
#include "p_djgpp2.h"
#include "linker.h"

static const CLANG_FORMAT_DUMMY_STATEMENT
#include "stub/i386-dos32.djgpp2.h"
static const CLANG_FORMAT_DUMMY_STATEMENT
#include "stub/i386-dos32.djgpp2-stubify.h"

/*************************************************************************
//
**************************************************************************/

PackDjgpp2::PackDjgpp2(InputFile *f) : super(f), coff_offset(0) {
    bele = &N_BELE_RTP::le_policy;
    COMPILE_TIME_ASSERT(sizeof(external_scnhdr_t) == 40)
    COMPILE_TIME_ASSERT(sizeof(coff_header_t) == 0xa8)
    COMPILE_TIME_ASSERT_ALIGNED1(external_scnhdr_t)
    COMPILE_TIME_ASSERT_ALIGNED1(coff_header_t)
    COMPILE_TIME_ASSERT(sizeof(stub_i386_dos32_djgpp2_stubify) == 2048)
    COMPILE_TIME_ASSERT(STUB_I386_DOS32_DJGPP2_STUBIFY_ADLER32 == 0xbf689ba8)
    COMPILE_TIME_ASSERT(STUB_I386_DOS32_DJGPP2_STUBIFY_CRC32 == 0x2ae982b2)
    // printf("0x%08x\n", upx_adler32(stubify_stub, sizeof(stubify_stub)));
    // assert(upx_adler32(stubify_stub, sizeof(stubify_stub)) == STUBIFY_STUB_ADLER32);
}

Linker *PackDjgpp2::newLinker() const { return new ElfLinkerX86; }

const int *PackDjgpp2::getCompressionMethods(int method, int level) const {
    return Packer::getDefaultCompressionMethods_le32(method, level);
}

const int *PackDjgpp2::getFilters() const {
    static const int filters[] = {0x26, 0x24,           0x49, 0x46, 0x16, 0x13,  0x14,
                                  0x11, FT_ULTRA_BRUTE, 0x25, 0x15, 0x12, FT_END};
    return filters;
}

unsigned PackDjgpp2::findOverlapOverhead(const byte *buf, const byte *tbuf, unsigned range,
                                         unsigned upper_limit) const {
    unsigned o = super::findOverlapOverhead(buf, tbuf, range, upper_limit);
    o = (o + 0x3ff) & ~0x1ff;
    return o;
}

void PackDjgpp2::buildLoader(const Filter *ft) {
    // prepare loader
    initLoader(stub_i386_dos32_djgpp2, sizeof(stub_i386_dos32_djgpp2));
    addLoader("IDENTSTR,DJ2MAIN1", ft->id ? "DJCALLT1" : "",
              ph.first_offset_found == 1 ? "DJ2MAIN2" : "",
              M_IS_LZMA(ph.method) ? "LZMA_INIT_STACK" : "", getDecompressorSections(),
              M_IS_LZMA(ph.method) ? "LZMA_DONE_STACK" : "", "DJ2BSS00");
    if (ft->id) {
        assert(ft->calls > 0);
        addLoader("DJCALLT2");
        addFilter32(ft->id);
    }
    addLoader("DJRETURN,+40C,UPX1HEAD");
}

/*************************************************************************
// util
**************************************************************************/

void PackDjgpp2::handleStub(OutputFile *fo) {
    if (fo && !opt->djgpp2_coff.coff) {
        if (coff_offset > 0) {
            // copy stub from exe
            Packer::handleStub(fi, fo, coff_offset);
        } else {
            // "stubify" stub
            info("Adding stub: %zd bytes", sizeof(stub_i386_dos32_djgpp2_stubify));
            fo->write(stub_i386_dos32_djgpp2_stubify, sizeof(stub_i386_dos32_djgpp2_stubify));
        }
    }
}

static bool is_dlm(InputFile *fi, unsigned coff_offset) {
    byte buf[4];
    unsigned off;

    try {
        fi->seek(coff_offset, SEEK_SET);
        fi->readx(buf, 4);
        off = get_le32(buf);
        if (off > coff_offset + 4)
            return false;
        fi->seek(off, SEEK_SET);
        fi->readx(buf, 4);
        if (memcmp(buf, "DLMF", 4) == 0)
            return true;
    } catch (const IOException &) {
    }
    return false;
}

static void handle_allegropak(InputFile *fi, OutputFile *fo) {
    byte b[8];
    int pfsize = 0;

    try {
        fi->seek(-8, SEEK_END);
        fi->readx(b, 8);
        if (memcmp(b, "slh+", 4) != 0)
            return;
        pfsize = get_be32_signed(b + 4);
        if (pfsize <= 8 || pfsize >= fi->st.st_size)
            return;
        fi->seek(-pfsize, SEEK_END);
    } catch (const IOException &) {
        return;
    }
    MemBuffer buf(0x4000);
    while (pfsize > 0) {
        const int len = UPX_MIN(pfsize, (int) buf.getSize());
        fi->readx(buf, len);
        fo->write(buf, len);
        pfsize -= len;
    }
}

int PackDjgpp2::readFileHeader() {
    dos_header_t dos_hdr;

    fi->seek(0, SEEK_SET);
    fi->readx(&dos_hdr, sizeof(dos_hdr));
    if (get_le16(&dos_hdr.e_magic) == 0x5a4d) { // MZ exe signature, stubbed?
        byte magic[8];
        fi->seek(16 * get_le16(&dos_hdr.e_cparhdr), SEEK_SET);
        fi->readx(magic, 8);
        if (memcmp("go32stub", magic, 8) != 0)
            return 0; // not V2 image
    }
    coff_offset = 512 * get_le16(&dos_hdr.e_cp);
    if (get_le16(&dos_hdr.e_cblp) != 0)
        coff_offset += get_le16(&dos_hdr.e_cblp) - 512;
    fi->seek(coff_offset, SEEK_SET);
    if (fi->read(&coff_hdr, sizeof(coff_hdr)) != sizeof(coff_hdr))
        throwCantPack("skipping djgpp symlink");
    if (coff_hdr.f_magic != 0x014c) // I386MAGIC
        return 0;
    if ((coff_hdr.f_flags & 2) == 0) // F_EXEC - COFF executable
        return 0;
    if (coff_hdr.a_magic != 0413) // ZMAGIC - demand load format
        return 0;
    // FIXME: check for Linux etc.

    text = &coff_hdr.sh[0];
    data = &coff_hdr.sh[1];
    bss = &coff_hdr.sh[2];
    return UPX_F_DJGPP2_COFF;
}

// "strip" debug info
void PackDjgpp2::stripDebug() {
    coff_hdr.f_symptr = 0;
    coff_hdr.f_nsyms = 0;
    coff_hdr.f_flags = 0x10f; // 0x100: "32 bit machine: LSB first"
    memset(text->misc, 0, 12);
}

/*************************************************************************
//
**************************************************************************/

tribool PackDjgpp2::canPack() {
    if (!readFileHeader())
        return false;
    if (is_dlm(fi, coff_offset))
        throwCantPack("can't handle DLM");

    if (opt->force == 0)
        if (text->size != coff_hdr.a_tsize || data->size != coff_hdr.a_dsize)
            throwAlreadyPacked();

    // Check for gap in vaddr between text and data, or between data and bss.
    if (text->vaddr + text->size != data->vaddr || data->vaddr + data->size != bss->vaddr) {
        // "Non-standard" layout of text,data,bss: not contiguous in vaddr.
        // But should be OK if no overlap.

        // Check for no overlap of text and data:
        // neither by vaddr, nor by image data
        if (text->vaddr + text->size <= data->vaddr &&
            data->scnptr - text->scnptr <= data->vaddr - text->vaddr) {
            // Examples: Quake1; FreePascal(DOS) install.exe (github-issue45)
            // Hack: enlarge text image data to eliminate the gap.
            text->size = coff_hdr.a_tsize = data->scnptr - text->scnptr;
            // But complain if this causes overlap in vaddr
            if (text->vaddr + text->size > data->vaddr)
                throwAlreadyPacked();
        } else
            throwAlreadyPacked();
    }
    // FIXME: check for Linux etc.
    return true;
}

/*************************************************************************
//
**************************************************************************/

void PackDjgpp2::pack(OutputFile *fo) {
    handleStub(fo);

    // patch coff header #1: "strip" debug info
    stripDebug();

    // read file
    const unsigned size = text->size + data->size;
    const unsigned tpos = text->scnptr;
    const unsigned hdrsize = 20 + 28 + mem_size(sizeof(external_scnhdr_t), coff_hdr.f_nscns);
    const unsigned usize = size + hdrsize;
    if (hdrsize < sizeof(coff_hdr) || hdrsize > tpos)
        throwCantPack("coff header error");

    ibuf.alloc(usize);
    obuf.allocForCompression(usize);

    fi->seek(coff_offset, SEEK_SET);
    fi->readx(ibuf, hdrsize); // orig. coff header
    fi->seek(coff_offset + tpos, SEEK_SET);
    fi->readx(ibuf + hdrsize, size);

    // prepare packheader
    ph.u_len = usize;
    // prepare filter
    Filter ft(ph.level);
    ft.buf_len = usize - data->size;
    ft.addvalue = text->vaddr - hdrsize;
    // compress
    upx_compress_config_t cconf;
    cconf.reset();
    // limit stack size needed for runtime decompression
    cconf.conf_lzma.max_num_probs = 1846 + (768 << 4); // ushort: ~28 KiB stack
    compressWithFilters(&ft, 512, &cconf);

    // patch coff header #2
    const unsigned lsize = getLoaderSize();
    assert(lsize % 4 == 0);
    text->size = lsize;    // new size of .text
    data->size = ph.c_len; // new size of .data

    unsigned stack = 1024 + ph.overlap_overhead + getDecompressorWrkmemSize();
    stack = ALIGN_UP(stack, 16u);
    if (bss->size < stack) // give it a .bss
        bss->size = stack;

    text->scnptr = sizeof(coff_hdr);
    data->scnptr = text->scnptr + text->size;
    data->vaddr = bss->vaddr + ((data->scnptr + data->size) & 0x1ff) - data->size +
                  ph.overlap_overhead - 0x200;
    coff_hdr.f_nscns = 3;

    linker->defineSymbol("original_entry", coff_hdr.a_entry);
    linker->defineSymbol("length_of_bss", ph.overlap_overhead / 4);
    defineDecompressorSymbols();
    // Just need no overlap; non-contiguous (gap length > 0)) is OK
    assert(bss->vaddr >= ((size + 0x1ff) & ~0x1ff) + (text->vaddr & ~0x1ff));
    linker->defineSymbol("stack_for_lzma", bss->vaddr + bss->size);
    linker->defineSymbol("start_of_uncompressed", text->vaddr - hdrsize);
    linker->defineSymbol("start_of_compressed", data->vaddr);
    defineFilterSymbols(&ft);

    // we should not overwrite our decompressor during unpacking
    // the original coff header (which is put just before the
    // beginning of the original .text section)
    assert(text->vaddr > hdrsize + lsize + sizeof(coff_hdr));

    // patch coff header #3
    text->vaddr = sizeof(coff_hdr);
    coff_hdr.a_entry = sizeof(coff_hdr) + getLoaderSection("DJ2MAIN1");
    bss->vaddr += ph.overlap_overhead;
    bss->size -= ph.overlap_overhead;

    // because of a feature (bug?) in stub.asm we need some padding
    memcpy(obuf + data->size, "UPX", 3);
    data->size = ALIGN_UP(data->size, 4u);

    linker->defineSymbol("DJ2MAIN1", coff_hdr.a_entry);
    relocateLoader();

    // prepare loader
    MemBuffer loader(lsize);
    memcpy(loader, getLoader(), lsize);
    patchPackHeader(loader, lsize);

    // write coff header, loader and compressed file
    fo->write(&coff_hdr, sizeof(coff_hdr));
    fo->write(loader, lsize);
    if (opt->debug.dump_stub_loader)
        OutputFile::dump(opt->debug.dump_stub_loader, loader, lsize);
    fo->write(obuf, data->size);
#if 0
    printf("%-13s: coff hdr   : %8d bytes\n", getName(), (int) sizeof(coff_hdr));
    printf("%-13s: loader     : %8d bytes\n", getName(), (int) lsize);
    printf("%-13s: compressed : %8d bytes\n", getName(), (int) data->size);
#endif

    // verify
    verifyOverlappingDecompression();

    // handle overlay
    // FIXME: only Allegro pakfiles are supported
    handle_allegropak(fi, fo);

    // finally check the compression ratio
    if (!checkFinalCompressionRatio(fo))
        throwNotCompressible();
}

/*************************************************************************
//
**************************************************************************/

tribool PackDjgpp2::canUnpack() {
    if (!readFileHeader())
        return false;
    if (is_dlm(fi, coff_offset))
        throwCantUnpack("can't handle DLM");
    fi->seek(coff_offset, SEEK_SET);
    return readPackHeader(4096) ? 1 : -1;
}

/*************************************************************************
//
**************************************************************************/

void PackDjgpp2::unpack(OutputFile *fo) {
    handleStub(fo);

    ibuf.alloc(ph.c_len);
    obuf.allocForDecompression(ph.u_len);

    fi->seek(coff_offset + ph.buf_offset + ph.getPackHeaderSize(), SEEK_SET);
    fi->readx(ibuf, ph.c_len);

    // decompress
    decompress(ibuf, obuf);

    coff_header_t *const chdr = (coff_header_t *) raw_bytes(obuf, sizeof(coff_header_t));
    text = &chdr->sh[0];
    data = &chdr->sh[1];
    bss = &chdr->sh[2];

    const unsigned hdrsize = 20 + 28 + mem_size(sizeof(external_scnhdr_t), chdr->f_nscns);
    if (hdrsize < sizeof(coff_hdr) || hdrsize > text->scnptr || hdrsize > ph.u_len)
        throwCantUnpack("coff header error");

    unsigned addvalue;
    if (ph.version >= 14)
        addvalue = text->vaddr - hdrsize;
    else
        addvalue = text->vaddr & ~0x1ff; // for old versions

    // unfilter
    if (ph.filter) {
        Filter ft(ph.level);
        ft.init(ph.filter, addvalue);
        ft.cto = (byte) ph.filter_cto;
        if (ph.version < 11) {
            byte ctobuf[4];
            fi->readx(ctobuf, 4);
            ft.cto = (byte) (get_le32(ctobuf) >> 24);
        }
        ft.unfilter(obuf, ph.u_len - data->size);
    }

    if (ph.version < 14) {
        // fixup for the aligning bug in strip 2.8+
        text->scnptr &= 0x1ff;
        data->scnptr = text->scnptr + text->size;
        // write decompressed file
        if (fo)
            fo->write(obuf, ph.u_len);
    } else {
        // write the header
        // some padding might be required between the end
        // of the header and the start of the .text section

        const unsigned padding = text->scnptr - hdrsize;
        ibuf.clear(0, padding);

        if (fo) {
            fo->write(obuf, hdrsize);
            fo->write(ibuf, padding);
            fo->write(obuf + hdrsize, ph.u_len - hdrsize);
        }
    }

    if (fo)
        handle_allegropak(fi, fo);
}

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