hbmap: fix iterator truncation when size_t < 32bit

[rofl0r-agsutils.git] / Clib32.c

/* CLIB32 - DJGPP implemention of the CLIB reader.
  (c) 1998-99 Chris Jones, (c) 2012 rofl0r
  
  22/12/02 - Shawn's Linux changes approved and integrated - CJ

  v1.2 (Apr'01)  added support for new multi-file CLIB version 10 files
  v1.1 (Jul'99)  added support for appended-to-exe data files

  Adventure Game Studio source code Copyright 1999-2011 Chris Jones.
  All rights reserved.

  The AGS Editor Source Code is provided under the Artistic License 2.0
  http://www.opensource.org/licenses/artistic-license-2.0.php

  You MAY NOT compile your own builds of the engine without making it EXPLICITLY
  CLEAR that the code has been altered from the Standard Version.
  
  v1.3 rofl0r: code cleaned up for usage in agsutils.
  v1.4 rofl0r: added writer and reader interfaces, as well as the entire writer code.
  
*/

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include "ByteArray.h"
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdint.h>
#include <stddef.h>
#include <limits.h>
#include "Clib32.h"
#include "endianness.h"

#ifndef _WIN32
#define O_BINARY 0
#define PSEP_STR "/"
#else
#define PSEP_STR "\\"
#endif
#define PSEP PSEP_STR[0]

#define RAND_SEED_SALT 9338638

static char *clibendfilesig = "CLIB\x1\x2\x3\x4SIGE";
static char *clibpasswencstring = "My\x1\xde\x4Jibzle";
static int _last_rand;

static void init_pseudo_rand_gen(int seed) {
        _last_rand = seed;
}

static int get_pseudo_rand() {
        return( ((_last_rand = _last_rand * 214013L
        + 2531011L) >> 16) & 0x7fff );
}

static void clib_encrypt_text(unsigned char *clear, unsigned char *encbuf) {
        unsigned adx = 0;
        while(1) {
                *encbuf = *clear + clibpasswencstring[adx];
                if(!*clear) break;
                adx++; encbuf++; clear++;
                if (adx > 10) adx = 0;
        }
}

static void clib_decrypt_text(char *toenc) {
        unsigned adx = 0;
        while (1) {
                *toenc -= clibpasswencstring[adx];
                if (!*toenc) break;
                adx++; toenc++;
                if (adx > 10) adx = 0;
        }
}

static void fgetnulltermstring(char *sss, struct ByteArray *ddd, int bufsize) {
        int b = -1;
        off_t l = ByteArray_get_length(ddd);
        do {
                if (b < bufsize - 1) b++;
                if(ByteArray_get_position(ddd) >= l)
                        return;
                sss[b] = ByteArray_readByte(ddd);
        } while (sss[b] != 0);
}

long last_opened_size;

static int fread_data_enc_byte(struct ByteArray *ba) {
        return ByteArray_readUnsignedByte(ba) - get_pseudo_rand();
}

static uint32_t fread_data_enc_int(struct ByteArray *ba) {
        union {
                uint32_t i;
                unsigned char c[4];
        } res;
        res.i = ByteArray_readUnsignedInt(ba);
        size_t i = 0;
        for(; i < 4; i++)
                res.c[i] -= get_pseudo_rand();
        return res.i;
}

static void fread_data_intarray_enc(struct ByteArray *ba, unsigned* dest, size_t count) {
        size_t i = 0;
        for(; i < count; i++)
                dest[i] = fread_data_enc_int(ba);
}

static void fread_data_intarray(struct ByteArray *ba, unsigned* dest, size_t count) {
        size_t i = 0;
        for(; i < count; i++)
                dest[i] = ByteArray_readInt(ba);
}

