windows-nt/Source/XPSP1/NT/net/tapi/sp/remotesp/dslookup.cpp

/*
 * Purpose: C++ API for finding the telephony
 *         servers in Active Directory
 *
 */

#ifndef UNICODE
#define UNICODE
#endif
#ifndef _UNICODE
#define _UNICODE
#endif

#include <windows.h>
#include <objbase.h>
#include <activeds.h>

#include "tspi.h"
#include "tapi.h"
#include "dslookup.h"
#include "utils.h"

#include "tchar.h"

const TCHAR gszNoDSQuery[] = TEXT("NoDSQuery");
const TCHAR gszStatusActive[] = TEXT("S{Active}");
const TCHAR gszTTLWithBrace[] = TEXT("TTL{");

//
//  Utility functions
//

//
//  GetIntFromString
//      Utility function used for retrieving TTL information
//  Parameters:
//      sz       -  String that contains the integer
//      dwDigits -  Number of digits to convert
//
int GetIntFromString (LPTSTR & sz, DWORD dwDigits)
{
    int         iRet = 0;

    while (*sz != 0 && dwDigits)
    {
        iRet = ((iRet << 3) + (iRet << 1)) + // IRet * 10
               + (*sz - '0');
        ++sz;
        --dwDigits;
    }

    return iRet;
}

//
//  Rules:
//      The following codes are not thread safe, the caller
//  needs to be concious about synchronization.
//      Currently theses are only used in remotesp.tsp
//

/**********************************************************
 *  Get TAPI servers list from the registry
 *********************************************************/

DWORD                 gdwCurServerNum = 0;
HKEY                  ghRegistry = NULL;

BOOL
RegOpenServerLookup(
    HKEY    hRegistry
    )
{
    if (NULL != ghRegistry)
    {
        // Already have a search in progress or the
        // caller did not close the last search.
        return FALSE;
    }
    else
    {
        ghRegistry = hRegistry;
        return TRUE;
    }
}

BOOL
RegGetNextServer(
    LPTSTR  pszServerName,
    DWORD   dwSize
    )
{
    DWORD dwRet;
    LOG((TL_TRACE, "GetNextServer entered"));

    TCHAR szServerN[24];
    DWORD dwType;

    wsprintf(szServerN, TEXT("Server%d"), gdwCurServerNum++);

    LOG((TL_INFO, "RegGetNextServer: Getting server %d from reg", gdwCurServerNum-1));

    dwRet = RegQueryValueEx(
        ghRegistry,
        szServerN,
        0,
        &dwType,
        (LPBYTE) pszServerName,
        &dwSize
        );
    if (ERROR_SUCCESS != dwRet)
    {
    	LOG((TL_INFO, "Got last server"));
        LOG((TL_TRACE, "GetNextServer exited"));
		return FALSE;
    }

    LOG((TL_TRACE, "GetNextServer exited"));
    return TRUE;
}

BOOL
RegCloseLookup(
    void
    )
{
    LOG((TL_INFO, "Closing directory lookup"));

    ghRegistry = NULL;
    gdwCurServerNum = 0;
    return TRUE;
}


/**********************************************************
 *  Enumerate published telephony servers
 *********************************************************/

typedef struct _TAPISRV_LOOKUP_CTX {
    ADS_SEARCH_HANDLE     hDirSearch;
    IDirectorySearch *    pDirSearch;
} TAPISRV_LOOKUP_CTX, *PTAPISRV_LOOKUP_CTX;

//  gszTapisrvGuid needs to be consistant with server\dspub.cpp
const WCHAR gszTapisrvGuid[] = L"keywords=B1A37774-E3F7-488E-ADBFD4DB8A4AB2E5";

//
//  GetGC
//
//      Retrieve the IDirectorySearch of the Global Catalog (GC)
//  for SCP maintenance / discovery
//

