CcpFileUtils.cpp

// Copyright © 2014 CCP ehf.


#include "include/CcpFileUtils.h"
#include "include/StringConversions.h"
#include "include/CcpSecureCrt.h"

#include <stdlib.h>

#ifdef _WIN32

int ConvertShareMode( CcpShareMode shareMode )
{
	int shflag = 0;

	switch( shareMode )
	{
	case CCP_SM_NOSHARING:
		shflag = _SH_DENYRW;
		break;

	case CCP_SM_READSHARING:
		shflag = _SH_DENYWR;
		break;

	case CCP_SM_RWSHARING:
		shflag = _SH_DENYNO;
		break;
	}

	return shflag;
}


int ConvertOpenMode( CcpOpenMode mode )
{
	int oflag = 0;

	switch( mode )
	{
	case CCP_OM_READONLY:
		oflag = _O_RDONLY;
		break;

	case CCP_OM_READWRITE:
		oflag = _O_CREAT | _O_RDWR;
		break;
	}

	return oflag;
}

int CcpOpenFile( const wchar_t* filename, CcpOpenMode mode, CcpShareMode shareMode )
{
	int oflag = ConvertOpenMode( mode );
	int shflag = ConvertShareMode( shareMode );

	int fd;
	_wsopen_s( &fd, filename, oflag | _O_BINARY, shflag, _S_IREAD | _S_IWRITE );

	return fd;
}

int CcpCreateFile( const wchar_t* filename, CcpShareMode shareMode )
{
	int fd;

	int shflag = ConvertShareMode( shareMode );
	_wsopen_s( &fd, filename, _O_CREAT | _O_TRUNC | O_RDWR | _O_BINARY, shflag, _S_IREAD | _S_IWRITE );

	return fd;
}

void CcpCloseFile( int fd )
{
	_close( fd );
}

ssize_t CcpReadFromFile( int fd, void* buf, size_t numBytes )
{
	return _read( fd, buf, (unsigned int)numBytes );
}

ssize_t CcpWriteToFile( int fd, const void* buf, size_t numBytes )
{
	return _write( fd, buf, (unsigned int)numBytes );
}

off_t CcpLseek( int fd, off_t offset, int whence )
{
	return _lseek( fd, offset, whence );
}

off_t CcpTell( int fd )
{
	return _tell( fd );
}

#else

int ConvertShareMode( CcpShareMode shareMode )
{
	int shflag = 0;
#ifndef __ANDROID__
	switch( shareMode )
	{
	case CCP_SM_NOSHARING:
		shflag = O_EXLOCK;
		break;

	case CCP_SM_READSHARING:
		shflag = O_SHLOCK;
		break;

	case CCP_SM_RWSHARING:
		shflag = 0;
		break;
	}
#endif
	return shflag;
}

int ConvertOpenMode( CcpOpenMode mode )
{
	int oflag = 0;

	switch( mode )
	{
	case CCP_OM_READONLY:
		oflag = O_RDONLY;
		break;

	case CCP_OM_READWRITE:
		oflag = O_CREAT | O_RDWR;
		break;
	}

	return oflag;
}


int CcpOpenFile( const wchar_t* filename, CcpOpenMode mode, CcpShareMode shareMode )
{
	int oflag = ConvertOpenMode( mode );
	int shflag = ConvertShareMode( shareMode );
	int fd = open( CW2A( filename ), oflag | shflag, S_IRUSR | S_IWUSR );

	return fd;
}

int CcpCreateFile( const wchar_t* filename )
{
	int fd = open( CW2A( filename ), O_CREAT | O_TRUNC | O_RDWR, S_IRUSR | S_IWUSR );

	return fd;
}

int CcpCreateFile( const wchar_t* filename, CcpShareMode shareMode )
{
	int shflag = ConvertShareMode( shareMode );
	int fd = open( CW2A( filename ), O_CREAT | O_TRUNC | O_RDWR | shflag, S_IRUSR | S_IWUSR );

	return fd;
}

void CcpCloseFile( int fd )
{
	close( fd );
}

ssize_t CcpReadFromFile( int fd, void* buf, size_t numBytes )
{
	return read( fd, buf, (unsigned int)numBytes );
}

ssize_t CcpWriteToFile( int fd, const void* buf, size_t numBytes )
{
	return write( fd, buf, (unsigned int)numBytes );
}

off_t CcpLseek( int fd, off_t offset, int whence )
{
	return lseek( fd, offset, whence );
}

off_t CcpTell( int fd )
{
	return lseek( fd, 0, SEEK_CUR );
}
#endif

