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

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1997.
//
//  File:       S M R A S . C P P
//
//  Contents:   The RAS engine that provides statistics to the status monitor
//
//  Notes:
//
//  Author:     CWill   12/02/1997
//
//----------------------------------------------------------------------------
#include "pch.h"
#pragma hdrstop
#include "ncras.h"
#include "sminc.h"
#include "netcon.h"
#include "smpsh.h"

#include "mprapi.h"



//+---------------------------------------------------------------------------
//
//  Member:     CRasStatEngine::CRasStatEngine
//
//  Purpose:    Creator
//
//  Arguments:  None
//
//  Returns:    Nil
//
CRasStatEngine::CRasStatEngine() :
    m_hRasConn(NULL)
{
    m_ncmType = NCM_PHONE;
    m_dwCharacter = NCCF_OUTGOING_ONLY;
    return;
}

//+---------------------------------------------------------------------------
//
//  Member:     CRasStatEngine::put_RasConn
//
//  Purpose:    Pass handles to the RAS engine
//
//  Arguments:  hRasConn - The handle being set
//
//  Returns:    Error code
//
VOID CRasStatEngine::put_RasConn(HRASCONN hRasConn)
{
    AssertSz(hRasConn, "We should have a hRasConn");
    m_hRasConn = hRasConn;
}

//+---------------------------------------------------------------------------
//
//  Member:     CRasStatEngine::put_MediaType
//
//  Purpose:    Pass media type of RAS connection type to the RAS engine
//
//  Arguments:  ncmType  - NETCON_MEDIATYPE being set
//              ncsmType - NETCON_SUBMEDIATYPE being set
//
//  Returns:
//
VOID CRasStatEngine::put_MediaType(NETCON_MEDIATYPE ncmType, NETCON_SUBMEDIATYPE ncsmType)
{
    m_ncmType   = ncmType;
    m_ncsmType  = ncsmType;
}

//+---------------------------------------------------------------------------
//
//  Member:     CRasStatEngine::put_Character
//
//  Purpose:    Character of RAS connection
//
//  Arguments:  dwCharacter - The character being set
//
//  Returns:
//
VOID CRasStatEngine::put_Character(DWORD dwCharacter)
{
    m_dwCharacter = dwCharacter;
}

