windows-xp/Source/XPSP1/NT/net/config/netman/conobs/dialup.cpp

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1997.
//
//  File:       D I A L U P . C P P
//
//  Contents:   Implements the dial up connection object.
//
//  Notes:
//
//  Author:     shaunco   23 Sep 1997
//
//----------------------------------------------------------------------------

#include "pch.h"
#pragma hdrstop
#include "dialup.h"
#include "nccom.h"
#include "ncnetcon.h"
#include "ncras.h"
#include "ncreg.h"
#include "userenv.h"
#include "cmutil.h"
#include "cobase.h"

//+---------------------------------------------------------------------------
//
//  Member:     CDialupConnection::CreateInstanceUninitialized
//
//  Purpose:    Create an uninitialized instance of
//              CComObject <CDialupConnection> and return an interface
//              pointer as well as a pointer to the CDialupConnection.
//
//  Arguments:
//      riid  [in]  IID of desired interface.
//      ppv   [out] Returned interface pointer.
//      ppObj [out] Returned object pointer.
//
//  Returns:    S_OK or E_OUTOFMEMORY.
//
//  Author:     shaunco   20 Apr 1998
//
//  Notes:
//
//static
HRESULT
CDialupConnection::CreateInstanceUninitialized (
    REFIID              riid,
    VOID**              ppv,
    CDialupConnection** ppObj)
{
    Assert (ppObj);
    Assert (ppv);

    *ppv = NULL;
    *ppObj = NULL;

    HRESULT hr = E_OUTOFMEMORY;

    CDialupConnection* pObj;
    pObj = new CComObject <CDialupConnection>;
    if (pObj)
    {
        // Do the standard CComCreator::CreateInstance stuff.
        //
        pObj->SetVoid (NULL);
        pObj->InternalFinalConstructAddRef ();
        hr = pObj->FinalConstruct ();
        pObj->InternalFinalConstructRelease ();

        if (SUCCEEDED(hr))
        {
            INetConnection* pCon = static_cast<INetConnection*>(pObj);
            hr = pCon->QueryInterface (riid, ppv);
            if (SUCCEEDED(hr))
            {
                *ppObj = pObj;
            }
        }

        if (FAILED(hr))
        {
            delete pObj;
        }
    }
    TraceError ("CDialupConnection::CreateInstanceFromDetails", hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Member:     CDialupConnection::CreateInstanceFromDetails
//
//  Purpose:    Create an initialized instance of
//              CComObject <CDialupConnection> given RASENUMENTRYDETAILS and
//              return an interface pointer on that object.
//
//  Arguments:
//      pszwPbkFile     [in]  Path to the phonebook file.
//      pszwEntryName   [in]  Name of the entry in the phonebook.
//      fForAllUsers    [in]  TRUE if this entry is for all users.
//      riid            [in]  IID of desired interface.
//      ppv             [out] Returned interface pointer.
//
//  Returns:    S_OK or E_OUTOFMEMORY.
//
//  Author:     shaunco   23 Sep 1997
//
//  Notes:
//
// static
HRESULT
CDialupConnection::CreateInstanceFromDetails (
    const RASENUMENTRYDETAILS*  pEntryDetails,
    REFIID                      riid,
    VOID**                      ppv)
{
    Assert(pEntryDetails);
    Assert(pEntryDetails->szPhonebookPath);

    CDialupConnection* pObj;
    HRESULT hr = CreateInstanceUninitialized (riid, ppv, &pObj);
    if (SUCCEEDED(hr))
    {
        pObj->SetPbkFile (pEntryDetails->szPhonebookPath);

        pObj->CacheProperties (pEntryDetails);

        // We are now a full-fledged object.
        //
        pObj->m_fInitialized = TRUE;
    }
    TraceError ("CDialupConnection::CreateInstanceFromDetails", hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Member:     CDialupConnection::CreateInstanceFromPbkFileAndEntryName
//
//  Purpose:    Create an initialized instance of
//              CComObject <CDialupConnection> given only a phonebook path,
//              entry name, and weather it is for all users or not and
//              return an interface pointer on that object.
//
//  Arguments:
//      pszPbkFile   [in]  Phonebook path.
//      pszEntryName [in]  Entry name.
//      riid          [in]  IID of desired interface.
//      ppv           [out] Returned interface pointer.
//
//  Returns:    S_OK or E_OUTOFMEMORY.
//
//  Author:     shaunco   20 Apr 1998
//
//  Notes:      This is called from Duplicate.
//
//static
HRESULT
CDialupConnection::CreateInstanceFromPbkFileAndEntryName (
    PCWSTR pszPbkFile,
    PCWSTR pszEntryName,
    REFIID  riid,
    VOID**  ppv)
{
    TraceTag (ttidWanCon,
        "CDialupConnection::CreateInstanceFromPbkFileAndEntryName called");

    CDialupConnection* pObj;
    HRESULT hr = CreateInstanceUninitialized (riid, ppv, &pObj);
    if (SUCCEEDED(hr))
    {
        pObj->SetPbkFile (pszPbkFile);
        pObj->SetEntryName (pszEntryName);
        pObj->m_guidId = GUID_NULL;

        // We are now a full-fledged object.
        //
        pObj->m_fInitialized = TRUE;
    }
    TraceError ("CDialupConnection::CreateInstanceFromPbkFileAndEntryName", hr);
    return hr;
}

//+---------------------------------------------------------------------------
// INetConnection
//

STDMETHODIMP
CDialupConnection::GetUiObjectClassId (
    CLSID*  pclsid)
{
    HRESULT hr = S_OK;

    // Validate parameters.
    //
    if (!pclsid)
    {
        hr = E_POINTER;
    }
    else if (!m_fInitialized)
    {
        hr = E_UNEXPECTED;
    }
    else
    {
        static const CLSID CLSID_DialupConnectionUi =
                {0x7007ACC1,0x3202,0x11D1,{0xAA,0xD2,0x00,0x80,0x5F,0xC1,0x27,0x0E}};

        static const CLSID CLSID_DirectConnectionUi =
                {0x7007ACC2,0x3202,0x11D1,{0xAA,0xD2,0x00,0x80,0x5F,0xC1,0x27,0x0E}};

        static const CLSID CLSID_VpnConnectionUi =
                {0x7007ACC6,0x3202,0x11D1,{0xAA,0xD2,0x00,0x80,0x5F,0xC1,0x27,0x0E}};

        static const CLSID CLSID_PPPoEUi = 
                {0x7007ACD4,0x3202,0x11D1,{0xAA,0xD2,0x00,0x80,0x5F,0xC1,0x27,0x0E}};     

        hr = HrEnsureEntryPropertiesCached ();
        if (SUCCEEDED(hr))
        {
            switch (MediaType ())
            {
                case NCM_DIRECT:
                    *pclsid = CLSID_DirectConnectionUi;
                    break;

                case NCM_ISDN:
                case NCM_PHONE:
                    *pclsid = CLSID_DialupConnectionUi;
                    break;

                case NCM_TUNNEL:
                    *pclsid = CLSID_VpnConnectionUi;
                    break;

                case NCM_PPPOE:
                    *pclsid = CLSID_PPPoEUi;
                    break;

                default:
                    *pclsid = CLSID_DialupConnectionUi;
                    TraceTag (ttidWanCon, "GetUiObjectClassId: Unknown media type "
                        "(%d) treating as CLSID_DialupConnectionUi", MediaType());
            }
        }
    }
    TraceError ("CDialupConnection::GetUiObjectClassId", hr);
    return hr;
}

STDMETHODIMP
CDialupConnection::Connect ()
{
    return E_NOTIMPL;
}

STDMETHODIMP
CDialupConnection::Disconnect ()
{
    HRESULT hr;

    if (!m_fInitialized)
    {
        hr = E_UNEXPECTED;
    }
    else
    {
        HRASCONN hRasConn;

        hr = HrFindRasConn (&hRasConn, NULL);
        if (S_OK == hr)
        {
            // Because RasHangup could call RasCustomHangup
            // we need to impersonate the client to allow the correct
            // per-user information to be used.
            //

            // Impersonate the client.
            //
            HRESULT hrT = CoImpersonateClient ();
            TraceErrorOptional ("CDialupConnection::Disconnect -- CoImpersonateClient", hrT, RPC_E_CALL_COMPLETE == hrT);

            // We need to continue if we're called in-proc (ie. if RPC_E_CALL_COMPLETE is returned).
            if (SUCCEEDED(hrT) || (RPC_E_CALL_COMPLETE == hrT))
            {
                hr = HrRasHangupUntilDisconnected (hRasConn);
            }
            
            if (SUCCEEDED(hrT))
            {
                hrT = CoRevertToSelf ();
                TraceError ("CDialupConnection::Disconnect -- CoRevertToSelf", hrT);
            }
        }
        else if (S_FALSE == hr)
        {
            hr = S_OK;
        }
    }
    TraceError ("CDialupConnection::Disconnect", hr);
    return hr;
}

STDMETHODIMP
CDialupConnection::Delete ()
{
    HRESULT hr = E_UNEXPECTED;

    if (!m_fInitialized)
    {
        hr = E_UNEXPECTED;
    }
    else
    {
        hr = HrEnsureEntryPropertiesCached ();
        if (SUCCEEDED(hr))
        {
            // If we allow removal (a decision which is based on the
            // whether the user is an admin, whether the connection is
            // 'for all users', and the connection's current state) then
            // proceed.  If FAllowRemoval fails, it's output parameter
            // is the "reason" in the form of an HRESULT.  We can use
            // this as our return value in that case.
            //
            HRESULT hrReason;
            if (FAllowRemoval (&hrReason))
            {
                // If we're active in any way, we can't be removed.
                //
                NETCON_STATUS status;

                hr = HrGetStatus(&status);
                if (SUCCEEDED(hr) &&
                    ((NCS_CONNECTING    != status) &&
                     (NCS_CONNECTED     != status) &&
                     (NCS_DISCONNECTING != status)))
                {

                    // We do an impersonation here in case the connection has a RAS custom delete notification
                    // setup (CM connections do, for instance).  This allows the RasCustomDeleteEntryNotify
                    // function to interact with the system as the user.
                    //
                    HRESULT hrT = CoImpersonateClient ();
                    TraceError ("HrRemoveCmProfile -- CoImpersonateClient", hrT);

                    // We need to continue if we're called in-proc (ie. if RPC_E_CALL_COMPLETE is returned).
                    if (SUCCEEDED(hrT) || (RPC_E_CALL_COMPLETE == hrT))
                    {
                        //  Delete the RAS entry, note that for branded connections, RAS
                        //  will call RasCustomDeleteEntryNotify after deletion.
                        //
                        DWORD dwErr = RasDeleteEntry (PszwPbkFile (), PszwEntryName ());

                        hr = HRESULT_FROM_WIN32 (dwErr);
                        TraceError ("RasDeleteEntry", hr);
                    }
                    
                    //  Revert to ourselves
                    //
                    if (SUCCEEDED(hrT))
                    {
                        CoRevertToSelf ();
                    }

                }
                else
                {
                    // Don't allow deletion unless disconnected
                    //
                    TraceTag (ttidWanCon, "Disallowing delete while in connected or"
                        "partially connected state");
                    hr = E_UNEXPECTED;
                }
            }
            else
            {
                hr = hrReason;
            }
        }
    }

    TraceError ("CDialupConnection::Delete", hr);
    return hr;
}

STDMETHODIMP
CDialupConnection::Duplicate (
    PCWSTR              pszDuplicateName,
    INetConnection**    ppCon)
{
    HRESULT hr = S_OK;

    // Validate parameters.
    //
    if (!pszDuplicateName || !ppCon)
    {
        hr = E_POINTER;
    }
    else if (!m_fInitialized)
    {
        hr = E_UNEXPECTED;
    }
    else
    {
        *ppCon = NULL;

        hr = HrEnsureEntryPropertiesCached ();
        if (SUCCEEDED(hr))
        {
            // Make sure the name is valid in the same phone book.
            //
            DWORD dwErr = RasValidateEntryName (
                            PszwPbkFile (), pszDuplicateName);

            hr = HRESULT_FROM_WIN32 (dwErr);
            TraceError ("RasValidateEntryName", hr);

            if (SUCCEEDED(hr))
            {
                dwErr = DwCloneEntry (
                            PszwPbkFile(),
                            PszwEntryName(),
                            pszDuplicateName);

                hr = HRESULT_FROM_WIN32 (dwErr);
                TraceError ("DwCloneEntry", hr);

                if (SUCCEEDED(hr))
                {
                    hr = CreateInstanceFromPbkFileAndEntryName (
                            PszwPbkFile (),
                            pszDuplicateName,
                            IID_INetConnection, (VOID**)ppCon);
                    
                    if (SUCCEEDED(hr))
                    {
                        hr = HrEnsureHNetPropertiesCached();
                    }
                    
                    if (SUCCEEDED(hr))
                    {
                        if (m_HNetProperties.fFirewalled || m_HNetProperties.fIcsPublic) // lazy eval the hnetcfg stuff
                        {
                            IHNetCfgMgr* pHomenetConfigManager;
                            hr = HrGetHNetCfgMgr(&pHomenetConfigManager);
                            if(SUCCEEDED(hr))
                            {
                                IHNetConnection* pNewHomenetConnection;
                                hr = pHomenetConfigManager->GetIHNetConnectionForINetConnection(*ppCon, &pNewHomenetConnection);
                                if(SUCCEEDED(hr))
                                {
                                    IHNetConnection* pHomenetConnection;
                                    hr = HrGetIHNetConnection(&pHomenetConnection);
                                    if(SUCCEEDED(hr))
                                    {
                                        // copy port bindings
                                        // REVIEW if somethings fails here to we need to nuke the new connection?
                                        IEnumHNetPortMappingBindings* pEnumPortMappingBindings;
                                        hr = pNewHomenetConnection->EnumPortMappings(FALSE, &pEnumPortMappingBindings);
                                        if(SUCCEEDED(hr))
                                        {
                                            ULONG ulFetched;
                                            IHNetPortMappingBinding* pNewPortMappingBinding;
                                            while(S_OK == pEnumPortMappingBindings->Next(1, &pNewPortMappingBinding, &ulFetched)) 
                                            {
                                                Assert(1 == ulFetched);
                                                IHNetPortMappingProtocol* pPortMappingProtocol;
                                                hr = pNewPortMappingBinding->GetProtocol(&pPortMappingProtocol);
                                                if(SUCCEEDED(hr))
                                                {
                                                    // find the original binding by using the protocol field
                                                    IHNetPortMappingBinding* pPortMappingBinding;
                                                    hr = pHomenetConnection->GetBindingForPortMappingProtocol(pPortMappingProtocol, &pPortMappingBinding);
                                                    if(SUCCEEDED(hr))
                                                    {
                                                        BOOLEAN bEnabled;
                                                        hr = pPortMappingBinding->GetEnabled(&bEnabled);
                                                        if(SUCCEEDED(hr))
                                                        {
                                                            if(TRUE == bEnabled)
                                                            {
                                                                hr = pNewPortMappingBinding->SetEnabled(bEnabled);
                                                            }
                                                        }
                                                        
                                                        // always set the computer address
                                                        
                                                        if(SUCCEEDED(hr))
                                                        {
                                                            ULONG ulAddress;
                                                            hr = pPortMappingBinding->GetTargetComputerAddress(&ulAddress);
                                                            if(SUCCEEDED(hr))
                                                            {
                                                                if(0 != ulAddress)
                                                                {
                                                                    hr = pNewPortMappingBinding->SetTargetComputerAddress(ulAddress);
                                                                }
                                                            }
                                                        }
                                                        
                                                        // only set the computer name if it is used
                                                        
                                                        if(SUCCEEDED(hr))
                                                        {
                                                            BOOLEAN bUseName;
                                                            hr = pPortMappingBinding->GetCurrentMethod(&bUseName);
                                                            if(SUCCEEDED(hr) && TRUE == bUseName)
                                                            {
                                                                OLECHAR* pszTargetComputerName;
                                                                hr = pPortMappingBinding->GetTargetComputerName(&pszTargetComputerName);
                                                                if(SUCCEEDED(hr))
                                                                {
                                                                    if(L'\0' != *pszTargetComputerName)
                                                                    {
                                                                        hr = pNewPortMappingBinding->SetTargetComputerName(pszTargetComputerName);
                                                                    }
                                                                    CoTaskMemFree(pszTargetComputerName);
                                                                }
                                                            }
                                                        }
                                                        ReleaseObj(pPortMappingBinding);    
                                                    }
                                                    ReleaseObj(pPortMappingProtocol);
                                                }
                                                ReleaseObj(pNewPortMappingBinding);
                                            }
                                            ReleaseObj(pEnumPortMappingBindings);
                                        }
                                        
                                        if(m_HNetProperties.fFirewalled) // copy firewall yes/no and ICMP settings
                                        {
                                            IHNetFirewalledConnection* pFirewalledConnection;
                                            hr = pNewHomenetConnection->Firewall(&pFirewalledConnection);
                                            if(SUCCEEDED(hr))
                                            {
                                                HNET_FW_ICMP_SETTINGS* pICMPSettings;
                                                hr = pHomenetConnection->GetIcmpSettings(&pICMPSettings);
                                                if(SUCCEEDED(hr))
                                                {
                                                    hr = pNewHomenetConnection->SetIcmpSettings(pICMPSettings);
                                                    CoTaskMemFree(pICMPSettings);
                                                }
                                                ReleaseObj(pFirewalledConnection);
                                            }
                                        }
                                        ReleaseObj(pHomenetConnection);
                                    }
                                    ReleaseObj(pNewHomenetConnection);
                                }
                                ReleaseObj(pHomenetConfigManager);
                            }
                        }
                    }
                }
            }
        }
    }
    TraceError ("CDialupConnection::Duplicate", hr);
    return hr;
}

STDMETHODIMP
CDialupConnection::GetProperties (
    NETCON_PROPERTIES** ppProps)
{
    HRESULT hr = S_OK;
    HRESULT hrHiddenCM = S_OK;
    CMEntry cm;

    // Validate parameters.
    //
    if (!ppProps)
    {
        hr = E_POINTER;
    }
    else if (!m_fInitialized)
    {
        hr = E_UNEXPECTED;
    }
    else
    {
        // Initialize the output parameter.
        //
        *ppProps = NULL;

        hr = HrEnsureEntryPropertiesCached ();
        if (SUCCEEDED(hr))
        {
            NETCON_PROPERTIES* pProps;
            hr = HrCoTaskMemAlloc (sizeof (NETCON_PROPERTIES),
                    reinterpret_cast<VOID**>(&pProps));
            if (SUCCEEDED(hr))
            {
                HRESULT hrT;

                ZeroMemory (pProps, sizeof (NETCON_PROPERTIES));

                // guidId
                //
                pProps->guidId = GuidId ();

                // pszwName
                //
                hrT = HrCoTaskMemAllocAndDupSz (
                            PszwEntryName(),
                            &pProps->pszwName);
                if (FAILED(hrT))
                {
                    hr = hrT;
                }

                hrT = HrCoTaskMemAllocAndDupSz (
                            PszwDeviceName(),
                            &pProps->pszwDeviceName);
                if (FAILED(hrT))
                {
                    hr = hrT;
                }

                // Status
                //
                hrT = HrGetStatus (&pProps->Status);
                if (FAILED(hrT))
                {
                    hr = hrT;
                }

                // Verify that the status return is accurate. HrGetStatus returns NCS_DISCONNECTED
                // if the connectoid is NCS_CONNECTING, which is wrong!!!!.
                //
                if( pProps->Status == NCS_DISCONNECTED )
                {
                    // CMUtil remebers the Hidden connection (Connection Manager) and the status of
                    // any ras events (i.e. Connecting, Disconnecting etc). The Data is filled in 
                    // in function RasEventNotify.
                    //
                    hrHiddenCM = CCMUtil::Instance().HrGetEntry(pProps->guidId,cm);
                    if ( S_OK == hrHiddenCM )
                    {
                        // Use CCMUtil's status, its more accurate.
                        //
                        pProps->Status = cm.m_ncs;
                    }
                }

                // Check if this connection has a child connection
                //
               
                hrHiddenCM = CCMUtil::Instance().HrGetEntry(PszwEntryName(),cm);        
                if( hrHiddenCM == S_OK )
                {
                    // It has a child connectoid
                    // Now we have to determine which one describes the overall status of the connection
                    //
                    if( cm.m_ncs == NCS_CONNECTING || cm.m_ncs == NCS_DISCONNECTING ||
                        cm.m_ncs == NCS_CONNECTED)
                    {
                        if( pProps->Status == NCS_DISCONNECTING )
                        {
                            // This case happens if the parent is disconnecting
                            // The parent is disconnecting, so the child will be disconnecting.
                            // Change the status of the child to disconnecting so that we do not
                            // get confused later on when the child is connected at the parent is
                            // disconnected. i.e. are we overall connecting or disconnecting!!!!
                            //
                            CCMUtil::Instance().SetEntry(GuidId (), PszwEntryName(),pProps->Status);        
                        }
                        else
                        if( cm.m_ncs == NCS_CONNECTED && pProps->Status == NCS_DISCONNECTED )
                        {
                            // This case will only happen if the child is connected and the parent is still
                            // disconnected.
                            //
                            pProps->Status = NCS_CONNECTING;
                        }
                        else if (!IsEqualGUID(pProps->guidId, cm.m_guid))
                        {
                            TraceTag(ttidWanCon, "Overwriting parent connection status: %s with child status: %s", DbgNcs(pProps->Status), DbgNcs(cm.m_ncs));

                            // When in doubt and the GUID's are different (ie. not a BAP/Multilink connection) take the childs status =)
                            //
                            pProps->Status = cm.m_ncs;
                        }
                    }

                }


                // Type
                //
                pProps->MediaType = MediaType ();

                // dwCharacter
                //
                hrT = HrGetCharacteristics (&pProps->dwCharacter);
                if (FAILED(hrT))
                {
                    hr = hrT;
                }

                // clsidThisObject
                //
                pProps->clsidThisObject = CLSID_DialupConnection;

                // clsidUiObject
                //
                hrT = GetUiObjectClassId (&pProps->clsidUiObject);
                if (FAILED(hrT))
                {
                    hr = hrT;
                }

                // Assign the output parameter or cleanup if we had any failures.
                //
                if (SUCCEEDED(hr))
                {
                    *ppProps = pProps;
                }
                else
                {
                    Assert (NULL == *ppProps);
                    FreeNetconProperties (pProps);
                }
            }
        }
    }
    TraceError ("CDialupConnection::GetProperties", hr);
    return hr;
}

STDMETHODIMP
CDialupConnection::Rename (
    PCWSTR pszNewName)
{
    HRESULT hr;

    // Validate parameters.
    //
    if (!pszNewName)
    {
        hr = E_POINTER;
    }
    else if (!m_fInitialized)
    {
        hr = E_UNEXPECTED;
    }
    else
    {
        hr = HrLockAndRenameEntry (pszNewName, this);
    }
    TraceError ("CDialupConnection::Rename", hr);
    return hr;
}


//+---------------------------------------------------------------------------
// INetRasConnection
//
STDMETHODIMP
CDialupConnection::GetRasConnectionInfo (
    RASCON_INFO* pRasConInfo)
{
    HRESULT hr = HrGetRasConnectionInfo (pRasConInfo);

    TraceError ("CDialupConnection::GetRasConnectionInfo", hr);
    return hr;
}

STDMETHODIMP
CDialupConnection::SetRasConnectionInfo (
    const RASCON_INFO* pRasConInfo)
{
    HRESULT hr = HrSetRasConnectionInfo (pRasConInfo);

    TraceError ("CDialupConnection::SetRasConnectionInfo", hr);
    return hr;
}

STDMETHODIMP
CDialupConnection::GetRasConnectionHandle (
    ULONG_PTR* phRasConn)
{
    HRESULT hr = HrGetRasConnectionHandle (
                    reinterpret_cast<HRASCONN*>(phRasConn));

    TraceError ("CDialupConnection::GetRasConnectionHandle",
        (S_FALSE == hr) ? S_OK : hr);
    return hr;
}


//+---------------------------------------------------------------------------
// IPersistNetConnection
//
STDMETHODIMP
CDialupConnection::GetClassID (
    CLSID*  pclsid)
{
    HRESULT hr = S_OK;

    // Validate parameters.
    //
    if (!pclsid)
    {
        hr = E_POINTER;
    }
    else
    {
        *pclsid = CLSID_DialupConnection;
    }
    TraceError ("CDialupConnection::GetClassID", hr);
    return hr;
}

STDMETHODIMP
CDialupConnection::GetSizeMax (
    ULONG*  pcbSize)
{
    HRESULT hr = HrPersistGetSizeMax (pcbSize);
    TraceError ("CDialupConnection::GetSizeMax", hr);
    return hr;
}

STDMETHODIMP
CDialupConnection::Load (
    const BYTE* pbBuf,
    ULONG       cbSize)
{
    HRESULT hr = HrPersistLoad (pbBuf, cbSize);
    TraceError ("CDialupConnection::Load", hr);
    return hr;
}

STDMETHODIMP
CDialupConnection::Save (
    BYTE*   pbBuf,
    ULONG   cbSize)
{
    HRESULT hr = HrPersistSave (pbBuf, cbSize);
    TraceError ("CDialupConnection::Save", hr);
    return hr;
}

//+---------------------------------------------------------------------------
// INetConnectionBrandingInfo
//

//+---------------------------------------------------------------------------
//
//  Member:     CDialupConnection::GetBrandingIconPaths
//
//  Purpose:    Returns the full paths to three icons.
//
//  Arguments:  pConBrandInfo - pointer to an Icon branding structure
//
//  Returns:   S_OK or an error code
//
STDMETHODIMP
CDialupConnection::GetBrandingIconPaths(
    CON_BRANDING_INFO ** ppConBrandInfo)
{
    HRESULT hr = HrEnsureEntryPropertiesCached ();
    CON_BRANDING_INFO * pConBrandInfo   = NULL;

    Assert(ppConBrandInfo);

    if (SUCCEEDED(hr))
    {
        if (!FIsBranded ())
        {
            hr = E_NOTIMPL;
        }
        else
        {
            WCHAR szTemp[MAX_PATH+1];
            WCHAR szIconName[MAX_PATH+1];
            const WCHAR* const CMSECTION = L"Connection Manager";
            HICON hIcon;

            hr = HrCoTaskMemAlloc(sizeof(CON_BRANDING_INFO), (LPVOID*)&pConBrandInfo);
            if (SUCCEEDED(hr))
            {
                ZeroMemory(pConBrandInfo, sizeof(CON_BRANDING_INFO));

                // Get the path to the cms file to get the Icon entries from.
                //
                hr = HrEnsureCmStringsLoaded();

                if (SUCCEEDED(hr))
                {
                    //  Get the Large Icon path
                    //
                    if (0 != GetPrivateProfileStringW(CMSECTION, L"Icon", L"",
                                szIconName, celems(szIconName), PszwCmsFile ()))
                    {
                        lstrcpynW(szTemp, PszwCmDir (), celems(szTemp));
                        lstrcatW(szTemp, szIconName);

                        if (NULL != (hIcon = (HICON)LoadImage(NULL, szTemp, IMAGE_ICON, 32, 32, LR_LOADFROMFILE)))
                        {
                            DestroyIcon(hIcon);
                            hr = HrCoTaskMemAllocAndDupSz (szTemp, &(pConBrandInfo->szwLargeIconPath));
                        }
                    }

                    // See if the CM icon is hidden
                    WCHAR szHideTrayIcon[MAX_PATH+1];
                    DWORD dwHideTrayIcon = 1; // default is to hide the CM icon
                    if (SUCCEEDED(hr) &&
                        (0 != GetPrivateProfileStringW(CMSECTION, L"HideTrayIcon", L"1",
                                szHideTrayIcon, celems(szHideTrayIcon), PszwCmsFile ())))
                    {
                        dwHideTrayIcon = _ttoi(szHideTrayIcon);
                    }

                    if (dwHideTrayIcon) // If the CM icon is not hidden, we don't want another branded icon. We'll use blinky lights instead
                    {
                        //  Get the Tray Icon path
                        //
                        if (SUCCEEDED(hr) &&
                            (0 != GetPrivateProfileStringW(CMSECTION, L"TrayIcon", L"",
                                    szIconName, celems(szIconName), PszwCmsFile ())))
                        {
                            lstrcpynW(szTemp, PszwCmDir (), celems(szTemp));
                            lstrcatW(szTemp, szIconName);

                            if (NULL != (hIcon = (HICON)LoadImage(NULL, szTemp, IMAGE_ICON, 16, 16, LR_LOADFROMFILE)))
                            {
                                DestroyIcon(hIcon);
                                hr = HrCoTaskMemAllocAndDupSz (szTemp, &(pConBrandInfo->szwTrayIconPath));
                            }
                        }
                    }
                }
            }
        }
    }

    // Fill in the out param struct if we succeeded, otherwise leave it alone so it will still
    // marshall.
    //
    if (SUCCEEDED(hr))
    {
        *ppConBrandInfo = pConBrandInfo;
    }

    TraceError ("CDialupConnection::GetBrandingIconPaths", hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Member:     CDialupConnection::GetTrayMenuEntries
//
//  Purpose:    Returns any branded menu items to be added to the tray menu.
//
//  Arguments:  pMenuData -- Pointer to a Tray Menu Data struct
//
//  Returns:   S_OK or an error code
//
STDMETHODIMP
CDialupConnection::GetTrayMenuEntries(
    CON_TRAY_MENU_DATA** ppMenuData)
{
    // initialize output
    Assert(ppMenuData);
    *ppMenuData = NULL;

    CON_TRAY_MENU_DATA * pMenuData = NULL;
    HRESULT hr = HrEnsureEntryPropertiesCached ();

    if (SUCCEEDED(hr))
    {
        if (!FIsBranded ())
        {
            hr = E_NOTIMPL;
        }
        else
        {
            hr = HrEnsureCmStringsLoaded();
            if (SUCCEEDED(hr))
            {
                //
                //  Get the menu item section
                //
                WCHAR* pszMenuItemsSection = NULL;
                int nSize;

                hr = HrGetPrivateProfileSectionWithAlloc(&pszMenuItemsSection, &nSize);

                //  Process the menu items
                //
                if (SUCCEEDED(hr) && (nSize>0))
                {
                    //  We have menu items to process.  First make a copy of the data
                    //  and figure out a line count.
                    //
                    hr = HrCoTaskMemAlloc(sizeof(CON_TRAY_MENU_DATA), (LPVOID*)&pMenuData);
                    if (SUCCEEDED(hr))
                    {
                        DWORD dwCount = 0;
                        WCHAR*pszLine = NULL;
                        WCHAR szName[MAX_PATH+1];
                        WCHAR szCmdLine[MAX_PATH+1];
                        WCHAR szParams[MAX_PATH+1];

                        pszLine = pszMenuItemsSection;

                        while ((NULL != pszLine) && (0 != *pszLine))
                        {
                            if (SUCCEEDED(HrGetMenuNameAndCmdLine(pszLine, szName,
                                    szCmdLine, szParams)))
                            {
                                dwCount++;
                            }
                            pszLine = pszLine + lstrlenW(pszLine) + 1;
                        }

                        ASSERT(0 != dwCount);

                        // Now that we have an accurate count, lets
                        // allocate the memory for the marshalling and
                        // reparse the items.
                        //
                        hr = HrCoTaskMemAlloc(dwCount*sizeof(CON_TRAY_MENU_ENTRY),
                                              (LPVOID*)&pMenuData->pctme);

                        if (SUCCEEDED(hr))
                        {
                            pMenuData->dwCount = dwCount;

                            DWORD dwNumAdded = 0;
                            pszLine = pszMenuItemsSection;
                            while ((NULL != pszLine) && (0 != *pszLine) && SUCCEEDED(hr))
                            {
                                if (SUCCEEDED(HrGetMenuNameAndCmdLine(pszLine,
                                    szName, szCmdLine, szParams)) && (dwNumAdded <= dwCount))
                                {
                                    hr = HrFillInConTrayMenuEntry(szName, szCmdLine, szParams,
                                        &(pMenuData->pctme[dwNumAdded]));

                                    if (FAILED(hr))
                                    {
                                        CoTaskMemFree(&pMenuData->pctme);
                                    }

                                    dwNumAdded++;
                                }
                                pszLine = pszLine + lstrlenW(pszLine) + 1;
                            }
                        }
                        else
                        {
                            delete pMenuData;
                        }
                    }
                    delete (pszMenuItemsSection);
                }
            }
        }
    }

    // Fill in the out param struct if we succeeded, otherwise leave it alone so it will still
    // marshall.
    //
    if (SUCCEEDED(hr))
    {
        *ppMenuData = pMenuData;
    }

    TraceError ("CDialupConnection::GetTrayMenuEntries", hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Member:     CDialupConnection::HrGetPrivateProfileSectionWithAlloc
//
//  Purpose:    This function ensures that the CM specific member vars for dialup
//              are loaded and usable by CM specific functions.
//
//  Arguments: none
//
//  Returns:    S_OK or an error code
//
HRESULT
CDialupConnection::HrGetPrivateProfileSectionWithAlloc (
    WCHAR** pszSection,
    int*    pnSize)
{

    Assert(pszSection);
    Assert(pnSize);

    HRESULT hr = HrEnsureCmStringsLoaded();

    if (!pszSection)
    {
        return E_POINTER;
    }
    if (!pnSize)
    {
        return E_POINTER;
    }


    if (SUCCEEDED(hr))
    {
        const int c_64K= 64*1024;
        int nAllocated = 1024;
        *pnSize = nAllocated - 2;

        while ((nAllocated <= c_64K) && ((*pnSize) == (nAllocated - 2)))
        {
            //      Should never need more than the 4-5 lines we already allocated
            //      but someone might want lots of menu options.
            //
            if (NULL != *pszSection)
            {
                delete (*pszSection);
            }

            *pszSection = new WCHAR[nAllocated];

            if (*pszSection)
            {
                *pnSize = GetPrivateProfileSectionW(L"Menu Options",
                            *pszSection, nAllocated,
                            PszwCmsFile ());
            }
            else
            {
                hr = E_OUTOFMEMORY;
                break;
            }

            nAllocated = 2*nAllocated;
        }

        if (nAllocated > c_64K)
        {
            hr = E_UNEXPECTED;
        }
        if (nAllocated > c_64K || 0 == *pnSize)
        {
            // We need to free this in both cases, because if the size is 0, then the callers don't free this.
            delete *pszSection;
        }
    }

    TraceError ("CDialupConnection::HrGetPrivateProfileSectionWithAlloc", hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Member:     CDialupConnection::HrGetMenuNameAndCmdLine
//
//  Purpose:    Given a menu item line from a CMS file parses out the Menu item name,
//                              Menu executable, and Menu item parameters.
//
//  Arguments:  pMenuData -- Pointer to a Tray Menu Data struct
//
//  Returns:    S_OK or an error code
//
HRESULT
CDialupConnection::HrGetMenuNameAndCmdLine(
    PWSTR pszString,
    PWSTR szName,
    PWSTR szProgram,
    PWSTR szParams)
{
    WCHAR*      pszPtr1;
    WCHAR*      pszPtr2;
    WCHAR       szLine[MAX_PATH+1];
    BOOL fLong = FALSE;
    HRESULT hr;

    Assert(NULL != pszString);
    Assert(NULL != szName);
    Assert(NULL != szProgram);
    Assert(NULL != szParams);

    ZeroMemory(szName, celems(szName));
    ZeroMemory(szProgram, celems(szProgram));
    ZeroMemory(szParams, celems(szParams));

    lstrcpynW(szLine, pszString, celems(szLine));

    // Process the first portion, the "Name=" part
    //
    pszPtr1 = wcsstr(szLine, L"=");

    if (pszPtr1)
    {
        *pszPtr1 = 0;
        lstrcpynW(szName, szLine, MAX_PATH);

        // Process next portion, the program name
        //
        pszPtr1++;

        if (pszPtr1)
        {
            // Look for "+" or " " marking end of program portion
            //
            if (*pszPtr1 == L'+')
            {
                pszPtr1++;
                pszPtr2 = wcsstr(pszPtr1, L"+");
                fLong = TRUE;
            }
            else
            {
                // If not a long filename then we have two choices,
                // either a short program name and params or just a
                // short program name.
                //
                pszPtr2 = wcsstr(pszPtr1, L" ");
                fLong = FALSE;
            }

            // Terminate program name and copy
            //
            if (pszPtr2)
            {
                if (*pszPtr2 != 0)
                {
                    *pszPtr2 = 0;
                    pszPtr2++;
                }

                lstrcpynW(szProgram, pszPtr1, MAX_PATH);

                // Process final portion, the params
                //
                if (fLong)
                {
                    pszPtr2++; // skip blank
                }

                // Now we are have the param string
                //
                if (pszPtr2)
                {
                    lstrcpynW(szParams, pszPtr2, MAX_PATH);
                }
            }
            else
            {
                // Just a program with no params and no space seperator
                // (this happens on memphis)
                //
                lstrcpynW(szProgram, pszPtr1, MAX_PATH);
            }
        }
        hr = S_OK;
    }
    else
    {
        //  No entries
        //
        hr =  E_UNEXPECTED;
    }

    TraceError ("CDialupConnection::HrGetMenuNameAndCmdLine", hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Member:     CDialupConnection::HrFillInConTrayMenuEntry
//
//  Purpose:    Given the elements of a ConTrayMenuEntry struct, the function
//              allocs the memory necessary and copies of the given elements.
//
//  Arguments:  szwName - Display name of the command to show in the tray context menu
//              szwCmdLine - actual command to run for this menu entry
//              szwParams - command params for this command
//              pMenuEntry - pointer to the struct to fill in and execute
//
//  Returns:    S_OK or an error code
//
HRESULT
CDialupConnection::HrFillInConTrayMenuEntry (
    PCWSTR szName,
    PCWSTR szCmdLine,
    PCWSTR szParams,
    CON_TRAY_MENU_ENTRY* pMenuEntry)
{
    HRESULT hr;
    ZeroMemory(pMenuEntry, sizeof(CON_TRAY_MENU_ENTRY));

    hr = HrCoTaskMemAlloc ((lstrlenW(szName)+1)*sizeof(WCHAR),
                               (LPVOID*)&(pMenuEntry->szwMenuText));
    if (SUCCEEDED(hr))
    {
        lstrcpyW(pMenuEntry->szwMenuText, szName);
        hr = HrCoTaskMemAlloc ((lstrlenW(szParams)+1)*sizeof(WCHAR),
                                                   (LPVOID*)&(pMenuEntry->szwMenuParams));
        if (S_OK == hr)
        {
            lstrcpyW(pMenuEntry->szwMenuParams, szParams);
            if (0 == wcsncmp(PszwShortServiceName (), szCmdLine,
                    lstrlenW(PszwShortServiceName ())))
            {
                //
                //      Then we have an included file.  Add the profile dir path
                //
                // Take out the "short service name" because it's already included in the path
                PCWSTR pszFileName = szCmdLine + lstrlenW(PszwShortServiceName()) + 1;
                hr = HrCoTaskMemAlloc ((lstrlenW(pszFileName)+lstrlenW(PszwProfileDir())+1)*sizeof(WCHAR),
                                                           (LPVOID*)&(pMenuEntry->szwMenuCmdLine));
                if (S_OK == hr)
                {
                    lstrcpyW(pMenuEntry->szwMenuCmdLine, PszwProfileDir ());
                    lstrcatW(pMenuEntry->szwMenuCmdLine, pszFileName);
                }
            }
            else
            {
                hr = HrCoTaskMemAlloc ((lstrlenW(szCmdLine)+1)*sizeof(WCHAR),
                                                           (LPVOID*)&(pMenuEntry->szwMenuCmdLine));
                if (S_OK == hr)
                {
                    lstrcpyW(pMenuEntry->szwMenuCmdLine, szCmdLine);
                }
            }
        }
    }
    if (FAILED(hr))
    {
        //
        //      We Failed so free the memory
        //
        CoTaskMemFree(pMenuEntry->szwMenuText);
        CoTaskMemFree(pMenuEntry->szwMenuCmdLine);
        CoTaskMemFree(pMenuEntry->szwMenuParams);
    }

    return hr;
}

//+---------------------------------------------------------------------------
//
//  Member:     CDialupConnection::HrGetCmpFileLocation
//
//  Purpose:    Compares the phonebook file path to path of the current user's
//              application data dir.  If the initial paths are the same we have
//              a private profile.  Please NOTE that calling this function
//              requires the calling client to properly setup CoSetProxyBlanket for
//              a private user profile (matches the call to CoImpersonateClient)
//
//  Arguments:  szwPhonebook -- path to the phonebook the CM connectoid lives in
//
//  Returns:    S_OK or an error code
//
HRESULT
CDialupConnection::HrGetCmpFileLocation(
    PCWSTR szPhonebook,
    PCWSTR szEntryName,
    PWSTR  szCmpFilePath)
{
    DWORD dwSize = MAX_PATH;
    HKEY hKey;
    HANDLE hBaseKey = NULL;
    HANDLE hFile;
    HRESULT hr;
    HRESULT hrImpersonate = E_FAIL;
    static const WCHAR c_mappingsRegKey[] = L"Software\\Microsoft\\Connection Manager\\Mappings";
    HANDLE hImpersonationToken = NULL;   // The token of the thread
    HANDLE hPrimaryToken = NULL;         // The primary token for the new process

    if ((NULL == szCmpFilePath) || (NULL == szPhonebook))
    {
        hr = E_POINTER;
    }
    else
    {
        hr = HrEnsureEntryPropertiesCached ();

        if (SUCCEEDED(hr))
        {
            if (m_fForAllUsers)
            {
                //  We have an all users key so get the information from HKLM
                //
                hBaseKey = HKEY_LOCAL_MACHINE;
            }
            else
            {
                //  Then we have a private profile.  Since netman runs as a system account,
                //  we must impersonate the client and then make an RTL call to get
                //  the current users HKCU hive before querying the registry for the
                //  cmp path.  We also need to get the user token so that we can expand the
                //  cmp string in the single user case.
                //

                hrImpersonate = CoImpersonateClient ();
                TraceError ("HrGetCmpFileLocation -- CoImpersonateClient", hr);

                if (SUCCEEDED(hrImpersonate))
                {
                    NTSTATUS ntstat = RtlOpenCurrentUser(KEY_READ | KEY_WRITE, &hBaseKey);
                    hr = HRESULT_FROM_NT(ntstat);
                    TraceError ("RtlOpenCurrentUser", hr);

                    if (SUCCEEDED(hr))
                    {
                        // Create a primary token
                        //
                        if (!OpenThreadToken(
                                GetCurrentThread(),
                                TOKEN_QUERY | TOKEN_DUPLICATE | TOKEN_ASSIGN_PRIMARY,
                                TRUE,
                                &hImpersonationToken))
                        {
                            hr = HrFromLastWin32Error();
                            TraceError ("HrGetCmpFileLocation -- OpenThreadToken", hr);
                        }
                        else
                        {
                            if(!DuplicateTokenEx(hImpersonationToken,
                                TOKEN_IMPERSONATE | TOKEN_READ | TOKEN_ASSIGN_PRIMARY | TOKEN_DUPLICATE,
                                NULL,
                                SecurityImpersonation,
                                TokenPrimary,
                                &hPrimaryToken
                                ))
                            {
                                hr = HrFromLastWin32Error();
                                TraceError ("HrGetCmpFileLocation -- DuplicateTokenEx", hr);
                            }
                        }
                    }
                }
            }

            //  Now Open the mappings key and get the cmp file path
            //
            if (SUCCEEDED(hr))
            {
                hr = HrRegOpenKeyEx((HKEY)hBaseKey,
                                    c_mappingsRegKey,
                                    KEY_READ, &hKey);

                if (SUCCEEDED(hr))
                {
                    dwSize = MAX_PATH;
                    WCHAR szTemp[MAX_PATH+1];
                    hr = HrRegQuerySzBuffer(hKey, szEntryName, szTemp, &dwSize);

                    if (SUCCEEDED (hr))
                    {
                        //  Check to see if the file exists
                        //
                        if (!m_fForAllUsers)
                        {
                            ExpandEnvironmentStringsForUserW(hPrimaryToken, szTemp,
                                szCmpFilePath, MAX_PATH);
                        }
                        else
                        {
                            lstrcpyW(szCmpFilePath, szTemp);
                        }

                        hFile = CreateFile(szCmpFilePath, GENERIC_READ, FILE_SHARE_READ,
                                            NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

                        if (INVALID_HANDLE_VALUE == hFile)
                        {
                            hr = HRESULT_FROM_WIN32(GetLastError());
                        }
                        else
                        {
                            CloseHandle(hFile);
                            hr = S_OK;
                        }
                    }
                    RegCloseKey(hKey);
                }
            }
        }

        if (!m_fForAllUsers)
        {
            if (hImpersonationToken)
            {
                CloseHandle(hImpersonationToken);
            }

            if (hPrimaryToken)
            {
                CloseHandle(hPrimaryToken);
            }

            // Close the handle opened by RtlOpenCurrentUser
            //
            NtClose(hBaseKey);

        }
        if (SUCCEEDED(hrImpersonate))
        {
            hr = CoRevertToSelf ();
            TraceError ("HrGetCmpFileLocation -- CoRevertToSelf", hr);
        }        
    }

    TraceError ("CDialupConnection::HrGetCmpFileLocation", hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Member:     CDialupConnection::HrEnsureCmStringsLoaded
//
//  Purpose:    This function ensures that the CM specific member vars for dialup
//              are loaded and usable by CM specific functions.  Please NOTE that
//              calling EnsureCmStringsAreLoaded requires the calling client to
//              properly setup CoSetProxyBlanket for a private user profile.
//
//  Arguments: none
//
//  Returns:    S_OK or an error code
//
HRESULT
CDialupConnection::HrEnsureCmStringsLoaded()
{
    HRESULT hr = S_OK;

    if (!m_fCmPathsLoaded)
    {
        WCHAR szwCmpFile[MAX_PATH];
        WCHAR szwCmsFile[MAX_PATH];
        WCHAR szwDrive[MAX_PATH];
        WCHAR szwDir[MAX_PATH];
        WCHAR szwFileName[MAX_PATH];
        WCHAR szwExtension[MAX_PATH];
        WCHAR szwProfileDir[MAX_PATH];
        WCHAR szwCmDir[MAX_PATH];

        int nNumChars;

        hr = HrGetCmpFileLocation(PszwPbkFile (), PszwEntryName (), szwCmpFile);

        if (SUCCEEDED(hr))
        {
            //  Now split the path
            //
            _wsplitpath(szwCmpFile, szwDrive, szwDir, szwFileName, szwExtension);

            //  Now construct the path to the cms file
            //
            nNumChars = wsprintfW(szwCmsFile, L"%s%s%s\\%s%s", szwDrive, szwDir, szwFileName, szwFileName, L".cms");
            ASSERT(nNumChars < celems(szwCmsFile));

            //  Now construct the profile dir path
            //
            nNumChars = wsprintfW(szwProfileDir, L"%s%s%s\\", szwDrive, szwDir, szwFileName);
            ASSERT(nNumChars < celems(szwProfileDir));

            //  Now construct the CM dir path
            //
            nNumChars = wsprintfW(szwCmDir, L"%s%s", szwDrive, szwDir);
            ASSERT(nNumChars < celems(szwCmDir));

            //  Now transfer to the member variables
            //
            m_strCmsFile = szwCmsFile;
            m_strProfileDir = szwProfileDir;    // remember this already has the trailing slash
            m_strCmDir = szwCmDir;              // remember this already has the trailing slash
            m_strShortServiceName = szwFileName;
            m_fCmPathsLoaded = TRUE;
        }
    }

    TraceError ("CDialupConnection::HrEnsureCmStringsLoaded", hr);
    return hr;
}

// INetDefaultConnection

//+---------------------------------------------------------------------------
//
//  Member:     CDialupConnection::SetDefault
//
//  Purpose:    Set the default RAS connection
//
//  Arguments:  TRUE to set as default connection. FALSE to unset it
//
//  Returns:    S_OK or an error code
//
HRESULT
CDialupConnection::SetDefault(BOOL bDefault)
{
    HRESULT hr = S_OK;
    HRESULT hrT = S_OK;

    if (!m_fInitialized)
    {
        hr = E_UNEXPECTED;
    }
    else
    {
        hr = HrEnsureEntryPropertiesCached ();
        if (SUCCEEDED(hr))
        {
            RASAUTODIALENTRY adEntry;
            ZeroMemory(&adEntry, sizeof(adEntry));
            
            adEntry.dwSize = sizeof(adEntry);
            if (bDefault)
            {
                wcsncpy(adEntry.szEntry, PszwEntryName(), sizeof(adEntry.szEntry) / sizeof(TCHAR));
            }

            hrT = CoImpersonateClient();
            if (SUCCEEDED(hrT))
            {
                DWORD dwErr = RasSetAutodialAddress(
                                NULL,
                                NULL,
                                &adEntry,
                                sizeof(adEntry),
                                1);

                if (dwErr != NO_ERROR)
                {
                    hr = HRESULT_FROM_WIN32(dwErr);
                }
                hrT = CoRevertToSelf();
            }
        }
    }
    TraceError ("CDialupConnection::SetDefault", hr);
    
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Member:     CDialupConnection::GetDefault
//
//  Purpose:    Get the default RAS connection
//
//  Arguments:  pbDefault - Is this the default connection
//
//  Returns:    S_OK or an error code
//
HRESULT
CDialupConnection::GetDefault (BOOL* pbDefault)
{
    HRESULT hr = S_OK;

    if (!m_fInitialized)
    {
        hr = E_UNEXPECTED;
    }
    else
    {
        hr = HrEnsureEntryPropertiesCached ();
        if (SUCCEEDED(hr))
        {
            if (m_dwFlagsPriv & REED_F_Default)
            {
                *pbDefault = TRUE;
            }
            else
            {
                *pbDefault = FALSE;
            }
        }
    }

    TraceError ("CDialupConnection::GetDefault", hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Member:     CDialupConnection::GetDefault
//
//  Purpose:    Get the default RAS connection
//
//  Arguments:  pbDefault - Is this the default connection
//
//  Returns:    S_OK or an error code
//
HRESULT
CDialupConnection::GetPropertiesEx(NETCON_PROPERTIES_EX** ppConnectionPropertiesEx)
{
    HRESULT hr = S_OK;

    *ppConnectionPropertiesEx = NULL;
    
    if (!m_fInitialized)
    {
        hr = E_UNEXPECTED;
    }
    else
    {
        NETCON_PROPERTIES* pProps;
        NETCON_PROPERTIES_EX* pPropsEx = reinterpret_cast<NETCON_PROPERTIES_EX*>(CoTaskMemAlloc(sizeof(NETCON_PROPERTIES_EX)));

        if (pPropsEx)
        {
        
            ZeroMemory(pPropsEx, sizeof(NETCON_PROPERTIES_EX));

            hr = GetProperties(&pProps);
        
            if (SUCCEEDED(hr))
            {
                hr = HrBuildPropertiesExFromProperties(pProps, pPropsEx, dynamic_cast<IPersistNetConnection *>(this));
                if (SUCCEEDED(hr))
                {
                    pPropsEx->bstrPhoneOrHostAddress = SysAllocString(m_strPhoneNumber.c_str());
                    *ppConnectionPropertiesEx = pPropsEx;
                }
                FreeNetconProperties(pProps);
            }
        }
        else
        {
            hr = E_OUTOFMEMORY;
        }
    }
    
    TraceError ("CDialupConnection::GetPropertiesEx", hr);
    return hr;
}