#if 0
static void fread_data_enc(void *data, size_t dataSize, size_t dataCount, struct ByteArray *ooo) {
        ByteArray_readMultiByte(ooo, (char*)data, dataSize * dataCount);
        unsigned char *dataChar = (unsigned char*)data;
        size_t i = 0;
        for (; i < dataSize * dataCount; i++)
                dataChar[i] -= get_pseudo_rand();
}
#endif

static void fgetstring_enc(char *sss, struct ByteArray *ooo, int maxLength) {
        int i = 0;
        while ((i == 0) || (sss[i - 1] != 0)) {
                sss[i] = ByteArray_readByte(ooo) - get_pseudo_rand();
                if (i < maxLength - 1) i++;
        }
}

static int read_v30_clib(struct MultiFileLibNew * mfl, struct ByteArray * wout) {
        size_t aa;
        /* int reservedFlags = */ ByteArray_readInt(wout);

        mfl->num_data_files = ByteArray_readInt(wout);
        assert(mfl->num_data_files <= MAXMULTIFILES);
        for (aa = 0; aa < mfl->num_data_files; aa++)
                fgetnulltermstring(mfl->data_filenames[aa], wout, 50);
        mfl->num_files = ByteArray_readInt(wout);

        if (mfl->num_files > MAX_FILES)
                return -1;

        for (aa = 0; aa < mfl->num_files; aa++) {
                fgetnulltermstring(mfl->filenames[aa], wout, 100);
                mfl->file_datafile[aa] = ByteArray_readUnsignedByte(wout); /* "LibUid" */
                unsigned long long tmp;
                tmp = ByteArray_readUnsignedLongLong(wout);
                mfl->offset[aa] = tmp;
                tmp = ByteArray_readUnsignedLongLong(wout);
                mfl->length[aa] = tmp;
        }

//      for(aa = 0; aa < mfl->num_files; aa++)
//              mfl->file_datafile[aa] = fread_data_enc_byte(wout);
        return 0;
}

static int getw_enc(struct ByteArray *ooo) {
        return fread_data_enc_int(ooo);
}

static int read_new_new_enc_format_clib(struct MultiFileLibNew * mfl, struct ByteArray * wout) {
        size_t aa;
        int randSeed = ByteArray_readInt(wout);
        init_pseudo_rand_gen(randSeed + RAND_SEED_SALT);
        mfl->num_data_files = getw_enc(wout);
        for (aa = 0; aa < mfl->num_data_files; aa++)
                fgetstring_enc(mfl->data_filenames[aa], wout, 50);
        mfl->num_files = getw_enc(wout);

        if (mfl->num_files > MAX_FILES)
                return -1;

        for (aa = 0; aa < mfl->num_files; aa++)
                fgetstring_enc(mfl->filenames[aa], wout, 100);
        for (aa = 0; aa < mfl->num_files; aa++)
                mfl->offset[aa] = fread_data_enc_int(wout);
        for (aa = 0; aa < mfl->num_files; aa++)
                mfl->length[aa] = fread_data_enc_int(wout);
        for (aa = 0; aa < mfl->num_files; aa++)
                mfl->file_datafile[aa] = fread_data_enc_byte(wout);
        return 0;
}

static int read_new_new_format_clib(struct MultiFileLibNew* mfl, struct ByteArray * wout) {
        size_t aa;
        mfl->num_data_files = ByteArray_readInt(wout);
        for (aa = 0; aa < mfl->num_data_files; aa++)
                fgetnulltermstring(mfl->data_filenames[aa], wout, 50);
        mfl->num_files = ByteArray_readInt(wout);

        if (mfl->num_files > MAX_FILES) return -1;

        for (aa = 0; aa < mfl->num_files; aa++) {
                short nameLength = ByteArray_readShort(wout);
                nameLength /= 5;
                ByteArray_readMultiByte(wout, mfl->filenames[aa], nameLength);
                clib_decrypt_text(mfl->filenames[aa]);
        }
        for (aa = 0; aa < mfl->num_files; aa++)
                mfl->offset[aa] = ByteArray_readInt(wout);
        for (aa = 0; aa < mfl->num_files; aa++)
                mfl->length[aa] = ByteArray_readInt(wout);
        ByteArray_readMultiByte(wout, mfl->file_datafile, mfl->num_files);
        return 0;
}