HRESULT GetGC (IDirectorySearch ** ppGC)
{
    HRESULT             hr = S_OK;
    IEnumVARIANT        * pEnum = NULL;
    IADsContainer       * pCont = NULL;
    VARIANT             var;
    IDispatch           * pDisp = NULL;
    ULONG               lFetch;

    // Set IDirectorySearch pointer to NULL.
    *ppGC = NULL;

    // First, bind to the GC: namespace container object. The "real" GC DN 
    // is a single immediate child of the GC: namespace, which must 
    // be obtained using enumeration.
    hr = ADsOpenObject(
        TEXT("GC:"),
        NULL,
        NULL,
        ADS_SECURE_AUTHENTICATION, //Use Secure Authentication
        IID_IADsContainer,
        (void**)&pCont
        );
    if (FAILED(hr))
    {
        LOG((TL_ERROR, "ADsOpenObject failed: 0x%x\n", hr));
        goto cleanup;
    } 

    // Fetch an enumeration interface for the GC container. 
    hr = ADsBuildEnumerator(pCont, &pEnum);
    if (FAILED(hr)) {
        LOG((TL_ERROR, "ADsBuildEnumerator failed: 0x%x\n", hr));
        goto cleanup;
    } 

    //Now enumerate. There's only one child of the GC: object.
    hr = ADsEnumerateNext(pEnum, 1, &var, &lFetch);
    if (FAILED(hr)) {
        LOG((TL_ERROR, "ADsEnumerateNext failed: 0x%x\n", hr));
        goto cleanup;
    } 

    if (( hr == S_OK ) && ( lFetch == 1 ) )
    {
        pDisp = V_DISPATCH(&var);
        hr = pDisp->QueryInterface( IID_IDirectorySearch, (void**)ppGC); 
    }

cleanup:
    if (pEnum)
    {
        ADsFreeEnumerator(pEnum);
    }
    if (pCont)
    {
        pCont->Release();
    }
    if (pDisp)
    {
        (pDisp)->Release();
    }
    return hr;
}

//
//  DsOpenServerLookup
//      Start the operation of tapisrv server lookup
//  pctx    - The lookup context
//

HRESULT
DsOpenServerLookup(
    PTAPISRV_LOOKUP_CTX     pctx
    )
{
    HRESULT             hr = S_OK;
    ADS_SEARCHPREF_INFO SearchPref[3];
    BOOL                bInited = FALSE;
    DWORD               dwPref;

    WCHAR   *szAttribs[]={
        L"distinguishedName"
        };

    if (pctx == NULL)
    {
        hr = E_INVALIDARG;
        goto ExitHere;
    }

    pctx->hDirSearch = NULL;
    pctx->pDirSearch = NULL;

    hr = CoInitializeEx (NULL, COINIT_MULTITHREADED);
    if (FAILED (hr))
    {
        goto ExitHere;
    }
    bInited = TRUE;

    //  Get the global catalog
    hr = GetGC (&pctx->pDirSearch);
    if (FAILED (hr) || pctx->pDirSearch == NULL)
    {
        goto ExitHere;
    }

    // Set up the search. We want to do a deep search.
    // Note that we are not expecting thousands of objects
    // in this example, so we will ask for 10 rows / page.
    dwPref=sizeof(SearchPref)/sizeof(ADS_SEARCHPREF_INFO);
    SearchPref[0].dwSearchPref =    ADS_SEARCHPREF_SEARCH_SCOPE;
    SearchPref[0].vValue.dwType =   ADSTYPE_INTEGER;
    SearchPref[0].vValue.Integer =  ADS_SCOPE_SUBTREE;

    SearchPref[1].dwSearchPref =    ADS_SEARCHPREF_PAGESIZE;
    SearchPref[1].vValue.dwType =   ADSTYPE_INTEGER;
    SearchPref[1].vValue.Integer =  10;

    SearchPref[2].dwSearchPref =    ADS_SEARCHPREF_TIME_LIMIT;
    SearchPref[2].vValue.dwType =   ADSTYPE_INTEGER;
    SearchPref[2].vValue.Integer =  5 * 60; // 5 minute search timeout

    hr = pctx->pDirSearch->SetSearchPreference(SearchPref, dwPref);
    if (FAILED(hr))    {
        LOG((TL_ERROR, "Failed to set search prefs: hr:0x%x\n", hr));
        goto ExitHere;
    }

    //  Now execute the search
    hr = pctx->pDirSearch->ExecuteSearch(
        (LPWSTR)gszTapisrvGuid, 
        szAttribs, 
        sizeof(szAttribs) / sizeof(WCHAR *),
        &pctx->hDirSearch
        );

ExitHere:
    if (FAILED(hr) && pctx != NULL)
    {
        if (pctx->pDirSearch)
        {
            pctx->pDirSearch->Release();
        }
    }
    if (FAILED(hr) && bInited)
    {
        CoUninitialize ();
    }
    return hr;
}

