windows-server-2003/net/mmc/mprsnap/ports.cpp

/**********************************************************************/
/**                       Microsoft Windows/NT                         **/
/**                Copyright(c) Microsoft Corporation, 1997 - 1999                  **/
/**********************************************************************/

/*
    Ports
        Interface node information
        
    FILE HISTORY:
        
*/

#include "stdafx.h"
#include "Ports.h"
#include "ifadmin.h"
#include "rtrstrm.h"        // for RouterAdminConfigStream
#include "rtrlib.h"         // ContainerColumnInfo
#include "coldlg.h"         // ColumnDlg
#include "column.h"     // ComponentConfigStream
#include "refresh.h"        // IRouterRefresh
#include "iface.h"        // for interfacenode data
#include "portdlg.h"        // CConnDlg - connection dialog
#include "msgdlg.h"         // CMessageDlg
#include "raserror.h"
#include "dmvcomp.h"
#include "remras.h"
#include "rrasutil.h"        // Smart pointers
#include "rtrcomn.h"        // CoCreateRouterConfig
#include "rtrutilp.h"        // PortsDeviceTypeToCString

static BOOL RestartComputer(LPTSTR szMachineName);

//$PPTP
// This is the maximum number of ports that we allow for PPTP.
// Thus we can raise the maximum to this value only.
// --------------------------------------------------------------------

#define PPTP_MAX_PORTS      16384

//$L2TP
// This is the maximum number of ports that we allow for L2TP.
// Thus we can raise the maximum to this value only.
// --------------------------------------------------------------------

#define L2TP_MAX_PORTS      30000



/*---------------------------------------------------------------------------
    Defaults
 ---------------------------------------------------------------------------*/


PortsNodeData::PortsNodeData()
{
#ifdef DEBUG
    StrCpyA(m_szDebug, "PortsNodeData");
#endif
}

PortsNodeData::~PortsNodeData()
{
}

/*!--------------------------------------------------------------------------
    PortsNodeData::InitAdminNodeData
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsNodeData::InitAdminNodeData(ITFSNode *pNode,
                                         RouterAdminConfigStream *pConfigStream)
{
    HRESULT             hr = hrOK;
    PortsNodeData * pData = NULL;
    
    pData = new PortsNodeData;

    SET_PORTSNODEDATA(pNode, pData);

    // Need to connect to the router to get this data
    
    return hr;
}

/*!--------------------------------------------------------------------------
    PortsNodeData::FreeAdminNodeData
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsNodeData::FreeAdminNodeData(ITFSNode *pNode)
{    
    PortsNodeData * pData = GET_PORTSNODEDATA(pNode);
    delete pData;
    SET_PORTSNODEDATA(pNode, NULL);
    
    return hrOK;
}


HRESULT PortsNodeData::LoadHandle(LPCTSTR pszMachineName)
{
    m_stMachineName = pszMachineName;
    return HResultFromWin32(::MprAdminServerConnect((LPTSTR) pszMachineName,
        &m_sphDdmHandle));
    
}

HANDLE PortsNodeData::GetHandle()
{
    if (!m_sphDdmHandle)
    {
        LoadHandle(m_stMachineName);
    }
    return m_sphDdmHandle;
}

void PortsNodeData::ReleaseHandles()
{
    m_sphDdmHandle.Release();
}


STDMETHODIMP PortsNodeHandler::QueryInterface(REFIID riid, LPVOID *ppv)
{
    // Is the pointer bad?
    if (ppv == NULL)
        return E_INVALIDARG;

    //    Place NULL in *ppv in case of failure
    *ppv = NULL;

    //    This is the non-delegating IUnknown implementation
    if (riid == IID_IUnknown)
        *ppv = (LPVOID) this;
    else if (riid == IID_IRtrAdviseSink)
        *ppv = &m_IRtrAdviseSink;
    else
        return CHandler::QueryInterface(riid, ppv);

    //    If we're going to return an interface, AddRef it first
    if (*ppv)
    {
    ((LPUNKNOWN) *ppv)->AddRef();
        return hrOK;
    }
    else
        return E_NOINTERFACE;    
}


/*---------------------------------------------------------------------------
    NodeHandler implementation
 ---------------------------------------------------------------------------*/

extern const ContainerColumnInfo    s_rgPortsColumnInfo[];

const ContainerColumnInfo s_rgPortsColumnInfo[] =
{
    { IDS_PORTS_COL_NAME,        CON_SORT_BY_STRING, TRUE , COL_IF_NAME},
    { IDS_PORTS_COL_DEVICE,     CON_SORT_BY_STRING, TRUE , COL_STRING},
    { IDS_PORTS_COL_USAGE,         CON_SORT_BY_STRING, TRUE , COL_STRING},
    { IDS_PORTS_COL_STATUS,     CON_SORT_BY_STRING, TRUE , COL_STATUS},
    { IDS_PORTS_COL_COMMENT,    CON_SORT_BY_STRING, FALSE , COL_STRING},
};
                                            
#define NUM_FOLDERS 1

PortsNodeHandler::PortsNodeHandler(ITFSComponentData *pCompData)
    : BaseContainerHandler(pCompData, DM_COLUMNS_PORTS, s_rgPortsColumnInfo),
    m_bExpanded(FALSE),
    m_pConfigStream(NULL),
    m_ulConnId(0),
    m_ulRefreshConnId(0),
    m_dwActivePorts(0)
{

    m_rgButtonState[MMC_VERB_PROPERTIES_INDEX] = ENABLED;
    m_bState[MMC_VERB_PROPERTIES_INDEX] = TRUE;

    // Setup the verb states for this node
    m_rgButtonState[MMC_VERB_REFRESH_INDEX] = ENABLED;
    m_bState[MMC_VERB_REFRESH_INDEX] = TRUE;
}

/*!--------------------------------------------------------------------------
    PortsNodeHandler::Init
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsNodeHandler::Init(IRouterInfo *pRouterInfo,
                               RouterAdminConfigStream *pConfigStream)
{
    HRESULT hr = hrOK;

    // If we don't have a router info then we probably failed to load
    // or failed to connect.  Bail out of this.
    if (!pRouterInfo)
        CORg( E_FAIL );
    
    m_spRouterInfo.Set(pRouterInfo);

    // Also need to register for change notifications
    m_spRouterInfo->RtrAdvise(&m_IRtrAdviseSink, &m_ulConnId, 0);

    m_pConfigStream = pConfigStream;

Error:
    return hrOK;
}

/*!--------------------------------------------------------------------------
    PortsNodeHandler::DestroyHandler
        Implementation of ITFSNodeHandler::DestroyHandler
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP PortsNodeHandler::DestroyHandler(ITFSNode *pNode)
{
    PortsNodeData::FreeAdminNodeData(pNode);

    m_spDataObject.Release();
    
    if (m_ulRefreshConnId)
    {
        SPIRouterRefresh    spRefresh;
        if (m_spRouterInfo)
            m_spRouterInfo->GetRefreshObject(&spRefresh);
        if (spRefresh)
            spRefresh->UnadviseRefresh(m_ulRefreshConnId);
    }
    m_ulRefreshConnId = 0;
    
    if (m_spRouterInfo)
    {
        m_spRouterInfo->RtrUnadvise(m_ulConnId);
        m_spRouterInfo.Release();
    }
    return hrOK;
}

/*!--------------------------------------------------------------------------
    PortsNodeHandler::HasPropertyPages
        Implementation of ITFSNodeHandler::HasPropertyPages
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
PortsNodeHandler::HasPropertyPages
(
    ITFSNode *            pNode,
    LPDATAOBJECT        pDataObject, 
    DATA_OBJECT_TYPES    type, 
    DWORD                dwType
)
{
    // Yes, we do have property pages
    return hrOK;
}

/*!--------------------------------------------------------------------------
    PortsNodeHandler::CreatePropertyPages
        Implementation of ITFSNodeHandler::CreatePropertyPages
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP PortsNodeHandler::CreatePropertyPages(
    ITFSNode *                pNode,
    LPPROPERTYSHEETCALLBACK lpProvider,
    LPDATAOBJECT            pDataObject, 
    LONG_PTR                handle, 
    DWORD                    dwType
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    HRESULT     hr = hrOK;

    PortsProperties*    pPropSheet = NULL;
    SPIComponentData spComponentData;
    CString     stTitle;

    CORg( m_spNodeMgr->GetComponentData(&spComponentData) );

    pPropSheet = new PortsProperties(pNode, spComponentData,
                                     m_spTFSCompData, stTitle,
                                     NULL, 0, TRUE
                                    );

    if ( FHrFailed(pPropSheet->Init(m_spRouterInfo, this)) ) 
    {
        AfxMessageBox(IDS_ERR_NO_ROUTERPROTOCOLS);
        delete pPropSheet;
        return hr;
    }

    if (lpProvider)
        hr = pPropSheet->CreateModelessSheet(lpProvider, handle);
    else
        hr = pPropSheet->DoModelessSheet();

Error:
    return hr;
}




/*---------------------------------------------------------------------------
    Menu data structure for our menus
 ---------------------------------------------------------------------------*/

struct SPortsNodeMenu
{
    ULONG    m_sidMenu;            // string/command id for this menu item
    ULONG    (PortsNodeHandler:: *m_pfnGetMenuFlags)(PortsNodeHandler::SMenuData *);
    ULONG    m_ulPosition;
};

//static const SPortsNodeMenu    s_rgPortsNodeMenu[] =
//{
//    // Add items that are primary go here
//    // Add items that go on the "Create new" menu here
//    // Add items that go on the "Task" menu here
//};

