windows-server-2003/net/mmc/wins/verify.c

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

/*
    verify.c
        Comment goes here

    FILE HISTORY:

*/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "tchar.h"

#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <wtypes.h>

#include <fcntl.h>
#include <ctype.h>

#include <windows.h>
#include <windowsx.h>
#include <tdi.h>

#include <winsock.h>
#include <wsahelp.h>
#include <nameser.h>
//#include <resolve.h>
#include <nb30.h>
#include <nbtioctl.h>

#define WINS_CLIENT_APIS
#include "winsintf.h"
#include "resource.h"
#include "verify.h"


//
// The format of Adapter Status responses
//
typedef struct
{
    ADAPTER_STATUS AdapterInfo;
    NAME_BUFFER    Names[32];
} tADAPTERSTATUS;


#define WINSTEST_FOUND            0
#define WINSTEST_NOT_FOUND        1
#define WINSTEST_NO_RESPONSE      2

#define WINSTEST_VERIFIED         0
#define WINSTEST_OUT_OF_MEMORY    3
#define WINSTEST_BAD_IP_ADDRESS   4
#define WINSTEST_HOST_NOT_FOUND   5
#define WINSTEST_NOT_VERIFIED     6

#define WINSTEST_INVALID_ARG      7
#define WINSTEST_OPEN_FAILED      8

TCHAR    *messages[] = {
                        L"success",
                        L"name not found",
                        L"no response",
                        L"out of memory",
                        L"bad ip address",
                        L"host not found",
                        L"host address not verified",
                        L"invalid argument",
                        L"failed to open NBT driver"
                     };



#define MAX_NB_NAMES 1000
#define MAX_SERVERS  1000
#define MAX_SIZE     1024

SOCKET  sd;
WSADATA WsaData;

HWND	    g_wndDlg = NULL;
HWND        g_hwndParent = NULL;
HANDLE      g_hThread = NULL;
HINSTANCE   g_hInstance = NULL;

HRESULT foo;

struct  sockaddr_in myad;
struct  sockaddr_in recvad;
int     addrlen;
u_short TranID;
u_long  NonBlocking = 1;

int      NumWinServers = 0;
int      NumNBNames = 0;
u_char * NBNames[MAX_NB_NAMES];
u_long   VerifiedAddress[MAX_NB_NAMES];

//char  lpResults[MAX_SIZE];
//TCHAR  lpResults[MAX_SIZE];
//lpResults = (char*) malloc  (64536);

WINSERVERS WinServers[MAX_SERVERS];

#define NBT_NONCODED_NMSZ   17
#define NBT_NAMESIZE        34

ULONG   NetbtIpAddress;
CHAR    pScope[BUFF_SIZE];

NTSTATUS
DeviceIoCtrl(
    IN HANDLE           fd,
    IN PVOID            ReturnBuffer,
    IN ULONG            BufferSize,
    IN ULONG            Ioctl,
    IN PVOID            pInput,
    IN ULONG            SizeInput
    );


INT_PTR CALLBACK
dlgProc(
		 HWND hWnd,
    UINT Message,
    WPARAM wParam,
    LPARAM lParam
    )
{
    int ntest;

	switch (Message)
	{
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDCANCEL:
                    EndDialog(hWnd, IDCANCEL);
                    return TRUE;
            }
            break;

        case WM_INITDIALOG:
            g_wndDlg = hWnd;
            break;

        default:
            return FALSE;
    }

	return TRUE;
}

void ToWCS(LPCSTR szMBCSString, LPWSTR lpWideString)
{
	int nResult;

	// determone the size first
	nResult = MultiByteToWideChar(
						CP_ACP,
						MB_COMPOSITE,
						szMBCSString,
						-1,
						lpWideString,
						0);

	MultiByteToWideChar(
						CP_ACP,
						MB_COMPOSITE,
						szMBCSString,
						-1,
						lpWideString,
						nResult);

    lpWideString[nResult + 1] = '\0';
}

void AddStatusMessageW(LPCWSTR pszMessage)
{
    HWND    hwndEdit;
    MSG     msg;

    hwndEdit = GetDlgItem(g_wndDlg, IDC_EDIT_MESSAGE);

	SetFocus (hwndEdit);
    SendMessage (hwndEdit, EM_SETSEL, -1, -1);
    SendMessage (hwndEdit, EM_REPLACESEL, 0, (LPARAM) ((LPCTSTR) pszMessage));

    // give the window some time to process the message
    while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
}

void AddStatusMessage(LPCSTR pszMessage)
{
    WCHAR   szBuffer[MAX_SIZE];

    ToWCS(pszMessage, szBuffer);

    AddStatusMessageW(szBuffer);
}