//
//  DsGetNextServer
//
//      Return the next server name (in ANSI since that is what the
//  RPC subsystem uses)
//
//      returns S_FALSE if no more server to enumerate
//

HRESULT
DsGetNextServer(
    PTAPISRV_LOOKUP_CTX     pctx,
    LPTSTR                  pszServerName,
    DWORD                   dwSize
    )
{
    HRESULT             hr = S_OK;
    ADS_SEARCH_COLUMN   Col;
    TCHAR               szDN[MAX_PATH];
    WCHAR   *szAttribs[]={
        L"serviceDNSName",
        L"serviceBindingInformation",
        };
    ADS_ATTR_INFO       *pPropEntries = NULL;
    DWORD               dwNumAttrGot;
    IDirectoryObject    * pSCP = NULL;
    int                 i;
    LPWSTR              wsz;
    BOOL                bCheckedBinding;

    if (pctx == NULL || pctx->pDirSearch == NULL ||
        pctx->hDirSearch == NULL ||
        dwSize < sizeof(WCHAR))
    {
        hr = E_INVALIDARG;
        goto ExitHere;
    }

    hr = pctx->pDirSearch->GetNextRow(pctx->hDirSearch);
    if (SUCCEEDED (hr) && hr != S_ADS_NOMORE_ROWS)
    {
        hr = pctx->pDirSearch->GetColumn(
            pctx->hDirSearch,
            L"distinguishedName",
            &Col
            );
        if (FAILED (hr))
        {
            goto ExitHere;
        }
        _tcscpy (szDN, TEXT("LDAP://"));
        _tcsncpy (
            szDN + _tcslen (szDN), 
            Col.pADsValues->CaseExactString, 
            sizeof(szDN)/sizeof(TCHAR) - _tcslen (szDN)
            );
        pctx->pDirSearch->FreeColumn(&Col);
        hr = ADsGetObject (
            szDN,
            IID_IDirectoryObject,
            (void **)&pSCP
            );

        if (FAILED(hr))
        {
            LOG((TL_ERROR, "DsGetNextServer: ADsGetObject %S failed", szDN));
            goto ExitHere;
        }
        LOG((TL_TRACE, "DsGetNextServer: ADsGetObject %S succeeded", szDN));
        hr = pSCP->GetObjectAttributes (
            szAttribs,
            sizeof(szAttribs) / sizeof(WCHAR *),
            &pPropEntries,
            &dwNumAttrGot
            );
        if (FAILED(hr) || dwNumAttrGot != sizeof(szAttribs) / sizeof(WCHAR *))
        {
            LOG((TL_ERROR, "DsGetNextServer: GetObjectAttributes %S failed", szDN));
            goto ExitHere;
        }
        LOG((TL_TRACE, "DsGetNextServer: GetObjectAttributes %S succeeded", szDN));

        bCheckedBinding = FALSE;
        for (i=0;i<(int)dwNumAttrGot;i++) 
        {
            if (_tcsicmp(TEXT("serviceDNSName"), pPropEntries[i].pszAttrName) ==0 &&
                (pPropEntries[i].pADsValues->dwType == ADSTYPE_CASE_EXACT_STRING ||
                pPropEntries[i].pADsValues->dwType == ADSTYPE_CASE_IGNORE_STRING))
            {
                _tcsncpy (
                    pszServerName, 
                    pPropEntries[i].pADsValues->CaseExactString, 
                    dwSize/sizeof(TCHAR)
                    );
                pszServerName[dwSize/sizeof(TCHAR) - 1] = '\0';
                if (bCheckedBinding)
                {
                    break;
                }
            }
            else if (_tcsicmp(TEXT("serviceBindingInformation"), pPropEntries[i].pszAttrName) ==0 &&
                (pPropEntries[i].pADsValues->dwType == ADSTYPE_CASE_EXACT_STRING ||
                pPropEntries[i].pADsValues->dwType == ADSTYPE_CASE_IGNORE_STRING))
            {
                SYSTEMTIME          st;
                FILETIME            ft1, ft2;

                bCheckedBinding = TRUE;
                wsz = pPropEntries[i].pADsValues->CaseExactString;
                wsz = wcsstr (wsz, gszStatusActive);
                if (wsz == NULL)
                {
                    //  No server status information or server is not active
                    //  ignore this server
                    LOG((TL_ERROR, "DsGetNextServer:  %S No server status information", szDN));
                    hr = S_FALSE;
                    break;
                }
                wsz += _tcslen(gszStatusActive); // skip "S{Active}" itself
                wsz = wcsstr (wsz, gszTTLWithBrace);
                if (wsz == NULL)
                {
                    // No TTL found, corrupt serviceBindingInformation, ignore
                    LOG((TL_ERROR, "DsGetNextServer: %S No TTL found", szDN));
                    hr = S_FALSE;
                    break;
                }
                wsz += _tcslen (gszTTLWithBrace);   // skip "TTL{"
                
                //
                //  The following codes parses the TTL information
                //  created in server\dspub.cpp. They need to be
                //  consistant. The current format is 5 digits for
                //  year & 3 digits for milliseconds, 2 digits for
                //  the remaining
                //
                st.wYear = (WORD) GetIntFromString (wsz, 5);
                st.wMonth = (WORD) GetIntFromString (wsz, 2);
                st.wDay = (WORD) GetIntFromString (wsz, 2),
                st.wHour = (WORD) GetIntFromString (wsz, 2);
                st.wMinute = (WORD) GetIntFromString (wsz, 2);
                st.wSecond = (WORD) GetIntFromString (wsz, 2);
                st.wMilliseconds = (WORD) GetIntFromString (wsz, 3);
                SystemTimeToFileTime (&st, &ft1);
                GetSystemTimeAsFileTime (&ft2);
                if (CompareFileTime (&ft1, &ft2) < 0)
                {
                    //  The TapiSCP object has passed its TTL, ignore
                    hr = S_FALSE;
                    LOG((TL_ERROR, "DsGetNextServer: %S The TapiSCP object has passed its TTL", szDN));
                    break;
                }
            }
        }
        if (i == (int) dwNumAttrGot)
        {
            //  Did not find an attribute
            hr = S_FALSE;
        }
    }

ExitHere:
    if (pSCP)
        pSCP->Release();

    if (pPropEntries)
        FreeADsMem(pPropEntries);

    return hr;
}