bool CcpRenameFile( const std::wstring& src, const std::wstring& dst )
{
#ifdef _WIN32
	wchar_t srcBuffer[CCP_MAX_PATH];
	wchar_t dstBuffer[CCP_MAX_PATH];
	GetFullPathNameW( src.c_str(), CCP_MAX_PATH, srcBuffer, NULL );
	GetFullPathNameW( dst.c_str(), CCP_MAX_PATH, dstBuffer, NULL );

	if( !MoveFileW( srcBuffer, dstBuffer ) )
	{
		return false;
	}
#else
	if( rename( CW2A( src.c_str() ), CW2A( dst.c_str() ) ) )
	{
		return false;
	}
#endif
	return true;
}

#if defined(_WIN32)
#else
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <unistd.h>
#include <errno.h>
#ifdef __APPLE__
#include <mach-o/dyld.h>
#endif
#endif

#ifdef _WIN32
std::wstring CcpGetAbsolutePath( const std::wstring& name )
{
	std::wstring absName;
	wchar_t buffer[CCP_MAX_PATH];
	DWORD len = GetFullPathNameW( name.c_str(), CCP_MAX_PATH, buffer, NULL );
	if( len > 0 )
	{
		absName = buffer;
		std::replace( absName.begin(), absName.end(), L'\\', L'/' );
	}
	return absName;
}

// Returns true iff name is the path of an existing file.
bool CcpIsPathExistingFile(const std::wstring& name)
{
	DWORD attr = GetFileAttributesW(name.c_str());
	if (attr != INVALID_FILE_ATTRIBUTES)
	{
		return true;
	}

	return false;
}

// Returns true iff name is the path of an existing file.
// adjustedName is the absolute path to the file
bool CcpIsPathExistingFile( const std::wstring& name, std::wstring& absName )
{
	wchar_t buffer[CCP_MAX_PATH];
	DWORD len = GetFullPathNameW( name.c_str(), CCP_MAX_PATH, buffer, NULL );
	if( len > 0 )
	{
		absName = buffer;
		std::replace( absName.begin(), absName.end(), L'\\', L'/' );
		DWORD attr = GetFileAttributesW( buffer );
		if( attr != INVALID_FILE_ATTRIBUTES )
		{
			return true;
		}
	}

	return false;
}

bool CcpIsPathDirectory( const wchar_t* name )
{
	DWORD attr = GetFileAttributesW( name );
	if( attr == INVALID_FILE_ATTRIBUTES )
	{
		return false;
	}
	else
	{
		return (attr & FILE_ATTRIBUTE_DIRECTORY) != 0;
	}
}

bool CcpIsPathRelative( const wchar_t* name )
{
    return PathIsRelativeW( name ) != 0;
}

void CcpGetDirectoryContents( const std::wstring& candidate, std::set<std::wstring>& tmpResults )
{
	std::wstring folderWithWildcard = candidate;
	folderWithWildcard += L"\\*";
	WIN32_FIND_DATAW findFileData;
	HANDLE h = FindFirstFileW( folderWithWildcard.c_str(), &findFileData );
	if( h != INVALID_HANDLE_VALUE )
	{
		BOOL isMore = TRUE;
		do
		{
			bool isSpecial = (wcscmp( findFileData.cFileName, L"." ) == 0);
			isSpecial = isSpecial || (wcscmp( findFileData.cFileName, L".." ) == 0);
			if( !isSpecial )
			{
				std::wstring name = findFileData.cFileName;
				for( std::wstring::iterator it = name.begin(); it != name.end(); ++it )
				{
					*it = tolower( *it );
				}
				tmpResults.insert( name );
			}
			isMore = FindNextFileW( h, &findFileData );
		}
		while( isMore );
	}
}

std::wstring CcpGetCurrentWorkingDirectory()
{
	std::wstring result;

	wchar_t cwdBuffer[CCP_MAX_PATH];
	int cdRes = GetCurrentDirectoryW( CCP_MAX_PATH, cwdBuffer );
	if( cdRes > 0 )
	{
		result = cwdBuffer;
		std::replace( result.begin(), result.end(), L'\\', L'/' );
	}
	else
	{
		CCP_LOGERR( "Couldn't get current directory (%d, %d)", cdRes, GetLastError() );
	}
	return result;
}


void CcpRemoveFile( const std::wstring& filename )
{
	BOOL res = DeleteFileW( filename.c_str() );
	if(res == FALSE)
	{
		CCP_LOGERR("Couldn't delete file %S - %d", filename.c_str(), GetLastError());
	}
}

std::wstring CcpExecutablePath()
{
    std::vector<wchar_t> tmp(CCP_MAX_PATH);
    while( GetModuleFileNameW(NULL, &tmp[0], (DWORD)tmp.size()) == tmp.size() )
    {
        tmp.resize(tmp.size()*2);
    }
    return &tmp[0];
}