DWORD
GetStatus(
        BOOL            fPrint,
        LPVOID          pResultsA,
        BOOL            fNew,
        BOOL            fShort,
        PUCHAR          IpAddr
        )
{
        DWORD                     Status, i;
        struct in_addr            InAddr;
        PWINSINTF_RESULTS_T       pResults = pResultsA;
        PWINSINTF_RESULTS_NEW_T   pResultsN = pResultsA;
        PWINSINTF_ADD_VERS_MAP_T  pAddVersMaps;
        DWORD                     NoOfOwners;
        handle_t                  BindHdl;
        WINSINTF_BIND_DATA_T      BindData;
        char                      lpResults[MAX_SIZE] = {0};
        TCHAR                     szErrMsg[MAX_SIZE];

		WCHAR  WcharString1[WINSINTF_MAX_NAME_SIZE] = {0};

		int nSize = MultiByteToWideChar(CP_ACP,
							MB_PRECOMPOSED,
							IpAddr,
							-1,
							WcharString1,
							0
							);

		MultiByteToWideChar(CP_ACP,
							MB_PRECOMPOSED,
							IpAddr,
							-1,
							WcharString1,
							nSize
							);

		WcharString1[nSize] = '\0';

		BindData.fTcpIp = TRUE;
        BindData.pServerAdd = (LPSTR) (LPTSTR) WcharString1;

		strcpy(lpResults, "");
		strcat(lpResults, "*****\r\n" );
		strcat(lpResults, "Getting map table from " );
		strcat(lpResults, IpAddr);
		strcat(lpResults, "\r\n");

        AddStatusMessage(lpResults);

        BindHdl = WinsBind(&BindData);
        if (BindHdl == NULL)
        {
    		strcpy(lpResults, "");
            strcat(lpResults, "Unable to bind to " );
            strcat(lpResults, IpAddr);
            strcat(lpResults, "\r\n");

            AddStatusMessage(lpResults);

            return STATUS_SUCCESS;
        }

        if (!fNew)
        {
#ifdef WINS_CLIENT_APIS
            Status = WinsStatus(BindHdl, WINSINTF_E_CONFIG, pResultsA);
#else
            Status = WinsStatus(WINSINTF_E_CONFIG, pResultsA);
#endif  WINS_CLIENT_APIS
        }
        else
        {
            pResultsN->pAddVersMaps = NULL;

#ifdef WINS_CLIENT_APIS
            Status = WinsStatusNew(BindHdl, WINSINTF_E_CONFIG, pResultsN);
#else
            Status = WinsStatusNew(WINSINTF_E_CONFIG, pResultsN);
#endif WINS_CLIENT_APIS
        }

		if (Status == 0)
		{
			//strcpy(lpResults, "");
			//strcat(lpResults, "SUCCESS \r\n");

            //AddStatusMessage(lpResults);
        }
		else
		{
            wsprintfA(lpResults, "Get Wins Status failed! Error: %d\r\n", Status);
            AddStatusMessage(lpResults);
		}

        if (Status == WINSINTF_SUCCESS)
        {
            if (fPrint)
            {
                if (!fNew)
                {
                     pAddVersMaps = pResults->AddVersMaps;
                     NoOfOwners = pResults->NoOfOwners;
                }
                else
                {
                     pAddVersMaps = pResultsN->pAddVersMaps;
                     NoOfOwners = pResultsN->NoOfOwners;
                }

                if (NoOfOwners == 0)
                {
					strcpy(lpResults, "");
                    strcat(lpResults, "The database list of owners is empty.\r\n");

                    AddStatusMessage(lpResults);

         		    Status = WINSINTF_FAILURE;
                }
            }
        }

        WinsUnbind(&BindData, BindHdl);

        return(Status);
}

//------------------------------------------------------------------------
NTSTATUS
GetIpAddress(
    IN HANDLE           fd,
    OUT PULONG          pIpAddress
    )

/*++

Routine Description:

    This function calls into netbt to get the ip address.

Arguments:

   fd - file handle to netbt
   pIpAddress - the ip address returned

Return Value:

   ntstatus

History:
    27-Dec-1995 CDermody    copied from nbtstat.c

--*/

{
    NTSTATUS    status;
    ULONG       BufferSize=100;
    PVOID       pBuffer;

    pBuffer = LocalAlloc(LMEM_FIXED,BufferSize);
    if (!pBuffer)
    {
        return(STATUS_INSUFFICIENT_RESOURCES);
    }

    status = DeviceIoCtrl(fd,
                         pBuffer,
                         BufferSize,
                         IOCTL_NETBT_GET_IP_ADDRS,
                         NULL,
                         0);

    if (NT_SUCCESS(status))
    {
        *pIpAddress = *(ULONG *)pBuffer;
    }
    else
    {
        *pIpAddress = 0;
    }

    LocalFree(pBuffer);

    return(status);
}