/*!--------------------------------------------------------------------------
    PortsNodeHandler::OnAddMenuItems
        Implementation of ITFSNodeHandler::OnAddMenuItems
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP PortsNodeHandler::OnAddMenuItems(
                                                ITFSNode *pNode,
                                                LPCONTEXTMENUCALLBACK pContextMenuCallback, 
                                                LPDATAOBJECT lpDataObject, 
                                                DATA_OBJECT_TYPES type, 
                                                DWORD dwType,
                                                long *pInsertionAllowed)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    
    HRESULT hr = S_OK;
    
    COM_PROTECT_TRY
    {
        // Uncomment if you have items to add
//        hr = AddArrayOfMenuItems(pNode, s_rgPortsNodeMenu,
//                                 DimensionOf(s_rgPortsNodeMenu),
//                                 pContextMenuCallback,
//                                 *pInsertionAllowed);
    }
    COM_PROTECT_CATCH;
        
    return hr; 
}

/*!--------------------------------------------------------------------------
    PortsNodeHandler::GetString
        Implementation of ITFSNodeHandler::GetString
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCTSTR) PortsNodeHandler::GetString(ITFSNode *pNode, int nCol)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    HRESULT hr = hrOK;

    COM_PROTECT_TRY
    {
        if (m_stTitle.IsEmpty())
            m_stTitle.LoadString(IDS_PORTS);
    }
    COM_PROTECT_CATCH;

    return m_stTitle;
}


/*!--------------------------------------------------------------------------
    PortsNodeHandler::OnCreateDataObject
        Implementation of ITFSNodeHandler::OnCreateDataObject
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP PortsNodeHandler::OnCreateDataObject(MMC_COOKIE cookie,
    DATA_OBJECT_TYPES type,
    IDataObject **ppDataObject)
{
    HRESULT hr = hrOK;
    
    COM_PROTECT_TRY
    {
        if (!m_spDataObject)
        {
            CORg( CreateDataObjectFromRouterInfo(m_spRouterInfo,
                m_spRouterInfo->GetMachineName(),
                type, cookie, m_spTFSCompData,
                &m_spDataObject, NULL, FALSE) );
            Assert(m_spDataObject);
        }
        
        *ppDataObject = m_spDataObject;
        (*ppDataObject)->AddRef();
            
        COM_PROTECT_ERROR_LABEL;
    }
    COM_PROTECT_CATCH;
    return hr;
}

/*!--------------------------------------------------------------------------
    PortsNodeHandler::OnExpand
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsNodeHandler::OnExpand(ITFSNode *pNode,
                                   LPDATAOBJECT pDataObject,
                                   DWORD dwType,
                                   LPARAM arg,
                                   LPARAM lParam)
{
    HRESULT                 hr = hrOK;

    // If we don't have a router object, then we don't have any info, don't
    // try to expand.
    if (!m_spRouterInfo)
        return hrOK;
    
    if (m_bExpanded)
        return hrOK;

    COM_PROTECT_TRY
    {
        SynchronizeNodeData(pNode);

        m_bExpanded = TRUE;

    }
    COM_PROTECT_CATCH;

    return hr;
}


/*!--------------------------------------------------------------------------
    PortsNodeHandler::OnResultShow
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsNodeHandler::OnResultShow(ITFSComponent *pTFSComponent,
                                       MMC_COOKIE cookie,
                                       LPARAM arg,
                                       LPARAM lParam)
{
    BOOL    bSelect = (BOOL) arg;
    HRESULT hr = hrOK;
    SPIRouterRefresh    spRefresh;
    SPITFSNode    spNode;

    BaseContainerHandler::OnResultShow(pTFSComponent, cookie, arg, lParam);

    if (bSelect)
    {
        // Call synchronize on this node
        m_spNodeMgr->FindNode(cookie, &spNode);
        if (spNode)
            SynchronizeNodeData(spNode);
    }

    // Un/Register for refresh advises
    if (m_spRouterInfo)
        m_spRouterInfo->GetRefreshObject(&spRefresh);

    if (spRefresh)
    {
        if (bSelect)
        {
            if (m_ulRefreshConnId == 0)
                spRefresh->AdviseRefresh(&m_IRtrAdviseSink, &m_ulRefreshConnId, 0);
        }
        else
        {
            if (m_ulRefreshConnId)
                spRefresh->UnadviseRefresh(m_ulRefreshConnId);
            m_ulRefreshConnId = 0;
        }
    }
    
    return hr;
}


/*!--------------------------------------------------------------------------
    PortsNodeHandler::ConstructNode
        Initializes the Domain node (sets it up).
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsNodeHandler::ConstructNode(ITFSNode *pNode)
{
    HRESULT         hr = hrOK;
    PortsNodeData * pNodeData;
    
    if (pNode == NULL)
        return hrOK;

    COM_PROTECT_TRY
    {
        // Need to initialize the data for the Domain node
        pNode->SetData(TFS_DATA_IMAGEINDEX, IMAGE_IDX_INTERFACES);
        pNode->SetData(TFS_DATA_OPENIMAGEINDEX, IMAGE_IDX_INTERFACES);
        pNode->SetData(TFS_DATA_SCOPEID, 0);

        // This is a leaf node in the scope pane
        pNode->SetData(TFS_DATA_SCOPE_LEAF_NODE, TRUE);

        m_cookie = reinterpret_cast<LONG_PTR>(pNode);
        pNode->SetData(TFS_DATA_COOKIE, m_cookie);

        pNode->SetNodeType(&GUID_RouterPortsNodeType);
        
        PortsNodeData::InitAdminNodeData(pNode, m_pConfigStream);

        pNodeData = GET_PORTSNODEDATA(pNode);
        Assert(pNodeData);
        //if there is any handle open, release it first
        pNodeData->ReleaseHandles();
        // Ignore the error, we should be able to deal with the
        // case of a stopped router.
        pNodeData->LoadHandle(m_spRouterInfo->GetMachineName());
    }
    COM_PROTECT_CATCH

    return hr;
}


/*!--------------------------------------------------------------------------
    PortsNodeHandler::SynchronizeNodeData
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsNodeHandler::SynchronizeNodeData(ITFSNode *pThisNode)
{
    Assert(pThisNode);
    
    SPITFSNodeEnum    spEnum;
    int             i;
    
    HRESULT hr = hrOK;
    InterfaceNodeData    *pData;
    DWORD                dwErr;
    PortsNodeData * pNodeData;
    PortsList            portsList;
    PortsList            newPortsList;
    PortsListEntry *    pPorts;
    BOOL                fFound;
    POSITION            pos;
    SPITFSNode            spChildNode;
    InterfaceNodeData * pChildData;

    DWORD               dwOldGdiBatchLimit;

    dwOldGdiBatchLimit = GdiGetBatchLimit();
    GdiSetBatchLimit(100);

    COM_PROTECT_TRY
    {

        // Get the status data from the running router
        pNodeData = GET_PORTSNODEDATA(pThisNode);
        // Ignore the error, we should be able to deal with the
        // case of a stopped router.
        if(pNodeData)
        {
            pNodeData->ReleaseHandles();
            pNodeData->LoadHandle(m_spRouterInfo->GetMachineName());
        }

        if (pNodeData == NULL || INVALID_HANDLE_VALUE == pNodeData->GetHandle())
        {
            // Remove all of the nodes, we can't connect so we can't
            // get any running data.
            UnmarkAllNodes(pThisNode, spEnum);
            RemoveAllUnmarkedNodes(pThisNode, spEnum);
            return hrOK;
        }
        
        // Unmark all of the nodes    
        pThisNode->GetEnum(&spEnum);
        UnmarkAllNodes(pThisNode, spEnum);
        
        // Go out and grab the data, merge the the new data in with
        // the old data.
        if( S_OK == GenerateListOfPorts(pThisNode, &portsList) )
        {
        
            pos = portsList.GetHeadPosition();

            // clear active ports count -- for bug 165862
            m_dwActivePorts = 0;
        
            while (pos)
            {
                pPorts = & portsList.GetNext(pos);
            
                // Look for this entry in our current list of nodes
                spEnum->Reset();
                spChildNode.Release();
            
                fFound = FALSE;
            
                for (;spEnum->Next(1, &spChildNode, NULL) == hrOK; spChildNode.Release())
                {
                    pChildData = GET_INTERFACENODEDATA(spChildNode);
                    Assert(pChildData);

                    if (pChildData->m_rgData[PORTS_SI_PORT].m_ulData ==
                        (LONG_PTR) pPorts->m_rp0.hPort)
                    {
                        // Ok, this user already exists, update the metric
                        // and mark it
                        Assert(pChildData->dwMark == FALSE);
                        pChildData->dwMark = TRUE;
                    
                        fFound = TRUE;
                    
                        SetUserData(spChildNode, *pPorts);
                    
                        // Force MMC to redraw the node
                        spChildNode->ChangeNode(RESULT_PANE_CHANGE_ITEM_DATA);
                        break;
                    }
                }
            
                if (!fFound)
                    newPortsList.AddTail(*pPorts);
            
            }
        }

        // Remove all nodes that were not marked
        RemoveAllUnmarkedNodes(pThisNode, spEnum);

        // Now iterate through the list of new users, adding them all in.

        pos = newPortsList.GetHeadPosition();
        while (pos)
        {
            pPorts = & newPortsList.GetNext(pos);

            AddPortsUserNode(pThisNode, *pPorts);
        }
    }
    COM_PROTECT_CATCH;

    GdiFlush();
    GdiSetBatchLimit(dwOldGdiBatchLimit);
        
    return hr;
}

/*!--------------------------------------------------------------------------
    PortsNodeHandler::SetUserData
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsNodeHandler::SetUserData(ITFSNode *pNode,
                                      const PortsListEntry& entry)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    HRESULT     hr = hrOK;
    InterfaceNodeData * pData;
    TCHAR        szNumber[32];
    CString     st;
    int         ids;

    pData = GET_INTERFACENODEDATA(pNode);
    Assert(pData);

    st.Format(IDS_PORTS_NAME_FORMAT, entry.m_rp0.wszDeviceName,
              entry.m_rp0.wszPortName);
    pData->m_rgData[PORTS_SI_NAME].m_stData = st;
    pData->m_rgData[PORTS_SI_DEVICE].m_stData = entry.m_rp0.wszDeviceType;

    if (entry.m_fActiveDialOut)
    {
        ids = IDS_PORTS_DIALOUT_ACTIVE;
    }
    else if (entry.m_rp0.dwPortCondition == RAS_PORT_AUTHENTICATED)
    {
        ids = IDS_PORTS_ACTIVE;
        // to know how many active ports: BUG -- 165862
        // to prepare total number of active ports -- Wei Jiang
        m_dwActivePorts++;
    }
    else
    {
        ids = IDS_PORTS_INACTIVE;
    }
    pData->m_rgData[PORTS_SI_STATUS].m_stData.LoadString(ids);
    pData->m_rgData[PORTS_SI_STATUS].m_dwData = entry.m_rp0.dwPortCondition;

    pData->m_rgData[PORTS_SI_PORT].m_ulData = (LONG_PTR) entry.m_rp0.hPort;

    // fix b: 32887 --  show ras/routing enabled information
    // Column 0...Usage
    INT iType = (entry.m_dwEnableRas * 2) + 
                entry.m_dwEnableRouting | 
                entry.m_dwEnableOutboundRouting;
    pData->m_rgData[PORTS_SI_USAGE].m_stData = PortsDeviceTypeToCString(iType);



    // Update the PortsListEntry
    * (PortsListEntry *)pData->lParamPrivate = entry;
    
    // For status, need to check to see if there are any connections
    // on this port.

    return hr;
}

/*!--------------------------------------------------------------------------
    PortsNodeHandler::GenerateListOfPorts
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsNodeHandler::GenerateListOfPorts(ITFSNode *pNode, PortsList *pList)
{
    HRESULT         hr = hrOK;
    PortsListEntry    entry;
    PortsNodeData * pPortsData;
    DWORD            dwTotal;
    DWORD            i;
    RAS_PORT_0 *    rp0Table;
    DWORD            rp0Count;
    SPMprAdminBuffer    spMpr;
    HANDLE          hRasHandle = INVALID_HANDLE_VALUE;
    DWORD           dwSize, dwEntries;
    DWORD           dwErr;
    LPBYTE          pbPorts = NULL;
    POSITION        pos;
    POSITION        posPort;
    RasmanPortMap   portMap;
    
    // fix b: 3288 --
    PortsDeviceList    portsDeviceList;
    PortsDataEntry    portsDataEntry;
    

    pPortsData = GET_PORTSNODEDATA(pNode);
    Assert(pPortsData);

    // If we are connected, enumerate through the list of
    // ports
    CWRg( ::MprAdminPortEnum( pPortsData->GetHandle(),
                              0,
                              INVALID_HANDLE_VALUE,
                              (BYTE **) &rp0Table,
                              (DWORD) -1,
                              &rp0Count,
                              &dwTotal,
                              NULL) );

    Assert(rp0Table);
                                  
    spMpr = (LPBYTE) rp0Table;

    // Add a new PortsListEntry for each port

    // fix b: 32887 --  show ras/routing enabled information
    // use PortsDataEntry to load the device information to be use later for each ports
    // to get if a port is enabled for ras / routing
    hr = portsDataEntry.Initialize(m_spRouterInfo->GetMachineName());

    if (hr == S_OK)
    {
        hr = portsDataEntry.LoadDevices(&portsDeviceList);
    }
    
    
    for (i=0; i<rp0Count; i++)
    {
        ::ZeroMemory(&entry, sizeof(entry));
        entry.m_rp0 = rp0Table[i];

	//Get the unicode name from the port handle
	//RasGetUnicodeDeviceName(entry.m_rp0.hPort, entry.m_rp0.wszDeviceName);
        
        entry.m_fActiveDialOut = FALSE;

        // find out if ras / routing is enabled on the port
        entry.m_dwEnableRas = 0;                // = 1 if RAS is enabled on this device
        entry.m_dwEnableRouting = 0;            // = 1 if Routing is enabled on this device
        entry.m_dwEnableOutboundRouting = 0;    // = 1 if outbound 
                                                //  routing is enabled 
                                                //  on this device

        POSITION    pos;
        pos = portsDeviceList.GetHeadPosition();

        while(pos != NULL)
        {
            PortsDeviceEntry *    pPortEntry = portsDeviceList.GetNext(pos);

            CString strPortName = entry.m_rp0.wszDeviceName;

            if(strPortName == pPortEntry->m_stDisplayName)
            {
                entry.m_dwEnableRas  = pPortEntry->m_dwEnableRas;
                entry.m_dwEnableRouting = pPortEntry->m_dwEnableRouting;
                entry.m_dwEnableOutboundRouting = 
                    pPortEntry->m_dwEnableOutboundRouting;
                break;
            }
        }

        pList->AddTail(entry);
    }

    spMpr.Free();

Error:
    delete [] pbPorts;
    if (hRasHandle != INVALID_HANDLE_VALUE)
        RasRpcDisconnectServer(hRasHandle);
    return hr;
}


ImplementEmbeddedUnknown(PortsNodeHandler, IRtrAdviseSink)

STDMETHODIMP PortsNodeHandler::EIRtrAdviseSink::OnChange(LONG_PTR ulConn,
    DWORD dwChangeType, DWORD dwObjectType, LPARAM lUserParam, LPARAM lParam)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    InitPThis(PortsNodeHandler, IRtrAdviseSink);
    SPITFSNode                spThisNode;
    HRESULT hr = hrOK;

    COM_PROTECT_TRY
    {

        pThis->m_spNodeMgr->FindNode(pThis->m_cookie, &spThisNode);
    
        if (dwChangeType == ROUTER_REFRESH)
        {
            // Ok, just call the synchronize on this node
            pThis->SynchronizeNodeData(spThisNode);
        }
        else if (dwChangeType == ROUTER_DO_DISCONNECT)
        {
            PortsNodeData * pData = GET_PORTSNODEDATA(spThisNode);
            Assert(pData);

            // Release the handle
            pData->ReleaseHandles();
            
        }
    }
    COM_PROTECT_CATCH;
    
    return hr;
}

/*!--------------------------------------------------------------------------
    PortsNodeHandler::CompareItems
        Implementation of ITFSResultHandler::CompareItems
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(int) PortsNodeHandler::CompareItems(
                                ITFSComponent * pComponent,
                                MMC_COOKIE cookieA,
                                MMC_COOKIE cookieB,
                                int nCol)
{
    // Get the strings from the nodes and use that as a basis for
    // comparison.
    SPITFSNode    spNode;
    SPITFSResultHandler spResult;

    m_spNodeMgr->FindNode(cookieA, &spNode);
    spNode->GetResultHandler(&spResult);
    return spResult->CompareItems(pComponent, cookieA, cookieB, nCol);
}


/*!--------------------------------------------------------------------------
    PortsNodeHandler::AddPortsUserNode
        Adds a user to the UI.    This will create a new result item
        node for each interface.
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsNodeHandler::AddPortsUserNode(ITFSNode *pParent, const PortsListEntry& PortsEntry)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    PortsUserHandler *    pHandler;
    SPITFSResultHandler     spHandler;
    SPITFSNode                spNode;
    HRESULT                 hr = hrOK;

    pHandler = new PortsUserHandler(m_spTFSCompData);
    spHandler = pHandler;
    CORg( pHandler->Init(m_spRouterInfo, pParent) );
    
    CORg( CreateLeafTFSNode(&spNode,
                            NULL,
                            static_cast<ITFSNodeHandler *>(pHandler),
                            static_cast<ITFSResultHandler *>(pHandler),
                            m_spNodeMgr) );
    CORg( pHandler->ConstructNode(spNode, NULL, &PortsEntry) );

    SetUserData(spNode, PortsEntry);
    
    // Make the node immediately visible
    CORg( spNode->SetVisibilityState(TFS_VIS_SHOW) );
    CORg( pParent->AddChild(spNode) );
Error:
    return hr;
}

/*!--------------------------------------------------------------------------
    PortsNodeHandler::UnmarkAllNodes
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsNodeHandler::UnmarkAllNodes(ITFSNode *pNode, ITFSNodeEnum *pEnum)
{
    SPITFSNode    spChildNode;
    InterfaceNodeData * pNodeData;
    
    pEnum->Reset();
    for ( ;pEnum->Next(1, &spChildNode, NULL) == hrOK; spChildNode.Release())
    {
        pNodeData = GET_INTERFACENODEDATA(spChildNode);
        Assert(pNodeData);
        
        pNodeData->dwMark = FALSE;            
    }
    return hrOK;
}

/*!--------------------------------------------------------------------------
    PortsNodeHandler::RemoveAllUnmarkedNodes
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsNodeHandler::RemoveAllUnmarkedNodes(ITFSNode *pNode, ITFSNodeEnum *pEnum)
{
    HRESULT     hr = hrOK;
    SPITFSNode    spChildNode;
    InterfaceNodeData * pNodeData;
    
    pEnum->Reset();
    for ( ;pEnum->Next(1, &spChildNode, NULL) == hrOK; spChildNode.Release())
    {
        pNodeData = GET_INTERFACENODEDATA(spChildNode);
        Assert(pNodeData);
        
        if (pNodeData->dwMark == FALSE)
        {
            pNode->RemoveChild(spChildNode);
            spChildNode->Destroy();
        }
    }

    return hr;
}



/*---------------------------------------------------------------------------
    PortsUserHandler implementation
 ---------------------------------------------------------------------------*/

DEBUG_DECLARE_INSTANCE_COUNTER(PortsUserHandler)

IMPLEMENT_ADDREF_RELEASE(PortsUserHandler)

STDMETHODIMP PortsUserHandler::QueryInterface(REFIID riid, LPVOID *ppv)
{
    // Is the pointer bad?
    if (ppv == NULL)
        return E_INVALIDARG;

    //    Place NULL in *ppv in case of failure
    *ppv = NULL;

    //    This is the non-delegating IUnknown implementation
    if (riid == IID_IUnknown)
        *ppv = (LPVOID) this;
    else if (riid == IID_IRtrAdviseSink)
        *ppv = &m_IRtrAdviseSink;
    else
        return CBaseResultHandler::QueryInterface(riid, ppv);

    //    If we're going to return an interface, AddRef it first
    if (*ppv)
    {
    ((LPUNKNOWN) *ppv)->AddRef();
        return hrOK;
    }
    else
        return E_NOINTERFACE;    
}


/*---------------------------------------------------------------------------
    NodeHandler implementation
 ---------------------------------------------------------------------------*/


PortsUserHandler::PortsUserHandler(ITFSComponentData *pCompData)
            : BaseRouterHandler(pCompData),
            m_ulConnId(0)
{
    DEBUG_INCREMENT_INSTANCE_COUNTER(PortsUserHandler);

    // Enable Refresh from the node itself
    // ----------------------------------------------------------------
    m_rgButtonState[MMC_VERB_REFRESH_INDEX] = ENABLED;
    m_bState[MMC_VERB_REFRESH_INDEX] = TRUE;
}


