windows-server-2003/base/ntsetup/opktools/opklib/opklib.c

/*++

Copyright (c) 2000 Microsoft Corporation

Module Name:

    opk.c

Abstract:

    Common modules shared by OPK tools.  Note: Source Depot requires that we 
    publish the .h (E:\NT\admin\published\ntsetup) and .lib 
    (E:\NT\public\internal\admin\lib).

Author:

    Brian Ku (briank) 06/20/2000

Revision History:

    7/00 - Jason Cohen (jcohen)
        Added in the rest of the common APIs form Millennium (need for lfnbk).

--*/


//
// Include file(s)
//

#include <pch.h>
#include <tchar.h>
#include <shlwapi.h>


//
// External Function(s):
//

LPTSTR AllocateString(HINSTANCE hInstance, UINT uID)
{
    //  ISSUE-2002/02/26-acosma - This sets a restriction of 256 characters on the buffer.
    //
    TCHAR   szBuffer[256];
    LPTSTR  lpBuffer = NULL;

    // Load the string from the resource and then allocate
    // a buffer just big enough for it.  Strings can exceed 256 characters.
    //
    if ( ( LoadString(hInstance, uID, szBuffer, sizeof(szBuffer) / sizeof(TCHAR)) ) &&
         ( lpBuffer = (LPTSTR) MALLOC(sizeof(TCHAR) * (lstrlen(szBuffer) + 1)) ) )
    {
        lstrcpy(lpBuffer, szBuffer);
    }

    // Return the allocated buffer, or NULL if there was an error.
    //
    return lpBuffer;
}

LPTSTR AllocateExpand(LPTSTR lpszBuffer)
{
    LPTSTR      lpszExpanded = NULL;
    DWORD       cbExpanded;

    // First we need to get the size of the expanded buffer and
    // allocate it.
    //
    if ( ( cbExpanded = ExpandEnvironmentStrings(lpszBuffer, NULL, 0) ) &&
         ( lpszExpanded = (LPTSTR) MALLOC(cbExpanded * sizeof(TCHAR)) ) )
    {
        // Now expand out the buffer.
        //
        if ( ( 0 == ExpandEnvironmentStrings(lpszBuffer, lpszExpanded, cbExpanded) ) ||
             ( NULLCHR == *lpszExpanded ) )
        {
            FREE(lpszExpanded);
        }
    }

    // Return the allocated buffer, or NULL if there was an error
    // or nothing in the string.
    //
    return lpszExpanded;
}

LPTSTR AllocateStrRes(HINSTANCE hInstance, LPSTRRES lpsrTable, DWORD cbTable, LPTSTR lpString, LPTSTR * lplpReturn)
{
    LPSTRRES    lpsrSearch  = lpsrTable;
    LPTSTR      lpReturn    = NULL;
    BOOL        bFound;

    // Init this return value.
    //
    if ( lplpReturn )
        *lplpReturn = NULL;

    // Try to find the friendly name for this string in our table.
    //
    while ( ( bFound = ((DWORD) (lpsrSearch - lpsrTable) < cbTable) ) &&
            ( lstrcmpi(lpString, lpsrSearch->lpStr) != 0 ) )
    {
        lpsrSearch++;
    }

    // If it was found, allocate the friendly name from the resource.
    //
    if ( bFound )
    {
        lpReturn = AllocateString(hInstance, lpsrSearch->uId);
        if ( lplpReturn )
            *lplpReturn = lpsrSearch->lpStr;
    }

    return lpReturn;
}