static int read_new_format_clib(struct MultiFileLib * mfl, struct ByteArray * wout, int libver) {
        mfl->num_data_files = ByteArray_readInt(wout);
        ByteArray_readMultiByte(wout, (char*) mfl->data_filenames, 20U * mfl->num_data_files);
        mfl->num_files = ByteArray_readInt(wout);

        if (mfl->num_files > MAX_FILES) return -1;
        
        ByteArray_readMultiByte(wout, (char*) mfl->filenames, 25U * mfl->num_files);
        
        fread_data_intarray(wout, mfl->offset, mfl->num_files);
        fread_data_intarray(wout, mfl->length, mfl->num_files);
        ByteArray_readMultiByte(wout, mfl->file_datafile, mfl->num_files);

        if (libver >= 11) {
                size_t aa;
                for (aa = 0; aa < mfl->num_files; aa++)
                        clib_decrypt_text(mfl->filenames[aa]);
        }
        return 0;
}

void AgsFile_close(struct AgsFile *f) {
        unsigned i;
        for (i=0; i < AgsFile_getDataFileCount(f); i++)
                ByteArray_close_file(&f->f[i]);
}

int AgsFile_getVersion(struct AgsFile *f) {
        return f->libversion;
}

void AgsFile_setVersion(struct AgsFile *f, int version) {
        f->libversion = version;
}

void AgsFile_setSourceDir(struct AgsFile *f, char* sourcedir) {
        f->dir = sourcedir;
}

void AgsFile_setFileCount(struct AgsFile *f, size_t count) {
        f->mflib.num_files = count;
}

static off_t filelength(int fd) {
        struct stat st;
        fstat(fd, &st);
        return st.st_size;
}

int AgsFile_setFile(struct AgsFile *f, size_t index, char* fn) {
        strncpy(f->mflib.filenames[index], fn, 100);
        char fnbuf[512];
        snprintf(fnbuf, sizeof(fnbuf), "%s%c%s", f->dir, PSEP, f->mflib.filenames[index]);
        int fd = open(fnbuf, O_RDONLY|O_BINARY);
        if(fd == -1) return 0;
        off_t fl = filelength(fd);
        close(fd);
        f->mflib.length[index] = fl;
        return 1;
}

int AgsFile_setDataFile(struct AgsFile *f, size_t index, char* fn) {
        size_t l = strlen(fn);
        if(l >= 20) return 0;
        strncpy(f->mflib.data_filenames[index], fn, 20);
        return 1;
}

void AgsFile_setDataFileCount(struct AgsFile *f, size_t count) {
        f->mflib.num_data_files = count;
}

static void write_ull(int fd, unsigned long long val) {
        unsigned long long le = end_htole64(val);
        write(fd, &le, sizeof(le));
}

static int get_int_le(int val) {
        return end_htole32(val);
}

static void write_int(int fd, int val) {
        int le = get_int_le(val);
        write(fd, &le, sizeof(le));
}

static short get_short_le(short val) {
        return end_htole16(val);
}

static void write_short(int fd, short val) {
        short le = get_short_le(val);
        write(fd, &le, sizeof(le));
}

static void write_int_array(int fd, int* arr, size_t len) {
        size_t i = 0;
        for(; i < len; i++)
                write_int(fd, arr[i]);
}