/*!--------------------------------------------------------------------------
    PortsUserHandler::Init
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsUserHandler::Init(IRouterInfo *pInfo, ITFSNode *pParent)
{
    m_spRouterInfo.Set(pInfo);
    return hrOK;
}


/*!--------------------------------------------------------------------------
    PortsUserHandler::DestroyResultHandler
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP PortsUserHandler::DestroyResultHandler(MMC_COOKIE cookie)
{
    SPITFSNode    spNode;
    
    m_spNodeMgr->FindNode(cookie, &spNode);
    InterfaceNodeData::Free(spNode);
    
    CHandler::DestroyResultHandler(cookie);
    return hrOK;
}


static DWORD    s_rgInterfaceImageMap[] =
     {
     ROUTER_IF_TYPE_HOME_ROUTER,    IMAGE_IDX_WAN_CARD,
     ROUTER_IF_TYPE_FULL_ROUTER,    IMAGE_IDX_WAN_CARD,
     ROUTER_IF_TYPE_CLIENT,         IMAGE_IDX_WAN_CARD,
     ROUTER_IF_TYPE_DEDICATED,        IMAGE_IDX_LAN_CARD,
     ROUTER_IF_TYPE_INTERNAL,        IMAGE_IDX_LAN_CARD,
     ROUTER_IF_TYPE_LOOPBACK,        IMAGE_IDX_LAN_CARD,
     -1,                            IMAGE_IDX_WAN_CARD, // sentinel value
     };

/*!--------------------------------------------------------------------------
    PortsUserHandler::ConstructNode
        Initializes the Domain node (sets it up).
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsUserHandler::ConstructNode(ITFSNode *pNode,
                                         IInterfaceInfo *pIfInfo,
                                         const PortsListEntry *pEntry)
{
    HRESULT         hr = hrOK;
    int             i;
    InterfaceNodeData * pData;

    Assert(pEntry);
    
    if (pNode == NULL)
        return hrOK;

    COM_PROTECT_TRY
    {
        // Need to initialize the data for the Domain node

        pNode->SetData(TFS_DATA_IMAGEINDEX, IMAGE_IDX_WAN_CARD);
        pNode->SetData(TFS_DATA_OPENIMAGEINDEX, IMAGE_IDX_WAN_CARD);
        
        pNode->SetData(TFS_DATA_SCOPEID, 0);

        pNode->SetData(TFS_DATA_COOKIE, reinterpret_cast<LONG_PTR>(pNode));

        //$ Review: kennt, what are the different type of interfaces
        // do we distinguish based on the same list as above? (i.e. the
        // one for image indexes).
        pNode->SetNodeType(&GUID_RouterPortsResultNodeType);

        m_entry = *pEntry;

        InterfaceNodeData::Init(pNode, pIfInfo);

        // We need to save this pointer so that it can be modified
        // (and updated) at a later time.
        // ------------------------------------------------------------
        pData = GET_INTERFACENODEDATA(pNode);
        pData->lParamPrivate = (LPARAM) &m_entry;
    }
    COM_PROTECT_CATCH
    return hr;
}

/*!--------------------------------------------------------------------------
    PortsUserHandler::GetString
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCTSTR) PortsUserHandler::GetString(ITFSComponent * pComponent,
    MMC_COOKIE cookie,
    int nCol)
{
    Assert(m_spNodeMgr);
    
    SPITFSNode        spNode;
    InterfaceNodeData * pData;
    ConfigStream *    pConfig;

    m_spNodeMgr->FindNode(cookie, &spNode);
    Assert(spNode);

    pData = GET_INTERFACENODEDATA(spNode);
    Assert(pData);

    pComponent->GetUserData((LONG_PTR *) &pConfig);
    Assert(pConfig);

    return pData->m_rgData[pConfig->MapColumnToSubitem(DM_COLUMNS_PORTS, nCol)].m_stData;
}

/*!--------------------------------------------------------------------------
    PortsUserHandler::CompareItems
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(int) PortsUserHandler::CompareItems(ITFSComponent * pComponent,
    MMC_COOKIE cookieA,
    MMC_COOKIE cookieB,
    int nCol)
{
    return StriCmpW(GetString(pComponent, cookieA, nCol),
                    GetString(pComponent, cookieB, nCol));
}

static const SRouterNodeMenu s_rgIfNodeMenu[] =
{
    { IDS_MENU_PORTS_STATUS, 0,
        CCM_INSERTIONPOINTID_PRIMARY_TOP},
    
    { IDS_MENU_PORTS_DISCONNECT, PortsUserHandler::GetDisconnectMenuState,
        CCM_INSERTIONPOINTID_PRIMARY_TOP},
};

ULONG PortsUserHandler::GetDisconnectMenuState(const SRouterNodeMenu *pMenuData,
                                               INT_PTR pUserData)
{
    InterfaceNodeData * pNodeData;
    SMenuData * pData = reinterpret_cast<SMenuData *>(pUserData);
    
    pNodeData = GET_INTERFACENODEDATA(pData->m_spNode);
    Assert(pNodeData);

    if (pNodeData->m_rgData[PORTS_SI_STATUS].m_dwData == RAS_PORT_AUTHENTICATED)
        return 0;
    else
        return MF_GRAYED;
}

/*!--------------------------------------------------------------------------
    PortsUserHandler::AddMenuItems
        Implementation of ITFSResultHandler::OnAddMenuItems
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP PortsUserHandler::AddMenuItems(ITFSComponent *pComponent,
                                                MMC_COOKIE cookie,
                                                LPDATAOBJECT lpDataObject, 
                                                LPCONTEXTMENUCALLBACK pContextMenuCallback,
    long *pInsertionAllowed)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    
    HRESULT hr = S_OK;
    SPITFSNode    spNode;
    PortsUserHandler::SMenuData menuData;

    // We don't allow any actions on active dialout connections
    // ------------------------------------------------------------
    if (m_entry.m_fActiveDialOut)
        return hrOK;
    
    COM_PROTECT_TRY
    {
        m_spNodeMgr->FindNode(cookie, &spNode);

        // Now go through and add our menu items
        menuData.m_spNode.Set(spNode);
        
        hr = AddArrayOfMenuItems(spNode, s_rgIfNodeMenu,
                                 DimensionOf(s_rgIfNodeMenu),
                                 pContextMenuCallback,
                                 *pInsertionAllowed,
                                 reinterpret_cast<INT_PTR>(&menuData));
    }
    COM_PROTECT_CATCH;
        
    return hr; 
}

/*!--------------------------------------------------------------------------
    PortsUserHandler::Command
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP PortsUserHandler::Command(ITFSComponent *pComponent,
                                           MMC_COOKIE cookie,
                                           int nCommandId,
                                           LPDATAOBJECT pDataObject)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    SPITFSNode    spNode;
    SPITFSNode    spNodeParent;
    SPITFSNodeHandler    spParentHandler;
    PortsNodeData * pData;
    HRESULT hr = S_OK;

    COM_PROTECT_TRY
    {
        switch (nCommandId)
        {
            case IDS_MENU_PORTS_STATUS:
                {
                    BOOL    fRefresh = FALSE;
                    DWORD   dwInterval = 60;                    
                    SPIRouterRefresh    spRefresh;
                    
                    if (m_spRouterInfo)
                        m_spRouterInfo->GetRefreshObject(&spRefresh);
                    
                    // Stop the auto refresh (if it is turned on)
                    // ------------------------------------------------
                    if (spRefresh && FHrOK(spRefresh->IsRefreshStarted()))
                    {
                        fRefresh = TRUE;
                        spRefresh->GetRefreshInterval(&dwInterval);
                        spRefresh->Stop();
                    }
                    
                    // NOTE: This function gets called from other places
                    // in the code (for which pDataObject==NULL)
                    
                    // Get the hServer and hPort
                    m_spNodeMgr->FindNode(cookie, &spNode);
                    spNode->GetParent(&spNodeParent);

                    pData = GET_PORTSNODEDATA(spNodeParent);

                    CPortDlg    portdlg((LPCTSTR) pData->m_stMachineName,
                                        pData->GetHandle(),
                                        m_entry.m_rp0.hPort,
                                        spNodeParent
                                        );    

                    portdlg.DoModal();

//                  if (portdlg.m_bChanged)
                    RefreshInterface(cookie);

                    // Restart the refresh mechanism
                    // ------------------------------------------------
                    if (fRefresh && spRefresh)
                    {
                        spRefresh->SetRefreshInterval(dwInterval);
                        spRefresh->Start(dwInterval);
                    }
                }
                break;
            case IDS_MENU_PORTS_DISCONNECT:
                {
                    // Get the hServer and hPort
                    m_spNodeMgr->FindNode(cookie, &spNode);
                    spNode->GetParent(&spNodeParent);

                    pData = GET_PORTSNODEDATA(spNodeParent);
                        
                    ::MprAdminPortDisconnect(
                        pData->GetHandle(),
                        m_entry.m_rp0.hPort);

                    RefreshInterface(cookie);
                }
                break;
            default:
                break;
        };
    }
    COM_PROTECT_CATCH;
    
    return hr;
}


ImplementEmbeddedUnknown(PortsUserHandler, IRtrAdviseSink)

STDMETHODIMP PortsUserHandler::EIRtrAdviseSink::OnChange(LONG_PTR ulConn,
    DWORD dwChangeType, DWORD dwObjectType, LPARAM lUserParam, LPARAM lParam)
{
    InitPThis(PortsUserHandler, IRtrAdviseSink);
    HRESULT hr = hrOK;
    
    return hr;
}


/*!--------------------------------------------------------------------------
    PortsUserHandler::OnCreateDataObject
        Implementation of ITFSResultHandler::OnCreateDataObject
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP PortsUserHandler::OnCreateDataObject(ITFSComponent *pComp,
    MMC_COOKIE cookie,
    DATA_OBJECT_TYPES type,
    IDataObject **ppDataObject)
{
    HRESULT hr = hrOK;
    
    COM_PROTECT_TRY
    {
        CORg( CreateDataObjectFromRouterInfo(m_spRouterInfo,
                                             m_spRouterInfo->GetMachineName(),
                                             type, cookie, m_spTFSCompData,
                                             ppDataObject, NULL, FALSE) );
        COM_PROTECT_ERROR_LABEL;
    }
    COM_PROTECT_CATCH;
    return hr;
}

STDMETHODIMP PortsUserHandler::HasPropertyPages (
    ITFSComponent *pComp,
    MMC_COOKIE cookie,
    LPDATAOBJECT pDataObject)
{
    return hrFalse;
}


/*!--------------------------------------------------------------------------
    PortsUserHandler::RefreshInterface
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
void PortsUserHandler::RefreshInterface(MMC_COOKIE cookie)
{
    ForceGlobalRefresh(m_spRouterInfo);
}

/*!--------------------------------------------------------------------------
    PortsUserHandler::OnResultItemClkOrDblClk
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsUserHandler::OnResultItemClkOrDblClk(ITFSComponent *pComponent,
    MMC_COOKIE cookie,
    LPARAM arg,
    LPARAM lParam ,
    BOOL bDoubleClick)
{
    HRESULT     hr = hrOK;
    
    // We don't allow any actions on active dialout connections
    // ------------------------------------------------------------
    if (m_entry.m_fActiveDialOut)
        return hrOK;
    
    if (bDoubleClick)
    {
        // Bring up the status dialog on this port
        CORg( Command(pComponent, cookie, IDS_MENU_PORTS_STATUS,
                      NULL) );
    }

Error:
    return hr;
}


/*---------------------------------------------------------------------------
    PortsProperties implementation
 ---------------------------------------------------------------------------*/

PortsProperties::PortsProperties(ITFSNode *pNode,
                                 IComponentData *pComponentData,
                                 ITFSComponentData *pTFSCompData,
                                 LPCTSTR pszSheetName,
                                 CWnd *pParent,
                                 UINT iPage,
                                 BOOL fScopePane)
    : RtrPropertySheet(pNode, pComponentData, pTFSCompData,
                       pszSheetName, pParent, iPage, fScopePane),
        m_pageGeneral(IDD_PORTS_GLOBAL_GENERAL),
        m_pPortsNodeHandle(NULL),
        m_dwThreadId(0)
{
}

PortsProperties::~PortsProperties()
{
    if (m_dwThreadId)
        DestroyTFSErrorInfoForThread(m_dwThreadId, 0);
    if(m_pPortsNodeHandle)
    {
        m_pPortsNodeHandle->Release();
        m_pPortsNodeHandle = NULL;
    }
}

/*!--------------------------------------------------------------------------
    PortsProperties::Init
        Initialize the property sheets.  The general action here will be
        to initialize/add the various pages.
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsProperties::Init(IRouterInfo *pRouter, PortsNodeHandler* pPortsNodeHandle)
{
    Assert(pRouter);
    HRESULT hr = hrOK;

    m_spRouter.Set(pRouter);
    
    m_pPortsNodeHandle = pPortsNodeHandle;
    if(m_pPortsNodeHandle)    m_pPortsNodeHandle->AddRef();

    // The pages are embedded members of the class
    // do not delete them.
    m_bAutoDeletePages = FALSE;

    m_pageGeneral.Init(this, pRouter);
    AddPageToList((CPropertyPageBase*) &m_pageGeneral);

//Error:
    return hr;
}


/*!--------------------------------------------------------------------------
    PortsProperties::SetThreadInfo
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
void PortsProperties::SetThreadInfo(DWORD dwThreadId)
{
    m_dwThreadId = dwThreadId;
}


/*---------------------------------------------------------------------------
    PortsPageGeneral
 ---------------------------------------------------------------------------*/

BEGIN_MESSAGE_MAP(PortsPageGeneral, RtrPropertyPage)
    //{{AFX_MSG_MAP(PortsPageGeneral)
    ON_BN_CLICKED(IDC_PGG_BTN_CONFIGURE, OnConfigure)
    ON_NOTIFY(NM_DBLCLK, IDC_PGG_LIST, OnListDblClk)
    ON_NOTIFY(LVN_ITEMCHANGED, IDC_PGG_LIST, OnNotifyListItemChanged)
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

PortsPageGeneral::~PortsPageGeneral()
{
    while (!m_deviceList.IsEmpty())
        delete m_deviceList.RemoveHead();
}


