/*++
Function:
GetSystemInfo
GetSystemInfo
The GetSystemInfo function returns information about the current system.
Parameters
lpSystemInfo
[out] Pointer to a SYSTEM_INFO structure that receives the information.
Return Values
This function does not return a value.
Note:
fields returned by this function are:
dwNumberOfProcessors
dwPageSize
Others are set to zero.
--*/
VOID
PALAPI
GetSystemInfo(
OUT LPSYSTEM_INFO lpSystemInfo)
{
int nrcpus = 0;
long pagesize;
PERF_ENTRY(GetSystemInfo);
ENTRY("GetSystemInfo (lpSystemInfo=%p)\n", lpSystemInfo);
pagesize = getpagesize();
lpSystemInfo->wProcessorArchitecture_PAL_Undefined = 0;
lpSystemInfo->wReserved_PAL_Undefined = 0;
lpSystemInfo->dwPageSize = pagesize;
lpSystemInfo->dwActiveProcessorMask_PAL_Undefined = 0;
#if HAVE_SYSCONF
#if defined(__hppa__) || ( defined (_IA64_) && defined (_HPUX_) )
struct pst_dynamic psd;
if (pstat_getdynamic(&psd, sizeof(psd), (size_t)1, 0) != -1) {
nrcpus = psd.psd_proc_cnt;
}
else {
ASSERT("pstat_getdynamic failed (%d)\n", errno);
}
#else // !__hppa__
nrcpus = sysconf(_SC_NPROCESSORS_ONLN);
if (nrcpus < 1)
{
ASSERT("sysconf failed for _SC_NPROCESSORS_ONLN (%d)\n", errno);
}
#endif // __hppa__
#elif HAVE_SYSCTL
int rc;
size_t sz;
int mib[2];
sz = sizeof(nrcpus);
mib[0] = CTL_HW;
mib[1] = HW_NCPU;
rc = sysctl(mib, 2, &nrcpus, &sz, NULL, 0);
if (rc != 0)
{
ASSERT("sysctl failed for HW_NCPU (%d)\n", errno);
}
#endif // HAVE_SYSCONF
TRACE("dwNumberOfProcessors=%d\n", nrcpus);
lpSystemInfo->dwNumberOfProcessors = nrcpus;
#ifdef VM_MAXUSER_ADDRESS
lpSystemInfo->lpMaximumApplicationAddress = (PVOID) VM_MAXUSER_ADDRESS;
#elif defined(__sun__) || defined(_AIX) || defined(__hppa__) || ( defined (_IA64_) && defined (_HPUX_) ) || defined(__LINUX__)
lpSystemInfo->lpMaximumApplicationAddress = (PVOID) -1;
#elif defined(USERLIMIT)
lpSystemInfo->lpMaximumApplicationAddress = (PVOID) USERLIMIT;
#elif defined(_WIN64)
#if defined(USRSTACK64)
lpSystemInfo->lpMaximumApplicationAddress = (PVOID) USRSTACK64;
#else // !USRSTACK64
#error How come USRSTACK64 is not defined for 64bit?
#endif // USRSTACK64
#elif defined(USRSTACK)
lpSystemInfo->lpMaximumApplicationAddress = (PVOID) USRSTACK;
#else
#error The maximum application address is not known on this platform.
#endif
lpSystemInfo->lpMinimumApplicationAddress = (PVOID) pagesize;
lpSystemInfo->dwProcessorType_PAL_Undefined = 0;
lpSystemInfo->dwAllocationGranularity = pagesize;
lpSystemInfo->wProcessorLevel_PAL_Undefined = 0;
lpSystemInfo->wProcessorRevision_PAL_Undefined = 0;
LOGEXIT("GetSystemInfo returns VOID\n");
PERF_EXIT(GetSystemInfo);
}
/*++
Function:
GetDiskFreeSpaceW
See MSDN doc.
--*/
PALIMPORT
BOOL
PALAPI
GetDiskFreeSpaceW(
LPCWSTR lpDirectoryName,
LPDWORD lpSectorsPerCluster,
LPDWORD lpBytesPerSector,
LPDWORD lpNumberOfFreeClusters, /* Caller will ignore output value */
LPDWORD lpTotalNumberOfClusters) /* Caller will ignore output value */
{
BOOL bRetVal = FALSE;
pal_statfs fsInfoBuffer;
INT statfsRetVal = 0;
DWORD dwLastError = NO_ERROR;
CHAR DirNameBuffer[ MAX_PATH ];
PERF_ENTRY(GetDiskFreeSpaceW);
ENTRY( "GetDiskFreeSpaceW( lpDirectoryName=%p (%S), lpSectorsPerCluster=%p,"
"lpBytesPerSector=%p, lpNumberOfFreeClusters=%p, "
"lpTotalNumberOfClusters=%p )\n", lpDirectoryName ? lpDirectoryName :
W16_NULLSTRING, lpDirectoryName ? lpDirectoryName :
W16_NULLSTRING, lpSectorsPerCluster, lpBytesPerSector,
lpNumberOfFreeClusters, lpTotalNumberOfClusters );
/* Sanity checks. */
if ( !lpSectorsPerCluster )
{
ERROR( "lpSectorsPerCluster cannot be NULL!\n" );
dwLastError = ERROR_INVALID_PARAMETER;
goto exit;
}
if ( !lpBytesPerSector )
{
ERROR( "lpBytesPerSector cannot be NULL!\n" );
dwLastError = ERROR_INVALID_PARAMETER;
goto exit;
}
if ( lpNumberOfFreeClusters || lpTotalNumberOfClusters )
{
TRACE("GetDiskFreeSpaceW is ignoring lpNumberOfFreeClusters"
" and lpTotalNumberOfClusters\n" );
}
if ( lpDirectoryName && PAL_wcslen( lpDirectoryName ) == 0 )
{
ERROR( "lpDirectoryName is empty.\n" );
dwLastError = ERROR_INVALID_PARAMETER;
goto exit;
}
/* Fusion uses this API to round file sizes up to their actual size
on-disk based on the BytesPerSector * SectorsPerCluster.
The intent is to avoid computing the sum of all file sizes in the
cache just in bytes and not account for the cluster-sized slop, when
determining if the cache is too large or not. */
if ( lpDirectoryName )
{
if ( WideCharToMultiByte( CP_ACP, 0, lpDirectoryName, -1,
DirNameBuffer,MAX_PATH, 0, 0 ) != 0 )
{
FILEDosToUnixPathA( DirNameBuffer );
statfsRetVal = statfs( DirNameBuffer, &fsInfoBuffer );
}
else
{
ASSERT( "Unable to convert the lpDirectoryName to multibyte.\n" );
dwLastError = ERROR_INTERNAL_ERROR;
goto exit;
}
}
else
{
statfsRetVal = statfs( "/", &fsInfoBuffer );
}
if ( statfsRetVal == 0 )
{
*lpBytesPerSector = fsInfoBuffer.f_bsize;
*lpSectorsPerCluster = 1;
bRetVal = TRUE;
}
else
{
if ( errno == ENOTDIR || errno == ENOENT )
{
FILEGetProperNotFoundError( DirNameBuffer, &dwLastError );
goto exit;
}
dwLastError = FILEGetLastErrorFromErrno();
if ( ERROR_INTERNAL_ERROR == dwLastError )
{
ASSERT("statfs() not expected to fail with errno:%d (%s)\n",
errno, strerror(errno));
}
else
{
TRACE("statfs() failed, errno:%d (%s)\n", errno, strerror(errno));
}
}
exit:
if ( NO_ERROR != dwLastError )
{
SetLastError( dwLastError );
}
LOGEXIT( "GetDiskFreeSpace returning %s.\n", bRetVal == TRUE ? "TRUE" : "FALSE" );
PERF_EXIT(GetDiskFreeSpaceW);
return bRetVal;
}
/*++
Function:
FormatMessageW
See MSDN doc.
--*/
DWORD
PALAPI
FormatMessageW(
IN DWORD dwFlags,
IN LPCVOID lpSource,
IN DWORD dwMessageId,
IN DWORD dwLanguageId,
OUT LPWSTR lpBuffer,
IN DWORD nSize,
IN va_list *Arguments)
{
BOOL bIgnoreInserts = FALSE;
BOOL bIsVaList = TRUE;
BOOL bIsLocalAlloced = FALSE;
LPWSTR lpSourceString = NULL;
UINT nCount = 0;
LPWSTR lpReturnString = NULL;
LPWSTR lpWorkingString = NULL;
PERF_ENTRY(FormatMessageW);
ENTRY( "FormatMessageW(dwFlags=%#x, lpSource=%p, dwMessageId=%#x, "
"dwLanguageId=%#x, lpBuffer=%p, nSize=%u, va_list=%p)\n",
dwFlags, lpSource, dwMessageId, dwLanguageId, lpBuffer, nSize,
Arguments);
/* Sanity checks. */
if ( dwFlags & FORMAT_MESSAGE_FROM_STRING && !lpSource )
{
/* This behavior is different then in Windows.
Windows would just crash.*/
ERROR( "lpSource cannot be NULL.\n" );
SetLastError( ERROR_INVALID_PARAMETER );
goto exit;
}
if ( !(dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER ) && !lpBuffer )
{
/* This behavior is different then in Windows.
Windows would just crash.*/
ERROR( "lpBuffer cannot be NULL, if "
" FORMAT_MESSAGE_ALLOCATE_BUFFER is not specified.\n" );
SetLastError( ERROR_INVALID_PARAMETER );
goto exit;
}
if ( ( dwFlags & FORMAT_MESSAGE_FROM_STRING ) &&
( dwFlags & FORMAT_MESSAGE_FROM_SYSTEM ) )
{
ERROR( "These flags cannot co-exist. You can either "
"specify FORMAT_MESSAGE_FROM_STRING, or "
"FORMAT_MESSAGE_FROM_SYSTEM.\n" );
SetLastError( ERROR_INVALID_PARAMETER );
goto exit;
}
if ( !( dwFlags & FORMAT_MESSAGE_FROM_STRING ) &&
( dwLanguageId != 0
#if ENABLE_DOWNLEVEL_FOR_NLS
&& dwLanguageId != MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT )
#endif
) )
{
ERROR( "Invalid language indentifier.\n" );
SetLastError( ERROR_RESOURCE_LANG_NOT_FOUND );
goto exit;
}
/* Parameter processing. */
if ( dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER )
{
TRACE( "Allocated %d TCHARs. Don't forget to call LocalFree to "
"free the memory when done.\n", nSize );
bIsLocalAlloced = TRUE;
}
if ( dwFlags & FORMAT_MESSAGE_IGNORE_INSERTS )
{
bIgnoreInserts = TRUE;
}
if ( dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY )
{
if ( !Arguments && !bIgnoreInserts )
{
ERROR( "The va_list cannot be NULL.\n" );
SetLastError( ERROR_INVALID_PARAMETER );
goto exit;
}
else
{
bIsVaList = FALSE;
}
}
if ( dwFlags & FORMAT_MESSAGE_FROM_STRING )
{
lpSourceString = (LPWSTR)lpSource;
}
else if ( dwFlags & FORMAT_MESSAGE_FROM_SYSTEM )
{
if ((dwMessageId & 0xFFFF0000) == 0x80070000)
{
// This message has been produced by HRESULT_FROM_WIN32. Undo its work.
dwMessageId &= 0xFFFF;
}
lpWorkingString = lpReturnString =
FMTMSG_GetMessageString( dwMessageId );
if ( !lpWorkingString )
{
ERROR( "Unable to find the message %d.\n", dwMessageId );
SetLastError( ERROR_INTERNAL_ERROR );
nCount = 0;
goto exit;
}
nCount = PAL_wcslen( lpWorkingString );
if ( !bIsLocalAlloced && nCount > nSize )
{
ERROR( "Insufficient buffer.\n" );
SetLastError( ERROR_INSUFFICIENT_BUFFER );
lpWorkingString = NULL;
nCount = 0;
goto exit;
}
if ( !lpWorkingString )
{
ERROR( "Invalid error indentifier.\n" );
SetLastError( ERROR_INVALID_ADDRESS );
}
goto exit;
}
else
{
ERROR( "Unknown flag.\n" );
SetLastError( ERROR_INVALID_PARAMETER );
goto exit;
}
if ( nSize == 0 && bIsLocalAlloced )
{
nSize = 1;
}
lpWorkingString = static_cast<WCHAR *>(
LocalAlloc( LMEM_FIXED, nSize * sizeof( WCHAR ) ) );
if ( !lpWorkingString )
{
ERROR( "Unable to allocate memory for the working string.\n" );
SetLastError( ERROR_INSUFFICIENT_BUFFER );
goto exit;
}
/* Process the string. */
lpReturnString = lpWorkingString;
while ( *lpSourceString )
{
if ( *lpSourceString == '%' && !bIgnoreInserts )
{
lpSourceString++;
/* Escape sequences. */
if ( *lpSourceString == '0' )
{
/* Terminates a message without a newline character. */
*lpWorkingString = '\0';
goto exit;
}
else if ( PAL_iswdigit( *lpSourceString ) )
{
/* Get the insert number. */
WCHAR Number[] = { '\0', '\0', '\0' };
SIZE_T Index = 0;
Number[ 0 ] = *lpSourceString;
lpSourceString++;
if ( PAL_iswdigit( *lpSourceString ) )
{
Number[ 1 ] = *lpSourceString;
lpSourceString++;
if ( PAL_iswdigit( *lpSourceString ) )
{
ERROR( "Invalid insert indentifier.\n" );
SetLastError( ERROR_INVALID_PARAMETER );
lpWorkingString = NULL;
nCount = 0;
goto exit;
}
}
Index = FMTMSG__watoi( Number );
if ( Index == 0 )
{
ERROR( "Invalid insert indentifier.\n" );
SetLastError( ERROR_INVALID_PARAMETER );
lpWorkingString = NULL;
nCount = 0;
goto exit;
}
if ( *lpSourceString == '!' )
{
LPWSTR lpInsertString = NULL;
LPWSTR lpPrintfString = NULL;
LPWSTR lpStartOfFormattedString = NULL;
UINT nPrintfLength = 0;
LPWSTR lpFormattedString = NULL;
UINT nFormattedLength = 0;
if ( !bIsVaList )
{
lpInsertString = ((LPWSTR*)Arguments)[ Index - 1 ];
}
else
{
va_list TheArgs;
va_copy(TheArgs, *Arguments);
UINT i = 0;
for ( ; i < Index; i++ )
{
lpInsertString = va_arg( TheArgs, LPWSTR );
}
}
/* Calculate the length, and extract the printf string.*/
lpSourceString++;
{
LPWSTR p = PAL_wcschr( lpSourceString, '!' );
if ( NULL == p )
{
nPrintfLength = 0;
}
else
{
nPrintfLength = p - lpSourceString;
}
}
lpPrintfString =
(LPWSTR)PAL_malloc( ( nPrintfLength + 1 ) * sizeof( WCHAR ) );
if ( !lpPrintfString )
{
ERROR( "Unable to allocate memory.\n" );
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
lpWorkingString = NULL;
nCount = 0;
goto exit;
}
PAL_wcsncpy( lpPrintfString, lpSourceString, nPrintfLength );
*( lpPrintfString + nPrintfLength ) = '\0';
lpStartOfFormattedString = lpFormattedString =
FMTMSG_ProcessPrintf( *lpPrintfString,
lpPrintfString,
lpInsertString);
if ( !lpFormattedString )
{
ERROR( "Unable to process the format string.\n" );
/* Function will set the error code. */
PAL_free( lpPrintfString );
lpWorkingString = NULL;
goto exit;
}
nFormattedLength = PAL_wcslen( lpFormattedString );
/* Append the processed printf string into the working string */
while ( *lpFormattedString )
{
_CHECKED_ADD_TO_STRING( *lpFormattedString );
lpFormattedString++;
}
lpSourceString += nPrintfLength + 1;
PAL_free( lpPrintfString );
PAL_free( lpStartOfFormattedString );
lpPrintfString = lpFormattedString = NULL;
}
else
{
/* The printf format string defaults to 's'.*/
LPWSTR lpInsert = NULL;
if ( !bIsVaList )
{
lpInsert = ((LPWSTR*)Arguments)[Index - 1];
}
else
{
va_list TheArgs;
va_copy(TheArgs, *Arguments);
UINT i = 0;
for ( ; i < Index; i++ )
{
lpInsert = va_arg( TheArgs, LPWSTR );
}
}
while ( *lpInsert )
{
_CHECKED_ADD_TO_STRING( *lpInsert );
lpInsert++;
}
}
}
/* Format specifiers. */
else if ( *lpSourceString == '%' )
{
_CHECKED_ADD_TO_STRING( '%' );
lpSourceString++;
}
else if ( *lpSourceString == 'n' )
{
/* Hard line break. */
_CHECKED_ADD_TO_STRING( '\n' );
lpSourceString++;
}
else if ( *lpSourceString == '.' )
{
_CHECKED_ADD_TO_STRING( '.' );
lpSourceString++;
}
else if ( *lpSourceString == '!' )
{
_CHECKED_ADD_TO_STRING( '!' );
lpSourceString++;
}
else if ( !*lpSourceString )
{
ERROR( "Invalid parameter.\n" );
SetLastError( ERROR_INVALID_PARAMETER );
lpWorkingString = NULL;
nCount = 0;
goto exit;
}
else /* Append the character. */
{
_CHECKED_ADD_TO_STRING( *lpSourceString );
lpSourceString++;
}
}/* END if ( *lpSourceString == '%' ) */
else
{
/* In Windows if FormatMessage is called with ignore inserts,
then FormatMessage strips %1!s! down to %1, since string is the
default. */
if ( bIgnoreInserts && *lpSourceString == '!' &&
*( lpSourceString + 1 ) == 's' )
{
LPWSTR lpLastBang = PAL_wcschr( lpSourceString + 1, '!' );
if ( lpLastBang && ( 2 == lpLastBang - lpSourceString ) )
{
lpSourceString = lpLastBang + 1;
}
else
{
ERROR( "Mal-formed string\n" );
SetLastError( ERROR_INVALID_PARAMETER );
lpWorkingString = NULL;
nCount = 0;
goto exit;
}
}
else
{
/* Append to the string. */
_CHECKED_ADD_TO_STRING( *lpSourceString );
lpSourceString++;
}
}
}
/* Terminate the message. */
_CHECKED_ADD_TO_STRING( '\0' );
/* NULL does not count. */
nCount--;
exit: /* Function clean-up and exit. */
if ( lpWorkingString )
{
if ( bIsLocalAlloced )
{
TRACE( "Assigning the buffer to the pointer.\n" );
// when FORMAT_MESSAGE_ALLOCATE_BUFFER is specified, nSize
// does not specify the size of lpBuffer, rather it specifies
// the minimum size of the string
// as such we have to blindly assume that lpBuffer has enough space to
// store PVOID
// might cause a prefast warning, but there is no good way to suppress it yet
_ASSERTE(dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER);
*((LPVOID*)lpBuffer) = (LPVOID)lpReturnString;
}
else /* Only delete lpReturnString if the caller has their own buffer.*/
{
TRACE( "Copying the string into the buffer.\n" );
PAL_wcsncpy( lpBuffer, lpReturnString, nCount + 1 );
LocalFree( lpReturnString );
}
}
else /* Error, something occurred. */
{
if ( lpReturnString )
{
LocalFree( lpReturnString );
}
}
LOGEXIT( "FormatMessageW returns %d.\n", nCount );
PERF_EXIT(FormatMessageW);
return nCount;
}
/*++
Function:
CreateDirectoryA
Note:
lpSecurityAttributes always NULL.
See MSDN doc.
--*/
BOOL
PALAPI
CreateDirectoryA(
IN LPCSTR lpPathName,
IN LPSECURITY_ATTRIBUTES lpSecurityAttributes)
{
BOOL bRet = FALSE;
DWORD dwLastError = 0;
char *realPath;
LPSTR UnixPathName = NULL;
int pathLength;
int i;
const int mode = S_IRWXU | S_IRWXG | S_IRWXO;
PERF_ENTRY(CreateDirectoryA);
ENTRY("CreateDirectoryA(lpPathName=%p (%s), lpSecurityAttr=%p)\n",
lpPathName?lpPathName:"NULL",
lpPathName?lpPathName:"NULL", lpSecurityAttributes);
if ( lpSecurityAttributes )
{
ASSERT("lpSecurityAttributes is not NULL as it should be\n");
dwLastError = ERROR_INVALID_PARAMETER;
goto done;
}
// Windows returns ERROR_PATH_NOT_FOUND when called with NULL.
// If we don't have this check, strdup(NULL) segfaults.
if (lpPathName == NULL)
{
ERROR("CreateDirectoryA called with NULL pathname!\n");
dwLastError = ERROR_PATH_NOT_FOUND;
goto done;
}
UnixPathName = PAL__strdup(lpPathName);
if (UnixPathName == NULL )
{
ERROR("PAL__strdup() failed\n");
dwLastError = ERROR_NOT_ENOUGH_MEMORY;
goto done;
}
FILEDosToUnixPathA( UnixPathName );
// Remove any trailing slashes at the end because mkdir might not
// handle them appropriately on all platforms.
pathLength = strlen(UnixPathName);
i = pathLength;
while(i > 1)
{
if(UnixPathName[i - 1] =='/')
{
UnixPathName[i - 1]='\0';
i--;
}
else
{
break;
}
}
// Check the constraint for the real path length (should be < MAX_LONGPATH).
// Get an absolute path.
if (UnixPathName[0] == '/')
{
realPath = UnixPathName;
}
else
{
const char *cwd = PAL__getcwd(NULL, MAX_LONGPATH);
if (NULL == cwd)
{
WARN("Getcwd failed with errno=%d [%s]\n", errno, strerror(errno));
dwLastError = DIRGetLastErrorFromErrno();
goto done;
}
// Copy cwd, '/', path
int iLen = strlen(cwd) + 1 + pathLength + 1;
realPath = static_cast<char *>(alloca(iLen));
sprintf_s(realPath, iLen, "%s/%s", cwd, UnixPathName);
PAL_free((char *)cwd);
}
// Canonicalize the path so we can determine its length.
FILECanonicalizePath(realPath);
if (strlen(realPath) >= MAX_LONGPATH)
{
WARN("UnixPathName is larger than MAX_LONGPATH (%d)!\n", MAX_LONGPATH);
dwLastError = ERROR_FILENAME_EXCED_RANGE;
goto done;
}
if ( mkdir(realPath, mode) != 0 )
{
TRACE("Creation of directory [%s] was unsuccessful, errno = %d.\n",
UnixPathName, errno);
switch( errno )
{
case ENOTDIR:
/* FALL THROUGH */
case ENOENT:
FILEGetProperNotFoundError( realPath, &dwLastError );
goto done;
case EEXIST:
dwLastError = ERROR_ALREADY_EXISTS;
break;
default:
dwLastError = ERROR_ACCESS_DENIED;
}
}
else
{
TRACE("Creation of directory [%s] was successful.\n", UnixPathName);
bRet = TRUE;
}
done:
if( dwLastError )
{
SetLastError( dwLastError );
}
PAL_free( UnixPathName );
LOGEXIT("CreateDirectoryA returns BOOL %d\n", bRet);
PERF_EXIT(CreateDirectoryA);
return bRet;
}
/*++
Function:
SetCurrentDirectoryA
See MSDN doc.
--*/
BOOL
PALAPI
SetCurrentDirectoryA(
IN LPCSTR lpPathName)
{
BOOL bRet = FALSE;
DWORD dwLastError = 0;
int result;
LPSTR UnixPathName = NULL;
PERF_ENTRY(SetCurrentDirectoryA);
ENTRY("SetCurrentDirectoryA(lpPathName=%p (%s))\n",
lpPathName?lpPathName:"NULL",
lpPathName?lpPathName:"NULL");
/*check if the given path is null. If so
return FALSE*/
if (lpPathName == NULL )
{
ERROR("Invalid path/directory name\n");
dwLastError = ERROR_INVALID_NAME;
goto done;
}
if (strlen(lpPathName) >= MAX_LONGPATH)
{
WARN("Path/directory name longer than MAX_LONGPATH characters\n");
dwLastError = ERROR_FILENAME_EXCED_RANGE;
goto done;
}
UnixPathName = PAL__strdup(lpPathName);
if (UnixPathName == NULL )
{
ERROR("PAL__strdup() failed\n");
dwLastError = ERROR_NOT_ENOUGH_MEMORY;
goto done;
}
FILEDosToUnixPathA( UnixPathName );
TRACE("Attempting to open Unix dir [%s]\n", UnixPathName);
result = chdir(UnixPathName);
if ( result == 0 )
{
bRet = TRUE;
}
else
{
if ( errno == ENOTDIR || errno == ENOENT )
{
struct stat stat_data;
if ( stat( UnixPathName, &stat_data) == 0 &&
(stat_data.st_mode & S_IFMT) == S_IFREG )
{
/* Not a directory, it is a file. */
dwLastError = ERROR_DIRECTORY;
}
else
{
FILEGetProperNotFoundError( UnixPathName, &dwLastError );
}
TRACE("chdir() failed, path was invalid.\n");
}
else
{
dwLastError = ERROR_ACCESS_DENIED;
ERROR("chdir() failed; errno is %d (%s)\n", errno, strerror(errno));
}
}
done:
if( dwLastError )
{
SetLastError(dwLastError);
}
if(UnixPathName != NULL)
{
PAL_free( UnixPathName );
}
LOGEXIT("SetCurrentDirectoryA returns BOOL %d\n", bRet);
PERF_EXIT(SetCurrentDirectoryA);
return bRet;
}
/*++
Function:
RemoveDirectoryW
See MSDN doc.
--*/
BOOL
PALAPI
RemoveDirectoryW(
IN LPCWSTR lpPathName)
{
PathCharString mb_dirPathString;
int mb_size;
DWORD dwLastError = 0;
BOOL bRet = FALSE;
size_t length;
char * mb_dir;
PERF_ENTRY(RemoveDirectoryW);
ENTRY("RemoveDirectoryW(lpPathName=%p (%S))\n",
lpPathName?lpPathName:W16_NULLSTRING,
lpPathName?lpPathName:W16_NULLSTRING);
if (lpPathName == NULL)
{
dwLastError = ERROR_PATH_NOT_FOUND;
goto done;
}
length = (PAL_wcslen(lpPathName)+1) * 3;
mb_dir = mb_dirPathString.OpenStringBuffer(length);
if (NULL == mb_dir)
{
dwLastError = ERROR_NOT_ENOUGH_MEMORY;
goto done;
}
mb_size = WideCharToMultiByte( CP_ACP, 0, lpPathName, -1, mb_dir, length,
NULL, NULL );
mb_dirPathString.CloseBuffer(mb_size);
if( mb_size == 0 )
{
dwLastError = GetLastError();
if( dwLastError == ERROR_INSUFFICIENT_BUFFER )
{
WARN("lpPathName is larger than MAX_LONGPATH (%d)!\n", MAX_LONGPATH);
dwLastError = ERROR_FILENAME_EXCED_RANGE;
}
else
{
ASSERT("WideCharToMultiByte failure! error is %d\n", dwLastError);
dwLastError = ERROR_INTERNAL_ERROR;
}
goto done;
}
if ((bRet = RemoveDirectoryHelper (mb_dir, &dwLastError)))
{
TRACE("Removal of directory [%s] was successful.\n", mb_dir);
}
done:
if( dwLastError )
{
SetLastError( dwLastError );
}
LOGEXIT("RemoveDirectoryW returns BOOL %d\n", bRet);
PERF_EXIT(RemoveDirectoryW);
return bRet;
}
/*++
Function:
SetCurrentDirectoryW
See MSDN doc.
--*/
BOOL
PALAPI
SetCurrentDirectoryW(
IN LPCWSTR lpPathName)
{
BOOL bRet;
DWORD dwLastError = 0;
PathCharString dirPathString;
int size;
size_t length;
char * dir;
PERF_ENTRY(SetCurrentDirectoryW);
ENTRY("SetCurrentDirectoryW(lpPathName=%p (%S))\n",
lpPathName?lpPathName:W16_NULLSTRING,
lpPathName?lpPathName:W16_NULLSTRING);
/*check if the given path is null. If so
return FALSE*/
if (lpPathName == NULL )
{
ERROR("Invalid path/directory name\n");
dwLastError = ERROR_INVALID_NAME;
bRet = FALSE;
goto done;
}
length = (PAL_wcslen(lpPathName)+1) * 3;
dir = dirPathString.OpenStringBuffer(length);
if (NULL == dir)
{
dwLastError = ERROR_NOT_ENOUGH_MEMORY;
bRet = FALSE;
goto done;
}
size = WideCharToMultiByte( CP_ACP, 0, lpPathName, -1, dir, length,
NULL, NULL );
dirPathString.CloseBuffer(size);
if( size == 0 )
{
dwLastError = GetLastError();
if( dwLastError == ERROR_INSUFFICIENT_BUFFER )
{
WARN("lpPathName is larger than MAX_LONGPATH (%d)!\n", MAX_LONGPATH);
dwLastError = ERROR_FILENAME_EXCED_RANGE;
}
else
{
ASSERT("WideCharToMultiByte failure! error is %d\n", dwLastError);
dwLastError = ERROR_INTERNAL_ERROR;
}
bRet = FALSE;
goto done;
}
bRet = SetCurrentDirectoryA(dir);
done:
if( dwLastError )
{
SetLastError(dwLastError);
}
LOGEXIT("SetCurrentDirectoryW returns BOOL %d\n", bRet);
PERF_EXIT(SetCurrentDirectoryW);
return bRet;
}
/*++
Function:
GetTempPathA
See MSDN.
Notes:
On Windows, the temp path is determined by the following steps:
1. The value of the "TMP" environment variable, or if it doesn't exist,
2. The value of the "TEMP" environment variable, or if it doesn't exist,
3. The Windows directory.
On Unix, we follow in spirit:
1. The value of the "TMPDIR" environment variable, or if it doesn't exist,
2. The /tmp directory.
This is the same approach employed by mktemp.
--*/
DWORD
PALAPI
GetTempPathA(
IN DWORD nBufferLength,
OUT LPSTR lpBuffer)
{
DWORD dwPathLen = 0;
PERF_ENTRY(GetTempPathA);
ENTRY("GetTempPathA(nBufferLength=%u, lpBuffer=%p)\n",
nBufferLength, lpBuffer);
if ( !lpBuffer )
{
ERROR( "lpBuffer was not a valid pointer.\n" )
SetLastError( ERROR_INVALID_PARAMETER );
LOGEXIT("GetTempPathA returns DWORD %u\n", dwPathLen);
PERF_EXIT(GetTempPathA);
return 0;
}
/* Try the TMPDIR environment variable. This is the same env var checked by mktemp. */
dwPathLen = GetEnvironmentVariableA("TMPDIR", lpBuffer, nBufferLength);
if (dwPathLen > 0)
{
/* The env var existed. dwPathLen will be the length without null termination
* if the entire value was successfully retrieved, or it'll be the length
* required to store the value with null termination.
*/
if (dwPathLen < nBufferLength)
{
/* The environment variable fit in the buffer. Make sure it ends with '/'. */
if (lpBuffer[dwPathLen - 1] != '/')
{
/* If adding the slash would still fit in our provided buffer, do it. Otherwise,
* let the caller know how much space would be needed.
*/
if (dwPathLen + 2 <= nBufferLength)
{
lpBuffer[dwPathLen++] = '/';
lpBuffer[dwPathLen] = '\0';
}
else
{
dwPathLen += 2;
}
}
}
else /* dwPathLen >= nBufferLength */
{
/* The value is too long for the supplied buffer. dwPathLen will now be the
* length required to hold the value, but we don't know whether that value
* is going to be '/' terminated. Since we'll need enough space for the '/', and since
* a caller would assume that the dwPathLen we return will be sufficient,
* we make sure to account for it in dwPathLen even if that means we end up saying
* one more byte of space is needed than actually is.
*/
dwPathLen++;
}
}
else /* env var not found or was empty */
{
/* no luck, use /tmp/ */
const char *defaultDir = "/tmp/";
int defaultDirLen = strlen(defaultDir);
if (defaultDirLen < nBufferLength)
{
dwPathLen = defaultDirLen;
strcpy_s(lpBuffer, nBufferLength, defaultDir);
}
else
{
/* get the required length */
dwPathLen = defaultDirLen + 1;
}
}
if ( dwPathLen >= nBufferLength )
{
ERROR("Buffer is too small, need space for %d characters including null termination\n", dwPathLen);
SetLastError( ERROR_INSUFFICIENT_BUFFER );
}
LOGEXIT("GetTempPathA returns DWORD %u\n", dwPathLen);
PERF_EXIT(GetTempPathA);
return dwPathLen;
}
/*++
Function:
GetFullPathNameA
See MSDN doc.
--*/
DWORD
PALAPI
GetFullPathNameA(
IN LPCSTR lpFileName,
IN DWORD nBufferLength,
OUT LPSTR lpBuffer,
OUT LPSTR *lpFilePart)
{
DWORD nReqPathLen, nRet = 0;
LPSTR lpUnixPath = NULL;
BOOL fullPath = FALSE;
PERF_ENTRY(GetFullPathNameA);
ENTRY("GetFullPathNameA(lpFileName=%p (%s), nBufferLength=%u, lpBuffer=%p, "
"lpFilePart=%p)\n",
lpFileName?lpFileName:"NULL",
lpFileName?lpFileName:"NULL", nBufferLength, lpBuffer, lpFilePart);
if(NULL == lpFileName)
{
WARN("lpFileName is NULL\n");
SetLastError(ERROR_INVALID_PARAMETER);
goto done;
}
/* find out if lpFileName is a partial or full path */
if ('\\' == *lpFileName || '/' == *lpFileName)
{
fullPath = TRUE;
}
if(fullPath)
{
lpUnixPath = PAL__strdup( lpFileName );
if(NULL == lpUnixPath)
{
ERROR("strdup() failed; error is %d (%s)\n",
errno, strerror(errno));
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto done;
}
}
else
{
size_t max_len;
/* allocate memory for full non-canonical path */
max_len = strlen(lpFileName)+1; /* 1 for the slash to append */
max_len += MAX_LONGPATH + 1;
lpUnixPath = (LPSTR)PAL_malloc(max_len);
if(NULL == lpUnixPath)
{
ERROR("PAL_malloc() failed; error is %d (%s)\n",
errno, strerror(errno));
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto done;
}
/* build full path */
if(!GetCurrentDirectoryA(MAX_LONGPATH + 1, lpUnixPath))
{
/* no reason for this to fail now... */
ASSERT("GetCurrentDirectoryA() failed! lasterror is %#xd\n",
GetLastError());
SetLastError(ERROR_INTERNAL_ERROR);
goto done;
}
if (strcat_s(lpUnixPath, max_len, "/") != SAFECRT_SUCCESS)
{
ERROR("strcat_s failed!\n");
SetLastError(ERROR_FILENAME_EXCED_RANGE);
goto done;
}
if (strcat_s(lpUnixPath, max_len, lpFileName) != SAFECRT_SUCCESS)
{
ERROR("strcat_s failed!\n");
SetLastError(ERROR_FILENAME_EXCED_RANGE);
goto done;
}
}
/* do conversion to Unix path */
FILEDosToUnixPathA( lpUnixPath );
/* now we can canonicalize this */
FILECanonicalizePath(lpUnixPath);
/* at last, we can figure out how long this path is */
nReqPathLen = strlen(lpUnixPath)+1;
if(nBufferLength < nReqPathLen)
{
TRACE("reporting insufficient buffer : minimum is %d, caller "
"provided %d\n", nReqPathLen, nBufferLength);
nRet = nReqPathLen;
goto done;
}
nRet = nReqPathLen-1;
strcpy_s(lpBuffer, nBufferLength, lpUnixPath);
/* locate the filename component if caller cares */
if(lpFilePart)
{
*lpFilePart = strrchr(lpBuffer, '/');
if (*lpFilePart == NULL)
{
ASSERT("Not able to find '/' in the full path.\n");
SetLastError( ERROR_INTERNAL_ERROR );
nRet = 0;
goto done;
}
else
{
(*lpFilePart)++;
}
}
done:
PAL_free (lpUnixPath);
LOGEXIT("GetFullPathNameA returns DWORD %u\n", nRet);
PERF_EXIT(GetFullPathNameA);
return nRet;
}
/*++
Function:
GetFullPathNameW
See MSDN doc.
--*/
DWORD
PALAPI
GetFullPathNameW(
IN LPCWSTR lpFileName,
IN DWORD nBufferLength,
OUT LPWSTR lpBuffer,
OUT LPWSTR *lpFilePart)
{
LPSTR fileNameA;
/* bufferA needs to be able to hold a path that's potentially as
large as MAX_PATH WCHARs. */
CHAR bufferA[MAX_LONGPATH * sizeof(WCHAR)];
LPSTR lpFilePartA;
int fileNameLength;
int srcSize;
DWORD length;
DWORD nRet = 0;
PERF_ENTRY(GetFullPathNameW);
ENTRY("GetFullPathNameW(lpFileName=%p (%S), nBufferLength=%u, lpBuffer=%p"
", lpFilePart=%p)\n",
lpFileName?lpFileName:W16_NULLSTRING,
lpFileName?lpFileName:W16_NULLSTRING, nBufferLength,
lpBuffer, lpFilePart);
/* Find the number of bytes required to convert lpFileName
to ANSI. This may be more than MAX_PATH. We try to
handle that case, since it may be less than MAX_PATH
WCHARs. */
fileNameLength = WideCharToMultiByte(CP_ACP, 0, lpFileName,
-1, NULL, 0, NULL, NULL);
if (fileNameLength == 0)
{
/* Couldn't convert to ANSI. That's odd. */
SetLastError(ERROR_INVALID_PARAMETER);
goto done;
}
else
{
fileNameA = static_cast<LPSTR>(alloca(fileNameLength));
}
/* Now convert lpFileName to ANSI. */
srcSize = WideCharToMultiByte (CP_ACP, 0, lpFileName,
-1, fileNameA, fileNameLength,
NULL, NULL );
if( srcSize == 0 )
{
DWORD dwLastError = GetLastError();
if( dwLastError == ERROR_INSUFFICIENT_BUFFER )
{
ERROR("lpFileName is larger than MAX_LONGPATH (%d)!\n", MAX_LONGPATH);
}
else
{
ASSERT("WideCharToMultiByte failure! error is %d\n", dwLastError);
}
SetLastError(ERROR_INVALID_PARAMETER);
goto done;
}
length = GetFullPathNameA(fileNameA, sizeof(bufferA), bufferA, &lpFilePartA);
if (length == 0 || length > sizeof(bufferA))
{
/* Last error is set by GetFullPathNameA */
nRet = length;
goto done;
}
/* Convert back to Unicode the result */
nRet = MultiByteToWideChar( CP_ACP, 0, bufferA, -1,
lpBuffer, nBufferLength );
if (nRet == 0)
{
if ( GetLastError() == ERROR_INSUFFICIENT_BUFFER )
{
/* get the required length */
nRet = MultiByteToWideChar( CP_ACP, 0, bufferA, -1,
NULL, 0 );
SetLastError(ERROR_BUFFER_OVERFLOW);
}
goto done;
}
/* MultiByteToWideChar counts the trailing NULL, but
GetFullPathName does not. */
nRet--;
/* now set lpFilePart */
if (lpFilePart != NULL)
{
*lpFilePart = lpBuffer;
*lpFilePart += MultiByteToWideChar( CP_ACP, 0, bufferA,
lpFilePartA - bufferA, NULL, 0);
}
done:
LOGEXIT("GetFullPathNameW returns DWORD %u\n", nRet);
PERF_EXIT(GetFullPathNameW);
return nRet;
}
/*++
Function:
SearchPathW
See MSDN doc.
PAL-specific notes :
-lpPath must be non-NULL; path delimiters are platform-dependent (':' for Unix)
-lpFileName must be non-NULL, may be an absolute path
-lpExtension must be NULL
-lpFilePart (if non-NULL) doesn't need to be used (but we do)
--*/
DWORD
PALAPI
SearchPathW(
IN LPCWSTR lpPath,
IN LPCWSTR lpFileName,
IN LPCWSTR lpExtension,
IN DWORD nBufferLength,
OUT LPWSTR lpBuffer,
OUT LPWSTR *lpFilePart
)
{
DWORD nRet = 0;
WCHAR FullPath[MAX_PATH];
LPCWSTR pPathStart;
LPCWSTR pPathEnd;
size_t PathLength;
size_t FileNameLength;
DWORD dw;
char AnsiPath[MAX_PATH];
WCHAR CanonicalPath[MAX_PATH];
PERF_ENTRY(SearchPathW);
ENTRY("SearchPathW(lpPath=%p (%S), lpFileName=%p (%S), lpExtension=%p, "
"nBufferLength=%u, lpBuffer=%p, lpFilePart=%p)\n",
lpPath,
lpPath, lpFileName, lpFileName, lpExtension, nBufferLength, lpBuffer,
lpFilePart);
/* validate parameters */
if(NULL == lpPath)
{
ASSERT("lpPath may not be NULL\n");
SetLastError(ERROR_INVALID_PARAMETER);
goto done;
}
if(NULL == lpFileName)
{
ASSERT("lpFileName may not be NULL\n");
SetLastError(ERROR_INVALID_PARAMETER);
goto done;
}
if(NULL != lpExtension)
{
ASSERT("lpExtension must be NULL, is %p instead\n", lpExtension);
SetLastError(ERROR_INVALID_PARAMETER);
goto done;
}
/* special case : if file name contains absolute path, don't search the
provided path */
if('\\' == lpFileName[0] || '/' == lpFileName[0])
{
/* Canonicalize the path to deal with back-to-back '/', etc. */
dw = GetFullPathNameW(lpFileName, MAX_PATH, CanonicalPath, NULL);
if (dw == 0 || dw >= MAX_PATH)
{
WARN("couldn't canonicalize path <%S>, error is %#x. failing.\n",
lpPath, GetLastError());
SetLastError(ERROR_INVALID_PARAMETER);
goto done;
}
/* see if the file exists */
WideCharToMultiByte(CP_ACP, 0, CanonicalPath, -1,
AnsiPath, MAX_PATH, NULL, NULL);
if(0 == access(AnsiPath, F_OK))
{
/* found it */
nRet = dw;
}
}
else
{
LPCWSTR pNextPath;
pNextPath = lpPath;
FileNameLength = PAL_wcslen(lpFileName);
while (*pNextPath)
{
pPathStart = pNextPath;
/* get a pointer to the end of the first path in pPathStart */
pPathEnd = PAL_wcschr(pPathStart, ':');
if (!pPathEnd)
{
pPathEnd = pPathStart + PAL_wcslen(pPathStart);
/* we want to break out of the loop after this pass, so let
*pNextPath be '\0' */
pNextPath = pPathEnd;
}
else
{
/* point to the next component in the path string */
pNextPath = pPathEnd+1;
}
PathLength = pPathEnd-pPathStart;
if (PathLength+FileNameLength+1 >= MAX_PATH)
{
/* The path+'/'+file length is too long. Skip it. */
WARN("path component %.*S is too long, skipping it\n",
(int)PathLength, pPathStart);
continue;
}
else if(0 == PathLength)
{
/* empty component : there were 2 consecutive ':' */
continue;
}
/* Construct a pathname by concatenating one path from lpPath, '/'
and lpFileName */
memcpy(FullPath, pPathStart, PathLength*sizeof(WCHAR));
FullPath[PathLength] = '/';
PAL_wcscpy(&FullPath[PathLength+1], lpFileName);
/* Canonicalize the path to deal with back-to-back '/', etc. */
dw = GetFullPathNameW(FullPath, MAX_PATH,
CanonicalPath, NULL);
if (dw == 0 || dw >= MAX_PATH)
{
/* Call failed - possibly low memory. Skip the path */
WARN("couldn't canonicalize path <%S>, error is %#x. "
"skipping it\n", FullPath, GetLastError());
continue;
}
/* see if the file exists */
WideCharToMultiByte(CP_ACP, 0, CanonicalPath, -1,
AnsiPath, MAX_PATH, NULL, NULL);
if(0 == access(AnsiPath, F_OK))
{
/* found it */
nRet = dw;
break;
}
}
}
if (nRet == 0)
{
/* file not found anywhere; say so. in Windows, this always seems to say
FILE_NOT_FOUND, even if path doesn't exist */
SetLastError(ERROR_FILE_NOT_FOUND);
}
else
{
/* find out the required buffer size, copy path to buffer if it's
large enough */
nRet = PAL_wcslen(CanonicalPath)+1;
if(nRet <= nBufferLength)
{
if(NULL == lpBuffer)
{
/* Windows merily crashes here, but let's not */
ERROR("caller told us buffer size was %d, but buffer is NULL\n",
nBufferLength);
SetLastError(ERROR_INVALID_PARAMETER);
nRet = 0;
goto done;
}
PAL_wcscpy(lpBuffer, CanonicalPath);
/* don't include the null-terminator in the count if buffer was
large enough */
nRet--;
if(NULL != lpFilePart)
{
*lpFilePart = PAL_wcsrchr(lpBuffer, '/');
if(NULL == *lpFilePart)
{
ASSERT("no '/' in full path!\n");
}
else
{
/* point to character after last '/' */
(*lpFilePart)++;
}
}
}
}
done:
LOGEXIT("SearchPathW returns DWORD %u\n", nRet);
PERF_EXIT(SearchPathW);
return nRet;
}
/*++
Function:
SearchPathA
See MSDN doc.
PAL-specific notes :
-lpPath must be non-NULL; path delimiters are platform-dependent (':' for Unix)
-lpFileName must be non-NULL, may be an absolute path
-lpExtension must be NULL
-lpFilePart (if non-NULL) doesn't need to be used (but we do)
--*/
DWORD
PALAPI
SearchPathA(
IN LPCSTR lpPath,
IN LPCSTR lpFileName,
IN LPCSTR lpExtension,
IN DWORD nBufferLength,
OUT LPSTR lpBuffer,
OUT LPSTR *lpFilePart
)
{
DWORD nRet = 0;
CHAR FullPath[MAX_PATH];
CHAR CanonicalFullPath[MAX_PATH];
LPCSTR pPathStart;
LPCSTR pPathEnd;
size_t PathLength;
size_t FileNameLength;
DWORD dw;
PERF_ENTRY(SearchPathA);
ENTRY("SearchPathA(lpPath=%p (%s), lpFileName=%p (%s), lpExtension=%p, "
"nBufferLength=%u, lpBuffer=%p, lpFilePart=%p)\n",
lpPath,
lpPath, lpFileName, lpFileName, lpExtension, nBufferLength, lpBuffer,
lpFilePart);
/* validate parameters */
if(NULL == lpPath)
{
ASSERT("lpPath may not be NULL\n");
SetLastError(ERROR_INVALID_PARAMETER);
goto done;
}
if(NULL == lpFileName)
{
ASSERT("lpFileName may not be NULL\n");
SetLastError(ERROR_INVALID_PARAMETER);
goto done;
}
if(NULL != lpExtension)
{
ASSERT("lpExtension must be NULL, is %p instead\n", lpExtension);
SetLastError(ERROR_INVALID_PARAMETER);
goto done;
}
FileNameLength = strlen(lpFileName);
/* special case : if file name contains absolute path, don't search the
provided path */
if('\\' == lpFileName[0] || '/' == lpFileName[0])
{
if(FileNameLength >= MAX_PATH)
{
WARN("absolute file name <%s> is too long\n", lpFileName);
SetLastError(ERROR_INVALID_PARAMETER);
goto done;
}
/* Canonicalize the path to deal with back-to-back '/', etc. */
dw = GetFullPathNameA(lpFileName, MAX_PATH, CanonicalFullPath, NULL);
if (dw == 0 || dw >= MAX_PATH)
{
WARN("couldn't canonicalize path <%s>, error is %#x. failing.\n",
FullPath, GetLastError());
SetLastError(ERROR_INVALID_PARAMETER);
goto done;
}
/* see if the file exists */
if(0 == access(CanonicalFullPath, F_OK))
{
/* found it */
nRet = dw;
}
}
else
{
LPCSTR pNextPath;
pNextPath = lpPath;
while (*pNextPath)
{
pPathStart = pNextPath;
/* get a pointer to the end of the first path in pPathStart */
pPathEnd = strchr(pPathStart, ':');
if (!pPathEnd)
{
pPathEnd = pPathStart + strlen(pPathStart);
/* we want to break out of the loop after this pass, so let
*pNextPath be '\0' */
pNextPath = pPathEnd;
}
else
{
/* point to the next component in the path string */
pNextPath = pPathEnd+1;
}
PathLength = pPathEnd-pPathStart;
if (PathLength+FileNameLength+1 >= MAX_PATH)
{
/* The path+'/'+file length is too long. Skip it. */
WARN("path component %.*s is too long, skipping it\n",
(int)PathLength, pPathStart);
continue;
}
else if(0 == PathLength)
{
/* empty component : there were 2 consecutive ':' */
continue;
}
/* Construct a pathname by concatenating one path from lpPath, '/'
and lpFileName */
memcpy(FullPath, pPathStart, PathLength);
FullPath[PathLength] = '/';
if (strcpy_s(&FullPath[PathLength+1], MAX_PATH-PathLength, lpFileName) != SAFECRT_SUCCESS)
{
ERROR("strcpy_s failed!\n");
SetLastError( ERROR_FILENAME_EXCED_RANGE );
nRet = 0;
goto done;
}
/* Canonicalize the path to deal with back-to-back '/', etc. */
dw = GetFullPathNameA(FullPath, MAX_PATH,
CanonicalFullPath, NULL);
if (dw == 0 || dw >= MAX_PATH)
{
/* Call failed - possibly low memory. Skip the path */
WARN("couldn't canonicalize path <%s>, error is %#x. "
"skipping it\n", FullPath, GetLastError());
continue;
}
/* see if the file exists */
if(0 == access(CanonicalFullPath, F_OK))
{
/* found it */
nRet = dw;
break;
}
}
}
if (nRet == 0)
{
/* file not found anywhere; say so. in Windows, this always seems to say
FILE_NOT_FOUND, even if path doesn't exist */
SetLastError(ERROR_FILE_NOT_FOUND);
}
else
{
if (nRet < nBufferLength)
{
if(NULL == lpBuffer)
{
/* Windows merily crashes here, but let's not */
ERROR("caller told us buffer size was %d, but buffer is NULL\n",
nBufferLength);
SetLastError(ERROR_INVALID_PARAMETER);
nRet = 0;
goto done;
}
if (strcpy_s(lpBuffer, nBufferLength, CanonicalFullPath) != SAFECRT_SUCCESS)
{
ERROR("strcpy_s failed!\n");
SetLastError( ERROR_FILENAME_EXCED_RANGE );
nRet = 0;
goto done;
}
if(NULL != lpFilePart)
{
*lpFilePart = strrchr(lpBuffer,'/');
if(NULL == *lpFilePart)
{
ASSERT("no '/' in full path!\n");
}
else
{
/* point to character after last '/' */
(*lpFilePart)++;
}
}
}
else
{
/* if buffer is too small, report required length, including
terminating null */
nRet++;
}
}
done:
LOGEXIT("SearchPathA returns DWORD %u\n", nRet);
PERF_EXIT(SearchPathA);
return nRet;
}
/*++
Function:
GlobalMemoryStatusEx
GlobalMemoryStatusEx
Retrieves information about the system's current usage of both physical and virtual memory.
Return Values
This function returns a BOOL to indicate its success status.
--*/
BOOL
PALAPI
GlobalMemoryStatusEx(
IN OUT LPMEMORYSTATUSEX lpBuffer)
{
PERF_ENTRY(GlobalMemoryStatusEx);
ENTRY("GlobalMemoryStatusEx (lpBuffer=%p)\n", lpBuffer);
lpBuffer->dwMemoryLoad = 0;
lpBuffer->ullTotalPhys = 0;
lpBuffer->ullAvailPhys = 0;
lpBuffer->ullTotalPageFile = 0;
lpBuffer->ullAvailPageFile = 0;
lpBuffer->ullTotalVirtual = 0;
lpBuffer->ullAvailVirtual = 0;
lpBuffer->ullAvailExtendedVirtual = 0;
BOOL fRetVal = FALSE;
// Get the physical memory size
#if HAVE_SYSCONF && HAVE__SC_PHYS_PAGES
int64_t physical_memory;
// Get the Physical memory size
physical_memory = sysconf( _SC_PHYS_PAGES ) * sysconf( _SC_PAGE_SIZE );
lpBuffer->ullTotalPhys = (DWORDLONG)physical_memory;
fRetVal = TRUE;
#elif HAVE_SYSCTL
int mib[2];
int64_t physical_memory;
size_t length;
// Get the Physical memory size
mib[0] = CTL_HW;
mib[1] = HW_MEMSIZE;
length = sizeof(INT64);
int rc = sysctl(mib, 2, &physical_memory, &length, NULL, 0);
if (rc != 0)
{
ASSERT("sysctl failed for HW_MEMSIZE (%d)\n", errno);
}
else
{
lpBuffer->ullTotalPhys = (DWORDLONG)physical_memory;
fRetVal = TRUE;
}
#elif // HAVE_SYSINFO
// TODO: implement getting memory details via sysinfo. On Linux, it provides swap file details that
// we can use to fill in the xxxPageFile members.
#endif // HAVE_SYSCONF
// Get the physical memory in use - from it, we can get the physical memory available.
// We do this only when we have the total physical memory available.
if (lpBuffer->ullTotalPhys > 0)
{
#ifndef __APPLE__
lpBuffer->ullAvailPhys = sysconf(SYSCONF_PAGES) * sysconf(_SC_PAGE_SIZE);
INT64 used_memory = lpBuffer->ullTotalPhys - lpBuffer->ullAvailPhys;
lpBuffer->dwMemoryLoad = (DWORD)((used_memory * 100) / lpBuffer->ullTotalPhys);
#else
vm_size_t page_size;
mach_port_t mach_port;
mach_msg_type_number_t count;
vm_statistics_data_t vm_stats;
mach_port = mach_host_self();
count = sizeof(vm_stats) / sizeof(natural_t);
if (KERN_SUCCESS == host_page_size(mach_port, &page_size))
{
if (KERN_SUCCESS == host_statistics(mach_port, HOST_VM_INFO, (host_info_t)&vm_stats, &count))
{
lpBuffer->ullAvailPhys = (int64_t)vm_stats.free_count * (int64_t)page_size;
INT64 used_memory = ((INT64)vm_stats.active_count + (INT64)vm_stats.inactive_count + (INT64)vm_stats.wire_count) * (INT64)page_size;
lpBuffer->dwMemoryLoad = (DWORD)((used_memory * 100) / lpBuffer->ullTotalPhys);
}
}
mach_port_deallocate(mach_task_self(), mach_port);
#endif // __APPLE__
}
// There is no API to get the total virtual address space size on
// Unix, so we use a constant value representing 128TB, which is
// the approximate size of total user virtual address space on
// the currently supported Unix systems.
static const UINT64 _128TB = (1ull << 47);
lpBuffer->ullTotalVirtual = _128TB;
lpBuffer->ullAvailVirtual = lpBuffer->ullAvailPhys;
LOGEXIT("GlobalMemoryStatusEx returns %d\n", fRetVal);
PERF_EXIT(GlobalMemoryStatusEx);
return fRetVal;
}
__cdecl
PAL_fopen(const char * fileName, const char * mode)
{
PAL_FILE *f = NULL;
LPSTR supported = NULL;
LPSTR UnixFileName = NULL;
struct stat stat_data;
BOOL bTextMode = TRUE;
PERF_ENTRY(fopen);
ENTRY("fopen ( fileName=%p (%s) mode=%p (%s))\n", fileName, fileName, mode , mode );
_ASSERTE(fileName != NULL);
_ASSERTE(mode != NULL);
if ( *mode == 'r' || *mode == 'w' || *mode == 'a' )
{
supported = MapFileOpenModes( (char*)mode,&bTextMode);
if ( !supported )
{
goto done;
}
UnixFileName = PAL__strdup(fileName);
if (UnixFileName == NULL )
{
ERROR("PAL__strdup() failed\n");
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto done;
}
FILEDosToUnixPathA( UnixFileName );
/*I am not checking for the case where stat fails
*as fopen will handle the error more gracefully in case
*UnixFileName is invalid*/
if ((stat(UnixFileName, &stat_data) == 0 ) &&
((stat_data.st_mode & S_IFMT) == S_IFDIR))
{
goto done;
}
f = (PAL_FILE*)PAL_malloc( sizeof( PAL_FILE ) );
if ( f )
{
f->bsdFilePtr = (FILE*)fopen( UnixFileName, supported );
f->PALferrorCode = PAL_FILE_NOERROR;
f->bTextMode = bTextMode;
if ( !f->bsdFilePtr )
{
/* Failed */
PAL_free( f );
f = NULL;
}
#if UNGETC_NOT_RETURN_EOF
else
{
f->bWriteOnlyMode = WriteOnlyMode(f->bsdFilePtr);
}
#endif //UNGETC_NOT_RETURN_EOF
}
else
{
ERROR( "Unable to allocate memory to the PAL_FILE wrapper\n" );
}
}
else
{
ERROR( "The mode flags must start with either an a, w, or r.\n" );
}
done:
PAL_free( supported );
supported = NULL;
PAL_free( UnixFileName );
LOGEXIT( "fopen returns FILE* %p\n", f );
PERF_EXIT(fopen);
return f;
}