#else

namespace
{

void AbsPath( const char* path, char* realPath )
{
	char src[PATH_MAX];
	if( path[0] != '/' )
	{
		// If not an absolute path, we need to prepend current
		// working directory
		if( !getcwd( src, sizeof( src ) ) )
		{
			strcpy( realPath, path );
			return;
		}

		auto len = strlen( src );
		if( len > 0 && path[0] != 0 && src[len - 1] != '/' )
		{
			src[len] = '/';
			src[len + 1] = 0;
		}
		strcat( src, path );
	}
	else
	{
		strcpy( src, path );
	}

	// Collect leading slashes: there can be at most 2 of them.
	// All the others should be eaten up
	auto start = src;
	size_t initialSlashes = 0;
	while( *start == '/' )
	{
		++initialSlashes;
		++start;
		if( initialSlashes == 2 )
		{
			break;
		}
	}

	// Split the path by slashes
	auto end = start;
	std::vector<std::pair<char*, char*>> comps;
	while( true )
	{
		if( *end == '/' || *end == 0 )
		{
			// Empty comopnents (like in //) and . are ignored
			if( start != end && ( end - start != 1 || *start != '.' ) )
			{
				// If the component is .., pop the previous component
				if( end - start == 2 && start[0] == '.' && start[1] == '.' )
				{
					if( !comps.empty() )
					{
						comps.pop_back();
					}
				}
				else
				{
					comps.push_back( std::make_pair( start, end ) );
				}
			}
			if( *end == 0 )
			{
				break;
			}
			else
			{
				start = end + 1;
			}
		}
		++end;
	}

	// Put initial slashes back in
	end = realPath;
	for( size_t i = 0; i < initialSlashes; ++i )
	{
		*end = '/';
		++end;
	}

	// Join path components
	for( size_t i = 0; i < comps.size(); ++i )
	{
		if( i )
		{
			*end = '/';
			++end;
		}
		auto len = comps[i].second - comps[i].first;
		strncpy( end, comps[i].first, len );
		end += len;
	}
	*end = 0;
}

}

std::wstring CcpGetAbsolutePath( const std::wstring& name )
{
	if( name.empty() )
	{
		return L"";
	}
	auto nameA = CW2A( name.c_str() );
	char buffer[PATH_MAX];
	strcpy_s( buffer, nameA );
	AbsPath( CW2A( name.c_str() ), buffer );
    std::wstring absName = std::wstring( CA2W( buffer ) );
    if( CcpIsPathDirectory( absName.c_str() ) && !absName.empty() && absName[absName.length() - 1] != L'/' )
    {
        absName += L"/";
    }
    return absName;
}

void BreakPathIntoComponents( const std::string& path, std::vector<std::string>& components )
{
	size_t endPos = 0;
	size_t startPos = path.find_first_of( '/', endPos );
	if( startPos == std::string::npos )
	{
		components.push_back( path );
		return;
	}
	while( startPos != std::string::npos )
	{
		++startPos;
		endPos = path.find_first_of( '/', startPos );
		size_t len;
		if( endPos == std::string::npos )
		{
			len = endPos;
		}
		else
		{
			len = endPos - startPos;
		}
		std::string comp = path.substr( startPos, len );

		components.push_back( comp );
		startPos = endPos;
	} 
}

// Removes any '.' entries, and collapses '..' entries with the entry preceding it.
// For example, '/root/a/b/../.././c' becomes '/root/c'.
void CollapseRelativePaths( std::vector<std::string>& components )
{
	for( auto it = components.begin(); it != components.end(); )
	{
		if( *it == "." ) 
		{
			it = components.erase( it );
		}
		else
		{
			auto next = it + 1;
			if( next != components.end() )
			{
				if( *next == ".." )
				{
					components.erase( next );
					components.erase( it );
					it = components.begin();
				}
				else
				{
					++it;
				}
			}
			else
			{
				++it;
			}
		}
	}
}

void GetPossibleCasings( const std::string& path, const std::string& nextComponent, std::vector<std::string>& possibleCasings )
{
	DIR* dpdf = opendir( path.c_str() );

	if( dpdf )
	{
		struct dirent entry;
		struct dirent* result;
		int resultCode = readdir_r( dpdf, &entry, &result );
		while( (resultCode == 0) && result )
		{
			if( strcasecmp( nextComponent.c_str(), result->d_name ) == 0 )
			{
				possibleCasings.push_back( result->d_name );
			}
			resultCode = readdir_r( dpdf, &entry, &result );
		}

		closedir( dpdf );
	}
}

