windows-server-2003/net/rras/ras/ui/common/pbk/pbk.c

// Copyright (c) 1995, Microsoft Corporation, all rights reserved
//
// pbk.c
// Remote Access phonebook library
// General routines
// Listed alphabetically
//
// 06/20/95 Steve Cobb


#include "pbkp.h"
#include <search.h>  // Qsort
#include <tapi.h>

#ifdef UNICODE
#define SZ_PathCanonicalize     "PathCanonicalizeW"
#define SZ_PathRemoveFileSpec   "PathRemoveFileSpecW"
#else
#define SZ_PathCanonicalize     "PathCanonicalizeA"
#define SZ_PathRemoveFileSpec   "PathRemoveFileSpecA"
#endif

PbkPathInfo g_PbkPathInfo;

//----------------------------------------------------------------------------
// Local prototypes
//----------------------------------------------------------------------------

DWORD
AppendPbportToList(
    IN HANDLE hConnection,
    IN DTLLIST* pdtllist,
    IN RASMAN_PORT* pPort );

DWORD
AppendStringToList(
    IN DTLLIST* pdtllist,
    IN TCHAR* psz );

int __cdecl
CompareDevices(
    const void* pDevice1,
    const void* pDevice2 );

int __cdecl
ComparePorts(
    const void* pPort1,
    const void* pPort2 );

CHAR*
PbMedia(
    IN PBDEVICETYPE pbdt,
    IN CHAR* pszMedia );

WCHAR *
GetUnicodeName(HANDLE hPort);


//----------------------------------------------------------------------------
// Routines
//----------------------------------------------------------------------------

DWORD
RdtFromPbdt(PBDEVICETYPE pbdt, DWORD dwFlags)
{
    DWORD rdt;

    switch(pbdt)
    {
        case PBDT_Modem:
        {
            rdt = RDT_Modem;

            if(PBP_F_NullModem & dwFlags)
            {
                rdt |= (RDT_Direct | RDT_Null_Modem);
            }
            
            break;
        }

        case PBDT_X25:
        {
            rdt = RDT_X25;
            break;
        }

        case PBDT_Isdn:
        {
            rdt = RDT_Isdn;
            break;
        }

        case PBDT_Serial:
        {
            rdt = RDT_Serial;
            break;
        }

        case PBDT_FrameRelay:
        {
            rdt = RDT_FrameRelay;
            break;
        }

        case PBDT_Atm:
        {
            rdt = RDT_Atm;
            break;
        }

        case PBDT_Vpn:
        {
            rdt = RDT_Tunnel;

            if(PBP_F_L2tpDevice & dwFlags)
            {
                rdt |= RDT_Tunnel_L2tp;
            }
            else if(PBP_F_PptpDevice & dwFlags)
            {
                rdt |= RDT_Tunnel_Pptp;
            }
            
            break;
        }

        case PBDT_Sonet:
        {
            rdt = RDT_Sonet;
            break;
        }

        case PBDT_Sw56:
        {
            rdt = RDT_Sw56;
            break;
        }

        case PBDT_Irda:
        {
            rdt = (RDT_Irda | RDT_Direct);
            break;
        }

        case PBDT_Parallel:
        {
            rdt = (RDT_Parallel | RDT_Direct);
            break;
        }

        case PBDT_Null:
        {
            rdt = (RDT_Direct | RDT_Null_Modem);
            break;
        }

        case PBDT_PPPoE:
        {
            rdt = (RDT_PPPoE | RDT_Broadband);
            break;
        }

        default:
        {
            rdt = RDT_Other;
            break;
        }
    }

    return rdt;
}


PBDEVICETYPE
PbdtFromRdt(
    IN DWORD rdt
    )
{
    PBDEVICETYPE pbdt;

    switch(rdt)
    {
        case RDT_Modem:
        {
            pbdt = PBDT_Modem;
            break;
        }

        case RDT_X25:
        {
            pbdt = PBDT_X25;
            break;
        }

        case RDT_Isdn:
        {
            pbdt = PBDT_Isdn;
            break;
        }

        case RDT_Serial:
        {
            pbdt = PBDT_Serial;
            break;
        }

        case RDT_FrameRelay:
        {
            pbdt = PBDT_FrameRelay;
            break;
        }

        case RDT_Atm:
        {
            pbdt = PBDT_Atm;
            break;
        }

        case RDT_Tunnel_Pptp:
        case RDT_Tunnel_L2tp:
        {
            pbdt = PBDT_Vpn;
            break;
        }

        case RDT_Sonet:
        {
            pbdt = PBDT_Sonet;
            break;
        }

        case RDT_Sw56:
        {
            pbdt = PBDT_Sw56;
            break;
        }

        case RDT_Irda:
        {
            pbdt = PBDT_Irda;
            break;
        }

        case RDT_Parallel:
        {
            pbdt = PBDT_Parallel;
            break;
        }

        case RDT_PPPoE:
        {
            pbdt = PBDT_PPPoE;
            break;
        }

        default:
        {
            pbdt = PBDT_Other;
            break;
        }
    }

    return pbdt;
}

TCHAR *
pszDeviceTypeFromRdt(RASDEVICETYPE rdt)
{
    TCHAR *pszDeviceType = NULL;
    
    switch(RAS_DEVICE_TYPE(rdt))
    {
        case RDT_Modem:
        {
            pszDeviceType = RASDT_Modem;
            break;
        }

        case RDT_X25:
        {
            pszDeviceType = RASDT_X25;
            break;
        }

        case RDT_Isdn:
        {
            pszDeviceType = RASDT_Isdn;
            break;
        }

        case RDT_Serial:
        {
            pszDeviceType = RASDT_Serial;
            break;
        }

        case RDT_FrameRelay:
        {
            pszDeviceType = RASDT_FrameRelay;
            break;
        }

        case RDT_Atm:
        {   
            pszDeviceType = RASDT_Atm;
            break;
        }

        case RDT_Sonet:
        {
            pszDeviceType = RASDT_Sonet;
            break;
        }

        case RDT_Sw56:
        {
            pszDeviceType = RASDT_SW56;
            break;
        }

        case RDT_Tunnel_Pptp:
        case RDT_Tunnel_L2tp:
        {
            pszDeviceType = RASDT_Vpn;
            break;
        }

        case RDT_Irda:
        {
            pszDeviceType = RASDT_Irda;
            break;
        }

        case RDT_Parallel:
        {
            pszDeviceType = RASDT_Parallel;
            break;
        }

        case RDT_PPPoE:
        {
            pszDeviceType = RASDT_PPPoE;
            break;
        }

        default:
        {   
            pszDeviceType = NULL;
            break;
        }
    }

    return StrDup(pszDeviceType);
}

DWORD
AppendPbportToList(
    IN HANDLE hConnection,
    IN DTLLIST* pdtllist,
    IN RASMAN_PORT* pPort )

    // Append a PBPORT onto the list 'pdtllist' which has the characteristics
    // of RAS Manager port 'pPort'.
    //
    // Returns 0 if successful, otherwise a non-zero error code.
    //
{
    DWORD dwErr;
    DTLNODE* pdtlnode;
    PBPORT* ppbport;
    DWORD dwType, dwClass;

    dwErr = 0;

    pdtlnode = CreatePortNode();
    if (    !pdtlnode)
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    // Get detailed information about the device from
    // rasman
    dwClass = RAS_DEVICE_CLASS(pPort->P_rdtDeviceType);
    dwType = RAS_DEVICE_TYPE(pPort->P_rdtDeviceType);

    // Now set the device info
    ppbport = (PBPORT* )DtlGetData( pdtlnode );
    // ppbport->pszDevice = StrDupTFromAUsingAnsiEncoding( pPort->P_DeviceName );
    ppbport->pszDevice = GetUnicodeName(pPort->P_Handle);
    
    if(ppbport->pszDevice == NULL)
    {
        ppbport->pszDevice = StrDupTFromAUsingAnsiEncoding( pPort->P_DeviceName );
    }
    
    ppbport->pszPort = StrDupTFromAUsingAnsiEncoding( pPort->P_PortName );

    // Record the flags appropriate to this device
    if ( dwType == RDT_Tunnel_Pptp )
    {
        ppbport->dwFlags |= PBP_F_PptpDevice;
    }
    else if ( dwType == RDT_Tunnel_L2tp )
    {
        ppbport->dwFlags |= PBP_F_L2tpDevice;
    }
    //For whistler 349087 345068    gangz
    //
    else if ( dwType == RDT_PPPoE )
    {
        ppbport->dwFlags |= PBP_F_PPPoEDevice;
    }
    
    if ( dwClass & RDT_Null_Modem )
    {
        ppbport->dwFlags |= PBP_F_NullModem;
    }
    //For whistler 349087 345068    gangz
    //
    else if ( dwClass & RDT_Broadband )
    {
        ppbport->dwFlags |= PBP_F_PPPoEDevice;
    }

    // Compute the phonebook device type
    //
    ppbport->pbdevicetype = PbdtFromRdt(dwType);
    if ( PBDT_Other == ppbport->pbdevicetype )
    {
        ppbport->pbdevicetype = PbdevicetypeFromPszTypeA( pPort->P_DeviceType);
    }

    ppbport->pszMedia = StrDupTFromAUsingAnsiEncoding(
        PbMedia( ppbport->pbdevicetype, pPort->P_MediaName ) );

    if (!ppbport->pszPort || !ppbport->pszDevice || !ppbport->pszMedia)
    {
        dwErr = ERROR_NOT_ENOUGH_MEMORY;
    }
    else if ((ppbport->pbdevicetype == PBDT_Modem)  ||
             (ppbport->dwFlags & PBP_F_NullModem))
    {

#ifdef MXSMODEMS
        if (pPort->P_LineDeviceId == 0xFFFFFFFF)
        {
            // MXS modem port.
            //
            ppbport->fMxsModemPort = TRUE;

            GetRasPortMaxBps( pPort->P_Handle,
                &ppbport->dwMaxConnectBps, &ppbport->dwMaxCarrierBps );

            GetRasPortModemSettings( pPort->P_Handle, &ppbport->fHwFlowDefault,
                &ppbport->fEcDefault, &ppbport->fEccDefault );
        }
        else
#else
        ASSERT( pPort->P_LineDeviceId != 0xFFFFFFFF );
#endif

        {
            // Unimodem port.
            //
            UNIMODEMINFO info;

            ZeroMemory((PBYTE) &info, sizeof(info));

            GetRasUnimodemInfo( 
                        hConnection, 
                        pPort->P_Handle, 
                        pPort->P_DeviceType, 
                        &info );

            TRACE6( "Port=%s,fHw=%d,fEc=%d,bps=%d,fSp=%d,prot=%x",
                pPort->P_PortName, info.fHwFlow, info.fEc,
                info.dwBps, info.fSpeaker, info.dwModemProtocol );

            ppbport->fHwFlowDefault = info.fHwFlow;
            ppbport->fEcDefault = info.fEc;
            ppbport->fEccDefault = info.fEcc;
            ppbport->dwBpsDefault = info.dwBps;
            ppbport->fSpeakerDefault = info.fSpeaker;

            // pmay: 228565
            // Add the modem protocol information
            //
            ppbport->dwModemProtDefault = info.dwModemProtocol;
            ppbport->pListProtocols = info.pListProtocols;
        }
    }

    if (dwErr == 0)
    {
        ppbport->dwType = EntryTypeFromPbport( ppbport );
        DtlAddNodeLast( pdtllist, pdtlnode );
    }
    else
    {
        Free0( ppbport->pszDevice );
        Free0( ppbport->pszMedia );
        Free0( ppbport->pszPort );
        DtlDestroyNode( pdtlnode );
    }

    return dwErr;
}