/*!--------------------------------------------------------------------------
    PortsPageGeneral::Init
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsPageGeneral::Init(PortsProperties *pPropSheet, IRouterInfo *pRouter)
{
    m_pPortsPropSheet = pPropSheet;
    m_spRouter.Set(pRouter);
    
    RouterVersionInfo    routerVersion;

    // Get the version info.  Needed later on.
    // ----------------------------------------------------------------
    ASSERT(m_spRouter.p);
    m_spRouter->GetRouterVersionInfo(&routerVersion);

    m_bShowContent = (routerVersion.dwRouterVersion >= 5);

    return hrOK;
}

/*!--------------------------------------------------------------------------
    PortsPageGeneral::OnInitDialog
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL PortsPageGeneral::OnInitDialog()
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    HRESULT     hr= hrOK;
    int         i;
    CString     st;
    UINT        cRows = 0;
    PortsDeviceEntry *    pEntry = NULL;
    TCHAR        szNumber[32];
    HRESULT     hrT;
    RECT        rc;
    int         nWidth, nUsageWidth;
    int            nListWidth;
    POSITION    pos;
    INT         iPos;
    HKEY        hkeyMachine = 0;
    INT         iType, idsType;
    DWORD        dwIn, dwOut;

    // if focus on NT4 machine, not to display the content of the dialog, only display some text
    // for the user that the snapin only shows property of NT5 server
    if (!m_bShowContent)
    {
        CString     st;

        st.LoadString(IDS_ERR_NOPORTINFO_ON_NT4);
        
        EnableChildControls(GetSafeHwnd(), PROPPAGE_CHILD_HIDE | PROPPAGE_CHILD_DISABLE);
        GetDlgItem(IDC_PGG_TXT_NOINFO)->SetWindowText(st);
        GetDlgItem(IDC_PGG_TXT_NOINFO)->ShowWindow(SW_SHOW);
        GetDlgItem(IDC_PGG_TXT_NOINFO)->EnableWindow(TRUE);
        return TRUE;
    }

    // hide the warning text if on NT5 servers
    GetDlgItem(IDC_PGG_TXT_NOINFO)->ShowWindow(SW_HIDE);
    
    COM_PROTECT_TRY
    {
        // This assumes that this page will always come up.
        // Create the error info for this thread!
        // ------------------------------------------------------------
        CreateTFSErrorInfo(0);
        m_pPortsPropSheet->SetThreadInfo(GetCurrentThreadId());
        
        RtrPropertyPage::OnInitDialog();

        ListView_SetExtendedListViewStyle(m_listCtrl.GetSafeHwnd(),
                                          LVS_EX_FULLROWSELECT);
        

        // Initialize the list control (with the list of devices)
        // Determine optimal width for the header control
        GetDlgItem(IDC_PGG_LIST)->GetWindowRect(&rc);
        nListWidth = rc.right - rc.left;

        // Figure out the size of Ras/Routing
        st.LoadString(IDS_PORTSDLG_COL_RASROUTING);
        st += _T("WW"); // add extra padding to get a little wider
        nUsageWidth = m_listCtrl.GetStringWidth(st);

        // Remove the Ras/Routing column from the rest of the width
        nListWidth -= nUsageWidth;

        // Remove four pixels off the end (for the borders?)
        nListWidth -= 4;

        // Split the width into fifths
        nWidth = nListWidth / 5;

        // Create the column headers.

        // Column 0...Usage
        st.LoadString(IDS_PORTSDLG_COL_USAGE);
        m_listCtrl.InsertColumn(PORTS_COL_USAGE, st, LVCFMT_LEFT, nUsageWidth, 0);

        
        // Column 1...Device
        st.LoadString(IDS_PORTSDLG_COL_NAME);
        m_listCtrl.InsertColumn(PORTS_COL_DEVICE, st, LVCFMT_LEFT, 3*nWidth, 0);

        
        // Column 2...Type
        st.LoadString(IDS_PORTSDLG_COL_TYPE);
        m_listCtrl.InsertColumn(PORTS_COL_TYPE, st, LVCFMT_LEFT, nWidth, 0);

        
        // Column 3...Number of Ports
        st.LoadString(IDS_PORTSDLG_COL_NUM_PORTS);
        m_listCtrl.InsertColumn(PORTS_COL_NUMBER, st, LVCFMT_LEFT, nWidth, 0);

        
        // Query for the ports' data.
        m_deviceDataEntry.Initialize(m_spRouter->GetMachineName());
        m_deviceDataEntry.LoadDevices(&m_deviceList);

        
        // Walk the list of ports and construct the row entry for the table 
        // for the given port.
        pos = m_deviceList.GetHeadPosition();
        while (pos)
        {
            pEntry = m_deviceList.GetNext(pos);
            Assert(!::IsBadReadPtr(pEntry, sizeof(PortsDeviceEntry)));

            // Column 1...Device
            iPos = m_listCtrl.InsertItem(cRows, pEntry->m_stDisplayName);
            m_listCtrl.SetItemText(iPos, PORTS_COL_DEVICE,
                                   (LPCTSTR) pEntry->m_stDisplayName);
            
            // Column 2...Type
            st = PortTypeToCString(RAS_DEVICE_TYPE(pEntry->m_eDeviceType));
            m_listCtrl.SetItemText(iPos, PORTS_COL_TYPE, (LPCTSTR) st);

            // Column 3...Number of Ports
            FormatNumber(pEntry->m_dwPorts, szNumber,
                         DimensionOf(szNumber), FALSE);
            m_listCtrl.SetItemText(iPos, PORTS_COL_NUMBER, (LPCTSTR) szNumber);

            m_listCtrl.SetItemData(iPos, (LONG_PTR) pEntry);

            // Column 0...Usage
            iType = (pEntry->m_dwEnableRas * 2) + 
                    (pEntry->m_dwEnableRouting |
                     pEntry->m_dwEnableOutboundRouting);

            st = PortsDeviceTypeToCString(iType);
            m_listCtrl.SetItemText(iPos, PORTS_COL_USAGE, (LPCTSTR) st);

            // How many rows now?
            ++cRows;    // preincrement faster operation on Pentium chips...
        }

        // As a default, disable the maximum ports dialog
        GetDlgItem(IDC_PGG_BTN_CONFIGURE)->EnableWindow(FALSE);
        
        if (cRows)
        {
            // Select the first entry in the list control
            m_listCtrl.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED);
        }

    }
    COM_PROTECT_CATCH;
    
    SetDirty(FALSE);
        
    if (!FHrSucceeded(hr))
    {
        delete pEntry;
        Cancel();
    }
    return FHrSucceeded(hr) ? TRUE : FALSE;
}

/*!--------------------------------------------------------------------------
    PortsPageGeneral::DoDataExchange
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
void PortsPageGeneral::DoDataExchange(CDataExchange *pDX)
{
    if (!m_bShowContent)    return;

    RtrPropertyPage::DoDataExchange(pDX);

    //{{AFX_DATA_MAP(PortsPageGeneral)
    DDX_Control(pDX, IDC_PGG_LIST, m_listCtrl);
    //}}AFX_DATA_MAP
    
}

/*!--------------------------------------------------------------------------
    PortsPageGeneral::OnApply
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL PortsPageGeneral::OnApply()
{
    if (!m_bShowContent)    return TRUE;
    
    if (m_pPortsPropSheet->IsCancel())
        return TRUE;

    if(!IsDirty())
        return TRUE;
    
    BOOL        fReturn;
    HRESULT     hr = hrOK;
    HRESULT     hrT = hrOK;
    DWORD        dwErr, dwInValue, dwOutValue;
    HKEY        hkeyMachine;
    RegKey        regkeyMachine;
    POSITION    pos;
    PortsDeviceEntry *    pEntry;

    // Create an error object (just in case)
    CreateTFSErrorInfo(0);
    ClearTFSErrorInfo(0);

    CWRg( ConnectRegistry(m_spRouter->GetMachineName(), &hkeyMachine) );
    regkeyMachine.Attach(hkeyMachine);

    // We ignore the error code from the SaveDevices().  The reason
    // is that for most of the failures, it's only a partial failure
    // (especially for the RasSetDeviceConfigInfo() call.

    hrT = m_deviceDataEntry.SaveDevices(&m_deviceList);
    AddSystemErrorMessage(hrT);
    
Error:
    if (!FHrSucceeded(hr) || !FHrSucceeded(hrT))
    {
        AddHighLevelErrorStringId(IDS_ERR_CANNOT_SAVE_PORTINFO);
        DisplayTFSErrorMessage(NULL);

        // Set focus back to the property sheet
        BringWindowToTop();

        // If the only thing that reports failure is hrT (or the
        // SaveDevices() code), then we continue on.
        if (FHrSucceeded(hr))
            fReturn = RtrPropertyPage::OnApply();
        else
            fReturn = FALSE;
    }
    else
        fReturn = RtrPropertyPage::OnApply();


    // Windows NT Bug : 174916 - need to force a refresh through
    ForceGlobalRefresh(m_spRouter);
    
    return fReturn;
}


void PortsPageGeneral::OnListDblClk(NMHDR *pNMHdr, LRESULT *pResult)
{
    OnConfigure();

    *pResult = 0;
}

/*!--------------------------------------------------------------------------
    PortsPageGeneral::OnNotifyListItemChanged
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
void PortsPageGeneral::OnNotifyListItemChanged(NMHDR *pNmHdr, LRESULT *pResult)
{
//    NMLISTVIEW *    pnmlv = reinterpret_cast<NMLISTVIEW *>(pNmHdr);
//    BOOL            fEnable = !!(pnmlv->uNewState & LVIS_SELECTED);
    BOOL fEnable = (m_listCtrl.GetSelectedCount() != 0);

    GetDlgItem(IDC_PGG_BTN_CONFIGURE)->EnableWindow(fEnable);
    *pResult = 0;
}


/*!--------------------------------------------------------------------------
    PortsPageGeneral::OnConfigure
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
void PortsPageGeneral::OnConfigure()
{
    // Windows NT Bug : 322955
    // Always mark the page dirty.  This is needed because the OnOK()
    // will call OnApply() on the property sheet before the dialog is
    // exited.  This is called to force the changes to save back before
    // the restart is called.
    // ----------------------------------------------------------------
    SetDirty(TRUE);
    SetModified();
    
    OnConfigurePorts(m_spRouter->GetMachineName(),
                     m_pPortsPropSheet->m_pPortsNodeHandle->GetActivePorts(),
                     this,
                     &m_listCtrl);
}


/*---------------------------------------------------------------------------
    PortsDataEntry implementation
 ---------------------------------------------------------------------------*/

PortsDataEntry::PortsDataEntry()
{
    m_fReadFromRegistry = TRUE;
}

PortsDataEntry::~PortsDataEntry()
{
}