int MsgBoxLst(HWND hwndParent, LPTSTR lpFormat, LPTSTR lpCaption, UINT uType, va_list lpArgs)
{
    INT     nReturn;
    DWORD   dwCount     = 0;
    LPTSTR  lpText      = NULL;

    // The format string is required.
    //
    if ( lpFormat )
    {
        do
        {
            // Allocate 1k of characters at a time.
            //
            dwCount += 1024;

            // Free the previous buffer, if there was one.
            //
            FREE(lpText);

            // Allocate a new buffer.
            //
            if ( lpText = MALLOC(dwCount * sizeof(TCHAR)) )
                nReturn = _vsntprintf(lpText, dwCount, lpFormat, lpArgs);
            else
                nReturn = 0;
        }
        while ( nReturn < 0 );

        // Make sure we have the format string.
        //
        if ( lpText )
        {
            // Display the message box.
            //
            nReturn = MessageBox(hwndParent, lpText, lpCaption, uType);
            FREE(lpText);
        }
    }
    else
        nReturn = 0;

    // Return the return value of the MessageBox() call.  If there was a memory
    // error, 0 will be returned.
    //
    return nReturn;
}

int MsgBoxStr(HWND hwndParent, LPTSTR lpFormat, LPTSTR lpCaption, UINT uType, ...)
{
    va_list lpArgs;

    // Initialize the lpArgs parameter with va_start().
    //
    va_start(lpArgs, uType);

    // Return the return value of the MessageBox() call.  If there was a memory
    // error, 0 will be returned.  This is all 
    //
    return MsgBoxLst(hwndParent, lpFormat, lpCaption, uType, lpArgs);
}

int MsgBox(HWND hwndParent, UINT uFormat, UINT uCaption, UINT uType, ...)
{
    va_list lpArgs;
    INT     nReturn;
    LPTSTR  lpFormat    = NULL,
            lpCaption   = NULL;

    // Initialize the lpArgs parameter with va_start().
    //
    va_start(lpArgs, uType);

    // Get the format and caption strings from the resource.
    //
    if ( uFormat )
        lpFormat = AllocateString(NULL, uFormat);
    if ( uCaption )
        lpCaption = AllocateString(NULL, uCaption);

    // Return the return value of the MessageBox() call.  If there was a memory
    // error, 0 will be returned.
    //
    nReturn = MsgBoxLst(hwndParent, lpFormat, lpCaption, uType, lpArgs);

    // Free the format and caption strings.
    //
    FREE(lpFormat);
    FREE(lpCaption);    

    // Return the value saved from the previous function call.
    //
    return nReturn;
}

void CenterDialog(HWND hwnd)
{
    CenterDialogEx(NULL, hwnd); 
}


void CenterDialogEx(HWND hParent, HWND hChild)
{
    RECT rcChild,
         rcParent;

    if ( GetWindowRect(hChild, &rcChild) )
    {
        // If parent is specified center with respect to parent.
        if ( hParent && (GetWindowRect(hParent, &rcParent)) )
            SetWindowPos(hChild, NULL, ((rcParent.right + rcParent.left - (rcChild.right - rcChild.left)) / 2), ((rcParent.bottom + rcParent.top - (rcChild.bottom - rcChild.top)) / 2), 0, 0, SWP_NOSIZE | SWP_NOACTIVATE);

        // Otherwise center with respect to screen.
        //
        else 
            SetWindowPos(hChild, NULL, ((GetSystemMetrics(SM_CXSCREEN) - (rcChild.right - rcChild.left)) / 2), ((GetSystemMetrics(SM_CYSCREEN) - (rcChild.bottom - rcChild.top)) / 2), 0, 0, SWP_NOSIZE | SWP_NOACTIVATE);
    }
}
        

        


INT_PTR CALLBACK SimpleDialogProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_INITDIALOG:
            //CenterDialog(hwnd);
            return FALSE;

        case WM_COMMAND:
            EndDialog(hwnd, LOWORD(wParam));
            return FALSE;

        default:
            return FALSE;
    }

    return TRUE;
}

INT_PTR SimpleDialogBox(HINSTANCE hInstance, LPCTSTR lpTemplate, HWND hWndParent)
{
    return DialogBox(hInstance, lpTemplate, hWndParent, SimpleDialogProc);
}