DWORD
AppendStringToList(
    IN DTLLIST* pdtllist,
    IN TCHAR* psz )

    // Appends a copy of 'psz' to the end of list 'pdtllist'.
    //
    // Returns 0 if successful, otherwise a non-zero error code.
    // ERROR_NOT_ENOUGH_MEMORY is returned if 'psz' is NULL.
    //
{
    DTLNODE* pdtlnode;
    TCHAR*   pszDup;

    if (!psz)
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    pszDup = StrDup( psz );
    if (!pszDup)
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    pdtlnode = DtlCreateNode( pszDup, 0L );
    if (!pdtlnode )
    {
        Free( pszDup );
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    DtlAddNodeLast( pdtllist, pdtlnode );
    return 0;
}


DTLNODE*
CloneEntryNode(
    DTLNODE* pdtlnodeSrc )

    // Duplicates entry node 'pdtlnodeSrc' with fields that cannot be cloned
    // set to "like new" settings.
    //
{
    DTLNODE* pdtlnode = NULL;
    RPC_STATUS rpcStatus = RPC_S_OK;
    PBENTRY* ppbentry = NULL;
    HRESULT hr = S_OK;

    __try
    {
        pdtlnode = DuplicateEntryNode( pdtlnodeSrc );

        if ( NULL == pdtlnode )
        {
            hr = E_FAIL;
            __leave;
        }
        
        ppbentry = (PBENTRY* )DtlGetData( pdtlnode );
        ASSERT( ppbentry );

        if ( NULL == ppbentry )
        {
            hr = E_FAIL;
            __leave;
        }
        
        ppbentry->fSkipDownLevelDialog = FALSE;
        ppbentry->fSkipDoubleDialDialog = FALSE;
        ppbentry->fSkipNwcWarning = FALSE;
        ppbentry->dwDialParamsUID = GetTickCount();

        if (ppbentry->dwType != RASET_Phone)
        {
            ppbentry->fPreviewPhoneNumber = FALSE;
            ppbentry->fSharedPhoneNumbers = FALSE;
        }

        Free0( ppbentry->pGuid );
        ppbentry->pGuid = Malloc( sizeof(GUID) );
        
        if ( NULL == ppbentry->pGuid)
        {
            hr = E_OUTOFMEMORY;
            __leave;
        }
        
        // For Whistler bug 513885
        rpcStatus =  UuidCreate( (UUID* )ppbentry->pGuid );

        if( !( ( RPC_S_OK == rpcStatus) ||
               ( RPC_S_UUID_LOCAL_ONLY == rpcStatus ) 
              )
           )
        {
            hr = E_FAIL;
            __leave;
        }

        ppbentry->fDirty = FALSE;
    }
    __finally
    {
        if ( S_OK != hr )
        {
            if ( pdtlnode )
            {
                DestroyEntryNode( pdtlnode );
                pdtlnode = NULL;
            }
        }
    }
    
    return pdtlnode;
}


int __cdecl
CompareDevices(
    const void* pDevice1,
    const void* pDevice2 )

    // Qsort compare function for RASMAN_DEVICEs.
    //
{
    return
        lstrcmpiA( ((RASMAN_DEVICE* )pDevice1)->D_Name,
                   ((RASMAN_DEVICE* )pDevice2)->D_Name );
}


int __cdecl
ComparePorts(
    const void* pPort1,
    const void* pPort2 )

    // Qsort compare function for RASMAN_PORTs.
    //
{
    return
        lstrcmpiA( ((RASMAN_PORT* )pPort1)->P_PortName,
                   ((RASMAN_PORT* )pPort2)->P_PortName );
}


DWORD
CopyToPbport(
    IN PBPORT* ppbportDst,
    IN PBPORT* ppbportSrc )

    // Make a duplicate of 'ppbportSrc' in 'ppbportDst'.  If 'ppbportSrc' is
    // NULL it sets 'ppbportDst' to defaults.
    //
    // Returns 0 if successful or an error code.
    //
{
    DTLNODE *pdtlnode, *pNode;
    WCHAR *pwsz;
    DTLLIST *pdtllist = NULL;
    
    Free0( ppbportDst->pszDevice );
    Free0( ppbportDst->pszMedia );
    Free0( ppbportDst->pszPort );

    if (!ppbportSrc)
    {
        ppbportDst->pszPort = NULL;
        ppbportDst->fConfigured = TRUE;
        ppbportDst->pszDevice = NULL;
        ppbportDst->pszMedia = NULL;
        ppbportDst->pbdevicetype = PBDT_None;
        ppbportDst->dwType = RASET_Phone;
        ppbportDst->fHwFlowDefault = FALSE;
        ppbportDst->fEcDefault = FALSE;
        ppbportDst->fEccDefault = FALSE;
        ppbportDst->dwBpsDefault = 0;
        ppbportDst->fSpeakerDefault = TRUE;
        ppbportDst->fScriptBeforeTerminal = FALSE;
        ppbportDst->fScriptBefore = FALSE;
        ppbportDst->pszScriptBefore = NULL;
        return 0;
    }

    CopyMemory( ppbportDst, ppbportSrc, sizeof(*ppbportDst) );
    ppbportDst->pszDevice = StrDup( ppbportSrc->pszDevice );
    ppbportDst->pszMedia = StrDup( ppbportSrc->pszMedia );
    ppbportDst->pszPort = StrDup( ppbportSrc->pszPort );
    ppbportDst->pszScriptBefore = StrDup( ppbportSrc->pszScriptBefore );

    //
    // Copy the protocol list.
    //
    if(ppbportSrc->pListProtocols)
    {
        for (pdtlnode = DtlGetFirstNode( ppbportSrc->pListProtocols);
             pdtlnode;
             pdtlnode = DtlGetNextNode( pdtlnode ))
        {
            if(NULL == pdtllist)
            {
                pdtllist = DtlCreateList(0);
                if(NULL == pdtllist)
                {
                    return ERROR_NOT_ENOUGH_MEMORY;
                }
            }
            
            pwsz = (WCHAR *) DtlGetData(pdtlnode);

            pNode = DtlCreateSizedNode(
                        (wcslen(pwsz) + 1) * sizeof(WCHAR),
                        pdtlnode->lNodeId);

            if(NULL == pNode)
            {
                return ERROR_NOT_ENOUGH_MEMORY;
            }

            wcscpy((WCHAR *) DtlGetData(pNode), pwsz);
            DtlAddNodeLast(pdtllist, pNode);
        }
    }

    ppbportDst->pListProtocols = pdtllist;

    if ((ppbportSrc->pszDevice && !ppbportDst->pszDevice)
        || (ppbportSrc->pszMedia && !ppbportDst->pszMedia)
        || (ppbportSrc->pszPort && !ppbportDst->pszPort)
        || (ppbportSrc->pszScriptBefore && !ppbportDst->pszScriptBefore))
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    return 0;
}


VOID
ChangeEntryType(
    PBENTRY* ppbentry,
    DWORD dwType )

    // Changes the type of 'ppbentry' to 'dwType' and sets defaults
    // accordingly.
    //
{
    ppbentry->dwType = dwType;

    if (dwType == RASET_Phone)
    {
        ppbentry->fPreviewPhoneNumber = TRUE;

        // Defaults for Phones changed per bug 230240 and 363809.
        //
        ppbentry->dwAuthRestrictions = AR_F_TypicalUnsecure;
        ppbentry->dwTypicalAuth =  TA_Unsecure;
        ppbentry->dwDataEncryption = DE_IfPossible;
        ppbentry->fIpHeaderCompression = TRUE;
        
        ppbentry->fShareMsFilePrint = FALSE;

        // Disable File and Print services by default for phone
        //
        EnableOrDisableNetComponent( ppbentry, TEXT("ms_server"),
            FALSE);

        ppbentry->fBindMsNetClient = TRUE;

        EnableOrDisableNetComponent( ppbentry, TEXT("ms_msclient"),
                TRUE);
    }
    else if (dwType == RASET_Vpn)
    {
        // NOTE: If you change this you may need to also make a change in
        //       CloneEntryNode.
        //
        ppbentry->fPreviewPhoneNumber = FALSE;
        ppbentry->fSharedPhoneNumbers = FALSE;

        // Defaults for VPN changed per bug 230240 and 363809.
        //
        ppbentry->dwAuthRestrictions = AR_F_TypicalSecure;
        ppbentry->dwTypicalAuth =  TA_Secure;
        ppbentry->dwDataEncryption = DE_Require;
        ppbentry->fIpHeaderCompression = FALSE;
        
        // We share file and print by default for vpn
        //
        ppbentry->fShareMsFilePrint = TRUE;

        // Enable File and Print services by default
        //
        EnableOrDisableNetComponent( ppbentry, TEXT("ms_server"),
            TRUE);
            
        ppbentry->fBindMsNetClient = TRUE;

        EnableOrDisableNetComponent( ppbentry, TEXT("ms_msclient"),
                TRUE);
    }
    else if (dwType == RASET_Broadband)
    {
        // NOTE: If you change this you may need to also make a change in
        //       CloneEntryNode.
        //
        ppbentry->fPreviewPhoneNumber = FALSE;
        ppbentry->fSharedPhoneNumbers = FALSE;

        // Defaults for broadband connections
        //
        ppbentry->dwAuthRestrictions = AR_F_TypicalSecure;
        ppbentry->dwTypicalAuth =  TA_Secure;
        ppbentry->dwDataEncryption = DE_IfPossible;
        ppbentry->fIpHeaderCompression = FALSE;
        
        // We share file and print by default for vpn
        //
        ppbentry->fShareMsFilePrint = TRUE;

        // Enable File and Print services by default
        //
        EnableOrDisableNetComponent( ppbentry, TEXT("ms_server"),
            FALSE);
            
        ppbentry->fBindMsNetClient = TRUE;

        EnableOrDisableNetComponent( ppbentry, TEXT("ms_msclient"),
                TRUE);
    }
    else if (dwType == RASET_Direct)
    {
        // NOTE: If you change this you may need to also make a change in
        //       CloneEntryNode.
        //
        ppbentry->fPreviewPhoneNumber = FALSE;
        ppbentry->fSharedPhoneNumbers = FALSE;

        // Defaults for DCC (like Phones in this regard) changed per bug
        // 230240 and 363809.
        //
        ppbentry->dwAuthRestrictions = AR_F_TypicalUnsecure;
        ppbentry->dwTypicalAuth =  TA_Unsecure;
        ppbentry->dwDataEncryption = DE_IfPossible;
        ppbentry->fIpHeaderCompression = TRUE;
        
        // We share file and print by default for dcc
        //
        ppbentry->fShareMsFilePrint = TRUE;

        // Enable File and Print services by default
        //
        EnableOrDisableNetComponent( ppbentry, TEXT("ms_server"),
            TRUE);
            
        ppbentry->fBindMsNetClient = TRUE;

        EnableOrDisableNetComponent( ppbentry, TEXT("ms_msclient"),
                TRUE);
    }
}


DTLNODE*
CreateEntryNode(
    BOOL fCreateLink )

    // Allocates a sized phonebook entry node of type RASET_Phone and fills it
    // with default values.  See ChangeEntryNodeType routine.  'If
    // 'fCreateLink' is true a default node is added the list of links.
    // Otherwise, the list of links is empty.
    //
    // Returns the address of the allocated node if successful, NULL
    // otherwise.
    //
{
    DTLNODE* pdtlnode;
    PBENTRY* ppbentry;

    TRACE( "CreateEntryNode" );

    // Allocate the node with built-in PBENTRY.
    //
    pdtlnode = DtlCreateSizedNode( sizeof(PBENTRY), 0L );
    if (!pdtlnode)
    {
        return NULL;
    }

    ppbentry = (PBENTRY* )DtlGetData( pdtlnode );
    ASSERT( ppbentry );

    // Create the list of links with a default link node or no link nodes as
    // chosen by caller.
    //
    ppbentry->pdtllistLinks = DtlCreateList( 0 );
    if (!ppbentry->pdtllistLinks)
    {
        DestroyEntryNode( pdtlnode );
        return NULL;
    }

    if (fCreateLink)
    {
        DTLNODE* pLinkNode;

        pLinkNode = CreateLinkNode();
        if (!pLinkNode)
        {
            DestroyEntryNode( pdtlnode );
            return NULL;
        }

        DtlAddNodeLast( ppbentry->pdtllistLinks, pLinkNode );
    }

    // Set fields to defaults.
    //
    ppbentry->pszEntryName = NULL;
    ppbentry->dwType = RASET_Phone;

    // General page fields.
    //
    ppbentry->pszPrerequisiteEntry = NULL;
    ppbentry->pszPrerequisitePbk = NULL;
    ppbentry->fSharedPhoneNumbers = TRUE;
    ppbentry->fGlobalDeviceSettings = FALSE;
    ppbentry->fShowMonitorIconInTaskBar = TRUE;
    ppbentry->pszPreferredDevice = NULL;
    ppbentry->pszPreferredPort = NULL;
    
    //For .Net 639551   Add preferred info for Modem settings
    ppbentry->dwPreferredBps    = 0;
    ppbentry->fPreferredHwFlow  = 0;
    ppbentry->fPreferredEc      = 0;
    ppbentry->fPreferredEcc     = 0;
    ppbentry->fPreferredSpeaker = 0;
    
    ppbentry->dwPreferredModemProtocol=0;   //For whislter bug 402522


    // Options page fields.
    //
    ppbentry->fShowDialingProgress = TRUE;
    ppbentry->fPreviewPhoneNumber = TRUE;
    ppbentry->fPreviewUserPw = TRUE;
    ppbentry->fPreviewDomain = FALSE;  // See bug 281673

    ppbentry->dwDialMode = RASEDM_DialAll;
    ppbentry->dwDialPercent = 75;
    ppbentry->dwDialSeconds = 120;
    ppbentry->dwHangUpPercent = 10;
    ppbentry->dwHangUpSeconds = 120;

    ppbentry->dwfOverridePref =
        RASOR_RedialAttempts | RASOR_RedialSeconds
        | RASOR_IdleDisconnectSeconds | RASOR_RedialOnLinkFailure;

    ppbentry->lIdleDisconnectSeconds = 0;
    ppbentry->dwRedialAttempts = 3;
    ppbentry->dwRedialSeconds = 60;
    ppbentry->fRedialOnLinkFailure = FALSE;

    // Security page fields.
    //
    ppbentry->dwAuthRestrictions = AR_F_TypicalUnsecure;
    ppbentry->dwTypicalAuth = TA_Unsecure;
    ppbentry->dwDataEncryption = DE_IfPossible;
    ppbentry->fAutoLogon = FALSE;
    ppbentry->fUseRasCredentials = TRUE;

    ppbentry->dwCustomAuthKey = (DWORD )-1;
    ppbentry->pCustomAuthData = NULL;
    ppbentry->cbCustomAuthData = 0;

    ppbentry->fScriptAfterTerminal = FALSE;
    ppbentry->fScriptAfter = FALSE;
    ppbentry->pszScriptAfter = NULL;

    ppbentry->pszX25Network = NULL;
    ppbentry->pszX25Address = NULL;
    ppbentry->pszX25UserData = NULL;
    ppbentry->pszX25Facilities = NULL;

    // Use is unknown
    //
    ppbentry->dwUseFlags = 0;
    
    //IP Security Dialog box
    //
    ppbentry->dwIpSecFlags = 0;

    // Network page fields.
    //
    ppbentry->dwBaseProtocol = BP_Ppp;
    ppbentry->dwVpnStrategy = VS_Default;
    ppbentry->dwfExcludedProtocols = 0;
    ppbentry->fLcpExtensions = TRUE;
    ppbentry->fSkipNwcWarning = FALSE;
    ppbentry->fSkipDownLevelDialog = FALSE;
    ppbentry->fSkipDoubleDialDialog = FALSE;
    ppbentry->fSwCompression = TRUE;

    // (shaunco) Gibbs and QOS guys want this on by default.
    // for whislter bug 385842      gangz
    // we cut this functionality, so set the default to be FALSE
    //
    ppbentry->fNegotiateMultilinkAlways = FALSE;

    // Create the list of links with a default link node or no link nodes as
    // chosen by caller.
    //
    ppbentry->pdtllistNetComponents = DtlCreateList( 0 );
    if (!ppbentry->pdtllistNetComponents)
    {
        DestroyEntryNode( pdtlnode );
        return NULL;
    }

#ifdef AMB
    ppbentry->dwAuthentication = (DWORD )AS_Default;
#endif

    ppbentry->fIpPrioritizeRemote = TRUE;
    ppbentry->fIpHeaderCompression = TRUE;
    ppbentry->pszIpAddress = NULL;
    ppbentry->pszIpDnsAddress = NULL;
    ppbentry->pszIpDns2Address = NULL;
    ppbentry->pszIpWinsAddress = NULL;
    ppbentry->pszIpWins2Address = NULL;
    ppbentry->dwIpAddressSource = ASRC_ServerAssigned;
    ppbentry->dwIpNameSource = ASRC_ServerAssigned;
    ppbentry->dwFrameSize = 1006;

    //Changed Vivekk - BugId: 105777
    if ( !IsServerOS() )
        ppbentry->dwIpDnsFlags = 0;
    else
        ppbentry->dwIpDnsFlags = DNS_RegDefault;

    ppbentry->dwIpNbtFlags = PBK_ENTRY_IP_NBT_Enable;

    // Whistler bug 300933.  0=default
    //
    ppbentry->dwTcpWindowSize = 0;
   
    ppbentry->pszIpDnsSuffix = NULL;

    // Router page fields.
    //
    ppbentry->dwCallbackMode = CBM_No;
    ppbentry->fAuthenticateServer = FALSE;

    // Other fields not shown in UI.
    //
    ppbentry->pszCustomDialDll = NULL;
    ppbentry->pszCustomDialFunc = NULL;

    ppbentry->pszCustomDialerName = NULL;

    ppbentry->dwDialParamsUID = GetTickCount();

    ppbentry->pGuid = Malloc( sizeof(GUID) );
    if (ppbentry->pGuid)
    {
        if(UuidCreate( (UUID* )(ppbentry->pGuid) ))
        {
        }
    }

    ppbentry->pszOldUser = NULL;
    ppbentry->pszOldDomain = NULL;

    // Status flags.  'fDirty' is set when the entry has changed so as to
    // differ from the phonebook file on disk.  'fCustom' is set when the
    // entry contains at least one MEDIA and DEVICE (so RASAPI is able to read
    // it) but was not created by us.  When 'fCustom' is set only 'pszEntry'
    // is guaranteed valid and the entry cannot be edited.
    //
    ppbentry->fDirty = FALSE;
    ppbentry->fCustom = FALSE;

    return pdtlnode;
}


DTLNODE*
CreateLinkNode(
    void )

    // Allocates a sized phonebook entry link node and fills it with default
    // values.
    //
    // Returns the address of the allocated node if successful, NULL
    // otherwise.  It's the caller's responsibility to free the block.
    //
{
    DTLNODE* pdtlnode;
    PBLINK* ppblink;

    TRACE( "CreateLinkNode" );

    pdtlnode = DtlCreateSizedNode( sizeof(PBLINK), 0L );
    if (!pdtlnode)
    {
        return NULL;
    }

    ppblink = (PBLINK* )DtlGetData( pdtlnode );
    ASSERT( ppblink );

    CopyToPbport( &ppblink->pbport, NULL );

    ppblink->dwBps = 0;
    ppblink->fHwFlow = TRUE;
    ppblink->fEc = TRUE;
    ppblink->fEcc = TRUE;
    ppblink->fSpeaker = TRUE;
    ppblink->dwModemProtocol = 0;

    ppblink->fProprietaryIsdn = FALSE;
    ppblink->lLineType = 0;
    ppblink->fFallback = TRUE;
    ppblink->fCompression = TRUE;
    ppblink->lChannels = 1;

    ppblink->pTapiBlob = NULL;
    ppblink->cbTapiBlob = 0;

    ppblink->iLastSelectedPhone = 0;
    ppblink->fPromoteAlternates = FALSE;
    ppblink->fTryNextAlternateOnFail = TRUE;

    ppblink->fEnabled = TRUE;

    // The list of phone number blocks is created but left empty.
    //
    ppblink->pdtllistPhones = DtlCreateList( 0 );
    if (!ppblink->pdtllistPhones)
    {
        Free( ppblink );
        return NULL;
    }

    return pdtlnode;
}

VOID
GetCountryCodeAndID( 
    IN PBPHONE* pPhone )

    // Get TAPI�s country ID for the current location.  This is needed because
    // it�s needed for lineGetCountry.
    //
{
    static BOOLEAN fAlreadyQueried = FALSE;
    static DWORD   dwPreviousCountryCode = 1;
    static DWORD   dwPreviousCountryID   = 1;
    
    LPLINETRANSLATECAPS lpTranslateCaps = NULL;
    LPLINELOCATIONENTRY lpLocationList  = NULL;
    DWORD dwErr = 0;
    DWORD dwNeededSize = 0;
    DWORD dwLocationIndex = 0;

    TRACE("GetCountryCodeAndID");
    ASSERT(pPhone != NULL);

    // Check to see if we've done this already so we don't have to do it again.
    //
    if (fAlreadyQueried)
    {
        pPhone->dwCountryCode = dwPreviousCountryCode;
        pPhone->dwCountryID   = dwPreviousCountryID;
        return;
    }

    // It's okay to set fAlreadyQueried since the defaults are set up to valid
    // values.
    //
    fAlreadyQueried = TRUE;

    // Setup the defaults in case something fails.
    //
    pPhone->dwCountryCode = 1;
    pPhone->dwCountryID = 1;

    lpTranslateCaps = Malloc(sizeof(LINETRANSLATECAPS));
    if (lpTranslateCaps == NULL)
    {
        return;
    }

    // Query lineGetTranslateCaps to find out how big our LINETRANSLATECAPS 
    // structure needs to be.
    //
    lpTranslateCaps->dwTotalSize = sizeof(LINETRANSLATECAPS);
    dwErr = lineGetTranslateCaps(0, TAPI_CURRENT_VERSION, lpTranslateCaps);
    if (dwErr != 0)
    {
        Free(lpTranslateCaps);
        return;
    }

    // Make our LINETRANSLATECAPS structure big enough. 
    //
    dwNeededSize = lpTranslateCaps->dwNeededSize;
    Free(lpTranslateCaps);
    lpTranslateCaps = Malloc(dwNeededSize); 
    if (lpTranslateCaps == NULL)
    {
        return;
    }

    // Now we can actually go and get the locations.
    //
    lpTranslateCaps->dwTotalSize = dwNeededSize;
    dwErr = lineGetTranslateCaps(0, TAPI_CURRENT_VERSION, lpTranslateCaps);
    if (dwErr != 0)
    {
        Free(lpTranslateCaps);
        return;
    }

    // Walk through the locations, looking for the current location.
    //
    lpLocationList = (LPLINELOCATIONENTRY) ( ((LPSTR)lpTranslateCaps) + lpTranslateCaps->dwLocationListOffset );
    for ( dwLocationIndex=0; dwLocationIndex < lpTranslateCaps->dwNumLocations; dwLocationIndex++ )
    {
        if (lpLocationList[dwLocationIndex].dwPermanentLocationID == lpTranslateCaps->dwCurrentLocationID)
        {
                break;
        }
    }

    // If we found the current location, we know which country�s ID to use for dialing rules.
    //
    if (dwLocationIndex < lpTranslateCaps->dwNumLocations)
    {
        pPhone->dwCountryCode = lpLocationList[dwLocationIndex].dwCountryCode;
        pPhone->dwCountryID = lpLocationList[dwLocationIndex].dwCountryID;

        // Save the values in case we're called again.
        // 
        dwPreviousCountryCode = pPhone->dwCountryCode;
        dwPreviousCountryID = pPhone->dwCountryID;
    }

    Free(lpTranslateCaps);
}

DTLNODE*
CreatePhoneNode(
    void )

    // Allocates a sized phone number node and fills it with default values.
    //
    // Returns the address of the allocated node if successful, NULL
    // otherwise.  It's the caller's responsibility to free the block.
    //
{
    DTLNODE* pNode;
    PBPHONE* pPhone;

    TRACE( "CreatePhoneNode" );

    pNode = DtlCreateSizedNode( sizeof(PBPHONE), 0L );
    if (!pNode)
    {
        return NULL;
    }

    pPhone = (PBPHONE* )DtlGetData( pNode );
    ASSERT( pPhone );

    GetCountryCodeAndID( pPhone );

    pPhone->fUseDialingRules = FALSE;

    return pNode;
}


DTLNODE*
CreatePortNode(
    void )

    // Allocates a sized port node and fills it with default values.
    //
    // Returns the address of the allocated node if successful, NULL
    // otherwise.  It's the caller's responsibility to free the block.
    //
{
    DTLNODE* pdtlnode;
    PBPORT* ppbport;

    TRACE( "CreatePortNode" );

    pdtlnode = DtlCreateSizedNode( sizeof(PBPORT), 0L );
    if (!pdtlnode)
    {
        return NULL;
    }

    ppbport = (PBPORT* )DtlGetData( pdtlnode );
    ASSERT( ppbport );

    CopyToPbport( ppbport, NULL );

    return pdtlnode;
}

VOID
DestroyPort(
    PBPORT* pPort)
{
    Free0( pPort->pszDevice );
    Free0( pPort->pszMedia );
    Free0( pPort->pszPort );
    Free0( pPort->pszScriptBefore );

    // pmay: 228565
    // Clean up the list of available protocols
    // if any.
    //
    if ( pPort->pListProtocols )
    {
        DtlDestroyList( pPort->pListProtocols, NULL );
    }
}

VOID
DestroyEntryTypeNode(
    IN DTLNODE *pdtlnode)
{
    DtlDestroyNode(pdtlnode);
}

VOID
DestroyEntryNode(
    IN DTLNODE* pdtlnode )

    // Release all memory associated with phonebook entry node 'pdtlnode'.
    // See DtlDestroyList.
    //
{
    PBENTRY* ppbentry;

    TRACE( "DestroyEntryNode" );

    ASSERT( pdtlnode );
    ppbentry = (PBENTRY* )DtlGetData( pdtlnode );
    ASSERT( ppbentry );

    Free0( ppbentry->pszEntryName );
    Free0( ppbentry->pszPrerequisiteEntry );
    Free0( ppbentry->pszPrerequisitePbk );
    Free0( ppbentry->pszPreferredPort );
    Free0( ppbentry->pszPreferredDevice );

    Free0( ppbentry->pCustomAuthData );

    Free0( ppbentry->pszScriptAfter );
    Free0( ppbentry->pszX25Network );
    Free0( ppbentry->pszX25Address );
    Free0( ppbentry->pszX25UserData );
    Free0( ppbentry->pszX25Facilities );

    Free0( ppbentry->pszIpAddress );
    Free0( ppbentry->pszIpDnsAddress );
    Free0( ppbentry->pszIpDns2Address );
    Free0( ppbentry->pszIpWinsAddress );
    Free0( ppbentry->pszIpWins2Address );
    Free0( ppbentry->pszIpDnsSuffix );

    Free0( ppbentry->pszCustomDialDll );
    Free0( ppbentry->pszCustomDialFunc );
    Free0( ppbentry->pszCustomDialerName);

    Free0( ppbentry->pszOldUser );
    Free0( ppbentry->pszOldDomain );

    Free0( ppbentry->pGuid );

    DtlDestroyList( ppbentry->pdtllistLinks, DestroyLinkNode );
    DtlDestroyList( ppbentry->pdtllistNetComponents, DestroyKvNode );

    DtlDestroyNode( pdtlnode );
}


VOID
DestroyLinkNode(
    IN DTLNODE* pdtlnode )

    // Release all memory associated with phonebook entry link node
    // 'pdtlnode'.  See DtlDestroyList.
    //
{
    PBLINK* ppblink;

    TRACE( "DestroyLinkNode" );

    ASSERT( pdtlnode );
    ppblink = (PBLINK* )DtlGetData( pdtlnode );
    ASSERT( ppblink );

    DestroyPort(&(ppblink->pbport));
    Free0( ppblink->pTapiBlob );
    DtlDestroyList( ppblink->pdtllistPhones, DestroyPhoneNode );

    DtlDestroyNode( pdtlnode );
}


VOID
DestroyPhoneNode(
    IN DTLNODE* pdtlnode )

    // Release memory associated with PBPHONE node 'pdtlnode'.  See
    // DtlDestroyList.
    //
{
    PBPHONE* pPhone;

    TRACE( "DestroyPhoneNode" );

    ASSERT( pdtlnode );
    pPhone = (PBPHONE* )DtlGetData( pdtlnode );
    ASSERT( pPhone );

    Free0( pPhone->pszAreaCode );
    Free0( pPhone->pszPhoneNumber );
    Free0( pPhone->pszComment );

    DtlDestroyNode( pdtlnode );
}

VOID
DestroyPortNode(
    IN DTLNODE* pdtlnode )

    // Release memory associated with PBPORT node 'pdtlnode'.  See
    // DtlDestroyList.
    //
{
    PBPORT* pPort;

    TRACE( "DestroyPortNode" );

    ASSERT( pdtlnode );
    pPort = (PBPORT* )DtlGetData( pdtlnode );
    ASSERT( pPort );

    DestroyPort(pPort);

    DtlDestroyNode( pdtlnode );
}


DTLNODE*
DuplicateEntryNode(
    DTLNODE* pdtlnodeSrc )

    // Duplicates phonebook entry node 'pdtlnodeSrc'.  See CloneEntryNode and
    // DtlDuplicateList.
    //
    // Returns the address of the allocated node if successful, NULL
    // otherwise.  It's the caller's responsibility to free the block.
    //
{
    DTLNODE* pdtlnodeDst;
    PBENTRY* ppbentrySrc;
    PBENTRY* ppbentryDst;
    BOOL fDone;

    TRACE( "DuplicateEntryNode" );

    pdtlnodeDst = DtlCreateSizedNode( sizeof(PBENTRY), 0L );
    if (!pdtlnodeDst)
    {
        return NULL;
    }

    ppbentrySrc = (PBENTRY* )DtlGetData( pdtlnodeSrc );
    ppbentryDst = (PBENTRY* )DtlGetData( pdtlnodeDst );
    fDone = FALSE;

    CopyMemory( ppbentryDst, ppbentrySrc, sizeof(PBENTRY) );

    ppbentryDst->pszEntryName = NULL;
    ppbentryDst->pdtllistLinks = NULL;
    ppbentryDst->pszPrerequisiteEntry = NULL;
    ppbentryDst->pszPrerequisitePbk = NULL;
    ppbentryDst->pszPreferredPort = NULL;
    ppbentryDst->pszPreferredDevice = NULL;

    //For .Net 639551   Add preferred info for Modem settings
    ppbentryDst->dwPreferredBps    = 0;
    ppbentryDst->fPreferredHwFlow  = 0;
    ppbentryDst->fPreferredEc      = 0;
    ppbentryDst->fPreferredEcc     = 0;
    ppbentryDst->fPreferredSpeaker = 0;
    
    ppbentryDst->dwPreferredModemProtocol = 0;

    ppbentryDst->pCustomAuthData = NULL;

    ppbentryDst->pszScriptAfter = NULL;
    ppbentryDst->pszX25Network = NULL;
    ppbentryDst->pszX25Address = NULL;
    ppbentryDst->pszX25UserData = NULL;
    ppbentryDst->pszX25Facilities = NULL;

    ppbentryDst->pdtllistNetComponents = NULL;

    ppbentryDst->pszIpAddress = NULL;
    ppbentryDst->pszIpDnsAddress = NULL;
    ppbentryDst->pszIpDns2Address = NULL;
    ppbentryDst->pszIpWinsAddress = NULL;
    ppbentryDst->pszIpWins2Address = NULL;
    ppbentryDst->pszIpDnsSuffix = NULL;

    ppbentryDst->pszCustomDialDll = NULL;
    ppbentryDst->pszCustomDialFunc = NULL;
    ppbentryDst->pszCustomDialerName = NULL;

    ppbentryDst->pGuid = NULL;

    ppbentryDst->pszOldUser = NULL;
    ppbentryDst->pszOldDomain = NULL;

    do
    {
        // Duplicate strings.
        //
        if (ppbentrySrc->pszEntryName
            && (!(ppbentryDst->pszEntryName =
                    StrDup( ppbentrySrc->pszEntryName ))))
        {
            break;
        }

        if (ppbentrySrc->pszPrerequisiteEntry
            && (!(ppbentryDst->pszPrerequisiteEntry =
                    StrDup( ppbentrySrc->pszPrerequisiteEntry ))))
        {
            break;
        }

        if (ppbentrySrc->pszPrerequisitePbk
            && (!(ppbentryDst->pszPrerequisitePbk =
                    StrDup( ppbentrySrc->pszPrerequisitePbk ))))
        {
            break;
        }

        if (ppbentrySrc->pszPreferredPort
            && (!(ppbentryDst->pszPreferredPort =
                    StrDup( ppbentrySrc->pszPreferredPort ))))
        {
            break;
        }

        ppbentryDst->dwPreferredModemProtocol =
            ppbentrySrc->dwPreferredModemProtocol;

        //For .Net 639551   Add preferred info for Modem settings
        ppbentryDst->dwPreferredBps    = ppbentrySrc->dwPreferredBps;
        ppbentryDst->fPreferredHwFlow  = ppbentrySrc->fPreferredHwFlow;
        ppbentryDst->fPreferredEc      = ppbentrySrc->fPreferredEc;
        ppbentryDst->fPreferredEcc     = ppbentrySrc->fPreferredEcc ;
        ppbentryDst->fPreferredSpeaker = ppbentrySrc->fPreferredSpeaker;
        
        if (ppbentrySrc->pszPreferredDevice
            && (!(ppbentryDst->pszPreferredDevice =
                    StrDup( ppbentrySrc->pszPreferredDevice ))))
        {
            break;
        }

        if (ppbentrySrc->cbCustomAuthData && ppbentrySrc->pCustomAuthData)
        {
            ppbentryDst->pCustomAuthData = Malloc( ppbentrySrc->cbCustomAuthData );
            if (!ppbentryDst->pCustomAuthData)
            {
                break;
            }
            CopyMemory( ppbentryDst->pCustomAuthData,
                        ppbentrySrc->pCustomAuthData,
                        ppbentrySrc->cbCustomAuthData);
            ppbentryDst->cbCustomAuthData = ppbentrySrc->cbCustomAuthData;
        }

        if (ppbentrySrc->pszIpAddress
            && (!(ppbentryDst->pszIpAddress =
                    StrDup( ppbentrySrc->pszIpAddress ))))
        {
            break;
        }

        if (ppbentrySrc->pszIpDnsAddress
            && (!(ppbentryDst->pszIpDnsAddress =
                    StrDup( ppbentrySrc->pszIpDnsAddress ))))
        {
            break;
        }

        if (ppbentrySrc->pszIpDns2Address
            && (!(ppbentryDst->pszIpDns2Address =
                    StrDup( ppbentrySrc->pszIpDns2Address ))))
        {
            break;
        }

        if (ppbentrySrc->pszIpWinsAddress
            && (!(ppbentryDst->pszIpWinsAddress =
                    StrDup( ppbentrySrc->pszIpWinsAddress ))))
        {
            break;
        }

        if (ppbentrySrc->pszIpWins2Address
            && (!(ppbentryDst->pszIpWins2Address =
                    StrDup( ppbentrySrc->pszIpWins2Address ))))
        {
            break;
        }

        if (ppbentrySrc->pszIpDnsSuffix
            && (!(ppbentryDst->pszIpDnsSuffix =
                    StrDup( ppbentrySrc->pszIpDnsSuffix ))))
        {
            break;
        }

        if (ppbentrySrc->pszScriptAfter
            && (!(ppbentryDst->pszScriptAfter =
                    StrDup( ppbentrySrc->pszScriptAfter ))))
        {
            break;
        }

        if (ppbentrySrc->pszX25Network
            && (!(ppbentryDst->pszX25Network =
                    StrDup( ppbentrySrc->pszX25Network ))))
        {
            break;
        }

        if (ppbentrySrc->pszX25Address
            && (!(ppbentryDst->pszX25Address =
                    StrDup( ppbentrySrc->pszX25Address ))))
        {
            break;
        }

        if (ppbentrySrc->pszX25UserData
            && (!(ppbentryDst->pszX25UserData =
                    StrDup( ppbentrySrc->pszX25UserData ))))
        {
            break;
        }

        if (ppbentrySrc->pszX25Facilities
            && (!(ppbentryDst->pszX25Facilities =
                    StrDup( ppbentrySrc->pszX25Facilities ))))
        {
            break;
        }

        if (ppbentrySrc->pszCustomDialDll
            && (!(ppbentryDst->pszCustomDialDll =
                    StrDup( ppbentrySrc->pszCustomDialDll ))))
        {
            break;
        }

        if (ppbentrySrc->pszCustomDialFunc
            && (!(ppbentryDst->pszCustomDialFunc =
                    StrDup( ppbentrySrc->pszCustomDialFunc ))))
        {
            break;
        }

        if (ppbentrySrc->pszCustomDialerName
            && (!(ppbentryDst->pszCustomDialerName =
                    StrDup( ppbentrySrc->pszCustomDialerName))))
        {
            break;
        }

        if (ppbentrySrc->pszOldUser
            && (!(ppbentryDst->pszOldUser =
                    StrDup( ppbentrySrc->pszOldUser ))))
        {
            break;
        }

        if (ppbentrySrc->pszOldDomain
            && (!(ppbentryDst->pszOldDomain =
                    StrDup( ppbentrySrc->pszOldDomain ))))
        {
            break;
        }

        // Duplicate GUID.
        //
        if (ppbentrySrc->pGuid)
        {
            ppbentryDst->pGuid = Malloc( sizeof( GUID ) );
            if (!ppbentryDst->pGuid)
            {
                break;
            }

            *ppbentryDst->pGuid = *ppbentrySrc->pGuid;
        }

        // Duplicate net component list information.
        //
        if (ppbentrySrc->pdtllistNetComponents
            && (!(ppbentryDst->pdtllistNetComponents =
                    DtlDuplicateList(
                        ppbentrySrc->pdtllistNetComponents,
                        DuplicateKvNode,
                        DestroyKvNode ))))
        {
            break;
        }

        // Duplicate list of link information.
        //
        if (ppbentrySrc->pdtllistLinks
            && (!(ppbentryDst->pdtllistLinks =
                    DtlDuplicateList(
                        ppbentrySrc->pdtllistLinks,
                        DuplicateLinkNode,
                        DestroyLinkNode ))))
        {
            break;
        }

        fDone = TRUE;
    }
    while (FALSE);

    if (!fDone)
    {
        DestroyEntryNode( pdtlnodeDst );
        return NULL;
    }

    // Since the copy is "new" it is inherently dirty relative to the
    // phonebook file.
    //
    ppbentryDst->fDirty = TRUE;

    return pdtlnodeDst;
}


DTLNODE*
DuplicateLinkNode(
    IN DTLNODE* pdtlnodeSrc )

    // Duplicates phonebook entry link node 'pdtlnodeSrc'.  See
    // DtlDuplicateList.
    //
    // Returns the address of the allocated node if successful, NULL
    // otherwise.  It's the caller's responsibility to free the block.
    //
{
    DTLNODE* pdtlnodeDst;
    PBLINK* ppblinkSrc;
    PBLINK* ppblinkDst;
    BOOL fDone;

    TRACE( "DuplicateLinkNode" );

    pdtlnodeDst = DtlCreateSizedNode( sizeof(PBLINK), 0L );
    if (!pdtlnodeDst)
    {
        return NULL;
    }

    ppblinkSrc = (PBLINK* )DtlGetData( pdtlnodeSrc );
    ppblinkDst = (PBLINK* )DtlGetData( pdtlnodeDst );
    fDone = FALSE;

    CopyMemory( ppblinkDst, ppblinkSrc, sizeof(PBLINK) );

    ppblinkDst->pbport.pszDevice = NULL;
    ppblinkDst->pbport.pszMedia = NULL;
    ppblinkDst->pbport.pszPort = NULL;
    ppblinkDst->pbport.pszScriptBefore = NULL;
    ppblinkDst->pbport.pListProtocols = NULL;
    ppblinkDst->pTapiBlob = NULL;
    ppblinkDst->pdtllistPhones = NULL;

    do
    {
        // Duplicate strings.
        //
        if (ppblinkSrc->pbport.pszDevice
            && (!(ppblinkDst->pbport.pszDevice =
                    StrDup( ppblinkSrc->pbport.pszDevice ))))
        {
            break;
        }

        if (ppblinkSrc->pbport.pszMedia
            && (!(ppblinkDst->pbport.pszMedia =
                    StrDup( ppblinkSrc->pbport.pszMedia ))))
        {
            break;
        }


        if (ppblinkSrc->pbport.pszPort
            && (!(ppblinkDst->pbport.pszPort =
                    StrDup( ppblinkSrc->pbport.pszPort ))))
        {
            break;
        }

        if (ppblinkSrc->pbport.pszScriptBefore
            && (!(ppblinkDst->pbport.pszScriptBefore =
                    StrDup( ppblinkSrc->pbport.pszScriptBefore ))))
        {
            break;
        }

        // Duplicate TAPI blob.
        //
        if (ppblinkSrc->pTapiBlob)
        {
            VOID* pTapiBlobDst;

            ppblinkDst->pTapiBlob = (VOID* )Malloc( ppblinkSrc->cbTapiBlob );
            if (!ppblinkDst->pTapiBlob)
                break;

            CopyMemory( ppblinkDst->pTapiBlob, ppblinkSrc->pTapiBlob,
                ppblinkSrc->cbTapiBlob );
        }

        // Duplicate list of phone numbers.
        //
        if (ppblinkSrc->pdtllistPhones
            &&  (!(ppblinkDst->pdtllistPhones =
                     DtlDuplicateList(
                         ppblinkSrc->pdtllistPhones,
                         DuplicatePhoneNode,
                         DestroyPhoneNode ))))
        {
            break;
        }

        //For whistler bug 398438       gangz
        //If the pListProtocls is not duplicated, then in EuFree() which calls 
        // DestoryEntryNode() to free EINFO->pNode, ClosePhonebookFile() to 
        // free EINFO->pFile, both of them will eventually free this 
        // pListProtocols, then an AV will occur.
        //
        if (ppblinkSrc->pbport.pListProtocols
            && ( !(ppblinkDst->pbport.pListProtocols =
                    DtlDuplicateList(
                        ppblinkSrc->pbport.pListProtocols,
                        DuplicateProtocolNode,
                        DestroyProtocolNode))))
        {
            break;
        }
        
        fDone = TRUE;
    }
    while (FALSE);

    if (!fDone)
    {
        DestroyLinkNode( pdtlnodeDst );
        return NULL;
    }

    return pdtlnodeDst;
}

//For whistler bug 398438       gangz
//
DTLNODE*
DuplicateProtocolNode(
    IN DTLNODE* pdtlnodeSrc )
{
    DTLNODE* pdtlnodeDst = NULL;
    BOOL fDone = FALSE;
    PVOID pNameSrc = NULL;

    TRACE( "DuplicateProtocolNode" );

    pdtlnodeDst = DtlCreateSizedNode( sizeof(DTLNODE), 0L );
    if ( !pdtlnodeDst )
    {
        return NULL;
    }

    do
    {
        pNameSrc = DtlGetData( pdtlnodeSrc );
        if(pNameSrc
            && ( !(pdtlnodeDst->pData = StrDup(pNameSrc) ))
            )
        {
            break;
        }

        pdtlnodeDst->lNodeId = pdtlnodeSrc->lNodeId;
        
        fDone = TRUE;   
    }
    while(FALSE);

    if (!fDone)
    {
        DestroyProtocolNode(pdtlnodeDst);
        return NULL;
    }

    return pdtlnodeDst;
}

VOID
DestroyProtocolNode(
    IN DTLNODE* pdtlnode )

    // Release memory associated with PBPHONE node 'pdtlnode'.  See
    // DtlDestroyList.
    //
{
    TRACE( "DestroyProtocolNode" );

    DtlDestroyNode( pdtlnode );
}


DTLNODE*
DuplicatePhoneNode(
    IN DTLNODE* pdtlnodeSrc )

    // Duplicates phone number set node 'pdtlnodeSrc'.  See DtlDuplicateList.
    //
    // Returns the address of the allocated node if successful, NULL
    // otherwise.  It's the caller's responsibility to free the block.
    //
{
    DTLNODE* pdtlnodeDst;
    PBPHONE* pPhoneSrc;
    PBPHONE* pPhoneDst;
    BOOL fDone;

    TRACE( "DuplicatePhoneNode" );

    pdtlnodeDst = DtlCreateSizedNode( sizeof(PBPHONE), 0L );
    if (!pdtlnodeDst)
    {
        return NULL;
    }

    pPhoneSrc = (PBPHONE* )DtlGetData( pdtlnodeSrc );
    pPhoneDst = (PBPHONE* )DtlGetData( pdtlnodeDst );
    fDone = FALSE;

    CopyMemory( pPhoneDst, pPhoneSrc, sizeof(PBPHONE) );

    pPhoneDst->pszPhoneNumber = NULL;
    pPhoneDst->pszAreaCode = NULL;
    pPhoneDst->pszComment = NULL;

    do
    {
        // Duplicate strings.
        //
        if (pPhoneSrc->pszPhoneNumber
            && (!(pPhoneDst->pszPhoneNumber =
                    StrDup( pPhoneSrc->pszPhoneNumber ))))
        {
            break;
        }

        if (pPhoneSrc->pszAreaCode
            && (!(pPhoneDst->pszAreaCode =
                    StrDup( pPhoneSrc->pszAreaCode ))))
        {
            break;
        }

        if (pPhoneSrc->pszComment
            && (!(pPhoneDst->pszComment =
                    StrDup( pPhoneSrc->pszComment ))))
        {
            break;
        }

        fDone = TRUE;
    }
    while (FALSE);

    if (!fDone)
    {
        DestroyPhoneNode( pdtlnodeDst );
        return NULL;
    }

    return pdtlnodeDst;
}


VOID
EnableOrDisableNetComponent(
    IN PBENTRY* pEntry,
    IN LPCTSTR  pszComponent,
    IN BOOL     fEnable)
{
    KEYVALUE*   pKv;
    BOOL        fIsEnabled;

    static const TCHAR c_pszDisabledValue[] = TEXT("0");
    static const TCHAR c_pszEnabledValue [] = TEXT("1");

    ASSERT (pEntry);
    ASSERT (pszComponent);

    // If the component already exists in the list, update its value.
    //
    if (FIsNetComponentListed (pEntry, pszComponent, &fIsEnabled, &pKv))
    {
        LPCTSTR pszNewValue = NULL;

        // If we need to change the value, do so, otherwise, we don't have
        // any work to do.  (Use a logical XOR here instead of == because
        // there are many values of TRUE.
        //
        if (fEnable && !fIsEnabled)
        {
            pszNewValue = c_pszEnabledValue;
        }
        else if (!fEnable && fIsEnabled)
        {
            pszNewValue = c_pszDisabledValue;
        }

        if (pszNewValue)
        {
            Free0 (pKv->pszValue);
            pKv->pszValue = StrDup(pszNewValue);
        }
    }

    // If the component does not exist in the list, we need to add it.
    //
    else
    {
        LPCTSTR     pszValue;
        DTLNODE*    pdtlnode;

        pszValue = (fEnable) ? c_pszEnabledValue : c_pszDisabledValue;
        pdtlnode = CreateKvNode (pszComponent, pszValue);
        if (pdtlnode)
        {
            ASSERT( DtlGetData(pdtlnode) );
            DtlAddNodeLast (pEntry->pdtllistNetComponents, pdtlnode);
        }
    }
}


BOOL
FIsNetComponentListed(
    IN PBENTRY*     pEntry,
    IN LPCTSTR      pszComponent,
    OUT BOOL*       pfEnabled,
    OUT KEYVALUE**  ppKv)

    // Returns TRUE if the pszComponent exists as the key of the NETCOMPONENTs
    // KEYVALUE pairs in pEntry.  If TRUE is returned, *pfEnabled is the
    // BOOL form of the value part of the pair.  This represents whether the
    // component is 'checked' in the property UI on the networking page.
    // ppKv is an optional output parameter.  If ppKv is specfied, and the
    // function returns TRUE, it will point to the KEYVALUE in the DTLLIST
    // of NETCOMPONENTS.
{
    DTLNODE*    pdtlnode;
    BOOL        fPresent = FALSE;

    ASSERT (pEntry);
    ASSERT (pEntry->pdtllistNetComponents);
    ASSERT (pszComponent);
    ASSERT (pfEnabled);

    // Initialize the output parameters.
    //
    *pfEnabled = FALSE;
    if (ppKv)
    {
        *ppKv = NULL;
    }

    // Look for pszComponent in the list.
    //
    for (pdtlnode = DtlGetFirstNode (pEntry->pdtllistNetComponents);
         pdtlnode;
         pdtlnode = DtlGetNextNode (pdtlnode))
    {
        KEYVALUE* pKv = (KEYVALUE* )DtlGetData (pdtlnode);
        ASSERT (pKv);

        if (0 == lstrcmp(pszComponent, pKv->pszKey))
        {
            // If we found the component, get its value (as a BOOL)
            // and return the KEYVALUE pointer if requested.
            //
            LONG lValue = _ttol (pKv->pszValue);
            *pfEnabled = !!lValue;

            fPresent = TRUE;

            if (ppKv)
            {
                *ppKv = pKv;
            }

            break;
        }
    }

    return fPresent;
}


DTLNODE*
EntryNodeFromName(
    IN DTLLIST* pdtllistEntries,
    IN LPCTSTR pszName )

    // Returns the address of the node in the global phonebook entries list
    // whose Entry Name matches 'pszName' or NULL if none.
    //
{
    DTLNODE* pdtlnode;

    for (pdtlnode = DtlGetFirstNode( pdtllistEntries );
         pdtlnode;
         pdtlnode = DtlGetNextNode( pdtlnode ))
    {
        PBENTRY* ppbentry = (PBENTRY* )DtlGetData( pdtlnode );

        if (lstrcmpi( ppbentry->pszEntryName, pszName ) == 0)
        {
            return pdtlnode;
        }
    }

    return NULL;
}


DWORD
EntryTypeFromPbport(
    IN PBPORT* ppbport )

    // Returns the RASET_* entry type associated with the 'ppbport' port type.
    //
{
    DWORD dwType;

    // Default is phone type
    //
    dwType = RASET_Phone;

    if ((ppbport->pbdevicetype == PBDT_Null)      ||
        (ppbport->dwFlags & PBP_F_NullModem)      ||
        (ppbport->pbdevicetype == PBDT_Irda)      ||
        (ppbport->pbdevicetype == PBDT_Parallel))
    {
        dwType = RASET_Direct;
    }
    else if (ppbport->pbdevicetype == PBDT_Vpn)
    {
        dwType = RASET_Vpn;
    }
    else if (ppbport->pbdevicetype == PBDT_PPPoE)
    {
        dwType = RASET_Broadband;
    }
    else if (ppbport->pszPort)
    {
        TCHAR achPort[ 3 + 1 ];

        lstrcpyn( achPort, ppbport->pszPort, 3 + 1 );

        if (lstrcmp( achPort, TEXT("VPN") ) == 0)
        {
            dwType = RASET_Vpn;
        }
    }

    return dwType;
}


DWORD
GetOverridableParam(
    IN PBUSER* pUser,
    IN PBENTRY* pEntry,
    IN DWORD dwfRasorBit )

    // Return the value of the parameter identified by RASOR_* the single bit
    // in bitmask 'dwfRasorBit', retrieving the value from the 'pUser' or
    // 'pEntry' based on the override mask in 'pEntry'.
    //
{
    switch (dwfRasorBit)
    {
        case RASOR_RedialAttempts:
        {
            if (pEntry->dwfOverridePref & RASOR_RedialAttempts)
            {
                return pEntry->dwRedialAttempts;
            }
            else
            {
                return pUser->dwRedialAttempts;
            }
        }

        case RASOR_RedialSeconds:
        {
            if (pEntry->dwfOverridePref & RASOR_RedialSeconds)
            {
                return pEntry->dwRedialSeconds;
            }
            else
            {
                return pUser->dwRedialSeconds;
            }
        }

        case RASOR_IdleDisconnectSeconds:
        {
            if (pEntry->dwfOverridePref & RASOR_IdleDisconnectSeconds)
            {
                return (DWORD )pEntry->lIdleDisconnectSeconds;
            }
            else
            {
                return pUser->dwIdleDisconnectSeconds;
            }
        }

        case RASOR_RedialOnLinkFailure:
        {
            if (pEntry->dwfOverridePref & RASOR_RedialOnLinkFailure)
            {
                return pEntry->fRedialOnLinkFailure;
            }
            else
            {
                return pUser->fRedialOnLinkFailure;
            }
        }

        case RASOR_PopupOnTopWhenRedialing:
        {
            if (pEntry->dwfOverridePref & RASOR_PopupOnTopWhenRedialing)
            {
#if 0
                return pEntry->fPopupOnTopWhenRedialing;
#else
                return (DWORD )TRUE;
#endif
            }
            else
            {
                return pUser->fPopupOnTopWhenRedialing;
            }
        }

        case RASOR_CallbackMode:
        {
            if (pEntry->dwfOverridePref & RASOR_CallbackMode)
            {
                return pEntry->dwCallbackMode;
            }
            else
            {
                return pUser->dwCallbackMode;
            }
        }
    }

    return 0;
}

DWORD
PbkPathInfoInit(
    IN PbkPathInfo* pInfo)
{
    DWORD dwErr = NO_ERROR;
    
    ZeroMemory(pInfo, sizeof(PbkPathInfo));

    //Add try...except blocck for bug 763057
    __try
    {
        InitializeCriticalSection(&(pInfo->csLock));
     }
     __except(EXCEPTION_EXECUTE_HANDLER)
     {
        
        dwErr = ERROR_NOT_ENOUGH_MEMORY;
     }

    return dwErr;
}
    
DWORD
PbkPathInfoReset(
    OUT PbkPathInfo* pInfo)
{
    if (pInfo)
    {
        if (pInfo->hSwapiDll)
        {
            FreeLibrary(pInfo->hSwapiDll);
        }
        Free0(pInfo->pszAllUsers);
        Free0(pInfo->pszSysRas);

        pInfo->fLoaded = FALSE;
        pInfo->hSwapiDll = NULL;
        pInfo->pPathCanonicalize = NULL;
        pInfo->pPathRemoveFileSpec = NULL;
        pInfo->pszAllUsers = NULL;
        pInfo->pszSysRas = NULL;
    }

    return NO_ERROR;
}

DWORD
PbkPathInfoLoad(
    OUT PbkPathInfo* pInfo)
{
    DWORD dwErr = NO_ERROR;
    BOOL fOk;
    TCHAR* pszTemp = NULL;
    
    EnterCriticalSection(&pInfo->csLock);
    
    do
    {
        if (pInfo->fLoaded)
        {
            dwErr = NO_ERROR;
            break;
        }

        pInfo->pszAllUsers = Malloc( (MAX_PATH + 1) * sizeof(TCHAR) );
        pInfo->pszSysRas = Malloc( (MAX_PATH + 1) * sizeof(TCHAR) );
        pszTemp = Malloc( (MAX_PATH + 1) * sizeof(TCHAR) );
        if ((!pInfo->pszAllUsers) || (!pInfo->pszSysRas) || (!pszTemp))
        {
            dwErr = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }
        
        pInfo->hSwapiDll= LoadLibrary(TEXT("shlwapi.dll"));
        if (pInfo->hSwapiDll == NULL)
        {
            dwErr = GetLastError();
            break;
        }
        
        pInfo->pPathCanonicalize = 
            GetProcAddress(pInfo->hSwapiDll, SZ_PathCanonicalize);
            
        pInfo->pPathRemoveFileSpec = 
            GetProcAddress(pInfo->hSwapiDll, SZ_PathRemoveFileSpec);

        fOk = GetPhonebookDirectory(PBM_System, pszTemp);
        if (!fOk)
        {
            dwErr = ERROR_CAN_NOT_COMPLETE;
            break;
        }
       
        // Canonicalize the path and remove any trailing \
        //
        pInfo->pPathCanonicalize(pInfo->pszAllUsers, pszTemp);
        if(TEXT('\\') == *(pInfo->pszAllUsers + lstrlen(pInfo->pszAllUsers) - 1))
        {
            *(pInfo->pszAllUsers + lstrlen(pInfo->pszAllUsers) - 1) = TEXT('\0');
        }

        fOk = GetSystemWindowsDirectory(
                pInfo->pszSysRas, 
                MAX_PATH - S_SYSRASDIR_LENGTH); 
        if (!fOk)
        {
            dwErr = ERROR_CAN_NOT_COMPLETE;
            break;
        }
        lstrcat(pInfo->pszSysRas, S_SYSRASDIR);
        
        pInfo->fLoaded = TRUE;
    
    } while (FALSE);

    // Cleanup
    //
    {
        if (dwErr != NO_ERROR)
        {
            PbkPathInfoReset(pInfo);
        }
        Free0(pszTemp);
    }

    LeaveCriticalSection(&pInfo->csLock);

    return dwErr;
}

DWORD
PbkPathInfoClear(
    OUT PbkPathInfo* pInfo)
{
    PbkPathInfoReset(pInfo);
    DeleteCriticalSection(&(pInfo->csLock));
    ZeroMemory(pInfo, sizeof(PbkPathInfo));

    return NO_ERROR;
}

BOOL
IsPublicPhonebook(
    IN LPCTSTR pszPhonebookPath )

    // Returns TRUE if the given phonebook is in the 'All Users' directory
    // and hence is a shared phonebook; returns FALSE otherwise
    //
{
    BOOL bPublic = FALSE;
    TCHAR* pszPhonebook = NULL;
    DWORD dwErr = NO_ERROR;

    do
    {
        pszPhonebook = Malloc( (MAX_PATH + 1) * sizeof(TCHAR) );
        if ( !pszPhonebook ) 
        { 
            break; 
        }

        dwErr = PbkPathInfoLoad(&g_PbkPathInfo);
        if (dwErr != NO_ERROR)
        {
            TRACE1(
                "IsPublicPhonebook: Unable to load pbk path info %x", 
                dwErr);
            break;                
        }

        g_PbkPathInfo.pPathCanonicalize(pszPhonebook, pszPhonebookPath);
        g_PbkPathInfo.pPathRemoveFileSpec(pszPhonebook);

        if (!lstrcmpi(pszPhonebook, g_PbkPathInfo.pszAllUsers))
        {
            bPublic = TRUE;
        }
        else
        {
            bPublic = (lstrcmpi(pszPhonebook, g_PbkPathInfo.pszSysRas) == 0);
        }

    } while ( FALSE );

    // Clean up
    //
    Free0 ( pszPhonebook );

    TRACE1( "IsPublicPhonebook=%u", bPublic);
    
    return bPublic;
}

DWORD
LoadPadsList(
    OUT DTLLIST** ppdtllistPads )

    // Build a list of all X.25 PAD devices in '*ppdtllistPads'.
    //
    // Returns 0 if successful, otherwise a non-zero error code.  It is
    // caller's responsibility to DtlDestroyList the list when done.
    //
{
    INT i;
    DWORD dwErr;
    RASMAN_DEVICE* pDevices;
    DWORD dwDevices;

    TRACE( "LoadPadsList" );

    *ppdtllistPads = NULL;

    dwErr = GetRasPads( &pDevices, &dwDevices );
    if (dwErr != 0)
    {
        return dwErr;
    }

    *ppdtllistPads = DtlCreateList( 0L );
    if (!*ppdtllistPads)
    {
        Free( pDevices );
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    qsort( (VOID* )pDevices, (size_t )dwDevices, sizeof(RASMAN_DEVICE),
           CompareDevices );

    for (i = 0; i < (INT )dwDevices; ++i)
    {
        TCHAR* pszDup;

        pszDup = StrDupTFromA( pDevices[ i ].D_Name );
        dwErr = AppendStringToList( *ppdtllistPads, pszDup );
        Free0( pszDup );

        if (dwErr != 0)
        {
            Free( pDevices );
            DtlDestroyList( *ppdtllistPads, NULL );
            *ppdtllistPads = NULL;
            return dwErr;
        }
    }

    Free( pDevices );

    TRACE( "LoadPadsList=0" );
    return 0;
}


DWORD
LoadPortsList(
    OUT DTLLIST** ppdtllistPorts )

    // Build a sorted list of all RAS ports in '*ppdtllistPorts'.
    //
    // Returns 0 if successful, otherwise a non-zero error code.  It is
    // caller's responsibility to DtlDestroyList the list when done.
    //
{
    return LoadPortsList2( NULL, ppdtllistPorts, FALSE );
}


DWORD
LoadPortsList2(
    IN  HANDLE hConnection,
    OUT DTLLIST** ppdtllistPorts,
    IN  BOOL fRouter)

    // Build a sorted list of all RAS ports in '*ppdtllistPorts'.  'FRouter'
    // indicates only ports with "router" usage should be returned.
    // Otherwise, only dialout ports are returned.
    //
    // Returns 0 if successful, otherwise a non-zero error code.  It is
    // caller's responsibility to DtlDestroyList the list when done.
    //
{
    INT i;
    DWORD dwErr;
    RASMAN_PORT* pPorts;
    RASMAN_PORT* pPort;
    DWORD dwPorts;

    TRACE( "LoadPortsList2" );

    *ppdtllistPorts = NULL;

    dwErr = GetRasPorts( hConnection, &pPorts, &dwPorts );
    if (dwErr != 0)
    {
        return dwErr;
    }

    *ppdtllistPorts = DtlCreateList( 0L );
    if (!*ppdtllistPorts)
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    qsort( (VOID* )pPorts, (size_t )dwPorts, sizeof(RASMAN_PORT),
           ComparePorts );

    for (i = 0, pPort = pPorts; i < (INT )dwPorts; ++i, ++pPort)
    {
        if (fRouter)
        {
            // We're only interested in router ports.
            //
            //Add this CALL_OUTBOUND_ROUTER for bug 349087 345068
            //
            if (!(pPort->P_ConfiguredUsage & CALL_ROUTER) &&
                !(pPort->P_ConfiguredUsage &CALL_OUTBOUND_ROUTER) 
                )
            {
                continue;
            }
        }
        else
        {
            // We're only interested in ports you can dial-out on.
            //
            if (!(pPort->P_ConfiguredUsage & CALL_OUT))
            {
                continue;
            }
        }

        dwErr = AppendPbportToList( hConnection, *ppdtllistPorts, pPort );
        if (dwErr != 0)
        {
            Free( pPorts );
            DtlDestroyList( *ppdtllistPorts, NULL );
            *ppdtllistPorts = NULL;
            return dwErr;
        }
    }

    Free( pPorts );

    TRACE( "LoadPortsList=0" );
    return 0;
}


DWORD
LoadScriptsList(
    HANDLE  hConnection,
    OUT DTLLIST** ppdtllistScripts )

    // Build a sorted list of all RAS switch devices in '*ppdtllistPorts'.
    //
    // Returns 0 if successful, otherwise a non-zero error code.  It is
    // caller's responsibility to DtlDestroyList the list when done.
    //
{
    INT i;
    DWORD dwErr;
    RASMAN_DEVICE* pDevices;
    DWORD dwDevices;

    TRACE( "LoadScriptsList" );

    *ppdtllistScripts = NULL;

    dwErr = GetRasSwitches( hConnection, &pDevices, &dwDevices );
    if (dwErr != 0)
    {
        return dwErr;
    }

    *ppdtllistScripts = DtlCreateList( 0L );
    if (!*ppdtllistScripts)
    {
        Free( pDevices );
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    qsort( (VOID* )pDevices, (size_t )dwDevices, sizeof(RASMAN_DEVICE),
           CompareDevices );

    for (i = 0; i < (INT )dwDevices; ++i)
    {
        TCHAR* pszDup;

        pszDup = StrDupTFromA( pDevices[ i ].D_Name );

        if(NULL == pszDup)
        {
            return E_OUTOFMEMORY;
        }
        
        dwErr = AppendStringToList( *ppdtllistScripts, pszDup );
        Free( pszDup );

        if (dwErr != 0)
        {
            Free( pDevices );
            DtlDestroyList( *ppdtllistScripts, NULL );
            *ppdtllistScripts = NULL;
            return dwErr;
        }
    }

    Free( pDevices );

    TRACE( "LoadScriptsList=0" );
    return 0;
}


#if 0
TCHAR*
NameFromIndex(
    IN DTLLIST* pdtllist,
    IN INT iToFind )

    // Returns the name associated with 0-based index 'iToFind' in the linked
    // list of strings, 'pdtllist', or NULL if not found.
    //
{
    DTLNODE* pdtlnode;

    if (!pdtllist)
    {
        return NULL;
    }

    pdtlnode = DtlGetFirstNode( pdtllist );

    if (iToFind < 0)
    {
        return NULL;
    }

    while (pdtlnode && iToFind--)
    {
        pdtlnode = DtlGetNextNode( pdtlnode );
    }

    return (pdtlnode) ? (TCHAR* )DtlGetData( pdtlnode ) : NULL;
}
#endif


PBDEVICETYPE
PbdevicetypeFromPszType(
    IN TCHAR* pszDeviceType )

    // Returns the device type corresponding to the device type string,
    // 'pszDeviceType'.
    //
{
    CHAR* pszA;
    PBDEVICETYPE pbdt;

    pbdt = PBDT_None;
    pszA = StrDupAFromT( pszDeviceType );
    if (pszA)
    {
        pbdt = PbdevicetypeFromPszTypeA( pszA );
        Free( pszA );
    }
    return pbdt;
}


PBDEVICETYPE
PbdevicetypeFromPszTypeA(
    IN CHAR* pszDeviceTypeA )

    // Returns the device type corresponding to the ANSI device type string,
    // 'pszDeviceType'.
    //
{
    PBDEVICETYPE pbdt;
    TCHAR *pszDeviceType = StrDupTFromA(pszDeviceTypeA);

    if(NULL == pszDeviceType)
    {
        return PBDT_None;
    }
    
    if( CSTR_EQUAL == CompareString(
            LOCALE_INVARIANT,
            NORM_IGNORECASE,
            RASDT_Modem,
            -1,
            pszDeviceType,
            -1
            )
      )
    {
        pbdt =  PBDT_Modem;
    }
    else if( CSTR_EQUAL == CompareString(
                LOCALE_INVARIANT,
                NORM_IGNORECASE,
                TEXT("null"),
                -1,
                pszDeviceType,
                -1
                )
            )
    {
        pbdt =  PBDT_Null;
    }
    else if( CSTR_EQUAL == CompareString(
                LOCALE_INVARIANT,
                NORM_IGNORECASE,
                RASDT_Parallel,
                -1,
                pszDeviceType,
                -1
                )
            )
    {
        pbdt = PBDT_Parallel;
    }
    else if( CSTR_EQUAL == CompareString(
                LOCALE_INVARIANT,
                NORM_IGNORECASE,
                RASDT_Irda,
                -1,
                pszDeviceType,
                -1
                )
            )
    {
        pbdt = PBDT_Irda;
    }
    else if( CSTR_EQUAL == CompareString(
                LOCALE_INVARIANT,
                NORM_IGNORECASE,
                RASDT_Pad,
                -1,
                pszDeviceType,
                -1
                )
            )
    {
        pbdt =  PBDT_Pad;
    }
    else if( CSTR_EQUAL == CompareString(
                LOCALE_INVARIANT,
                NORM_IGNORECASE,
                TEXT("switch"),
                -1,
                pszDeviceType,
                -1
                )
            )
    {
        pbdt =  PBDT_Switch;
    }
    else if( CSTR_EQUAL == CompareString(
                LOCALE_INVARIANT,
                NORM_IGNORECASE,
                RASDT_Isdn,
                -1,
                pszDeviceType,
                -1
                )
            )
    {
        pbdt =  PBDT_Isdn;
    }
    else if( CSTR_EQUAL == CompareString(
                LOCALE_INVARIANT,
                NORM_IGNORECASE,
                RASDT_X25,
                -1,
                pszDeviceType,
                -1
                )
            )
    {
        pbdt =  PBDT_X25;
    }
    else if( CSTR_EQUAL == CompareString(
                LOCALE_INVARIANT,
                NORM_IGNORECASE,
                RASDT_Vpn,
                -1,
                pszDeviceType,
                -1
                )
            )
    {
        pbdt =  PBDT_Vpn;
    }
    else if( CSTR_EQUAL == CompareString(
                LOCALE_INVARIANT,
                NORM_IGNORECASE,
                RASDT_Atm,
                -1,
                pszDeviceType,
                -1
                )
            )
    {
        pbdt =  PBDT_Atm;
    }
    else if( CSTR_EQUAL == CompareString(
                LOCALE_INVARIANT,
                NORM_IGNORECASE,
                RASDT_Serial,
                -1,
                pszDeviceType,
                -1
                )
            )
    {
        pbdt =  PBDT_Serial;
    }
    else if( CSTR_EQUAL == CompareString(
                LOCALE_INVARIANT,
                NORM_IGNORECASE,
                RASDT_FrameRelay,
                -1,
                pszDeviceType,
                -1
                )
            )
    {   
        pbdt =  PBDT_FrameRelay;
    }
    else if( CSTR_EQUAL == CompareString(
                LOCALE_INVARIANT,
                NORM_IGNORECASE,
                RASDT_Sonet,
                -1,
                pszDeviceType,
                -1
                )
            )
    {
        pbdt =  PBDT_Sonet;
    }
    else if( CSTR_EQUAL == CompareString(
                LOCALE_INVARIANT,
                NORM_IGNORECASE,
                RASDT_SW56,
                -1,
                pszDeviceType,
                -1
                )
            )
    {
        pbdt =  PBDT_Sw56;
    }
    else if( CSTR_EQUAL == CompareString(
                LOCALE_INVARIANT,
                NORM_IGNORECASE,
                RASDT_PPPoE,
                -1,
                pszDeviceType,
                -1
                )
            )
    {
        pbdt = PBDT_PPPoE;
    }
    else
    {
        pbdt =  PBDT_Other;
    }
    
    if(pszDeviceType)
    {
        Free(pszDeviceType);
    }

    return pbdt;
}

CHAR*
PbMedia(
    IN PBDEVICETYPE pbdt,
    IN CHAR* pszMedia )

    // The media names stored in the phonebook are not exactly the same as
    // those returned by RASMAN.  This translates a RASMAN media name to
    // equivalent phonebook media names given the device type.  The reason for
    // this is historical and obscure.
    //
{
    if (pbdt == PBDT_Isdn)
    {
        return ISDN_TXT;
    }
    else if (pbdt == PBDT_X25)
    {
        return X25_TXT;
    }
    else if (   pbdt == PBDT_Other
            ||  pbdt == PBDT_Vpn
            ||  pbdt == PBDT_Irda
            ||  pbdt == PBDT_Serial
            ||  pbdt == PBDT_Atm
            ||  pbdt == PBDT_Parallel
            ||  pbdt == PBDT_Sonet
            ||  pbdt == PBDT_Sw56
            ||  pbdt == PBDT_FrameRelay
            ||  pbdt == PBDT_PPPoE)
    {
        return pszMedia;
    }
    else
    {
        return SERIAL_TXT;
    }
}


PBPORT*
PpbportFromPortAndDeviceName(
    IN DTLLIST* pdtllistPorts,
    IN TCHAR* pszPort,
    IN TCHAR* pszDevice )

    // Return port with port name 'pszPort' and device name 'pszDevice' in
    // list of ports 'pdtllistPorts' or NULL if not found.  'PszPort' may be
    // an old-style name such as PcImacISDN1, in which case it will match
    // ISDN1.  'PszDevice' may be NULL in which case any device name is
    // assumed to match.
    //
{
    DTLNODE* pdtlnode;

    TCHAR szPort[MAX_PORT_NAME+1];

    if (!pszPort)
    {
        return NULL;
    }

    for (pdtlnode = DtlGetFirstNode( pdtllistPorts );
         pdtlnode;
         pdtlnode = DtlGetNextNode( pdtlnode ))
    {
        PBPORT* ppbport = (PBPORT* )DtlGetData( pdtlnode );

        if ((ppbport->pszPort && lstrcmp( ppbport->pszPort, pszPort ) == 0)
            && (!ppbport->pszDevice || !pszDevice
                || lstrcmp( ppbport->pszDevice, pszDevice ) == 0))
        {
            return ppbport;
        }
    }

    // No match.  Look for the old port name format.
    //
    for (pdtlnode = DtlGetFirstNode( pdtllistPorts );
         pdtlnode;
         pdtlnode = DtlGetNextNode( pdtlnode ))
    {
        TCHAR szBuf[ MAX_DEVICE_NAME + MAX_DEVICETYPE_NAME + 10 + 1 ];
        PBPORT* ppbport;

        ppbport = (PBPORT* )DtlGetData( pdtlnode );

        // Skip modems (COM ports) and unconfigured ports, since they do not
        // follow the same port name formatting rules as other ports.
        //
        if (!ppbport->pszDevice || ppbport->pbdevicetype == PBDT_Modem)
        {
            continue;
        }

        lstrcpy( szBuf, ppbport->pszDevice );
        lstrcat( szBuf, ppbport->pszPort );

        if (lstrcmp( szBuf, pszPort ) == 0)
        {
            return ppbport;
        }
    }

    return NULL;
}

PBPORT*
PpbportFromNT4PortandDevice(
    IN DTLLIST* pdtllistPorts,
    IN TCHAR* pszPort,
    IN TCHAR* pszDevice )
    // This function is called when we couldn't
    // find a port that matches the one in the
    // phonebook. This will take care of the case
    // where the port is pre-nt5 type of port. Since
    // the portnames have changed in nt5 for isdn
    // and vpn, this routine will try to find a
    // port with the same type.
{
    PBPORT *ppbport;
    PBPORT *ppbportRet = NULL;
    DTLNODE *pdtlnode;
    TCHAR   szPort[MAX_PORT_NAME+1];

    if(NULL == pszPort)
    {
        return NULL;
    }

    ZeroMemory(szPort, sizeof(szPort));

    lstrcpyn(szPort, pszPort, MAX_PORT_NAME);

    szPort[lstrlen(TEXT("VPN"))] = TEXT('\0');

    if(0 == lstrcmp(szPort, TEXT("VPN")))
    {
        for (pdtlnode = DtlGetFirstNode( pdtllistPorts );
             pdtlnode;
             pdtlnode = DtlGetNextNode( pdtlnode ))
        {
            ppbport = (PBPORT *) DtlGetData(pdtlnode);

            if(PBDT_Vpn == ppbport->pbdevicetype)
            {
                ppbportRet = ppbport;
                break;
            }
        }

        return ppbportRet;
    }

    return NULL;
}


PBPORT*
PpbportFromNullModem(
    IN DTLLIST* pdtllistPorts,
    IN TCHAR* pszPort,
    IN TCHAR* pszDevice )

    //
    // pmay: 226594
    //
    // Added this function because sometimes we just need to
    // match a given port to a null modem
    //
    // Will attempt to match the ports, but returns any
    // NULL modem it finds if it can't match ports.
    //
{
    DTLNODE* pdtlnode;
    PBPORT * pRet = NULL;

    for (pdtlnode = DtlGetFirstNode( pdtllistPorts );
         pdtlnode;
         pdtlnode = DtlGetNextNode( pdtlnode ))
    {
        PBPORT* ppbport = (PBPORT* )DtlGetData( pdtlnode );

        if ((ppbport->dwFlags & PBP_F_NullModem) && (pRet == NULL))
        {
            pRet = ppbport;
        }

        if ((ppbport->pszPort)                          &&
            (pszPort)                                   &&
            (lstrcmpi( ppbport->pszPort, pszPort ) == 0)
           )
        {
            pRet =  ppbport;
            break;
        }
    }

    return pRet;
}

BOOL
PbportTypeMatchesEntryType(
    IN PBPORT * pPort,
    IN PBENTRY* pEntry)

    // Returns whether the given port has a type that's compatible
    // with the type of the given entry.
{
    if (!pPort || !pEntry)
    {
        return TRUE;
    }

    if ( ( pEntry->dwType == RASET_Phone ) )
    {
        if ( ( pPort->pbdevicetype == PBDT_Null )      ||
             ( pPort->pbdevicetype == PBDT_Parallel )  ||
             ( pPort->pbdevicetype == PBDT_Irda )      ||
             ( pPort->dwFlags & PBP_F_NullModem )      ||
             ( pPort->pbdevicetype == PBDT_Vpn )       ||
             ( pPort->pbdevicetype == PBDT_PPPoE )
           )
        {
            return FALSE;
        }
    }

    return TRUE;
}

BOOL
SetDefaultModemSettings(
    IN PBLINK* pLink )

    // Set the MXS modem settings for link 'pLink' to the defaults.
    //
    // Returns true if something changed, false otherwise.
    //
{
    BOOL fChange;

    fChange = FALSE;

    if (pLink->fHwFlow != pLink->pbport.fHwFlowDefault)
    {
        fChange = TRUE;
        pLink->fHwFlow = pLink->pbport.fHwFlowDefault;
    }

    if (pLink->fEc != pLink->pbport.fEcDefault)
    {
        fChange = TRUE;
        pLink->fEc = pLink->pbport.fEcDefault;
    }

    if (pLink->fEcc != pLink->pbport.fEccDefault)
    {
        fChange = TRUE;
        pLink->fEcc = pLink->pbport.fEccDefault;
    }

    if (pLink->fSpeaker != pLink->pbport.fSpeakerDefault)
    {
        fChange = TRUE;
        pLink->fSpeaker = pLink->pbport.fSpeakerDefault;
    }

    if (pLink->dwBps != pLink->pbport.dwBpsDefault)
    {
        fChange = TRUE;
        pLink->dwBps = pLink->pbport.dwBpsDefault;
    }

    // For whistler bug 402522       gangz
    // Add preferred modem protocol
    // pmay: 228565
    // Add the default modem protocol
    if (pLink->dwModemProtocol != pLink->pbport.dwModemProtDefault)
    {
        fChange = TRUE;
        pLink->dwModemProtocol = pLink->pbport.dwModemProtDefault;
    }

    TRACE2( "SetDefaultModemSettings(bps=%d)=%d", pLink->dwBps, fChange );
    return fChange;
}


BOOL
ValidateAreaCode(
    IN OUT TCHAR* pszAreaCode )

    // Checks that area code consists of decimal digits only.  If the area
    // code is all white characters it is reduced to empty string.  Returns
    // true if 'pszAreaCode' is a valid area code, false if not.
    //
{
    if (IsAllWhite( pszAreaCode ))
    {
        *pszAreaCode = TEXT('\0');
        return TRUE;
    }

    if (lstrlen( pszAreaCode ) > RAS_MaxAreaCode)
    {
        return FALSE;
    }

    while (*pszAreaCode != TEXT('\0'))
    {
        if (*pszAreaCode < TEXT('0') || *pszAreaCode > TEXT('9'))
        {
            return FALSE;
        }

        ++pszAreaCode;
    }

    return TRUE;
}


BOOL
ValidateEntryName(
    IN LPCTSTR pszEntry )

    // Returns true if 'pszEntry' is a valid phonebook entry name, false if
    // not.
    //
{
    INT nLen = lstrlen( pszEntry );

    if (nLen <= 0
        || nLen > RAS_MaxEntryName
        || IsAllWhite( pszEntry )
        || pszEntry[ 0 ] == TEXT('.'))
    {
        return FALSE;
    }

    return TRUE;
}