/*!--------------------------------------------------------------------------
    PortsDataEntry::Initialize
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsDataEntry::Initialize(LPCTSTR pszMachineName)
{
    DWORD       dwErr;
    HRESULT     hr = hrOK;
    HKEY        hkeyMachine;

    m_fRestrictDialin = TRUE;
    m_regkeyMachine.Close();
    m_stMachine = pszMachineName;
    
    dwErr = ConnectRegistry( m_stMachine, &hkeyMachine);
    if( dwErr == NO_ERROR)
    {
        m_regkeyMachine.Attach(hkeyMachine);
        hr = CheckForDialinRestriction();
    }
    else
    {
        hr = HRESULT_FROM_WIN32(dwErr);
    }
    return hr;
}

/*!--------------------------------------------------------------------------
    PortsDataEntry::LoadDevices
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsDataEntry::LoadDevices(PortsDeviceList *pList)
{
    HRESULT     hr = hrOK;
    POSITION    pos;
    PortsDeviceEntry *    pEntry;

    // Try to load the devices from the router (actually rasman),
    // if that fails then try the registry

    hr = LoadDevicesFromRouter(pList);
    if (!FHrSucceeded(hr))
        hr = LoadDevicesFromRegistry(pList);

    return hr;
}

/*!--------------------------------------------------------------------------
    PortsDataEntry::LoadDevicesFromRegistry
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsDataEntry::LoadDevicesFromRegistry(PortsDeviceList *pList)
{
    HRESULT     hr = hrOK;
    RegKey        regkey;
    RegKey        regkeyDevice;
    RegKey        regkeyEnable;
    RegKeyIterator    regkeyIter;
    HRESULT     hrIter;
    CString     stKey;
    CString     st;
    CString     stFullText;
    CString     stComponentId;
    DWORD        dwEnableRas;
    DWORD        dwEnableRouting;
    DWORD        dwEnableOutboundRouting;
    DWORD        dwT;
    DWORD        dwErr;
    PortsDeviceEntry *    pEntry;
    WCHAR devName[MAX_DEVICE_NAME + 1];
    
    COM_PROTECT_TRY
    {
        // Connect to the machine
        // ------------------------------------------------------------
        if (m_regkeyMachine == NULL)
        {
            CORg(ERROR_CAN_NOT_COMPLETE);
        }
    
        // Get the list of devices
        // ------------------------------------------------------------
    
        // Open HKLM\System\CurrentControlSet\Control\Class\<Modem GUID>
        // ------------------------------------------------------------
        CWRg( regkey.Open(m_regkeyMachine, c_szModemKey, KEY_READ) );

        
        // Enumerate through the list of modems
        // ------------------------------------------------------------
        CORg( regkeyIter.Init(&regkey) );
        
        for (hrIter = regkeyIter.Next(&stKey); hrIter == hrOK; stKey.Empty(), hrIter = regkeyIter.Next(&stKey))
        {
            // Cleanup from the previous loop
            // --------------------------------------------------------
            regkeyDevice.Close();
            regkeyEnable.Close();
        
            // Open the key
            // --------------------------------------------------------
            dwErr = regkeyDevice.Open(regkey, stKey, KEY_READ | KEY_WRITE);
            if (dwErr != ERROR_SUCCESS)
                continue;
        
            // Need to check for the EnableForRas subkey
            // --------------------------------------------------------
            dwErr = regkeyEnable.Open(regkeyDevice, c_szClientsRasKey, KEY_READ);
            if (dwErr == ERROR_SUCCESS)
            {
                dwErr = regkeyEnable.QueryValue(c_szEnableForRas, dwEnableRas);
            }
        
            // Default: assume that the modems are RAS-enabled
            // --------------------------------------------------------
            if (dwErr != ERROR_SUCCESS)
                dwEnableRas = 1;
        
            // Need to check for the EnableForRouting subkey
            // --------------------------------------------------------
            dwErr = regkeyEnable.QueryValue(c_szEnableForRouting, dwEnableRouting);
        
            // Default: assume that the modems are not routing-enabled
            // --------------------------------------------------------
            if (dwErr != ERROR_SUCCESS)
                dwEnableRouting = 0;


            // Need to check for the EnableForOutboundRouting subkey
            // --------------------------------------------------------
            dwErr = regkeyEnable.QueryValue(
                        c_szEnableForOutboundRouting, dwEnableOutboundRouting
                        );
        
            // Default: assume that the modems are not routing-enabled
            // --------------------------------------------------------
            if (dwErr != ERROR_SUCCESS)
                dwEnableOutboundRouting = 0;


            CString stDisplay;
        
            // Do allocation before adding the text to the UI
            // --------------------------------------------------------
            pEntry = new PortsDeviceEntry;
            pEntry->m_fModified = FALSE;
            pEntry->m_dwPorts = 1;
            pEntry->m_fWriteable = FALSE;        // # of ports can't be changed
            pEntry->m_dwMinPorts = pEntry->m_dwPorts;
            pEntry->m_dwMaxPorts = pEntry->m_dwPorts;
            pEntry->m_dwMaxMaxPorts = pEntry->m_dwMaxPorts;
            pEntry->m_dwEnableRas = dwEnableRas;
            pEntry->m_dwEnableRouting = dwEnableRouting;
            pEntry->m_dwEnableOutboundRouting = dwEnableOutboundRouting;
            pEntry->m_eDeviceType = RDT_Modem;
                
            // Save the old values
            // --------------------------------------------------------
            pEntry->m_dwOldPorts = pEntry->m_dwPorts;

            // Add this modem to the list
            // --------------------------------------------------------
            regkeyDevice.QueryValue(c_szFriendlyName, stFullText);
            regkeyDevice.QueryValue(c_szAttachedTo, st);
            stDisplay.Format(IDS_PORTS_NAME_FORMAT, stFullText, st);
            swprintf(devName, L"%S",(LPCTSTR)stDisplay);
            pEntry->m_stDisplayName = devName;

            // Read in all data from the registry key BEFORE here
            // --------------------------------------------------------
            pEntry->m_fRegistry = TRUE;
            pEntry->m_hKey = regkeyDevice;        
            regkeyDevice.Detach();

            
            pList->AddTail(pEntry);
            
            pEntry = NULL;
        }
    
    
        // Enumerate through the list of adapters that have the EnableForRas flag
        // Open HKLM\System\CurrentControlSet\Control\Class\GUID_DEVCLASS_NET
        // ------------------------------------------------------------
        regkey.Close();
        CWRg( regkey.Open(m_regkeyMachine, c_szRegKeyGUID_DEVCLASS_NET, KEY_READ | KEY_WRITE) );
        
        // Enumerate through the list of adapters
        // ------------------------------------------------------------
        CORg( regkeyIter.Init(&regkey) );
        
        stKey.Empty();
        
        for (hrIter = regkeyIter.Next(&stKey); hrIter == hrOK; hrIter = regkeyIter.Next(&stKey))
        {
            // Cleanup from the previous loop
            // --------------------------------------------------------
            regkeyDevice.Close();
            
            // Open the key
            // --------------------------------------------------------
            dwErr = regkeyDevice.Open(regkey, stKey, KEY_READ | KEY_WRITE);
            if (dwErr == ERROR_SUCCESS)
            {
                CString stDisplay;
                DWORD    dwEndpoints;
                
                // Need to get the ComponentId to check for PPTP/PTI
                // ------------------------------------------------
                dwErr = regkeyDevice.QueryValue(c_szRegValMatchingDeviceId,
                                                stComponentId);
                if (dwErr != ERROR_SUCCESS)
                {
                    dwErr = regkeyDevice.QueryValue(c_szRegValComponentId,
                        stComponentId);
                    if (dwErr != ERROR_SUCCESS)
                        stComponentId.Empty();
                }

                
                // Check to see if it has the EnableForRas flag
                // ----------------------------------------------------
                dwErr = regkeyDevice.QueryValue(c_szEnableForRas, dwEnableRas);
                
                // Default: assume that adapters are RAS-enabled
                // ----------------------------------------------------
                if (dwErr != ERROR_SUCCESS)
                {
                    // Windows NT Bug : 292615
                    // If this is a parallel port, do not enable RAS
                    // by default.
                    // ------------------------------------------------
                    if (stComponentId.CompareNoCase(c_szPtiMiniPort) == 0)
                        dwEnableRas = 0;
                    else
                        dwEnableRas = 1;
                }

                
                // Check to see if it has the EnableForRouting flag
                // ----------------------------------------------------
                dwErr = regkeyDevice.QueryValue(c_szEnableForRouting,
                                                dwEnableRouting);
                
                // Default: assume that adapters are not routing-enabled
                // ----------------------------------------------------
                if (dwErr != ERROR_SUCCESS)
                    dwEnableRouting = 0;

                // Need to check for the EnableForOutboundRouting subkey
                // --------------------------------------------------------
                dwErr = regkeyEnable.QueryValue(
                            c_szEnableForOutboundRouting, dwEnableOutboundRouting
                            );
            
                // Default: assume that the adapters are not routing-enabled
                // --------------------------------------------------------
                if (dwErr != ERROR_SUCCESS)
                    dwEnableOutboundRouting = 0;

                
                dwErr = regkeyDevice.QueryValue(c_szWanEndpoints, dwEndpoints);

                
                // If there is no WanEndpoints key, then we assume
                // that the device isn't RAS-capable
                // ----------------------------------------------------
                if (dwErr == ERROR_SUCCESS)
                {
        
                    // Do allocation before adding the text to the UI
                    // ------------------------------------------------
                    pEntry = new PortsDeviceEntry;
                    pEntry->m_fModified = FALSE;
                    pEntry->m_dwEnableRas = dwEnableRas;
                    pEntry->m_dwEnableRouting = dwEnableRouting;
                    pEntry->m_dwEnableOutboundRouting =
                        dwEnableOutboundRouting;
                            
                    pEntry->m_dwPorts = dwEndpoints;
                    
                    // If this is PPTP, then set the eDeviceType flag
                    // ------------------------------------------------
                    if (stComponentId.CompareNoCase(c_szPPTPMiniPort) == 0)
                        pEntry->m_eDeviceType = RDT_Tunnel_Pptp;
                    else if (stComponentId.CompareNoCase(c_szL2TPMiniPort) == 0)
                        pEntry->m_eDeviceType = RDT_Tunnel_L2tp;
                    else if (stComponentId.CompareNoCase(c_szPPPoEMiniPort) == 0)
                        pEntry->m_eDeviceType = RDT_PPPoE;
                    else if (stComponentId.CompareNoCase(c_szPtiMiniPort) == 0)
                        pEntry->m_eDeviceType = RDT_Parallel;
                    else
                        pEntry->m_eDeviceType = (RASDEVICETYPE) RDT_Other;

                    
                    // Save the old values
                    // ------------------------------------------------
                    pEntry->m_dwOldPorts = pEntry->m_dwPorts;        
                                        
                    // Look for min and max values
                    // If the MinWanEndpoints and MaxWanEndpoints keys
                    // exist then this is writeable.
                    // ------------------------------------------------
                    dwErr = regkeyDevice.QueryValue(c_szMinWanEndpoints, dwT);
                    pEntry->m_dwMinPorts = dwT;
                    if (dwErr == ERROR_SUCCESS)
                        dwErr = regkeyDevice.QueryValue(c_szMaxWanEndpoints, dwT);
                    if (dwErr != ERROR_SUCCESS)
                    {
                        pEntry->m_fWriteable = FALSE;
                        pEntry->m_dwMinPorts = pEntry->m_dwPorts;
                        pEntry->m_dwMaxPorts = pEntry->m_dwPorts;
                    }
                    else
                    {
                        pEntry->m_fWriteable = TRUE;
                        pEntry->m_dwMaxPorts = dwT;
                    }
                    pEntry->m_dwMaxMaxPorts = pEntry->m_dwMaxPorts;

                    //$PPTP
                    // For PPTP, we can change the m_dwMaxMaxPorts
                    // ------------------------------------------------
                    if (RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_Tunnel_Pptp)
                    {
                        pEntry->m_dwMaxMaxPorts = m_fRestrictDialin ?
                                                    MAX_ALLOWED_DIALIN : 
                                                    PPTP_MAX_PORTS;
                    }

                    //$L2TP
                    // For L2TP, change the dwMaxMaxPorts
                    // ------------------------------------------------
                    if (RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_Tunnel_L2tp)
                    {
                        pEntry->m_dwMaxMaxPorts = m_fRestrictDialin ?
                                                    MAX_ALLOWED_DIALIN : 
                                                    L2TP_MAX_PORTS;
                    }

                    //$PPPoE
                    // For PPPoE, we cannot change the number of endpoints
                    // ------------------------------------------------
                    if (RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_PPPoE)
                    {
                        pEntry->m_fWriteable = FALSE;
                    }

                    // Verify current set of endpoints is within range
                    //-------------------------------------------------
                    if (pEntry->m_dwMaxPorts > pEntry->m_dwMaxMaxPorts)
                    {
                        pEntry->m_dwMaxPorts = pEntry->m_dwMaxMaxPorts;
                    }

                    if (pEntry->m_dwPorts > pEntry->m_dwMaxPorts)
                    {
                        pEntry->m_dwPorts = pEntry->m_dwMaxPorts;
                    }
                    
                    // Add this device to the list
                    // ------------------------------------------------
                    regkeyDevice.QueryValue(c_szRegValDriverDesc, stDisplay);
                    pEntry->m_stDisplayName = stDisplay;
                                    
                    // Store the value so that we can use it to write
                    // ------------------------------------------------
                    pEntry->m_fRegistry = TRUE;
                    pEntry->m_hKey = regkeyDevice;
                    regkeyDevice.Detach();
                    
                    pList->AddTail(pEntry);
                    pEntry = NULL;
                }
            }
            stKey.Empty();
        }

        COM_PROTECT_ERROR_LABEL;
    }
    COM_PROTECT_CATCH;

    if (FHrSucceeded(hr))
        m_fReadFromRegistry = TRUE;
    
    return hr;
}

/*!--------------------------------------------------------------------------
    PortsDataEntry::LoadDevicesFromRouter
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsDataEntry::LoadDevicesFromRouter(PortsDeviceList *pList)
{
    HRESULT     hr = hrOK;
    HANDLE        hConnection = 0;
    DWORD        cDevices = 0;
    DWORD        cbData = 0;
    BYTE *        pbData = NULL;
    RAS_DEVICE_INFO *    pDevInfo = NULL;
    PortsDeviceEntry *    pEntry = NULL;
    DWORD        dwVersion;
    UINT        i;
    DWORD        dwErr;
    WCHAR devName[MAX_DEVICE_NAME + 1];

    
    USES_CONVERSION;

    COM_PROTECT_TRY
    {

        // Connect to the server
        CWRg( RasRpcConnectServer((LPTSTR) (LPCTSTR)m_stMachine, &hConnection) );

        dwVersion = RasGetServerVersion(hConnection);

        // Get the device information from the router
        dwErr = RasGetDeviceConfigInfo(hConnection,
                                       &dwVersion,
                                       &cDevices,
                                       &cbData,
                                       NULL);

        if (dwErr == ERROR_BUFFER_TOO_SMALL)
            dwErr = ERROR_SUCCESS;
        CWRg(dwErr);
        
        pbData = (BYTE *) new char[cbData];
        
        // Go out and actually grab the data
        CWRg( RasGetDeviceConfigInfo(hConnection,
                                     &dwVersion,
                                     &cDevices,
                                     &cbData,
                                     pbData));

        pDevInfo = (RAS_DEVICE_INFO *) pbData;

        // If we found something and we don't understand the dev version,
        // just punt.
        if (cDevices && pDevInfo->dwVersion != 0 && pDevInfo->dwVersion != VERSION_501)
        {
            // We don't understand the version information
            hr = E_FAIL;
            goto Error;
        }

        if(dwVersion == VERSION_501)
        {
            for (i=0; i<cDevices; i++, pDevInfo++)
            {
                pEntry = new PortsDeviceEntry;
                pEntry->m_fModified = FALSE;
                pEntry->m_dwEnableRas = pDevInfo->fRasEnabled;
                pEntry->m_dwEnableRouting = pDevInfo->fRouterEnabled;
                pEntry->m_dwEnableOutboundRouting =
                    pDevInfo->fRouterOutboundEnabled;
                pEntry->m_stDisplayName = pDevInfo->wszDeviceName;
                pEntry->m_dwPorts = pDevInfo->dwNumEndPoints;
                pEntry->m_eDeviceType = pDevInfo->eDeviceType;
                
                // Save the old values
                pEntry->m_dwOldPorts = pEntry->m_dwPorts;

                pEntry->m_dwMinPorts = pDevInfo->dwMinWanEndPoints;
                pEntry->m_dwMaxPorts = pDevInfo->dwMaxWanEndPoints;
                pEntry->m_dwMaxMaxPorts = pEntry->m_dwMaxPorts;

                //$PPTP
                // For PPTP, we can adjust the value of m_dwMaxPorts
                // --------------------------------------------------------
                if (RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_Tunnel_Pptp)
                {
                    pEntry->m_dwMaxMaxPorts = m_fRestrictDialin ?
                                                MAX_ALLOWED_DIALIN :
                                                PPTP_MAX_PORTS;
                }

                //$L2TP
                // For L2TP, we can adjust the value of m_dwMaxPorts
                // --------------------------------------------------------
                if (RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_Tunnel_L2tp)
                {
                    pEntry->m_dwMaxMaxPorts = m_fRestrictDialin ?
                                                MAX_ALLOWED_DIALIN :
                                                L2TP_MAX_PORTS;
                }

                // Verify current set of endpoints is within range
                //-------------------------------------------------
                if (pEntry->m_dwMaxPorts > pEntry->m_dwMaxMaxPorts)
                {
                    pEntry->m_dwMaxPorts = pEntry->m_dwMaxMaxPorts;
                }

                if (pEntry->m_dwPorts > pEntry->m_dwMaxPorts)
                {
                    pEntry->m_dwPorts = pEntry->m_dwMaxPorts;
                }

                pEntry->m_fWriteable = 
                    (pEntry->m_dwMinPorts != pEntry->m_dwMaxPorts) &&
                    (RAS_DEVICE_TYPE(pEntry->m_eDeviceType) != RDT_PPPoE);
                
                pEntry->m_fRegistry = FALSE;
                pEntry->m_hKey = NULL;

                // Make a copy of the data
                pEntry->m_RasDeviceInfo = *pDevInfo;

                pList->AddTail(pEntry);
                pEntry = NULL;                    
            }
        }
        else
        {
            RAS_DEVICE_INFO_V500 * pDevInfo500 = (RAS_DEVICE_INFO_V500 *)pbData;

	        for (i=0; i<cDevices; i++, pDevInfo500++)
	        {
	            pEntry = new PortsDeviceEntry;
	            pEntry->m_fModified = FALSE;
	            pEntry->m_dwEnableRas = pDevInfo500->fRasEnabled;
	            pEntry->m_dwEnableRouting = pDevInfo500->fRouterEnabled;
	            swprintf(devName, L"%S", pDevInfo500->szDeviceName);
	            pEntry->m_stDisplayName = devName;
	            pEntry->m_dwPorts = pDevInfo500->dwNumEndPoints;
	            pEntry->m_eDeviceType = pDevInfo500->eDeviceType;
	            
	            // Save the old values
	            pEntry->m_dwOldPorts = pEntry->m_dwPorts;
	        
	            pEntry->m_dwMinPorts = pDevInfo500->dwMinWanEndPoints;
	            pEntry->m_dwMaxPorts = pDevInfo500->dwMaxWanEndPoints;
	            pEntry->m_dwMaxMaxPorts = pEntry->m_dwMaxPorts;

	            //$PPTP
	            // For PPTP, we can adjust the value of m_dwMaxPorts
	            // --------------------------------------------------------
	            if (RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_Tunnel_Pptp)
	            {
	                pEntry->m_dwMaxMaxPorts = PPTP_MAX_PORTS;
	            }
	            
	            //$L2TP
	            // For L2TP, we can adjust the value of m_dwMaxPorts
	            // --------------------------------------------------------
	            if (RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_Tunnel_L2tp)
	            {
	                pEntry->m_dwMaxMaxPorts = L2TP_MAX_PORTS;
	            }
	            
	            pEntry->m_fWriteable = 
	                (pEntry->m_dwMinPorts != pEntry->m_dwMaxPorts) &&
	                (RAS_DEVICE_TYPE(pEntry->m_eDeviceType) != RDT_PPPoE);
	            
	            pEntry->m_fRegistry = FALSE;
	            pEntry->m_hKey = NULL;

	            // Make a copy of the data
	            // pEntry->m_RasDeviceInfo = *pDevInfo;
	            memcpy(&pEntry->m_RasDeviceInfo, pDevInfo500,
	                   FIELD_OFFSET(RAS_DEVICE_INFO, fRouterOutboundEnabled));
                memcpy(&pEntry->m_RasDeviceInfo.dwTapiLineId, 
                       &pDevInfo500->dwTapiLineId,
                       sizeof(RAS_DEVICE_INFO) 
                       - FIELD_OFFSET(RAS_DEVICE_INFO, dwTapiLineId));
                       
	            pList->AddTail(pEntry);
	            pEntry = NULL;                    
	        }
            
            
        }
        
        COM_PROTECT_ERROR_LABEL;
    }
    COM_PROTECT_CATCH;

    if (FHrSucceeded(hr))
        m_fReadFromRegistry = FALSE;
    
    // If the function didn't succeed, clean out the list
    if (!FHrSucceeded(hr))
    {
        while (!pList->IsEmpty())
            delete pList->RemoveHead();
    }

    delete [] pbData;
    delete pEntry;
        
    if (hConnection)
        RasRpcDisconnectServer(hConnection);
    return hr;
}


/*!--------------------------------------------------------------------------
    PortsDataEntry::SaveDevices
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsDataEntry::SaveDevices(PortsDeviceList *pList)
{
    HRESULT     hr = hrOK;
    CWaitCursor wait;

    if (m_fReadFromRegistry)
        hr = SaveDevicesToRegistry(pList);
    else
        hr = SaveDevicesToRouter(pList);
    
    return hr;
}

/*!--------------------------------------------------------------------------
    PortsDataEntry::SaveDevicesToRegistry
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsDataEntry::SaveDevicesToRegistry(PortsDeviceList *pList)
{
    HRESULT     hr = hrOK;
    RegKey        regkeyDevice;
    RegKey        regkeyPptpProtocol;
    POSITION    pos;
    PortsDeviceEntry *    pEntry = NULL;
    DWORD        dwErr;

    Assert(pList);

    // Write any changes made to the per-device configuration
    // and write that back out to the registry
    // ----------------------------------------------------------------
    pos = pList->GetHeadPosition();
    while (pos)
    {
        pEntry = pList->GetNext(pos);

        if (pEntry->m_fModified)
        {
            Assert(pEntry->m_hKey);

            regkeyDevice.Attach(pEntry->m_hKey);
            COM_PROTECT_TRY
            {
                RegKey    regkeyModem;
                RegKey *    pRegkeyDevice = NULL;
                
                if (pEntry->m_fWriteable)
                {
                    if (m_fRestrictDialin &&
                        (pEntry->m_dwPorts > MAX_ALLOWED_DIALIN))
                    {
                        pEntry->m_dwPorts = MAX_ALLOWED_DIALIN;
                    }
                    
                    regkeyDevice.SetValue(c_szWanEndpoints,
                                          pEntry->m_dwPorts);

                    //$PPTP
                    // We need to adjust the upper limit for the
                    // number of PPTP ports.
                    // ------------------------------------------------
                    if ((RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_Tunnel_Pptp) &&
                        (pEntry->m_dwPorts > pEntry->m_dwMaxPorts))
                    {
                        DWORD   dwPorts;

                        //$PPTP
                        // Keep the value of the number of PPTP ports
                        // below the max.
                        // --------------------------------------------
                        if (m_fRestrictDialin)
                            dwPorts = MAX_ALLOWED_DIALIN;
                        else
                            dwPorts = min(pEntry->m_dwPorts, PPTP_MAX_PORTS);
                        regkeyDevice.SetValue(c_szMaxWanEndpoints, dwPorts);
                    }
                    
                    //$L2TP
                    // We need to adjust the upper limit for the
                    // number of L2TP ports.
                    // ------------------------------------------------
                    if ((RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_Tunnel_L2tp) &&
                        (pEntry->m_dwPorts > pEntry->m_dwMaxPorts))
                    {
                        DWORD   dwPorts;

                        //$L2TP
                        // Keep the value of the number of L2TP ports
                        // below the max.
                        // --------------------------------------------
                        if (m_fRestrictDialin)
                            dwPorts = MAX_ALLOWED_DIALIN;
                        else
                            dwPorts = min(pEntry->m_dwPorts, L2TP_MAX_PORTS);
                        regkeyDevice.SetValue(c_szMaxWanEndpoints, dwPorts);
                    }
                }

                // Get the clients subkey (if for a modem)
                // else use the device key
                // ----------------------------------------------------
                if (pEntry->m_eDeviceType == RDT_Modem)
                {
                    dwErr = regkeyModem.Create(regkeyDevice, c_szClientsRasKey);
                    pRegkeyDevice = &regkeyModem;
                }
                else
                {
                    pRegkeyDevice = &regkeyDevice;
                    dwErr = ERROR_SUCCESS;
                }

                if (dwErr == ERROR_SUCCESS)
                {
                    pRegkeyDevice->SetValue(c_szEnableForRas,
                                            pEntry->m_dwEnableRas);
                    pRegkeyDevice->SetValue(c_szEnableForRouting,
                                            pEntry->m_dwEnableRouting);
                    pRegkeyDevice->SetValue(c_szEnableForOutboundRouting,
                                            pEntry->m_dwEnableOutboundRouting);
                }
            }
            COM_PROTECT_CATCH;
            regkeyDevice.Detach();

            // The NumberLineDevices is no longer used in NT5.

            // if this is for PPTP, then we need to special case the
            // code to set the PPTP number of devices
            // --------------------------------------------------------
            if (pEntry->m_fWriteable &&
                pEntry->m_fModified &&
                RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_Tunnel_Pptp)
            {
                // Open the PPTP registry key
                // ----------------------------------------------------
                dwErr = regkeyPptpProtocol.Open(m_regkeyMachine,
                                                c_szRegKeyPptpProtocolParam);
                
                // set the NumberLineDevices registry value
                // ----------------------------------------------------
                if (dwErr == ERROR_SUCCESS)
                    regkeyPptpProtocol.SetValue(c_szRegValNumberLineDevices,
                                                pEntry->m_dwPorts);
                regkeyPptpProtocol.Close();
            }
            
        }

        // Windows NT Bug: 136858 (add called id support)
        // Save called id info
        // ------------------------------------------------------------
        if (pEntry->m_fSaveCalledIdInfo)
        {
            Assert(pEntry->m_fCalledIdInfoLoaded);

            regkeyDevice.Attach(pEntry->m_hKey);

            regkeyDevice.SetValueExplicit(c_szRegValCalledIdInformation,
                                          REG_MULTI_SZ,
                                          pEntry->m_pCalledIdInfo->dwSize,
                                          (PBYTE) pEntry->m_pCalledIdInfo->bCalledId
                                          );
            
            regkeyDevice.Detach();

            
        }
    }

    return hr;
}

/*!--------------------------------------------------------------------------
    PortsDataEntry::SaveDevicesToRouter
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsDataEntry::SaveDevicesToRouter(PortsDeviceList *pList)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    HRESULT     hr = hrOK, hrTemp;
    HANDLE        hConnection = 0;
    DWORD        cDevices = 0;
    BYTE *        pbData = NULL;
    RAS_DEVICE_INFO *    pDevInfo = NULL;
    PortsDeviceEntry *    pEntry = NULL;
    POSITION    pos;
    UINT        i;
    RAS_CALLEDID_INFO    calledIdInfo;
    DWORD        dwErr = ERROR_SUCCESS;
    TCHAR        szErr[512];
    DWORD       dwVersion;
    

    Assert(pList);

    COM_PROTECT_TRY
    {

        // Connect to the server
        // ------------------------------------------------------------
        CWRg( RasRpcConnectServer((LPTSTR)(LPCTSTR)m_stMachine, &hConnection) );

        dwVersion = RasGetServerVersion(hConnection);

        // Allocate space for the data
        // ------------------------------------------------------------
        pbData = (BYTE *) new RAS_DEVICE_INFO[pList->GetCount()];

        pDevInfo = (RAS_DEVICE_INFO *) pbData;

        pos = pList->GetHeadPosition();
        cDevices = pList->GetCount();

        if(dwVersion == VERSION_501)
        {
            for (i=0; i<cDevices; i++, pDevInfo++)
            {
                Assert(pos);

                pEntry = pList->GetNext(pos);

                // Get the information needed to calculate the number
                // of ports
                // --------------------------------------------------------
                *pDevInfo = pEntry->m_RasDeviceInfo;

                pDevInfo->fWrite = TRUE;
                pDevInfo->fRasEnabled = pEntry->m_dwEnableRas;
                pDevInfo->fRouterEnabled = pEntry->m_dwEnableRouting;
                pDevInfo->fRouterOutboundEnabled = 
                    pEntry->m_dwEnableOutboundRouting;
                if ((m_fRestrictDialin) && 
                    (pEntry->m_dwPorts > MAX_ALLOWED_DIALIN))
                {
                    pEntry->m_dwPorts = MAX_ALLOWED_DIALIN;
                }
                pDevInfo->dwNumEndPoints = pEntry->m_dwPorts;
                pDevInfo->dwMaxWanEndPoints = pEntry->m_dwMaxPorts;

                // Windows NT Bug : 168364
                // From RaoS, I also need to set the maximum incoming/outging
                // --------------------------------------------------------

                // Windows NT Bug : ?
                // Use the defaults for now,
                // This will get removed later.
                // --------------------------------------------------------
                pDevInfo->dwMaxInCalls = (-1);
                pDevInfo->dwMaxOutCalls = 3;
                

                // if this is for PPTP, then we need to special case the
                // code to set the PPTP number of devices
                // --------------------------------------------------------
                if (RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_Tunnel_Pptp)
                {
                    //$PPTP
                    // We need to adjust the upper limit for the
                    // number of PPTP ports.
                    // ------------------------------------------------
                    if (pEntry->m_dwPorts > pEntry->m_dwMaxPorts)
                    {
                        DWORD   dwPorts;

                        //$PPTP
                        // Keep the value of the number of PPTP ports
                        // below the max.
                        // --------------------------------------------
                        if (m_fRestrictDialin)
                            dwPorts = MAX_ALLOWED_DIALIN;
                        else
                            dwPorts = min(pEntry->m_dwPorts, PPTP_MAX_PORTS);
                        pDevInfo->dwMaxWanEndPoints = dwPorts;
                    }
                    
                    RegKey        regkeyMachine;
                    RegKey        regkeyPptpProtocol;
                    HKEY        hkeyMachine;
                    
                    // Connect to the machine
                    dwErr = ConnectRegistry(m_stMachine, &hkeyMachine);
                    regkeyMachine.Attach(hkeyMachine);

                    // Open the PPTP registry key
                    dwErr = regkeyPptpProtocol.Open(regkeyMachine,
                                                    c_szRegKeyPptpProtocolParam);
                    
                    // set the NumberLineDevices registry value
                    if (dwErr == ERROR_SUCCESS)
                        regkeyPptpProtocol.SetValue(c_szRegValNumberLineDevices,
                                                    pEntry->m_dwPorts);
                    regkeyPptpProtocol.Close();
                    regkeyMachine.Close();
                }


                if (RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_Tunnel_L2tp)
                {
                    //$L2TP
                    // We need to adjust the upper limit for the
                    // number of L2TP ports.
                    // ------------------------------------------------
                    if (pEntry->m_dwPorts > pEntry->m_dwMaxPorts)
                    {
                        DWORD   dwPorts;

                        //$L2TP
                        // Keep the value of the number of L2TP ports
                        // below the max.
                        // --------------------------------------------
                        if (m_fRestrictDialin)
                            dwPorts = MAX_ALLOWED_DIALIN;
                        else
                            dwPorts = min(pEntry->m_dwPorts, L2TP_MAX_PORTS);
                        pDevInfo->dwMaxWanEndPoints = dwPorts;
                    }
                }

                // Windows NT Bug : 136858 (add called id support)
                // Do we need to save the called id info?
                // --------------------------------------------------------
                if (pEntry->m_fSaveCalledIdInfo && pEntry->m_pCalledIdInfo)
                {
                    Assert(pEntry->m_fCalledIdInfoLoaded);
                    
                    //: if the call fails, what should we do? -- save it later
                    
                    hrTemp = RasSetCalledIdInfo(hConnection,
                                                pDevInfo,
                                                pEntry->m_pCalledIdInfo,
                                                TRUE);

                    // We've saved it, we don't need to save it again
                    // unless it changes.
                    // ----------------------------------------------------
                    if (FHrSucceeded(hrTemp))
                        pEntry->m_fSaveCalledIdInfo = FALSE;
                }
            }

            dwErr = RasSetDeviceConfigInfo(hConnection,
                                           cDevices,
                                           sizeof(RAS_DEVICE_INFO)*cDevices,
                                           pbData);
        }                                       
        else
        {
            RAS_DEVICE_INFO_V500 *pDevInfo500 = (RAS_DEVICE_INFO_V500 *) pbData;
            
            for (i=0; i<cDevices; i++, pDevInfo500++)
            {
                Assert(pos);

                pEntry = pList->GetNext(pos);

                // Get the information needed to calculate the number
                // of ports
                // --------------------------------------------------------
                // *pDevInfo = pEntry->m_RasDeviceInfo;
                memcpy(pDevInfo500, &pEntry->m_RasDeviceInfo,
                        FIELD_OFFSET(RAS_DEVICE_INFO, fRouterOutboundEnabled));
                memcpy(&pDevInfo500->dwTapiLineId, 
                       &pEntry->m_RasDeviceInfo.dwTapiLineId,
                       sizeof(RAS_DEVICE_INFO)
                       - FIELD_OFFSET(RAS_DEVICE_INFO, dwTapiLineId));

                pDevInfo500->fWrite = TRUE;
                pDevInfo500->fRasEnabled = pEntry->m_dwEnableRas;
                pDevInfo500->fRouterEnabled = pEntry->m_dwEnableRouting;
                pDevInfo500->dwNumEndPoints = pEntry->m_dwPorts;
                pDevInfo500->dwMaxWanEndPoints = pEntry->m_dwMaxPorts;

                // Windows NT Bug : 168364
                // From RaoS, I also need to set the maximum incoming/outging
                // --------------------------------------------------------

                // Windows NT Bug : ?
                // Use the defaults for now,
                // This will get removed later.
                // --------------------------------------------------------
                pDevInfo500->dwMaxInCalls = (-1);
                pDevInfo500->dwMaxOutCalls = 3;
                

                // if this is for PPTP, then we need to special case the
                // code to set the PPTP number of devices
                // --------------------------------------------------------
                if (RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_Tunnel_Pptp)
                {
                    //$PPTP
                    // We need to adjust the upper limit for the
                    // number of PPTP ports.
                    // ------------------------------------------------
                    if (pEntry->m_dwPorts > pEntry->m_dwMaxPorts)
                    {
                        DWORD   dwPorts;

                        //$PPTP
                        // Keep the value of the number of PPTP ports
                        // below the max.
                        // --------------------------------------------
                        dwPorts = min(pEntry->m_dwPorts, PPTP_MAX_PORTS);
                        pDevInfo500->dwMaxWanEndPoints = dwPorts;
                    }
                    
                    RegKey        regkeyMachine;
                    RegKey        regkeyPptpProtocol;
                    HKEY        hkeyMachine;
                    
                    // Connect to the machine
                    dwErr = ConnectRegistry(m_stMachine, &hkeyMachine);
                    regkeyMachine.Attach(hkeyMachine);

                    // Open the PPTP registry key
                    dwErr = regkeyPptpProtocol.Open(regkeyMachine,
                                                    c_szRegKeyPptpProtocolParam);
                    
                    // set the NumberLineDevices registry value
                    if (dwErr == ERROR_SUCCESS)
                        regkeyPptpProtocol.SetValue(c_szRegValNumberLineDevices,
                                                    pEntry->m_dwPorts);
                    regkeyPptpProtocol.Close();
                    regkeyMachine.Close();
                }


                if (RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_Tunnel_L2tp)
                {
                    //$L2TP
                    // We need to adjust the upper limit for the
                    // number of L2TP ports.
                    // ------------------------------------------------
                    if (pEntry->m_dwPorts > pEntry->m_dwMaxPorts)
                    {
                        DWORD   dwPorts;

                        //$L2TP
                        // Keep the value of the number of L2TP ports
                        // below the max.
                        // --------------------------------------------
                        dwPorts = min(pEntry->m_dwPorts, L2TP_MAX_PORTS);
                        pDevInfo500->dwMaxWanEndPoints = dwPorts;
                    }
                }

                // Windows NT Bug : 136858 (add called id support)
                // Do we need to save the called id info?
                // --------------------------------------------------------
                if (pEntry->m_fSaveCalledIdInfo && pEntry->m_pCalledIdInfo)
                {
                    Assert(pEntry->m_fCalledIdInfoLoaded);
                    
                    //: if the call fails, what should we do? -- save it later
                    
                    hrTemp = RasSetCalledIdInfo(hConnection,
                                                (RAS_DEVICE_INFO *) pDevInfo500,
                                                pEntry->m_pCalledIdInfo,
                                                TRUE);

                    // We've saved it, we don't need to save it again
                    // unless it changes.
                    // ----------------------------------------------------
                    if (FHrSucceeded(hrTemp))
                        pEntry->m_fSaveCalledIdInfo = FALSE;
                }
            }

            dwErr = RasSetDeviceConfigInfo(hConnection,
                                           cDevices,
                                           sizeof(RAS_DEVICE_INFO_V500)*cDevices,
                                           pbData);
        
        }
        if (dwErr != ERROR_SUCCESS)
        {
            CString stErr;
            CString stErrCode;
            BOOL    fErr = FALSE;
            if(dwVersion == VERSION_501)
            {
                RAS_DEVICE_INFO *    pDevice;
                
                // Need to grab the error information out of the
                // info struct an set the error strings.

                // Could not save the information for the following
                // devices
                pDevice = (RAS_DEVICE_INFO *) pbData;

                stErr.LoadString(IDS_ERR_SETDEVICECONFIGINFO_GEEK);
                for (i=0; i<cDevices; i++, pDevice++)
                {
                    if (pDevice->dwError)
                    {
                        CString stErrString;

                        FormatError(HRESULT_FROM_WIN32(pDevice->dwError),
                                    szErr, DimensionOf(szErr));
                                    
                        stErrCode.Format(_T("%s (%08lx)"), szErr,
                                         pDevice->dwError);
                        stErr += _T(" ");
                        stErr += pDevice->szDeviceName;
                        stErr += _T(" ");
                        stErr += stErrCode;
                        stErr += _T("\n");

                        fErr = TRUE;
                    }
                }
            }
            else
            {
                RAS_DEVICE_INFO_V500 *    pDevice;
                
                // Need to grab the error information out of the
                // info struct an set the error strings.

                // Could not save the information for the following
                // devices
                pDevice = (RAS_DEVICE_INFO_V500 *) pbData;

                stErr.LoadString(IDS_ERR_SETDEVICECONFIGINFO_GEEK);
                for (i=0; i<cDevices; i++, pDevice++)
                {
                    if (pDevice->dwError)
                    {
                        CString stErrString;

                        FormatError(HRESULT_FROM_WIN32(pDevice->dwError),
                                    szErr, DimensionOf(szErr));
                                    
                        stErrCode.Format(_T("%s (%08lx)"), szErr,
                                         pDevice->dwError);
                        stErr += _T(" ");
                        stErr += pDevice->szDeviceName;
                        stErr += _T(" ");
                        stErr += stErrCode;
                        stErr += _T("\n");

                        fErr = TRUE;
                    }
                }
            
            }

            if (fErr)
                AddGeekLevelErrorString(stErr);
            
            
            CWRg(dwErr);
        }

        COM_PROTECT_ERROR_LABEL;
    }
    COM_PROTECT_CATCH;

    delete [] pbData;
        
    if (hConnection)
        RasRpcDisconnectServer(hConnection);
    return hr;
}

/*!--------------------------------------------------------------------------
    IsMaxDialinPortsRestricted
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsDataEntry::CheckForDialinRestriction()
{
    DWORD       dwMajor, dwMinor, dwErr;
    HRESULT     hr = hrOK;
    RegKey      regkeyProduct;
    CString     stProductType, stSuite;
    CStringList stlProductSuite;
    
    
    COM_PROTECT_TRY
    {
        dwErr = GetNTVersion(m_regkeyMachine, &dwMajor, &dwMinor, NULL);

        if ( (dwErr == NO_ERROR) &&
             ( (dwMajor > 5) ||
               ((dwMajor == 5) && (dwMinor > 1)) ) )
              
        {
            CWRg( regkeyProduct.Open(
                    m_regkeyMachine, c_szRegKeyProductOptions, KEY_READ
                    ));

            CWRg( regkeyProduct.QueryValue(c_szRegValProductType, stProductType) );

            if (stProductType.Compare(c_szServerNT) == 0)
            {
                //
                // ok, this is a server box
                //

                CWRg( regkeyProduct.QueryValue(
                        c_szRegValProductSuite, stlProductSuite
                        ) );

                POSITION pos = stlProductSuite.GetHeadPosition();

                while( pos != NULL )
                {
                    stSuite = stlProductSuite.GetNext(pos);

                    if(( stSuite.Compare(c_szEnterprise) == 0) ||
                       ( stSuite.Compare(c_szDataCenter) == 0) ||
                       ( stSuite.Compare(c_szSecurityAppliance) == 0 ))
                    {
                        //
                        // This is either a DataCenter or Enterprise version
                        //
                        
                        m_fRestrictDialin = FALSE;
                    }
                }
            }
        }

        else
        {
            m_fRestrictDialin = FALSE;
        }
                
        COM_PROTECT_ERROR_LABEL;
    }
    COM_PROTECT_CATCH;

    return hr;
}


/*---------------------------------------------------------------------------
    PortsDeviceConfigDlg implementation
 ---------------------------------------------------------------------------*/

