gtkradiant/libs/pak/pakstuff.cpp

/*
Copyright (C) 1999-2007 id Software, Inc. and contributors.
For a list of contributors, see the accompanying CONTRIBUTORS file.

This file is part of GtkRadiant.

GtkRadiant 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.

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

#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#if defined (__linux__) || defined (__APPLE__)
#include <dirent.h>
#endif
#ifdef _WIN32
#include <io.h>
#endif
#include "pakstuff.h"
#include "unzip.h"
#include "str.h"

#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif

int                     m_nPAKIndex;
FILE*                   pakfile[16];
struct PACKDirectory	pakdir;
PACKDirPtr	      	pakdirptr = &pakdir;
UInt16	       		dirsize;
bool		        pakopen = false;
int   			f_type;
DIRECTORY	   	*paktextures = NULL;
UInt32		   	PakColormapOffset;
UInt32		       	PakColormapSize;
DIRECTORY      		*dirhead = NULL;
bool                    g_bPK3 = false;
char                    g_strBasePaths[16][1024];
int                     g_numBasePaths = 0;

struct PK3FileInfo
{
  unzFile m_zFile;
  char *m_pName;
  unz_s m_zInfo;
  long m_lSize;
  ~PK3FileInfo()
  {
    delete []m_pName;
  }
  bool operator ==(const PK3FileInfo& rhs) const { return strcmp(m_pName, rhs.m_pName) == 0; }
};

#define __PATHSEPERATOR   '/'

//#define LOG_PAKFAIL

#ifdef LOG_PAKFAIL

#if defined (__linux__) || defined (__APPLE__)
#include <unistd.h>
#include <pwd.h>
#endif
#include <sys/types.h>

class LogFile
{
public:
  FILE *m_pFile;
  LogFile(const char* pName)
  {
#if defined (__linux__) || defined (__APPLE__)
    // leo: use ~/.q3a/radiant/paklog instead of /tmp/paklog.txt
    char *home = NULL;
 
    home = getenv("HOME");
    if ( home == NULL )
    {
      uid_t id = getuid();
      struct passwd *pwd;
 
      setpwent();
      while( (pwd = getpwent()) != NULL )
	if( pwd->pw_uid == id )
	{
	  home = pwd->pw_dir;
	  break;
	}
      endpwent();
    }

    if (home != NULL)
    {
      char path[PATH_MAX];
      strcpy (path, home);
      if (path[strlen(path)-1] != '/')
	strcat (path, "/");
      strcat (path, ".q3a/radiant/paklog");
      m_pFile = fopen(path, "w");
    }
    else
#endif
      m_pFile = fopen(pName, "w");
  }
  ~LogFile()
  {
    if (m_pFile)
    {
      fclose(m_pFile);
    }
  }
  void Log(const char *pFormat, ...)
  {
    if (m_pFile == NULL)
      return;

    va_list arg_ptr;
    va_start(arg_ptr, pFormat);
    fprintf(m_pFile, pFormat, arg_ptr);
    va_end(arg_ptr);
  }
};

LogFile g_LogFile("/tmp/paklog.txt");
#endif

template <class T> class StrPtr : public Str
{
protected:
  T* m_pPtr;
  StrPtr()
  {
    m_pPtr = NULL;
  }

  StrPtr(const char *pStr, T *p) : Str(pStr)
  {
    m_pPtr = p;
  }

  T* Ptr()
  {
    return m_pPtr;
  }

  T& Ref()
  {
    return *m_pPtr;
  }
    

};
// PtrList
// a list of ptrs
// 
template <class T> class PtrList
{
protected:
  T *m_pPtr;
  PtrList *m_pNext;

public:

  PtrList()
  {
    m_pNext = NULL;
    m_pPtr = NULL;
  }

  PtrList(T *ip)
  {
    m_pNext = NULL;
    m_pPtr = ip;
  }

  virtual ~PtrList()
  {
    delete m_pPtr;
  }

  PtrList* Next()
  {
    return m_pNext;
  }

  void Add(T *ip)
  {
    PtrList *pl = this;
    while (pl && pl->m_pNext)
    {
      pl = pl->Next();
    }
    pl->m_pNext = new PtrList(ip);
  }

  void Remove()
  {
    PtrList *p = m_pNext;
    if (p)
    {
      while (p->m_pNext != this && p->m_pNext != NULL)
      {
        p = p->m_pNext;
      }
      if (p->m_pNext == this)
      {
        p->m_pNext = m_pNext;
      }
    }
  }

  virtual PtrList* Find(T *ip)
  {
    PtrList *p = m_pNext;
    while (p)
    {
      if (*p->m_pPtr == *ip)
      {
        return p;
      }
      p = p->m_pNext;
    }
    return NULL;
  }

  // remove vp from the list
  void Remove(T *ip)
  {
    PtrList *p = Find(ip);
    if (p)
    {
      p->Remove();
    }
  }

  T* Ptr()
  {
    return m_pPtr;
  }

  T& Ref()
  {
    return *m_pPtr;
  }

  void RemoveAll()
  {
    PtrList *p = m_pNext;
    while (p)
    {
      PtrList *p2 = p;
      p = p->m_pNext;
      delete p2;
    }
  }
};


typedef PtrList<unzFile> ZFileList;
typedef PtrList<Str> StrList;
typedef PtrList<PK3FileInfo> PK3List;


StrList g_PK3TexturePaths;
PK3List g_PK3Files;
ZFileList g_zFiles;
#define WORK_LEN 1024
#define TEXTURE_PATH "textures"
#define PATH_SEPERATORS "/\\:\0"

/*
char* __StrDup(char* pStr)
{
  if (pStr == NULL)
    pStr = "";

  return strcpy(new char[strlen(pStr)+1], pStr); 
}

char* __StrDup(const char* pStr)
{ 
  if (pStr == NULL)
    pStr = "";

  return strcpy(new char[strlen(pStr)+1], pStr); 
}
*/