// Return value indicates whether search should continue or not.
// If true, continue searching.
// If false, searching is over. In this case, the result string contains the string if found, otherwise it is empty
// meaning the search was exhausted without finding a match.
bool FindCasingCorrectedPath( const std::string& path, const std::vector<std::string>& components, size_t compIx, std::string& result )
{
	std::vector<std::string> possibleCasings;
	GetPossibleCasings( path, components[compIx], possibleCasings );

	for( auto it = possibleCasings.begin(); it != possibleCasings.end(); ++it )
	{
		std::string candidate = path;
		if( compIx > 0 )
		{
			candidate += '/';
		}
		candidate += *it;

		if( compIx == components.size() - 1 )
		{
			// We're at a leaf node
			struct stat statData;
			int statResult = stat( candidate.c_str(), &statData );

			if( statResult == 0 )
			{
				result = candidate;
				return false;
			}
			else
			{
				return true;
			}
		}
		else		
		{
			bool isMore = FindCasingCorrectedPath( candidate, components, compIx + 1, result );
			if( !isMore )
			{
				return false;
			}
		}
	}

	// Returning true here to keep the search going - we want to force the search to all leaf nodes
	return true;
}

bool CcpIsPathExistingFile( const std::wstring& name, std::wstring& adjustedName )
{
	std::string nameA = (const char*)CW2A( name.c_str() );

	struct stat statData;
	int statResult = stat( nameA.c_str(), &statData );

	if( statResult != 0 )
	{
		// Path not found - try to correct casing
		std::vector<std::string> components;
		BreakPathIntoComponents( nameA, components );
		CollapseRelativePaths( components );

		std::string root = "/";
		std::string adjustedNameA;
		FindCasingCorrectedPath( root, components, 0, adjustedNameA );
		if( !adjustedNameA.empty() )
		{
			adjustedName = CA2W( adjustedNameA.c_str() );
			return true;
		}
		else
		{
			return false;
		}
	}
	else
	{
        adjustedName = name;
		return true;
	}
}

bool CcpIsPathExistingFile( const std::wstring& name )
{
	std::wstring adjustedName;
	return CcpIsPathExistingFile(name, adjustedName);
}

bool CcpIsPathDirectory( const wchar_t* name )
{
	std::string nameA = (const char*)CW2A( name );
	struct stat statData;
	int statResult = stat( nameA.c_str(), &statData );

	if( statResult == 0 )
	{
		return S_ISDIR( statData.st_mode );
	}
	else
	{
		return false;
	}
}

bool CcpIsPathRelative( const wchar_t* name )
{
    return name && name[0] != L'/';
}

void CcpGetDirectoryContents( const std::wstring& candidate, std::set<std::wstring>& tmpResults )
{
	std::string folderName = (const char*)CW2A( candidate.c_str() );
	DIR* dpdf = opendir( folderName.c_str() );

	if( dpdf )
	{
		struct dirent entry;
		struct dirent* result;
		int resultCode = readdir_r( dpdf, &entry, &result );
		while( (resultCode == 0) && result )
		{
			bool isSpecial = (strcmp( result->d_name, "." ) == 0);
			isSpecial = isSpecial || (strcmp( result->d_name, ".." ) == 0);
			if( !isSpecial )
			{
				std::wstring name = (const wchar_t*)CA2W( result->d_name );
				for( std::wstring::iterator it = name.begin(); it != name.end(); ++it )
				{
					*it = tolower( *it );
				}
				tmpResults.insert( name );
			}
			resultCode = readdir_r( dpdf, &entry, &result );
		}

		closedir( dpdf );
	}
}

std::wstring CcpGetCurrentWorkingDirectory()
{
	std::wstring result;

	static const int BUFFER_SIZE = 1024;
	char cwdBuffer[BUFFER_SIZE];
	if( getcwd( cwdBuffer, BUFFER_SIZE ) )
	{
		result = (const wchar_t*)CA2W( cwdBuffer );
	}
	else
	{
		CCP_LOGERR( "Couldn't get current directory (%d)", errno );
	}

	return result;
}


void CcpRemoveFile( const std::wstring& filename )
{
	std::string name = (const char*)CW2A( filename.c_str() );
	remove( name.c_str() );
}

std::wstring CcpExecutablePath()
{
#ifdef __APPLE__
    std::vector<char> tmp(CCP_MAX_PATH);
    uint32_t size = uint32_t( tmp.size() );
    if( _NSGetExecutablePath( &tmp[0], &size ) < 0 )
    {
        tmp.resize( size );
        _NSGetExecutablePath( &tmp[0], &size );
    }
    
    char actualpath [PATH_MAX];
    char* path = realpath(&tmp[0], actualpath);
    return std::wstring( CA2W( actualpath ) );
#else
    static_assert( false, "CcpExecutablePath is not implemented" );
#endif
}


#endif