windows-xp/Source/XPSP1/NT/net/rras/cm/cmdial/main.cpp

//+----------------------------------------------------------------------------
//
// File:     main.cpp
//
// Module:   CMDIAL32.DLL
//
// Synopsis: The main module implementing interfaces to external (RAS, 
//           InetDialHandler and internal modules (CmCustomDialDlg).
//
// Copyright (c) 1996-1999 Microsoft Corporation
//
// Author:   Dondu      Created    96'
//
// History: 
//              5/05/97     Modified    byao
//                                      added 'InetDialHandler()' for IE4
//              1/26/98     Modified    quintinb
//                                      Added RasCustomDialDlg, RasCustomEntryDlg,
//                                      RasCustomHangUp, and RasCustomDial stubs.
//              02/10/98    Modified    Heavily refvised for 1.2 architectural shift
//
//+----------------------------------------------------------------------------

#include <windows.h>

//#ifdef  WIN32_LEAN_AND_MEAN
//#include <shellapi.h>
//#endif

#include <ras.h>
#include <raserror.h>
#include <rasdlg.h>

#include "cmmaster.h"
#include <wininet.h>
#include "cmtiming.h"
#include "DynamicLib.h"

#include "shelldll.cpp"

//
// Globals
//

HINSTANCE g_hInst;

const TCHAR* const c_pszCmmgrExe = TEXT("CMMGR32.EXE");
const TCHAR* const c_pszExplorerExe = TEXT("EXPLORER.EXE");
const TCHAR* const c_pszCmstpExe = TEXT("CMSTP.EXE");
const TCHAR* const c_pszRunDll32Exe = TEXT("RUNDLL32.EXE");
const TCHAR* const c_pszRasAutoUExe = TEXT("RASAUTOU.EXE");

const TCHAR* const c_pszConnectMutex = TEXT("Connection Manager Connect - "); // Root only

#define RASDDFLAG_Reserved1 0x10000000

//+---------------------------------------------------------------------------
//
//  struct CmRasDialDlg
//
//  Description: Append CM reconnect infor mation to the end of RASDIALDLG
//
//  History:    fengsun Created     11/14/97
//
//----------------------------------------------------------------------------
struct CmRasDialDlg
{
    RASDIALDLG RasDialDlgInfo;  
    struct CmRasDialDlg* pSelf; // point to itself, used to verify CmReConnect
    DWORD  dwSignature;         // verify CmReConnect
    CMDIALINFO CmInfo;          // Reconnect information

    enum {CM_RECONNECT_SIGNATURE = 0xC6687DB5};  // To verify dwSignature
};

//+----------------------------------------------------------------------------
//
// Function:  StripTunnelSuffixW
//
// Synopsis:  Determines if a connection name string contains a suffix of 
//            " (for advanced use only)" and removes it if found.
//
// Arguments: LPWSTR pszwConnectionName - The string (connectoid name).
//
// Returns:   Nothing
//
// History:   nickball      created     1/11/00
//
//+----------------------------------------------------------------------------
void StripTunnelSuffixW(LPWSTR pszwConnectionName)
{
    MYDBGASSERT(pszwConnectionName);

    if (NULL == pszwConnectionName)
    {
        return;
    }

    //
    // On 9X we have to resolve the tunnel connectoid name to the 
    // service name by removing " (for advanced use only)" if it.
    // exists. 
    //

    if (OS_W9X)
    {
        LPWSTR pszwSuffix = GetTunnelSuffix();

        //
        // Search for suffix and truncate as necessary.
        // Note: Assumes that the service name does not match our suffix.
        //

        if (pszwSuffix)
        {           
            LPWSTR pszwTmp = CmStrStrW(pszwConnectionName, pszwSuffix); 
           
            if (pszwTmp)
            {
                CMTRACE1(TEXT("StripTunnelSuffixW - found suffix of %s"), pszwTmp);
                *pszwTmp = L'\0';
                CMTRACE1(TEXT("StripTunnelSuffixW - long service name is %s"), pszwConnectionName);
            }
        }       

        CmFree(pszwSuffix);
    }
}

//+----------------------------------------------------------------------------
//
// Function:  IsStringWithInBuffer
//
// Synopsis:  Verify whether a string go beyond the buffer.
//            
//
// Arguments: const TCHAR* pszStr - the string to be tested
//            DWORD dwSize - the size of the buffer
//
// Returns:   BOOL - TRUE if is
//
// History:   fengsun Created Header    5/22/98
//
//+----------------------------------------------------------------------------
BOOL IsStringWithInBuffer(const TCHAR* pszStr, DWORD dwSize)
{
    MYDBGASSERT(pszStr);

    //
    // Can not do strlen here.  If the data in pszStr is garbage
    // strlen can cause access voilation
    //
    for (DWORD i =0; i<dwSize; i++)
    {
        if (pszStr[i] == TEXT('\0'))
        {
            return TRUE;
        }
    }

    return FALSE;
}



//+----------------------------------------------------------------------------
//
// Function:  IsCmReconnectRequest
//
// Synopsis:  Check whether CM reconnect information is appended to RASDIALDLG
//
// Arguments: const RASDIALDLG* lpInfo - the structure to check
//
// Returns:   BOOL - TRUE if is
//
// History:   fengsun Created Header    5/22/98
//
//+----------------------------------------------------------------------------
BOOL IsCmReconnectRequest(const RASDIALDLG* lpInfo)
{
    MYDBGASSERT(lpInfo);

    if (NULL == lpInfo)
    {
        return FALSE;
    }

    CMTRACE1(TEXT("IsCmReconnectRequest - RASDIALDLG.dwFlags is 0x%x"), ((LPRASDIALDLG)lpInfo)->dwFlags);
    
    //
    // See its our reconnect case by examining the dwFlags of lpInfo
    //

    if (((LPRASDIALDLG)lpInfo)->dwFlags & RASDDFLAG_Reserved1)
    {
        //
        // Test whether we can read beyond RASDIALDLG to avoid access violation
        //

        if (!IsBadReadPtr(lpInfo, sizeof(CmRasDialDlg)) )
        {
            CmRasDialDlg* const pCmDlgInfo = (CmRasDialDlg* const)lpInfo;

            //
            // Test whether it has the flag we added
            //

            if (pCmDlgInfo->pSelf == pCmDlgInfo && 
                pCmDlgInfo->dwSignature == CmRasDialDlg::CM_RECONNECT_SIGNATURE)
            {
                //
                // Whether the reconnect information is valid
                //

                //
                // Does password seem ok?  Whether the password go beyond CmIndo.szPassword
                // We can not do strlen here.  If we have some garbage here, strlen can 
                // cauce access violation.
                //

                if (IsStringWithInBuffer(pCmDlgInfo->CmInfo.szPassword, 
                        sizeof(pCmDlgInfo->CmInfo.szPassword)) )
                {
                    //
                    // Inet Password OK?
                    //
                    if (IsStringWithInBuffer(pCmDlgInfo->CmInfo.szInetPassword, 
                        sizeof(pCmDlgInfo->CmInfo.szInetPassword)) )
                    {
                        //
                        // skip the dwFlags
                        // This is a valid reconnect request from CMMON
                        //
                        return TRUE;
                    }
                }
            }
        }
    }

    return FALSE;
}