/****************************************************************************\

HFONT                       // Returns a valid handle to a font if it is
                            // successfully created, or NULL if something
                            // failed.  The font handle should be deleteted
                            // with DeleteObject() when it is no longer
                            // needed.

GetFont(                    // This function creates a font based in the info
                            // passed in.

    HWND hwndCtrl,          // Handle to a control that is used for the
                            // default font characteristics.  This may be
                            // NULL if not default is control is available.

    LPTSTR lpFontName,      // Points to a string that contains the name of
                            // the font to create. This parameter may be NULL
                            // if a valid control handle is passed in.  In
                            // that case, the font of the control is used.

    DWORD dwFontSize,       // Point size to use for the font.  If it is zero,
                            // the default is used.

    BOOL bSymbol            // If this is TRUE, the font is set to
                            // SYMBOL_CHARSET.  Typically this is FALSE.

);

\****************************************************************************/

HFONT GetFont(HWND hwndCtrl, LPTSTR lpFontName, DWORD dwFontSize, LONG lFontWeight, BOOL bSymbol)
{
    HFONT           hFont;
    LOGFONT         lFont;
    BOOL            bGetFont;

    // If the font name is passed in, then try to use that
    // first before getting the font of the control.
    //
    if ( lpFontName && *lpFontName )
    {
        // Make sure the font name is not longer than
        // 32 characters (including the NULL terminator).
        //
        if ( lstrlen(lpFontName) >= sizeof(lFont.lfFaceName) )
            return NULL;

        // Setup the structure to use to get the
        // font we want.
        //
        ZeroMemory(&lFont, sizeof(LOGFONT));
        lFont.lfCharSet = DEFAULT_CHARSET;
        lstrcpy(lFont.lfFaceName, lpFontName);
    }
        
    // First try to get the font that we wanted.
    //
    if ( ( lpFontName == NULL ) ||
         ( *lpFontName == NULLCHR ) ||
         ( (hFont = CreateFontIndirect((LPLOGFONT) &lFont)) == NULL ) )
    {
        // Couldn't get the font we wanted, try the font of the control
        // if a valid window handle was passed in.
        //
        if ( ( hwndCtrl == NULL ) ||
             ( (hFont = (HFONT) (WORD) SendMessage(hwndCtrl, WM_GETFONT, 0, 0L)) == NULL ) )
        {
            // All atempts to get the font failed.  We must return NULL.
            //
            return NULL;
        }
    }

    // Return the font we have now if we don't need to
    // change the size or weight.
    //
    if ( (lFontWeight == 0) && (dwFontSize == 0) )
        return hFont;

    // We must have a valid HFONT now.  Fill in the structure
    // and setup the size and weight we wanted for it.
    //
    bGetFont = GetObject(hFont, sizeof(LOGFONT), (LPVOID) &lFont);
    DeleteObject(hFont);

    if ( bGetFont )
    {
        // Set the bold and point size of the font.
        //
        if ( lFontWeight )
            lFont.lfWeight = lFontWeight;
        if ( dwFontSize )
            lFont.lfHeight = -MulDiv(dwFontSize, GetDeviceCaps(GetDC(NULL), LOGPIXELSY), 72);
        if ( bSymbol )
            lFont.lfCharSet = SYMBOL_CHARSET;

        // Create the font.
        //
        hFont = CreateFontIndirect((LPLOGFONT) &lFont);
    }
    else
        hFont = NULL;

    return hFont;
}

void ShowEnableWindow(HWND hwnd, BOOL bShowEnable)
{
    EnableWindow(hwnd, bShowEnable);
    ShowWindow(hwnd, bShowEnable ? SW_SHOW : SW_HIDE);
}

/****************************************************************************\

BOOL                        // Returns TRUE if we are running a server OS.

IsServer(                   // This routine checks if we're running on a
                            // Server OS.

    VOID

);

\****************************************************************************/

BOOL IsServer(VOID) 
{
    OSVERSIONINFOEX verInfo;
    BOOL            fReturn = FALSE;

    verInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
    if ( ( GetVersionEx((LPOSVERSIONINFO) &verInfo) ) &&
         ( verInfo.dwPlatformId == VER_PLATFORM_WIN32_NT ) &&
         ( ( verInfo.wProductType == VER_NT_SERVER ) ||
           ( verInfo.wProductType == VER_NT_DOMAIN_CONTROLLER ) ) )
    {
        fReturn = TRUE;
    }

    return fReturn;
}