/* if *bytes == -1L, read entire file, and store the total amount read there */
static int copy_into_file(int fd, const char *dir, const char *fn, size_t *bytes) {
        char fnbuf[512];
        snprintf(fnbuf, sizeof(fnbuf), "%s%c%s", dir, PSEP, fn);
        int f = open(fnbuf, O_RDONLY|O_BINARY);
        if(f == -1) return 0;
        size_t filesize = *bytes;
        char readbuf[4096];
        int ret = 1;
        if(filesize == -1L) {
                *bytes = 0;
                while(1) {
                        ssize_t r = read(f, readbuf, sizeof readbuf);
                        if(r < 0) { ret=0; goto end; }
                        if(r == 0) break;
                        *bytes += r;
                        if(write(fd, readbuf, r) != r) { ret=0; goto end; }
                }
        } else do {
                size_t togo = filesize > sizeof(readbuf) ? sizeof(readbuf) : filesize;
                if((size_t) read(f, readbuf, togo) != togo) { ret = 0; goto end; }
                filesize -= togo;
                ssize_t wret;
                size_t nwritten = 0;
                while(togo) {
                        wret = write(fd, readbuf + nwritten, togo);
                        if(wret <= 0) { ret = 0; goto end; }
                        nwritten += wret;
                        togo -= wret;
                }
        } while(filesize);
        end:
        close(f);
        return ret;
}

#define WH_EWRITE(X,Y,Z) do {if(Z != write(X, Y, Z)) return 0;} while(0)
static size_t write_header(struct AgsFile *f, int fd) {
        int myversion = f->libversion >= 30 ? 30 : 20; //f->libversion;
        unsigned char version = myversion;
        WH_EWRITE(fd, "CLIB\x1a", 5);
        WH_EWRITE(fd, &version, 1);
        version = 0;
        if(myversion >= 10) WH_EWRITE(fd, &version, 1);
        size_t written = 7;
        size_t i,l;
        if(myversion == 30) {
                write_int(fd, 0); /*reservedFlags*/
                written += 4;
        }
        write_int(fd, f->mflib.num_data_files);
        written += sizeof(int);
        for(i = 0; i < f->mflib.num_data_files; i++) {
                l = strlen(f->mflib.data_filenames[i]) + 1;
                written += l;
                if(l != (size_t) write(fd, f->mflib.data_filenames[i], l))
                        return 0;
        }

        write_int(fd, f->mflib.num_files);
        written += sizeof(int);

        if(myversion == 30) {
                for(i = 0; i < f->mflib.num_files; i++) {
                        l = strlen(f->mflib.filenames[i]) + 1;
                        written += l;
                        if(l != (size_t) write(fd, f->mflib.filenames[i], l))
                                return 0;
                        /* write another 0 byte as libuid */
                        WH_EWRITE(fd, &version, 1);
                        ++written;

                        write_ull(fd, f->mflib.offset[i]);
                        written += 8;

                        write_ull(fd, f->mflib.length[i]);
                        written += 8;
                }
                return written;
        }

        unsigned char encbuf[100];
        for(i = 0; i < f->mflib.num_files; i++) {
                l = strlen(f->mflib.filenames[i]) + 1;
                write_short(fd, l * 5);
                clib_encrypt_text((unsigned char*)f->mflib.filenames[i], encbuf);
                if(l != (size_t) write(fd, encbuf, l)) return 0;
                written += sizeof(short) + l;
        }
        l = f->mflib.num_files;
        for(i = 0; i < l; ++i)
                write_int(fd, f->mflib.offset[i]);
        written += sizeof(int) * l;

        for(i = 0; i < l; ++i)
                write_int(fd, f->mflib.length[i]);
        written += sizeof(int) * l;

        if(l != (size_t) write(fd, f->mflib.file_datafile, l))
                return 0;
        written += l;
        return written;
}

static void write_footer(int fd, unsigned offset, int v30) {
        write_int(fd, offset);
        if(v30) write_int(fd, 0);
        write(fd, clibendfilesig, 12);
}

void AgsFile_setExeStub(struct AgsFile *f, const char *fn) {
        f->exestub_fn = fn;
}