//+----------------------------------------------------------------------------
//
// Function:  CmReConnect
//
// Synopsis:  Used specificly for CMMON to call upon reconnect
//      This function is added to fix bug 169128: RasCustomHangup not called 
//          when hangup reconnected connection.
//      In order for RAS to call RasCustomHangup, we have to call RasDialDlg.
//      CMMON calls CmReConnect with reconnect information.  CmReconnect append 
//      CM specific information to the RASDIALDLG structure then calls RasDialDlg.
//      RasCustomHangup then figures out it is a reconnect request.
//
// Arguments: LPTSTR        lpszPhonebook - Ptr to the full path and filename of the phonebook.
//            LPTSTR        lpszEntry - Ptr to the name of the phone-book entry to dial.
//            LPCMDIALINFO lpCmInfo - The reconnect information
//
// Returns:   DWORD WINAPI - Return code
//
//+----------------------------------------------------------------------------
extern "C" 
BOOL CmReConnect(LPTSTR lpszPhonebook, 
    LPTSTR lpszEntry, 
    LPCMDIALINFO lpCmInfo)
{
    CMTRACE(TEXT("CmReconnect"));

    if (OS_NT5)
    {
        //
        // Call RasDialDlg for NT5
        //
        CmRasDialDlg CmDlgInfo;
        ZeroMemory(&CmDlgInfo, sizeof(CmDlgInfo));

        CmDlgInfo.RasDialDlgInfo.dwSize = sizeof(CmDlgInfo.RasDialDlgInfo);
        CmDlgInfo.RasDialDlgInfo.dwFlags = RASDDFLAG_Reserved1;
        CmDlgInfo.CmInfo = *lpCmInfo;
        CmDlgInfo.pSelf = &CmDlgInfo;
        CmDlgInfo.dwSignature = (DWORD)CmRasDialDlg::CM_RECONNECT_SIGNATURE;

        //
        // Load rasdlg.dll
        //

        CDynamicLibrary libRasDlg(TEXT("rasdlg.dll"));

        MYDBGASSERT(libRasDlg.IsLoaded());
        typedef BOOL (WINAPI* fnRasDialDlgTYPE)(
            LPTSTR lpszPhonebook, LPTSTR lpszEntry, LPTSTR lpszPhoneNumber,
            LPRASDIALDLG lpInfo );

#ifndef UNICODE
        LPSTR pszRasDialDlgText = {"RasDialDlgA"};
#else
        LPSTR pszRasDialDlgText = {"RasDialDlgW"};
#endif

        fnRasDialDlgTYPE fnRasDialDlg = (fnRasDialDlgTYPE)libRasDlg.GetProcAddress(pszRasDialDlgText);
        if (fnRasDialDlg)
        {
            //
            // We base on the assumption that RasDialDlg passes the same pointer to RasCustomDialDlg.
            //
            if (lpszPhonebook != NULL && lpszPhonebook[0] == TEXT('\0'))
            {
                return fnRasDialDlg(NULL, lpszEntry, NULL, (RASDIALDLG*)&CmDlgInfo);
            }

            return fnRasDialDlg(lpszPhonebook, lpszEntry, NULL, (RASDIALDLG*)&CmDlgInfo);
        }

        return FALSE;
    }
    else
    {
        //
        // For non-NT5 platform, call CmCustomDialDlg directly
        //
        
        return CmCustomDialDlg(NULL,        // hwndParent
                               RCD_AllUsers, // dwFlags
                               lpszPhonebook, 
                               lpszEntry, 
                               NULL,       // lpszPhoneNumber
                               NULL,       // lpRasDialDlg,
                               NULL,       // lpRasEntryDlg,
                               lpCmInfo);

    }
}

//+----------------------------------------------------------------------------
//
// Function:  WhoIsCaller
//
// Synopsis:  Helper function to determine if we were called manually from the
//            desktop or programmatically.
//
// Arguments: dwCaller - which desktop caller.
//
// Returns:   BOOL - TRUE if the caller matches one of those specified in dwCaller.
//
// History:   nickball    Created Header    3/17/98
//
//+----------------------------------------------------------------------------
BOOL WhoIsCaller(DWORD dwCaller)
{
    BOOL bRet = FALSE;

    TCHAR szTmp[MAX_PATH + 1];
    ZeroMemory(szTmp, sizeof(szTmp));

    //
    // Get the path of the calling process
    //

    MYVERIFY(GetModuleFileNameU(GetModuleHandleA(NULL), szTmp, MAX_PATH));      

    CMTRACE1(TEXT("WhoIsCaller() - Calling process is %s"), szTmp);

    //
    // Locate the filename part
    //

    LPTSTR pszName = StripPath(szTmp);
       
    MYDBGASSERT(pszName);

    if (pszName)
    {
        //
        // Compare against CM and Shell
        //

        if (dwCaller & DT_CMMGR)
        {
            bRet = (lstrcmpiU(pszName, c_pszCmmgrExe) == 0);
        }

        if (!bRet && dwCaller & DT_CMMON)
        {
            bRet |= (lstrcmpiU(pszName, c_pszCmMonExeName) == 0);
        }

        if (!bRet && dwCaller & DT_EXPLORER)
        {
            bRet |= (lstrcmpiU(pszName, c_pszExplorerExe) == 0);
        }
        
        if (!bRet && dwCaller & DT_CMSTP)
        {
            bRet |= (lstrcmpiU(pszName, c_pszCmstpExe) == 0);
        }

        if (!bRet && dwCaller & DT_RUNDLL32)
        {
            bRet |= (lstrcmpiU(pszName, c_pszRunDll32Exe) == 0);
        }

        if (!bRet && dwCaller & DT_RASAUTOU)
        {
            bRet |= (lstrcmpiU(pszName, c_pszRasAutoUExe) == 0);
        }

        CmFree(pszName);
    }

    return bRet;
}

//+----------------------------------------------------------------------------
//
// Function:  HandleCustomConnectRequest
//
// Synopsis:  Attempts to resolve a connect request for the specified entry by
//            examining the current state if any of that connection.
//
// Arguments: HWND hwndParent               - HWND of parent for user notification messages
//            CConnectionTable *pConnTable  - Ptr to the connection table - assumed open
//            LPCTSTR pszEntry              - The name of the service entry
//            DWORD dwFlags                 - The application flags FL_...
//            LPBOOL pfSuccess              - Ptr to flag indicating that the request was
//                                            both 1) resolved and 2) already connected
//
// Returns:   BOOL - TRUE if the request was resolved against the existing table data
//
// History:   nickball    Created     3/18/98
//
//+----------------------------------------------------------------------------
BOOL HandleCustomConnectRequest(
    HWND hwndParent,
    CConnectionTable *pConnTable,
    LPCTSTR pszEntry,
    DWORD dwFlags,
    LPBOOL pfSuccess)
{
    BOOL fResolvedInTable = FALSE;
        
    CM_CONNECTION Connection;
    ZeroMemory(&Connection, sizeof(CM_CONNECTION));

    //
    // Only if there is an existing entry do we have any work here
    //

    if (SUCCEEDED(pConnTable->GetEntry(pszEntry, &Connection)))
    {
        *pfSuccess = TRUE; // assume the best

        //
        // There is a connection entry for this service, examine state.
        //
        
        if (CM_RECONNECTPROMPT != Connection.CmState)
        {
            fResolvedInTable = TRUE; // we can handle it here
            
            //
            // The entry is connecting, connected, or disconnecting. If its a manual
            // connection just notify the user, otherwise check the exact state.
            //
            
            if (dwFlags & FL_DESKTOP) // Set in CMMGR
            {                                       
                NotifyUserOfExistingConnection(hwndParent, &Connection, FALSE);
            }
            else
            {                       
                //
                // Only if we are actually connected can we safely succeed.
                //
                
                if (CM_CONNECTED != Connection.CmState)
                {
                    *pfSuccess = FALSE;
                }
                else
                {
                    MYVERIFY(SUCCEEDED(pConnTable->AddEntry(Connection.szEntry, Connection.fAllUser))); // just bump ref
                }
            }
        }
        else
        {
            //
            // We must be in RECONNECT mode, if this connect request is 
            // from another source, tell CMMON to stop its monitoring. 
            // 

            if (!(dwFlags & FL_RECONNECT))
            {
                //
                // Its not a reconnect, so notify CMMON
                //

                HangupNotifyCmMon(pConnTable, Connection.szEntry);
            }
        }
    }

    return fResolvedInTable;
}

