l_qfiles.c

Go to the documentation of this file.

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it 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.

Quake III Arena source code 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 Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/

#if defined(WIN32)|defined(_WIN32)
#include <windows.h>
#include <sys/types.h>
#include <sys/stat.h>
#else
#include <glob.h>
#include <sys/stat.h>
#include <unistd.h>
#endif

#include "qbsp.h"

//file extensions with their type
typedef struct qfile_exttype_s
{
    char *extension;
    int type;
} qfile_exttyp_t;

qfile_exttyp_t quakefiletypes[] =
{
    {QFILEEXT_UNKNOWN, QFILETYPE_UNKNOWN},
    {QFILEEXT_PAK, QFILETYPE_PAK},
    {QFILEEXT_PK3, QFILETYPE_PK3},
    {QFILEEXT_SIN, QFILETYPE_PAK},
    {QFILEEXT_BSP, QFILETYPE_BSP},
    {QFILEEXT_MAP, QFILETYPE_MAP},
    {QFILEEXT_MDL, QFILETYPE_MDL},
    {QFILEEXT_MD2, QFILETYPE_MD2},
    {QFILEEXT_MD3, QFILETYPE_MD3},
    {QFILEEXT_WAL, QFILETYPE_WAL},
    {QFILEEXT_WAV, QFILETYPE_WAV},
    {QFILEEXT_AAS, QFILETYPE_AAS},
    {NULL, 0}
};

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int QuakeFileExtensionType(char *extension)
{
    int i;

    for (i = 0; quakefiletypes[i].extension; i++)
    {
        if (!stricmp(extension, quakefiletypes[i].extension))
        {
            return quakefiletypes[i].type;
        } //end if
    } //end for
    return QFILETYPE_UNKNOWN;
} //end of the function QuakeFileExtensionType
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
char *QuakeFileTypeExtension(int type)
{
    int i;

    for (i = 0; quakefiletypes[i].extension; i++)
    {
        if (quakefiletypes[i].type == type)
        {
            return quakefiletypes[i].extension;
        } //end if
    } //end for
    return QFILEEXT_UNKNOWN;
} //end of the function QuakeFileExtension
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int QuakeFileType(char *filename)
{
    char ext[_MAX_PATH] = ".";

    ExtractFileExtension(filename, ext+1);
    return QuakeFileExtensionType(ext);
} //end of the function QuakeFileTypeFromFileName
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
char *StringContains(char *str1, char *str2, int casesensitive)
{
    int len, i, j;

    len = strlen(str1) - strlen(str2);
    for (i = 0; i <= len; i++, str1++)
    {
        for (j = 0; str2[j]; j++)
        {
            if (casesensitive)
            {
                if (str1[j] != str2[j]) break;
            } //end if
            else
            {
                if (toupper(str1[j]) != toupper(str2[j])) break;
            } //end else
        } //end for
        if (!str2[j]) return str1;
    } //end for
    return NULL;
} //end of the function StringContains
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int FileFilter(char *filter, char *filename, int casesensitive)
{
    char buf[1024];
    char *ptr;
    int i, found;

    while(*filter)
    {
        if (*filter == '*')
        {
            filter++;
            for (i = 0; *filter; i++)
            {
                if (*filter == '*' || *filter == '?') break;
                buf[i] = *filter;
                filter++;
            } //end for
            buf[i] = '\0';
            if (strlen(buf))
            {
                ptr = StringContains(filename, buf, casesensitive);
                if (!ptr) return false;
                filename = ptr + strlen(buf);
            } //end if
        } //end if
        else if (*filter == '?')
        {
            filter++;
            filename++;
        } //end else if
        else if (*filter == '[' && *(filter+1) == '[')
        {
            filter++;
        } //end if
        else if (*filter == '[')
        {
            filter++;
            found = false;
            while(*filter && !found)
            {
                if (*filter == ']' && *(filter+1) != ']') break;
                if (*(filter+1) == '-' && *(filter+2) && (*(filter+2) != ']' || *(filter+3) == ']'))
                {
                    if (casesensitive)
                    {
                        if (*filename >= *filter && *filename <= *(filter+2)) found = true;
                    } //end if
                    else
                    {
                        if (toupper(*filename) >= toupper(*filter) &&
                            toupper(*filename) <= toupper(*(filter+2))) found = true;
                    } //end else
                    filter += 3;
                } //end if
                else
                {
                    if (casesensitive)
                    {
                        if (*filter == *filename) found = true;
                    } //end if
                    else
                    {
                        if (toupper(*filter) == toupper(*filename)) found = true;
                    } //end else
                    filter++;
                } //end else
            } //end while
            if (!found) return false;
            while(*filter)
            {
                if (*filter == ']' && *(filter+1) != ']') break;
                filter++;
            } //end while
            filter++;
            filename++;
        } //end else if
        else
        {
            if (casesensitive)
            {
                if (*filter != *filename) return false;
            } //end if
            else
            {
                if (toupper(*filter) != toupper(*filename)) return false;
            } //end else
            filter++;
            filename++;
        } //end else
    } //end while
    return true;
} //end of the function FileFilter
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
quakefile_t *FindQuakeFilesInZip(char *zipfile, char *filter)
{
    unzFile         uf;
    int             err;
    unz_global_info gi;
    char            filename_inzip[MAX_PATH];
    unz_file_info   file_info;
    int             i;
    quakefile_t     *qfiles, *lastqf, *qf;

    uf = unzOpen(zipfile);
    err = unzGetGlobalInfo(uf, &gi);

    if (err != UNZ_OK) return NULL;

    unzGoToFirstFile(uf);

    qfiles = NULL;
    lastqf = NULL;
    for (i = 0; i < gi.number_entry; i++)
    {
        err = unzGetCurrentFileInfo(uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL,0,NULL,0);
        if (err != UNZ_OK) break;

        ConvertPath(filename_inzip);
        if (FileFilter(filter, filename_inzip, false))
        {
            qf = malloc(sizeof(quakefile_t));
            if (!qf) Error("out of memory");
            memset(qf, 0, sizeof(quakefile_t));
            strcpy(qf->pakfile, zipfile);
            strcpy(qf->filename, zipfile);
            strcpy(qf->origname, filename_inzip);
            qf->zipfile = true;
            //memcpy( &buildBuffer[i].zipfileinfo, (unz_s*)uf, sizeof(unz_s));
            memcpy(&qf->zipinfo, (unz_s*)uf, sizeof(unz_s));
            qf->offset = 0;
            qf->length = file_info.uncompressed_size;
            qf->type = QuakeFileType(filename_inzip);
            //add the file ot the list
            qf->next = NULL;
            if (lastqf) lastqf->next = qf;
            else qfiles = qf;
            lastqf = qf;
        } //end if
        unzGoToNextFile(uf);
    } //end for

    unzClose(uf);

    return qfiles;
} //end of the function FindQuakeFilesInZip
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
quakefile_t *FindQuakeFilesInPak(char *pakfile, char *filter)
{
    FILE *fp;
    dpackheader_t packheader;
    dsinpackfile_t *packfiles;
    dpackfile_t *idpackfiles;
    quakefile_t *qfiles, *lastqf, *qf;
    int numpackdirs, i;

    qfiles = NULL;
    lastqf = NULL;
    //open the pak file
    fp = fopen(pakfile, "rb");
    if (!fp)
    {
        Warning("can't open pak file %s", pakfile);
        return NULL;
    } //end if
    //read pak header, check for valid pak id and seek to the dir entries
    if ((fread(&packheader, 1, sizeof(dpackheader_t), fp) != sizeof(dpackheader_t))
        || (packheader.ident != IDPAKHEADER && packheader.ident != SINPAKHEADER)
        ||  (fseek(fp, LittleLong(packheader.dirofs), SEEK_SET))
        )
    {
        fclose(fp);
        Warning("invalid pak file %s", pakfile);
        return NULL;
    } //end if
    //if it is a pak file from id software
    if (packheader.ident == IDPAKHEADER)
    {
        //number of dir entries in the pak file
        numpackdirs = LittleLong(packheader.dirlen) / sizeof(dpackfile_t);
        idpackfiles = (dpackfile_t *) malloc(numpackdirs * sizeof(dpackfile_t));
        if (!idpackfiles) Error("out of memory");
        //read the dir entry
        if (fread(idpackfiles, sizeof(dpackfile_t), numpackdirs, fp) != numpackdirs)
        {
            fclose(fp);
            free(idpackfiles);
            Warning("can't read the Quake pak file dir entries from %s", pakfile);
            return NULL;
        } //end if
        fclose(fp);
        //convert to sin pack files
        packfiles = (dsinpackfile_t *) malloc(numpackdirs * sizeof(dsinpackfile_t));
        if (!packfiles) Error("out of memory");
        for (i = 0; i < numpackdirs; i++)
        {
            strcpy(packfiles[i].name, idpackfiles[i].name);
            packfiles[i].filepos = LittleLong(idpackfiles[i].filepos);
            packfiles[i].filelen = LittleLong(idpackfiles[i].filelen);
        } //end for
        free(idpackfiles);
    } //end if
    else //its a Sin pack file
    {
        //number of dir entries in the pak file
        numpackdirs = LittleLong(packheader.dirlen) / sizeof(dsinpackfile_t);
        packfiles = (dsinpackfile_t *) malloc(numpackdirs * sizeof(dsinpackfile_t));
        if (!packfiles) Error("out of memory");
        //read the dir entry
        if (fread(packfiles, sizeof(dsinpackfile_t), numpackdirs, fp) != numpackdirs)
        {
            fclose(fp);
            free(packfiles);
            Warning("can't read the Sin pak file dir entries from %s", pakfile);
            return NULL;
        } //end if
        fclose(fp);
        for (i = 0; i < numpackdirs; i++)
        {
            packfiles[i].filepos = LittleLong(packfiles[i].filepos);
            packfiles[i].filelen = LittleLong(packfiles[i].filelen);
        } //end for
    } //end else
    //
    for (i = 0; i < numpackdirs; i++)
    {
        ConvertPath(packfiles[i].name);
        if (FileFilter(filter, packfiles[i].name, false))
        {
            qf = malloc(sizeof(quakefile_t));
            if (!qf) Error("out of memory");
            memset(qf, 0, sizeof(quakefile_t));
            strcpy(qf->pakfile, pakfile);
            strcpy(qf->filename, pakfile);
            strcpy(qf->origname, packfiles[i].name);
            qf->zipfile = false;
            qf->offset = packfiles[i].filepos;
            qf->length = packfiles[i].filelen;
            qf->type = QuakeFileType(packfiles[i].name);
            //add the file ot the list
            qf->next = NULL;
            if (lastqf) lastqf->next = qf;
            else qfiles = qf;
            lastqf = qf;
        } //end if
    } //end for
    free(packfiles);
    return qfiles;
} //end of the function FindQuakeFilesInPak
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
quakefile_t *FindQuakeFilesWithPakFilter(char *pakfilter, char *filter)
{
#if defined(WIN32)|defined(_WIN32)
    WIN32_FIND_DATA filedata;
    HWND handle;
    struct _stat statbuf;
#else
    glob_t globbuf;
    struct stat statbuf;
    int j;
#endif
    quakefile_t *qfiles, *lastqf, *qf;
    char pakfile[_MAX_PATH], filename[_MAX_PATH], *str;
    int done;

    qfiles = NULL;
    lastqf = NULL;
    if (pakfilter && strlen(pakfilter))
    {
#if defined(WIN32)|defined(_WIN32)
        handle = FindFirstFile(pakfilter, &filedata);
        done = (handle == INVALID_HANDLE_VALUE);
        while(!done)
        {
            _splitpath(pakfilter, pakfile, NULL, NULL, NULL);
            _splitpath(pakfilter, NULL, &pakfile[strlen(pakfile)], NULL, NULL);
            AppendPathSeperator(pakfile, _MAX_PATH);
            strcat(pakfile, filedata.cFileName);
            _stat(pakfile, &statbuf);
#else
        glob(pakfilter, 0, NULL, &globbuf);
        for (j = 0; j < globbuf.gl_pathc; j++)
        {
            strcpy(pakfile, globbuf.gl_pathv[j]);
            stat(pakfile, &statbuf);
#endif
            //if the file with .pak or .pk3 is a folder
            if (statbuf.st_mode & S_IFDIR)
            {
                strcpy(filename, pakfilter);
                AppendPathSeperator(filename, _MAX_PATH);
                strcat(filename, filter);
                qf = FindQuakeFilesWithPakFilter(NULL, filename);
                if (lastqf) lastqf->next = qf;
                else qfiles = qf;
                lastqf = qf;
                while(lastqf->next) lastqf = lastqf->next;
            } //end if
            else
            {
#if defined(WIN32)|defined(_WIN32)
                str = StringContains(pakfile, ".pk3", false);
#else
                str = StringContains(pakfile, ".pk3", true);
#endif
                if (str && str == pakfile + strlen(pakfile) - strlen(".pk3"))
                {
                    qf = FindQuakeFilesInZip(pakfile, filter);
                } //end if
                else
                {
                    qf = FindQuakeFilesInPak(pakfile, filter);
                } //end else
                //
                if (qf)
                {
                    if (lastqf) lastqf->next = qf;
                    else qfiles = qf;
                    lastqf = qf;
                    while(lastqf->next) lastqf = lastqf->next;
                } //end if
            } //end else
            //
#if defined(WIN32)|defined(_WIN32)
            //find the next file
            done = !FindNextFile(handle, &filedata);
        } //end while
#else
        } //end for
        globfree(&globbuf);
#endif
    } //end if
    else
    {
#if defined(WIN32)|defined(_WIN32)
        handle = FindFirstFile(filter, &filedata);
        done = (handle == INVALID_HANDLE_VALUE);
        while(!done)
        {
            _splitpath(filter, filename, NULL, NULL, NULL);
            _splitpath(filter, NULL, &filename[strlen(filename)], NULL, NULL);
            AppendPathSeperator(filename, _MAX_PATH);
            strcat(filename, filedata.cFileName);
#else
        glob(filter, 0, NULL, &globbuf);
        for (j = 0; j < globbuf.gl_pathc; j++)
        {
            strcpy(filename, globbuf.gl_pathv[j]);
#endif
            //
            qf = malloc(sizeof(quakefile_t));
            if (!qf) Error("out of memory");
            memset(qf, 0, sizeof(quakefile_t));
            strcpy(qf->pakfile, "");
            strcpy(qf->filename, filename);
            strcpy(qf->origname, filename);
            qf->offset = 0;
            qf->length = 0;
            qf->type = QuakeFileType(filename);
            //add the file ot the list
            qf->next = NULL;
            if (lastqf) lastqf->next = qf;
            else qfiles = qf;
            lastqf = qf;
#if defined(WIN32)|defined(_WIN32)
            //find the next file
            done = !FindNextFile(handle, &filedata);
        } //end while
#else
        } //end for
        globfree(&globbuf);
#endif
    } //end else
    return qfiles;
} //end of the function FindQuakeFilesWithPakFilter
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
quakefile_t *FindQuakeFiles(char *filter)
{
    char *str;
    char newfilter[_MAX_PATH];
    char pakfilter[_MAX_PATH];
    char filefilter[_MAX_PATH];

    strcpy(newfilter, filter);
    ConvertPath(newfilter);
    strcpy(pakfilter, newfilter);

    str = StringContains(pakfilter, ".pak", false);
    if (!str) str = StringContains(pakfilter, ".pk3", false);

    if (str)
    {
        str += strlen(".pak");
        if (*str)
        {
            *str++ = '\0';
            while(*str == '\\' || *str == '/') str++;
            strcpy(filefilter, str);
            return FindQuakeFilesWithPakFilter(pakfilter, filefilter);
        } //end if
    } //end else
    return FindQuakeFilesWithPakFilter(NULL, newfilter);
} //end of the function FindQuakeFiles
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int LoadQuakeFile(quakefile_t *qf, void **bufferptr)
{
    FILE *fp;
    void *buffer;
    int length;
    unzFile zf;

    if (qf->zipfile)
    {
        //open the zip file
        zf = unzOpen(qf->pakfile);
        //set the file pointer
        qf->zipinfo.file = ((unz_s *) zf)->file;
        //open the Quake file in the zip file
        unzOpenCurrentFile(&qf->zipinfo);
        //allocate memory for the buffer
        length = qf->length;
        buffer = GetMemory(length+1);
        //read the Quake file from the zip file
        length = unzReadCurrentFile(&qf->zipinfo, buffer, length);
        //close the Quake file in the zip file
        unzCloseCurrentFile(&qf->zipinfo);
        //close the zip file
        unzClose(zf);

        *bufferptr = buffer;
        return length;
    } //end if
    else
    {
        fp = SafeOpenRead(qf->filename);
        if (qf->offset) fseek(fp, qf->offset, SEEK_SET);
        length = qf->length;
        if (!length) length = Q_filelength(fp);
        buffer = GetMemory(length+1);
        ((char *)buffer)[length] = 0;
        SafeRead(fp, buffer, length);
        fclose(fp);

        *bufferptr = buffer;
        return length;
    } //end else
} //end of the function LoadQuakeFile
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int ReadQuakeFile(quakefile_t *qf, void *buffer, int offset, int length)
{
    FILE *fp;
    int read;
    unzFile zf;
    char tmpbuf[1024];

    if (qf->zipfile)
    {
        //open the zip file
        zf = unzOpen(qf->pakfile);
        //set the file pointer
        qf->zipinfo.file = ((unz_s *) zf)->file;
        //open the Quake file in the zip file
        unzOpenCurrentFile(&qf->zipinfo);
        //
        while(offset > 0)
        {
            read = offset;
            if (read > sizeof(tmpbuf)) read = sizeof(tmpbuf);
            unzReadCurrentFile(&qf->zipinfo, tmpbuf, read);
            offset -= read;
        } //end while
        //read the Quake file from the zip file
        length = unzReadCurrentFile(&qf->zipinfo, buffer, length);
        //close the Quake file in the zip file
        unzCloseCurrentFile(&qf->zipinfo);
        //close the zip file
        unzClose(zf);

        return length;
    } //end if
    else
    {
        fp = SafeOpenRead(qf->filename);
        if (qf->offset) fseek(fp, qf->offset, SEEK_SET);
        if (offset) fseek(fp, offset, SEEK_CUR);
        SafeRead(fp, buffer, length);
        fclose(fp);

        return length;
    } //end else
} //end of the function ReadQuakeFile

---