int AgsFile_write(struct AgsFile *f) {
        int fd = open(f->fn, O_CREAT | O_WRONLY | O_TRUNC | O_BINARY, 0660);
        if(fd == -1) return 0;
        size_t i;
        unsigned long long off;
        if(!(off = write_header(f, fd))) return 0;
        for(i = 0; i < f->mflib.num_files; i++) {
                f->mflib.offset[i] = off;
                off += f->mflib.length[i];
        }
        lseek(fd, 0, SEEK_SET);
        unsigned header_offset = 0; /* we can safely assume the exe stub fits into 4 GB */
        if(f->exestub_fn) {
                size_t stubsize = -1L;
                if(!copy_into_file(fd, f->dir, f->exestub_fn, &stubsize))
                        return 0;
                header_offset = stubsize;
        }
        write_header(f, fd);
        for(i = 0; i < f->mflib.num_files; i++) {
                size_t fs = f->mflib.length[i];
                if(!copy_into_file(fd, f->dir, f->mflib.filenames[i], &fs))
                        return 0;
        }
        write_footer(fd, header_offset, f->libversion >= 30);
        close(fd);
        return 1;
}

static int prep_multifiles(struct AgsFile *f) {
        unsigned aa;
        struct ByteArray *ba;
        /* open each datafile as a byte array */
        assert(MAXMULTIFILES >= f->mflib.num_data_files);
        for (aa = 1; aa < f->mflib.num_data_files; aa++) {
                char fntmp[512];
                snprintf(fntmp, sizeof fntmp, "%s%s%s",
                        f->dir ? f->dir : "",
                        f->dir ? PSEP_STR : "",
                        f->mflib.data_filenames[aa]);
                ba = &f->f[aa];
                ByteArray_ctor(ba);
                if(!ByteArray_open_file(ba, fntmp)) {
                        fprintf(stderr, "error opening mfl datafile %s\n", fntmp);
                        return -1;
                }
                ByteArray_set_endian(ba, BAE_LITTLE); // all ints etc are saved in little endian.
        }
        return 0;
}