//+---------------------------------------------------------------------------
//
//  Function:   InetDialHandler
//
//  Synopsis:   Ansi and only form of the AutoDial handler . 
//
//  Arguments:  hwndParent[IN]      Handle to parent window. No longer ignored.
//              pszConnectoid[IN]   Connectoid name
//              dwFlags[IN]         Custom dial handler execution flags
//                                  Current the following flags are supported
//                                          INTERNET_CUSTOMDIAL_CONNECT 
//                                          INTERNET_CUSTOMDIAL_UNATTENDED
//                                          INTERNET_CUSTOMDIAL_DISCONNECT
//                                  These flags will be passed from WININET
//              lpdwRasError[OUT]   RasError code returned from ICM
//
//              Returns: The return type is different than one defined in wininet.h
//              TRUE:    This handler handled the dial request (connected or not)
//              FALSE:   This handler didn't handle the dial request
//
//              When returning TRUE, lpdwRasError is set to:
//                  ERROR_SUCCESS:              Call completed
//                  ERROR_USER_DISCONNECTION:   User cancelled dial request
//                  <other ras error>           Dial attempt failed.
//
//              This is a synchronous call. It should not return until the operation is complete.
//
//  Note:       We do not provide a wide form of this API as it is stored in 
//              the szAutoDialfunc member of the RASENTRY downlevel. If the 
//              wide form were avialable, RASAUTOU.EXE would call the function
//              (it appends A or W to the name that it finds in AutoDialFunc),
//              which would be inappropriate because the semantics of the 
//              parameters differ even though the function prototypes match.
//
//  History:    byao        Created                                                 - 05/05/97
//              quintinb    Rewrote to use InetDialHandlerW                         - 03/09/99
//              nickball    Removed InetDialHandlerW as it confuses RasAuto on NT4  - 07/28/99
//              quintinb    Always return true if connect request handled #390890   - 08/19/99
//
//----------------------------------------------------------------------------
extern "C" DWORD WINAPI InetDialHandler(HWND hwndParent, 
    LPCSTR pszConnectoid,
    DWORD dwFlags, 
    LPDWORD lpdwRasError) 
{
    MYDBGASSERT(pszConnectoid);
    MYDBGASSERT(lpdwRasError);
    CMTRACE(TEXT("InetDialHandler"));

    TCHAR           szProfilePath[MAX_PATH+1];
    LPWSTR          pszwConnectionName              = NULL;
    LPTSTR          pszRasPhoneBook                 = NULL;
    LPCMDIALINFO    lpCmInfo                        = NULL;
    BOOL            bRet                            = TRUE; // Read all comments before modifying this init value.
    BOOL            bAllUser;

    //
    // Check whether the parameters are valid
    //
    if (lpdwRasError)
    {
        if (! ((INTERNET_CUSTOMDIAL_CONNECT == dwFlags) ||
               (INTERNET_CUSTOMDIAL_UNATTENDED == dwFlags) ||
               (INTERNET_CUSTOMDIAL_DISCONNECT == dwFlags) ||
               (INTERNET_CUSTOMDIAL_SHOWOFFLINE== dwFlags) ))
        {
            CMASSERTMSG(FALSE, TEXT("InetDialHandler called with invalid flag"));
            *lpdwRasError = ERROR_INVALID_PARAMETER;
            return FALSE;
        }

        if (!pszConnectoid || TEXT('\0') == pszConnectoid[0])
        {
            *lpdwRasError = ERROR_INVALID_PARAMETER;
            return FALSE;
        }
    }
    else
    {
        return FALSE;   
    }
    
    //
    // Make a wide copy of the connectoid name. We also want a copy so 
    // that we can modify if necessary. On 9x we will resolve tunnel
    // entry names down to the base connectoid/service name.
    //

    pszwConnectionName = SzToWzWithAlloc(pszConnectoid);

    MYDBGASSERT(pszwConnectionName);

    if (!pszwConnectionName)
    {
        *lpdwRasError = GetLastError();
        bRet = FALSE;
        goto InetDialHandlerExit;
    }
   
    StripTunnelSuffixW(pszwConnectionName);

    //
    // Handle the Hangup case 
    //

    if (INTERNET_CUSTOMDIAL_DISCONNECT == dwFlags)
    {   
        *lpdwRasError = CmCustomHangUp(NULL, pszwConnectionName, TRUE, FALSE);
        bRet = (ERROR_SUCCESS == *lpdwRasError);
        goto InetDialHandlerExit;       
    }
    
    //
    // Its a connect request, setup CmInfo flags and call
    // 
    
    lpCmInfo = (LPCMDIALINFO) CmMalloc(sizeof(CMDIALINFO));
    
    if (NULL == lpCmInfo)
    {
        *lpdwRasError = ERROR_NOT_ENOUGH_MEMORY;
        bRet = FALSE;
        goto InetDialHandlerExit;       
    }

    if (INTERNET_CUSTOMDIAL_UNATTENDED == dwFlags ) 
    {
        //
        // Unattended dialing mode has been requested
        //

        lpCmInfo->dwCmFlags |= FL_UNATTENDED;
    }

    //
    // Note: Treat INTERNET_CUSTOMDIAL_SHOWOFFLINE the same as INTERNET_CUSTOMDIAL_CONNECT
    //

    bAllUser = ReadMapping(pszwConnectionName, szProfilePath, (sizeof(szProfilePath)/sizeof(TCHAR)), TRUE, TRUE); // TRUE == fAllUser, TRUE == bExpandEnvStrings

    if (FALSE == bAllUser)
    {
        if (FALSE == ReadMapping(pszwConnectionName, szProfilePath, (sizeof(szProfilePath)/sizeof(TCHAR)), FALSE, TRUE)) // FALSE == fAllUser, TRUE == bExpandEnvStrings
        {
            //
            // No mapping, no connection
            //
        
            *lpdwRasError = ERROR_INVALID_PARAMETER;
            bRet = FALSE;
            goto InetDialHandlerExit;
        }
        
        //
        // We have a single user profile path. If this is NT5, build a phonebook path
        //
        
        MYDBGASSERT(OS_NT5);

        if (OS_NT5)
        {
            pszRasPhoneBook = GetRasPbkFromNT5ProfilePath(szProfilePath);
            MYDBGASSERT(pszRasPhoneBook);
        }
    }
    
    //
    // InetDialHandler is usually an auto-dial case. 
    // Exceptions are:
    //      1) When called from WinLogon.exe on NT4.          NT #370311
    //      2) When called from Rundll32.exe.on any platform. 9x #127217
    //

    if ((FALSE == IsLogonAsSystem()) && (FALSE == WhoIsCaller(DT_RUNDLL32)))
    {
        lpCmInfo->dwCmFlags |= FL_AUTODIAL;
    }

    //
    // We set the error code based on whether or not we connected. However, 
    // we should always return TRUE to indicate to WININET, etc. that we 
    // handled the connection request (if we did actually handle it). 
    // Otherwise the caller (eg.IE) will try to dial its own dialer. #390890
    //

    if (CmCustomDialDlg(hwndParent, 
                        bAllUser ? RCD_AllUsers : RCD_SingleUser, 
                        pszRasPhoneBook, 
                        pszwConnectionName, 
                        NULL, 
                        NULL, 
                        NULL,
                        lpCmInfo))
    {
        *lpdwRasError = ERROR_SUCCESS;
    }
    else
    {
        *lpdwRasError = ERROR_USER_DISCONNECTION;
    }

InetDialHandlerExit:

    CmFree(pszRasPhoneBook);
    CmFree(lpCmInfo);
    CmFree(pszwConnectionName);

    CMTRACE2(TEXT("InetDialHandler returns %u with *lpdwRasError %u"), bRet, *lpdwRasError);

    return bRet; 
}