//+---------------------------------------------------------------------------
//
//  Member:     CRasStatEngine::HrUpdateData
//
//  Purpose:    Get new statistics from the devices.  This data is used to be
//              displayed in the UI.
//
//  Arguments:  pdwChangeFlags -    Where to return for statistics
//
//  Returns:    Error code
//
HRESULT
CRasStatEngine::HrUpdateData (
    DWORD* pdwChangeFlags,
    BOOL*  pfNoLongerConnected)
{
    HRESULT         hr          = S_OK;

    // Initialize the output parameters.
    //
    if (pdwChangeFlags)
    {
        *pdwChangeFlags = SMDCF_NULL;
    }

    *pfNoLongerConnected = FALSE;

    CExceptionSafeComObjectLock EsLock(this);

    // Get a pointer to the elements of the array.
    //
    if (m_dwCharacter & NCCF_OUTGOING_ONLY)
    {
        // Get the status of the connection.
        //
        NETCON_STATUS ncs;
        hr = HrRasGetNetconStatusFromRasConnectStatus (
                m_hRasConn, &ncs);

        // Make sure we have a statistics structure
        //
        EnterCriticalSection(&g_csStatmonData);

        if (!m_psmEngineData)
        {
            m_psmEngineData = new STATMON_ENGINEDATA;

            if (m_psmEngineData)
            {
                ZeroMemory(m_psmEngineData, sizeof(STATMON_ENGINEDATA));
            }
        }

        // Set the status
        //
        if (m_psmEngineData)
        {
            if (SUCCEEDED(hr) && (NCS_DISCONNECTED != ncs))
            {
                m_psmEngineData->SMED_CONNECTIONSTATUS = ncs;
            }
            else if (HRESULT_FROM_WIN32(ERROR_INVALID_HANDLE) == hr)
            {
                *pfNoLongerConnected = TRUE;

                // set the connection status to "disconnected" so we can close the UI
                m_psmEngineData->SMED_CONNECTIONSTATUS = NCS_DISCONNECTED;

                hr = S_OK;
            }
        }
        else
        {
            hr = E_OUTOFMEMORY;
        }

        LeaveCriticalSection(&g_csStatmonData);

        if ((m_psmEngineData) && SUCCEEDED(hr) && (NCS_DISCONNECTED != ncs))
        {
            // Retrieve the statistics of the connection
            //
            RAS_STATS   rsNewData;
            rsNewData.dwSize = sizeof(RAS_STATS);
            DWORD dwErr = RasGetConnectionStatistics(m_hRasConn, &rsNewData);
            hr = HRESULT_FROM_WIN32 (dwErr);
            TraceError ("RasGetConnectionStatistics", hr);

            if (SUCCEEDED(hr))
            {
                // Update the change flags if asked for
                //
                if (pdwChangeFlags)
                {
                    if (m_psmEngineData->SMED_PACKETSTRANSMITTING
                            != rsNewData.dwFramesXmited)
                    {
                        *pdwChangeFlags |= SMDCF_TRANSMITTING;
                    }

                    if (m_psmEngineData->SMED_PACKETSRECEIVING
                            != rsNewData.dwFramesRcved)
                    {
                        *pdwChangeFlags |= SMDCF_RECEIVING;
                    }
                }

                // Get the rest of the data
                //
                m_psmEngineData->SMED_DURATION  = rsNewData.dwConnectDuration/1000;

                // Don't pass out speed info for VPN connections (294953)
                if (NCM_TUNNEL != m_ncmType)
                {
                    m_psmEngineData->SMED_SPEEDTRANSMITTING         = rsNewData.dwBps;
                    m_psmEngineData->SMED_SPEEDRECEIVING            = rsNewData.dwBps;
                }

                m_psmEngineData->SMED_BYTESTRANSMITTING         = rsNewData.dwBytesXmited;
                m_psmEngineData->SMED_BYTESRECEIVING            = rsNewData.dwBytesRcved;

                m_psmEngineData->SMED_COMPRESSIONTRANSMITTING   = rsNewData.dwCompressionRatioOut;
                m_psmEngineData->SMED_COMPRESSIONRECEIVING      = rsNewData.dwCompressionRatioIn;

                m_psmEngineData->SMED_ERRORSTRANSMITTING        = 0;
                m_psmEngineData->SMED_ERRORSRECEIVING           = rsNewData.dwCrcErr +
                                                                   rsNewData.dwTimeoutErr +
                                                                   rsNewData.dwAlignmentErr +
                                                                   rsNewData.dwHardwareOverrunErr +
                                                                   rsNewData.dwFramingErr +
                                                                   rsNewData.dwBufferOverrunErr;

                m_psmEngineData->SMED_PACKETSTRANSMITTING       = rsNewData.dwFramesXmited;
                m_psmEngineData->SMED_PACKETSRECEIVING          = rsNewData.dwFramesRcved;

                m_psmEngineData->SMED_INFRASTRUCTURE_MODE = IM_NOT_SUPPORTED;
            }
        }
    }
    else if (m_dwCharacter & NCCF_INCOMING_ONLY)
    {
        // RAS inbound connection
        EnterCriticalSection(&g_csStatmonData);

        if (!m_psmEngineData)
        {
            m_psmEngineData = new STATMON_ENGINEDATA;
            if(m_psmEngineData) 
            {
                ZeroMemory(m_psmEngineData, sizeof(STATMON_ENGINEDATA));
            }
        }

        // Set the status
        //
        if (m_psmEngineData)
        {
            // Set the status to connected by default
            // Unless we get ERROR_INVALID_PARAMETER on any of the function calls below
            //
            m_psmEngineData->SMED_CONNECTIONSTATUS = NCS_CONNECTED;
        }
        else
        {
            hr = E_OUTOFMEMORY;
        }
        LeaveCriticalSection(&g_csStatmonData);

        if (SUCCEEDED(hr) && m_psmEngineData)
        {
            // Get the server handle
            //
            RAS_SERVER_HANDLE hMprAdmin;
            DWORD dwError = MprAdminServerConnect(NULL, &hMprAdmin);

            if (dwError == NO_ERROR)
            {
                // Get connection duration
                //
                RAS_CONNECTION_0 * pConn0;
                dwError = MprAdminConnectionGetInfo(hMprAdmin,
                                                    0,
                                                    m_hRasConn,
                                                    (LPBYTE*)&pConn0);
                if (dwError == NO_ERROR)
                {
                    // duration needs to be in milliseconds
                    m_psmEngineData->SMED_DURATION  = pConn0->dwConnectDuration;

                    MprAdminBufferFree(pConn0);

                    // Get connection speed

                    // Don't pass out speed info for VPN connections (357758)
                    if (NCM_TUNNEL != m_ncmType)
                    {
                        // Enum all the ports and add up the link speed
                        //
                        RAS_PORT_0 * pPort0;
                        DWORD dwPortCount;
                        DWORD dwTotalEntries;
    
                        dwError = MprAdminPortEnum (hMprAdmin,
                                                    0,
                                                    m_hRasConn,
                                                    (LPBYTE*)&pPort0,
                                                    -1,
                                                    &dwPortCount,
                                                    &dwTotalEntries,
                                                    NULL);
                        if (dwError == NOERROR)
                        {
                            RAS_PORT_0 * pCurPort0 = pPort0;
                            DWORD dwConnSpeed=0;
    
                            while (dwPortCount)
                            {
                                RAS_PORT_1 * pCurPort1;
                                dwError = MprAdminPortGetInfo(hMprAdmin,
                                                              1,
                                                              pCurPort0->hPort,
                                                              (LPBYTE*)&pCurPort1);
                                if (dwError == NO_ERROR)
                                {
                                    dwConnSpeed += pCurPort1->dwLineSpeed;
                                }
                                else
                                {
                                    break;
                                }
    
                                MprAdminBufferFree(pCurPort1);
    
                                dwPortCount--;
                                pCurPort0++;
                            }
    
                            MprAdminBufferFree(pPort0);
    
                            if (dwError == NO_ERROR)
                            {
                                // Get the accumulated connection speed
                                m_psmEngineData->SMED_SPEEDTRANSMITTING = dwConnSpeed;
                                m_psmEngineData->SMED_SPEEDRECEIVING    = dwConnSpeed;
                            }
                        }
                    }

                    if (dwError == NO_ERROR)
                    {
                        // Get Transmitted\Received Bytes, Compression and Bytes
                        RAS_CONNECTION_1 * pConn1;
                        dwError = MprAdminConnectionGetInfo(hMprAdmin,
                                                            1,
                                                            m_hRasConn,
                                                            (LPBYTE*)&pConn1);
                        if (dwError == NO_ERROR)
                        {
                            // Update the change flags if asked for
                            //
                            if (pdwChangeFlags)
                            {
                                if (m_psmEngineData->SMED_BYTESTRANSMITTING
                                        != pConn1->dwBytesXmited)
                                {
                                    *pdwChangeFlags |= SMDCF_TRANSMITTING;
                                }

                                if (m_psmEngineData->SMED_BYTESRECEIVING
                                        != pConn1->dwBytesRcved)
                                {
                                    *pdwChangeFlags |= SMDCF_RECEIVING;
                                }
                            }

                            m_psmEngineData->SMED_BYTESTRANSMITTING         = pConn1->dwBytesXmited;
                            m_psmEngineData->SMED_BYTESRECEIVING            = pConn1->dwBytesRcved;

                            m_psmEngineData->SMED_COMPRESSIONTRANSMITTING   = pConn1->dwCompressionRatioOut;
                            m_psmEngineData->SMED_COMPRESSIONRECEIVING      = pConn1->dwCompressionRatioIn;

                            m_psmEngineData->SMED_ERRORSTRANSMITTING        = 0;
                            m_psmEngineData->SMED_ERRORSRECEIVING           = pConn1->dwCrcErr +
                                                                              pConn1->dwTimeoutErr +
                                                                              pConn1->dwAlignmentErr +
                                                                              pConn1->dwHardwareOverrunErr +
                                                                              pConn1->dwFramingErr +
                                                                              pConn1->dwBufferOverrunErr;
                        }

                        MprAdminBufferFree(pConn1);
                    }
                }

                if (dwError != NO_ERROR)
                {
                    *pfNoLongerConnected = TRUE;

                    // set the connection status to "disconnected" so we can close the UI
                    m_psmEngineData->SMED_CONNECTIONSTATUS = NCS_DISCONNECTED;

                    hr = S_OK;
                }
            }
            MprAdminServerDisconnect (hMprAdmin);
        }
    }

    TraceError("CRasStatEngine::HrUpdateData", hr);
    return hr;
}