static int csetlib(struct AgsFile* f, char *filename)  {
        char clbuff[20];
        if (!filename)
                return -11;
        
        int passwmodifier = 0;
        size_t aa;
        size_t cc, l;
        
        struct ByteArray *ba = &f->f[0];
        ByteArray_ctor(ba);
        if(!ByteArray_open_file(ba, filename)) return -1;
        ByteArray_set_endian(ba, BAE_LITTLE); // all ints etc are saved in little endian.
        off_t ba_len = ByteArray_get_length(ba);
        ByteArray_readMultiByte(ba, clbuff, 5);

        uint32_t absoffs = 0; /* we read 4 bytes- so our datatype 
        must be 4 bytes as well, since we use a pointer to it */

        f->pack_off = 0;
        if (strncmp(clbuff, "CLIB", 4) != 0) {
                /* CLIB signature not found at the beginning of file
                   so it's probably an exe and we need to lookup the tail
                   signature. */
                ByteArray_set_position(ba,  ba_len - 12);
                ByteArray_readMultiByte(ba, clbuff, 12);

                if (strncmp(clbuff, clibendfilesig, 12) != 0)
                        return -2;
                // it's an appended-to-end-of-exe thing.
                // there's a new format using a 64bit offset, we need to try
                // that first.

                uint64_t off64;
                ByteArray_set_position(ba,  ba_len - 20);
                off64 = ByteArray_readUnsignedLongLong(ba);
                if(off64 < ba_len &&
                   ByteArray_set_position(ba, off64) &&
                   ByteArray_readMultiByte(ba, clbuff, 5) &&
                   !strncmp(clbuff, "CLIB", 4)) {
                        if(off64 > 0xffffffff) {
                                fprintf(stderr, "error: gamepacks > 4GB not supported at this time\n");
                                return -21;
                        }
                        absoffs = off64;
                } else {
                        ByteArray_set_position(ba,  ba_len - 16);
                        absoffs = ByteArray_readUnsignedInt(ba);
                }

                ByteArray_set_position(ba, absoffs);
                ByteArray_readMultiByte(ba, clbuff, 5);
                if(strncmp(clbuff, "CLIB", 4)) {
                        fprintf(stderr, "error: ags clib header signature not found\n");
                        return -22;
                }

                f->pack_off = absoffs;
        }

        f->libversion = ByteArray_readUnsignedByte(ba);
        switch (f->libversion) {
                /* enum MFLVersion (kMFLVersion_MultiV21 ...)  in newer AGS */
                case 6: case 10: case 11: case 15: case 20: case 21: case 30:
                        break;
                default:
                        // unsupported version
                        return -3;
        }

        // remove slashes so that the lib name fits in the buffer
        while (filename[0] == '\\' || filename[0] == '/') filename++;

        if (f->libversion >= 10) {
                if (ByteArray_readUnsignedByte(ba) != 0)
                        return -4;  // not first datafile in chain

                if (f->libversion >= 30) {
                        if (read_v30_clib(&f->mflib, ba)) return -5;
                } else if (f->libversion >= 21) {
                        if (read_new_new_enc_format_clib(&f->mflib, ba))
                        return -5;
                } else if (f->libversion == 20) {
                        if (read_new_new_format_clib(&f->mflib, ba))
                        return -5;
                } else  {
                        struct MultiFileLib mflibOld_b, *mflibOld = &mflibOld_b;

                        if (read_new_format_clib(mflibOld, ba, f->libversion))
                                return -5;
                        // convert to newer format
                        f->mflib.num_files = mflibOld->num_files;
                        f->mflib.num_data_files = mflibOld->num_data_files;
                        for(aa = 0; aa < f->mflib.num_files; ++aa)
                                f->mflib.offset[aa] = mflibOld->offset[aa];
                        for(aa = 0; aa < f->mflib.num_files; ++aa)
                                f->mflib.length[aa] = mflibOld->length[aa];
                        memcpy(f->mflib.file_datafile, mflibOld->file_datafile, sizeof(char) * f->mflib.num_files);
                        assert(MAXMULTIFILES >= f->mflib.num_data_files);
                        for (aa = 0; aa < f->mflib.num_data_files; aa++)
                                strcpy(f->mflib.data_filenames[aa], mflibOld->data_filenames[aa]);
                        for (aa = 0; aa < f->mflib.num_files; aa++)
                                strcpy(f->mflib.filenames[aa], mflibOld->filenames[aa]);
                }

                strcpy(f->mflib.data_filenames[0], filename);
                for (aa = 0; aa < f->mflib.num_files; aa++) {
                        // correct offsets for EXE file
                        if (f->mflib.file_datafile[aa] == 0)
                                f->mflib.offset[aa] += absoffs;
                }
                return prep_multifiles(f);
        }

        passwmodifier = ByteArray_readUnsignedByte(ba);
        ByteArray_readUnsignedByte(ba); // unused byte
        f->mflib.num_data_files = 1;
        strcpy(f->mflib.data_filenames[0], filename);

        short tempshort = ByteArray_readShort(ba);
        f->mflib.num_files = tempshort;

        if (f->mflib.num_files > MAX_FILES) return -4;

        ByteArray_readMultiByte(ba, clbuff, 13);  // skip password dooberry
        for (aa = 0; aa < f->mflib.num_files; aa++) {
                ByteArray_readMultiByte(ba, f->mflib.filenames[aa], 13);
                l = strlen(f->mflib.filenames[aa]);
                for (cc = 0; cc < l; cc++)
                        f->mflib.filenames[aa][cc] -= passwmodifier;
        }
        for(cc = 0; cc < f->mflib.num_files; cc++)
                f->mflib.length[cc] = ByteArray_readUnsignedInt(ba);
        
        ByteArray_set_position_rel(ba, 2 * f->mflib.num_files); // skip flags & ratio
        
        f->mflib.offset[0] = ByteArray_get_position(ba);

        for (aa = 1; aa < f->mflib.num_files; aa++) {
                f->mflib.offset[aa] = f->mflib.offset[aa - 1] + f->mflib.length[aa - 1];
                f->mflib.file_datafile[aa] = 0;
        }
        f->mflib.file_datafile[0] = 0;

        return prep_multifiles(f);
}