#define MEM_BLOCKSIZE 4096
void* __qblockmalloc(size_t nSize)
{
	void *b;
  // round up to threshold
  int nAllocSize = nSize % MEM_BLOCKSIZE;
  if ( nAllocSize > 0)
  {
    nSize += MEM_BLOCKSIZE - nAllocSize;
  }
	b = malloc(nSize + 1);
	memset (b, 0, nSize);
	return b;
}

void* __qmalloc (size_t nSize)
{
	void *b;
	b = malloc(nSize + 1);
	memset (b, 0, nSize);
	return b;
}


/*
====================
Extract file parts
====================
*/
void __ExtractFilePath (const char *path, char *dest)
{
	const char *src;

	src = path + strlen(path) - 1;

//
// back up until a \ or the start
//
	while (src != path && *(src-1) != __PATHSEPERATOR)
		src--;

	memcpy (dest, path, src-path);
	dest[src-path] = 0;
}

void __ExtractFileName (const char *path, char *dest)
{
	const char *src;

	src = path + strlen(path) - 1;

//
// back up until a \ or the start
//
	while (src != path && *(src-1) != '/' 
		 && *(src-1) != '\\' )
		src--;

	while (*src)
	{
		*dest++ = *src++;
	}
	*dest = 0;
}

void __ExtractFileBase (const char *path, char *dest)
{
	const char *src;

	src = path + strlen(path) - 1;

//
// back up until a \ or the start
//
	while (src != path && *(src-1) != '/' 
		 && *(src-1) != '\\' )
		src--;

	while (*src && *src != '.')
	{
		*dest++ = *src++;
	}
	*dest = 0;
}

void __ExtractFileExtension (const char *path, char *dest)
{
	const char *src;

	src = path + strlen(path) - 1;

//
// back up until a . or the start
//
	while (src != path && *(src-1) != '.')
		src--;
	if (src == path)
	{
		*dest = 0;	// no extension
		return;
	}

	strcpy (dest,src);
}