BOOL IsIA64() 
/*++
===============================================================================
Routine Description:

    This routine checks if we're running on a 64-bit machine.

Arguments:

    None - 

Return Value:

    TRUE - We are running on 64-bit machine.
    FALSE - Not a 64-bit machine.

===============================================================================
--*/
{
    BOOL        fReturn         = FALSE;
    ULONG_PTR   Wow64Info       = 0;
    DWORD       dwSt            = 0;
    SYSTEM_INFO siSystemInfo;

    ZeroMemory( &siSystemInfo, sizeof(SYSTEM_INFO) );
    GetSystemInfo(&siSystemInfo);

    if ( (siSystemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) ||
         (siSystemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64) )
        fReturn = TRUE;
    

    if (!fReturn)
    {
        // Now make sure that GetSystemInfo isn't lying because we are in emulation mode.
    
        dwSt = NtQueryInformationProcess(GetCurrentProcess(), ProcessWow64Information, &Wow64Info, sizeof(Wow64Info), NULL);
        if (!NT_SUCCESS(dwSt)) 
        {
            // Handle to process is bad, or the code is compiled 32-bit and running on NT4 or earlier.
            // Do nothing

        } 
        else if (Wow64Info)
        {
            // The process is 32-bit and is running inside WOW64.
            // We are really on IA64 and running in 32-bit mode.
            fReturn = TRUE;

        }
    }
    return fReturn;

}







BOOL ValidDosName(LPCTSTR lpName)
{
    LPCTSTR lpSearch    = lpName;
    int     nDot        = 0,
            nSpot       = 0,
            nLen;

    // Do the easy checks.
    //
    if ( ( lpSearch == NULL ) ||
         ( *lpSearch == NULLCHR ) ||
         ( (nLen = lstrlen(lpSearch)) > 12 ) )
    {
        return FALSE;
    }

    // Search the string.
    //
    for (; *lpSearch; lpSearch++)
    {
        // Check for dots.
        //
        if ( *lpSearch == _T('.') )
        {
            // Keep track of the number of dots.
            //
            nDot++;
            nSpot = (int) (lpSearch - lpName);
        }
        else
        {
            // Check for valid characters.
            //
            if ( !( ( ( _T('0') <= *lpSearch ) && ( *lpSearch <= _T('9') ) ) ||
                    ( ( _T('a') <= *lpSearch ) && ( *lpSearch <= _T('z') ) ) ||
                    ( ( _T('A') <= *lpSearch ) && ( *lpSearch <= _T('Z') ) ) ||
                    ( *lpSearch == _T('-') ) ||
                    ( *lpSearch == _T('_') ) ||
                    ( *lpSearch == _T('~') ) ) )
            {
                // Invalid character.
                //
                return FALSE;
            }
        }
    }

    // Make sure the dot is in the right place.
    //
    if ( ( nDot > 1 ) ||
         ( ( nDot == 0 ) && ( nLen > 8 ) ) ||
         ( ( nDot == 1 ) && ( nSpot > 8 ) ) ||
         ( ( nDot == 1 ) && ( (nLen - nSpot) > 4 ) ) )
    {
        return FALSE;
    }

    return TRUE;
}