BEGIN_MESSAGE_MAP(PortsDeviceConfigDlg, CBaseDialog)
    //{{AFX_MSG_MAP(PortsPageGeneral)
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

void PortsDeviceConfigDlg::DoDataExchange(CDataExchange *pDX)
{
    CBaseDialog::DoDataExchange(pDX);

    DDX_Control(pDX, IDC_DEVCFG_SPIN_PORTS, m_spinPorts);
}

void PortsDeviceConfigDlg::SetDevice(PortsDeviceEntry *pEntry, DWORD dwTotalActivePorts)
{
    Assert(pEntry);
    m_pEntry = pEntry;
    m_dwTotalActivePorts = dwTotalActivePorts;
}

BOOL PortsDeviceConfigDlg::OnInitDialog()
{
    HRESULT     hr;
    CString     stCalledIdInfo;
    CString     stDisplay;
    Assert(m_pEntry);
    
    CBaseDialog::OnInitDialog();

    if (RAS_DEVICE_TYPE(m_pEntry->m_eDeviceType) == RDT_PPPoE)
    {
        CheckDlgButton(IDC_DEVCFG_BTN_RAS, FALSE);
        GetDlgItem(IDC_DEVCFG_BTN_RAS)->EnableWindow(FALSE);
        CheckDlgButton(IDC_DEVCFG_BTN_ROUTING, FALSE);
        GetDlgItem(IDC_DEVCFG_BTN_ROUTING)->EnableWindow(FALSE);
        CheckDlgButton(
            IDC_DEVCFG_BTN_OUTBOUND_ROUTING, 
            m_pEntry->m_dwEnableOutboundRouting
            );
    }
    else
    {
        CheckDlgButton(IDC_DEVCFG_BTN_RAS, m_pEntry->m_dwEnableRas);
        CheckDlgButton(IDC_DEVCFG_BTN_ROUTING, m_pEntry->m_dwEnableRouting);
        CheckDlgButton(IDC_DEVCFG_BTN_OUTBOUND_ROUTING, FALSE);
        GetDlgItem(IDC_DEVCFG_BTN_OUTBOUND_ROUTING)->EnableWindow(FALSE);
    }

    m_spinPorts.SetBuddy(GetDlgItem(IDC_DEVCFG_EDIT_PORTS));
    m_spinPorts.SetRange(m_pEntry->m_dwMinPorts, m_pEntry->m_dwMaxMaxPorts);
    m_spinPorts.SetPos(m_pEntry->m_dwPorts);

    // If we can edit/change the number of ports, set it up here
    // ----------------------------------------------------------------
    if (!m_pEntry->m_fWriteable || (m_pEntry->m_dwMinPorts == m_pEntry->m_dwMaxPorts))
    {
        GetDlgItem(IDC_DEVCFG_SPIN_PORTS)->EnableWindow(FALSE);
        GetDlgItem(IDC_DEVCFG_EDIT_PORTS)->EnableWindow(FALSE);
        GetDlgItem(IDC_DEVCFG_TEXT_PORTS)->EnableWindow(FALSE);
        GetDlgItem(IDC_DEVCFG_TEXT)->EnableWindow(FALSE);        
    }

    // Windows NT Bug : 136858 - Get the called id info
    // ----------------------------------------------------------------
    LoadCalledIdInfo();

    // Get the called id info, format it into a string and add it to
    // the display
    // ----------------------------------------------------------------
    CalledIdInfoToString(&stCalledIdInfo);

    GetDlgItem(IDC_DEVCFG_EDIT_CALLEDID)->SetWindowText(stCalledIdInfo);
    ((CEdit *)GetDlgItem(IDC_DEVCFG_EDIT_CALLEDID))->SetModify(FALSE);
    if ((RAS_DEVICE_TYPE(m_pEntry->m_eDeviceType) == RDT_Parallel) ||
        (RAS_DEVICE_TYPE(m_pEntry->m_eDeviceType) == RDT_PPPoE)){
	        GetDlgItem(IDC_DEVCFG_EDIT_CALLEDID)->EnableWindow(FALSE);
               GetDlgItem(IDC_DEVCFG_TEXT_CALLEDID)->EnableWindow(FALSE);
    	}


    // Set the window title to include the display name of the adapter
    // ----------------------------------------------------------------
    stDisplay.Format(IDS_TITLE_CONFIGURE_PORTS,
                     (LPCTSTR) m_pEntry->m_stDisplayName);
    SetWindowText(stDisplay);

    return TRUE;
}