//------------------------------------------------------------------------
NTSTATUS
GetInterfaceList
(
    char pDeviceName[][MAX_NAME+1]
)
{
    HANDLE              StreamHandle;
    OBJECT_ATTRIBUTES   ObjectAttributes;
    IO_STATUS_BLOCK     IoStatusBlock;
    STRING              name_string, AnsiString;
    UNICODE_STRING      uc_name_string;
    NTSTATUS            status;
    char                pNbtWinsDeviceName[MAX_NAME] = "\\Device\\NetBt_Wins_Export";

    PUCHAR  SubKeyParms = "system\\currentcontrolset\\services\\netbt\\parameters";
    PUCHAR  Scope = "ScopeId";
    CHAR    pScopeBuffer[BUFF_SIZE];
    HKEY    Key;
    LONG    Type;
    ULONG   size;

    NETBT_INTERFACE_INFO    *pInterfaceInfo;
    ULONG                   InterfaceInfoSize = 10 * sizeof(NETBT_ADAPTER_INDEX_MAP) + sizeof(ULONG);
    PVOID                   pInput = NULL;
    ULONG                   SizeInput = 0;

    LONG    i, index = 0;

    pInterfaceInfo = LocalAlloc(LMEM_FIXED,InterfaceInfoSize);
    if (!pInterfaceInfo)
    {
        return(STATUS_INSUFFICIENT_RESOURCES);
    }

    RtlInitString(&name_string, pNbtWinsDeviceName);
    RtlAnsiStringToUnicodeString(&uc_name_string, &name_string, TRUE);

    InitializeObjectAttributes(
        &ObjectAttributes,
        &uc_name_string,
        OBJ_CASE_INSENSITIVE,
        (HANDLE) NULL,
        (PSECURITY_DESCRIPTOR) NULL
        );

    status = NtCreateFile (&StreamHandle,
                           SYNCHRONIZE | FILE_READ_DATA | FILE_WRITE_DATA,
                           &ObjectAttributes,
                           &IoStatusBlock,
                           NULL,
                           FILE_ATTRIBUTE_NORMAL,
                           FILE_SHARE_READ | FILE_SHARE_WRITE,
                           FILE_OPEN_IF,
                           0,
                           NULL,
                           0);

    RtlFreeUnicodeString(&uc_name_string);

    if (NT_SUCCESS (status))
    {
        do
        {
            status = DeviceIoCtrl(StreamHandle,
                                 pInterfaceInfo,
                                 InterfaceInfoSize,
                                 IOCTL_NETBT_GET_INTERFACE_INFO,
                                 pInput,
                                 SizeInput);

            if (status == STATUS_BUFFER_OVERFLOW)
            {
                LocalFree(pInterfaceInfo);
                pInterfaceInfo = NULL;

                InterfaceInfoSize *= 2;
                if (InterfaceInfoSize != 0xFFFF)
                {
                    pInterfaceInfo = LocalAlloc(LMEM_FIXED,InterfaceInfoSize);
                }

                if (!pInterfaceInfo)
                {
                    NtClose(StreamHandle);
                    //NlsPerror(COMMON_UNABLE_TO_ALLOCATE_PACKET,0);
                    return(STATUS_INSUFFICIENT_RESOURCES);
                }
            }
            else if (!NT_SUCCESS (status))
            {
                LocalFree(pInterfaceInfo);

                NtClose(StreamHandle);
                return(status);
            }

        } while (status == STATUS_BUFFER_OVERFLOW);
        NtClose (StreamHandle);

        for (i = 0; i<pInterfaceInfo->NumAdapters; i++)
        {
            RtlInitString(&name_string, NULL);
            RtlInitUnicodeString(&uc_name_string, pInterfaceInfo->Adapter[i].Name);
            if (NT_SUCCESS(RtlUnicodeStringToAnsiString(&name_string, &uc_name_string, TRUE)))
            {
                size = (name_string.Length > MAX_NAME) ? MAX_NAME : name_string.Length;

                strncpy(pDeviceName[index], name_string.Buffer, size);
                pDeviceName[index][size] = '\0';
                RtlFreeAnsiString (&name_string);

                index++;
            }
        }

        //
        // NULL out the next device string ptr
        //
        if (index < NBT_MAXIMUM_BINDINGS)
        {
            pDeviceName[index][0] = '\0';
        }

        //
        // Read the ScopeId key!
        //
        size = BUFF_SIZE;
        *pScope = '\0';     // By default
        status = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
                     SubKeyParms,
                     0,
                     KEY_READ,
                     &Key);

        if (status == ERROR_SUCCESS)
        {
            // now read the Scope key
            status = RegQueryValueExA(Key, Scope, NULL, &Type, pScopeBuffer, &size);
            if (status == ERROR_SUCCESS)
            {
                strcpy(pScope,pScopeBuffer);
            }
            status = RegCloseKey(Key);
        }

        status = STATUS_SUCCESS;
    }

    if (pInterfaceInfo != NULL)
        LocalFree(pInterfaceInfo);

    return status;
}

//------------------------------------------------------------------------
NTSTATUS
OpenNbt(
    IN char path[][MAX_NAME+1],
    OUT PHANDLE pHandle,
    int max_paths
    )
{
    HANDLE              StreamHandle;
    OBJECT_ATTRIBUTES   ObjectAttributes;
    IO_STATUS_BLOCK     IoStatusBlock;
    STRING              name_string;
    UNICODE_STRING      uc_name_string;
    NTSTATUS            status;
    LONG                index=0;

    ASSERT ( max_paths <= NBT_MAXIMUM_BINDINGS );

    while ((path[index][0] != '\0') && (index < max_paths))
    {
        RtlInitString(&name_string, path[index]);
        RtlAnsiStringToUnicodeString(&uc_name_string, &name_string, TRUE);

        InitializeObjectAttributes(
            &ObjectAttributes,
            &uc_name_string,
            OBJ_CASE_INSENSITIVE,
            (HANDLE) NULL,
            (PSECURITY_DESCRIPTOR) NULL
            );

        status =
        NtCreateFile(
            &StreamHandle,
            SYNCHRONIZE | FILE_READ_DATA | FILE_WRITE_DATA,
            &ObjectAttributes,
            &IoStatusBlock,
            NULL,
            FILE_ATTRIBUTE_NORMAL,
            FILE_SHARE_READ | FILE_SHARE_WRITE,
            FILE_OPEN_IF,
            0,
            NULL,
            0);

        RtlFreeUnicodeString(&uc_name_string);

        if (NT_SUCCESS(status))
        {
            *pHandle = StreamHandle;
            return(status);
        }

        ++index;
    }

    return (status);
} // s_open

//------------------------------------------------------------------------
NTSTATUS
DeviceIoCtrl(
    IN HANDLE           fd,
    IN PVOID            ReturnBuffer,
    IN ULONG            BufferSize,
    IN ULONG            Ioctl,
    IN PVOID            pInput,
    IN ULONG            SizeInput
    )

/*++

Routine Description:

    This procedure performs an ioctl(I_STR) on a stream.

Arguments:

    fd        - NT file handle
    iocp      - pointer to a strioctl structure

Return Value:

    0 if successful, non-zero otherwise.

History:
    27-Dec-1995 CDermody    copied from nbtstat.c
--*/

{
    NTSTATUS                        status;
    int                             retval;
    ULONG                           QueryType;
    IO_STATUS_BLOCK                 iosb;


    status = NtDeviceIoControlFile(
                      fd,                      // Handle
                      NULL,                    // Event
                      NULL,                    // ApcRoutine
                      NULL,                    // ApcContext
                      &iosb,                   // IoStatusBlock
                      Ioctl,                   // IoControlCode
                      pInput,                  // InputBuffer
                      SizeInput,               // InputBufferSize
                      (PVOID) ReturnBuffer,    // OutputBuffer
                      BufferSize);             // OutputBufferSize


    if (status == STATUS_PENDING)
    {
        status = NtWaitForSingleObject(
                    fd,                         // Handle
                    TRUE,                       // Alertable
                    NULL);                      // Timeout
        if (NT_SUCCESS(status))
        {
            status = iosb.Status;
        }
    }

    return(status);
}