DWORD GetLineArgs(LPTSTR lpSrc, LPTSTR ** lplplpArgs, LPTSTR * lplpAllArgs)
{
    LPTSTR  lpCmdLine,
            lpArg,
            lpDst;
    DWORD   dwArgs = 0;
    BOOL    bQuote;

    // Fist make sure that we were passed in a valid pointer, we have a command
    // line to parse, and that we were able to allocate the memory to hold it.
    //
    if ( ( lplplpArgs != NULL ) &&
         ( lpSrc ) &&
         ( *lpSrc ) &&
         ( lpCmdLine = (LPTSTR) MALLOC((lstrlen(lpSrc) + 1) * sizeof(TCHAR)) ) )
    {
        // Fist parse the command line into NULL terminated sub strings.
        //
        lpDst = lpCmdLine;
        while ( *lpSrc )
        {
            // Eat the preceeding spaces.
            //
            while ( *lpSrc == _T(' ') )
                lpSrc = CharNext(lpSrc);

            // Make sure we still have an argument.
            //
            if ( *lpSrc == _T('\0') )
                break;

            // Return a pointer to all the command line args if they want one.
            //
            if ( ( dwArgs == 1 ) && lplpAllArgs )
                *lplpAllArgs = lpSrc;

            // Save the current arg pointer.
            //
            lpArg = lpDst;
            dwArgs++;

            // See if we are looking for the next quote or space.
            //
            if ( bQuote = (*lpSrc == _T('"')) )
                lpSrc = CharNext(lpSrc);

            // Copy the argument into our allocated buffer until we
            // hit the separating character (which will always be a space).
            //
            while ( *lpSrc && ( bQuote || ( *lpSrc != _T(' ') ) ) )
            {
                // We special case the quote.
                //
                if ( *lpSrc == _T('"') )
                {
                    // If the character before the quote is a backslash, then
                    // we don't count this as the separating quote.
                    //
                    LPTSTR lpPrev = CharPrev(lpCmdLine, lpDst);
                    if ( lpPrev && ( *lpPrev == _T('\\') ) )
                        *lpPrev = *lpSrc++;
                    else
                    {
                        // Since we have found the separating quote, set this to
                        // false so we look for the next space.
                        //
                        bQuote = FALSE;
                        lpSrc++;
                    }                        
                }
                else
                    *lpDst++ = *lpSrc++;
            }

            // NULL terminate this argument.
            //
            *lpDst++ = _T('\0');
        }

        // Now setup the pointers to each argument.  Make sure we have some arguments
        // to return and that we have the memory allocated for the array.
        //
        if ( *lpCmdLine && dwArgs && ( *lplplpArgs = (LPTSTR *) MALLOC(dwArgs * sizeof(LPTSTR)) ) )
        {
            DWORD dwCount = 0;

            // Copy a pointer to each NULL terminated sub string into our
            // array of arguments we are going to return.
            //
            do
            {
                *(*lplplpArgs + dwCount) = lpCmdLine;
                lpCmdLine += lstrlen(lpCmdLine) + 1;
            }
            while ( ++dwCount < dwArgs );
        }
        else
        {
            // Either there were no command line arguments, or the memory allocation
            // failed for the list of arguments to return.
            //
            dwArgs = 0;
            FREE(lpCmdLine);
        }
    }

    return dwArgs;
}

DWORD GetCommandLineArgs(LPTSTR ** lplplpArgs)
{
    return GetLineArgs(GetCommandLine(), lplplpArgs, NULL);
}

// 
// Generic singularly linked list pvItem must be allocated with MALLOC
//
BOOL FAddListItem(PGENERIC_LIST* ppList, PGENERIC_LIST** pppNewItem, PVOID pvItem)
{    
    if (pppNewItem && *pppNewItem == NULL)
        *pppNewItem = ppList;

    if (*pppNewItem) {
        if (**pppNewItem = (PGENERIC_LIST)MALLOC(sizeof(GENERIC_LIST))) {
            (**pppNewItem)->pNext = NULL;
            (**pppNewItem)->pvItem = pvItem;
            *pppNewItem = &((**pppNewItem)->pNext);
            return TRUE;
        }
    }
    return FALSE;
}

void FreeList(PGENERIC_LIST pList)
{
    while (pList) {
        PGENERIC_LIST pTemp = pList;
        pList = pList->pNext;

        FREE(pTemp->pvItem);
        FREE(pTemp);
    }
}

// Find factory.exe from the current process, should be in same directory
//
BOOL FGetFactoryPath(LPTSTR pszFactoryPath)
{
    // Attempt to locate FACTORY.EXE
    //
    // NTRAID#NTBUG9-549770-2002/02/26-acosma,georgeje - Possible buffer overflow.
    //
    if (pszFactoryPath && GetModuleFileName(NULL, pszFactoryPath, MAX_PATH)) {
        if (PathRemoveFileSpec(pszFactoryPath)) {
            PathAppend(pszFactoryPath, TEXT("FACTORY.EXE"));
            if (FileExists(pszFactoryPath))
                return TRUE;
        }
    }
    return FALSE;
}

