EN
games/alis / src / Alis / fn / unpack.php · commit 9c722cf
<?phpnamespace App\Alis;// Port of alis/src/unpack.c (MIT, Olivier Huguenot, Vadim Kindl).// PORT: the packed data (a malloc'd temporary in C) is a PHP string + index; the unpacked output is a// destination offset in Alis::$mem. The unpackers work on a local copy of the output and write it back// once (no function call per byte); the C bit-twiddling helpers swap/rotll/byte/word/decode/count/// write_neg are inlined in unpack_new() (kept below for reference/other callers).// ============================================================================// MARK: - Old Silmarils unpacker// ============================================================================/** C: s8 old_read_byte(u8** ptr_packed, u8* ptr_packed_end) — $buf is the packed string. */function old_read_byte(string $buf, int &$ptr_packed, int $ptr_packed_end): int{    return $ptr_packed == $ptr_packed_end ? 0 : s8(ord($buf[$ptr_packed++]));}/** C: void old_write_byte(u8** ptr_unpacked, u8 byte, u8 inc) — $ptr_unpacked is an offset in Alis::$mem. */function old_write_byte(int &$ptr_unpacked, int $byte, int $inc): void{    Alis::$mem[$ptr_unpacked] = chr($byte & 0xff);    $ptr_unpacked += $inc & 0xff;}/** $ptr_packed: packed bytes (PHP string); $ptr_unpacked: output offset in Alis::$mem. */function unpack_old(string $ptr_packed, int $packed_sz, int $ptr_unpacked, int $unpacked_sz, int $modpack): void{    $pp = 0;    $pp_end = $packed_sz;    $pu = 0;    $pu_end = $unpacked_sz;    if (strlen($ptr_packed) < $pp_end + 1) {        $ptr_packed = str_pad($ptr_packed, $pp_end + 1, "\0");    }    // modpack==1: output is contiguous, so each run is one bounded memset/memcpy.    if ($modpack == 1) {        $out = '';        while ($pp < $pp_end && $pu < $pu_end) {            $byte = ord($ptr_packed[$pp++]);            $counter = $byte & 0x7f;            $room = $pu_end - $pu;            $n = $counter < $room ? $counter : $room;   // clamp the run to pu_end            if ($byte & 0x80) {                $rep = ($pp < $pp_end) ? $ptr_packed[$pp++] : "\0";   // read one byte, repeat it                if ($n > 0) {                    $out .= str_repeat($rep, $n);                }            } else {                $avail = $pp_end - $pp;                 // literal bytes; 0-fill past pp_end                $real = $n < $avail ? $n : $avail;                if ($real > 0) {                    $out .= substr($ptr_packed, $pp, $real);                }                if ($real < $n) {                    $out .= str_repeat("\0", $n - $real);                }                $pp += $real;            }            $pu += $n;        }        mem_write($ptr_unpacked, $out);        return;    }    $out = str_pad(substr(Alis::$mem, $ptr_unpacked, $unpacked_sz), $unpacked_sz, "\0");    $cnt = $modpack;    do {        $byte = ($pp < $pp_end) ? ord($ptr_packed[$pp++]) : 0;        $counter = $byte & 0x7f;        if ($byte & 0x80) {            // read one byte, repeat it `counter` times            $rep = ($pp < $pp_end) ? $ptr_packed[$pp++] : "\0";            while ($counter--) {                if ($pu >= $pu_end) {                    if ((--$cnt) < 1) {                        break;                    }                    $pu = $modpack - $cnt;                }                $out[$pu] = $rep;                $pu += $modpack;            }        } else {            // copy `counter` literal bytes            while ($counter--) {                $b = ($pp < $pp_end) ? $ptr_packed[$pp++] : "\0";                if ($pu >= $pu_end) {                    if ((--$cnt) < 1) {                        break;                    }                    $pu = $modpack - $cnt;                }                $out[$pu] = $b;                $pu += $modpack;            }        }    } while ($pp != $pp_end && $cnt > 0);    mem_write($ptr_unpacked, substr($out, 0, $unpacked_sz));}// ============================================================================// MARK: - New Silmarils unpacker// ============================================================================/** All-ones 32-bit mask (u32 values are kept unsigned on 64-bit PHP, as raw bits on 32-bit PHP). */function unpack_mask32(): int{    return PHP_INT_SIZE === 8 ? (1 << 32) - 1 : -1;}/// swap higher and lower words in long valuefunction swap(int $val): int{    return ((($val & 0xffff) << 16) | (($val >> 16) & 0xffff)) & unpack_mask32();}/// ROTate Left Longfunction rotll(int $shift, int $value): int{    if (($shift &= 31) == 0) {        return $value;    }    return (($value << $shift) | (($value >> (32 - $shift)) & ((1 << $shift) - 1))) & unpack_mask32();}function byte(int $value): int{    return s8($value);}function word(int $value): int{    return s16($value);}/** * Unpack ALIS script. * $ptr_packed: raw packed data (PHP string, w/o header, specs, dictionary); $ptr_unpacked: output offset * in Alis::$mem; $dictionary: 8-byte string. Returns the length of unpacked data. */function unpack_new(string $ptr_packed, int $packed_sz, int $ptr_unpacked, int $unpacked_sz, string $dictionary): int{    $M = unpack_mask32();    $HI = ~0xffff & $M;           // 0xffff0000    $p = $ptr_packed;    if (strlen($p) < $packed_sz + 2) {        $p = str_pad($p, $packed_sz + 2, "\0");    }    $dict = str_pad($dictionary, 256, "\0");    $counter = 0;    $ucount = 0;                  // __unpack_counter    $pu = 0;    $uend = $unpacked_sz;    $pp = 0;    $pend = $packed_sz;           // unpack_pend    $over = 0;                    // unpack_over    $d5 = UnpackVars::$d5 & $M;    $d7 = 0;    UnpackVars::$unpack_beg = $ptr_unpacked;    UnpackVars::$unpack_pend = $packed_sz;    // local copy of the output (+ the 1024-byte slack of the C buffers)    $out = substr(Alis::$mem, $ptr_unpacked, ($uend > 0 ? $uend : 0) + 1024);    $outlen = strlen($out);    while ($pu < $uend) {        // loop: decode(1)        $b = 1;        $d5 &= $HI;        $d7 = ($d7 - $b) & 0xff;        if ($d7 & 0x80) {            $d7 = ($d7 + $b) & 0xff;            if ($s = $d7 & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; }            if ($pp < $pend) { $w = (ord($p[$pp]) << 8) | ord($p[$pp + 1]); $pp += 2; } else { $w = 0; $over++; }            $d5 = (($w << 16) | ($d5 & 0xffff)) & $M;            $b = ($b - $d7) & 0xff;            if ($s = $b & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; }            $d7 = (0x10 - $b) & 0xff;        } else {            $d5 = (($d5 << 1) | (($d5 >> 31) & 1)) & $M;        }        if (($d5 & 0xff) != 0) {            $counter = 0;            // ZMB - get number of bytes to write to output: count(2, 3)            do {                $b = 2;                $d5 &= $HI;                $d7 = ($d7 - $b) & 0xff;                if ($d7 & 0x80) {                    $d7 = ($d7 + $b) & 0xff;                    if ($s = $d7 & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; }                    if ($pp < $pend) { $w = (ord($p[$pp]) << 8) | ord($p[$pp + 1]); $pp += 2; } else { $w = 0; $over++; }                    $d5 = (($w << 16) | ($d5 & 0xffff)) & $M;                    $b = ($b - $d7) & 0xff;                    if ($s = $b & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; }                    $d7 = (0x10 - $b) & 0xff;                } else {                    $d5 = (($d5 << 2) | (($d5 >> 30) & 3)) & $M;                }                $counter = ((($counter + (($d5 & 0xffff) ^ 0x8000) - 0x8000) & 0xffff) ^ 0x8000) - 0x8000;            } while (($d5 & 0xffff) == 3);            // QQCH - write d2+1 unpacked bytes (do { } while (--counter != -1) on a s16)            $n = (($counter + 1) & 0xffff) ?: 0x10000;            $counter = -1;            if ($pu + $n > $outlen) {                $out .= str_repeat("\0", $pu + $n - $outlen);                $outlen = strlen($out);            }            for ($k = 0; $k < $n; $k++) {                // decode(8)                $b = 8;                $d5 &= $HI;                $d7 = ($d7 - $b) & 0xff;                if ($d7 & 0x80) {                    $d7 = ($d7 + $b) & 0xff;                    if ($s = $d7 & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; }                    if ($pp < $pend) { $w = (ord($p[$pp]) << 8) | ord($p[$pp + 1]); $pp += 2; } else { $w = 0; $over++; }                    $d5 = (($w << 16) | ($d5 & 0xffff)) & $M;                    $b = ($b - $d7) & 0xff;                    if ($s = $b & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; }                    $d7 = (0x10 - $b) & 0xff;                } else {                    $d5 = (($d5 << 8) | (($d5 >> 24) & 0xff)) & $M;                }                $out[$pu++] = chr($d5 & 0xff);            }            $ucount += $n;            // check unpack end            if ($pu >= $uend) {                break;            }        }        // MMI: decode(3)        $b = 3;        $d5 &= $HI;        $d7 = ($d7 - $b) & 0xff;        if ($d7 & 0x80) {            $d7 = ($d7 + $b) & 0xff;            if ($s = $d7 & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; }            if ($pp < $pend) { $w = (ord($p[$pp]) << 8) | ord($p[$pp + 1]); $pp += 2; } else { $w = 0; $over++; }            $d5 = (($w << 16) | ($d5 & 0xffff)) & $M;            $b = ($b - $d7) & 0xff;            if ($s = $b & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; }            $d7 = (0x10 - $b) & 0xff;        } else {            $d5 = (($d5 << 3) | (($d5 >> 29) & 7)) & $M;        }        // u16 bit = dictionary[byte(d5)] — PORT: a s8 index < 0 (out of bounds in C) reads 0 here        $bit = ord($dict[$d5 & 0xff]);        $d5 = ($d5 & $HI) | ($d5 & 3);        if (($d5 & 0xffff) != 0) {            $counter = $d5 & 3;        } else {            $counter = 0;        }        // decode(bit)        $b = $bit & 0xff;        $d5 &= $HI;        $d7 = ($d7 - $b) & 0xff;        if ($d7 & 0x80) {            $d7 = ($d7 + $b) & 0xff;            if ($s = $d7 & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; }            if ($pp < $pend) { $w = (ord($p[$pp]) << 8) | ord($p[$pp + 1]); $pp += 2; } else { $w = 0; $over++; }            $d5 = (($w << 16) | ($d5 & 0xffff)) & $M;            $b = ($b - $d7) & 0xff;            if ($s = $b & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; }            $d7 = (0x10 - $b) & 0xff;        } elseif ($s = $b & 31) {            $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M;        }        if ($counter == 0) {            // SNS            $save_d5w = $d5 & 0xffff;            $counter = 0;            // CRVL: count(3, 7)            do {                $b = 3;                $d5 &= $HI;                $d7 = ($d7 - $b) & 0xff;                if ($d7 & 0x80) {                    $d7 = ($d7 + $b) & 0xff;                    if ($s = $d7 & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; }                    if ($pp < $pend) { $w = (ord($p[$pp]) << 8) | ord($p[$pp + 1]); $pp += 2; } else { $w = 0; $over++; }                    $d5 = (($w << 16) | ($d5 & 0xffff)) & $M;                    $b = ($b - $d7) & 0xff;                    if ($s = $b & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; }                    $d7 = (0x10 - $b) & 0xff;                } else {                    $d5 = (($d5 << 3) | (($d5 >> 29) & 7)) & $M;                }                $counter = ((($counter + (($d5 & 0xffff) ^ 0x8000) - 0x8000) & 0xffff) ^ 0x8000) - 0x8000;            } while (($d5 & 0xffff) == 7);            // CRVL2            $d5 = ($d5 & $HI) | $save_d5w;            $counter = ((($counter + 4) & 0xffff) ^ 0x8000) - 0x8000;        }        // write_neg(word(d5), &counter): copy from the already unpacked output        $offset = -(((($d5 & 0xffff) ^ 0x8000) - 0x8000));        $n = (($counter + 1) & 0xffff) ?: 0x10000;        $counter = -1;        if ($pu + $n > $outlen) {            $out .= str_repeat("\0", $pu + $n - $outlen);            $outlen = strlen($out);        }        $src = $pu + $offset - 1;        for ($k = 0; $k < $n; $k++, $src++) {            $out[$pu++] = ($src >= 0 && $src < $outlen) ? $out[$src] : "\0";        }        $ucount += $n;    }    UnpackVars::$d5 = $d5;    UnpackVars::$d7 = $d7;    UnpackVars::$unpack_over = $over;    UnpackVars::$__unpack_counter = $ucount;    // write back what was produced (C may overrun the buffer end into its slack)    $max = strlen(Alis::$mem) - $ptr_unpacked;    mem_write($ptr_unpacked, substr($out, 0, $pu < $max ? $pu : $max));    return $ucount;}// ============================================================================// MARK: - Unpacker// ============================================================================// More zero padding than the 0xff byte buffer slack means the packed data is damaged.function unpack_damaged(string $path): int{    if (UnpackVars::$unpack_over <= 0x7f) {        return 0;    }    UnpackVars::$unpack_fatal = "Damaged script file: $path\nTry another copy of this file or check the original medium.";    AlisVars::$alis_fatal = UnpackVars::$unpack_fatal;    Alis::$state = C::eAlisStateStopped;    return 1;}function is_packed(int $packer_kind): int{    return 0; // C: (u8)packer_kind < 0 is always false}/** True when the dictionary ("new") packer is used. */function unpack_is_new(): bool{    return (Alis::$platform->version > 11 && (Alis::$typepack & 0xf0) == 0xa0)        // TODO: a quick fix to make the MadShow re-release work        || (Alis::$platform->version == 11 && (Alis::$typepack & 0xff) == 0xa1);}function unpack_modpack(): int{    $tp = Alis::$typepack & 0xff;    return Alis::$platform->kind == C::EPlatformPC        ? ($tp == 0x80 ? 1 : ($tp == 0xa0 ? 2 : 8))        : ((($tp & 0x40) == 0) ? 1 : 8);}/// Unpacks a script file to buffer ($unpacked_buffer: offset in Alis::$mem)./// Returns the unpacked file size if success, a negative value if error, or zero if the input file is not packedfunction unpack_script(string $packed_file_path, int $unpacked_buffer): int{    $ret = 0;    $damaged = 0;    $pfp = sys_fopen($packed_file_path, 'rb');    if ($pfp) {        // get packed sz        fseek($pfp, 0, SEEK_END);        $packed_size = (int)ftell($pfp);        rewind($pfp);        $magic = fread32($pfp);        $is_main = fread16($pfp) == 0;        $unpacked_size = $magic & 0x00ffffff;        $dict = str_repeat("\0", UnpackVars::$kPackedDictionarySize);        $packed_size -= UnpackVars::$kPackedHeaderSize; // size of magic + is_main        $unpacked_size -= UnpackVars::$kPackedHeaderSize; // TODO: not sure about that        if ($is_main) {            // skip vm specs            fseek($pfp, UnpackVars::$kVMSpecsSize, SEEK_CUR);            $packed_size -= UnpackVars::$kVMSpecsSize;            $unpacked_size -= UnpackVars::$kVMSpecsSize; // TODO: not sure about that        }        if (unpack_is_new()) {            // read dictionary            $dict = str_pad(fread_bytes($pfp, UnpackVars::$kPackedDictionarySize), UnpackVars::$kPackedDictionarySize, "\0");            $packed_size -= UnpackVars::$kPackedDictionarySize;        }        // read packed bytes in alloc'd buffer (+0xff zero bytes)        $packed_buffer = str_pad(fread_bytes($pfp, $packed_size), 0xff + max($packed_size, 0), "\0");        fclose($pfp);        if (unpack_is_new()) {            unpack_new($packed_buffer, $packed_size, $unpacked_buffer, $unpacked_size, $dict);            $damaged = unpack_damaged($packed_file_path);        } else {            unpack_old($packed_buffer, $packed_size, $unpacked_buffer, $unpacked_size, unpack_modpack());        }        $ret = $damaged ? C::EUnpackErrorFormat : s32($unpacked_size);    } else {        // error        $ret = C::EUnpackErrorInput;    }    return $ret;}/** $fp: PHP stream; $unpacked_buffer: offset in Alis::$mem. */function unpack_script_fp($fp, int $unpacked_buffer, int $unpacked_size): int{    $ret = 0;    if ($fp) {        $packed_size = $unpacked_size;        if (unpack_is_new()) {            $dict = str_pad(fread_bytes($fp, UnpackVars::$kPackedDictionarySize), UnpackVars::$kPackedDictionarySize, "\0");            $packed_buffer = str_pad(fread_bytes($fp, $packed_size), 0xff + max($packed_size, 0), "\0");            unpack_new($packed_buffer, $packed_size, $unpacked_buffer, $unpacked_size, $dict);            unpack_damaged('(data file)');        } else {            $packed_buffer = str_pad(fread_bytes($fp, $packed_size), 0xff + max($packed_size, 0), "\0");            unpack_old($packed_buffer, $packed_size, $unpacked_buffer, $unpacked_size, unpack_modpack());        }        $ret = $unpacked_size;    } else {        // error        $ret = C::EUnpackErrorInput;    }    return $ret;}