//
//  DsCloseLookup
//      Close the TAPI DS published server lookup identified by pctx
//

HRESULT
DsCloseLookup(
    PTAPISRV_LOOKUP_CTX     pctx
    )
{
    if (pctx && pctx->pDirSearch && pctx->hDirSearch)
    {
        pctx->pDirSearch->CloseSearchHandle(pctx->hDirSearch);
    }
    if (pctx && pctx->pDirSearch)
    {
        pctx->pDirSearch->Release();
    }
    CoUninitialize ();
    return S_OK;
}

/**********************************************************
 *  Get TAPI servers list remotesp.tsp should contact
 *      Servers include those specified in registry through
 *  tcmsetup.exe and those servers published in the DS
 *********************************************************/

typedef struct _SERVER_LOOKUP_ENTRY {
    TCHAR           szServer[MAX_PATH];
    BOOL            bFromReg;
} SERVER_LOOKUP_ENTRY, *PSERVER_LOOKUP_ENTRY;

typedef struct _SERVER_LOOKUP {
    DWORD                   dwTotalEntries;
    DWORD                   dwUsedEntries;
    SERVER_LOOKUP_ENTRY     * aEntries;
} SERVER_LOOKUP, *PSERVER_LOOKUP;

SERVER_LOOKUP       gLookup;
DWORD               gdwCurIndex;