/****************************************************************************/
/*      CheckRemoteTable                                                    */
/*                                                                          */
/*  This routine does an adapter status query to get the remote name table  */
/*  then checks to see if a netbios name is contained in it.                */
/*                                                                          */
/*  Parameters:                                                             */
/*      RemoteName, the IP address (asci nn.nn.nn.nn format) of a server to */
/*                  query.                                                  */
/*      SearchName, a net bios name.                                        */
/*                                                                          */
/*  Return:                                                                 */
/*      WINSTEST_VERIFIED       The name exists in the remote name table    */
/*      WINSTEST_NOT_VERIFIED   The name does not exist in the remote table */
/*      WINSTEST_BAD_IP_ADDRESS inet_addr could not convert the ip address  */
/*                              character string.                           */
/*      WINSTEST_HOST_NOT_FOUND Could not reach ip address                  */
/*      WINSTEST_OUT_OF_MEMORY  Out of memory                               */
/*  History:                                                                */
/*      27-Dec-1995     CDermody    created following example of nbtstat.c  */
/****************************************************************************/

int
CheckRemoteTable(
    IN HANDLE   fd,
    IN PCHAR    RemoteName,
    IN PCHAR    SearchName
    )

{
    LONG                        Count;
    LONG                        i;
    PVOID                       pBuffer;
    ULONG                       BufferSize=600;
    NTSTATUS                    status;
    tADAPTERSTATUS              *pAdapterStatus;
    NAME_BUFFER                 *pNames;
    CHAR                        MacAddress[20];
    tIPANDNAMEINFO              *pIpAndNameInfo;
    ULONG                       SizeInput;
    ULONG                       IpAddress;
    USHORT                      BytesToCopy;


    pBuffer = LocalAlloc(LMEM_FIXED,BufferSize);
    if (!pBuffer)
    {
        return(WINSTEST_OUT_OF_MEMORY);
    }

    status = STATUS_BUFFER_OVERFLOW;
    pIpAndNameInfo = LocalAlloc(LMEM_FIXED,sizeof(tIPANDNAMEINFO));
    if (!pIpAndNameInfo)
    {
        LocalFree(pBuffer);
        return(WINSTEST_OUT_OF_MEMORY);
    }

    RtlZeroMemory((PVOID)pIpAndNameInfo,sizeof(tIPANDNAMEINFO));

    //
    // Convert the remote name which is really a dotted decimal ip address
    // into a ulong
    //
    IpAddress = inet_addr(RemoteName);

    //
    // Don't allow zero for the address since it sends a broadcast and
    // every one responds
    //
    if ((IpAddress == INADDR_NONE) || (IpAddress == 0))
    {
        LocalFree(pBuffer);
        LocalFree(pIpAndNameInfo);

        return(WINSTEST_BAD_IP_ADDRESS);
    }

    pIpAndNameInfo->IpAddress = ntohl(IpAddress);

    pIpAndNameInfo->NetbiosAddress.Address[0].Address[0].NetbiosName[0] = '*';


    pIpAndNameInfo->NetbiosAddress.TAAddressCount = 1;
    pIpAndNameInfo->NetbiosAddress.Address[0].AddressLength
        = sizeof(TDI_ADDRESS_NETBIOS);
    pIpAndNameInfo->NetbiosAddress.Address[0].AddressType
        = TDI_ADDRESS_TYPE_NETBIOS;
    pIpAndNameInfo->NetbiosAddress.Address[0].Address[0].NetbiosNameType
        = TDI_ADDRESS_NETBIOS_TYPE_UNIQUE;

    SizeInput = sizeof(tIPANDNAMEINFO);

    while (status == STATUS_BUFFER_OVERFLOW)
    {
        status = DeviceIoCtrl(fd,
                             pBuffer,
                             BufferSize,
                             IOCTL_NETBT_ADAPTER_STATUS,
                             pIpAndNameInfo,
                             SizeInput);

        if (status == STATUS_BUFFER_OVERFLOW)
        {
            LocalFree(pBuffer);

            BufferSize *=2;
            pBuffer = LocalAlloc(LMEM_FIXED,BufferSize);
            if (!pBuffer || (BufferSize == 0xFFFF))
            {
                LocalFree(pIpAndNameInfo);

                return(WINSTEST_OUT_OF_MEMORY);
            }
        }
    }

    pAdapterStatus = (tADAPTERSTATUS *)pBuffer;
    if ((pAdapterStatus->AdapterInfo.name_count == 0) ||
        (status != STATUS_SUCCESS))
    {
        LocalFree(pIpAndNameInfo);
        LocalFree(pBuffer);

        return(WINSTEST_HOST_NOT_FOUND);
    }

    pNames = pAdapterStatus->Names;
    Count = pAdapterStatus->AdapterInfo.name_count;

    status = 1;

    while (Count--)
    {
        if (0 == _strnicmp(SearchName, pNames->name, strlen(SearchName)))
        {
            LocalFree(pIpAndNameInfo);
            LocalFree(pBuffer);

            return WINSTEST_VERIFIED; // found
        }

        pNames++;
    }

    LocalFree(pIpAndNameInfo);
    LocalFree(pBuffer);

    return WINSTEST_NOT_VERIFIED;
}


/****************************************************************************/
/*      VerifyRemote                                                        */
/*                                                                          */
/*  This routine checks to see if a netbios name is contained in the remote */
/*  name table at a given IP address.                                       */
/*                                                                          */
/*  Parameters:                                                             */
/*      RemoteName, the IP address (asci nn.nn.nn.nn format) of a server to */
/*                  query.                                                  */
/*      NBName,     a net bios name.                                        */
/*                                                                          */
/*  Return:                                                                 */
/*      WINSTEST_VERIFIED       The name exists in the remote name table    */
/*      WINSTEST_NOT_VERIFIED   The name does not exist in the remote table */
/*      WINSTEST_BAD_IP_ADDRESS inet_addr could not convert the ip address  */
/*                              character string.                           */
/*      WINSTEST_OPEN_FAILED    Could not open NBT driver or could not read */
/*                              the NBT driver info from the registry.      */
/*      WINSTEST_HOST_NOT_FOUND Could not reach ip address                  */
/*      WINSTEST_OUT_OF_MEMORY  Out of memory                               */
/*  History:                                                                */
/*      27-Dec-1995     CDermody    created following example of nbtstat.c  */
/****************************************************************************/