/*!--------------------------------------------------------------------------
    PortsDeviceConfigDlg::OnOK
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
void PortsDeviceConfigDlg::OnOK()
{
    BOOL    fChanged = FALSE;
    BOOL    fReboot = FALSE;
    DWORD   dwNewEnableRas, dwNewEnableRouting, 
            dwNewEnableOutboundRouting, dwNewPorts;
    
    // Check to see if the values changed
    dwNewEnableRas = (IsDlgButtonChecked(IDC_DEVCFG_BTN_RAS) != 0);
    dwNewEnableRouting = (IsDlgButtonChecked(IDC_DEVCFG_BTN_ROUTING) != 0);
    dwNewEnableOutboundRouting = 
        (IsDlgButtonChecked(IDC_DEVCFG_BTN_OUTBOUND_ROUTING) != 0);
    
    dwNewPorts = m_spinPorts.GetPos();

    // Make sure that we have a valid size
    // ----------------------------------------------------------------
    if ((dwNewPorts < m_pEntry->m_dwMinPorts) ||
        (dwNewPorts > m_pEntry->m_dwMaxMaxPorts))
    {
        CString st;
        st.Format(IDS_ERR_PORTS_BOGUS_SIZE, m_pEntry->m_dwMinPorts,
                  m_pEntry->m_dwMaxMaxPorts);
        AfxMessageBox(st);
        return;
    }

    // Windows NT Bug : 174803
    // We do not allow the user to change the number of PPTP ports down
    // to 0.
    // ----------------------------------------------------------------
    if ((RAS_DEVICE_TYPE(m_pEntry->m_eDeviceType) == RDT_Tunnel_Pptp) &&
        (dwNewPorts == 0))
    {
        AfxMessageBox(IDS_ERR_PPTP_PORTS_EQUAL_ZERO);
        return;
    }

    // Windows NT Bugs : 165862
    // If we are changing the number of ports for PPTP
    // then we need to warn the user (since PPTP is not yet
    // fully PnP (4/23/98).
    //
    //$PPTP
    // For PPTP, if the value of m_dwPorts exceeds the value of
    // m_dwMaxPorts, then we have to reboot (we also need to adjust
    // the appropriate registry entries).
    // ----------------------------------------------------------------
    if ((dwNewPorts > m_pEntry->m_dwMaxPorts) &&
        (RAS_DEVICE_TYPE(m_pEntry->m_eDeviceType) == RDT_Tunnel_Pptp))
    {
        // If we have a page, then we can do a reboot, otherwise we
        // are in the wizard and can't do a reboot at this point.
        // ------------------------------------------------------------
        if (m_pageGeneral)
        {
            // The user chose Yes indicating that he wants to be prompted to
            // reboot, so set this flag to trigger a reboot request.
            // --------------------------------------------------------
            if (AfxMessageBox(IDS_WRN_PPTP_NUMPORTS_CHANGING, MB_YESNO) == IDYES)
            {
                fReboot = TRUE;
            }
        }
        else
            AfxMessageBox(IDS_WRN_PPTP_NUMPORTS_CHANGING2, MB_OK);
    }

    //$L2TP
    // For L2TP, if the value of m_dwPorts exceeds the value of
    // m_dwMaxPorts, then we have to reboot (we also need to adjust
    // the appropriate registry entries).
    // ----------------------------------------------------------------
    if ((dwNewPorts > m_pEntry->m_dwMaxPorts) &&
        (RAS_DEVICE_TYPE(m_pEntry->m_eDeviceType) == RDT_Tunnel_L2tp))
    {
        // If we have a page, then we can do a reboot, otherwise we
        // are in the wizard and can't do a reboot at this point.
        // ------------------------------------------------------------
        if (m_pageGeneral)
        {
            // The user chose Yes indicating that he wants to be prompted to
            // reboot, so set this flag to trigger a reboot request.
            // --------------------------------------------------------
            if (AfxMessageBox(IDS_WRN_L2TP_NUMPORTS_CHANGING, MB_YESNO) == IDYES)
            {
                fReboot = TRUE;
            }
        }
        else
            AfxMessageBox(IDS_WRN_L2TP_NUMPORTS_CHANGING2, MB_OK);
    }

    if ((dwNewEnableRas != m_pEntry->m_dwEnableRas) ||
        (dwNewEnableRouting != m_pEntry->m_dwEnableRouting) ||
        (dwNewEnableOutboundRouting != 
            m_pEntry->m_dwEnableOutboundRouting) ||
        (dwNewPorts != m_pEntry->m_dwPorts))
    {
        // warning user -- client could be disconnected  -- BUG 165862
        // when disable router / ras
        // decreasing the number of ports
        // ras
        if(!dwNewEnableRas &&
           m_pEntry->m_dwEnableRas &&
           m_dwTotalActivePorts > 0 &&
           AfxMessageBox(IDS_WRN_PORTS_DISABLERAS, MB_YESNO | MB_DEFBUTTON2) == IDNO)
            goto L_RESTORE;
        
        // routing
        if (((!dwNewEnableRouting &&
             m_pEntry->m_dwEnableRouting) ||
            (!dwNewEnableOutboundRouting &&
             m_pEntry->m_dwEnableOutboundRouting)) &&
             m_dwTotalActivePorts > 0    &&
            AfxMessageBox(IDS_WRN_PORTS_DISABLEROUTING, MB_YESNO | MB_DEFBUTTON2) == IDNO)
            goto L_RESTORE;

            
        // Bug 263958
        //ports --  We cannot count the number of outgoing connection remotely.
        // Therefore if we reduce the number of port, give warning without counting total
        // active connections.
        if(dwNewPorts < m_pEntry->m_dwPorts &&
           AfxMessageBox(IDS_WRN_PORTS_DECREASE, MB_YESNO | MB_DEFBUTTON2) == IDNO)
            goto L_RESTORE;

        m_pEntry->m_dwEnableRas = dwNewEnableRas;
        m_pEntry->m_dwEnableRouting = dwNewEnableRouting;
        m_pEntry->m_dwEnableOutboundRouting = 
            dwNewEnableOutboundRouting;
        m_pEntry->m_dwPorts = dwNewPorts;
        m_pEntry->m_fModified = TRUE;
    }

    // Get the called id info string (if the field changed)
    // ----------------------------------------------------------------
    if (((CEdit *) GetDlgItem(IDC_DEVCFG_EDIT_CALLEDID))->GetModify())
    {
        CString st;
        GetDlgItem(IDC_DEVCFG_EDIT_CALLEDID)->GetWindowText(st);

        StringToCalledIdInfo((LPCTSTR) st);

        // Now set the changed state on the structure
        // We need to save this data back to the registry
        // ------------------------------------------------------------
        m_pEntry->m_fSaveCalledIdInfo = TRUE;
    }
    
    CBaseDialog::OnOK();
 
    if(fReboot == TRUE)
    {
        Assert(m_pageGeneral);
        
        // force an OnApply to save data before shut down
        // ------------------------------------------------------------
        if (m_pageGeneral->OnApply()) {
           WCHAR szComputer[MAX_COMPUTERNAME_LENGTH + 1];
           DWORD dwLength = MAX_COMPUTERNAME_LENGTH;

           GetComputerName(szComputer, &dwLength );
           if (lstrcmpi(szComputer, (LPTSTR)m_pageGeneral->m_spRouter->GetMachineName())) 
           {
               ::RestartComputer((LPTSTR)m_pageGeneral->m_spRouter->GetMachineName());
           }
           else
               ::RestartComputer((LPTSTR)NULL);
        }
    }

    return;
    
L_RESTORE:
    if (RAS_DEVICE_TYPE(m_pEntry->m_eDeviceType) == RDT_PPPoE)
    {
        CheckDlgButton(
            IDC_DEVCFG_BTN_OUTBOUND_ROUTING, 
            m_pEntry->m_dwEnableOutboundRouting
            );
    }

    else
    {
        CheckDlgButton(IDC_DEVCFG_BTN_RAS, m_pEntry->m_dwEnableRas);
        CheckDlgButton(IDC_DEVCFG_BTN_ROUTING, m_pEntry->m_dwEnableRouting);
    }

    m_spinPorts.SetPos(m_pEntry->m_dwPorts);

    return;
}


/*!--------------------------------------------------------------------------
    PortsDeviceConfigDlg::LoadCalledIdInfo
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsDeviceConfigDlg::LoadCalledIdInfo()
{
    HRESULT hr = hrOK;
    
    if (!m_pEntry->m_fCalledIdInfoLoaded)
    {
        // Read the data from the registry
        // ------------------------------------------------------------
        if (m_pEntry->m_fRegistry)
        {
            DWORD    dwType;
            DWORD    dwSize;
            LPBYTE    pbData = NULL;
            DWORD    dwErr;
            RegKey    regkeyDevice;
            
            regkeyDevice.Attach(m_pEntry->m_hKey);

            dwErr = regkeyDevice.QueryValueExplicit(c_szRegValCalledIdInformation,
                &dwType,
                &dwSize,
                &pbData);

            hr = HRESULT_FROM_WIN32(dwErr);

            if ((dwErr == ERROR_SUCCESS) &&
                (dwType == REG_MULTI_SZ))
            {
                // Allocate space for a new called id structure
                // ----------------------------------------------------
                delete (BYTE *) m_pEntry->m_pCalledIdInfo;
                hr = AllocateCalledId(dwSize, &(m_pEntry->m_pCalledIdInfo));

                if (FHrSucceeded(hr))
                {
                    memcpy(m_pEntry->m_pCalledIdInfo->bCalledId,
                           pbData,
                           dwSize);
                }

            }
            
            delete pbData;
            
            regkeyDevice.Detach();
        }
        else
        {
            HANDLE    hConnection = NULL;
            DWORD    dwSize = 0;
            DWORD    dwErr;
                                  
            // use Rao's API
            
            // Connect to the server
            // --------------------------------------------------------
            dwErr = RasRpcConnectServer((LPTSTR) (LPCTSTR)m_stMachine,
                                        &hConnection);

            // Call it once to get the size information
            // --------------------------------------------------------
            if (dwErr == ERROR_SUCCESS)
                dwErr = RasGetCalledIdInfo(hConnection,
                                           &m_pEntry->m_RasDeviceInfo,
                                           &dwSize,
                                           NULL);
            hr = HRESULT_FROM_WIN32(dwErr);

            if ((dwErr == ERROR_BUFFER_TOO_SMALL) ||
                (dwErr == ERROR_SUCCESS))
            {
                // Allocate space for a new called id structure
                // ----------------------------------------------------
                delete (BYTE *) m_pEntry->m_pCalledIdInfo;
                AllocateCalledId(dwSize, &(m_pEntry->m_pCalledIdInfo));

                dwErr = RasGetCalledIdInfo(hConnection,
                                           &m_pEntry->m_RasDeviceInfo,
                                           &dwSize,
                                           m_pEntry->m_pCalledIdInfo
                                          );
                hr = HRESULT_FROM_WIN32(dwErr);
            }

            if (hConnection)
                RasRpcDisconnectServer(hConnection);
        }

        // Set the status flags, depending on whether the operation
        // succeeded or not
        // ------------------------------------------------------------

        // We always set the save value to FALSE after we have read
        // something in (or tried to read something in).
        // ------------------------------------------------------------
        m_pEntry->m_fSaveCalledIdInfo = FALSE;

        // We always set the load value to TRUE (we have tried to load
        // the information but it failed, for example the registry
        // key may not exist).
        // ------------------------------------------------------------
        m_pEntry->m_fCalledIdInfoLoaded = TRUE;
        
        if (!FHrSucceeded(hr))
        {
            delete m_pEntry->m_pCalledIdInfo;
            m_pEntry->m_pCalledIdInfo = NULL;
        }
    }
//Error:
    return hr;
}


/*!--------------------------------------------------------------------------
    PortsDeviceConfigDlg::AllocateCalledId
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsDeviceConfigDlg::AllocateCalledId(DWORD dwSize,
                                               RAS_CALLEDID_INFO **ppCalledId)
{
    HRESULT     hr = hrOK;

    *ppCalledId = NULL;
    
    COM_PROTECT_TRY
    {
        *ppCalledId =
            (RAS_CALLEDID_INFO *) new BYTE[sizeof(RAS_CALLEDID_INFO) +
                                         dwSize];
        (*ppCalledId)->dwSize = dwSize;
    }
    COM_PROTECT_CATCH;

    return hr;
}

/*!--------------------------------------------------------------------------
    PortsDeviceConfigDlg::CalledIdInfoToString
        Converts the data in the called id info structure into a
        semi-colon separated string.
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsDeviceConfigDlg::CalledIdInfoToString(CString *pst)
{
    WCHAR * pswz = NULL;
    HRESULT hr = hrOK;
    USES_CONVERSION;

    Assert(pst);
    Assert(m_pEntry);

    COM_PROTECT_TRY
    {
    
        pst->Empty();

        if (m_pEntry->m_pCalledIdInfo)
            pswz = (WCHAR *) (m_pEntry->m_pCalledIdInfo->bCalledId);

        if (pswz && *pswz)
        {
            *pst += W2T(pswz);

            // Skip over the terminating NULL
            // --------------------------------------------------------
            pswz += StrLenW(pswz)+1;
            
            while (*pswz)
            {
                *pst += _T("; ");
                *pst += W2T(pswz);
                
                // Skip over the terminating NULL
                // --------------------------------------------------------
                pswz += StrLenW(pswz)+1;
            }
        }
    }
    COM_PROTECT_CATCH;

    if (!FHrSucceeded(hr))
        pst->Empty();

    return hr;    
}

/*!--------------------------------------------------------------------------
    PortsDeviceConfigDlg::StringToCalledIdInfo
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT PortsDeviceConfigDlg::StringToCalledIdInfo(LPCTSTR psz)
{
    DWORD    cchSize;
    WCHAR * pswzData = NULL;
    WCHAR * pswzCurrent;
    LPTSTR    pszBufferStart = NULL;
    LPTSTR    pszBuffer = NULL;
    RAS_CALLEDID_INFO * pCalledInfo = NULL;
    HRESULT hr = hrOK;
    CString stTemp;

    // We need to parse the string (look for separators)
    // ----------------------------------------------------------------

    COM_PROTECT_TRY
    {

        // Allocate some space for the called id info (it's just as long
        // as the string, maybe even somewhat smaller).
        // Allocate twice the space so that we are sure of getting
        // all of the NULL terminating characters
        // ------------------------------------------------------------
        pswzData = new WCHAR[2*(StrLen(psz)+1) + 1];
        pswzCurrent = pswzData;
        
        // Copy the string into a buffer
        // ------------------------------------------------------------
        pszBufferStart = StrDup(psz);
        pszBuffer = pszBufferStart;
        
        _tcstok(pszBuffer, _T(";"));
        
        while (pszBuffer && *pszBuffer)
        {
            // Trim the string (get rid of whitespace, before and after).
            // --------------------------------------------------------
            stTemp = pszBuffer;
            stTemp.TrimLeft();
            stTemp.TrimRight();
            
            if (!stTemp.IsEmpty())
            {
                StrCpyWFromT(pswzCurrent, (LPCTSTR) stTemp);
                pswzCurrent += stTemp.GetLength()+1;
            }
            
            pszBuffer = _tcstok(NULL, _T(";"));
        }
        
        // Add extra terminating NULL character (so that it conforms
        // to the REG_MULTI_SZ format).
        // ------------------------------------------------------------
        *pswzCurrent = 0;
        cchSize = pswzCurrent - pswzData + 1;
        
        // Allocate the real data structure
        // Allocate and copy into a temporary so that in case
        // of an exception, we don't lose the original data
        // ------------------------------------------------------------
        AllocateCalledId(cchSize*sizeof(WCHAR), &pCalledInfo);
        memcpy(pCalledInfo->bCalledId,
               pswzData,
               cchSize*sizeof(WCHAR));

        delete (BYTE *) m_pEntry->m_pCalledIdInfo;
        m_pEntry->m_pCalledIdInfo = pCalledInfo;

        // Set to NULL so that we don't delete our new pointer
        // on exit.
        // ------------------------------------------------------------
        pCalledInfo = NULL;
        
    }
    COM_PROTECT_CATCH;

    delete pszBufferStart;
    delete pswzData;
    
    delete pCalledInfo;
    
    return hr;
}



/*---------------------------------------------------------------------------
    PortsSimpleDeviceConfigDlg implementation
 ---------------------------------------------------------------------------*/

