windows-server-2003/net/config/shell/statmon/smraspsp.cpp

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1997.
//
//  File:       S M R A S P S P . C P P
//
//  Contents:   The rendering of the UI for the network status monitor's RAS
//              property page
//
//  Notes:
//
//  Author:     CWill   02/03/1998
//
//----------------------------------------------------------------------------

#include "pch.h"
#pragma hdrstop

#include "sminc.h"
#include "smpsh.h"
#include "smutil.h"
#include "nsres.h"
#include "ncatlui.h"
#include "ncnetcon.h"
#include "ncras.h"

#include "mprapi.h"



const int c_nColumns=2;

HRESULT HrRasGetSubEntryHandle(HRASCONN hrasconn, DWORD dwSubEntry,
        HRASCONN* prasconnSub);
HRESULT HrRasHangUp(HRASCONN hrasconn);

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::CPspStatusMonitorRas
//
//  Purpose:    Creator
//
//  Arguments:  None
//
//  Returns:    Nil
//
CPspStatusMonitorRas::CPspStatusMonitorRas() :
    m_hRasConn(NULL)
{
    TraceFileFunc(ttidStatMon);

    m_pGenPage = NULL;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::~CPspStatusMonitorTool
//
//  Purpose:    Destructor
//
//  Arguments:  None
//
//  Returns:    Nil
//
CPspStatusMonitorRas::~CPspStatusMonitorRas(VOID)
{
    ::FreeCollectionAndItem(m_lstprdi);
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::HrInitRasPage
//
//  Purpose:    Initialize the RAS page class before the page has been
//              created
//
//  Arguments:  pncInit -   The connection associated with this monitor
//              pGenPage -  The general page that contains the persistent info
//                          for retrieving the INetConnection on disconnect
//
//  Returns:    Error code
//
HRESULT CPspStatusMonitorRas::HrInitRasPage(INetConnection* pncInit,
                                            CPspStatusMonitorGen * pGenPage,
                                            const DWORD * adwHelpIDs)
{
    TraceFileFunc(ttidStatMon);

    HRESULT hr  = S_OK;

    // set context help IDs
    m_adwHelpIDs = adwHelpIDs;

    // Stash the connection name for later use.
    // Note: Failures are handled and are not fatal
    //
    NETCON_PROPERTIES* pProps;
    hr = pncInit->GetProperties(&pProps);
    if (SUCCEEDED(hr))
    {
        m_strConnectionName = pProps->pszwName;
        m_ncmType = pProps->MediaType;
        m_dwCharacter = pProps->dwCharacter;

        FreeNetconProperties(pProps);
    }

    // Get a point to the General page where we can disconnect the connection
    // when suspending the last link in multilink RAS connection
    AssertSz(pGenPage, "We should have a valid pointer to the General page.");
    if (SUCCEEDED(hr))
    {
        m_pGenPage = pGenPage;
    }

    // Get RAS specific data
    //
    if (m_dwCharacter & NCCF_OUTGOING_ONLY)
    {
        INetRasConnection*  pnrcNew     = NULL;

        hr = HrQIAndSetProxyBlanket(pncInit, &pnrcNew);
        if (SUCCEEDED(hr))
        {
            RASCON_INFO     rciPage = { 0 };

            // Find out what entry in what phone book this connection is on
            //
            hr = pnrcNew->GetRasConnectionInfo (&rciPage);
            if (SUCCEEDED(hr))
            {
                RASENTRY*   pRasEntry = NULL;

                AssertSz(rciPage.pszwPbkFile, "We should have a pszwPbkFile");
                AssertSz(rciPage.pszwEntryName, "We should have a pszwEntryName");

                // Save for later use
                //
                m_strPbkFile    = rciPage.pszwPbkFile;
                m_strEntryName  = rciPage.pszwEntryName;

                // Get the handle to the connection
                //
                hr = pnrcNew->GetRasConnectionHandle(
                            reinterpret_cast<ULONG_PTR*>(&m_hRasConn));
                if (SUCCEEDED(hr))
                {
                    // We only allow user to dial/resume individual links
                    // if DialAll is set (i.e. neither "DialAsNeeded" or
                    // "Dial first available device only")
                    //
                    hr = ::HrRasGetEntryProperties(
                            rciPage.pszwPbkFile,
                            rciPage.pszwEntryName,
                            &pRasEntry,
                            NULL);
                    if (SUCCEEDED(hr))
                    {
                        if (pRasEntry->dwDialMode == RASEDM_DialAll)
                        {
                            DWORD   iSubEntry   = 1;

                            // clear up the current list before we add any new new entry
                            // $REVIEW(tongl 5/12): to fix bug # 170789
                            ::FreeCollectionAndItem(m_lstprdi);

                            // This is a one based count, so we have to have less than or
                            // equal to
                            //
                            for (; SUCCEEDED(hr) && iSubEntry <= pRasEntry->dwSubEntries;
                                    iSubEntry++)
                            {
                                RASSUBENTRY*    pRasSubEntry    = NULL;

                                // The name of the subentry
                                //
                                hr = ::HrRasGetSubEntryProperties(
                                        rciPage.pszwPbkFile,
                                        rciPage.pszwEntryName,
                                        iSubEntry,
                                        &pRasSubEntry);
                                if (SUCCEEDED(hr))
                                {
                                    CRasDeviceInfo* prdiNew     = NULL;
                                    // If we have all the info we need, create
                                    // a new entry add it to the list
                                    //
                                    prdiNew = new CRasDeviceInfo;

                                    if (prdiNew)
                                    {
                                        prdiNew->SetSubEntry(iSubEntry);
                                        prdiNew->SetDeviceName(pRasSubEntry->szDeviceName);
                                        
                                        m_lstprdi.push_back(prdiNew);
                                    }

                                    // Free the subentry data
                                    //
                                    MemFree(pRasSubEntry);
                                }
                            }
                        }

                        MemFree(pRasEntry);
                    }
                }

                ::RciFree(&rciPage);
            }

            ::ReleaseObj(pnrcNew);
        }

    }
    else if (m_dwCharacter & NCCF_INCOMING_ONLY)
    {
        // for incoming connection only

        // save the handle
        INetInboundConnection*  pnicNew;

        hr = HrQIAndSetProxyBlanket(pncInit, &pnicNew);

        if (SUCCEEDED(hr))
        {
            hr = pnicNew->GetServerConnectionHandle(
                    reinterpret_cast<ULONG_PTR*>(&m_hRasConn));
            if (SUCCEEDED(hr))
            {
                // Find out what ports are in this connection
                //
                // NTRAID#NTBUG9-84706-2000/09/28-sumeetb
            }

            ReleaseObj(pnicNew);
        }
    }
    else
    {
        AssertSz(FALSE, "Invalid connection type..");
    }

    TraceError("CPspStatusMonitorRas::HrInitRasPage",hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::OnInitDialog
//
//  Purpose:    Do the initialization required when the page has just been created
//
//  Arguments:  Standard window messsage parameters
//
//  Returns:    Standard window message return value
//
LRESULT CPspStatusMonitorRas::OnInitDialog(UINT uMsg, WPARAM wParam,
        LPARAM lParam, BOOL& bHandled)
{
    TraceFileFunc(ttidStatMon);

    // Fill the property list view
    //
    FillPropertyList();

    // Fill the device list
    //
    FillDeviceDropDown();

    return 0;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::OnDestroy
//
//  Purpose:    Clean up the dialog before the window goes away
//
//  Arguments:  Standard window messsage parameters
//
//  Returns:    Standard window message return value
//
LRESULT CPspStatusMonitorRas::OnDestroy(UINT uMsg, WPARAM wParam,
        LPARAM lParam, BOOL& bHandled)
{
    TraceFileFunc(ttidStatMon);

    ::FreeCollectionAndItem(m_lstprdi);
    return 0;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::OnContextMenu
//
//  Purpose:    When right click a control, bring up help
//
//  Arguments:  Standard command parameters
//
//  Returns:    Standard return
//
LRESULT
CPspStatusMonitorRas::OnContextMenu(UINT uMsg,
                                    WPARAM wParam,
                                    LPARAM lParam,
                                    BOOL& fHandled)
{
    TraceFileFunc(ttidStatMon);

    if (m_adwHelpIDs != NULL)
    {
        ::WinHelp(m_hWnd,
                  c_szNetCfgHelpFile,
                  HELP_CONTEXTMENU,
                  (ULONG_PTR)m_adwHelpIDs);
    }

    return 0;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::OnHelp
//
//  Purpose:    When drag context help icon over a control, bring up help
//
//  Arguments:  Standard command parameters
//
//  Returns:    Standard return
//
LRESULT
CPspStatusMonitorRas::OnHelp(UINT uMsg,
                             WPARAM wParam,
                             LPARAM lParam,
                             BOOL& fHandled)
{
    TraceFileFunc(ttidStatMon);

    LPHELPINFO lphi = reinterpret_cast<LPHELPINFO>(lParam);
    Assert(lphi);

    if ((m_adwHelpIDs != NULL) && (HELPINFO_WINDOW == lphi->iContextType))
    {
        ::WinHelp(static_cast<HWND>(lphi->hItemHandle),
                  c_szNetCfgHelpFile,
                  HELP_WM_HELP,
                  (ULONG_PTR)m_adwHelpIDs);
    }

    return 0;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::OnSetCursor
//
//  Purpose:    Ensure the mouse cursor over the Property Sheet is an Arrow.
//
//  Arguments:  Standard command parameters
//
//  Returns:    Standard return
//

LRESULT
CPspStatusMonitorRas::OnSetCursor (
    UINT    uMsg,
    WPARAM  wParam,
    LPARAM  lParam,
    BOOL&   bHandled)
{
    TraceFileFunc(ttidStatMon);

    if (LOWORD(lParam) == HTCLIENT)
    {
        SetCursor(LoadCursor(NULL, IDC_ARROW));
    }
	
    return FALSE;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::GetActiveDeviceCount
//
//  Purpose:    Return the number of active devices
//
//  Arguments:  none
//
//  Returns:    UINT
//
UINT CPspStatusMonitorRas::GetActiveDeviceCount()
{
    TraceFileFunc(ttidStatMon);
    
    INT   nCntDevices;
    INT   iCmb;
    INT   nCnt = 0;

    nCntDevices = (INT)SendDlgItemMessage(IDC_CMB_SM_RAS_DEVICES, CB_GETCOUNT, 0L, 0L);
    if ((CB_ERR != nCntDevices) && (nCntDevices > 1))
    {
        for (iCmb = 0; iCmb < nCntDevices; iCmb++)
        {
            CRasDeviceInfo* prdiSelect  = NULL;
            NETCON_STATUS   ncsTemp     = NCS_DISCONNECTED;

            // Get the object from the selection
            //
            prdiSelect = reinterpret_cast<CRasDeviceInfo*>(
                    SendDlgItemMessage(IDC_CMB_SM_RAS_DEVICES,
                                       CB_GETITEMDATA, iCmb, 0L));

            AssertSz(prdiSelect, "We should have a prdiSelect");

            // Count the connected devices
            //
            ncsTemp = NcsGetDeviceStatus(prdiSelect);
            if (fIsConnectedStatus(ncsTemp))
            {
                nCnt++;
            }
        }
    }

    return nCnt;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::FillPropertyList
//
//  Purpose:    Fill in the list of RAS properties
//
//  Arguments:  None
//
//  Returns:    Nil
//
VOID CPspStatusMonitorRas::FillPropertyList(VOID)
{
    TraceFileFunc(ttidStatMon);

    HWND hList = GetDlgItem(IDC_LVW_RAS_PROPERTY);

    // list view column structure
    RECT rect;
    LV_COLUMN lvCol;
    int index, iNewItem;

    // Calculate column width
    ::GetClientRect(hList, &rect);
    
    int colWidthFirst      = (int)(rect.right * 0.4); // First column is 40%
    int colWidthSubsequent = (rect.right-colWidthFirst)/(c_nColumns-1); // Divide remaining space between other columns equally

    // The mask specifies that the fmt, width and pszText members
    // of the structure are valid
    lvCol.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT ;
    lvCol.fmt = LVCFMT_LEFT;   // left-align column

    // Add the two columns and header text.
    for (index = 0; index < c_nColumns; index++)
    {
        // column header text
        if (0==index) // first column
        {
            lvCol.cx = colWidthFirst;
            lvCol.pszText = (PWSTR) SzLoadIds(IDS_PROPERTY);
        }
        else
        {
            lvCol.cx = colWidthSubsequent;
            lvCol.pszText = (PWSTR) SzLoadIds(IDS_VALUE);
        }

        iNewItem = ListView_InsertColumn(hList, index, &lvCol);

        AssertSz((iNewItem == index), "Invalid item inserted to list view !");
    }

    // Get RAS property data
    if (m_dwCharacter & NCCF_OUTGOING_ONLY)
    {
        FillRasClientProperty();
    }
    else
    {
        FillRasServerProperty();
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::FillRasClientProperty
//
//  Purpose:    Fill in the list of RAS properties for a RAS client
//
//  Arguments:  None
//
//  Returns:    Nil
//
VOID CPspStatusMonitorRas::FillRasClientProperty(VOID)
{
    TraceFileFunc(ttidStatMon);
    
    BOOLEAN bSlipConnection = FALSE;
    HWND hList = GetDlgItem(IDC_LVW_RAS_PROPERTY);
    tstring strServerType = (PWSTR) SzLoadIds(IDS_PPP);
    tstring strProtocolList = c_szEmpty;
    tstring strDeviceName = c_szEmpty;
    tstring strDeviceType = c_szEmpty;

    DWORD   dwRetCode;
    DWORD   dwSize;

    
    RASCONNSTATUS rcs;
    rcs.dwSize = sizeof(RASCONNSTATUS);
    dwRetCode = RasGetConnectStatus (m_hRasConn, &rcs);
    if (dwRetCode == NO_ERROR)
    {
        strDeviceName = rcs.szDeviceName;
        strDeviceType = rcs.szDeviceType;
        
        TraceTag(ttidStatMon, "RASCONNSTATUS.szDeviceName = %s", rcs.szDeviceName);
        TraceTag(ttidStatMon, "RASCONNSTATUS.szDeviceType = %s", rcs.szDeviceType);
    }

    // RASP_PppIp
    tstring strServerIp   = c_szEmpty;
    tstring strClientIp   = c_szEmpty;

    RASPPPIP    RasPppIp;
    RasPppIp.dwSize = sizeof( RasPppIp );

    dwSize = sizeof( RasPppIp );

    dwRetCode = RasGetProjectionInfo (m_hRasConn, RASP_PppIp, &RasPppIp, &dwSize);
    if ((dwRetCode == NO_ERROR) && (NO_ERROR == RasPppIp.dwError))
    {
        if (!strProtocolList.empty())
            strProtocolList += SzLoadIds(IDS_COMMA);
        strProtocolList += SzLoadIds(IDS_TCPIP);

        TraceTag(ttidStatMon, "RasPppIp.szServerIpAddress = %S", RasPppIp.szServerIpAddress);
        TraceTag(ttidStatMon, "RasPppIp.szIpAddress = %S", RasPppIp.szIpAddress);

        strServerIp = RasPppIp.szServerIpAddress;
        strClientIp = RasPppIp.szIpAddress;
    }

    // RASP_PppIpx
    tstring strClientIpx = c_szEmpty;

    RASPPPIPX    RasPppIpx;
    RasPppIpx.dwSize = sizeof( RasPppIpx );

    dwSize = sizeof( RasPppIpx );

    dwRetCode = RasGetProjectionInfo (m_hRasConn, RASP_PppIpx, &RasPppIpx, &dwSize);
    if ((dwRetCode == NO_ERROR)  && (NO_ERROR == RasPppIpx.dwError))
    {
        if (!strProtocolList.empty())
            strProtocolList += SzLoadIds(IDS_COMMA);
        strProtocolList += SzLoadIds(IDS_IPX);

        TraceTag(ttidStatMon, "RasPppIpx.szIpxAddress = %S", RasPppIpx.szIpxAddress);
        strClientIpx = RasPppIpx.szIpxAddress;
    }

    // RASP_PppNbf
    tstring strComputerName = c_szEmpty;

    RASPPPNBF    RasPppNbf;
    RasPppNbf.dwSize = sizeof( RasPppNbf );

    dwSize = sizeof( RasPppNbf );

    dwRetCode = RasGetProjectionInfo (m_hRasConn, RASP_PppNbf, &RasPppNbf, &dwSize);
    if ((dwRetCode == NO_ERROR) && (NO_ERROR == RasPppNbf.dwError))
    {
        if (!strProtocolList.empty())
            strProtocolList += SzLoadIds(IDS_COMMA);
        strProtocolList += SzLoadIds(IDS_NBF);

        TraceTag(ttidStatMon, "RasPppNbf.szWorkstationName = %S", RasPppNbf.szWorkstationName);
        strComputerName = RasPppNbf.szWorkstationName;
    }

    // RASP_Slip
    RASSLIP    RasSlip;
    RasSlip.dwSize = sizeof( RasSlip );

    dwSize = sizeof( RasSlip );

    dwRetCode =  RasGetProjectionInfo (m_hRasConn, RASP_Slip, &RasSlip, &dwSize);
    if ((dwRetCode == NO_ERROR) && (NO_ERROR == RasSlip.dwError))
    {
        AssertSz(strProtocolList.empty(), "How could this connection be both PPP and SLIP ?");

        strServerType = SzLoadIds(IDS_SLIP);
        strProtocolList = SzLoadIds(IDS_TCPIP);

        // Get the client IP address. The server IP is not exposed in this 
        // structure.
        strClientIp = RasSlip.szIpAddress;

        // Remember that this is a SLIP connection and not a PPP connection.
        bSlipConnection = TRUE;
    }

    // Authentication, Encryption and Compression info
    tstring strAuthentication   = c_szEmpty;
    tstring strEncryption       = c_szEmpty;
    tstring strIPSECEncryption  = c_szEmpty;
    tstring strCompression      = SzLoadIds(IDS_NONE);
    tstring strFraming          = c_szEmpty;

    // RASP_PppLcp
    RASPPPLCP    RasLcp;
    RasLcp.dwSize = sizeof( RasLcp );

    dwSize = sizeof( RasLcp );

    dwRetCode =  RasGetProjectionInfo (m_hRasConn, RASP_PppLcp, &RasLcp, &dwSize);
    if ((dwRetCode == NO_ERROR) && (NO_ERROR == RasLcp.dwError))
    {
        TraceTag(ttidStatMon, "Getting RASP_PppLcp info");
        TraceTag(ttidStatMon, "RasLcp.dwServerAuthenticationProtocol = %d", RasLcp.dwAuthenticationProtocol);
        TraceTag(ttidStatMon, "RasLcp.dwServerAuthenticationData = %d",     RasLcp.dwAuthenticationData);
        TraceTag(ttidStatMon, "RasLcp.fMultilink = %d", RasLcp.fMultilink);
        TraceTag(ttidStatMon, "RasLcp.dwOptions = %d", RasLcp.dwOptions);

        switch(RasLcp.dwServerAuthenticationProtocol)
        {
        case RASLCPAP_PAP:
            strAuthentication = SzLoadIds(IDS_PAP);
            break;

        case RASLCPAP_SPAP:
            strAuthentication = SzLoadIds(IDS_SPAP);
            break;

        case RASLCPAP_CHAP:
            {
                // get more specifics
                switch(RasLcp.dwServerAuthenticationData)
                {
                case RASLCPAD_CHAP_MS:
                    strAuthentication = SzLoadIds(IDS_CHAP);
                    break;

                case RASLCPAD_CHAP_MD5:
                    strAuthentication = SzLoadIds(IDS_CHAP_MD5);
                    break;

                case RASLCPAD_CHAP_MSV2:
                    strAuthentication = SzLoadIds(IDS_CHAP_V2);
                    break;
                }
            }
            break;

        case RASLCPAP_EAP:
            strAuthentication = SzLoadIds(IDS_EAP);
            break;
        }

        if (bSlipConnection == FALSE )
        {
            // Only PPP connections have the multilink property.
            if (RasLcp.fMultilink)
                strFraming = SzLoadIds(IDS_ON);
            else
                strFraming = SzLoadIds(IDS_OFF);
        }

        if (RasLcp.dwOptions & RASLCPO_DES_56)
        {
            strIPSECEncryption = SzLoadIds(IDS_EncryptionDES56);
        }
        else if (RasLcp.dwOptions & RASLCPO_3_DES)
        {
            strIPSECEncryption = SzLoadIds(IDS_Encryption3DES);
        }
    }

    // RASP_PppCcp
    RASPPPCCP    RasCcp;
    RasCcp.dwSize = sizeof( RasCcp );

    dwSize = sizeof( RasCcp );

    dwRetCode =  RasGetProjectionInfo (m_hRasConn, RASP_PppCcp, &RasCcp, &dwSize);
    if ((dwRetCode == NO_ERROR) && (NO_ERROR == RasCcp.dwError))
    {
        TraceTag(ttidStatMon, "Getting RASP_PppCcp info");
        TraceTag(ttidStatMon, "RasCcp.dwOptions = %x", RasCcp.dwOptions);
        TraceTag(ttidStatMon, "RasCcp.dwCompressionAlgorithm = %d", RasCcp.dwCompressionAlgorithm);

        if (RasCcp.dwOptions & RASCCPO_Encryption56bit)
        {
            strEncryption = SzLoadIds(IDS_Encryption56bit);
        }
        else if (RasCcp.dwOptions & RASCCPO_Encryption40bit)
        {
            strEncryption = SzLoadIds(IDS_Encryption40bit);
        }
        else if (RasCcp.dwOptions & RASCCPO_Encryption128bit)
        {
            strEncryption = SzLoadIds(IDS_Encryption128bit);
        }

        if (RasCcp.dwOptions & RASCCPO_Compression)
        {
            switch(RasCcp.dwCompressionAlgorithm)
            {
            case RASCCPCA_MPPC:
                strCompression = SzLoadIds(IDS_MPPC);
                break;

            case RASCCPCA_STAC:
                strCompression = SzLoadIds(IDS_STAC);
                break;
            }
        }
    }

    // Fill the list view
    ListView_DeleteAllItems(hList);

    int iItem =0;

    // Device name
    int iListviewItem = InsertProperty(&iItem, IDS_DeviceName, strDeviceName);
    if (-1 != iListviewItem)
    {
        ListView_SetItemState(hList, iListviewItem, LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED);
    }

    // Device type
    InsertProperty(&iItem, IDS_DeviceType, strDeviceType);
    
    // Server type
    InsertProperty(&iItem, IDS_ServerType, strServerType);

    // Transports
    InsertProperty(&iItem, IDS_Transports, strProtocolList);

    // Authentication
    InsertProperty(&iItem, IDS_Authentication, strAuthentication);

    // Encryption
    InsertProperty(&iItem, IDS_Encryption, strEncryption);

    // IPSEC Encryption
    InsertProperty(&iItem, IDS_IPSECEncryption, strIPSECEncryption);

    // Compression
    InsertProperty(&iItem, IDS_Compression, strCompression);

    // PPP Multilink Framing
    InsertProperty(&iItem, IDS_ML_Framing, strFraming);

    // Server IP address
    InsertProperty(&iItem, IDS_ServerIP, strServerIp);

    // Client IP address
    InsertProperty(&iItem, IDS_ClientIP, strClientIp);

    // Client IPX address
    InsertProperty(&iItem, IDS_ClientIPX, strClientIpx);

    // Client computer name
    InsertProperty(&iItem, IDS_ComputerName, strComputerName);

}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::FillRasServerProperty
//
//  Purpose:    Fill in the list of RAS properties for a RAS server
//
//  Arguments:  None
//
//  Returns:    Nil
//
VOID CPspStatusMonitorRas::FillRasServerProperty(VOID)
{
    TraceFileFunc(ttidStatMon);

    HWND hList = GetDlgItem(IDC_LVW_RAS_PROPERTY);

    RAS_SERVER_HANDLE hMprAdmin;
    DWORD dwError = MprAdminServerConnect(NULL, &hMprAdmin);

    if (dwError == NO_ERROR)
    {
        // Initialize the list view
        ListView_DeleteAllItems(hList);
        int iItem =0;

        //
        // Level 1 info
        //

        // Only PPP is supported on the RAS server
        tstring strServerType = (PWSTR) SzLoadIds(IDS_PPP);
        tstring strProtocolList = c_szEmpty;

        // IP info
        tstring strServerIp = c_szEmpty;
        tstring strClientIp = c_szEmpty;

        // IPX info
        tstring strClientIpx = c_szEmpty;

        // Nbf info
        tstring strComputerName = c_szEmpty;


        RAS_CONNECTION_1 * pConn1;
        dwError = MprAdminConnectionGetInfo(hMprAdmin,
                                            1,
                                            m_hRasConn,
                                            (LPBYTE*)&pConn1);
        if (dwError == NO_ERROR)
        {
            PPP_INFO * pInfo = &(pConn1->PppInfo);

            // PPP_IPCP_INFO
            if (!(pInfo->ip).dwError)
            {
                if (!strProtocolList.empty())
                    strProtocolList += SzLoadIds(IDS_COMMA);
                strProtocolList += SzLoadIds(IDS_TCPIP);

                strServerIp = pInfo->ip.wszAddress; 
                strClientIp = pInfo->ip.wszRemoteAddress;
            }

            // PPP_IPXCP_INFO
            if (!pInfo->ipx.dwError)
            {
                if (!strProtocolList.empty())
                    strProtocolList += SzLoadIds(IDS_COMMA);
                strProtocolList += SzLoadIds(IDS_IPX);

                strClientIpx = pInfo->ipx.wszAddress;
            }

            // PPP_NBFCP_INFO
            if (!pInfo->nbf.dwError)
            {
                if (!strProtocolList.empty())
                    strProtocolList += SzLoadIds(IDS_COMMA);
                strProtocolList += SzLoadIds(IDS_NBF);

                strComputerName = pInfo->nbf.wszWksta;
            }

            // PPP_ATCP_INFO
            if (!pInfo->at.dwError)
            {
                if (!strProtocolList.empty())
                    strProtocolList += SzLoadIds(IDS_COMMA);
                strProtocolList += SzLoadIds(IDS_APPLETALK);
            }

            MprAdminBufferFree(pConn1);
        }

        //
        // Level 2 info
        //

        // Authentication, Encryption and Compression
        tstring strAuthentication   = c_szEmpty;
        tstring strEncryption       = c_szEmpty;
        tstring strCompression      = c_szEmpty;
        tstring strIPSECEncryption  = c_szEmpty;

        RAS_CONNECTION_2 * pConn2;
        dwError = MprAdminConnectionGetInfo(hMprAdmin,
                                            2,
                                            m_hRasConn,
                                            (LPBYTE*)&pConn2);
        if (dwError == NO_ERROR)
        {
            PPP_INFO_2 * pInfo2 = &(pConn2->PppInfo2);

            // PPP_LCP_INFO
            if (!(pInfo2->lcp).dwError)
            {
                TraceTag(ttidStatMon, "Getting PPP_LCP_INFO");
                TraceTag(ttidStatMon, "lcp.dwAuthenticationProtocol = %d", (pInfo2->lcp).dwAuthenticationProtocol);
                TraceTag(ttidStatMon, "lcp.dwAuthenticationData = %d", (pInfo2->lcp).dwAuthenticationData);
                TraceTag(ttidStatMon, "lcp.dwOptions = %d", (pInfo2->lcp).dwOptions);

                switch((pInfo2->lcp).dwAuthenticationProtocol)
                {
                case PPP_LCP_PAP:
                    strAuthentication = SzLoadIds(IDS_PAP);
                    break;

                case PPP_LCP_SPAP:
                    strAuthentication = SzLoadIds(IDS_SPAP);
                    break;

                case PPP_LCP_CHAP:
                    {
                        // get more specifics
                        switch((pInfo2->lcp).dwAuthenticationData)
                        {
                        case RASLCPAD_CHAP_MS:
                            strAuthentication = SzLoadIds(IDS_CHAP);
                            break;

                        case RASLCPAD_CHAP_MD5:
                            strAuthentication = SzLoadIds(IDS_CHAP_MD5);
                            break;

                        case RASLCPAD_CHAP_MSV2:
                            strAuthentication = SzLoadIds(IDS_CHAP_V2);
                            break;
                        }
                    }
                    break;

                case PPP_LCP_EAP:
                    strAuthentication = SzLoadIds(IDS_EAP);
                    break;
                }

                if ((pInfo2->lcp).dwOptions & PPP_LCP_DES_56)
                {
                    strIPSECEncryption = SzLoadIds(IDS_EncryptionDES56);
                }
                else if ((pInfo2->lcp).dwOptions & PPP_LCP_3_DES)
                {
                    strIPSECEncryption = SzLoadIds(IDS_Encryption3DES);
                }
            }

            // PPP_CCP_INFO
            if (!(pInfo2->ccp).dwError)
            {
                TraceTag(ttidStatMon, "Getting PPP_CCP_INFO");
                TraceTag(ttidStatMon, "ccp.dwOptions = %x", pInfo2->ccp.dwOptions);
                TraceTag(ttidStatMon, "ccp.dwCompressionAlgorithm = %d", pInfo2->ccp.dwCompressionAlgorithm);

                if ((pInfo2->ccp.dwOptions) & PPP_CCP_ENCRYPTION56BIT)
                {
                    strEncryption = SzLoadIds(IDS_Encryption56bit);
                }
                else if ((pInfo2->ccp.dwOptions) & PPP_CCP_ENCRYPTION40BIT)
                {
                    strEncryption = SzLoadIds(IDS_Encryption40bit);
                }
                else if ((pInfo2->ccp.dwOptions) & PPP_CCP_ENCRYPTION128BIT)
                {
                    strEncryption = SzLoadIds(IDS_Encryption128bit);
                }

                if ((pInfo2->ccp.dwOptions) & PPP_CCP_COMPRESSION)
                {
                    switch(pInfo2->ccp.dwCompressionAlgorithm)
                    {
                    case RASCCPCA_MPPC:
                        strCompression = SzLoadIds(IDS_MPPC);
                        break;

                    case RASCCPCA_STAC:
                        strCompression = SzLoadIds(IDS_STAC);
                        break;
                    }
                }
            }

            MprAdminBufferFree(pConn2);
        }

        MprAdminServerDisconnect(hMprAdmin);

        // Now add to the list view

        // Server type
        InsertProperty(&iItem, IDS_ServerType, strServerType);

        // Transports
        InsertProperty(&iItem, IDS_Transports, strProtocolList);

        // Authentication
        InsertProperty(&iItem, IDS_Authentication, strAuthentication);

        // Encryption
        InsertProperty(&iItem, IDS_Encryption, strEncryption);

        // IPSEC Encryption
        InsertProperty(&iItem, IDS_IPSECEncryption, strIPSECEncryption);

        // Compression
        InsertProperty(&iItem, IDS_Compression, strCompression);

        // Server IP address
        InsertProperty(&iItem, IDS_ServerIP, strServerIp);

        // Client IP address
        InsertProperty(&iItem, IDS_ClientIP, strClientIp);

        // Client IPX address
        InsertProperty(&iItem, IDS_ClientIPX, strClientIpx);

        // Client computer name
        InsertProperty(&iItem, IDS_ComputerName, strComputerName);
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::InsertProperty
//
//  Purpose:    Fill one RAS properties to the list
//
//  Arguments:  piItem    - the index ofthe item
//              unId     - the property name
//              strValue - the property value
//
//  Returns:    Nil
//
int CPspStatusMonitorRas::InsertProperty(int * piItem,
                                          UINT  unId,
                                          tstring& strValue)
{
    TraceFileFunc(ttidStatMon);

    int lres = 0;

    if (!strValue.empty())
    {
        int iItem = *piItem;

        LV_ITEM lvItem;
        lvItem.mask = LVIF_TEXT;

        lvItem.iItem=iItem;
        lvItem.iSubItem=0;
        lvItem.pszText = (PWSTR) SzLoadIds(unId);
        lres = static_cast<int>(SendDlgItemMessage(IDC_LVW_RAS_PROPERTY, LVM_INSERTITEM,
                           iItem, (LPARAM)&lvItem));

        lvItem.iSubItem=1;
        lvItem.pszText=(PWSTR)strValue.c_str();

        SendDlgItemMessage(IDC_LVW_RAS_PROPERTY, LVM_SETITEMTEXT,
                           iItem, (LPARAM)&lvItem);
        ++(*piItem);
    }
    return lres;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::FillDeviceDropDown
//
//  Purpose:    Do the initialization required when the page has just been created
//
//  Arguments:  None
//
//  Returns:    Nil
//
VOID CPspStatusMonitorRas::FillDeviceDropDown(VOID)
{
    TraceFileFunc(ttidStatMon);

    INT                             iCmb    = 0;
    list<CRasDeviceInfo*>::iterator iterLstprdi;

    // Clear out the control
    //
    SendDlgItemMessage(IDC_CMB_SM_RAS_DEVICES, CB_RESETCONTENT, 0, 0L);

    // Put the devices in our list
    //
    iterLstprdi = m_lstprdi.begin();
    while (iterLstprdi != m_lstprdi.end())
    {
        // Create a new entry in the list
        //
        iCmb = (INT)SendDlgItemMessage(IDC_CMB_SM_RAS_DEVICES, CB_ADDSTRING, 0,
                (LPARAM)((*iterLstprdi)->PszGetDeviceName()));

        if (CB_ERR != iCmb)
        {
            // Store the vaule on the selection to make it easy to read later
            //
            SendDlgItemMessage(IDC_CMB_SM_RAS_DEVICES, CB_SETITEMDATA, iCmb,
                    (LPARAM)(*iterLstprdi));
        }

        iterLstprdi++;
    }

    // Set the first selection
    //
    SendDlgItemMessage(IDC_CMB_SM_RAS_DEVICES, CB_SETCURSEL, 0L, 0L);

    // Make sure the state of the button is correct
    //
    iCmb = (INT)SendDlgItemMessage(IDC_CMB_SM_RAS_DEVICES, CB_GETCURSEL,
            0L, 0L);
    if (CB_ERR != iCmb)
    {
        CRasDeviceInfo* prdiSelect  = NULL;

        // Get the object from the selection
        //
        prdiSelect = reinterpret_cast<CRasDeviceInfo*>(
                SendDlgItemMessage(
                    IDC_CMB_SM_RAS_DEVICES,
                    CB_GETITEMDATA,
                    iCmb,
                    0L));

        SetButtonStatus(prdiSelect);
    }

    // If the number of devices is less than or equal to one then
    // hide the device related group of controls
    //
    if (m_lstprdi.size() <= 1)
    {
        int nrgIdc[] = {IDC_CMB_SM_RAS_DEVICES, IDC_TXT_SM_NUM_DEVICES,
                        IDC_TXT_SM_NUM_DEVICES_VAL, IDC_BTN_SM_SUSPEND_DEVICE,
                        IDC_GB_SM_DEVICES};

        for (int nIdx=0; nIdx < celems(nrgIdc); nIdx++)
            ::ShowWindow(GetDlgItem(nrgIdc[nIdx]), SW_HIDE);

        // We can now display a larger properties window
        RECT rcRectDialog;
        if (GetWindowRect(&rcRectDialog))
        {
            RECT rcRectRasProperty;
            if (::GetWindowRect(GetDlgItem(IDC_LVW_RAS_PROPERTY), &rcRectRasProperty))
            {
                DWORD dwTopDiff    = rcRectRasProperty.top - rcRectDialog.top;
                DWORD dwLeftDiff   = rcRectRasProperty.left - rcRectDialog.left;
                DWORD dwRightDiff  = rcRectDialog.right  - rcRectRasProperty.right;
                DWORD dwBottomDiff = rcRectDialog.bottom - rcRectRasProperty.bottom;
                DWORD dwDialogWidth  = rcRectDialog.right - rcRectDialog.left;
                DWORD dwDialogHeight = rcRectDialog.bottom - rcRectDialog.top;

                rcRectRasProperty.top    = dwTopDiff;
                rcRectRasProperty.left   = dwLeftDiff;
                rcRectRasProperty.right  = dwDialogWidth  - dwRightDiff;
                rcRectRasProperty.bottom = dwDialogHeight - dwRightDiff;

                ::MoveWindow(GetDlgItem(IDC_LVW_RAS_PROPERTY), rcRectRasProperty.left, rcRectRasProperty.top, 
                    rcRectRasProperty.right - rcRectRasProperty.left, rcRectRasProperty.bottom - rcRectRasProperty.top, TRUE);
            }
        }

        // Disable the suspend button, so no one can activate it by keystroke
        //
        ::EnableWindow(GetDlgItem(IDC_BTN_SM_SUSPEND_DEVICE), FALSE);
    }
    else
    {
        // Set the number of active devices
        //
        UINT unActiveDeviceCount = GetActiveDeviceCount();

        SetDlgItemInt(
                IDC_TXT_SM_NUM_DEVICES_VAL,
                unActiveDeviceCount,
                FALSE);
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::OnSuspendDevice
//
//  Purpose:    Suspend the device that is in the combo box
//
//  Arguments:  Standard window message
//
//  Returns:    Standard return.
//
LRESULT CPspStatusMonitorRas::OnSuspendDevice(WORD wNotifyCode, WORD wID,
                                              HWND hWndCtl, BOOL& fHandled)
{
    TraceFileFunc(ttidStatMon);

    HRESULT hr = S_OK;

    if (BN_CLICKED == wNotifyCode)
    {
        // Get the item in the drop down
        //
        INT iCmb = (INT)SendDlgItemMessage(IDC_CMB_SM_RAS_DEVICES, CB_GETCURSEL,
                0L, 0L);
        if (CB_ERR != iCmb)
        {
            CRasDeviceInfo* prdiSelect  = NULL;
            NETCON_STATUS   ncsTemp     = NCS_DISCONNECTED;

            // Get the object from the selection
            //
            prdiSelect = reinterpret_cast<CRasDeviceInfo*>(
                        SendDlgItemMessage(
                        IDC_CMB_SM_RAS_DEVICES,
                        CB_GETITEMDATA,
                        iCmb,
                        0L));

            AssertSz(prdiSelect, "We should have a prdiSelect");
            AssertSz(m_hRasConn, "We should have a m_hRasConn");

            // Disable the button till the suspend/resume is done
            ::EnableWindow(GetDlgItem(IDC_BTN_SM_SUSPEND_DEVICE), FALSE);

            ncsTemp = NcsGetDeviceStatus(prdiSelect);
            if (fIsConnectedStatus(ncsTemp))
            {
                // If more than one active link exists, allow the hang up
                //
                UINT unActiveDeviceCount = GetActiveDeviceCount();
                if ( unActiveDeviceCount >1)
                {
                    HRASCONN        hrasconnSub = NULL;

                    // Get the handle to the sub entry and hangup
                    //
                    hr = ::HrRasGetSubEntryHandle(m_hRasConn,
                            prdiSelect->DwGetSubEntry(), &hrasconnSub);
                    if (SUCCEEDED(hr))
                    {
                        hr = ::HrRasHangUp(hrasconnSub);
                    }
                }
                else
                {
                    // Only one active link exists, prompt the user if
                    // they really wish to disconnect
                    //
                    HWND hwndPS = ::GetParent(m_hWnd);

                    if (IDYES == ::NcMsgBox(hwndPS,
                         IDS_SM_ERROR_CAPTION, IDS_SM_DISCONNECT_PROMPT,
                         MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2,
                         m_strConnectionName.c_str()))
                    {
                        AssertSz(m_pGenPage, "We should have a pointer to the general page.");

                        if (m_pGenPage)
                        {
                            hr = m_pGenPage->HrDisconnectConnection(TRUE);
                        }
                    }
                }
            }
            else
            {
                // if the link was disconnected, "resume"

                BOOL        fRet    = FALSE;
                RASDIALDLG  rdiTemp = { 0 };

                // Initialize the structure
                //
                rdiTemp.dwSize      = sizeof(RASDIALDLG);
                rdiTemp.hwndOwner   = m_hWnd;
                rdiTemp.dwSubEntry  = prdiSelect->DwGetSubEntry();

                // Dial the entry
                //
                fRet = RasDialDlg(
                        const_cast<PWSTR>(m_strPbkFile.c_str()),
                        const_cast<PWSTR>(m_strEntryName.c_str()),
                        NULL,
                        &rdiTemp);

                // We have an error.  See if the user canceled
                //
                if (ERROR_CANCELLED != rdiTemp.dwError)
                {
                    hr = HRESULT_FROM_WIN32(rdiTemp.dwError);
                }
            }

            // Regardless of what happened, set the status to it's new
            // state
            //
            SetButtonStatus(prdiSelect);

            // Re-Enable the button till the suspend/resume is done
            ::EnableWindow(GetDlgItem(IDC_BTN_SM_SUSPEND_DEVICE), TRUE);

            // Also update the active device count
            UINT unActiveDeviceCount = GetActiveDeviceCount();

            SetDlgItemInt(
                    IDC_TXT_SM_NUM_DEVICES_VAL,
                    unActiveDeviceCount,
                    FALSE);
        }
    }

    return 0;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::OnDeviceDropDown
//
//  Purpose:    Update the push button text when the combo-box selection changes
//
//  Arguments:  Standard window messsage parameters
//
//  Returns:    Standard window message return value
//
LRESULT CPspStatusMonitorRas::OnDeviceDropDown(WORD wNotifyCode, WORD wID,
        HWND hWndCtl, BOOL& fHandled)
{
    TraceFileFunc(ttidStatMon);

    if (CBN_SELCHANGE ==  wNotifyCode)
    {
        INT iCmb = (INT)SendDlgItemMessage(IDC_CMB_SM_RAS_DEVICES, CB_GETCURSEL,
                        0L, 0L);
        if (CB_ERR != iCmb)
        {
            CRasDeviceInfo*     prdiSelect  = NULL;
            INT                 idsButton   = 0;

            prdiSelect = reinterpret_cast<CRasDeviceInfo*>(
                    SendDlgItemMessage(
                        IDC_CMB_SM_RAS_DEVICES,
                        CB_GETITEMDATA,
                        iCmb,
                        0L));

            AssertSz(prdiSelect, "We should have a prdiSelect");

            if (fIsConnectedStatus(NcsGetDeviceStatus(prdiSelect)))
            {
                idsButton = IDS_SM_SUSPEND;
            }
            else
            {
                idsButton = IDS_SM_RESUME;
            }

            // Set the new name
            //
            SetDlgItemText(IDC_BTN_SM_SUSPEND_DEVICE,
                    ::SzLoadIds(idsButton));
        }
    }

    return 0;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::NcsGetDeviceStatus
//
//  Purpose:    Gets the status of one of the RAS subentries
//
//  Arguments:  prdiStatus -    Device to get status of
//
//  Returns:    The status of the device
//

LRESULT CPspStatusMonitorRas::OnUpdateRasLinkList(UINT uMsg, WPARAM wParam,
                                                 LPARAM lParam, BOOL& bHandled)
{
    TraceFileFunc(ttidStatMon);

    // Get the item in the drop down
    //
    INT iCmb = (INT)SendDlgItemMessage(IDC_CMB_SM_RAS_DEVICES, CB_GETCURSEL,
                                  0L, 0L);
    if (CB_ERR != iCmb)
    {
        CRasDeviceInfo* prdiSelect  = NULL;

        // Get the object from the selection
        //
        prdiSelect = reinterpret_cast<CRasDeviceInfo*>(
                        SendDlgItemMessage(
                        IDC_CMB_SM_RAS_DEVICES,
                        CB_GETITEMDATA,
                        iCmb,
                        0L));

        if (prdiSelect)
        {
            // Regardless of what happened, set the status to it's new
            // state
            //
            SetButtonStatus(prdiSelect);

            // Also update the active device count
            UINT unActiveDeviceCount = GetActiveDeviceCount();

            SetDlgItemInt(
                    IDC_TXT_SM_NUM_DEVICES_VAL,
                    unActiveDeviceCount,
                    FALSE);
        }
    }

    return 0;
}


//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::NcsGetDeviceStatus
//
//  Purpose:    Gets the status of one of the RAS subentries
//
//  Arguments:  prdiStatus -    Device to get status of
//
//  Returns:    The status of the device
//
NETCON_STATUS
CPspStatusMonitorRas::NcsGetDeviceStatus(
        CRasDeviceInfo* prdiStatus)
{
    TraceFileFunc(ttidStatMon);

    NETCON_STATUS   ncsStatus   = NCS_DISCONNECTED;
    HRESULT         hr          = S_OK;
    HRASCONN        hrasconnSub = NULL;

    TraceTag(ttidStatMon, " === Calling NcsGetDeviceStatus on device: %S, subentry: %d ===",
             prdiStatus->PszGetDeviceName(), prdiStatus->DwGetSubEntry());

    // Get the handle to the subentry so that we can
    // tell what state the connection is in.  If we
    // can't do that, assume it is disconnected
    //
    hr = HrRasGetSubEntryHandle(m_hRasConn,
            prdiStatus->DwGetSubEntry(), &hrasconnSub);

    TraceTag(ttidStatMon, "HrRasGetSubEntryHandle returns, hr = %x", hr);

    if (SUCCEEDED(hr))
    {
        hr = HrRasGetNetconStatusFromRasConnectStatus (
                hrasconnSub, &ncsStatus);

        TraceTag(ttidStatMon, "HrRasGetNetconStatusFromRasConnectStatus returns hr = %x, Status = %d",
                 hr, ncsStatus);
    }

    return ncsStatus;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorRas::SetButtonStatus
//
//  Purpose:    Change the suspend/resume button to the correct state
//
//  Arguments:  prdiSelect -    The device that is selected
//
//  Returns:    Nil
//
VOID CPspStatusMonitorRas::SetButtonStatus(CRasDeviceInfo* prdiSelect)
{
    TraceFileFunc(ttidStatMon);

    //$ REVIEW : CWill : 02/25/98 : Common function?
    INT idsButton   = 0;

    if (fIsConnectedStatus(NcsGetDeviceStatus(prdiSelect)))
    {
        idsButton = IDS_SM_SUSPEND;
    }
    else
    {
        idsButton = IDS_SM_RESUME;
    }

    // Set the new name
    //
    SetDlgItemText(IDC_BTN_SM_SUSPEND_DEVICE,
            ::SzLoadIds(idsButton));
}

//+---------------------------------------------------------------------------
//
//  Function:   HrRasGetSubEntryHandle
//
//  Purpose:    Wrapper around RasGetSubEntryHandle
//
//  Arguments:  RasGetSubEntryHandle arguements
//
//  Returns:    Error code
//
HRESULT HrRasGetSubEntryHandle(HRASCONN hrasconn, DWORD dwSubEntry,
        HRASCONN* prasconnSub)
{
    TraceFileFunc(ttidStatMon);

    HRESULT hr      = S_OK;

    DWORD dwRet = ::RasGetSubEntryHandle(hrasconn, dwSubEntry,
            prasconnSub);
    if (dwRet)
    {
        hr = HRESULT_FROM_WIN32(dwRet);
    }

    TraceError("HrRasGetSubEntryHandle", hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Function:   HrRasHangUp
//
//  Purpose:    Wrapper around RasHangUp
//
//  Arguments:  RasHangUp arguements
//
//  Returns:    Error code
//
HRESULT HrRasHangUp(HRASCONN hrasconn)
{
    TraceFileFunc(ttidStatMon);
    
    HRESULT hr = S_OK;

    DWORD dwRet = ::RasHangUp(hrasconn);
    if (dwRet)
    {
        hr = HRESULT_FROM_WIN32(dwRet);
    }

    TraceError("HrRasHangUp", hr);
    return hr;
}