AaronCameron.net

I care not for your petty politics.

• 
• 
• 
• 
• 

Not a Member? - Login or Create an Account

Tuesday the 22nd of May 2012 @ 06:14pm

Front Page Journal Projects Your Profile About

LibN2L N2L Home Older News Downloads Documentation (n2l5) Class Hierarchy Compound List File List n2l:: Members Functions Whole n2l:: Ref Documentation (libN2L-4) Class Hierarchy Compound List File List n2l:: Members Functions Whole n2l:: Ref Bugtracker Project Page Report a Bug Bug List Related Things Life 2130 Devel Game Journal

LibN2L-4 Library Code Reference Classes Compounds Files Members Method Index Full Reference vfsUtilities.cpp Go to the documentation of this file. /************************************************************************ Nova-2 Library (libN2L, or simply n2l) Game development C++ Library Copyright (C) 2003 Aaron Cameron This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA A copy of the GNU Lesser General Public License has been provided with this library in the file 'COPYING'. Contact information for the author of this library has been provided with this library in the file 'AUTHOR'. ************************************************************************/ #include "vfsUtilities.h" #include "n2l/n2l.h" #include "n2l/dynVars.h" #include "vfsConstants.h" #include "cVfsOpenException.h" #include "cVfsReadException.h" #include "vfsFileTypes.h" #include "cVfsNodeInterface.h" #include "cVfsDirectory.h" #include "cVfsFile.h" #include <map> #include <vector> #include <sys/stat.h> #include <stdio.h> #include <dirent.h> #include <errno.h> #ifdef WIN32 # include <windows.h> # define SHGFP_TYPE_CURRENT 0 # define CSIDL_APPDATA 0x0001a # define CSIDL_CREATE 0x8000 # ifndef S_ISDIR # define S_ISDIR(mode) (((mode) & _S_IFDIR) != 0) # endif # ifndef S_ISREG # define S_ISREG(mode) (((mode) & _S_IFREG) != 0) # endif # define getcwd _getcwd #else # include <sys/types.h> # include <pwd.h> # include <unistd.h> # include <libgen.h> #endif using namespace std; /******************************************************************************/ namespace n2l { /**************************************************************************/ const tString vfsPermissionsAsString( const tUint &iPerms ) { tString temp( "---" ); if (iPerms&VfsPermission_Readable) temp[0] = 'r'; if (iPerms&VfsPermission_Writeable) temp[1] = 'w'; if (iPerms&VfsPermission_Executable) temp[2] = 'x'; return temp; } /**************************************************************************/ const tFsNodeType getFsNodeType( const tFsNodeName &iName ) { tFsNodeName name = cleanFsPath(iName); struct stat statBuffer; if (0!=stat(name.c_str(),&statBuffer)) throw cVfsOpenException("getFsNodeType","Stat failed",name); if (S_ISDIR(statBuffer.st_mode)) return FsNodeType_Directory; if (S_ISREG(statBuffer.st_mode)) return FsNodeType_File; return FsNodeType_Unknown; } /**************************************************************************/ const tUint getVfsNodePermissions( const tVfsNodeName &iName ) { return 0; } /**************************************************************************/ const tUint getFsNodePermissions( const tFsNodeName & ) // i_name { return 0; } /**************************************************************************/ const tFsFileSize getFsNodeSize( const tFsNodeName &i_name ) { FILE * fp = fopen( i_name.c_str(), "rb" ); if (0==fp) throw cVfsOpenException("getFsNodeSize","Open failed",i_name); const tSint OldFpPos = ftell(fp); if (-1==OldFpPos) { fclose(fp); throw cVfsReadException( "getFsNodeSize", "Tell failed getting origin", i_name); } if (-1==fseek(fp,0,SEEK_END)) { fclose(fp); throw cVfsReadException("getFsNodeSize", "Seek end failed", i_name); } const tSint TotalSize = ftell(fp); if (-1==TotalSize) { fclose(fp); throw cVfsReadException( "getFsNodeSize", "Tell failed getting size", i_name); } if (-1==fseek(fp,OldFpPos,SEEK_SET)) { fclose(fp); throw cVfsReadException( "getFsNodeSize", "Seek origin failed", i_name); } fclose(fp); return tFsFileSize(TotalSize); } /**************************************************************************/ void getFsNodeDump( const tFsNodeName &i_name, tString &o_buffer ) { o_buffer.clear(); const tFsFileSize FileSize = getFsNodeSize(i_name); if (0==FileSize) return; o_buffer.reserve( FileSize ); FILE * fp = fopen( i_name.c_str(), "rb" ); if (0==fp) throw cVfsReadException("getFsNodeDump", "Open failed", i_name); const tUint ReadBufferSize = 1024*64; // 64k read buffer tUint8 readBuffer[ReadBufferSize]; tUint fileBytesLeftToRead = FileSize; tUint bytesToRead = (fileBytesLeftToRead > ReadBufferSize?ReadBufferSize:fileBytesLeftToRead); while (!feof(fp) && bytesToRead) { if ( 1!=fread((void*)(readBuffer), bytesToRead,1, fp) && !feof(fp) ) { fclose(fp); throw cVfsReadException( "getFsNodeDump", "Out of bytes before eof", i_name); } o_buffer.append( (char*)(readBuffer), tString::size_type(bytesToRead) ); fileBytesLeftToRead -= bytesToRead; bytesToRead = (fileBytesLeftToRead > ReadBufferSize?ReadBufferSize:fileBytesLeftToRead); } fclose(fp); } /**************************************************************************/ const tVfsNodeName convertFsLiteralNameToVfs( const tFsNodeName &i_name ) { const char FsPathSepArray[] = { _n2l::FsPathSeperatorSymbol,'\0' }; const char VfsPathSepArray[] = { VfsPathSeperatorSymbol,'\0' }; return cleanVfsPath( substringReplace( FsPathSepArray, VfsPathSepArray, i_name) ); } /**************************************************************************/ const tVfsNodeName cleanVfsPath( const tVfsNodeName &iName ) { return _n2l::cleanPath(iName,VfsPathSeperatorSymbol); } /**************************************************************************/ const tFsNodeName cleanFsPath( const tFsNodeName & iName ) { return _n2l::cleanPath( _n2l::cleanPath( iName, _n2l::FsPathSeperatorSymbol), _n2l::AltFsPathSeperatorSymbol ); } /**************************************************************************/ const vector<tVfsNodeName> splitVfsPathBlocks( const tVfsNodeName &i_name ) { vector<tVfsNodeName> temp; explode(i_name,temp,VfsPathSeperatorSymbol,'\0','\0'); // Remove blank entries for (vector<tVfsNodeName>::iterator blockIt = temp.begin(); blockIt!=temp.end();) { if (!blockIt->size()) blockIt = temp.erase(blockIt); else ++blockIt; } return temp; } /**************************************************************************/ const tVfsNodeName stripFrontLiteralVfsName( const tVfsNodeName &iName, tVfsNodeName &oStrippedName ) { const tVfsNodeName::size_type StartPos = iName.find_first_not_of(VfsPathSeperatorSymbol); if (StartPos == tVfsNodeName::npos) { oStrippedName = ""; return ""; } tVfsNodeName::size_type breakPos = iName.find( VfsPathSeperatorSymbol,StartPos+1); if (breakPos == tVfsNodeName::npos ) { oStrippedName = iName.substr(StartPos,iName.size()-StartPos); return ""; } const tVfsNodeName::difference_type StrippedNameSize = breakPos-StartPos; if (StrippedNameSize<=0) { oStrippedName = ""; return ""; } const tVfsNodeName::size_type RemainStrSize = iName.size()-breakPos; oStrippedName = iName.substr(StartPos,StrippedNameSize); if (RemainStrSize==1) return ""; return iName.substr(breakPos+1,RemainStrSize); } /**************************************************************************/ const tString & simpleGuessVfsFileType( const tVfsNodeName &iName ) { static map<tString,const tString*> extLookup; // Get an extension if there is one const tString::size_type LastDotPos = iName.find_last_of("."); if (LastDotPos==tString::npos) return VfsFileType_Unknown; // Get the extension const tString extStr = iName.substr( (LastDotPos+1), iName.size()-(LastDotPos+1) ); // Build the extension list if we haven't already if (extLookup.empty()) { extLookup["bmp"] = &VfsFileType_BMP; extLookup["gif"] = &VfsFileType_GIF; extLookup["jpeg"] = &VfsFileType_JPEG; extLookup["jpg"] = &VfsFileType_JPEG; extLookup["jpe"] = &VfsFileType_JPEG; extLookup["png"] = &VfsFileType_PNG; extLookup["tiff"] = &VfsFileType_TIFF; extLookup["tif"] = &VfsFileType_TIFF; extLookup["tga"] = &VfsFileType_TGA; extLookup["pcx"] = &VfsFileType_PCX; extLookup["wav"] = &VfsFileType_WAV; /**************************************************************************/ extLookup["mp3"] = &VfsFileType_MP3; extLookup["ogg"] = &VfsFileType_OGG; extLookup["gz"] = &VfsFileType_GZIP; extLookup["tgz"] = &VfsFileType_GZIP; extLookup["tar"] = &VfsFileType_TAR; extLookup["bz2"] = &VfsFileType_BZIP2; extLookup["zip"] = &VfsFileType_ZIP; } // Do the lookup const map<tString,const tString*>::const_iterator ExtPos = extLookup.find( extStr ); if (ExtPos == extLookup.end()) return VfsFileType_Unknown; return *(ExtPos->second); } /**************************************************************************/ const tUint vfsNodeFileWithHeader( const cVfsNodeInterface &iNode, const tString &iHeader, tVfsFileBuffer &oBuffer ) { oBuffer.clear(); if (!iNode.likeFile()) throw cBadDataUseException( "vfsNodeFileWithHeader", "Node is not like a file" ); if (iNode.firstLine()!=iHeader) throw cBadDataUseException( "vfsNodeFileWithHeader", tString("File header: \"") + iNode.firstLine() + "\" not " " the required header: \"" + iHeader + "\"" ); iNode.getBuffer( oBuffer ); const tUint DataOffset = iNode.firstLine().size()+1; if (oBuffer.size()<=DataOffset) throw cBadDataUseException( "vfsNodeFileWithHeader", "No data after header" ); return DataOffset; } /**************************************************************************/ const tUint vfsNodeFileWithHeader( const cVfsNodeInterface &iNode, const tString &iHeader ) { if (!iNode.likeFile()) throw cBadDataUseException( "vfsNodeFileWithHeader", "Node is not like a file" ); if (iNode.firstLine()!=iHeader) throw cBadDataUseException( "vfsNodeFileWithHeader", tString("File header: \"") + iNode.firstLine() + "\" not the required header: \"" + iHeader + "\"" ); const tUint DataOffset = iNode.firstLine().size()+1; if (iNode.size()<=DataOffset) throw cBadDataUseException( "vfsNodeFileWithHeader", "No data after header" ); return DataOffset; } /**************************************************************************/ void vfsNodeFileWithHeader( const cVfsNodeInterface &iNode, const tString &iHeader, cDynVar &oDef ) { if (!iNode.likeFile()) throw cBadDataUseException( "vfsNodeFileWithHeader", "Provided node isn\'t like a file" ); // Load it. if (iNode.firstLine()!=iHeader) throw cParsingException( "vfsNodeFileWithHeader", tString("This file isn\'t the right type. " "Wanted: \"") + iHeader + "\" but got: \"" + iNode.firstLine() + "\"" ); if (iNode.buffer().size()<=(iNode.firstLine().size()+1)) throw cParsingException( "vfsNodeFileWithHeader", "No data after header" ); // The type is ok, unserialize it for the caller to work with. oDef.unserialize( iNode.buffer().c_str() + iNode.firstLine().size()+1 ); } /**************************************************************************/ const tVfsNodeName vfsGetCWD() { # ifdef WIN32 tUint bufSize = MAX_PATH; # else tUint bufSize = 1024; # endif for (;;) { char *buf = new char[bufSize]; if (NULL == getcwd(buf, bufSize)) { delete []buf; if (errno == ERANGE && (bufSize*2>bufSize)) { bufSize *= 2; } else throw cException( "vfsGetCWD", "Failed, though I have no clue why. Errno was: " + asString(errno) ); } else { tVfsNodeName tmp = buf; delete []buf; return tmp; } } } /**************************************************************************/ const tVfsNodeName vfsGetHomeDir() { tFsNodeName temp; # ifdef WIN32 static HMODULE hSHFolderDLL = NULL; hSHFolderDLL = LoadLibrary("SHFOLDER.DLL"); typedef HRESULT (WINAPI *SHGetFolderPathADDR)(HWND, int, HANDLE, DWORD, LPTSTR); static SHGetFolderPathADDR SHGetFolderPath = 0; SHGetFolderPath = (SHGetFolderPathADDR)GetProcAddress( hSHFolderDLL, "SHGetFolderPathA" ); if (!SHGetFolderPath) throw cVfsException("vfsGetHomeDir", "Could not get proc addr for SHGetFolderPathA" ); char path[MAX_PATH]; HRESULT r = SHGetFolderPath(0, CSIDL_APPDATA|CSIDL_CREATE, 0, SHGFP_TYPE_CURRENT, path); if (r == S_FALSE || r == E_FAIL || r == E_INVALIDARG) throw cVfsException( "vfsGetHomeDir", "Failed calling ShGetFolderPath" ); temp = path; # else struct passwd *passWDLine = getpwuid( getuid() ); if (!passWDLine) throw cVfsException("vfsGetHomeDir", "Cannot get user passwd line"); temp = tFsNodeName( passWDLine->pw_dir ); # endif return convertFsLiteralNameToVfs( temp ); } /**************************************************************************/ const tString vfsGetExecBinaryDir( const tString &iArgV0 ) { if (iArgV0.empty()) throw cBadDataUseException( "vfsGetExecBinaryDir", "Called without an argv0." ); # ifdef WIN32 throw cUnsupportedMethodException( "vfsGetExecBinaryDir", "No implementation exists for this method. Actually, " "this method may work exactly the same as in Linux, it just " "hasn\'t been tested." ); # else vector<tString> path; tString binName; // Figure out the binary name and the path described by iArgV0 { char *tmp = new char[iArgV0.size()+1]; strcpy( tmp, iArgV0.c_str() ); path.push_back( dirname( tmp ) ); strcpy( tmp, iArgV0.c_str() ); binName = basename( tmp ); delete []tmp; } try { explode( n2lGetEnv("PATH"), path, ':', '\\', '\0', true ); } catch ( const cOutOfBoundsException & ) { // This is ok. Continue with no path defined. } for (tUint i=0; i!=path.size(); ++i) { cAutoPtr<cVfsDirectory> sDir = 0; try { sDir = new cVfsDirectory( path[i] ); cVfsDirectory::tConstIterator f = sDir->find( binName ); if (f==sDir->end()) continue; cAutoPtr<const cVfsFile> file = f->second.as<const cVfsFile>(); if (!file.isSet()) continue; if (file->isSymLink()) { // Let's give them this and be done with it. tString retV; { retV = file->readLink(); char *tmp = new char[retV.size()+1]; strcpy( tmp, retV.c_str() ); retV = dirname(tmp); delete []tmp; return retV; } } else return path[i]; } catch ( const cException & ) { } } return ""; # endif } } // namespace n2l namespace _n2l { /**************************************************************************/ const n2l::tString cleanPath(const n2l::tString &iName, const char iPathSplit ) { // This is a big hacky, but it sort of fits in the scope of // what we're supposed to do so I don't feel TOO terrible about it. if (iName==".") return _n2l::cleanPath( n2l::vfsGetCWD(), iPathSplit ); vector<n2l::tString> parts; vector<n2l::tString> cleanParts; n2l::explode(iName,parts,iPathSplit,'\0','\0'); for(vector<n2l::tString>::const_iterator it = parts.begin(); it!=parts.end(); ++it) { if (!it->empty() && *it!="." && *it!="..") cleanParts.push_back(*it); } n2l::tString finalStr; if (!iName.empty() && iName[0]==iPathSplit) finalStr.assign( 1, iPathSplit ); finalStr += n2l::implode(cleanParts,iPathSplit,'\0','\0'); return finalStr; } }

©2012 Aaron Cameron