//+----------------------------------------------------------------------------
//
// Function:  AutoDialFunc
//
// Synopsis:  The original AutoDial callback function, provided for backward 
//            compatibility.
//
// Arguments: HWND hwndParent - The hwnd of the caller.
//            LPCTSTR pszEntry - The name of the connection to be dialed
//            DWORD dwFlags - Specific behaviour for the dial session.
//            LPDWORD pdwRetCode - Buffer for return code.
//
// Returns:   BOOL WINAPI - TRUE on success
//
// History:   nickball    Created Header    2/5/98
//
// Note:      This is used by RAS on NT4 SP6
//
//+----------------------------------------------------------------------------
extern "C" BOOL WINAPI AutoDialFunc(HWND hwndParent, 
    LPCSTR pszEntry, 
    DWORD dwFlags,
    LPDWORD pdwRetCode) 
{
    CMTRACE(TEXT("AutoDialFunc()"));

    MYDBGASSERT(OS_NT4);

    //
    //  InetDialHandler always returns TRUE, thus we must determine success or
    //  failure from the pdwRetCode.  If this is ERROR_SUCCESS then we should
    //  return TRUE, otherwise FALSE.
    //
    InetDialHandler(hwndParent, pszEntry, dwFlags, pdwRetCode);

    BOOL bRet = (ERROR_SUCCESS == *pdwRetCode);
        
    //
    // Always override pdwRetCode to ERROR_SUCCESS or RAS will throw an 
    // unpleasant error. RAS is only interested in success or failure.
    //

    *pdwRetCode = ERROR_SUCCESS;

    CMTRACE2(TEXT("AutoDialFunc returns %u with *pdwRetCode %u"), bRet, *pdwRetCode);

    return bRet;
}

//+----------------------------------------------------------------------------
//
// Function:  CopyRasInput
//
// Synopsis:  Simple wrapper function to make copies of the parameters we
//            receive from RAS.
//
// Arguments: LPTSTR* ppszOurCopy - pointer to the string pointer to hold the return string
//            LPWSTR pszwStringFromRas - String from RAS
//
// Returns:   BOOL - returns TRUE on Success, FALSE otherwise
//
// History:   quintinb Created     4/13/99
//
//+----------------------------------------------------------------------------
BOOL CopyRasInput(LPTSTR* ppszOurCopy, LPWSTR pszwStringFromRas)
{
    if (pszwStringFromRas)
    {
#ifndef _UNICODE
        *ppszOurCopy = WzToSzWithAlloc(pszwStringFromRas);
#else
        *ppszOurCopy = CmStrCpyAllocW (pszwStringFromRas);
#endif
        return (NULL != *ppszOurCopy);
    }

    return TRUE;
}

//+----------------------------------------------------------------------------
//
// Function: RasCustomDialDlg
//
// Synopsis:  Our implementation of RasCustomDialDlg extension, analogous to 
//            RasDialDlg, but providing custom functionality.
//
// Arguments: HINSTANCE hInstDll - The HINSTANCE of the caller.
//            DWORD dwFlags - Dial flags
//            LPTSTR lpszPhonebook - Ptr to the full path and filename of the phonebook.
//            LPTSTR lpszEntry - Ptr to the name of the phone-book entry to dial.
//            LPTSTR lpszPhoneNumber - Ptr toi replacement phone number
//            LPRASDIALDLG lpInfo - Ptr to structure for additional parameters
//
// Returns:   BOOL WINAPI - TRUE on success
//
// History:   nickball    Created Header    2/5/98
//
//+----------------------------------------------------------------------------

extern "C" BOOL WINAPI RasCustomDialDlg(HINSTANCE hInstDll, 
    DWORD dwFlags, 
    LPWSTR lpszwPhonebook, 
    LPWSTR lpszwEntry, 
    LPWSTR lpszwPhoneNumber, 
    LPRASDIALDLG lpInfo,
    PVOID pVoid)
{
    MYDBGASSERT(lpszwEntry);
    MYDBGASSERT(lpszwEntry[0]);
    MYDBGASSERT(lpInfo);

    CMTRACE1(TEXT("RasCustomDialDlg() - dwFlags = 0x%x"), dwFlags);
    CMTRACE1(TEXT("RasCustomDialDlg() - (RASDIALDLG)lpInfo->dwFlags = 0x%x"), lpInfo->dwFlags);
    if (NULL == lpszwEntry || 0 == lpszwEntry[0])
    {
        return FALSE;
    }

    //
    // We have the minimum requirement of an entry name, get to work
    //

    BOOL fSuccess = TRUE;
    LPTSTR pszEntry = NULL;
    LPTSTR pszPhonebook = NULL;

    //
    // If we have a Phonebook name make a copy
    //
    fSuccess = CopyRasInput(&pszPhonebook, lpszwPhonebook);

    if (fSuccess)
    {
        //
        // If we have an entry name (always do), make a copy to work with
        //
        fSuccess = CopyRasInput(&pszEntry, lpszwEntry);

        if (fSuccess)
        {
            //
            // Its always a simple connect request, no flags, no caller ids
            // 

            CMDIALINFO CmInfo;
            ZeroMemory(&CmInfo, sizeof(CMDIALINFO));

            //
            // If this is a reconnect request from CMMON, copy the information
            //
            if (lpInfo && IsCmReconnectRequest(lpInfo))
            {
                CmInfo = ((CmRasDialDlg* )lpInfo)->CmInfo;
            }
            else
            {
                //
                // If running under the system account its never an autodial
                //

                if (FALSE == IsLogonAsSystem())
                {
                    //
                    // See where the call originated. If not a desktop scenario
                    // then set the AUTODIAL flag so that we do the right thing
                    // down the line. This is ugly, but we have no other way of
                    // making the determination. Note: That this entry point 
                    // only exists on NT5 and is only called by RAS so the perf 
                    // hit is contained and CMMGR is not a valid desktop scenario
                    // so we don't have to check for it.
                    //
                    // DT_RASAUTOU - When ICS is enabled, rasauto starts the 
                    // rasautou.exe process to dial a connection. CM used to add
                    // rasautou in the process watch list. The issue was that 
                    // it goes away after connecting, so cmmon32 thought it needed
                    // to disconnected. Now, RASAUTOU is not a watched process 
                    // and cmmon32 does not disconnect.
                    //
                    if (FALSE == WhoIsCaller(DT_EXPLORER | DT_CMSTP | DT_RASAUTOU))
                    {
                        CmInfo.dwCmFlags |= FL_AUTODIAL;
                    }
                }  

                //
                //  Note that we want to set the Unattended flag if RASDDFLAG_NoPrompt is set, unless
                //  the RASDDFLAG_LinkFailure is also set.  We only use the RAS redial on link failure
                //  when we are logging on through WinLogon where we no longer user cmmon32.exe.  Elsewhere,
                //  redial is handled by Cmmon32.exe.  However, in this one case we don't want to be in 
                //  unattended mode because the user won't have a saved password (they logged on from WinLogon)
                //  and unattended mode will just exit silently if it doesn't have all the needed info to dial.
                //
                if ((lpInfo->dwFlags & RASDDFLAG_NoPrompt) && !(lpInfo->dwFlags & RASDDFLAG_LinkFailure))
                {
                    CmInfo.dwCmFlags |= FL_UNATTENDED;
                    CMTRACE(TEXT("RasCustomDialDlg - Setting CmInfo.dwCmFlags |= FL_UNATTENDED"));
                }
            }

            //
            //  If we have a RASNOUSER struct, make sure to encode the password
            //
            LPRASNOUSER lpRasNoUser = NULL;

            if (NULL != pVoid)
            {
                if (0 == (dwFlags & RCD_Eap))
                {
                    lpRasNoUser = (LPRASNOUSER) pVoid;
                    CmEncodePassword(lpRasNoUser->szPassword);
                }
            }

            fSuccess = CmCustomDialDlg(lpInfo ? lpInfo->hwndOwner : NULL,
                                       dwFlags, 
                                       pszPhonebook, 
                                       pszEntry, 
                                       NULL, 
                                       lpInfo,
                                       NULL,
                                       &CmInfo,
                                       pVoid);

            //
            //  If we have a RASNOUSER struct, decode the password to make it plain text again
            //
            if (NULL != lpRasNoUser)
            {
                CmDecodePassword(lpRasNoUser->szPassword);
            }
        }
    }

    //
    // Cleanup and go home
    //

    CmFree(pszPhonebook);       
    CmFree(pszEntry);      

    CMTRACE1(TEXT("RasCustomDialDlg returning %d"), fSuccess);

    return fSuccess;
}