void __ConvertDOSToUnixName( char *dst, const char *src )
{
	while ( *src )
	{
		if ( *src == '\\' )
			*dst = '/';
		else
			*dst = *src;
		dst++; src++;
	}
	*dst = 0;
}





static void AddSlash(Str& str)
{
  int nLen = str.GetLength();
  if (nLen > 0)
  {
    if (str[nLen-1] != '\\' && str[nLen-1] != '/')
      str += '\\';
  }
}

static void FindReplace(Str& strContents, const char* pTag, const char* pValue)
{
  if (strcmp(pTag, pValue) == 0)
    return;
  for (int nPos = strContents.Find(pTag); nPos >= 0; nPos = strContents.Find(pTag))
  {
    int nRightLen = strContents.GetLength() - strlen(pTag) - nPos;
    Str strLeft(strContents.Left(nPos));
    Str strRight(strContents.Right(nRightLen));
    strLeft += pValue;
    strLeft += strRight;
    strContents = strLeft;
  }
}





void ClearFileList(FILELIST **list)
{
	FILELIST	*temp;

	while(*list)
	{
		temp = *list;
		*list = (*list)->next;
		free(temp);
	}
}

void ClearDirList(DIRLIST **list)
{
	DIRLIST	*temp;

	while(*list)
	{
		temp = *list;
		*list = (*list)->next;
		free(temp);
	}
}

DIRECTORY *FindPakDir(DIRECTORY *dir, char *name)
{
	DIRECTORY	*currentPtr;

	for(currentPtr = dir; currentPtr; currentPtr = currentPtr->next)
	{
		if(!stricmp(name, currentPtr->name))
		{
			return currentPtr;
		}
	}
	return NULL;
}


// LoadPK3FileList
// ---------------
//
// This gets passed a file mask which we want to remove as 
// we are only interested in the directory name and any given
// extension. Only handles explicit filenames or *.something
//
bool LoadPK3FileList(FILELIST **filelist, const char *pattern)
{
  char cSearch[WORK_LEN];
	__ConvertDOSToUnixName( cSearch, pattern );
  char cPath[WORK_LEN];
  char cExt[WORK_LEN];
  char cFile[WORK_LEN];
  char cWork[WORK_LEN];
  __ExtractFilePath(pattern, cPath);
  __ExtractFileName(pattern, cFile);
  __ExtractFileExtension(pattern, cExt);
  const char *pCompare = (strnicmp(cFile, "*.", 2) == 0) ? cExt : cFile;

  PK3List *p = g_PK3Files.Next();
  while (p != NULL)
  {
    // qualify the path
    PK3FileInfo *pKey = p->Ptr();
    if (strstr(pKey->m_pName, cPath) && strstr(pKey->m_pName, pCompare))
    {
      __ExtractFileName(pKey->m_pName, cWork); 
      AddToFileListAlphabetized(filelist, cWork, 0, 0, false);
    }
    p = p->Next();
  }
  return (*filelist) != NULL;
}

bool GetPackFileList(FILELIST **filelist, char *pattern)
{
	char					*str1, *str2;
	int						i;
	DIRECTORY				*dummy = paktextures;
	FILELIST				*temp;

	if (!pakopen)
		return false;

  if (g_bPK3)
  {
    return LoadPK3FileList(filelist, pattern);
  }

	str1 = pattern;

	for(i = 0; pattern[i] != '\0'; i++)
	{
		if(pattern[i] == '\\')
			pattern[i] = '/';
	}

	while(strchr(str1, '/'))
	{
		str2 = strchr(str1, '/');
		*str2++ = '\0';
		dummy = FindPakDir(dummy, str1);
		if(!dummy)
			return false;
		str1 = str2;
	}
	for(temp = dummy->files; temp; temp=temp->next)
	{
	  AddToFileListAlphabetized(filelist, temp->filename, temp->offset, 0, false);
	}
	return true;
}

