able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/termsrv/clcreator/dirutils.c

1887 lines
53 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1994 Microsoft Corporation
Module Name:
DirUtils.C
Abstract:
directory, file, filename and network utility functions.
Author:
Bob Watson (a-robw)
Revision History:
24 Jun 94 Written
--*/
//
// Windows Include Files
//
#include <windows.h>
#include <stdio.h>
#include <malloc.h>
#include <tchar.h> // unicode macros
#include <stdlib.h> // string to number conversions
#include <lmcons.h> // lanman API constants
#include <lmerr.h> // lanman error returns
#include <lmshare.h> // sharing API prototypes
#include <lmapibuf.h> // lanman buffer API prototypes
#include <commdlg.h> // common dialog include
//
// app include files
//
#include "otnboot.h"
#include "otnbtdlg.h"
LPCTSTR
GetRootFromPath (
IN LPCTSTR szPath
)
{
static TCHAR szReturnBuffer[MAX_PATH];
LPTSTR szNextChar;
LONG lIndex;
if (IsUncPath(szPath)) {
// return server & share
lstrcpy (szReturnBuffer, cszDoubleBackslash);
szNextChar = &szReturnBuffer[2];
if (GetServerFromUnc (szPath, szNextChar)) {
lstrcat (szReturnBuffer, cszBackslash);
szNextChar = &szReturnBuffer[lstrlen(szReturnBuffer)];
if (GetShareFromUnc(szPath, szNextChar)) {
// append trailing backslash
lstrcat (szReturnBuffer, cszBackslash);
} else {
szReturnBuffer[0] = 0;
}
} else {
szReturnBuffer[0] = 0;
}
} else {
// dos path name
for (lIndex = 0; lIndex < 3; lIndex++) {
if (szPath[lIndex] > cSpace) {
szReturnBuffer[lIndex] = szPath[lIndex];
} else {
break;
}
}
szReturnBuffer[lIndex] = 0;
}
return (LPCTSTR)&szReturnBuffer[0];
}
BOOL
GetShareFromUnc (
IN LPCTSTR szPath,
OUT LPTSTR szShare
)
/*++
Routine Description:
Parses a UNC path name and returns the Sharepoint name in the buffer
supplied by the caller. The buffer size is not checked and is
assumed to be at least (MAX_SHARENAME+1) characters
long.
Arguments:
IN LPCTSTR szPath UNC path name to parse
OUT LPTSTR szShare buffer supplied by caller to receive the server
Return Value:
TRUE if a sharename is returned, otherwise...
FALSE if unable to parse out a share name
--*/
{
int nSlashCount = 0; // count of backslashes found in string
LPTSTR szPathPtr; // pointer to char in szPath
LPTSTR szSharePtr; // pointer to char in szShare
szPathPtr = (LPTSTR)szPath;
szSharePtr = szShare;
if (IsUncPath(szPath)) {
while (*szPathPtr != 0) {
if (nSlashCount < 3) {
if (*szPathPtr++ == cBackslash) nSlashCount++;
} else {
if (*szPathPtr == cBackslash) {
szPathPtr++;
break;
} else {
*szSharePtr++ = *szPathPtr++;
}
}
}
}
*szSharePtr = 0; // terminate share name
if (szSharePtr == szShare) {
return FALSE;
} else {
return TRUE;
}
}
BOOL
GetNetPathInfo (
IN LPCTSTR szPath,
OUT LPTSTR szServer,
OUT LPTSTR szRemotePath
)
/*++
Routine Description:
Processes a path and returns the machine the files are on and the
local path on that machine. UNC, Redirected and local paths may
be processed by this routine. On remote machine paths (e.g.
redir'd dos paths and UNC paths on another machine) the shared
path on the remote machine is returned if there user has sufficient
permission to access that information. On local paths, the
local computer name and root path is returned.
Arguments:
IN LPCTSTR szPath
the input path to analyze.
OUT LPTSTR szServer
the server/computername that the path references. The buffer size
is NOT checked and must be at least MAX_COMPUTERNAME_LENGTH+1 char's
long.
OUT LPTSTR szRemotePath
the path on the "szServer" machine that corresponds to the
input path. The buffer size is NOT checked and must be at least
MAX_PATH + 1 characters long.
Return Value:
TRUE if a path was processed and data returned
FALSE if an error occurred or unable to process the path
--*/
{
DWORD dwBufLen; // buffer length value used in fn. calls
DWORD dwStatus; // status value returned by fn. calls
TCHAR szShareName[NNLEN+1]; // net share name from path
LPTSTR szUncPath; // buffer to get path from redir'd drive
TCHAR szDrive[4]; // buffer to build drive string in
LPTSTR szSubDirs; // pointer to start of dirs not in share
LONG lBsCount; // count of backslashes found parsing UNC
BOOL bReturn = FALSE; // return valie
PSHARE_INFO_2 psi2Data; // pointer to Net data buffer
// check args
if ((szServer == NULL) || (szRemotePath == NULL)) {
// an invalid argument was passed
return FALSE;
}
szUncPath = GlobalAlloc (GPTR, MAX_PATH_BYTES);
if (szUncPath == NULL) {
*szServer = 0;
*szRemotePath = 0;
return FALSE;
}
// args ok, so take a look at the path passed in to process
if (IsUncPath(szPath)) {
// extract the server from the path string
if (GetServerFromUnc(szPath, szServer)) {
// that worked, so extract the share name.
if (GetShareFromUnc(szPath, szShareName)) {
// find end of UNC so sub dirs may be appended to final path
for (szSubDirs = (LPTSTR)szPath, lBsCount = 0;
(lBsCount < 4) && (*szSubDirs != 0);
szSubDirs++) {
if (*szSubDirs == cBackslash) lBsCount++;
}
// now look up the share on the server to get the
// source path on the server machine
if (NetShareGetInfo (szServer, (LPWSTR)szShareName, 2L, (LPBYTE *)&psi2Data) == NERR_Success) {
// successful call so copy the data to the user's buffer
lstrcpy (szRemotePath, psi2Data->shi2_path);
NetApiBufferFree (psi2Data);
// add this only if there's a subdir to append
if (*szSubDirs != 0) {
if (szRemotePath[lstrlen(szRemotePath)-1] != cBackslash)
lstrcat(szRemotePath, cszBackslash);
lstrcat (szRemotePath, szSubDirs);
}
bReturn = TRUE;
} else {
// unable to get path on server
*szRemotePath = 0;
bReturn = FALSE;
}
} else {
// unable to get parse share name
*szRemotePath = 0;
bReturn = FALSE;
}
} else {
// unable to parse server name
*szServer = 0;
*szRemotePath = 0;
bReturn = FALSE;
}
} else {
// it's a dos pathname so see if it's a redirected drive
if (OnRemoteDrive(szPath)) {
// yes it's been redirected so look up the information
// get drive letter of redirected drive
szDrive[0] = szPath[0];
szDrive[1] = szPath[1];
szDrive[2] = 0;
szSubDirs = (LPTSTR)&szPath[3];
dwBufLen = MAX_PATH;
dwStatus = WNetGetConnection (
szDrive,
szUncPath,
&dwBufLen);
if (dwStatus == NO_ERROR) {
// UNC of shared dir looked up ok, now proccess that to
// find the server and path on the server
if (GetServerFromUnc(szUncPath, szServer)) {
if (GetShareFromUnc(szUncPath, szShareName)) {
// now look up the share on the server
if (NetShareGetInfo (szServer, (LPWSTR)szShareName, 2L, (LPBYTE *)&psi2Data) == NERR_Success) {
// successful call so return pointer to path string
lstrcpy (szRemotePath, psi2Data->shi2_path);
NetApiBufferFree (psi2Data);
if (*szSubDirs != 0) {
if (szRemotePath[lstrlen(szRemotePath)-1] != cBackslash)
lstrcat(szRemotePath, cszBackslash);
lstrcat (szRemotePath, szSubDirs);
}
bReturn = TRUE;
} else {
// unable to get path on server
*szRemotePath = 0;
bReturn = FALSE;
}
} else {
// unable to get parse share name
*szRemotePath = 0;
bReturn = FALSE;
}
} else {
// unable to parse server name
*szServer = 0;
*szRemotePath = 0;
bReturn = FALSE;
}
}
} else {
// this is a local path so return the local machine name
// and the path passed in
dwBufLen = MAX_COMPUTERNAME_LENGTH+1;
GetComputerName (szServer, &dwBufLen);
lstrcpy (szRemotePath, szPath);
bReturn = TRUE;
}
}
FREE_IF_ALLOC (szUncPath);
return bReturn;
}
BOOL
ComputerPresent (
IN LPCTSTR szMachine
)
/*++
Routine Description:
Try to connect to the registry on the machine name in order to
determine if the machine is available on the network.
Arguments:
IN LPCTSTR szMachine
computer name to try (must be in the form of \\machine)
Return Value:
TRUE "szMachine" is present
FALSE unable to connect to machine
--*/
{
LONG lStatus; // status of function call
HKEY hKey; // handle to registry key opened
lStatus = RegConnectRegistry (
(LPTSTR)szMachine,
HKEY_LOCAL_MACHINE,
&hKey);
if (lStatus == ERROR_SUCCESS) {
RegCloseKey (hKey);
return TRUE;
} else {
return FALSE;
}
}
BOOL
GetServerFromUnc (
IN LPCTSTR szPath,
OUT LPTSTR szServer
)
/*++
Routine Description:
reads a UNC path and returns the name of the server referenced in
the buffer provided by the caller
Arguments:
IN LPCTSTR szPath
UNC path to parse
OUT LPTSTR szServer
buffer to receive name of server (must be large enough!)
Return Value:
TRUE if successful,
FALSE if not
--*/
{
LPTSTR szPathPtr; // pointer to char in szPath
LPTSTR szServPtr; // pointer to char in szServer
int nSlashCount = 0; // count of backslash chars found
szPathPtr = (LPTSTR)szPath;
szServPtr = szServer;
if (IsUncPath(szPath)) {
while (szPathPtr != 0) {
if (*szPathPtr == cBackslash) nSlashCount++;
if ((nSlashCount == 2) && (*szPathPtr != cBackslash)) {
*szServPtr++ = *szPathPtr;
} else {
if (nSlashCount == 3) break; // exit loop
}
szPathPtr++;
}
}
*szServPtr = 0; // terminate server name
if (szServPtr == szServer) {
return FALSE;
} else {
return TRUE;
}
}
BOOL
LookupLocalShare (
IN LPCTSTR szDrivePath,
IN BOOL bExactMatch,
OUT LPTSTR szLocalPath,
IN PDWORD pdwBuffLen
)
/*++
Routine Description:
Searches registry to see if a file is already shared and returns
the UNC name of the path if it is. (note this function is
satisfied by the first match it finds, it doesn't try to
find the "Best" match, just "A" match.
Arguments:
IN LPCTSTR szDrivePath
DOS file path to look up
IN BOOL bExactMatch
TRUE find a share that matches the szDrivePath EXACTLY
FALSE find a share that has any higher path in szDrivePath
(e.g. if c:\dir is shared as XXX, then XXX would satisfy
the lookup if the path was c:\dir\subdir\etc)
OUT LPTSTR szLocalPath
buffer to receive UNC version of path if a share exists
IN PDWORD pdwBuffLen
length of buffer referenced by szLocalPath
Return Value:
TRUE if a match is found,
FALSE if not
--*/
{
HKEY hkeyShareList; // handle to registry listing shares
LONG lStatus; // called function status return value
BOOL bReturn = FALSE; // routine status to return to caller
BOOL bMatch; // true when strings match
DWORD dwIndex; // index used to increment through search
LPTSTR szValueBuffer; // value name string to examine
LPTSTR szValueName; // value value string
DWORD dwBufferSize; // buffer length variable
DWORD dwNameSize; // Name Buffer size
DWORD dwDataType; // data type read from registry
LPTSTR szThisItem; // pointer to value in enumerated list of values
LPTSTR szThisItemChar; // char in name value to compare to path
LPTSTR szThisMatchChar; // matching character found
LPTSTR szFilePath; // pointer into path buffer where filename is
TCHAR szLocalMachine[MAX_COMPUTERNAME_LENGTH + 1];
szValueName = GlobalAlloc (GPTR, MAX_PATH_BYTES);
szValueBuffer = GlobalAlloc (GPTR, (SMALL_BUFFER_SIZE * sizeof(TCHAR)));
if ((szValueName != NULL) && (szValueBuffer != NULL)) {
// read the registry on the machine the user is
// running the app on, not the server
lStatus = RegOpenKeyEx (
HKEY_LOCAL_MACHINE,
cszLanmanServerShares,
0L,
KEY_READ,
&hkeyShareList);
if (lStatus == ERROR_SUCCESS) {
// loop through all values under this key until
// a match is found or all have been examined
dwIndex = 0;
dwIndex = 0;
dwNameSize = MAX_PATH;
dwBufferSize = SMALL_BUFFER_SIZE;
dwNameSize = MAX_PATH;
dwBufferSize = SMALL_BUFFER_SIZE;
while ((RegEnumValue(hkeyShareList, dwIndex,
szValueName, &dwNameSize,
0L, &dwDataType,
(LPBYTE)szValueBuffer, &dwBufferSize) == ERROR_SUCCESS) && !bReturn) {
// value read in so scan multi-sz returned to find path entry
for (szThisItem = szValueBuffer;
*szThisItem != 0;
szThisItem += (lstrlen(szThisItem)+1)) {
// compare the current entry to the "Path" string.
// if the characters don't match then exit the loop
// after the loop, if the match char == 0 then all
// characters in the "item" matched so this is the
// Path entry. otherwise, it's not the path so go to the
// the next item.
for (szThisItemChar = szThisItem, szThisMatchChar = (LPTSTR)cszPath;
(*szThisMatchChar != 0) && (*szThisItemChar != 0);
szThisItemChar++, szThisMatchChar++) {
if (*szThisMatchChar != *szThisItemChar) break;
}
if (*szThisMatchChar == 0) {
// this is a match so see what the path that is
// shared.
while (*szThisItemChar != cEqual) szThisItemChar++;
szThisItemChar++;
// szThisItemChar now points to the path that is shared
// compare it to the path that was passed in. if it matches,
// then return the local machine and share name in a UNC
// format
if (bExactMatch) {
if (lstrcmpi(szThisItemChar, szDrivePath) == 0) {
bMatch = TRUE;
} else {
bMatch = FALSE;
}
} else {
bMatch = MatchFirst(szThisItemChar, szDrivePath);
}
if (bMatch) {
// it's a match so format return value
dwBufferSize = MAX_COMPUTERNAME_LENGTH + 1;
GetComputerName(
szLocalMachine,
&dwBufferSize);
if (szLocalPath != NULL) {
//
// format name by replacing drive letter and colon
// with UNC format \\server\path
//
lstrcpy (szLocalPath, cszDoubleBackslash);
lstrcat (szLocalPath, szLocalMachine);
lstrcat (szLocalPath, cszBackslash);
lstrcat (szLocalPath, szValueName);
szFilePath = (LPTSTR)&szDrivePath[lstrlen(szThisItemChar)];
if (*szFilePath != cBackslash) lstrcat (szLocalPath, cszBackslash);
lstrcat (szLocalPath, szFilePath);
}
bReturn = TRUE;
}
} else {
// this is not the path entry so break and go to the
// next one.
}
}
// read next value
dwIndex++;
dwNameSize = MAX_PATH;
dwBufferSize = SMALL_BUFFER_SIZE;
}
RegCloseKey (hkeyShareList);
} else {
// unable to open registry key
bReturn = FALSE;
}
} else {
// unable to allocate memory
bReturn = FALSE;
}
FREE_IF_ALLOC (szValueName);
FREE_IF_ALLOC (szValueBuffer);
return bReturn;
}
BOOL
LookupRemotePath (
IN LPCTSTR szDrivePath,
OUT LPTSTR szRemotePath,
IN PDWORD pdwBuffLen
)
/*++
Routine Description:
Looks up a path on a remote server to see if a Dos file path is really
on a remote drive and returns the UNC path if it is.
Arguments:
IN LPCTSTR szDrivePath
DOS file path to examine
OUT LPTSTR szRemotePath
buffer to get UNC version of path if one exists
IN PDWORD pdwBuffLen
length of szRemotePath buffer in bytes
Return Value:
TRUE if match found
FALSE if no match
--*/
{
HKEY hkeyNetDrive; // handle to registry describing remote drive
LONG lStatus; // function status returned by called fn's
LPTSTR szKeyName; // buffer to build name string in
TCHAR szLocalDrive[4]; // buffer to build local drive string in
LPTSTR szFilePath; // pointer into buffer where file path goes
DWORD dwValueType; // buffer for registry query
BOOL bReturn; // return value of this function
szKeyName = GlobalAlloc (GPTR, MAX_PATH_BYTES);
if (szKeyName == NULL) return FALSE;
lstrcpy (szKeyName, cszNetDriveListKeyName);
szLocalDrive[0] = szDrivePath[0];
szLocalDrive[1] = 0;
lstrcat (szKeyName, szLocalDrive);
szFilePath = (LPTSTR)&szDrivePath[2];
lStatus = RegOpenKeyEx (
HKEY_CURRENT_USER,
szKeyName,
0L,
KEY_READ,
&hkeyNetDrive);
if (lStatus == ERROR_SUCCESS) {
lStatus = RegQueryValueEx (
hkeyNetDrive,
(LPTSTR)cszRemotePathValue,
0L,
&dwValueType,
(LPBYTE)szRemotePath,
pdwBuffLen);
RegCloseKey (hkeyNetDrive);
if (lStatus == ERROR_SUCCESS) {
//append the rest of the path and exit
lstrcat (szRemotePath, szFilePath);
bReturn = TRUE;
} else {
bReturn = FALSE;
}
} else {
// unable to find drive or open key
bReturn = FALSE;
}
FREE_IF_ALLOC (szKeyName);
return bReturn;
}
BOOL
OnRemoteDrive (
IN LPCTSTR szPath
)
/*++
Routine Description:
Returns TRUE if drive referenced is a network drive as opposed to
on on the local machine
Arguments:
IN LPCTSTR szPath
path to look up
Return Value:
TRUE if szPath references a remote drive
FALSE if szPath references a local drive
--*/
{
TCHAR szRootDir[4]; // drive string
TCHAR szServerName[MAX_COMPUTERNAME_LENGTH*2]; // server name buffer
TCHAR szComputerName[MAX_COMPUTERNAME_LENGTH+1]; // local machine name
DWORD dwBufLen; // buffer len. var.
if (IsUncPath(szPath)) {
if (GetServerFromUnc(szPath, szServerName)) {
dwBufLen = MAX_COMPUTERNAME_LENGTH+1;
GetComputerName (szComputerName, &dwBufLen);
if (lstrcmpi(szServerName, szComputerName) == 0) {
// shared on this machine so not remote
return FALSE;
} else {
// not on this machine so it must be remote
return TRUE;
}
}
} else {
// check the DOS path
// see if this is a network or local drive
szRootDir[0] = szPath[0]; // letter
szRootDir[1] = szPath[1]; // colon
szRootDir[2] = cBackslash;
szRootDir[3] = 0;
if (GetDriveType(szRootDir) == DRIVE_REMOTE) {
return TRUE;
} else {
return FALSE;
}
}
return FALSE;
}
DWORD
ComputeFreeSpace (
IN LPCTSTR szPath
)
/*++
Routine Description:
Function to return free space on drive referenced in path
(NOTE: assumes DOS file path specification)
Arguments:
IN LPCTSTR szPath
Path including Drive to check free space of. (MUST BE A DOS
FILE Path)
Return Value:
Free space found in BYTES
--*/
{
DWORD dwSectorsPerCluster;
DWORD dwBytesPerSector;
DWORD dwFreeClusters;
DWORD dwClusters;
TCHAR szRoot[MAX_PATH]; // root dir of path
DWORD dwFreeBytes = 0;
UINT nErrorMode;
// disable windows error message popup
nErrorMode = SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
lstrcpy (szRoot, GetRootFromPath(szPath));
if (lstrlen(szRoot) > 0) {
// we have a path to process so get info from the root
if (GetDiskFreeSpace(szRoot, &dwSectorsPerCluster,
&dwBytesPerSector, &dwFreeClusters, &dwClusters)) {
ULONGLONG ullFreeBytes;
ullFreeBytes =
(ULONGLONG)dwFreeClusters *
dwSectorsPerCluster * dwBytesPerSector;
dwFreeBytes = (DWORD) ullFreeBytes;
if( (ULONGLONG)dwFreeBytes != ullFreeBytes ) {
//
// Overflow has occured.
//
dwFreeBytes = 0xFFFFFFFF;
}
}
} else {
dwFreeBytes = 0xFFFFFFFF;
}
SetErrorMode (nErrorMode); // restore old error mode
return dwFreeBytes;
}
BOOL
IsShareNameUsed (
IN LPCTSTR szServerName,
IN LPCTSTR szShareName,
IN OUT PDWORD pdwType,
IN OUT LPTSTR pszPath
)
/*++
Routine Description:
Looks up a share name on a sever to determine if the name is in use
and if so, what type of directory is shared.
Arguments:
IN LPCTSTR szServerName
server name to look up share name on (NULL == the local machine)
IN LPCTSTR szShareName
share name to look up
IN OUT PDWORD pdwType
buffer to return share type in options are:
NCDU_SHARE_IS_NOT_USED: name not found on server
NCDU_SHARE_IS_CLIENT_TREE: name is a client distribution tree
NCDU_SHARE_IS_SERVER_TOOLS: name is a server tool tree
NCDU_SHARE_IS_OTHER_DIR: name is shared to some other dir.
IN OUT LPTSTR pszPath
if path is shared, then this is the path on the server that
is shared
Return Value:
TRUE if share name is in use
FALSE if the share name is not found on the server.
--*/
{
LPTSTR szLocalPath; // local buffer to build path string in
LPTSTR szLocalName; // pointer into path where sharename starts
DWORD dwShareAttrib; // file attributes of share point
DWORD dwBufLen; // buffer length variable
BOOL bReturn = FALSE; // function return value
DWORD dwLocalType; // share dir type
PSHARE_INFO_2 psi2Data = NULL; // net info buffer pointer
LPTSTR szReturnPath
= (LPTSTR)cszEmptyString; // pointer to path string to return
szLocalPath = GlobalAlloc (GPTR, MAX_PATH_BYTES);
if (szLocalPath != NULL) {
// make share name into a UNC name using the appropriate machine
lstrcpy (szLocalPath, cszDoubleBackslash);
if (szServerName == NULL) {
dwBufLen = MAX_COMPUTERNAME_LENGTH + 1;
GetComputerName (&szLocalPath[2], &dwBufLen);
} else {
lstrcat (szLocalPath, szServerName);
}
lstrcat (szLocalPath, cszBackslash);
szLocalName = &szLocalPath[lstrlen(szLocalPath)];
lstrcpy (szLocalName, szShareName);
TrimSpaces (szLocalName);
// see if it's a valid path
dwShareAttrib = QuietGetFileAttributes (szLocalPath);
if (dwShareAttrib == 0xFFFFFFFF) {
// it's not a valid file or dir, so
bReturn = FALSE; // share name is not used
szReturnPath = (LPTSTR)cszEmptyString;
dwLocalType = NCDU_SHARE_IS_NOT_USED;
} else {
// it's a valid path so see if it's anything we want
bReturn = TRUE;
// terminate local path after server name for use in net API Call
*(szLocalName - 1) = 0;
// get share info
if (NetShareGetInfo ((LPWSTR)szLocalPath, (LPWSTR)szShareName,
2L, (LPBYTE *)&psi2Data) == NERR_Success) {
// successful call so return pointer to path string
szReturnPath = psi2Data->shi2_path;
} else {
// function failed so return empty path
szReturnPath = (LPTSTR)cszEmptyString;
}
// restore local path string
*(szLocalName - 1) = cBackslash;
// share is used, so see if it's a clients path
if (*szReturnPath != 0) {
if (ValidSharePath (szLocalPath) == 0) {
dwLocalType = NCDU_SHARE_IS_CLIENT_TREE;
} else if (ValidSrvToolsPath (szLocalPath) == 0) {
dwLocalType = NCDU_SHARE_IS_SERVER_TOOLS;
} else {
dwLocalType = NCDU_SHARE_IS_OTHER_DIR;
}
} else {
// no path name
bReturn = FALSE;
dwLocalType = NCDU_SHARE_IS_NOT_USED;
}
}
FREE_IF_ALLOC (szLocalPath);
} else {
// unable to allocate memory
bReturn = FALSE;
dwLocalType = 0;
}
if (pdwType != NULL) {
*pdwType = dwLocalType;
}
if (pszPath != NULL) {
lstrcpy (pszPath, szReturnPath);
}
// free buffer created by net call
if (psi2Data != NULL) NetApiBufferFree (psi2Data);
return bReturn;
}
DWORD
QuietGetFileAttributes (
IN LPCTSTR lpszFileName
)
/*++
Routine Description:
Reads the attributes of the path in lpzsFileName without triggering
any Windows error dialog if there's an OS error (e.g. drive not
ready)
Arguments:
IN LPCTSTR lpszFileName
path to retrieve attributes from
Return Value:
file attributes DWORD returned from GetFileAttributes or
0xFFFFFFFF if unable to open path.
--*/
{
DWORD dwReturn;
UINT nErrorMode;
// disable windows error message popup
nErrorMode = SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
dwReturn = GetFileAttributes (lpszFileName);
SetErrorMode (nErrorMode); // restore old error mode
return dwReturn;
}
BOOL
GetSizeOfDirs (
IN LPCTSTR szPath,
IN BOOL bFlags,
IN OUT PDWORD pdwSize
)
/*++
Routine Description:
Scans a directory and optionally a subdirectory to total the sizes
of the files found.
NOTE: This function will only process files that are < 4GB in size
and dir paths that total less then 4GB total.
Arguments:
IN LPCTSTR szPath
top dir or dir tree to scan.
IN BOOL bFlags
operation modification flags:
0 : specified path only.
GSOD_INCLUDE_SUBDIRS: include sub dirs
IN OUT PDWORD pdwSize
buffer to return size in.
Return Value:
TRUE size returned in pdwSize
FALSE error occurred
--*/
{
HANDLE hSearch;
HANDLE hFile;
WIN32_FIND_DATA fdSearch;
PDWORD pdwSizeBuffer;
DWORD dwLocalSize = 0;
DWORD dwPathAttrib;
BOOL bSearching;
LPTSTR szLocalPath;
LPTSTR szSearchPath;
LPTSTR szLocalFileName;
DWORD dwFileSizeLow;
DWORD dwFileSizeHigh;
LPTSTR szThisFileName;
BOOL bReturn;
//
// check path to see if it's a directory
//
dwPathAttrib = QuietGetFileAttributes (szPath);
// if an invalid attribute or it's not a directory then return FALSE and set error
if ((dwPathAttrib == 0xFFFFFFFF) ||
((dwPathAttrib & FILE_ATTRIBUTE_DIRECTORY) != FILE_ATTRIBUTE_DIRECTORY)) {
SetLastError (ERROR_BAD_PATHNAME);
return FALSE;
}
//
// Initialize size buffer
//
if (pdwSize == NULL) {
pdwSizeBuffer = &dwLocalSize;
} else {
pdwSizeBuffer = pdwSize;
}
// get a local buffer for the path
szSearchPath = GlobalAlloc (GPTR, MAX_PATH_BYTES);
szLocalPath = GlobalAlloc (GPTR, MAX_PATH_BYTES);
if ((szLocalPath != NULL) && (szSearchPath != NULL)) {
// make a local copy of the input path
lstrcpy (szLocalPath, szPath);
lstrcpy (szSearchPath, szLocalPath);
// make full path prefix for sub dir searches & filenames
if (szLocalPath[lstrlen(szLocalPath)-1] != cBackslash) lstrcat (szLocalPath, cszBackslash);
szLocalFileName = &szLocalPath[lstrlen(szLocalPath)];
// make wildcard path for searching this directory
lstrcat (szSearchPath, cszWildcardFile);
//
// start search of files in this path
//
hSearch = FindFirstFile (szSearchPath, &fdSearch);
if (hSearch != INVALID_HANDLE_VALUE) {
bSearching = TRUE;
while (bSearching) {
// if an alternate filename is defined, then use it, otherwise
// use the regular name
szThisFileName = ((fdSearch.cAlternateFileName[0] == 0) ?
fdSearch.cFileName : fdSearch.cAlternateFileName);
// if it's a dot or a dot dot (. or ..) dir, then skip
if (!DotOrDotDotDir(szThisFileName)) {
lstrcpy (szLocalFileName, szThisFileName);
// if it's a dir and the SUB DIR flag is set, then
// recurse through the next directory, otherwise
// get the file size of this file and continue
dwPathAttrib = QuietGetFileAttributes (szLocalPath);
if ((dwPathAttrib & FILE_ATTRIBUTE_DIRECTORY) ==
FILE_ATTRIBUTE_DIRECTORY) {
// this is a directory, so call this routine again
// if the sub-dir flag is set.
if ((bFlags & GSOD_INCLUDE_SUBDIRS) == GSOD_INCLUDE_SUBDIRS) {
if (!GetSizeOfDirs (szLocalPath, bFlags, pdwSizeBuffer)) {
// this call returned an errror so propogate it
// up the call stack and exit the loop here
bSearching = FALSE;
continue;
}
} else {
// the caller doesn't want sub dirs so ignore it
}
} else {
// this is a file so get the size of it and add
// it to the total
hFile = CreateFile (
szLocalPath,
GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFile != INVALID_HANDLE_VALUE) {
// then the file was opened successfully
// go get it's size and add it to the total
dwFileSizeLow = GetFileSize (hFile, &dwFileSizeHigh);
if (dwFileSizeLow != 0xFFFFFFFF) {
*pdwSizeBuffer += dwFileSizeLow;
}
// now close the file handle
CloseHandle (hFile);
} else {
// unable to open file so skip it
}
}
}
bSearching = FindNextFile (hSearch, &fdSearch);
}
FindClose (hSearch);
} else {
// unable to start search so return 0 size
}
bReturn = TRUE;
} else {
// unable to allocate memory
SetLastError (ERROR_OUTOFMEMORY);
bReturn = FALSE;
}
FREE_IF_ALLOC (szLocalPath);
FREE_IF_ALLOC (szSearchPath);
return bReturn;
}
BOOL
MediaPresent (
IN LPCTSTR szPath,
IN BOOL bPresentAndValid
)
/*++
Routine Description:
determines if the specified path is present and available
Arguments:
IN LPCTSTR szPath
path to examine (Must be a DOS path)
Return Value:
TRUE: path is available
FALSE: unable to find/open path
--*/
{
TCHAR szDev[8];
DWORD dwBytes = 0;
DWORD dwAttrib;
DWORD dwLastError = ERROR_SUCCESS;
BOOL bMediaPresent = FALSE;
UINT nErrorMode;
if (!IsUncPath(szPath)) {
// build device name string
szDev[0] = szPath[0];
szDev[1] = cColon;
szDev[2] = cBackslash;
szDev[3] = 0;
// disable windows error message popup
nErrorMode = SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
dwAttrib = QuietGetFileAttributes (szDev);
if ((dwAttrib != 0xFFFFFFFF) && ((dwAttrib & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)) {
// if the root dir is a dir, then it must be present and formatted
bMediaPresent = TRUE;
} else {
// otherwise see if it's present and not formatted or not present
dwLastError = GetLastError();
if (dwLastError == ERROR_NOT_READY) {
// then no disk in drive
bMediaPresent = FALSE;
} else if ((dwLastError == ERROR_FILE_NOT_FOUND) ||
#ifdef TERMSRV
(dwLastError == ERROR_UNRECOGNIZED_MEDIA) ||
(dwLastError == ERROR_SECTOR_NOT_FOUND)) {
#else // TERMSRV
(dwLastError == ERROR_UNRECOGNIZED_MEDIA)) {
#endif // TERMSRV
// then and UNFORMATTED disk is in drive
if (bPresentAndValid) {
// this isn't good enough if it's supposed to be formatted
bMediaPresent = FALSE;
} else {
// we're just looking for a disk so this is OK
bMediaPresent = TRUE;
}
}
}
SetErrorMode (nErrorMode); // restore old error mode
} else {
// assume UNC path devices are present
bMediaPresent = TRUE;
}
return bMediaPresent;
}
BOOL
FileExists (
IN LPCTSTR szFileName
)
/*++
Routine Description:
Opens the file to test for it's presences and returns TRUE if the
open was successful and FALSE if not.
Arguments:
file name to open
ReturnValue:
TRUE if file found
FALSE if not.
--*/
{
BOOL bMediaPresent;
UINT nDriveType;
DWORD dwAttr;
nDriveType = GetDriveType((LPTSTR)szFileName);
if ((nDriveType == DRIVE_REMOVABLE) || (nDriveType == DRIVE_CDROM)) {
// see if a formatted drive is really there
bMediaPresent = MediaPresent(szFileName, TRUE);
} else {
// if drive is not removable, then assume it's there
bMediaPresent = TRUE;
}
// try to get inforation on the file
dwAttr = QuietGetFileAttributes ((LPTSTR)szFileName);
if (dwAttr == 0xFFFFFFFF) {
// unable to obtain attributes, so assume it's not there
// or we can't access it
return FALSE;
} else {
// found, so close it and return TRUE
return TRUE;
}
}
BOOL
IsBootDisk (
IN LPCTSTR szPath
)
/*++
Routine Description:
examines the path (which should be the root dir of a floppy drive)
and looks for the "signature" files that indicate it's a bootable
(i.e. system) disk.
Arguments:
IN LPCTSTR szPath
drive path to look at
Return Value:
TRUE if one of the signature files was found
FALSE if not.
--*/
{
TCHAR szDrive[16];
LPTSTR szTestFile;
LPTSTR *szTryFile;
szTestFile = GlobalAlloc (GPTR, MAX_PATH_BYTES);
if (szTestFile == NULL) {
SetLastError (ERROR_OUTOFMEMORY);
return FALSE; // unable to continue
}
if (!IsUncPath(szPath)) {
szDrive[0] = szPath[0]; // drive letter
szDrive[1] = szPath[1]; // colon
szDrive[2] = cBackslash;
szDrive[3] = 0; // terminator
for (szTryFile = (LPTSTR *)szBootIdFiles;
*szTryFile != NULL;
szTryFile++) {
lstrcpy (szTestFile, szDrive);
lstrcat (szTestFile, *szTryFile);
if (FileExists(szTestFile)) return TRUE;
}
// if we didn't bail out already, it must not be a bootable disk
return FALSE;
} else {
// unc path name automatically is not a bootable drive
return FALSE;
}
FREE_IF_ALLOC (szTestFile);
}
MEDIA_TYPE
GetDriveTypeFromPath (
IN LPCTSTR szPath
)
/*++
Routine Description:
returns the drive type of the drive specified in the path argument
Arguments:
IN LPCTSTR szPath
path on drive to examine
Return Value:
MEDIA_TYPE value identifying drive type
--*/
{
HANDLE hFloppy;
DWORD dwRetSize;
DISK_GEOMETRY dgFloppy;
TCHAR szDevicePath[16];
UINT nDriveType;
UINT nErrorMode;
nDriveType = GetDriveType((LPTSTR)szPath);
// see if this is a remote disk and exit if it is.
if (nDriveType == DRIVE_REMOTE) return Unknown;
if ((nDriveType == DRIVE_REMOVABLE) || (nDriveType == DRIVE_CDROM)) {
// see if it's a UNC path and return unknown if so
if (IsUncPath(szPath)) return Unknown;
// it should be local and a DOS pathname so
// make device name from path
szDevicePath[0] = cBackslash;
szDevicePath[1] = cBackslash;
szDevicePath[2] = cPeriod;
szDevicePath[3] = cBackslash;
szDevicePath[4] = szPath[0]; // drive letter
szDevicePath[5] = szPath[1]; // colon
szDevicePath[6] = 0; // null terminator
// disable windows error message popup
nErrorMode = SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
// open device to get type
hFloppy = CreateFile (
szDevicePath,
GENERIC_READ,
(FILE_SHARE_READ | FILE_SHARE_WRITE),
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFloppy != INVALID_HANDLE_VALUE) {
// get drive information
if (!DeviceIoControl (hFloppy,
IOCTL_DISK_GET_DRIVE_GEOMETRY,
NULL, 0,
&dgFloppy,
sizeof(DISK_GEOMETRY),
&dwRetSize,
NULL) ){
// unable to get data so set to unknown
dgFloppy.MediaType = Unknown;
} // else return data from returned structure
CloseHandle (hFloppy);
} else {
// unable to open handle to device
dgFloppy.MediaType = Unknown;
}
SetErrorMode (nErrorMode); // reset error mode
}
return dgFloppy.MediaType;
}
BOOL
DotOrDotDotDir (
IN LPCTSTR szFileName
)
/*++
Routine Description:
examines the filename in the parameter list to see if it is one
of the default subdirectories (e.g. the . or the .. dirs). This
routine assumes that the argument is a filename only. (i.e. NO
PATH!)
Arguments:
Filename to compare
Return Value:
TRUE if filename is either the . or the .. dir
FALSE if it is any other string
--*/
{
if (szFileName != NULL) { // check for null parameter
if (lstrcmp(szFileName, cszDot) == 0) {
return TRUE; // it's the . dir
} else if (lstrcmp(szFileName, cszDotDot) == 0) {
return TRUE; // it's the .. dir
} else {
return FALSE; // it's neither
}
} else {
return FALSE; // null filename, so not a . or .. dir
}
}
UINT
ValidSharePath (
IN LPCTSTR szPath
)
/*++
Routine Description:
examines the path to see if it contains the "signature" file
that identifies the path as as that of a valid client
distribution directory tree.
Arguments:
IN LPCTSTR szPath
path to examine
Return Value:
ERROR_SUCCESS if it is
otherwise the ID of a string resource that describes
what was found and why it isn't a distribution tree
--*/
{
DWORD dwPathAttr;
UINT nReturn = 0;
LPTSTR szInfName;
szInfName = GlobalAlloc (GPTR, MAX_PATH_BYTES);
if (szInfName == NULL) {
SetLastError (ERROR_OUTOFMEMORY);
return NCDU_ERROR_NOMEMORY;
}
// validate share path by looking for INF file, display
// error box if necessary.
// Return 0 if valid
// return message string ID if not valid, for what ever reason.
//
dwPathAttr = QuietGetFileAttributes((LPTSTR)szPath);
if (dwPathAttr == 0xFFFFFFFF) {
// an error occured...
nReturn = NCDU_UNABLE_READ_DIR;
} else {
if ((dwPathAttr & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY) {
// so far so good!
lstrcpy (szInfName, szPath);
if (szInfName[lstrlen(szInfName)-1] != cBackslash) lstrcat(szInfName, cszBackslash);
lstrcat (szInfName, cszAppInfName);
dwPathAttr = QuietGetFileAttributes(szInfName);
if (dwPathAttr != 0xFFFFFFFF) {
nReturn = 0;
} else {
nReturn = NCDU_NOT_DIST_TREE;
}
} else {
nReturn = NCDU_PATH_NOT_DIR;
}
}
FREE_IF_ALLOC (szInfName);
return (nReturn);
}
UINT
ValidSrvToolsPath (
IN LPCTSTR szPath
)
/*++
Routine Description:
examines the path to see if it contains the "signature" file
that identifies the path as as that of a valid server tools
distribution directory tree.
Arguments:
IN LPCTSTR szPath
path to examine
Return Value:
ERROR_SUCCESS if it is
otherwise the ID of a string resource that describes
what was found and why it isn't a server tools tree
--*/
{
UINT nReturn = 0;
DWORD dwAttrib;
LPTSTR szClientPath;
szClientPath = GlobalAlloc (GPTR, MAX_PATH_BYTES);
if (szClientPath == NULL) {
SetLastError (ERROR_OUTOFMEMORY);
return NCDU_ERROR_NOMEMORY;
}
// make local copy of the path
lstrcpy (szClientPath, szPath);
// get file attributes of dir path to make sure it's really a dir
dwAttrib = QuietGetFileAttributes (szClientPath);
if ((dwAttrib != 0xFFFFFFFF) && ((dwAttrib & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)) {
if (szClientPath[lstrlen(szClientPath)-1] != cBackslash) lstrcat(szClientPath, cszBackslash);
lstrcat (szClientPath, cszSrvToolSigFile);
// now get the file attributes of the signature file to see if this is a valid path
dwAttrib = QuietGetFileAttributes (szClientPath);
if (dwAttrib != 0xFFFFFFFF) {
nReturn = 0;
} else {
nReturn = NCDU_NOT_TOOL_TREE;
}
} else {
nReturn = NCDU_PATH_NOT_DIR;
}
FREE_IF_ALLOC (szClientPath);
return (nReturn);
}
BOOL
IsPathADir (
IN LPCTSTR szPath
)
/*++
Routine Description:
Checks the path passed in to see if it's a directory or not
Arguments:
IN LPCTSTR szPath
path to check
Return Value:
TRUE if path is a valid directory
FALSE if unable to find path or if path is not a directory
--*/
{
DWORD dwAttrib;
dwAttrib = QuietGetFileAttributes (szPath);
if ((dwAttrib != 0xffffffff) &&
((dwAttrib & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)) {
return TRUE;
} else {
return FALSE;
}
}
static
DWORD
GetSectorSize (
IN LPTSTR szDriveName
)
/*++
Routine Description:
Returns the sector size in bytes of the disk drive specified in the
argument list.
Arguments:
IN LPTSTR szDriveName ASCIZ of drive to return data for (e.g. "C:")
Return Value:
size of disk sector in bytes,
0xFFFFFFFF ((DWORD)-1) if error, error retrieved using GetLastError()
--*/
{
BOOL bStatus;
LONG lReturn = 0xFFFFFFFF;
DWORD dwBytesReturned;
HANDLE hDrive;
DISK_GEOMETRY dgBuffer;
// open existing file (root drive)
hDrive = CreateFile (
szDriveName,
GENERIC_READ,
(FILE_SHARE_READ | FILE_SHARE_WRITE),
NULL,
OPEN_EXISTING,
0L,
NULL);
if (hDrive != INVALID_HANDLE_VALUE) {
// get disk inoformation
bStatus = DeviceIoControl(
hDrive,
IOCTL_DISK_GET_DRIVE_GEOMETRY,
NULL,
0L,
&dgBuffer,
sizeof(dgBuffer),
&dwBytesReturned,
NULL);
// if data was returned by IOCTL, then return
// sector size other wise return error value
if (bStatus) {
lReturn = dgBuffer.BytesPerSector;
} else {
lReturn = 0xFFFFFFFF;
}
CloseHandle (hDrive); // don't forget to close the handle
} else {
// unable to open device
lReturn = 0xFFFFFFFF;
}
return lReturn;
}
static
LONG
CopyFatBootSectorToBuffer (
IN LPTSTR szBootDrive,
IN LPBYTE *pOutputBuffer
)
/*++
Routine Description:
Copies the first sector of the volume to the specified file
Arguments:
IN LPTSTR szBootDrive volume to locate boot sector on
IN LPBYTE *pOutputBuffer address of pointer to buffer created
Return Value:
Win 32 Status Value:
ERROR_SUCCESS The routine complete all operations normally
--*/
{
LONG lStatus = ERROR_SUCCESS;
BOOL bStatus = FALSE;
DWORD dwByteCount;
DWORD dwBytesRead;
HANDLE hDrive;
LPBYTE pBootSector;
dwByteCount = GetSectorSize (szBootDrive);
if (dwByteCount != 0xFFFFFFFF) {
// allocate buffer to read data into
pBootSector = (LPBYTE)GlobalAlloc(GPTR, dwByteCount);
} else {
pBootSector = NULL;
lStatus = GetLastError();
}
if (pBootSector != NULL) {
// if memory allocated successfully, then open drive
hDrive = CreateFile (
szBootDrive,
GENERIC_READ,
(FILE_SHARE_READ | FILE_SHARE_WRITE),
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hDrive != INVALID_HANDLE_VALUE) {
SetFilePointer (hDrive, 0, NULL, FILE_BEGIN); // go to beginning
bStatus = ReadFile (
hDrive,
pBootSector,
dwByteCount,
&dwBytesRead,
NULL);
if (bStatus) {
*pOutputBuffer = pBootSector;
lStatus = ERROR_SUCCESS;
} else {
// unable to read the file (drive) so return error
*pOutputBuffer = NULL;
lStatus = GetLastError();
}
// close handle now that we're done with it.
CloseHandle (hDrive);
} else {
// unable to open drive
*pOutputBuffer = NULL;
lStatus = GetLastError();
}
} else {
lStatus = ERROR_OUTOFMEMORY;
}
return lStatus;
}
DWORD
GetBootDiskDosVersion (
IN LPCTSTR szPath
)
/*++
Routine Description:
examines the boot sector of the disk in the drive described in the
path variable and returns the MAJOR version of the OS that
formatted the disk.
Arguments:
IN LPCTSTR szPath
path containing drive to examine
Return Value:
Major version of MS-DOS that formatted the disk.
Zero is returned when:
-- the boot sector on the drive cannot be read
-- the drive is not a bootable drive
--*/
{
PDOS_BOOT_SECTOR pBootSector = NULL;
TCHAR szDrive[8];
DWORD dwReturn;
if (IsBootDisk(szPath)) {
szDrive[0] = cBackslash;
szDrive[1] = cBackslash;
szDrive[2] = cPeriod;
szDrive[3] = cBackslash;
szDrive[4] = szPath[0];
szDrive[5] = szPath[1];
szDrive[6] = 0;
szDrive[7] = 0;
if (CopyFatBootSectorToBuffer (
szDrive, (LPBYTE *)&pBootSector) == ERROR_SUCCESS) {
dwReturn = (pBootSector->bsOemName[5] - '0');
} else {
dwReturn = 0;
}
// free buffer allocated in CopyFatBootSectorToBuffer call.
FREE_IF_ALLOC (pBootSector);
} else {
dwReturn = 0;
}
return dwReturn;
}
DWORD
GetClusterSizeOfDisk (
IN LPCTSTR szPath
)
/*++
Routine Description:
returns the cluster size (in bytes) of the disk in the path
Arguments:
Path containing disk drive to examine
Return Value:
cluster size (allocation unit size) of disk in bytes.
if the function cannot determine the cluster size, then
a value of 512 for floppy disk or 4096 for hard disks will
be returned.
--*/
{
DWORD dwSectorsPerCluster;
DWORD dwBytesPerSector;
DWORD dwFreeClusters;
DWORD dwClusters;
TCHAR szRoot[4]; // root dir of path
DWORD dwClusterSize = 0;
UINT nErrorMode;
// disable windows error message popup
nErrorMode = SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
if (!IsUncPath(szPath)) {
szRoot[0] = szPath[0]; // drive letter
szRoot[1] = szPath[1]; // colon
szRoot[2] = cBackslash; // backslash
szRoot[3] = 0; // null terminator
if (GetDiskFreeSpace(szRoot, &dwSectorsPerCluster,
&dwBytesPerSector, &dwFreeClusters, &dwClusters)) {
dwClusterSize = dwSectorsPerCluster * dwBytesPerSector;
} else {
if (GetDriveType (szRoot) == DRIVE_FIXED) {
dwClusterSize = 4096;
} else {
dwClusterSize = 512;
}
}
} else {
dwClusterSize = 4096;
}
SetErrorMode (nErrorMode); // restore old error mode
return dwClusterSize;
}
DWORD
QuietGetFileSize (
IN LPCTSTR szPath
)
/*++
Routine Description:
Returns the size of the file passed in the arg list ( file sizz < 4GB)
while supressing any windows system error messages.
Arguments:
path to file to size
Return Value:
size of the file (if less then 4GB) or 0xFFFFFFFF if error
--*/
{
HANDLE hFile;
DWORD dwFileSizeLow, dwFileSizeHigh;
DWORD dwReturn;
UINT nErrorMode;
// disable windows error message popup
nErrorMode = SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
// get the size of the file and add it to the total
hFile = CreateFile (
szPath,
GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFile != INVALID_HANDLE_VALUE) {
// then the file was opened successfully
// go get it's size
dwFileSizeLow = GetFileSize (hFile, &dwFileSizeHigh);
dwReturn = dwFileSizeLow;
// now close the file handle
CloseHandle (hFile);
} else {
// unable to open file so return error
dwReturn = 0xFFFFFFFF;
}
SetErrorMode (nErrorMode); // restore old error mode
return dwReturn;
}

Reference in a new issue Copy permalink