// Find sysprep.exe from the current process, should be in same directory
//
BOOL FGetSysprepPath(LPTSTR pszSysprepPath)
{
    // Attempt to locate SYSPREP.EXE
    //
    // NTRAID#NTBUG9-549770-2002/02/26-acosma,georgeje - Possible buffer overflow.
    //
    if (pszSysprepPath && GetModuleFileName(NULL, pszSysprepPath, MAX_PATH)) {
        if (PathRemoveFileSpec(pszSysprepPath)) {
            PathAppend(pszSysprepPath, TEXT("SYSPREP.EXE"));
            if (FileExists(pszSysprepPath))
                return TRUE;
        }
    }
    return FALSE;
}


//------------------------------------------------------------------------------------------------------
//
// Function:    ConnectNetworkResource
//
// Purpose:     This function allows the user to connect to a network resource with
//              supplied credentials.
//
// Arguments:   lpszPath:       Network Resource that should be shared out
//              lpszUsername:   Username for credentials, can be in form of domain\username
//              lpszPassword:   Password to use for credentials
//              bState:         If set to TRUE we will add the connection, if FALSE we will
//                              attempt to delete the connection
//
// Returns:     BOOL            If the NetUse command was successful, TRUE is returned
//
//------------------------------------------------------------------------------------------------------
NET_API_STATUS ConnectNetworkResource(LPTSTR lpszPath, LPTSTR lpszUsername, LPTSTR lpszPassword, BOOL bState)
{
    BOOL            bRet   = FALSE;
    USE_INFO_2      ui2;
    NET_API_STATUS  nerr_NetUse;
    TCHAR           szDomain[MAX_PATH]  = NULLSTR,
                    szNetUse[MAX_PATH]  = NULLSTR;
    LPTSTR          lpUser,
                    lpSearch;

    // Zero out the user information structure
    //
    ZeroMemory(&ui2, sizeof(ui2));

    // Copy the path into our buffer so we can work with it
    //
    lstrcpyn(szNetUse, lpszPath, AS(szNetUse));
    StrRTrm(szNetUse, CHR_BACKSLASH);

    if ( szNetUse[0] && PathIsUNC(szNetUse) )
    {
        // Disconnect from existing share
        //
        nerr_NetUse = NetUseDel(NULL, szNetUse, USE_NOFORCE);

        // We need to Add a connection
        //
        if ( bState )
        {
            ui2.ui2_remote      = szNetUse;
            ui2.ui2_asg_type    = USE_DISKDEV;
            ui2.ui2_password    = lpszPassword;
    
            lstrcpyn(szDomain, lpszUsername, AS(szDomain));

            // Break up the Domain\Username for the NetUse function
            //
            if (lpUser = StrChr(szDomain, CHR_BACKSLASH) )
            {
                // Put a NULL character after the domain part of the user name
                // and advance the pointer to point to the actual user name.
                //
                *(lpUser++) = NULLCHR;
            }
            else
            {
                // Use the computer name in the path as the domain name.
                //
                if ( lpSearch = StrChr(szNetUse + 2, CHR_BACKSLASH) )
                    lstrcpyn(szDomain, szNetUse + 2, (int)((lpSearch - (szNetUse + 2)) + 1));
                else
                    lstrcpyn(szDomain, szNetUse + 2, AS(szDomain));

                lpUser = lpszUsername;
            }

            // Set the domain and user name pointers into our struct.
            //
            ui2.ui2_domainname  = szDomain;
            ui2.ui2_username    = lpUser;

            // Create a connect to the share
            //
            nerr_NetUse = NetUseAdd(NULL, 2, (LPBYTE) &ui2, NULL);
        }
    }
    else
        nerr_NetUse = NERR_UseNotFound;

    // Return failure/success
    //
    return nerr_NetUse;
}