bool GetPackTextureDirs(DIRLIST **dirlist)
{
	UInt16					i;
	char					buf[57];

	if (!pakopen)
		return 1;

  if (g_bPK3)
  {
    StrList *pl = g_PK3TexturePaths.Next();
    while (pl != NULL)
    {
      AddToDirListAlphabetized(dirlist, pl->Ref(), 0);
      pl = pl->Next();
    }
    return true;
  }

	for (i = 0; i < dirsize; i++)
	{
		if(!strnicmp(pakdirptr[i].name, "textures", 8))
		{
			strncpy(buf, &(pakdirptr[i].name[9]), 46);
			if(strchr(buf, '\\'))
	      	*strchr(buf, '\\') = '\0';
			else if(strchr(buf, '/'))
	      	*strchr(buf, '/') = '\0';
			else
	      	buf[56] = '\0';

			if(strchr(buf, '.'))
				continue;

			AddToDirListAlphabetized(dirlist, buf, 0);
		}
	}
	return true;
}

bool AddToDirListAlphabetized(DIRLIST **list, char *dirname, int from)
{
	DIRLIST	*currentPtr, *previousPtr, *newPtr;

	strlwr(dirname);
	for(currentPtr = *list; currentPtr; currentPtr = currentPtr->next)
	{
		if(!stricmp(dirname, currentPtr->dirname))
		{
			return false;
		}
	}
	previousPtr = NULL;
	currentPtr = *list;

	if((newPtr = (DIRLIST *)__qmalloc(sizeof(DIRLIST))) == NULL)
		return false;

	strcpy(newPtr->dirname, dirname);
	newPtr->from = from;

	while(currentPtr != NULL && stricmp(dirname, currentPtr->dirname) > 0)
	{
		previousPtr = currentPtr;
		currentPtr = currentPtr->next;
	} //End while
	if(previousPtr == NULL)
	{
		newPtr->next = *list;
		*list = newPtr;
	} //End if
	else
	{
		previousPtr->next = newPtr;
		newPtr->next = currentPtr;
	} //End else
	return true;
}

bool AddToFileListAlphabetized(FILELIST **list, char *filename, UInt32 offset, UInt32 size, bool dirs)
{
	FILELIST	*currentPtr, *previousPtr, *newPtr;

	for(currentPtr = *list; currentPtr; currentPtr = currentPtr->next)
	{
		if(!stricmp(filename, currentPtr->filename))
		{
			return false;
		}
	}
	previousPtr = NULL;
	currentPtr = *list;

	if((newPtr = (FILELIST *)__qmalloc(sizeof(FILELIST))) == NULL)
		return false;

	strcpy(newPtr->filename, filename);
	newPtr->offset = offset;
	newPtr->size = size;

	while(currentPtr != NULL && stricmp(filename, currentPtr->filename) > 0)
	{
		previousPtr = currentPtr;
		currentPtr = currentPtr->next;
	} //End while
	if(previousPtr == NULL)
	{
		newPtr->next = *list;
		*list = newPtr;
	} //End if
	else
	{
		previousPtr->next = newPtr;
		newPtr->next = currentPtr;
	} //End else
	return true;
}