int VerifyRemote(IN PCHAR RemoteName, IN PCHAR NBName)
{
    NTSTATUS    status;
    LONG        interval=-1;
    HANDLE      nbt = 0;
    int         nStatus;
    int         index;
    CHAR        pDeviceName[NBT_MAXIMUM_BINDINGS+1][MAX_NAME+1];

    status = GetInterfaceList(pDeviceName);
    if (!NT_SUCCESS(status))
    {
        return WINSTEST_OPEN_FAILED;
    }

    for (index = 0; index < NBT_MAXIMUM_BINDINGS && pDeviceName[index][0]; index++)
    {
        //
        //  Open the device of the appropriate streams module to start with.
        //
        status = OpenNbt(&pDeviceName[index], &nbt, NBT_MAXIMUM_BINDINGS-index);
        if (!NT_SUCCESS(status))
        {
            //
            // Try the next binding!
            //
            continue;
        }

        GetIpAddress(nbt, &NetbtIpAddress);

        if (RemoteName[0] == '\0')
            return WINSTEST_INVALID_ARG;

        nStatus = CheckRemoteTable(nbt,RemoteName,NBName);
        if (nStatus == WINSTEST_VERIFIED)
            break;
    }

    return nStatus;
}


/*************************************************************/
/*        NBDecode(name,name2)                               */
/*                                                           */
/* This routine decodes a netbios name from level2 to leve1. */
/* name is 16 bytes long, remember that.                     */
/*                                                           */
/*************************************************************/

void
NBDecode(
    unsigned char *name,
    unsigned char *name2
    )
{
  int i;

  for (i = 0; i < NBT_NONCODED_NMSZ - 1; i++)
  {
     name[i] = (name2[2*i+1] - 0x41)*(NBT_NONCODED_NMSZ-1) +
               (name2[2*i+2] - 0x41);
  }

}

/*************************************************************/
/*        NBEncode(name2,name)                               */
/*                                                           */
/* This routine code a netbios name from level1 to level2.   */
/* name2 has to be NBT_NAMESIZE bytes long, remember that.   */
/*************************************************************/

void
NBEncode(
    unsigned char *name2,
    unsigned char *name
    )
{
    int i;

    name2[0] = 0x20;        /* length of first block */

    for (i = 0; i < NBT_NONCODED_NMSZ - 1; i++)
    {
        name2[ 2*i+1 ] =  ((name[ i ] >> 4) & 0x0f) + 0x41;
        name2[ 2*i+2 ] =  (name[ i ]  & 0x0f) + 0x41;
    }

    name2[ NBT_NAMESIZE-1 ] = 0;    /* length of next block */
}

ULONG
AddWins(
    IN  ULONG   IPAddr
    )
{
    INT i;

    for (i = 0; i < MAX_SERVERS; i++)
    {
        if (WinServers[i].Server.s_addr == IPAddr)
        {
            return 0;
        }

        if (WinServers[i].Server.s_addr == 0)
        {
            WinServers[i].Server.s_addr = IPAddr;
			NumWinServers++;
            return i;
        }
    }

    return 0;
}

VOID
PurgeWinsAddr(
    IN  ULONG   IPAddr
    )
{
    INT i;

    for (i = 0; i < MAX_SERVERS; i++)
    {
        if (WinServers[i].Server.s_addr == IPAddr)
        {
            INT j = i + 1;

            while (WinServers[j].Server.s_addr)
            {
                WinServers[j - 1] = WinServers[j];
                j++;
            }

            //
            // Zap the last entry
            //
            WinServers[j - 1].Server.s_addr = 0;

            break;
        }
    }
}

/*******************************************************************/
/*                                                                 */
/* Initialize the WinServers table and set NumWinServers to count  */
/*                                                                 */
/*******************************************************************/

BOOLEAN
InitServers(char *szServer, BOOL fVerifyWithPartners)
{
    FILE *                  sf = NULL;
    int                     i = 0;
    ULONG                   j = 0;
    u_char                  buffer[100] = {0};
    WINSINTF_RESULTS_NEW_T  ResultsN;
    struct in_addr          InAddr;
    char	                szNum[10] = {0};
    char                    lpResults[MAX_SIZE] = {0};

	strcpy(buffer, szServer);

    //WinServers[i].Server.s_addr = inet_addr(buffer);
	InAddr.s_addr = inet_addr(buffer);
    AddWins(InAddr.s_addr);

	if (fVerifyWithPartners)
	{
		if (GetStatus(TRUE, &ResultsN, TRUE, FALSE, inet_ntoa(InAddr)))
		{
			strcpy(lpResults, "");
			strcat(lpResults, "Unable to verify against the WINS server: ");
			strcat(lpResults, inet_ntoa(InAddr));
			strcat(lpResults, "\r\n\r\n");

			AddStatusMessage(lpResults);

			return FALSE;
		}

		//
		// Enter all the WINS server names into the server table
		//
		for (j = 0; j < ResultsN.NoOfOwners; j++)
		{
			//
			// Add addresses; check for duplicates
			//
			struct  in_addr InAddr;
			InAddr.s_addr = htonl(ResultsN.pAddVersMaps[j].Add.IPAdd);
			(VOID)AddWins(htonl(ResultsN.pAddVersMaps[j].Add.IPAdd));
		}

		//NumWinServers = ResultsN.NoOfOwners;

		strcpy(lpResults, "");
		_itoa(NumWinServers, szNum, 10);
		strcat(lpResults, szNum);
		strcat(lpResults, " Wins servers will be Queried:\r\n");

		AddStatusMessage(lpResults);

		for (i = 0; i < NumWinServers; i++)
		{
			struct in_addr  InAddr;

			InAddr.s_addr = WinServers[i].Server.s_addr;

			strcpy(lpResults, "");
			strcat(lpResults, inet_ntoa(InAddr));
			strcat(lpResults,"\r\n");

			AddStatusMessage(lpResults);
		}
	}

    return  TRUE;
}