//////////////////////////////////////////////////////////////////////////////
//                                                                          //
//  CPspRasGen                                                              //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////

CPspRasGen::CPspRasGen(VOID)
{
    m_ncmType = NCM_PHONE;
    m_dwCharacter = NCCF_OUTGOING_ONLY;

    m_adwHelpIDs = NULL;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspRasGen::put_MediaType
//
//  Purpose:    Pass media type of RAS connection type to the RAS engine
//
//  Arguments:  ncmType  - NETCON_MEDIATYPE being set
//              ncsmType - NETCON_SUBMEDIATYPE being set
//
//  Returns:
//
VOID CPspRasGen::put_MediaType(NETCON_MEDIATYPE ncmType, NETCON_SUBMEDIATYPE ncsmType)
{
    m_ncmType  = ncmType;
    m_ncsmType = ncsmType;
}

VOID CPspRasGen::put_Character(DWORD dwCharacter)
{
    m_dwCharacter = dwCharacter;
}

//////////////////////////////////////////////////////////////////////////////
//                                                                          //
//  CPspRasTool                                                             //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////



CPspRasTool::CPspRasTool(VOID)
{
    m_ncmType = NCM_PHONE;
    m_dwCharacter = NCCF_OUTGOING_ONLY;

    m_adwHelpIDs = NULL;
}

VOID CPspRasTool::put_MediaType(NETCON_MEDIATYPE ncmType, NETCON_SUBMEDIATYPE ncsmType)
{
    m_ncmType = ncmType;
    m_ncsmType = ncsmType;
}

VOID CPspRasTool::put_Character(DWORD dwCharacter)
{
    m_dwCharacter = dwCharacter;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspRasTool::HrInitToolPageType
//
//  Purpose:    Gets from the connection any information that is relevant to
//              this particular connection type.
//
//  Arguments:  pncInit -   The connection assocatied with this dialog
//
//  Returns:    Error code
//
HRESULT CPspRasTool::HrInitToolPageType(INetConnection* pncInit)
{
    HRESULT hr  = S_OK;

    TraceError("CPspRasTool::HrInitToolPageType", hr);
    return hr;
}



//+---------------------------------------------------------------------------
//
//  Member:     CPspRasTool::HrAddCommandLineFlags
//
//  Purpose:    Adds the flags for this selection to the command line for the
//              tool being launched.
//
//  Arguments:  pstrFlags - The command line that the flags have to be
//                      appended to
//              psmteSel    - The tool entry associated with this selection
//
//  Returns:    Error code
//
HRESULT CPspRasTool::HrAddCommandLineFlags(tstring* pstrFlags,
        CStatMonToolEntry* psmteSel)
{
    HRESULT hr  = S_OK;

    //
    //  Check what flags are asked for and provide them if we can
    //

    TraceError("CPspRasTool::HrAddCommandLineFlags", hr);
    return hr;
}

HRESULT CPspRasTool::HrGetDeviceType(INetConnection* pncInit)
{
    HRESULT hr = S_OK;

    RASCONN*    aRasConn;
    DWORD       cRasConn;
    hr = HrRasEnumAllActiveConnections (
                    &aRasConn,
                    &cRasConn);

    if (SUCCEEDED(hr))
    {
        for (DWORD i = 0; i < cRasConn; i++)
        {
            if (m_guidId == aRasConn[i].guidEntry)
            {
                // Note: device types in RAS connections are defined
                // as follows in public\sdk\inc ras.h as RASDT_XXX

                m_strDeviceType = aRasConn[i].szDeviceType;
                break;
            }
        }
        MemFree (aRasConn);
    }

    return S_OK;
}

HRESULT CPspRasTool::HrGetComponentList(INetConnection* pncInit)
{
    // Obtain ras handle to this connection
    HRESULT     hr  = S_OK;
    HRASCONN    hRasConn = NULL;

    if (m_dwCharacter & NCCF_OUTGOING_ONLY)
    {
        // for outgoing connection
        INetRasConnection*  pnrcNew     = NULL;

        hr = HrQIAndSetProxyBlanket(pncInit, &pnrcNew);
        if (SUCCEEDED(hr))
        {
            hr = pnrcNew->GetRasConnectionHandle(
                        reinterpret_cast<ULONG_PTR*>(&hRasConn));
            ReleaseObj(pnrcNew);
        }
    }
    else if (m_dwCharacter & NCCF_INCOMING_ONLY)
    {
        // for incoming connection
        INetInboundConnection*  pnicNew;

        hr = HrQIAndSetProxyBlanket(pncInit, &pnicNew);

        if (SUCCEEDED(hr))
        {
            hr = pnicNew->GetServerConnectionHandle(
                    reinterpret_cast<ULONG_PTR*>(&hRasConn));

            ReleaseObj(pnicNew);
        }
    }

    if (SUCCEEDED(hr) && hRasConn)
    {
        // Get protocols list
        DWORD   dwRetCode;
        DWORD   dwSize;

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

        dwSize = sizeof( RasPppIp );

        dwRetCode = RasGetProjectionInfo (hRasConn, RASP_PppIp, &RasPppIp, &dwSize);
        if ((dwRetCode == NO_ERROR) && (NO_ERROR == RasPppIp.dwError))
        {
            m_lstpstrCompIds.push_back(new tstring(L"MS_TCPIP"));
        }

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

        dwSize = sizeof( RasPppIpx );

        dwRetCode = RasGetProjectionInfo (hRasConn, RASP_PppIpx, &RasPppIpx, &dwSize);
        if ((dwRetCode == NO_ERROR)  && (NO_ERROR == RasPppIpx.dwError))
        {
            m_lstpstrCompIds.push_back(new tstring(L"MS_NWIPX"));
        }

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

        dwSize = sizeof( RasPppNbf );

        dwRetCode = RasGetProjectionInfo (hRasConn, RASP_PppNbf, &RasPppNbf, &dwSize);
        if ((dwRetCode == NO_ERROR) && (NO_ERROR == RasPppNbf.dwError))
        {
            m_lstpstrCompIds.push_back(new tstring(L"MS_NetBEUI"));
        }

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

        dwSize = sizeof( RasSlip );

        dwRetCode =  RasGetProjectionInfo (hRasConn, RASP_Slip, &RasSlip, &dwSize);
        if ((dwRetCode == NO_ERROR) && (NO_ERROR == RasSlip.dwError))
        {
            m_lstpstrCompIds.push_back(new tstring(L"MS_TCPIP"));
        }
    }

    // Get client and services
    // $REVIEW(tongl 10/19): checked with Rao, for now we hard code
    // using MSClient and F&P services for all RAS connections
    // (raid #132575)
    m_lstpstrCompIds.push_back(new tstring(L"MS_MSCLIENT"));
    m_lstpstrCompIds.push_back(new tstring(L"MS_SERVER"));

    return S_OK;
}