//+----------------------------------------------------------------------------
//
// Function:  RasCustomEntryDlg
//
// Synopsis:  Our implementation of RasCustomEntryDlg extension, analogous to 
//            RasEntryDlg, but providing custom functionality.
//
// Arguments: HINSTANCE hInstDll - The HINSTANCE of the caller.
//            LPTSTR lpszPhonebook - Ptr to the full path and name of the phonebook to be edited.
//            LPTSTR lpszEntry - Ptr to the name of the entry to be edited.
//            LPRASENTRYDLG lpInfo - Ptr to structure containing additional parameters.
//
// Returns:   BOOL WINAPI - TRUE on success
//
// History:   nickball    2/5/98    Created Header    
//            nickball    1/11/00   Now used on 9x, added use of function
//                                  StripTunnelSuffixW() to resolve 9x tunnel
//                                  connectoid names.
//
//+----------------------------------------------------------------------------
extern "C" BOOL WINAPI RasCustomEntryDlg(HINSTANCE hInstDll, 
    LPWSTR lpszwPhonebook, 
    LPWSTR lpszwEntry, 
    LPRASENTRYDLG lpInfo,
    DWORD dwFlags)
{
    MYDBGASSERT(lpszwEntry);
    MYDBGASSERT(lpszwEntry[0]);

    CMTRACE1(TEXT("RasCustomEntryDlg() - dwFlags = 0x%x"), dwFlags);

    if (NULL == lpszwEntry || 0 == lpszwEntry[0])
    {
        return FALSE;
    }

    //
    // We have the minimum requirement of an entry name, get to work
    //

    BOOL fSuccess = TRUE;
    LPTSTR pszEntry = NULL;
    LPTSTR pszPhonebook = NULL;

    //
    // If we have a Phonebook name, make a copy to work with
    //
    fSuccess = CopyRasInput(&pszPhonebook, lpszwPhonebook);

    if (fSuccess)
    {
        //
        // If we have an entry name (always do), make a copy to work with
        //

        fSuccess = CopyRasInput(&pszEntry, lpszwEntry);

        if (fSuccess)
        {
            StripTunnelSuffixW(pszEntry); // Assumes we'll always compile Unicode

            //
            // Its always a properties request, set the flag and dial
            // 

            LPCMDIALINFO lpCmInfo = (LPCMDIALINFO) CmMalloc(sizeof(CMDIALINFO));

            if (lpCmInfo)
            {
                lpCmInfo->dwCmFlags |= FL_PROPERTIES;
                    
                fSuccess = CmCustomDialDlg(lpInfo ? lpInfo->hwndOwner : NULL, 
                                          dwFlags, 
                                          pszPhonebook, 
                                          pszEntry, 
                                          NULL, 
                                          NULL, 
                                          lpInfo,
                                          lpCmInfo);
            }
            else
            {
                fSuccess = FALSE;
            }

            CmFree(lpCmInfo);
        }
    }

    //
    // Cleanup and go home
    //

    CmFree(pszPhonebook);
    CmFree(pszEntry);
   
    return fSuccess;
}

//+----------------------------------------------------------------------------
//
// Function:  RasCustomHangUp
//
// Synopsis:  Our implementation of the RasCustomHangUp extension, analogous to 
//            RasHangup, but providing custom functionality. This function is
//            only called on NT5
//
// Arguments: HRASCONN hRasConn - The handle of the connection to be terminated.
//
// Returns:   DWORD WINAPI - Return code
//
// History:   nickball    Created Header    2/5/98
//
//+----------------------------------------------------------------------------
extern "C" DWORD WINAPI RasCustomHangUp(HRASCONN hRasConn)
{    
    //
    // If someone is calling this function on a system other then NT5, assert.
    //

    MYDBGASSERT(OS_NT5);
    MYDBGASSERT(hRasConn);

    CMTRACE(TEXT("RasCustomHangup()"));

    DWORD dwRes = ERROR_SUCCESS;  
 
    // 
    // First try to open the table, if none found then succeed.
    //
    
    CConnectionTable ConnTable;

    if (FAILED(ConnTable.Open()))
    {
        return dwRes;
    }
      
    //
    // If we have an entry, do the Disconnect
    //

    CM_CONNECTION Connection;
    ZeroMemory(&Connection, sizeof(CM_CONNECTION));
   
    if (SUCCEEDED(ConnTable.GetEntry(hRasConn, &Connection)))
    {
        MYDBGASSERT(hRasConn == Connection.hDial || hRasConn == Connection.hTunnel);
        // 
        // Check connect state of entry. 
        // If we are already in the DISCONNECTING state, perform a simple hangup.
        //
              
        if (CM_DISCONNECTING == Connection.CmState)
        {
            //
            // Set up RAS linkage
            //
        
            RasLinkageStruct rlsRasLink;
            ZeroMemory(&rlsRasLink, sizeof(RasLinkageStruct));

            if (TRUE == LinkToRas(&rlsRasLink) && rlsRasLink.pfnHangUp)
            {
                //
                // Linkage is good, make the hangup call
                //

                dwRes = DoRasHangup(&rlsRasLink, hRasConn);
            }
            else
            {
                MYDBGASSERT(FALSE);
                dwRes = ERROR_NOT_READY;             
            }

            //
            // Cleanup
            // 

            UnlinkFromRas(&rlsRasLink);
        }        
        else
        {
            //
            // If we're still here then we are not in the middle of an existing
            // disconnect, handle disconnect as we otherwise would.
            //

            dwRes = Disconnect(&ConnTable, &Connection, FALSE, FALSE);         
        }
    }
    else
    {
        dwRes = ERROR_NOT_FOUND;
    }
    
    //
    // We are done with the table, close it now. 
    //

    MYVERIFY(SUCCEEDED(ConnTable.Close()));    
    return dwRes;     
}

//+----------------------------------------------------------------------------
//
// Function:  RasCustomDial
//
// Synopsis:  Our implementation of RasCustomDial which we don't support.
//            Provided so that we can return E_NOTIMPL to indicate our lack of 
//            support for this extension.
//
// Arguments: N/A
//
// Returns:   DWORD WINAPI - E_NOTIMPL
//
// History:   nickball    Created Header    2/5/98
//
//+----------------------------------------------------------------------------

extern "C" DWORD WINAPI RasCustomDial(
    HINSTANCE hInstDll, 
    LPRASDIALEXTENSIONS lpRasDialExtensions, 
    LPWSTR lpszPhonebook, 
    LPRASDIALPARAMSW lpRasDialParams, 
    DWORD dwNotifierType, 
    LPVOID lpvNotifier, 
    LPHRASCONN lphRasConn, 
    DWORD dwFlags)
{
    return E_NOTIMPL;
}