/*******************************************************************/
/*                                                                 */
/* Send a Name Query to a WINS Server                              */
/*                                                                 */
/* name is the name to query                                       */
/* winsaddr is the ip address of the wins server to query          */
/* TransID is the transaction ID to use for the query              */
/*                                                                 */
/*******************************************************************/

void
_stdcall
SendNameQuery(
    unsigned char *name,
    u_long winsaddr,
    u_short TransID
    )
{
    struct sockaddr_in destad;
    char    lpResults[MAX_SIZE] = {0};
    char    paddedname[NBT_NONCODED_NMSZ];

    struct
    {
        u_short TransactionID;
        u_short Flags;
        u_short QuestionCount;
        u_short AnswerCount;
        u_short NSCount;
        u_short AdditionalRec;
        u_char  QuestionName[NBT_NAMESIZE];
        u_short QuestionType;
        u_short QuestionClass;
    } NameQuery;

    memset(paddedname, 0x20, sizeof(paddedname));
    memcpy(paddedname, name, strlen(name));

    NBEncode(NameQuery.QuestionName, paddedname);

    NameQuery.TransactionID = htons(TransID);
    NameQuery.Flags = htons(0x0100);
    NameQuery.QuestionCount = htons(1);
    NameQuery.AnswerCount = 0;
    NameQuery.NSCount = 0;
    NameQuery.AdditionalRec = 0;
    NameQuery.QuestionType = htons(0x0020);
    NameQuery.QuestionClass = htons(1);

    destad.sin_family = AF_INET;
    destad.sin_port = htons(137);
    destad.sin_addr.s_addr = winsaddr;

    if (sendto(sd, (char *)&NameQuery, sizeof(NameQuery), 0,
                   (struct sockaddr *)&destad, sizeof(destad)) == SOCKET_ERROR)
    {
        wsprintfA(lpResults, "sendto() failed. Error %d. \r\n", WSAGetLastError());

        AddStatusMessage(lpResults);

        // exit(1);
        return;
    }
}

/*******************************************************************/
/*                                                                 */
/* Wait for a Name Response which matches the Transaction ID       */
/*                                                                 */
/* recvaddr is the ip address returned by the wins server          */
/*                                                                 */
/*******************************************************************/

int
_stdcall
GetNameResponse(
    u_long * recvaddr,
	u_short  TransactionID
    )

{
    char lpResults[100] = {0};
    int i;
    int len;
    int rslt;
    u_long AnswerAddr;
    struct sockaddr_in addr;
    NameResponse * pNameResponse = NULL;
    BYTE Buf[NAME_RESPONSE_BUFFER_SIZE] = {0};

    i = 0;
    while (i < 15)
    {
        addrlen = sizeof(addr);
        if ((len=recvfrom(sd, (char *) Buf, sizeof(Buf), 0,
                     (struct sockaddr *)&addr, &addrlen)) < 0)
        {
            rslt = WSAGetLastError();
            if (rslt == WSAEWOULDBLOCK)
            {
                Sleep(100);
                i++;
                continue;
            }
            else
            {
                wsprintfA(lpResults, "recvfrom() failed. Error %d. \r\n", rslt);
                AddStatusMessage(lpResults);

                return WINSTEST_NO_RESPONSE;
            }
        }

        pNameResponse = (NameResponse *) Buf;

        if (TransactionID == htons(pNameResponse->TransactionID))
        {
            if (htons(pNameResponse->AnswerCount) == 0)
            {
                *recvaddr = 0;
                return(WINSTEST_NOT_FOUND);
            }

            AnswerAddr = (pNameResponse->AnswerAddr2 << 16) | pNameResponse->AnswerAddr1;
            *recvaddr = AnswerAddr;

            return(WINSTEST_FOUND);
        }
    }

    *recvaddr = 0;

    return(WINSTEST_NO_RESPONSE);
}