int PakLoadAnyFile(const char *filename, void **bufferptr)
{
  char cWork[WORK_LEN];
  if (g_bPK3)
  {
    // leo: hack to be able to use pak files from multiple directories
    for (int i = 0; i < g_numBasePaths; i++)
    {
      PK3FileInfo *pInfo;
      Str strKey;
      // need to lookup the file without the base/texture path on it
      Str strBase(g_strBasePaths[i]);
      AddSlash(strBase);
      __ConvertDOSToUnixName(cWork, strBase);
      Str strFile(filename);
      __ConvertDOSToUnixName(strFile, strFile);
      strFile.MakeLower();
      strlwr(cWork);
      FindReplace(strFile, cWork, "");

      PK3FileInfo infoFind;
      infoFind.m_pName = __StrDup(strFile.GetBuffer());
      PK3List *pList = g_PK3Files.Find(&infoFind);
      if (pList)
      {
	pInfo = pList->Ptr();
	memcpy(pInfo->m_zFile, &pInfo->m_zInfo, sizeof(unz_s));
	if (unzOpenCurrentFile(pInfo->m_zFile) == UNZ_OK)
        {
          void *buffer = __qblockmalloc(pInfo->m_lSize+1);
	  int n = unzReadCurrentFile(pInfo->m_zFile , buffer, pInfo->m_lSize);
	  *bufferptr = buffer;
	  unzCloseCurrentFile(pInfo->m_zFile);
	  return n;
	}
      }
    }

#ifdef LOG_PAKFAIL
    sprintf(cWork, "PAK failed on %s\n", filename);
    g_LogFile.Log(cWork);
#endif
    return -1;
  }

  for (int i = 0; i < dirsize; i++)
  {
    if(!stricmp(filename, pakdirptr[i].name))
    {
      if (fseek(pakfile[m_nPAKIndex], pakdirptr[i].offset, SEEK_SET) >= 0)
      {
	void *buffer = __qmalloc (pakdirptr[i].size+1);
	((char *)buffer)[pakdirptr[i].size] = 0;
	if (fread(buffer, 1, pakdirptr[i].size, pakfile[m_nPAKIndex]) == pakdirptr[i].size)
        {
          *bufferptr = buffer;
          return pakdirptr[i].size;
        }
      }
    }
  }
#ifdef LOG_PAKFAIL
  sprintf(cWork, "PAK failed on %s\n", filename);
  g_LogFile.Log(cWork);
#endif
  return -1;
}



DIRECTORY *AddPakDir(DIRECTORY **dir, char *name)
{
	DIRECTORY	*currentPtr, *previousPtr, *newPtr;

	for(currentPtr = *dir; currentPtr; currentPtr = currentPtr->next)
	{
		if(!stricmp(name, currentPtr->name))
		{
			return currentPtr;
		}
	}
	previousPtr = NULL;
	currentPtr = *dir;

	if((newPtr = (DIRECTORY *)__qmalloc(sizeof(DIRECTORY))) == NULL)
		return NULL;

	strcpy(newPtr->name, name);
	newPtr->files = NULL;

	while(currentPtr != NULL && stricmp(name, currentPtr->name) > 0)
	{
		previousPtr = currentPtr;
		currentPtr = currentPtr->next;
	}
	if(previousPtr == NULL)
	{
		newPtr->next = *dir;
		*dir = newPtr;
	}
	else
	{
		previousPtr->next = newPtr;
		newPtr->next = currentPtr;
	}
	return newPtr;
}