//
//  AddEntry : return FALSE if failed; otherwise, return true
//

BOOL
AddEntry (
    LPTSTR          szServer,
    BOOL            bFromReg
    )
{
    LPTSTR          psz;
    
    if (gLookup.dwUsedEntries >= gLookup.dwTotalEntries)
    {
        PSERVER_LOOKUP_ENTRY            pNew;

        pNew = (PSERVER_LOOKUP_ENTRY) DrvAlloc (
            sizeof(SERVER_LOOKUP_ENTRY) * (gLookup.dwTotalEntries + 5)
            );
        if (pNew == NULL)
        {
            return FALSE;
        }
        if (gLookup.dwUsedEntries > 0)
        {
            CopyMemory (
                pNew,
                gLookup.aEntries,
                sizeof(SERVER_LOOKUP_ENTRY) * gLookup.dwTotalEntries
                );
        }
        if (gLookup.aEntries)
        {
            DrvFree (gLookup.aEntries);
        }
        gLookup.aEntries = pNew;
        gLookup.dwTotalEntries += 5;
    }
    wcsncpy (
        gLookup.aEntries[gLookup.dwUsedEntries].szServer, 
        szServer,
        sizeof(gLookup.aEntries[gLookup.dwUsedEntries].szServer)/sizeof(TCHAR)
        );
    psz = _tcschr(gLookup.aEntries[gLookup.dwUsedEntries].szServer, TEXT('.'));
    if (psz != NULL)
    {
        *psz = 0;
    }
    gLookup.aEntries[gLookup.dwUsedEntries].bFromReg = bFromReg;
    ++gLookup.dwUsedEntries;
    return TRUE;
}

BOOL
IsServerInListOrSelf (
    LPTSTR          szServer
    )
{
    int             i;
    TCHAR           szServer1[MAX_PATH];
    LPTSTR          psz;
    BOOL            bRet = FALSE;

    _tcsncpy (szServer1, szServer, sizeof(szServer1)/sizeof(TCHAR));
    //  A computer name might be DNS name like comp1.microsoft.com
    //  only compare the computer name
    psz = _tcschr(szServer1, TEXT('.'));
    if (psz != NULL)
    {
        *psz = 0;
    }
    for (i = 0; i < (int)gLookup.dwUsedEntries; ++i)
    {
        if (_tcsicmp (szServer1, gLookup.aEntries[i].szServer) == 0)
        {
            bRet = TRUE;
            break;
        }
    }

    if (!bRet)
    {
        TCHAR           szSelf[MAX_PATH];
        DWORD           dwSize = sizeof(szSelf);
        
        if (GetComputerName (szSelf, &dwSize))
        {
            if (_tcsicmp (szServer1, szSelf) == 0)
            {
                bRet = TRUE;
            }
        }
    }

    return bRet;
}