BEGIN_MESSAGE_MAP(PortsSimpleDeviceConfigDlg, CBaseDialog)
    //{{AFX_MSG_MAP(PortsPageGeneral)
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

void PortsSimpleDeviceConfigDlg::DoDataExchange(CDataExchange *pDX)
{
    CBaseDialog::DoDataExchange(pDX);
}

BOOL PortsSimpleDeviceConfigDlg::OnInitDialog()
{
    HRESULT     hr;
    
    CBaseDialog::OnInitDialog();

    // If we are using the BIG dialog, then we need to disable
    // the unapplicable controls.
    if (GetDlgItem(IDC_DEVCFG_TEXT_CALLEDID))
    {
        MultiEnableWindow(GetSafeHwnd(),
                          FALSE,
                          IDC_DEVCFG_TEXT_CALLEDID,
                          IDC_DEVCFG_EDIT_CALLEDID,
                          IDC_DEVCFG_TEXT_PORTS,
                          IDC_DEVCFG_EDIT_PORTS,
                          IDC_DEVCFG_SPIN_PORTS,
                          IDC_DEVCFG_TEXT,
                          0);
    }

    CheckDlgButton(IDC_DEVCFG_BTN_RAS, m_dwEnableRas);
    CheckDlgButton(IDC_DEVCFG_BTN_ROUTING, m_dwEnableRouting);
    GetDlgItem(IDC_DEVCFG_BTN_OUTBOUND_ROUTING)->EnableWindow(FALSE);

    return TRUE;
}


/*!--------------------------------------------------------------------------
    PortsSimpleDeviceConfigDlg::OnOK
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
void PortsSimpleDeviceConfigDlg::OnOK()
{
    // Check to see if the values changed
    m_dwEnableRas = (IsDlgButtonChecked(IDC_DEVCFG_BTN_RAS) != 0);
    m_dwEnableRouting = (IsDlgButtonChecked(IDC_DEVCFG_BTN_ROUTING) != 0);

    CBaseDialog::OnOK(); 
    return;
}



/*---------------------------------------------------------------------------
    PortsDeviceEntry implementation
 ---------------------------------------------------------------------------*/

PortsDeviceEntry::PortsDeviceEntry()
    : m_hKey(NULL),
    m_fRegistry(FALSE),
    m_fSaveCalledIdInfo(FALSE),
    m_fCalledIdInfoLoaded(FALSE),
    m_pCalledIdInfo(NULL)
{
}


PortsDeviceEntry::~PortsDeviceEntry()
{
    delete (BYTE *) m_pCalledIdInfo;
    
    if (m_hKey)
        DisconnectRegistry(m_hKey);
    m_hKey = NULL;
}

BOOL
RestartComputer(LPTSTR szMachineName)

    /* Called if user chooses to shut down the computer.
    **
    ** Return false if failure, true otherwise
    */
{
   HANDLE             hToken;              /* handle to process token */
   TOKEN_PRIVILEGES  tkp;                  /* ptr. to token structure */
   BOOL              fResult;              /* system shutdown flag */
   CString             str;

   TRACE(L"RestartComputer");

   /* Enable the shutdown privilege */

   if (!OpenProcessToken( GetCurrentProcess(),
                          TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
                          &hToken))
      return FALSE;

   /* Get the LUID for shutdown privilege. */

   if (szMachineName)
       LookupPrivilegeValue(NULL, SE_REMOTE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid);
   else
       LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid);


   tkp.PrivilegeCount = 1;    /* one privilege to set    */
   tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

   /* Get shutdown privilege for this process. */

   AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES) NULL, 0);

   /* Cannot test the return value of AdjustTokenPrivileges. */

   if (GetLastError() != ERROR_SUCCESS)
      return FALSE;

   str.LoadString(IDS_SHUTDOWN_WARNING);
   fResult = InitiateSystemShutdownEx(
                szMachineName,          // computer to shutdown
                str.GetBuffer(10),      // msg. to user
                20,                     // time out period - shut down right away
                FALSE,                  // forcibly close open apps
                TRUE,                   // Reboot after shutdown
                SHTDN_REASON_FLAG_PLANNED | 
                SHTDN_REASON_MAJOR_OPERATINGSYSTEM | 
                SHTDN_REASON_MINOR_RECONFIG
                );
 
   str.ReleaseBuffer();

   if (!fResult)
    {
        return FALSE;
    }
   if( !ExitWindowsEx(EWX_REBOOT, 0))
      return FALSE;

   /* Disable shutdown privilege. */

   tkp.Privileges[0].Attributes = 0;
   AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES) NULL, 0);

   if (GetLastError() != ERROR_SUCCESS)
      return FALSE;

   return TRUE;
}


/*!--------------------------------------------------------------------------
    OnConfigurePorts
        Returns TRUE if something has changed.    FALSE otherwise.
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL OnConfigurePorts(LPCTSTR pszMachineName,
                      DWORD dwTotalActivePorts,
                      PortsPageGeneral *pPage,
                      CListCtrlEx *pListCtrl)
{
    BOOL    fChanged = FALSE;
    
    // Need to determine if multiple items are selected or not
    if (pListCtrl->GetSelectedCount() == 1)
    {    
        PortsDeviceConfigDlg    configdlg(pPage, pszMachineName);
        int                     iPos;
        PortsDeviceEntry *        pEntry;
        CString                 st;
        int                     iType;
        TCHAR                    szNumber[32];
        
        if ((iPos = pListCtrl->GetNextItem(-1, LVNI_SELECTED)) == -1)
            return FALSE;
        
        pEntry = (PortsDeviceEntry *) pListCtrl->GetItemData(iPos);
        
        // total number of active ports are passed over to dialog, so if user tries to reduce total number of port
        // below this total number, give a warning message
        configdlg.SetDevice(pEntry, dwTotalActivePorts);
        
        if (configdlg.DoModal() == IDOK)
        {
            // Get the values from pEntry and update the list control entry
            iType = (pEntry->m_dwEnableRas * 2) + 
                    (pEntry->m_dwEnableRouting ||
                     pEntry->m_dwEnableOutboundRouting);

            st = PortsDeviceTypeToCString(iType);
            pListCtrl->SetItemText(iPos, PORTS_COL_USAGE, (LPCTSTR) st);
            
            FormatNumber(pEntry->m_dwPorts, szNumber,
                         DimensionOf(szNumber), FALSE);
            pListCtrl->SetItemText(iPos, PORTS_COL_NUMBER, (LPCTSTR) szNumber);

            fChanged = TRUE;
        }
    }
    
    return fChanged;
}



/*---------------------------------------------------------------------------
    RasmanPortMap implementation
 ---------------------------------------------------------------------------*/

RasmanPortMap::~RasmanPortMap()
{
    m_map.RemoveAll();
}

HRESULT RasmanPortMap::Init(HANDLE hRasHandle,
                            RASMAN_PORT *pPort,
                            DWORD dwPorts)
{
    RASMAN_INFO     rasmaninfo;
    DWORD       i;
    DWORD       dwErr = NO_ERROR;
    HRESULT     hr = hrOK;

    if (pPort == NULL)
    {
        m_map.RemoveAll();
        return hr;
    }
    
    for (i=0; i<dwPorts; i++, pPort++)
    {
        // If the port is closed, there is no need
        // to go any further.  (No need to do an RPC for this).
        // ----------------------------------------------------
        if (pPort->P_Status == CLOSED)
            continue;
        
        dwErr = RasGetInfo(hRasHandle,
                           pPort->P_Handle,
                           &rasmaninfo);
        
        if (dwErr != ERROR_SUCCESS)
            continue;
        
        // If this is a dial-out port and in use
        // mark it as active
        // --------------------------------------------
        if ((rasmaninfo.RI_ConnState == CONNECTED) &&
            (pPort->P_ConfiguredUsage & (CALL_IN | CALL_ROUTER)) &&
            (rasmaninfo.RI_CurrentUsage & CALL_OUT))
        {
            // Ok, this is a candidate.  Add it to the list
            // ----------------------------------------
            WCHAR   swzPortName[MAX_PORT_NAME+1];

            StrnCpyWFromA(swzPortName,
                          pPort->P_PortName,
                          MAX_PORT_NAME);
            
            m_map.SetAt(swzPortName, pPort);
        }
    }

    return hr;
}

BOOL RasmanPortMap::FIsDialoutActive(LPCWSTR pswzPortName)
{
    LPVOID  pv;
    
    return m_map.Lookup(pswzPortName, pv);
}