static int checkIndex(struct AgsFile *f, size_t index) {
        if (index >= AgsFile_getFileCount(f)) return 0;
        return 1;
}

static int checkDataIndex(struct AgsFile *f, size_t index) {
        if (index >= AgsFile_getDataFileCount(f)) return 0;
        return 1;
}

size_t AgsFile_getFileCount(struct AgsFile *f) {
        return f->mflib.num_files;
}

size_t AgsFile_getDataFileCount(struct AgsFile *f) {
        return f->mflib.num_data_files;
}

int AgsFile_getFileNumber(struct AgsFile *f, size_t index) {
        if (!checkIndex(f, index)) return -1;
        return f->mflib.file_datafile[index];
}

void AgsFile_setFileNumber(struct AgsFile *f, size_t index, int number) {
        *(unsigned char*)(&f->mflib.file_datafile[index]) = number;
}

char *AgsFile_getFileName(struct AgsFile *f, size_t index) {
        if (!checkIndex(f, index)) return 0;
        return f->mflib.filenames[index];
}

char *AgsFile_getDataFileName(struct AgsFile *f, size_t index) {
        if (!checkDataIndex(f, index)) return 0;
        return f->mflib.data_filenames[index];
}

size_t AgsFile_getFileSize(struct AgsFile *f, size_t index) {
        if (!checkIndex(f, index)) return 0;
        return f->mflib.length[index];
}

size_t AgsFile_getOffset(struct AgsFile *f, size_t index) {
        if (!checkIndex(f, index)) return 0;
        return f->mflib.offset[index];
}

static int AgsFile_seek(struct AgsFile *f, int multifileno, off_t pos) {
        return ByteArray_set_position(&f->f[multifileno], pos);
}

static ssize_t AgsFile_read(struct AgsFile *f, int multifileno, void* buf, size_t count) {
        return ByteArray_readMultiByte(&f->f[multifileno], buf, count);
}

int AgsFile_extract(struct AgsFile* f, int multifileno, off_t start, size_t len, const char* outfn) {
        FILE *fo = fopen(outfn, "wb");
        if(fo == 0) return 0;
        char buf[4096];
        size_t written = 0, l = len;
        off_t save_pos = ByteArray_get_position(&f->f[multifileno]);
        AgsFile_seek(f, multifileno, start);
        while(written < l) {
                size_t togo = l - written;
                if(togo > sizeof(buf)) togo = sizeof(buf);
                if(togo == 0) break;
                ssize_t ret = AgsFile_read(f, multifileno, buf, togo);
                if(ret <= 0) break;
                ret = fwrite(buf, 1, togo, fo);
                if(ret != togo) {
                        fprintf(stderr, "short write\n");
                        break;
                }
                written += togo;
        }
        fclose(fo);
        AgsFile_seek(f, multifileno, save_pos);
        return written == l;
}

int AgsFile_dump(struct AgsFile* f, size_t index, const char* outfn) {
        if (!checkIndex(f, index)) return 0;
        return AgsFile_extract(f, AgsFile_getFileNumber(f, index), AgsFile_getOffset(f, index), AgsFile_getFileSize(f, index), outfn);
}

void AgsFile_init(struct AgsFile *buf, char* filename) {
        memset(buf, 0, sizeof *buf);
        buf->fn = filename;
}

int AgsFile_open(struct AgsFile *buf) {
        int ret = csetlib(buf, buf->fn);
        
        return ret == 0;
}