//+----------------------------------------------------------------------------
//
// Function:  RasCustomDeleteEntryNotify
//
// Synopsis:  Our implementation of RasCustomDeleteEntry.
//
// Arguments: 
//
// Returns:   DWORD WINAPI - 
//
// History:   quintinb    Created Header    2/5/98
//
//+----------------------------------------------------------------------------
extern "C" DWORD WINAPI RasCustomDeleteEntryNotify(LPWSTR pszPhonebook, LPWSTR pszEntry, DWORD dwFlags)
{
    CDynamicLibrary UserEnv(L"userenv.dll");
    CDynamicLibrary Advapi32(L"advapi32.dll");
    DWORD dwReturn = ERROR_INVALID_PARAMETER;
    HANDLE hImpersonationToken = NULL;   // The token of the thread
    HANDLE hPrimaryToken = NULL;         // The primary token for the new process
    LPWSTR pszShortServiceName = NULL;
    LPWSTR pszCmDirpath = NULL;
    PROCESS_INFORMATION ProcessInfo = {0};
    STARTUPINFO StartupInfo = {0};
    WCHAR szCmpPath[MAX_PATH+1] = {0};
    WCHAR szInfPath[MAX_PATH+1];
    WCHAR szParams[2*MAX_PATH+1];

    typedef BOOL (WINAPI* pfnCreateEnvironmentBlockSpec)(LPVOID*, HANDLE, BOOL);
    typedef BOOL (WINAPI* pfnDestroyEnvironmentBlockSpec)(LPVOID);
    typedef BOOL (WINAPI* pfnDuplicateTokenExSpec)(HANDLE, DWORD, LPSECURITY_ATTRIBUTES, SECURITY_IMPERSONATION_LEVEL, TOKEN_TYPE, PHANDLE);
 
    pfnCreateEnvironmentBlockSpec pfnCreateEnvironmentBlock = NULL;
    pfnDestroyEnvironmentBlockSpec pfnDestroyEnvironmentBlock = NULL;
    pfnDuplicateTokenExSpec pfnDuplicateTokenEx = NULL;

    //
    //  Are we deleting an All User or a Single User Connection
    //
    BOOL bAllUser = (RCD_AllUsers & dwFlags);

    //
    //  Assume we are impersonating until we know otherwise.  Profiles deleted from the
    //  IE Connections Tab will not be impersonating, whereas delete requests from the
    //  folder go through Netman.dll in svchost.exe and are thus impersonating.
    //
    BOOL bImpersonatingProfile = TRUE;

    //
    //  Check the params, note that pszPhoneBook could be NULL
    //
    if ((NULL == pszEntry) || (L'\0' == pszEntry[0]) || 
        ((NULL != pszPhonebook) && (L'\0' == pszPhonebook[0])))
    {
        goto exit;
    }

    //
    //  Next lets setup the impersonation Token
    //
    if (OpenThreadToken(GetCurrentThread(), 
                        TOKEN_QUERY | TOKEN_DUPLICATE | TOKEN_ASSIGN_PRIMARY,
                        TRUE, &hImpersonationToken))
    {
        //
        // Okay, we have an impersonation token.  Lets get it, duplicate it and then
        // we can use it to call CreateProcessAsUser
        //

        pfnDuplicateTokenEx = (pfnDuplicateTokenExSpec)Advapi32.GetProcAddress("DuplicateTokenEx");

        if (NULL == pfnDuplicateTokenEx)
        {
            dwReturn = GetLastError();
            CMTRACE1(TEXT("RasCustomDeleteEntry -- Unable get proc address for DuplicateTokenEx, GLE %d"), GetLastError());
            goto exit;        
        }

        if (!pfnDuplicateTokenEx(hImpersonationToken,
                                TOKEN_IMPERSONATE | TOKEN_READ | TOKEN_ASSIGN_PRIMARY | TOKEN_DUPLICATE,
                                NULL, SecurityImpersonation, TokenPrimary, &hPrimaryToken))
        {
            dwReturn = GetLastError();
            CMTRACE1(TEXT("RasCustomDeleteEntry -- DuplicateTokenEx Failed, GLE %d"), GetLastError());
            goto exit;
        }
    }
    else
    {
        bImpersonatingProfile = FALSE;
    }

    //
    //  First let's read the Mappings Key, note that we don't expand the environment strings
    //  if it is an impersonating profile.  ExpandEnvironmentStrings doesn't have the correct
    //  environment loaded sometimes when we are impersonating.  We are launching cmstp.exe
    //  with a full environment block via CreateProcessAsUser, this will take care of the
    //  expansion so there is no need.
    //
    if (FALSE == ReadMapping(pszEntry, szCmpPath, MAX_PATH, bAllUser, !bImpersonatingProfile)) // !bImpersonatingProfile == bExpandEnvStrings
    {
        //
        // No mappings key, return failure
        //
        CMASSERTMSG(FALSE, TEXT("RasCustomDeleteEntry -- ReadMapping returned FALSE, unable to find the profile."));
        dwReturn = ERROR_FILE_NOT_FOUND;
        goto exit;
    }   

    //
    //  At this point we should have a mappings value.  We need to convert that into the INF
    //  path.  CM 1.0/1.1 profiles stored their INF files in the system(32) dir.
    //  CM 1.2  Profiles store this file in the Profile directory.  Since
    //  a user could install an old profile we must try the Legacy location
    //  if the current location fails.
    //

    pszShortServiceName = CmStripPathAndExt(szCmpPath);
    pszCmDirpath = CmStripFileName(szCmpPath, TRUE); // bKeepSlash == TRUE

    if (pszShortServiceName && pszCmDirpath)
    {
        //
        //  Build the new inf location
        //
        wsprintfW(szInfPath, L"%s%s\\%s.inf", pszCmDirpath, pszShortServiceName, pszShortServiceName);

        if (!FileExists(szInfPath) && bAllUser) // if the doesn't file exists and we are all user then try the sys dir
        {
            //
            //  Looks like this is an old style profile with the inf in the system directory.
            //  Now build the old style path and see if it exists.  Note that 1.0 profiles were All User only
            //
            if (0 != GetSystemDirectoryU(szInfPath, MAX_PATH))
            {
                lstrcatU(szInfPath, L"\\");
                lstrcatU(szInfPath, pszShortServiceName);
                lstrcatU(szInfPath, L".inf");
                
                if (!FileExists(szInfPath))
                {
                    CMASSERTMSG(FALSE, TEXT("RasCustomDeleteEntry -- Unable to locate profile inf."));
                    dwReturn = ERROR_FILE_NOT_FOUND;
                    goto exit;                
                }
            }
            else
            {
                dwReturn = GetLastError();
                goto exit;
            }
        }
    } 
    else
    {
        dwReturn = ERROR_NOT_ENOUGH_MEMORY;
        goto exit;
    }

    lstrcpyU(szParams, L"cmstp.exe /u /s \"");
    lstrcatU(szParams, szInfPath);
    lstrcatU(szParams, L"\"");

    if (bImpersonatingProfile)
    {
        //
        //  Fill in the environment block
        //
        WCHAR* pszEnvBlock;

        pfnCreateEnvironmentBlock = (pfnCreateEnvironmentBlockSpec)UserEnv.GetProcAddress("CreateEnvironmentBlock");
        pfnDestroyEnvironmentBlock = (pfnDestroyEnvironmentBlockSpec)UserEnv.GetProcAddress("DestroyEnvironmentBlock");

        if ((NULL == pfnCreateEnvironmentBlock) || (NULL == pfnDestroyEnvironmentBlock))
        {
            dwReturn = ERROR_PROC_NOT_FOUND;
            CMTRACE(TEXT("RasCustomDeleteEntry -- Unable to load pfnCreateEnvironmentBlock Or pfnDestroyEnvironmentBlock."));
            goto exit;
        }    

        if (pfnCreateEnvironmentBlock((void**)&pszEnvBlock, hPrimaryToken, TRUE))
        {
            if (CreateProcessAsUser(hPrimaryToken,
                                    NULL,                         // lpApplicationName
                                    szParams,                     // lpCommandLine
                                    NULL,                         // pProcessAttributes
                                    NULL,                         // lpThreadAttributes
                                    FALSE,                        // bInheritHandles
                                    CREATE_UNICODE_ENVIRONMENT,   // dwCreationFlags
                                    pszEnvBlock,                  // lpEnvironment
                                    NULL,                         // lpCurrentDirectory
                                    &StartupInfo,
                                    &ProcessInfo))
            {
                CloseHandle(ProcessInfo.hProcess);
                CloseHandle(ProcessInfo.hThread);
                dwReturn = ERROR_SUCCESS;
            }
            else
            {
                dwReturn = GetLastError();
                CMTRACE1(TEXT("RasCustomDeleteEntry -- CreateProcessAsUser Failed, GLE %d"), GetLastError());
            }

            pfnDestroyEnvironmentBlock(pszEnvBlock);
        }
        else
        {
            CMTRACE1(L"Unable to Create the Environment block, GLE %d", GetLastError());
        }
    }
    else
    {
        //
        //  We aren't impersonating just use regular CreateProcess
        //
        if (CreateProcess(NULL,                        // lpApplicationName
                          szParams,                    // lpCommandLine
                          NULL,                        // pProcessAttributes
                          NULL,                        // lpThreadAttributes
                          FALSE,                       // bInheritHandles
                          CREATE_UNICODE_ENVIRONMENT,  // dwCreationFlags
                          NULL,                        // lpEnvironment
                          NULL,                        // lpCurrentDirectory
                          &StartupInfo,
                          &ProcessInfo))
        {
            CloseHandle(ProcessInfo.hProcess);
            CloseHandle(ProcessInfo.hThread);
            dwReturn = ERROR_SUCCESS;
        }
        else
        {
            dwReturn = GetLastError();
            CMTRACE1(TEXT("RasCustomDeleteEntry -- CreateProcessAsUser Failed, GLE %d"), GetLastError());
        }
    }
exit:

    if (hImpersonationToken)
    {
        CloseHandle(hImpersonationToken);
    }

    if (hPrimaryToken)
    {
        CloseHandle(hPrimaryToken);
    }

    CmFree(pszCmDirpath);
    CmFree(pszShortServiceName);

    return dwReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  DllMain
//
// Synopsis:  Main entry point into the DLL.
//
// Arguments: HINSTANCE  hinstDLL - Our HINSTANCE
//            DWORD  fdwReason - The reason we are being called.
//            LPVOID  lpvReserved - Reserved
//
// Returns:   BOOL WINAPI - TRUE - always
//
// History:   nickball    Created Header    2/5/98
//
//+----------------------------------------------------------------------------
extern "C" BOOL WINAPI DllMain(HINSTANCE  hInstDLL, 
    DWORD  fdwReason, 
    LPVOID  lpvReserved) 
{
    switch (fdwReason)
    {
        case DLL_PROCESS_ATTACH:

            if (!InitUnicodeAPI())
            {
               //
               //  Without our U api's we are going no where.  Bail.
               //
               MessageBox(NULL, TEXT("Cmdial32.dll Initialization Error:  Unable to initialize Unicode to ANSI conversion layer, exiting."),
                          TEXT("Connection Manager"), MB_OK | MB_ICONERROR);
                return FALSE;
            }

            /*
            if (S_OK != CmLogInitialize(hInstDLL))
            {
                MessageBox(NULL, TEXT("Cmdial32.dll initialization error: Unable to initialize logging, exiting."),
                           TEXT("Connection Manager"), MB_OK | MB_ICONERROR);
                // not fatal
            }
            */

            CMTRACE(TEXT("====================================================="));
            CMTRACE1(TEXT(" CMDIAL32.DLL - LOADING - Process ID is 0x%x "), GetCurrentProcessId());
            CMTRACE(TEXT("====================================================="));
        
#ifdef DEBUG        
            TCHAR szTmp[MAX_PATH];            
            MYVERIFY(GetModuleFileNameU (GetModuleHandleA(NULL), szTmp, MAX_PATH));      
            CMTRACE1(TEXT("Calling process is %s"), szTmp);
#endif

            // 
            // Setup global instance data
            //

            g_hInst = hInstDLL;

            //
            // Disable thread attach notification
            //

            MYVERIFY(DisableThreadLibraryCalls(hInstDLL));

            break;

        case DLL_PROCESS_DETACH:
        
            CMTRACE(TEXT("====================================================="));
            CMTRACE1(TEXT(" CMDIAL32.DLL - UNLOADING - Process ID is 0x%x "), GetCurrentProcessId());
            CMTRACE(TEXT("====================================================="));

            if (!UnInitUnicodeAPI())
            {
                CMASSERTMSG(FALSE, TEXT("cmdial32 dllmain UnInitUnicodeAPI failed - we are probably leaking a handle"));
            }
            
            //
            // Unlike Windows 95, on Windows NT, Windows classes 
            // that a DLL registers are NOT unregistered when the DLL is unloaded. 
            // Bug 168251:First launch of profile from connections UI causes access violation,
            // after copy new CM bits
            //

            if (OS_NT)
            {
                //
                // Unregister the bitmap class. The new CM bits will re-register the class with
                // correct wnd proc address.
                //
                UnregisterClassU(ICONNMGR_BMP_CLASS, g_hInst);
                UnRegisterWindowClass(g_hInst);
            }

            break;
    }

    return TRUE;
}

//+----------------------------------------------------------------------------
//
// Function: CmCustomDialDlg
//
// Synopsis:  Our CM specific variation on RasCustomDialDlg.  
//
// Arguments: HWND          hwndParent - The HWND of the parent if deemed necessary by the caller
//            DWORD         dwFlags - Dial flags
//            LPTSTR        lpszPhonebook - Ptr to the full path and filename of the phonebook.
//                          NULL = RAS system phone book
//                          "something" = user-defined RAS phonebook
//                          "" = has not been determined yet
//            LPTSTR        lpszEntry - Ptr to the name of the phone-book entry to dial.
//            LPTSTR        lpszPhoneNumber - Ptr to replacement phone number [IGNORED]
//            LPRASDIALDLG  lpRasDialDlg - Ptr to RASDIALDLG struct
//            LPRASENTRYDLG lpRasEntryDlg - Ptr to RASENTRYDLG struct
//            LPCMDIALINFO  lpCmInfo - Ptr to CMDIALINFO struct containing CM dial info such as flags.
//
// Returns:   BOOL WINAPI - TRUE on success
//
// History:   nickball    Created Header    2/5/98
//
//+----------------------------------------------------------------------------

extern "C" BOOL WINAPI CmCustomDialDlg(HWND hwndParent,
    DWORD dwFlags,
    LPTSTR lpszPhonebook, 
    LPCTSTR lpszEntry, 
    LPTSTR,                         // lpszPhoneNumber
    LPRASDIALDLG lpRasDialDlg,
    LPRASENTRYDLG lpRasEntryDlg,
    LPCMDIALINFO lpCmInfo,
    PVOID pvLogonBlob)
{
    MYDBGASSERT(lpCmInfo);
    MYDBGASSERT(lpszEntry);
    MYDBGASSERT(lpszEntry[0]);

    //DebugBreak();

    CMTRACE1(TEXT("CmCustomDialDlg() - dwFlags = 0x%x"), dwFlags);
    CMTRACE1(TEXT("CmCustomDialDlg() - lpszPhonebook = %s"), MYDBGSTR(lpszPhonebook));
    CMTRACE1(TEXT("CmCustomDialDlg() - lpszEntry = %s"), MYDBGSTR(lpszEntry));

    //
    // lpszPhonebook can be NULL, because we are called by our own modules, CMMGR, CMMON, etc.
    //

    if (NULL == lpszEntry || NULL == lpszEntry[0] || NULL == lpCmInfo)
    {
        return FALSE;
    }

    CM_SET_TIMING_INTERVAL("CmCustomDialDlg - Begin");

    CNamedMutex ConnectMutex;  
    CConnectionTable ConnTable;
    BOOL fConnTableExists = FALSE;
    BOOL fMultiInst = FALSE;
    
    if (!(lpCmInfo->dwCmFlags & FL_PROPERTIES))
    {
        //
        // Try to acquire connect mutex
        //
   
        LPTSTR pszTmp = CmStrCpyAlloc(c_pszConnectMutex);
        pszTmp = CmStrCatAlloc(&pszTmp, lpszEntry);

        if (FALSE == ConnectMutex.Lock(pszTmp, FALSE))
        {            
            if (FALSE == IsLogonAsSystem())
            {
                //
                // Another connect instance exists, try to front it
                //

                FrontExistingUI(NULL, lpszEntry, TRUE);

                // 
                // Now wait for Mutex to be released.
                //


                ConnectMutex.Lock(pszTmp, TRUE, INFINITE, TRUE);

                //
                // Mutex was released by the other instance, we'll handle the connect
                // request in the main path. If there is no table, we know that the 
                // instance which previously owned the mutex terminated without 
                // connecting and we follow suit by returning failure. Otherwise, we 
                // have to take a closer look. 
                //                                             

                fMultiInst = TRUE;
            }
            else
            {
                // 
                // No one is logged on and we don't need to be waiting for the mutex.
                //
                CmFree(pszTmp);
                return FALSE;
            }
       }
       

       CmFree(pszTmp);      
    }

    CMTRACE(TEXT("CmCustomDialDlg - Connect mutex acquired. Examining connection table."));
  
    fConnTableExists = SUCCEEDED(ConnTable.Open());

    if ((!fConnTableExists) && fMultiInst) 
    {
        //
        // If we're a secondary thread that was released from the mutex and
        // there is no connection table, then the user canceled, so bail.
        //

        CMTRACE(TEXT("CmCustomDialDlg - returning connect failure post mutex wait"));
        return FALSE;
    }
  
    //
    // If this is a connect request, see if connection exists. 
    //
    
    if (!(lpCmInfo->dwCmFlags & FL_PROPERTIES))
    {
        if (fConnTableExists)
        {
            //
            // Examine the connection table and try to resolve the connect request
            //

            BOOL fSuccess = FALSE;
            BOOL fDone = HandleCustomConnectRequest(NULL, 
                                                    &ConnTable, 
                                                    lpszEntry, 
                                                    lpCmInfo->dwCmFlags, 
                                                    &fSuccess);
            //
            // If we resolved the request, or we're in fMultiInst mode
            // then we can we can bail with the given success code. If  
            // fMultInst, we know we can bail because there is no entry
            // in the table, from which we infer that the previous owner
            // of the mutex failed and we return this out to our caller.
            //
            // NOTE: There is a theoretical corner case here in the multi-inst 
            // request case. If a succesful connection was established by the 
            // first thread, there is a window between the moment that the mutex 
            // lock is cleared above (releasing the waiting thread), and when 
            // the newly release thread reaches here. The logic is fouled if, 
            // and only if, the connection were dropped and entered the 
            // reconnect prompt state during this window. This is because the
            // second thread would dismiss the CMMON reconnect prompt UI during 
            // the call to HandleCustomConnectRequest, but would then return
            // despite fDone being FALSE. The correct behavior would be to 
            // continue, and honor the connect request. This state could be 
            // identified by an fDone of FALSE coupled with an fSuccess of TRUE.
            //
            
            if (fDone || fMultiInst)
            {
                MYVERIFY(SUCCEEDED(ConnTable.Close()));
                return fSuccess;            
            }           
        }
    }
    else
    {
        //
        // Its a properties request, front any UI that might exist
        //

        if (TRUE == FrontExistingUI(fConnTableExists? &ConnTable : NULL, lpszEntry, FALSE))
        {
            if (fConnTableExists)
            {
                MYVERIFY(SUCCEEDED(ConnTable.Close()));
            }
            return TRUE;       
        }
    }

    if (fConnTableExists)
    {
        MYVERIFY(SUCCEEDED(ConnTable.Close()));
    }
    
    //
    // Make a connection attempt
    //

    HRESULT hrRes = Connect(hwndParent,
                          lpszEntry, 
                          lpszPhonebook, 
                          lpRasDialDlg, 
                          lpRasEntryDlg, 
                          lpCmInfo,                           
                          OS_NT5 ? dwFlags : RCD_AllUsers, // Always AllUser downlevel
                          pvLogonBlob);

    //
    // Make sure we push error codes back out
    //
    BOOL bReturn = SUCCEEDED(hrRes);
    DWORD dwError = 0;

    if (lpRasDialDlg)
    {
        if (ERROR_CANCELLED == HRESULT_CODE(hrRes))
        {
            //
            //  If the user canceled then RasDialDlg returns a false to indicate failure
            //  but sets the dwError value to 0.  In order to match the way RAS does
            //  things we need to do this too.
            //
            lpRasDialDlg->dwError = 0;
        }
        else
        {
            //
            //  If the user entered the wrong PIN, we pass the error up to RAS unchanged
            //  so that RAS knows to take down its 'choose connectoid' dialog and drop
            //  the user back to winlogon
            //
            lpRasDialDlg->dwError = (BAD_SCARD_PIN(hrRes) ? hrRes : HRESULT_CODE(hrRes));
        }

        dwError = lpRasDialDlg->dwError;
    }

    if (lpRasEntryDlg)
    {
        if (ERROR_CANCELLED == HRESULT_CODE(hrRes))
        {
            //
            //  If the user canceled then RasEntryDlg returns a false to indicate failure
            //  but sets the dwError value to 0.  In order to match the way RAS does
            //  things we need to do this too.
            //
            lpRasEntryDlg->dwError = 0;
        }
        else
        {
            lpRasEntryDlg->dwError = HRESULT_CODE(hrRes);
        }

        dwError = lpRasEntryDlg->dwError;
    }
   
    //
    // Let go of the connect mutex and go home to papa.
    //

    CMTRACE(TEXT("CmCustomDialDlg - Releasing mutex")); 
    ConnectMutex.Unlock();

    CMTRACE2(TEXT("CmCustomDialDlg() returning with bReturn = %d, dwError = 0x%x"), bReturn, dwError);
    return bReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  CmCustomHangUp
//
// Synopsis:  Our CM specific variation on RasCustomHangUp. Optionally, the entry
//            name may be given instead of the RAS handle.
//
// Arguments: HRASCONN hRasConn - The handle of the connection to be terminated.
//            LPCTSTR pszEntry - Ptr to the name of the entry to be terminated.
//            BOLL fPersist - Preserve the entry and its usage count.
//
// Returns:   DWORD WINAPI - Return code
//
//+----------------------------------------------------------------------------
extern "C" DWORD WINAPI CmCustomHangUp(HRASCONN hRasConn,
    LPCTSTR pszEntry,
    BOOL fIgnoreRefCount,
    BOOL fPersist)
{
    CMTRACE(TEXT("CmCustomHangUp"));
    MYDBGASSERT(hRasConn || (pszEntry && pszEntry[0]));

    DWORD dwRes = ERROR_SUCCESS;

    //
    // Must have a handle or an entry name
    //

    if (NULL == hRasConn && (NULL == pszEntry || 0 == pszEntry[0]))
    {
        return ERROR_INVALID_PARAMETER;
    }

    // 
    // First try to open the table, if none found then succeed.
    //
    
    CConnectionTable ConnTable;

    if (FAILED(ConnTable.Open()))
    {
        return ERROR_NOT_FOUND;
    }

    //
    // Look up the specified entry
    //

    HRESULT hrRes;

    CM_CONNECTION Connection;
    ZeroMemory(&Connection, sizeof(CM_CONNECTION));
        
    if (hRasConn)
    {
        hrRes = ConnTable.GetEntry(hRasConn, &Connection);
    }
    else
    {
        hrRes = ConnTable.GetEntry(pszEntry, &Connection);
    }
    
    //
    // We have an entry, do the Disconnect
    //

    if (SUCCEEDED(hrRes))
    {               
        if (CM_CONNECTING == Connection.CmState)
        {
            dwRes = ERROR_NOT_FOUND;
        }
        else
        {
            //
            // If the persist flag is not set and the caller is from the desktop
            // then ignore the ref count and do a complete hangup.
            //

//            BOOL fIgnoreRefCount = ((!fPersist) && WhoIsCaller(DT_CMMON | DT_EXPLORER));

            dwRes = Disconnect(&ConnTable, &Connection, fIgnoreRefCount, fPersist);            
        }
    }

    MYVERIFY(SUCCEEDED(ConnTable.Close()));
    
    return dwRes;
}