BOOL GetUncShare(LPCTSTR lpszPath, LPTSTR lpszShare, DWORD cbShare)
{
    BOOL    bRet;
    LPCTSTR lpSrc = lpszPath;
    LPTSTR  lpDst = lpszShare;
    DWORD   dwBackslashes,
            dwCount;

    // Make sure the path is a UNC by calling the shell function.
    //
    bRet = PathIsUNC(lpszPath);

    // This will loop through the path string twice, each time coping all the
    // backslashes and then all the non-backslashes.  So if the string passed
    // in was "\\COMPUTER\SHARE\DIR\FILE.NAME", the first pass will copy
    // "\\COMPUTER" and the next pass would then copy "\SHARE" so the final
    // string would then be "\\COMPUTER\SHARE".  This loop also verifies there
    // are the correct number of backslashes and non-backslashes.  If there is
    // no return buffer, then we just are verifing the share.
    //
    for ( dwBackslashes = 2; dwBackslashes && bRet; dwBackslashes-- )
    {
        // First copy the backslashes.
        //
        dwCount = 0;
        while ( _T('\\') == *lpSrc )
        {
            if ( lpDst && cbShare )
            {
                *lpDst++ = *lpSrc;
                cbShare--;
            }
            lpSrc++;
            dwCount++;
        }

        // Make sure the number of backslashes is correct.
        // The fist pass there should be two and the next
        // pass should be just one.
        //
        if ( dwBackslashes != dwCount )
        {
            bRet = FALSE;
        }
        else
        {
            // Now copy the non-backslashes.
            //
            dwCount = 0;
            while ( ( *lpSrc ) &&
                    ( _T('\\') != *lpSrc ) )
            {
                if ( lpDst && cbShare )
                {
                    *lpDst++ = *lpSrc;
                    cbShare--;
                }
                lpSrc++;
                dwCount++;
            }

            // Make sure there was at least one non-backslash.
            // character.
            //
            // Also if we are on the first pass and the path
            // buffer is already empty, then we don't have the
            // share part so just error out.
            //
            if ( ( 0 == dwCount ) ||
                 ( ( 2 == dwBackslashes ) &&
                   ( NULLCHR == *lpSrc ) ) )
            {
                bRet = FALSE;
            }
        }
    }

    // Only fix up the return buffer if there is one.
    //
    if ( lpszShare )
    {
        // Make sure that we didn't fail and that we still
        // have room for the null terminator.
        //
        if ( bRet && cbShare )
        {
            // Don't forget to null terminate the return string.
            //
            *lpDst = NULLCHR;
        }
        else
        {
            // If we failed or ran out of buffer room, make sure
            // we don't return anything.
            //
            *lpszShare = NULLCHR;
        }
    }

    return bRet;
}

DWORD GetSkuType()
{
    DWORD           dwRet = 0;
    OSVERSIONINFOEX osvi;

    ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);

    if ( GetVersionEx((LPOSVERSIONINFO) &osvi) )
    {
        if ( VER_NT_WORKSTATION == osvi.wProductType )
        {
            if ( GET_FLAG(osvi.wSuiteMask, VER_SUITE_PERSONAL) )
            {
                dwRet = VER_SUITE_PERSONAL;
            }
            else
            {
                dwRet = VER_NT_WORKSTATION;
            }
        }
        else
        {
            if ( GET_FLAG(osvi.wSuiteMask, VER_SUITE_DATACENTER) )
            {
                dwRet = VER_SUITE_DATACENTER;
            }
            else if ( GET_FLAG(osvi.wSuiteMask, VER_SUITE_ENTERPRISE) )
            {
                dwRet = VER_SUITE_ENTERPRISE;
            }
            else if ( GET_FLAG(osvi.wSuiteMask, VER_SUITE_BLADE) )
            {
                dwRet = VER_SUITE_BLADE;
            }
            else
            {
                dwRet = VER_NT_SERVER;
            }
        }
    }

    return dwRet;
}