// OpenPK3
// -------
// Opens a PK3 ( or zip ) file and creates a list of filenames
// and zip info structures
// 
bool OpenPK3(const char *filename)
{
  char cFilename[WORK_LEN];
  char cName[WORK_LEN];
  char cWork[WORK_LEN];
  unz_file_info zInfo;
  unzFile *zFile = new unzFile(unzOpen(filename));
  g_zFiles.Add(zFile);
  if (zFile != NULL)
  {
    int nStatus = unzGoToFirstFile(*zFile);
    while (nStatus == UNZ_OK)
    {
      cFilename[0] = '\0';
      unzGetCurrentFileInfo(*zFile, &zInfo, cFilename, WORK_LEN, NULL, 0, NULL, 0);
      strlwr(cFilename);
    	__ConvertDOSToUnixName( cWork, cFilename);
      if (strstr(cWork, ".") != NULL)
      {
        PK3FileInfo *pInfo = new PK3FileInfo();
        pInfo->m_pName = __StrDup(cWork);
        memcpy(&pInfo->m_zInfo, (unz_s*)*zFile, sizeof(unz_s));
        pInfo->m_lSize = zInfo.uncompressed_size;
        pInfo->m_zFile = *zFile;
        g_PK3Files.Add(pInfo);
      }
      char *p = strstr(cFilename, TEXTURE_PATH);
      if (p != NULL)
      {
        // FIXME: path differences per os ?
        // catch solo directory entry
        if (strlen(p) > strlen(TEXTURE_PATH) + 1)
        {
          // skip textures + path seperator
          p += strlen(TEXTURE_PATH) + 1;
          int nEnd = strcspn(p, PATH_SEPERATORS);
          strncpy(cName, p, nEnd);
          cName[nEnd] = '\0';

          bool bFound = false;
          StrList *pl = g_PK3TexturePaths.Next();
          while (pl != NULL)
          {
            if (strcmpi(pl->Ref(), cName) == 0)
            {
              // already have this, continue
              bFound = true;
              break;
            }
            pl = pl->Next();
          }
          if (!bFound)
          {
            g_PK3TexturePaths.Add(new Str(cName));
          }
        }
      }
      nStatus = unzGoToNextFile(*zFile);
    }
  }
  return (zFile != NULL);
}

void closePK3(unzFile zf)
{
  unzClose(zf);
}

void OpenPakFile(const char *filename)
{
  if(!pakopen)
    paktextures = NULL;

  pakopen = g_bPK3 = OpenPK3(filename);
}

void ClearPaKDir(DIRECTORY **dir)
{
	DIRECTORY	*d1 = *dir, *d2;

	while(d1)
	{
		ClearFileList(&(d1->files));
		d2 = d1;
		d1 = d1->next;
		free(d2);
	}
}

void CleanUpPakDirs()
{
  ClearPaKDir(&paktextures);
  paktextures = NULL;
  dirhead = NULL;
  g_PK3TexturePaths.RemoveAll();
  g_PK3Files.RemoveAll();
}

void ClosePakFile(void)
{
	if(pakopen)
  {
    if (g_bPK3)
    {
      ZFileList *p = g_zFiles.Next();
      while (p != NULL)
      {
        unzFile uz = p->Ref();
        closePK3(uz);
        p = p->Next();
      }
    }
    else
    {
      fclose(pakfile[m_nPAKIndex]);
    }
  }
	pakopen = false;
  CleanUpPakDirs();
}


void WINAPI InitPakFile(const char * pBasePath, const char *pName)
{
  if (g_numBasePaths == 0)
  {
    m_nPAKIndex = 0;
    pakopen = false;
    paktextures = NULL;
  }
  strcpy(g_strBasePaths[g_numBasePaths], pBasePath);
  g_numBasePaths++;
  
  if (pName == NULL)
  {
    //++timo FIXME: use some kind of compatibility lib here!
#if defined (__linux__) || defined (__APPLE__)
    char cWork[WORK_LEN];
    struct dirent *dirlist;
    DIR *dir;
    
    dir = opendir (pBasePath);
    if (dir != NULL)
    {
      while ((dirlist = readdir (dir)) != NULL)
      {
        if (strstr (dirlist->d_name, ".pk3") == NULL)
          continue;
        sprintf(cWork, "%s/%s", pBasePath, dirlist->d_name);
        OpenPakFile(cWork);
      }
      closedir (dir);
    }
#endif
#ifdef _WIN32
    char cWork[WORK_LEN];
    Str strPath(pBasePath);
    AddSlash(strPath);
    strPath += "*.pk3";
    bool bGo = true;
    struct _finddata_t fileinfo;
    int handle = _findfirst (strPath, &fileinfo);
    if (handle != -1)
    {
      do
      {
        sprintf(cWork, "%s/%s", pBasePath, fileinfo.name);
        OpenPakFile(cWork);
      } while (_findnext( handle, &fileinfo ) != -1);
      _findclose (handle);
    }
#endif
  }
  else
  {
    OpenPakFile(pName);
  }
}