BOOL OpenServerLookup (
    HKEY            hRegistry
    )
{
    BOOL                bRet = TRUE;
    TCHAR               szServer[MAX_PATH];
    TAPISRV_LOOKUP_CTX  ctx;
    HRESULT             hr;
    DWORD               dwNoDSQuery = 0;
    DWORD               dwSize = sizeof(dwNoDSQuery);

    gLookup.dwTotalEntries = 0;
    gLookup.dwUsedEntries = 0;
    gLookup.aEntries = NULL;

    //
    //  First add the computer from registry
    //
    if (RegOpenServerLookup (hRegistry))
    {
        while (RegGetNextServer (szServer, sizeof(szServer)))
        {
            if (!IsServerInListOrSelf (szServer))
            {
                AddEntry (szServer, TRUE);
            }
        }
        RegCloseLookup ();
    }

    if (hRegistry != NULL)
    {
        if (ERROR_SUCCESS != RegQueryValueEx (
            hRegistry,
            gszNoDSQuery,
            NULL,
            NULL,
            (LPBYTE)&dwNoDSQuery,
            &dwSize
            ))
        {
            dwNoDSQuery = 0;
        }
    }

    //
    //  Next add the computer from DS unless disabled
    //
    if (dwNoDSQuery == 0)
    {
        if (DsOpenServerLookup (&ctx) == S_OK)
        {
            while (SUCCEEDED(hr = DsGetNextServer (&ctx,szServer, sizeof(szServer))))
            {
                if (hr == S_ADS_NOMORE_ROWS)
                {
                    break;
                }
                else if (hr != S_OK)
                {
                    continue;   //  Server needs to be ignored
                }
                if (szServer[0] != 0 && !IsServerInListOrSelf (szServer))
                {
                    AddEntry (szServer, FALSE);
                }
            }
            DsCloseLookup (&ctx);
        }
    }

    gdwCurIndex = 0;

    return TRUE;
}

BOOL GetNextServer (
    LPSTR           szServer,
    DWORD           dwSize,
    BOOL            * pbReg
    )
{
    BOOL             bRet = TRUE;
    DWORD            dwRet;

    if (gdwCurIndex >= gLookup.dwUsedEntries)
    {
        bRet = FALSE;
        goto ExitHere;
    }
    if (pbReg != NULL)
    {
        *pbReg = gLookup.aEntries[gdwCurIndex].bFromReg;
    }
    dwRet = WideCharToMultiByte(
        GetACP(),
        0,
        gLookup.aEntries[gdwCurIndex].szServer,
        -1,
        szServer,
        dwSize,
        0,
        NULL
        );
    if (dwRet == 0)
    {
        bRet = FALSE;
        goto ExitHere;
    }
    ++gdwCurIndex;

ExitHere:
    return bRet;
}

BOOL CloseLookup (
    void
    )
{
    if (gLookup.aEntries)
    {
        DrvFree (gLookup.aEntries);
    }
    gLookup.aEntries = NULL;
    gLookup.dwTotalEntries = 0;
    gLookup.dwUsedEntries = 0;
    gdwCurIndex = 0;

    return TRUE;
}

HRESULT SockStartup (
    RSPSOCKET       * pSocket
    )
{
    HRESULT             hr = S_OK;
    BOOL                bCleanup = FALSE;
    WSADATA             wsadata;
    WORD                wVersionRequested = MAKEWORD( 2, 2 );

    if (pSocket == NULL)
    {
        hr = LINEERR_INVALPARAM;
        goto ExitHere;
    }
    ZeroMemory (pSocket, sizeof(RSPSOCKET));
    bCleanup = TRUE;

    ZeroMemory (pSocket, sizeof(RSPSOCKET));

    pSocket->hWS2 = LoadLibrary (TEXT("ws2_32.dll"));
    if (pSocket->hWS2 == NULL)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        goto ExitHere;
    }
    
    pSocket->pFnWSAStartup = (PFNWSASTARTUP)GetProcAddress (
        pSocket->hWS2,
        "WSAStartup"
        );
    pSocket->pFnWSACleanup = (PFNWSACLEANUP)GetProcAddress (
        pSocket->hWS2,
        "WSACleanup"
        );
    pSocket->pFngethostbyname = (PFNGETHOSTBYNAME)GetProcAddress(
        pSocket->hWS2,
        "gethostbyname"
        );
    if (pSocket->pFnWSAStartup == NULL ||
        pSocket->pFnWSACleanup == NULL ||
        pSocket->pFngethostbyname == NULL)
    {
        hr = LINEERR_OPERATIONFAILED;
        goto ExitHere;
    }

    pSocket->hICMP = LoadLibrary (TEXT("icmp.dll"));
    if (pSocket->hICMP == NULL)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        goto ExitHere;
    }
    pSocket->pFnIcmpCreateFile = (PFNICMPCREATEFILE)GetProcAddress (
        pSocket->hICMP,
        "IcmpCreateFile"
        );
    pSocket->pFnIcmpCloseHandle = (PFNICMPCLOSEHANDLE)GetProcAddress (
        pSocket->hICMP,
        "IcmpCloseHandle"
        );
    pSocket->pFnIcmpSendEcho = (PFNICMPSENDECHO)GetProcAddress (
        pSocket->hICMP,
        "IcmpSendEcho"
        );
    if (pSocket->pFnIcmpCreateFile == NULL ||
        pSocket->pFnIcmpCreateFile == NULL ||
        pSocket->pFnIcmpCreateFile == NULL)
    {
        hr = LINEERR_OPERATIONFAILED;
        goto ExitHere;
    }

    hr = (*pSocket->pFnWSAStartup)(
        wVersionRequested,
        &wsadata
        );
    if(FAILED(hr))
    {
        goto ExitHere;
    }

    pSocket->IcmpHandle = (*pSocket->pFnIcmpCreateFile)();
    if (pSocket->IcmpHandle == INVALID_HANDLE_VALUE)
    {
        (*pSocket->pFnWSACleanup)();
        hr = LINEERR_OPERATIONFAILED;
    }