INT
_stdcall
InitNameCheckSocket()
{
	char lpResults[MAX_SIZE];

    /*  Set up a socket to use for querys and responses   */

    WSAStartup( 0x0101, &WsaData ); // make sure winsock is happy - noop for now

    if ((sd = socket( AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET)
    {
        //wsprintfA(lpResults, "socket() failed.  Error %d. \r\n", WSAGetLastError());
        //AddStatusMessage(lpResults);

		return WSAGetLastError();
    }

    myad.sin_family = AF_INET;
    myad.sin_addr.s_addr = INADDR_ANY;
    myad.sin_port = htons(0);

    if (bind( sd, (struct sockaddr *)&myad, sizeof(myad) ) < 0)
    {
        //wsprintfA(lpResults, "bind() failed. Error %d. \r\n", WSAGetLastError());
        //AddStatusMessage(lpResults);

        closesocket( sd );
		return WSAGetLastError();
    }

    if (ioctlsocket(sd, FIONBIO, &NonBlocking) < 0)
    {
        //wsprintfA(lpResults, "ioctlsocket() failed. Error %d. \r\n", WSAGetLastError());
        //AddStatusMessage(lpResults);
		return WSAGetLastError();
    }

	return 0;
}

INT
_stdcall
CloseNameCheckSocket()
{
	closesocket(sd);

	WSACleanup();

	return 0;
}

DWORD WINAPI ThreadProc(LPVOID pData)
{
    DialogBox(g_hInstance,
	 	      MAKEINTRESOURCE(IDD_VERSION_CONSIS),
			  g_hwndParent,
			  dlgProc);

    return 29;
}

void CreateConsistencyStatusWindow(HINSTANCE hInstance, HWND hWndParent)
{
	// dialog creation
    // create a new window if we don't have one or it possibly went away
    DWORD dwId;
    MSG   msg;

    g_hInstance = hInstance;
    g_hwndParent = hWndParent;

    if (g_wndDlg && !IsWindow(g_wndDlg))
    {
        CloseHandle(g_hThread);
        g_wndDlg = NULL;
    }

    if (!g_wndDlg)
    {
        g_hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, &dwId);
        while (g_wndDlg == NULL)
        {
            // give the thread a chance to run
            Sleep(0);

            // since we are all on the same message pump, we need to
            // give the system a chance to handle messages
            while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
	        {
		        TranslateMessage(&msg);
		        DispatchMessage(&msg);
	        }
        }
    }
}

void DestroyConsistencyStatusWindow()
{
    BOOL bResult;

	if (IsWindow(g_wndDlg))
    {
        bResult = PostMessage(g_wndDlg, WM_COMMAND, MAKEWPARAM(0, IDCANCEL), 0);
    }

    if (g_wndDlg)
    {
        WaitForSingleObject(g_hThread, 5000);

        CloseHandle(g_hThread);

        g_hThread = NULL;
        g_wndDlg = NULL;
    }
}

void EnableConsistencyCloseButton(BOOL bEnable)
{
    HWND    hButton;
    HMENU   hSysMenu;
    RECT    rect;

    if (IsWindow(g_wndDlg))
    {
        // enable/disable the button
        hButton = GetDlgItem(g_wndDlg, IDCANCEL);
        EnableWindow(hButton, bEnable);

        // now the system menu
        hSysMenu = GetSystemMenu(GetConsistencyStatusWnd(), FALSE);
        EnableMenuItem(hSysMenu, SC_CLOSE, bEnable ? MF_ENABLED : MF_DISABLED);

        GetWindowRect(GetConsistencyStatusWnd(), &rect);
        InvalidateRect(GetConsistencyStatusWnd(), &rect, TRUE);
    }
}

void ClearConsistencyStatusWindow()
{
    HWND hEdit;

    if (IsWindow(g_wndDlg))
    {
        hEdit = GetDlgItem(g_wndDlg, IDC_EDIT_MESSAGE);
        SetWindowText(hEdit, TEXT(""));
    }
}

HWND GetConsistencyStatusWnd()
{
    return g_wndDlg;
}

// this function should be called once before calling either AddWinsServer
// or CheckRegisteredNames
INT
_stdcall
InitNameConsistency(HINSTANCE hInstance, HWND hWnd)
{
	int status = 0;

    // initialize things
	NumWinServers = 0;
    memset(WinServers, 0, sizeof(WinServers));

    CreateConsistencyStatusWindow(hInstance, hWnd);

    InitNameCheckSocket();

	return status;
}

INT
_stdcall
AddWinsServer(char * szServer, BOOL fVerifyWithPartners)
{
    if (!InitServers(szServer, fVerifyWithPartners))
	{
        return FALSE;
	}

	return TRUE;
}

/*********************************************************************/
/*      M a i n                                                      */
/*                                                                   */
/* 27-Dec-1995  CDermody    Rather that report 'is not responding'   */
/*                          for partial response, use multiple       */
/*                          passes over those that were incomplete   */
/*                          and report 'never responded' only for    */
/*                          those that never did.                    */
/*                          Add mechanism to query the purported     */
/*                          owner of the address to see if the       */
/*                          service really exists there.             */
/*********************************************************************/
/*
_cdecl
main (argc, argv)
    int argc;
    char *argv[];
*/
INT
_stdcall
CheckNameConsistency(char* szName)
{
    int             status = 0;
    int             i;
    int             Pass;
    int             ServerInx, NameInx, Inx;
    struct in_addr  retaddr;
    struct in_addr  tempaddr;
    u_long          temp;
    WINSERVERS *    ServerTemp;
    int             retry;
	FILE *          nf;
    TCHAR           szBuffer[MAX_SIZE] = {0};
    TCHAR           szNum[10];
    char            lpResults[100] = {0};

	// initialize some things
    memset(NBNames, 0, sizeof(NBNames));
    memset(VerifiedAddress, 0, sizeof(VerifiedAddress));

    for (i = 0; i < MAX_SERVERS; i++)
    {
        WinServers[i].LastResponse = -1;
        WinServers[i].fQueried = FALSE;
        WinServers[i].Valid = 0;
        WinServers[i].Failed = 0;
        WinServers[i].Retries = 0;
        WinServers[i].Completed = 0;
    }

	SetCursor(LoadCursor(0, MAKEINTRESOURCE(IDC_WAIT)));

	// call InitNameConsistency, then AddWinsServer to build the list of servers
	// to verify this name against.
	NumNBNames = 1;
	NameInx = 0;

	NBNames[NameInx] = malloc(NBT_NONCODED_NMSZ);
    if (NBNames[NameInx] == NULL)
    {
        strcat(lpResults, "malloc(17) failed.\r\n");

        //DestroyStatusWindow();

        return FALSE;
    }

	strcpy(NBNames[NameInx], szName);

    for (Pass = 1; Pass < 3; Pass++)
    {
		_tcscpy(szBuffer, L"");
		_tcscat(szBuffer, L"\r\n");
        _tcscat(szBuffer, L"Pass ");
		_itot(Pass, szNum, 10);
		_tcscat(szBuffer, szNum);
		_tcscat(szBuffer, L"\r\n");
		_tcscat(szBuffer, L"\r\n");

        AddStatusMessageW(szBuffer);

        /*  We initially have no failed servers   */

        for (ServerInx = 0; ServerInx < NumWinServers; ServerInx++)
        {
            ServerTemp = &WinServers[ServerInx];
			ServerTemp->Failed = 0;
        }

        for (NameInx = 0; NameInx < NumNBNames; NameInx++)
        {
            for (ServerInx = 0; ServerInx < NumWinServers; ServerInx++)
            {
                ServerTemp = &WinServers[ServerInx];

                if (ServerTemp->Completed)
                {
                    continue;
                }

                retry = 0;
                TranID++;

RetryLoop:
                strcpy(lpResults, "");
                strcat(lpResults, "Sending NameQuery to the server [");
				strcat(lpResults, inet_ntoa(ServerTemp->Server));
				strcat(lpResults, "] for name " );
				strcat(lpResults, NBNames[NameInx]);

                //AddStatusMessage(lpResults);
                SendNameQuery(NBNames[NameInx],
                              ServerTemp->Server.s_addr,
                              TranID);

                switch (GetNameResponse(&retaddr.s_addr, TranID))
                {
                case WINSTEST_FOUND:     // found
                    ServerTemp->RetAddr.s_addr = retaddr.s_addr;
                    ServerTemp->Valid = 1;
                    ServerTemp->LastResponse = NameInx;

                    if (retaddr.s_addr == VerifiedAddress[NameInx])
                    {
                        // this address has already been verified... don't
                        // do the checking again
						strcat(lpResults, "; OK.\r\n");

                        AddStatusMessage(lpResults);
                        break;
                    }

                    status = VerifyRemote(inet_ntoa(ServerTemp->RetAddr),
                                          NBNames[NameInx]);


                    if (WINSTEST_VERIFIED == status)
                    {
						strcat(lpResults, "; OK.\r\n");

                        AddStatusMessage(lpResults);

                        VerifiedAddress[NameInx] = retaddr.s_addr;
                    }
                    else
                    {
						strcat(lpResults, "; could not be verified.\r\n");

                        AddStatusMessage(lpResults);
                    }

                    break;

                case WINSTEST_NOT_FOUND:     // responded -- name not found
                    ServerTemp->RetAddr.s_addr = retaddr.s_addr;
                    ServerTemp->Valid = 0;
                    ServerTemp->LastResponse = NameInx;

					strcat(lpResults, "; Name not found!\r\n");

                    AddStatusMessage(lpResults);

                    break;

                case WINSTEST_NO_RESPONSE:     // no response
                    ServerTemp->RetAddr.s_addr = retaddr.s_addr;
                    ServerTemp->Valid = 0;
                    ServerTemp->Retries++;

					strcat(lpResults, "; No response.\r\n");

                    AddStatusMessage(lpResults);

                    retry++;
                    if (retry > 2)
                    {
                        ServerTemp->Failed = 1;
                        continue;
                    }

                    goto RetryLoop;

                }   // switch GetNameResponse
            }   // for ServerInx

            for (ServerInx = 0; ServerInx < NumWinServers; ServerInx++)
            {
                ServerTemp = &WinServers[ServerInx];
                if (ServerTemp->Completed)
                {
                    continue;
                }

                if (ServerTemp->Valid)
                {
                    temp = ServerTemp->RetAddr.s_addr;
                    break;
                }
            }   // for ServerInx

            for (ServerInx = 0; ServerInx < NumWinServers; ServerInx++)
            {
                ServerTemp = &WinServers[ServerInx];
                if (ServerTemp->Completed)
                {
                    continue;
                }

                if ( (ServerTemp->Valid) )
                {
                    if ((temp != ServerTemp->RetAddr.s_addr)
                        || (0 != VerifiedAddress[NameInx]
                            && temp != VerifiedAddress[NameInx]) )
                    {
						strcpy(lpResults, "");
                        strcat(lpResults, "Inconsistency found with WINS for NetBIOS name ");
						strcat(lpResults, NBNames[NameInx]);
						strcat(lpResults, "\r\n");

                        AddStatusMessage(lpResults);

                        if (0 != VerifiedAddress[NameInx])
                        {
                            tempaddr.s_addr = VerifiedAddress[NameInx];

							strcpy(lpResults, "");
							strcat(lpResults,"NetBIOS name has verified address (");
							strcat(lpResults,inet_ntoa(tempaddr));
							strcat(lpResults, "). \r\n");

                            AddStatusMessage(lpResults);
                        }

                        for (Inx = 0; Inx < NumWinServers; Inx++)
                        {
                            if (WinServers[Inx].Valid)
                            {
								strcpy(lpResults, "");
                                strcat(lpResults,"    NameQuery(");
								strcat(lpResults,inet_ntoa(WinServers[Inx].Server));
								strcat(lpResults, " \\");
								strcat(lpResults, NBNames[NameInx]);
								strcat(lpResults, ")");

                                strcat(lpResults , " = ");
								strcat(lpResults, inet_ntoa(WinServers[Inx].RetAddr));
								strcat(lpResults, " \r\n");

                                AddStatusMessage(lpResults);
                            }
                        }
                        break;
                    }
                }
            }   // for ServerInx
        }   // for NameInx

        for (ServerInx = 0; ServerInx < NumWinServers; ServerInx++)
        {
            ServerTemp = &WinServers[ServerInx];
            if (!ServerTemp->Failed)
            {
                ServerTemp->Completed = 1;
            }
        } // for ServerInx
    }   // for Pass

    for (ServerInx = 0; ServerInx < NumWinServers; ServerInx++)
    {
        ServerTemp = &WinServers[ServerInx];
        if ((-1) == ServerTemp->LastResponse)
        {
			strcpy(lpResults, "");
            strcat(lpResults,"WINS Server ");
			strcat(lpResults, inet_ntoa(ServerTemp->Server));
			strcat(lpResults, " never responded! \r\n");

            AddStatusMessage(lpResults);
        }
        else if (0 == ServerTemp->Completed)
        {
			strcpy(lpResults, "");
            strcat(lpResults, "WINS Server ");
			strcat(lpResults, inet_ntoa(ServerTemp->Server));
			strcat(lpResults, " incomplete!\r\n");

            AddStatusMessage(lpResults);
        }
    }   // for ServerInx

    for (NameInx = 0; NameInx < NumNBNames; NameInx++)
    {
        if (0 == VerifiedAddress[NameInx])
        {
			strcpy(lpResults, "");
            strcat(lpResults,"Could not verify address for name (");
			strcat(lpResults, NBNames[NameInx]);
			strcat(lpResults, ").\r\n\r\n");

            AddStatusMessage(lpResults);
        }
    }   // for NameInx
    // exit(0);

	if (NBNames[0])
        free(NBNames[0]);

    return 1;   // just to keep the compiler happy -- why do we have to?
}