ExitHere:
    if (hr != S_OK && bCleanup)
    {
        if (pSocket->hWS2 != NULL)
        {
            FreeLibrary (pSocket->hWS2);
        }
        if (pSocket->hICMP != NULL)
        {
            FreeLibrary (pSocket->hICMP);
        }
        ZeroMemory (pSocket, sizeof(RSPSOCKET));
    }
    return hr;
}

#define MAX_PACKET_SIZE	    256
#define PING_TIMEOUT        1000

HRESULT SockIsServerResponding (
    RSPSOCKET       * pSocket,
    char *          szServer
    )
{
    HRESULT             hr = S_OK;
    unsigned long       inetAddr;
    HOSTENT             * pHost;
    BOOL                bRet;
	CHAR			    ReplyBuf[MAX_PACKET_SIZE];
	
    //  Validate parameters
    if (pSocket == NULL ||
        pSocket->hWS2 == NULL ||
        pSocket->hICMP == NULL ||
        pSocket->IcmpHandle == NULL ||
        pSocket->IcmpHandle == INVALID_HANDLE_VALUE)
    {
        hr = LINEERR_INVALPARAM;
        goto ExitHere;
    }

    //  Get the server IP address
    pHost = (*pSocket->pFngethostbyname)(szServer);
    if (pHost == NULL)
    {
        hr = LINEERR_OPERATIONFAILED;
        goto ExitHere;
    }
    inetAddr = *(unsigned long *)pHost->h_addr;

    //  Ping the server
    bRet = (*pSocket->pFnIcmpSendEcho)(
        pSocket->IcmpHandle,
        inetAddr,
        0,
        0,
        0,
        (LPVOID)ReplyBuf,
        sizeof(ReplyBuf),
        PING_TIMEOUT
        );
    if (!bRet || ((PICMP_ECHO_REPLY)ReplyBuf)->Address != inetAddr)
    {
        hr = S_FALSE;
    }
    
ExitHere:
    return hr;
}

HRESULT SockShutdown (
    RSPSOCKET       * pSocket
    )
{
    if (pSocket != NULL)
    {
        if (pSocket->IcmpHandle != INVALID_HANDLE_VALUE &&
            pSocket->IcmpHandle != NULL)
        {
            (*pSocket->pFnIcmpCloseHandle)(pSocket->IcmpHandle);
        }
        if (pSocket->hICMP != NULL)
        {
            FreeLibrary (pSocket->hICMP);
        }
        if (pSocket->hWS2 != NULL)
        {
            (*pSocket->pFnWSACleanup)();
            FreeLibrary (pSocket->hWS2);
        }
        ZeroMemory (pSocket, sizeof(RSPSOCKET));
    }
    
    return S_OK;
}