windows-xp/Source/XPSP1/NT/net/wins/server/nms/nmschl.c

/*+

Copyright (c) 1990  Microsoft Corporation

Module Name:
	nmschl.c

Abstract:
	This module contains the name challenge functions


Functions:

	NmsChlInit
	NmsChlHdlNamReg
	ChlThdInitFn
	HandleWrkItm
	WaitForRsp
	ProcRsp
	ChlUpdateDb
	InfRemWins


Portability:

	This module is portable

Author:

	Pradeep Bahl (PradeepB)  	Jan-1993

Revision History:

	Modification date	Person		Description of modification
        -----------------	-------		----------------------------
--*/

/*
 *       Includes
*/
#include <time.h>
#include "wins.h"
#include "nms.h"
#include "nmsdb.h"
#include "winsque.h"
#include "comm.h"
#include "winsthd.h"
#include "winsmsc.h"
#include "winsevt.h"
#include "winscnf.h"
#include "nmsnmh.h"
#include "nmschl.h"
#include "nmsmsgf.h"
#include "rplmsgf.h"


/*
 *	Local Macro Declarations
*/


//
// Computation of the time it can take for a WINS to conduct a challenge
// (in msecs)
//
#define WACK_TTL			(((1 << WinsCnf.MaxNoOfRetries) * \
					 WinsCnf.RetryInterval) + \
					WAIT_PAD)

//
// WAIT_PAD is used to increase the TTL sent to an NBT node that sent us the
// name registration request.  The pad is on top of the TTL we compute
// (WACK_TLL) above to determine how much time WINS will take to conduct
// the challenge. The pad is supposed to take care of the situation where
// WINS is dragging its feet due to a sudden transient peak in network
// load or cpu load.

#define  WAIT_PAD		       500	//500 msecs in case WINS is very
					        //busy

/*
 *	Global Variable Definitions
 */

//
// heap used to allocate work items for the challenge request and response
// queues
//
HANDLE  	   NmsChlHeapHdl;



/*
 *	Local Variable Definitions
 */
//
// It maintains a running count of how many responses to queries/releases are
// pending
//
DWORD		   scPendingRsp = 0;

//
// The maximum # of requests that the name challenge manager sends at any
// one time. This number is never allowed to go over
// NMSCHL_MAX_CHL_REQ_AT_ONE_TIME.  In fact after one series of
// challenges are over (i.e. either they have timed out or we have received
// responses for them, this counter is reinitialized to 0)
//
// This var. is reinitialized to zero when a batch of challenge requests
// is acquired from the one or more of the challenge request queues
//
// It maintains the total # of requests acquired from the request queues.
//
DWORD		   sMaxTransId = 0;
#ifdef WINSDBG
DWORD              NmsChlNoOfReqNbt;
DWORD              NmsChlNoOfReqRpl;
DWORD              NmsChlNoNoRsp;
DWORD              NmsChlNoInvRsp;
DWORD              NmsChlNoRspDropped;
DWORD              NmsChlNoReqDequeued;
DWORD              NmsChlNoRspDequeued;
DWORD              NmsChlNoReqAtHdOfList;
#endif
//
// We have a dimension 1 larger than the max. number of challenge requests
// handled at one time so that we can terminate the list with a NULL.
//
STATIC  PCHL_REQ_WRK_ITM_T   spReqWrkItmArr[NMSCHL_MAX_CHL_REQ_AT_ONE_TIME + 1];

/*
 *	Local Function Prototype Declarations
 */
STATIC
DWORD
ChlThdInitFn(
	IN LPVOID pThreadParam
	);

STATIC
STATUS
HandleWrkItm(
	PCHL_REQ_WRK_ITM_T	*ppaWrkItm,
	DWORD			MaxTransId,
	BOOL			fRetry	
	);


STATIC
STATUS
WaitForRsp(
	   VOID
	);

STATIC
STATUS
ProcRsp(
	VOID
	);

STATIC
STATUS
ChlUpdateDb(
        BOOL                    fUpdVersNoOfCnfRec,
	WINS_CLIENT_E		Client_e,
	PNMSDB_ROW_INFO_T	pRowInfo,
	DWORD			OwnerIdInCnf,
	BOOL			fRefreshOnly
	);
STATIC
VOID
InfRemWins(
	PCHL_REQ_WRK_ITM_T	pWrkItm
	  );

STATIC
STATUS
ProcAddList(
	PCHL_REQ_WRK_ITM_T	pReqWrkItm,
	PNMSMSGF_CNT_ADD_T	pCntAdd,
	LPBOOL			pfAdded
	);

/* prototypes for functions local to this module go here */

STATUS
NmsChlInit(
	VOID
	)

/*++

Routine Description:

	This function is called to initialize the name challenge component

Arguments:
	None

Externals Used:
	None

	
Return Value:
	WINS_SUCCESS or a failure code.  The function can also raise an
	exception in case of fatal errors

Error Handling:

Called by:
	Init in nms.c

Side Effects:
	
Comments:
	None
--*/

{

	STATUS RetStat = WINS_SUCCESS;
	
	/*
	* Create heap for allocating name challenge work items
	*/
        DBGPRINT0(HEAP_CRDL, "NmsChlInit: Chl. Mgr. heap\n");
	NmsChlHeapHdl =  WinsMscHeapCreate(
		0,    /*to have mutual exclusion	*/
		NMSCHL_INIT_BUFF_HEAP_SIZE
		);


	//
	//  Initialize the spReqWrkItmArr elements to NULL
	//	
	//  ANSI C should do it for us (all externals are initialized
	//  automatically, but I am taking no chances).  This is
	//  init time overhead.
	//
	WINSMSC_FILL_MEMORY_M((void *)spReqWrkItmArr, sizeof(spReqWrkItmArr), 0);
	
	
	//
	// Create the response event handle.  This event is signaled
	// by the UDP listener thread when it stores a response
	// in the spReqWrkItmArr array
	//
	WinsMscCreateEvt(
			  TEXT("WinsNmsChlRspEvt"),
			  FALSE,	//auto-reset
			  &QueNmsCrqQueHd.EvtHdl
			);

	//
	// Initialize the critical section for the response queue
	//				
	InitializeCriticalSection(&QueNmsCrqQueHd.CrtSec);
	
	//
	//Initialize the queue head for the response queue
	//
	InitializeListHead(&QueNmsCrqQueHd.Head);
	
	//
	// Since this thread deals with two request queues instead of
	// one, we need to create one more
	// critical section and event handle and initialize the
	// queue head of this  other queue.  The second queue
	// will be created when we create the thread
	//	
	InitializeListHead(&QueNmsRrcqQueHd.Head);	

	
	WinsMscCreateEvt(
			     TEXT("WinsNmsChlReplReqEvt"),
			     FALSE,		//Auto Reset
			     &QueNmsRrcqQueHd.EvtHdl
			  );

	InitializeCriticalSection(&QueNmsRrcqQueHd.CrtSec);

	//
	//
	// Create the name challenge thread.  This function will
	// initialize the critical section and the Evt handle passed
	// to it
	//	
	RetStat = WinsMscSetUpThd(
			&QueNmsNrcqQueHd,		//queue head
			ChlThdInitFn,		        //init function
			NULL,	   		        // no param
			&WinsThdPool.ChlThd[0].ThdHdl,
			&WinsThdPool.ChlThd[0].ThdId
			);

	if (RetStat == WINS_SUCCESS)
	{
		WinsThdPool.ChlThd[0].fTaken = TRUE;
		WinsThdPool.ThdCount++;  //increment the thread count
	}
	return(RetStat);

} // NmsChlInit()



STATUS
NmsChlHdlNamReg(
	IN NMSCHL_CMD_TYP_E   CmdTyp_e,
	IN WINS_CLIENT_E      Client_e,
	IN PCOMM_HDL_T        pDlgHdl,	
	IN MSG_T              pMsg,
        IN MSG_LEN_T          MsgLen,
	IN DWORD	      QuesNamSecLen,
	IN PNMSDB_ROW_INFO_T  pNodeToReg,
	IN PNMSDB_STAT_INFO_T  pNodeInCnf,
//	IN PCOMM_ADD_T	      pAddOfNodeInCnf,
	IN PCOMM_ADD_T	      pAddOfRemWins
	)

/*++

Routine Description:
	This function is called to handle a name registration that resulted
	in a conflict


Arguments:
	CmdTyp_e  - Type of command (challenge, challenge and release if
			challenge succeeds, release -- see nmschl.h)
	Client_e  - client (nms or replicator)
	pDlgHdl   - Dlg hdl (only if client is nms)
	pMsg      - Buffer containing request (only if client is nms)
	Msglen    - length of above buffer
	QuesNamSecLen - Length of question name section in buffer
	pNodeToreq  - Info about name to register
	pAddOfNodeInCnf - address of node in conflict (i.e. has name) with the
			  node trying to register

Externals Used:
	None

	
Return Value:

	WINS_SUCCESS or a failure code.  The function can also raise an
	exception in case of fatal errors

Error Handling:

Called by:
	NmsNmhNamRegInd, NmsNmhNamRegGrp (in an Nbt thread)

Side Effects:

Comments:
	None
--*/

{


	STATUS RetStat = WINS_SUCCESS;
#if USENETBT == 0
	BYTE   aBuff[COMM_DATAGRAM_SIZE];
#else
	BYTE   aBuff[COMM_DATAGRAM_SIZE + COMM_NETBT_REM_ADD_SIZE];
#endif
	DWORD  BuffLen;
	
	DBGENTER("NmsChlHdlNamReg\n");

	//
	//  Before inserting the request, send a WACK. The Time period
	//  in the TTL should be equal to WinsCnf.RetryInterval
	//
	//  Note: WACK is sent only if pDlgHdl is NON-NULL since that
	//        implies that the request is from an NBT thread
	//
	if (pDlgHdl != NULL)
	{
	
		COMM_ADD_T	NodeToSendWACKTo;
                DWORD       WackTtl;

                if (NMSDB_ENTRY_MULTIHOMED_M(pNodeInCnf->EntTyp))
                {
                        WackTtl = pNodeInCnf->NodeAdds.NoOfMems * WACK_TTL;
                }
                else
                {
                        WackTtl = WACK_TTL;
                }

		//
		// Format the WACK
		//
		NmsMsgfFrmWACK(
#if USENETBT == 0
				aBuff,
#else
				aBuff + COMM_NETBT_REM_ADD_SIZE,
#endif
				&BuffLen,
				pMsg,
				QuesNamSecLen,
				WackTtl
			     );


		//
		// We extract the address from the DlgHdl and don't use
		// the address passed in the name packet since a node
		// can register a name with an address different than
		// its own.
		//
		// RFCs are silent about the above
		//
		NodeToSendWACKTo.AddLen    = COMM_IP_ADD_SIZE;
		COMM_GET_IPADD_M(pDlgHdl, &NodeToSendWACKTo.Add.IPAdd);
		NodeToSendWACKTo.AddTyp_e  = COMM_ADD_E_TCPUDPIP;

		DBGPRINT2(CHL, "NmsChlHdlNamReg: Sending WACK to node with name = (%s) and address = (%X)\n", pNodeToReg->pName, NodeToSendWACKTo.Add.IPAdd);

		//
		// Send the WACK.  Use the explicit NBT dlg handle since the
		// WACK has to be sent as a UDP packet.
		//
		ECommSendMsg(
			&CommExNbtDlgHdl,
			&NodeToSendWACKTo,
#if USENETBT == 0
			aBuff,
#else
			aBuff + COMM_NETBT_REM_ADD_SIZE,
#endif	
			BuffLen

 	    	            );
	}	

        WINSMSC_COPY_MEMORY_M(
                pNodeToReg->Name,
                pNodeToReg->pName,
                pNodeToReg->NameLen
                        );
	//
	// Insert the request in the challenge queue so that the challenge
	// thread can get it
	//
	RetStat = QueInsertChlReqWrkItm(
			  CmdTyp_e,
			  Client_e,
			  pDlgHdl,
			  pMsg,
			  MsgLen,
			  QuesNamSecLen,
			  pNodeToReg,
			  pNodeInCnf,
			  pAddOfRemWins
			  );

#ifdef WINSDBG
        if (Client_e == WINS_E_NMSNMH)
        {
           NmsChlNoOfReqNbt++;
        }
        else
        {
           NmsChlNoOfReqRpl++;
        }
#endif
	DBGLEAVE("NmsChlHdlNamReg\n");
	return(RetStat);

} // NmsChlHdlNamReg()	





DWORD
ChlThdInitFn(
	IN LPVOID pThreadParam
	)
	
/*++

Routine Description:
	This is the initialization function for the name challenge thread


Arguments:
	pThreadParam  - NOT USED

Externals Used:
	None

	
Return Value:

	This function should never return.  If it returns it means there
	is some problem.  WINS_FAILURE is returned when this happens

Error Handling:

Called by:
	NmsChlInit

Side Effects:
	A name challenge thread is created

Comments:
	None
--*/

{
	
	STATUS 			RetStat = WINS_SUCCESS;
	HANDLE			ThdEvtHdlArray[3];	
	DWORD			ArrInd;		//index of hdl signaled
	PCHL_REQ_WRK_ITM_T	pWrkItm = NULL;
    BOOL                    fTablesOpen = FALSE;

    BOOL    bRecoverable = FALSE;
	UNREFERENCED_PARAMETER(pThreadParam);

while(TRUE)
{
try {
  if (!bRecoverable)
  {
	/*

	   Initialize the thread with the database
	*/
	NmsDbThdInit(WINS_E_NMSCHL);
	DBGMYNAME("Name Challenge Thread");

	/*
	 *  Initialize the array of handles on which the challenge thread will
	 *  wait.
	*/
	ThdEvtHdlArray[0]    =  NmsTermEvt;	        //termination event var
	ThdEvtHdlArray[1]    =  QueNmsNrcqQueHd.EvtHdl; //work queue event var
	ThdEvtHdlArray[2]    =  QueNmsRrcqQueHd.EvtHdl; //work queue event var

    bRecoverable = TRUE;
  }
	
	while (TRUE)
	{

		WinsMscWaitUntilSignaled(
				ThdEvtHdlArray,
				sizeof(ThdEvtHdlArray)/sizeof(HANDLE),
				&ArrInd,
                FALSE
					);	

		//
		// if NmsTermEvt was signaled, terminate self
		//
		if (ArrInd == 0)
		{
		      WinsMscTermThd(WINS_SUCCESS, WINS_DB_SESSION_EXISTS);
		}	

		while (TRUE)
		{	
			scPendingRsp      = 0;  //reinit TransId Counter to 0
			sMaxTransId       = 0;  //reinit MaxTransId Counter to 0
			RetStat =  QueRemoveChlReqWrkItm(
						ThdEvtHdlArray[ArrInd],
						(LPVOID *)spReqWrkItmArr,
						&sMaxTransId
						     );

			if (RetStat == WINS_NO_REQ)
			{
				break;   //break out of while loop	
			}	
			else   // one or more items were dequeued
			{
#ifdef WINSDBG
                                NmsChlNoReqDequeued += sMaxTransId;
#endif
				NmsDbOpenTables(WINS_E_NMSCHL);
                                fTablesOpen = TRUE;
				scPendingRsp = sMaxTransId;	

                                QueChlWaitForRsp();
				//
				// If HandleWrkItm fails, it will raise
				// an exception
				//
				HandleWrkItm(
					      spReqWrkItmArr,
					      sMaxTransId,
					      FALSE  //not a retry
					    );
				//
				// Wait for responses to all requests sent
				// WaitForRsp() function will return only
				// after all requests are done with
				// as a result of responses having been
				// received for them, they having timed out
				// after the requisite number of retries or
				// a mix of both.
				//
				WaitForRsp();

                                QueChlNoWaitForRsp();

				NmsDbCloseTables();
                                fTablesOpen = FALSE;

			}
		} // end of while (TRUE)
      } // end of while (TRUE)

     } // end of try {..}

except (EXCEPTION_EXECUTE_HANDLER) {
  if (bRecoverable)
  {
    DWORD   No;
    DWORD ExcCode = GetExceptionCode();
    DBGPRINTEXC("ChlThdInitFn: Name Challenge Thread");
    //
    // If ExcCode is NBT_ERR, it could mean that the main thread
    // closed the netbt handle.
    //
    if ( ExcCode == WINS_EXC_NBT_ERR)
    {
         if (WinsCnf.State_e == WINSCNF_E_TERMINATING)
         {
	        WinsMscTermThd(WINS_FAILURE, WINS_DB_SESSION_EXISTS);
         }
         else
         {
            //if ((WinsCnf.State_e != WINSCNF_E_PAUSED) && (!fWinsCnfInitStatePaused))
            {
	           WINSEVT_LOG_M(ExcCode, WINS_EVT_CHL_EXC);
            }
         }
    }
    else
    {
	   WINSEVT_LOG_M(ExcCode, WINS_EVT_CHL_EXC);
    }
	
    if(fTablesOpen)
    {
	NmsDbCloseTables();
        fTablesOpen = FALSE;
    }

    //
    // For all requests that were never sent, free them
    //
    for (No=0; No < sMaxTransId; No++)
    {
           if (spReqWrkItmArr[No] != NULL)
           {
                if (spReqWrkItmArr[No]->pMsg != NULL)
                {
		   ECommFreeBuff(spReqWrkItmArr[No]->pMsg);
                }
		QueDeallocWrkItm(NmsChlHeapHdl, spReqWrkItmArr[No]);
           }
    }

    QueChlNoWaitForRsp();

  } // end of if (bRecoverable)
  else // if (bRecoverable)
  {
	DBGPRINTEXC("ChlThdInitFn: Name Challenge Thread");
	//
	// If NmsDbThdInit comes back with an exception, it is possible
	// that the session has not yet been started.  Passing
	// WINS_DB_SESSION_EXISTS however is ok
	//
	//
        WINSEVT_LOG_M(GetExceptionCode(), WINS_EVT_CHL_ABNORMAL_SHUTDOWN);
	WinsMscTermThd(WINS_FAILURE, WINS_DB_SESSION_EXISTS);	
  } // if (bRecoverable)
} // exception handler
} // while(TRUE)
  //
  // We should never get here
  //
  return(WINS_FAILURE);

}  // ChlThdInitFn()



STATUS
HandleWrkItm(
	IN PCHL_REQ_WRK_ITM_T	*ppaWrkItm,
	IN DWORD		MaxTransId,
	IN BOOL			fRetry
	)

/*++

Routine Description:
	This function is called to send a name query to the node that
	was confliciting


Arguments:
	ppaWrkItm  - Address of an array of pointers to work items that
		    got queued in one or more of the challenge queues
		
	MaxTransId - One more than the index of the last filled entry in
		     the array

	fRetry	   - indicates whether HandleWrkItm is being called to
		     retry a request

Externals Used:
	None

	
Return Value:

   Success status codes -- WINS_SUCCESS
   Error status codes   -- WINS_FAILURE

Error Handling:

Called by:
	ChlThdInitFn(), WaitForRsp

Side Effects:

Comments:
	None
--*/

{
#if USENETBT == 0
	BYTE 	        	Buff[COMM_DATAGRAM_SIZE];
#else
	BYTE 	        	Buff[COMM_DATAGRAM_SIZE + COMM_NETBT_REM_ADD_SIZE];
#endif
	MSG_LEN_T		MsgLen;
	LPBYTE			pName           = NULL;
	DWORD			NameLen         = 0;
	PCOMM_ADD_T  		pAddOfNodeInCnf = NULL;
	NMSCHL_CMD_TYP_E	CmdTyp_e;
	NMSMSGF_NODE_TYP_E	NodeTyp_e;
	DWORD			cPendingRsp     = 0; //count of pending
						     //responses
	volatile DWORD		i;

	DBGENTER("HandleWrkItm\n");

PERF("For retries, reuse the buffer sent for the initial try. This means")
PERF("that I need to allocate it and store it in the request work item")
PERF("instead of using the stack for it")
	UNREFERENCED_PARAMETER(fRetry);

	//
	// Loop over all slots of the array that were filled as a result of
	// the acquisition of requests from the challenge request queue(s)
	//
FUTURES("Remove the exception handler out of production code")
try {
        DBGPRINT1(CHL, "HandleWrkItm: Max Trans. Id = (%d)\n", MaxTransId);
	for(
		i = 0;
		i < MaxTransId;
		ppaWrkItm++, i++
	    )
	{
		//
		// if we have hit an empty slot, it means that this function
		// has been called to retry one or more requests that
		// did not get satisfied in the first wait period.  The empty
		// slot indicates that a request that occupied this slot
		// got satisfied in one of the earlier retries.  Just
		// skip the empty slot
		//
		if (fRetry && (*ppaWrkItm == NULL))
		{
			DBGPRINT1(CHL, "HandleWrkItm: HIT a NULL entry. Trans. Id = (%d)\n", i);
			continue;
		}

		(*ppaWrkItm)->NodeToReg.pName = (*ppaWrkItm)->NodeToReg.Name;

		CmdTyp_e  	= (*ppaWrkItm)->CmdTyp_e;
		NodeTyp_e 	= (*ppaWrkItm)->NodeToReg.NodeTyp;

		pName      = (*ppaWrkItm)->NodeToReg.pName;

		//
		// if the first character is 0x1B, swap the bytes
		// This is for supporting the browser. See
		// NmsMsgfProcNbtReq
		//
		if (*pName == 0x1B)
		{
			WINS_SWAP_BYTES_M(pName, pName + 15);
		}
       	        NameLen    = (*ppaWrkItm)->NodeToReg.NameLen;
		
	
		//
		// get the last address (the only address unless the node in
		// conflict is a multihomed node) from the list of addresses
		//
        	pAddOfNodeInCnf = &((*ppaWrkItm)->NodeAddsInCnf.Mem[
					(*ppaWrkItm)->NoOfAddsToUse - 1	
							].Add);
		


		//
		//  If the command is directing us to do a challenge, send a
		//  name query
		//
		if (
			(CmdTyp_e == NMSCHL_E_CHL)
				||
			(CmdTyp_e == NMSCHL_E_CHL_N_REL_N_INF)
				||
			(CmdTyp_e == NMSCHL_E_CHL_N_REL)
		   )
	        {
			DBGPRINT3(CHL, "HandleWrkItm: Sending Name Query Request with Transid = (%d) to node with name = (%s) and address = (%X)\n", i, pName, pAddOfNodeInCnf->Add.IPAdd);
		
			NmsMsgfFrmNamQueryReq(
						i, 	//Transaction Id
#if USENETBT == 0
						Buff,
#else
						Buff + COMM_NETBT_REM_ADD_SIZE,
#endif
						&MsgLen,
						pName,
						NameLen
			    		     );	

			(*ppaWrkItm)->ReqTyp_e	        = NMSMSGF_E_NAM_QUERY;
		}	
		else   // has to be NMSCHL_E_REL or NMSCHL_E_REL_N_INF or
                       // NMSCHL_E_REL_ONLY
		{
		
			DBGPRINT3(CHL,
			    "HandleWrkItm: Sending Name Release Request with Transid = (%d) to node with name = (%s) and address = (%X)\n", i, pName, pAddOfNodeInCnf->Add.IPAdd);

			NmsMsgfFrmNamRelReq(
						i, 	//Transaction Id
#if USENETBT == 0
						Buff,
#else
						Buff + COMM_NETBT_REM_ADD_SIZE,
#endif
						&MsgLen,
						pName,
						NameLen,
						NodeTyp_e,
						pAddOfNodeInCnf
			    		  );	
			(*ppaWrkItm)->ReqTyp_e	        = NMSMSGF_E_NAM_REL;
		}

		ECommSendMsg(
				&CommExNbtDlgHdl,
				pAddOfNodeInCnf,
#if USENETBT == 0
				Buff,
#else
				Buff + COMM_NETBT_REM_ADD_SIZE,
#endif
				MsgLen
 	    	   	    );
		cPendingRsp++;
	}
	
	//
	// Do a sanity check
	//
#ifdef WINSDBG
	if (cPendingRsp != scPendingRsp)
	{
		DBGPRINT2(EXC, "SOFTWARE ERROR.  THE COUNT OF PENDING RESPONSES (%d) AS COMPUTED BY THE HandleWrkItm FN DOES NOT MATCH WITH THE EXPECTED ONE (%d)\n\n", cPendingRsp, scPendingRsp);
		WINS_RAISE_EXC_M(WINS_EXC_FATAL_ERR);
	}
#endif
}	
except(EXCEPTION_EXECUTE_HANDLER) {
	DBGPRINTEXC("HandleWrkItm");

        //
        // if the exception is an nbt error, it is expected if wins is in
        // the paused state.  Do not reraise the exception if this is the
        // case.  We want to go through our WaitRsp() function so that
        // the new records (replicas or registrations) get registered.
        // If this results in an inconsistent db, it will straighten
        // itself out soon after WINS is unpaused.
        //
        //if (!((GetExceptionCode() == WINS_EXC_NBT_ERR) && (WinsCnf.State_e ==
         //         WINSCNF_E_PAUSED) || (fWinsCnfInitStatePaused)))
        {
	   WINS_RERAISE_EXC_M();
        }
#if 0
        else
        {
            //
            // For all requests that were never sent, free them
            //
            for (No=0; No < sMaxTransId; No++, pReqWrkItm++)
            {
                if (pReqWrkItm != NULL)
                {
                  if (pReqWrkItm->pMsg != NULL)
                  {
		   ECommFreeBuff(pReqWrkItm->pMsg);
                  }
		  QueDeallocWrkItm(NmsChlHeapHdl, pReqWrkItm);

                }
            }
#endif
    }  // end of except { .. }

	DBGLEAVE("HandleWrkItm\n");
	return(WINS_SUCCESS);

} // HandleWrkItm()




STATUS
WaitForRsp(
	   VOID
	)

/*++

Routine Description:
	This function is responsible for waiting for responses to all
	requests that have been sent until either they time out or their
	responses are received.

Arguments:
	None

Externals Used:
	None

Return Value:
	WINS_SUCCESS or a failure code.  The function can also raise an
	exception in case of fatal errors

Error Handling:

Called by:

Side Effects:

Comments:
	None
--*/

{
	HANDLE ThdEvtHdlArray[2];	
    	DWORD  Count 	  = 0;
    	DWORD  TickCntSv;
 	DWORD  TickCnt    = 0;
	DWORD  TimeLeft;
	BOOL   fSignaled  = TRUE;	//was an event signaled
	DWORD  ArrInd     = 0;		//Not used
	DWORD  i 	  = 0;
	NMSMSGF_ERR_CODE_E Rcode_e = NMSMSGF_E_SRV_ERR;
	PCHL_REQ_WRK_ITM_T pReqWrkItm;
	NMSMSGF_RSP_INFO_T RspInfo;
        BOOL               fNewTry = TRUE;

	/*
	 *  Initialize the array of handles on which the challenge thread will
	 *  wait.
	*/
	ThdEvtHdlArray[0]    =  NmsTermEvt;	       //termination event var
	ThdEvtHdlArray[1]    =  QueNmsCrqQueHd.EvtHdl; //work queue event var
	
FUTURES("Remove the try out of production level code")
try {	
	while(TRUE)
	{
            if (fNewTry)
            {
	      //
	      // Get the number of msecs that have
	      // elapsed since windows was started
	      //
	      TickCntSv     = GetTickCount();
	      TimeLeft      = (1 << Count) * WinsCnf.RetryInterval;
            }

	    //
	    // Check if we have exhausted all retries for this batch of
	    // requests
            //
	    if (Count == WinsCnf.MaxNoOfRetries)
	    {
		
		//
		// CleanUp all spReqWrkItmArr entries which have not
		// been satisfied as yet.
		//
		for (i = 0; i < sMaxTransId; i++)
		{	
		   if (spReqWrkItmArr[i] != NULL)
		   {
#ifdef  WINSDBG
                      NmsChlNoNoRsp++;
#endif
		      pReqWrkItm = spReqWrkItmArr[i];

		      //
		      // Decrement the count of addresses to send query or
		      // release  to.
		      //
		      pReqWrkItm->NoOfAddsToUse--;	

		      //
		      //
		      // If there are no more addresses to challenge/release
                      //
		      if (pReqWrkItm->NoOfAddsToUse == 0)
		      {
						
			   //
			   // Just in case the record to register is a UNIQUE
			   // record.  No need to have an if (will add overhead)
			   //
			   pReqWrkItm->NodeToReg.pNodeAdd =
						&pReqWrkItm->AddToReg;
			   //
			   // In case the row we are putting in the database is
			   // one given to use by the Replicator, we don't
			   // need to set Rcode_e.  However, to avoid an if
			   // test, we just set it.  It will remain unused
			   //
                          if (pReqWrkItm->CmdTyp_e != NMSCHL_E_REL_ONLY)
                          {
			      if (
			        ChlUpdateDb(
                                        FALSE,
					pReqWrkItm->Client_e,
					&pReqWrkItm->NodeToReg,
					pReqWrkItm->OwnerIdInCnf,
					FALSE  //not just a refresh
					) ==  WINS_SUCCESS
			         )

			      {
				    DBGPRINT0(CHL, "WaitForRsp:Database Updated\n");
				    //
				    // if the remote WINS has to be notified of
				    // the update, do so
				    //
			             if(pReqWrkItm->CmdTyp_e ==
                                                  NMSCHL_E_REL_N_INF)
				    {
					   InfRemWins(pReqWrkItm);
				
				    }
				    Rcode_e = NMSMSGF_E_SUCCESS;
			      }
			      else
			      {
				     Rcode_e = NMSMSGF_E_SRV_ERR;
				     WINSEVT_LOG_M(
					    WINS_FAILURE,
					    WINS_EVT_CHLSND_REG_RSP_ERR
					     );

				     DBGPRINT0(CHL, "WaitForRsp:Server Error\n");
                              }
			  }
			
			  //
			  // Send a response only if the registration request
			  // was sent by an NBT node
			  //
			  if (
				(pReqWrkItm->Client_e == WINS_E_NMSNMH)
					&&
				(!pReqWrkItm->NodeToReg.fStatic)
					&&
				(!pReqWrkItm->NodeToReg.fAdmin)
			   )
			  {
				RspInfo.pMsg   = pReqWrkItm->pMsg;
				RspInfo.MsgLen = pReqWrkItm->MsgLen;
				RspInfo.QuesNamSecLen =
						pReqWrkItm->QuesNamSecLen;
				RspInfo.Rcode_e = Rcode_e;

				if (Rcode_e == NMSMSGF_E_SUCCESS)
				{
				   EnterCriticalSection(&WinsCnfCnfCrtSec);
				   RspInfo.RefreshInterval =
						WinsCnf.RefreshInterval;
				   LeaveCriticalSection(&WinsCnfCnfCrtSec);
				}
				

			     	NmsNmhSndNamRegRsp(
					&pReqWrkItm->DlgHdl,
					&RspInfo
						  );
			   }

		          //
		          //  deallocate the req  wrk items
		          //
		          QueDeallocWrkItm(NmsChlHeapHdl, pReqWrkItm);

		   }
		   else  // we haven't yet dealt with all the addresses. So,
			 // let us requeue the work item.
		   {

			 //
			 // Reinsert the work item since there are other
			 // addresses that we need to handle in HandleWrkItm()
			 //
             DBGPRINT2(CHL, "WaitForRsp: Name = (%s); NoOfAddsToUse is (%d)\n", pReqWrkItm->NodeToReg.Name, pReqWrkItm->NoOfAddsToUse);
			 QueInsertWrkItmAtHdOfList(
						&pReqWrkItm->Head,
						pReqWrkItm->QueTyp_e,
						NULL
						    );

		   }

		   //
		   // Reinit the array entry to obliterate the
		   // possibility of error (see ProcRsp)
		   //
		   spReqWrkItmArr[i] = NULL;
		   scPendingRsp--; //actually there is no need for this
				   //since scPendingRsp will be inited
				   //after dequeing requests

		  } 	// end of if
	        }  	//end of for loop for looping over sReqWrkItm array

	        break; 	//break out of the while(TRUE) loop

	     }
	     else   //count is != WinsCnf.MaxNoOfRetries
	     {

	   	WinsMscWaitTimedUntilSignaled(
			ThdEvtHdlArray,
			sizeof(ThdEvtHdlArray)/sizeof(HANDLE),
			&ArrInd,	
			TimeLeft,
			&fSignaled
			    );

	       //
	       //  if signaled, it means a response item is in the response
	       //  queue.
	       //
	       if (fSignaled)
	       {
					
                  DWORD TicksToSub;

		  //
		  // If signaled for termination, do it
		  //
		  if (ArrInd == 0)
	 	  {
			WinsMscTermThd(WINS_SUCCESS, WINS_DB_SESSION_EXISTS);
		  }

		  DBGPRINT0(CHL, "WaitForRsp: Received a response\n");
#ifdef WINSDBG
                  NmsChlNoRspDequeued++;
#endif
		  ProcRsp();	


		  //
		  //  If no responses are expected, break out of loop
		  //
		  if (scPendingRsp == 0)
		  {
			break;  	//break out of the while loop
		  }

	  	  //
	  	  // Get the number of msecs that have
	  	  // elapsed since windows was started
	  	  //
	  	  TickCnt = GetTickCount();

		  //
		  // If there has been a wrap around (will happen every 49.7
		  // days of Windows being up
		  //
		  if (TickCnt < TickCntSv)
		  {
		     TicksToSub = (TickCnt + (MAXULONG - TickCntSv));

		  }
		  else
		  {	
		     TicksToSub = TickCnt - TickCntSv;
		  }

                  //
                  // We don't want to subtract a biger number from a
                  // smaller number.  This will result in a huge value for
                  // TimeLeft making the challenge thread block forever.
                  //
                  if (TimeLeft > TicksToSub)
                  {
			TimeLeft -= TicksToSub;		
                        fNewTry = FALSE;
                  }
                  else
                  {
	    	        Count++;		//increment the count of retries
		        if ( Count != WinsCnf.MaxNoOfRetries)
		        {
			  //
			  // The Retry time interval being over, let us
			  // retry all those requests that did not get
			  // satisfied (i.e. no responses yet)
			  //
			  HandleWrkItm(
					spReqWrkItmArr,
					sMaxTransId,
					TRUE		//it is a retry	
				     );
                          //
                          // We have waited for the entire allowed
                          // wait time.  Time to do a retry
                          //
                          fNewTry = TRUE;
		        }
                  }
	       }
	       else
	       {
	    	  Count++;		//increment the count of retries
		  if ( Count != WinsCnf.MaxNoOfRetries)
		  {
			//
			// The Retry time interval being over, let us
			// retry all those requests that did not get
			// satisfied (i.e. no responses yet)
			//
			HandleWrkItm(
					spReqWrkItmArr,
					sMaxTransId,
					TRUE		//it is a retry	
				     );
                       fNewTry = TRUE;
		  }
	       }
	     }
	
	 }  // end of while (TRUE)
} // end of try ..
except(EXCEPTION_EXECUTE_HANDLER) {
	DBGPRINTEXC("WaitForRsp");

	//
	// must be some serious error. Reraise the exception
	//
	WINS_RERAISE_EXC_M();

 } // end of except { ..}
	return(WINS_SUCCESS);

}  // WaitForRsp()


STATUS
ProcRsp(
	VOID
	)

/*++

Routine Description:
	This function is called to process one or more work items
	queued on the challenge response queue.

	This response can be to  name query or name release requests sent
	earlier

Arguments:
	None

Externals Used:
	None

	
Return Value:

   Success status codes --  WINS_SUCCESS
   Error status codes   --  WINS_FAILURE

Error Handling:

Called by:
	WaitForRsp()

Side Effects:

Comments:
	None
--*/
{

	DWORD  		       TransId  = 0;
	NMSMSGF_NAM_REQ_TYP_E  Opcode_e   = NMSMSGF_E_NAM_QUERY;
	BYTE		       Name[NMSMSGF_RFC_MAX_NAM_LEN];
	DWORD		       NameLen;
//	COMM_IP_ADD_T	       IPAdd;
	NMSMSGF_CNT_ADD_T      CntAdd;
	NMSMSGF_ERR_CODE_E     Rcode_e;
	PCHL_REQ_WRK_ITM_T     pReqWrkItm;
	STATUS		       RetVal;
	PCHL_RSP_WRK_ITM_T     pRspWrkItm;
	STATUS		       RetStat = WINS_SUCCESS;
	LPBYTE		       pNameToComp;
	DWORD		       NameLenUsedInComp;
	BOOL		       fAdded;
    BOOL               fGroup;

	DBGENTER("ProcRsp\n");
	while (TRUE)
	{
		//dequeue each response and process
		RetVal = QueRemoveChlRspWrkItm(&pRspWrkItm);

		if (RetVal == WINS_NO_REQ)
		{
			break;
		}
		if (
			NmsMsgfUfmNamRsp(
			 	pRspWrkItm->pMsg,
			 	&Opcode_e,
			 	&TransId,
			 	Name,
			 	&NameLen,
			 	&CntAdd,
			 	&Rcode_e,
                &fGroup
					) == WINS_FAILURE
	   	   )
		{

	   		//
			// Throw away response
			//	
			ECommFreeBuff(pRspWrkItm->pMsg);
		        QueDeallocWrkItm(NmsChlHeapHdl, pRspWrkItm);
#ifdef WINSDBG
                        NmsChlNoInvRsp++;
#endif
			continue;
		}

        	//
		// Get the request corresponding to the response.
		//	
                if (TransId >= sMaxTransId)
                {
	   		//
			// Throw away response
			//	
                        DBGPRINT3(ERR, "ProcRsp: Rsp: Name = (%s); Transid = (%d), Opcode_e = (%d). Being rejected (TOO LARGE TRANS. ID)\n", Name, TransId, Opcode_e);
			ECommFreeBuff(pRspWrkItm->pMsg);
		        QueDeallocWrkItm(NmsChlHeapHdl, pRspWrkItm);
#ifdef WINSDBG
                        NmsChlNoInvRsp++;
#endif
			continue;


                }
		pReqWrkItm = spReqWrkItmArr[TransId];
		if (!pReqWrkItm)
		{
			//
			// Throw this response away
			//
			ECommFreeBuff(pRspWrkItm->pMsg);
		        QueDeallocWrkItm(NmsChlHeapHdl, pRspWrkItm);
#ifdef WINSDBG
                        NmsChlNoInvRsp++;
#endif
			continue;
		}	


		//
		// First and foremost check whether the response is for one of
		// the current requests (we want to guard against mismatching
		// the response to a request (the response could be for an old
		// request that is no longer in our spReqWrkItmArr array.
		//	

		
		//
		// Compare the Name and the Opcode from where the
		// response came with the same in the request
		//	
	        pNameToComp       =  pReqWrkItm->NodeToReg.pName;
		NameLenUsedInComp =  pReqWrkItm->NodeToReg.NameLen;

		RetVal = (ULONG) WINSMSC_COMPARE_MEMORY_M(
				       Name,
				       pNameToComp,
				       NameLenUsedInComp
						   );
		if (
		      (RetVal != NameLenUsedInComp )
		      		 ||
		      ( pReqWrkItm->ReqTyp_e != Opcode_e )
		     )
		{
			//
			// Throw this response away
			//
		        DBGPRINT5(ERR, "ProcRsp: Mismatch between response and request. Req/Res Name (%s/%s); ReqType_e/Opcode_e = (%d/%d). TransId = (%d)\n", pNameToComp, Name, pReqWrkItm->ReqTyp_e, Opcode_e, TransId);
		        WINSEVT_LOG_INFO_D_M(
					    WINS_SUCCESS,
					    WINS_EVT_REQ_RSP_MISMATCH
					  );
			ECommFreeBuff(pRspWrkItm->pMsg);
		        QueDeallocWrkItm(NmsChlHeapHdl, pRspWrkItm);
#ifdef WINSDBG
                        NmsChlNoInvRsp++;
#endif
			continue;

		}

		//
		// We have a valid response
		//
		DBGPRINT3(CHL, "ProcRsp: (%s) Response is for name = (%s); 16th char (%X)\n", Opcode_e == NMSMSGF_E_NAM_REL ? "RELEASE" : "QUERY", Name, Name[15]);
		//
		// Decrement the count of addresses to send query or release
		// to.  We send query/release to the next address in the list
                // if we get back a negative response to the current one. This
                // is just for extra safety (in case we have one or more
                // addresses in our list that are no longer valid for the name)
		//
		pReqWrkItm->NoOfAddsToUse--;	

		if (Opcode_e == NMSMSGF_E_NAM_REL)
		{
			
			//
			// If there are more addresses for sending the releases
			// to, insert the work item at the head of the queue
			//
			if ( (Rcode_e != NMSMSGF_E_SUCCESS) &&
                                      (pReqWrkItm->NoOfAddsToUse > 0))
			{
		   	   //
		   	   // The request has been processed. Init its
			   // position in the array. Also,
			   // decrement scPendingRsp.
		   	   //
		   	   spReqWrkItmArr[TransId] = NULL;
		   	   scPendingRsp--;

			   //
			   // Now, we have to send the RELEASE to the next
			   // address on the list .  This
			   // request has to be processed in the same
			   // way as all the other requests that are
			   // queued on our request queues (i.e. retry
			   // a certain number of times using a certain
			   // time interval).  Since we are in the
			   // middle of an execution of a batch of
			   // requests, queue this request at the head
			   // of the   next batch of requests.
			   //
             DBGPRINT2(CHL, "ProcRsp: Name = (%s); NoOfAddsToUse is (%d)\n", pReqWrkItm->NodeToReg.Name, pReqWrkItm->NoOfAddsToUse);
			   QueInsertWrkItmAtHdOfList(
						&pReqWrkItm->Head,
						pReqWrkItm->QueTyp_e,
						NULL
						);
			   //
			   // Throw the response away
			   //
			   ECommFreeBuff(pRspWrkItm->pMsg);

			   //
			   // deallocate the response buffer
			   //
		   	   QueDeallocWrkItm(NmsChlHeapHdl, pRspWrkItm);
			   return(WINS_SUCCESS);
			}	

                        //
                        // Either the name was released or we have exhausted
                        // the list of addresses without getting a positive
                        // release response
                        //

			//
			// Update the database.  Note: There is no need to
			// check the Rcode_e value since even if the release
			// request failed, we will overwrite the entry
			//
                        // A release is sent as a result of a clash during
                        // replication only, so a client id. of WINS_E_RPLPULL
                        // is correct.
                        //

                        if (pReqWrkItm->CmdTyp_e == NMSCHL_E_REL)
                        {
			   pReqWrkItm->NodeToReg.pNodeAdd =
						&pReqWrkItm->AddToReg;
		           if (ChlUpdateDb(
                                        FALSE,
					WINS_E_RPLPULL,
					&pReqWrkItm->NodeToReg,
					pReqWrkItm->OwnerIdInCnf,
					FALSE  //not just a refresh
				       ) != WINS_SUCCESS
			       )
			   {
			   WINSEVT_LOG_M(WINS_FAILURE, WINS_EVT_CANT_UPDATE_DB);
			   DBGPRINT0(CHL, "ProcRsp:COULD NOT UPDATE THE DB AFTER A RELEASE \n");
			   Rcode_e = NMSMSGF_E_SRV_ERR;
			   }
			   else
			   {
				//
				// if the remote WINS has to be notified of
				// the update.
                                //
                                // NOTE: This code won't be executed.
				//
				if(spReqWrkItmArr[TransId]->CmdTyp_e ==
						NMSCHL_E_REL_N_INF)
				{
					InfRemWins(
						spReqWrkItmArr[TransId]
					  	  );
				}
				Rcode_e = NMSMSGF_E_SUCCESS;
			   }
                      }

		}	
		else  // it is a name query response
		{

#ifdef WINSDBG
		  {
		    DWORD i;	
		    for (i=0; i<CntAdd.NoOfAdds;i++)
		    {
			DBGPRINT2(CHL, "ProcRsp: Address (%d) is (%X)\n", (i+1),CntAdd.Add[i].Add.IPAdd);
		    }
		   }
#endif
		
		   //
		   //  if the challenge succeded, we may need
		   //  to update the database
		   //
		   if (Rcode_e != NMSMSGF_E_SUCCESS ||
               pReqWrkItm->fGroupInCnf != fGroup)
		   {
			
			//
			// a negative name query response was received
            // OR Record type (unique vs group) doesn't match
            // (the second check is to consider the case of
            // a node which used the same name first as unique
            // and then as group)
			//

			//
			// If there are no more addresses to query
			//
			if (pReqWrkItm->NoOfAddsToUse == 0)
			{				
			  //
			  // Update the database
			  //
			  pReqWrkItm->NodeToReg.pNodeAdd =
						&pReqWrkItm->AddToReg;
		          if (ChlUpdateDb(
                                FALSE,
				pReqWrkItm->Client_e,
				&pReqWrkItm->NodeToReg,
				pReqWrkItm->OwnerIdInCnf,
				FALSE
				       ) == WINS_SUCCESS
			     )
		          {
		
		             //
			     // Set Rcode_e to SUCCESS
			     //
		       	     Rcode_e = NMSMSGF_E_SUCCESS;
		          }
			  else
			  {
			     Rcode_e = NMSMSGF_E_SRV_ERR;
			     WINSEVT_LOG_M(WINS_FAILURE, WINS_EVT_CANT_UPDATE_DB);
			  }
		       }
		       else
		       {
				//
				// We need to challenge (query) the next
				// address in the list of addresses
				//
		   	        spReqWrkItmArr[TransId] = NULL;
		   		scPendingRsp--;
			
             DBGPRINT2(CHL, "ProcRsp: Name = (%s); NoOfAddsToUse is (%d)\n", pReqWrkItm->NodeToReg.Name, pReqWrkItm->NoOfAddsToUse);
				QueInsertWrkItmAtHdOfList(
							&pReqWrkItm->Head,
							pReqWrkItm->QueTyp_e,
							NULL
							);
				//
				// Throw this response away
				//
				ECommFreeBuff(pRspWrkItm->pMsg);

				//
				// deallocate the response buffer
				//
		   		QueDeallocWrkItm(NmsChlHeapHdl, pRspWrkItm);
				return(WINS_SUCCESS);
		       }
		   }
		   else  // positive name query response received
		   {

                         //
                         // if the cmd is CHL_N_REL, we need to now tell
                         // the remote node to release the name.
                         //

                         if (CntAdd.NoOfAdds == 1)
                         {
                           //
                           // Note: the CmdType_e will be CHL_N_REL
                           // only if the client is WINS_E_RPLPULL
                           //
			   if (pReqWrkItm->CmdTyp_e ==  NMSCHL_E_CHL_N_REL)
			   {
                                  DWORD No;

				  //
				  // We need to tell the remote node
				  // release all names.
				  //
				  pReqWrkItm->CmdTyp_e = NMSCHL_E_REL_ONLY;

		   	          spReqWrkItmArr[TransId] = NULL;
		   		  scPendingRsp--;

                                  //
                                  // We need to update the Version
                                  // no of the conflicting entry
                                  //
		          	 (VOID)ChlUpdateDb(
                                                TRUE,  //update vers. no.
						WINS_E_NMSNMH,  //to speed fn up
						&pReqWrkItm->NodeToReg,
						pReqWrkItm->OwnerIdInCnf,
					        FALSE	
				       			);

                                 //
                                 // Tell the remote guy to release
                                 // the name. Copy the addresses of
                                 // into the proper field
                                 //
		                 pReqWrkItm->NoOfAddsToUse =
                                      pReqWrkItm->NodeToReg.NodeAdds.NoOfMems;	
                                 ASSERT(pReqWrkItm->NoOfAddsToUse <= NMSDB_MAX_MEMS_IN_GRP);
                                 for (No=0; No < pReqWrkItm->NoOfAddsToUse; No++)
                                 {
                                        *(pReqWrkItm->NodeAddsInCnf.Mem + No) = *(pReqWrkItm->NodeToReg.NodeAdds.Mem + No);

                                 }
                                 pReqWrkItm->NodeAddsInCnf.NoOfMems
                                                  = pReqWrkItm->NoOfAddsToUse;

                  DBGPRINT2(CHL, "ProcRsp: Name = (%s); NoOfAddsToUse is (%d); request REL_ONLY\n", pReqWrkItm->NodeToReg.Name, pReqWrkItm->NoOfAddsToUse);
				  QueInsertWrkItmAtHdOfList(
							&pReqWrkItm->Head,
							pReqWrkItm->QueTyp_e,
							NULL
							);
				  //
				  // Throw this response away
				  //
				  ECommFreeBuff(pRspWrkItm->pMsg);

				  //
				  // deallocate the response buffer
				  //
		   		  QueDeallocWrkItm(NmsChlHeapHdl, pRspWrkItm);
				  return(WINS_SUCCESS);
                          }
                        }

			//
			// If more than one address was returned in the
			// query response, it means that the challenged
			// node is a multi-homed node.  Actually, a multihomed
			// node could return just one address too. This is
			// because it might have just come up and the name
			// may not have yet been registered for the multiple
			// adapters.

			//
			// Note: We execute the else code if the
			// record to register is a special group
			//
			if (	
			     !NMSDB_ENTRY_GRP_M(pReqWrkItm->NodeToReg.EntTyp)
			   )
			{
				//
				// Check if we need to update the db
				//
				RetStat = ProcAddList(
						pReqWrkItm,
						&CntAdd,
						&fAdded
						      );	

				if (RetStat == WINS_FAILURE)
				{
				      //
				      // There is atleast one address in the
				      // list to register that is not in the
				      // list of addresses returned.  This means
				      // that at least one of the addresses to
				      // register is not claimed by the node
				      // that responded.  We can not honor
                                      // this registration
				      //

				      //
				      // NAME ACTIVE error
				      //
				      Rcode_e = NMSMSGF_E_ACT_ERR;
				}
				else
				{
			  	  	//
			  		// Update the database
			  		//
			  		pReqWrkItm->NodeToReg.pNodeAdd =
						  &pReqWrkItm->AddToReg;

		          		if (ChlUpdateDb(
                                                FALSE,
						pReqWrkItm->Client_e,
						&pReqWrkItm->NodeToReg,
						pReqWrkItm->OwnerIdInCnf,
						!fAdded
				       			) == WINS_SUCCESS
			     		  )
		          		{
		
		             		   //
			     		   // Set Rcode_e to SUCCESS
			     		   //
		       	     		   Rcode_e = NMSMSGF_E_SUCCESS;
		          		 }
			  		 else
			  		 {
			     			Rcode_e = NMSMSGF_E_SRV_ERR;
			     			WINSEVT_LOG_M(WINS_FAILURE, WINS_EVT_CANT_UPDATE_DB);
			  		 }

				}
					
			}
CHECK("Should a local multihomed node be told to release the name if it ")
CHECK("with a replica. This is what is done for the local unique/remote unique")
CHECK("name clash.  It seems the right strategy but may need to be rethought")

			else  // entry to register is a group
			{
				//
				// set Rcode_e to Error code
				//
				Rcode_e = NMSMSGF_E_ACT_ERR;
			}
		   }
		}	

		//
		// The request has been processed. Init its position
		// in the array.  Send the response to the waiting node
		// This will free the buffer too.
		//
		//  Also, decrement scPendingRsp.  This was incremented by
		//  HandleWrkItm for each query/release sent.
		//
		spReqWrkItmArr[TransId] = NULL;
		scPendingRsp--;

		//
		// Send a registration response only if the client that
		// submitted the request was an NBT thread.
		//
		if (
                       (pReqWrkItm->Client_e == WINS_E_NMSNMH)
					&&
			(!pReqWrkItm->NodeToReg.fStatic)
					&&
			(!pReqWrkItm->NodeToReg.fAdmin)
                   )
		{
			NMSMSGF_RSP_INFO_T	RspInfo;

			RspInfo.pMsg          = pReqWrkItm->pMsg;
			RspInfo.MsgLen 	      = pReqWrkItm->MsgLen;
			RspInfo.QuesNamSecLen = pReqWrkItm->QuesNamSecLen;
			RspInfo.Rcode_e       = Rcode_e;

			if (Rcode_e == NMSMSGF_E_SUCCESS)
			{
			   EnterCriticalSection(&WinsCnfCnfCrtSec);
			   RspInfo.RefreshInterval = WinsCnf.RefreshInterval;
			   LeaveCriticalSection(&WinsCnfCnfCrtSec);
			  DBGPRINT0(CHL, "ProcRsp: Sending a Positive name registration response\n");
			}
#ifdef WINSDBG
			else
			{
			  DBGPRINT0(CHL, "ProcRsp: Sending a negative name registration response\n");
			}
#endif

			NmsNmhSndNamRegRsp(
			 	        &pReqWrkItm->DlgHdl,
					&RspInfo
			      	          );
			
		}

	        //
	        // Throw this response away
		//
	        ECommFreeBuff(pRspWrkItm->pMsg);

		//
		//  deallocate the req and rsp wrk items
		//
		QueDeallocWrkItm(NmsChlHeapHdl, pReqWrkItm);
		QueDeallocWrkItm(NmsChlHeapHdl, pRspWrkItm);
	}

	DBGLEAVE("ProcRsp\n");
	return(WINS_SUCCESS);
} // ProcRsp()



STATUS
ChlUpdateDb(
        BOOL                    fUpdVersNoOfCnfRec,
	WINS_CLIENT_E		Client_e,
	PNMSDB_ROW_INFO_T	pRowInfo,
	DWORD			OwnerIdInCnf,	
	BOOL			fRefreshOnly
	)

/*++

Routine Description:
	This function is called to update the database.  It is called
	by ProcRsp and by ChlThdInitFn when challenge succeeds

Arguments:
	Client_e - id of client that submitted the request
	pRowInfo - info about the record to be inserted

Externals Used:
	None

	
Return Value:

   Success status codes -- WINS_SUCCESS
   Error status codes   -- WINS_FAILURE

Error Handling:

Called by:
	WaitForRsp(), ProcRsp()
Side Effects:

Comments:
	None
--*/

{
	NMSDB_STAT_INFO_T   StatInfo;
	STATUS		    RetStat    = WINS_SUCCESS;
        BOOL                fIncVersNo = FALSE;

	DBGENTER("ChlUpdateDb\n");

	//
	// update the time
	//
PERF("We can avoid this call to time, since we called time earlier before we")
PERF("challenge.  In the worst case that time will be off by a 2.5-3")
PERF("unless the thread is preempted for a long time")
PERF("assuming a name challenge and release took place.  In the best case")
PERF("it will be off by 1.25-1.5 secs (if just a challenge).  We can add ")
PERF("1.25 secs to that time  and avoid the overhead of a function call")

	(void)time(&pRowInfo->TimeStamp);

	if (((Client_e == WINS_E_NMSNMH) && !fRefreshOnly) ||
                   fUpdVersNoOfCnfRec)
        {
            fIncVersNo =  TRUE;
        }
	EnterCriticalSection(&NmsNmhNamRegCrtSec);
    if (pRowInfo->OwnerId == NMSDB_LOCAL_OWNER_ID)
    {
        pRowInfo->TimeStamp += WinsCnf.RefreshInterval;
    }
    else
    {
        pRowInfo->TimeStamp += WinsCnf.VerifyInterval;
    }
   try
   {

	//
	// If the client (the one that submitted the challenge request) is
	// an NBT thread, we need to store the new version number.  If the
	// client is the replicator, we use the version number in the
	// record
	//
	if (fIncVersNo)
	{
		pRowInfo->VersNo = NmsNmhMyMaxVersNo;
	}

	StatInfo.OwnerId = OwnerIdInCnf;
	if (*(pRowInfo->pName+15) == 0x1B)
	{
		WINS_SWAP_BYTES_M(pRowInfo->pName, pRowInfo->pName+15);
	}

        //
        // If the vers. no of the local record needs to be updated, do so.
        //
        if (fUpdVersNoOfCnfRec)
        {
            RetStat = NmsDbUpdateVersNo (FALSE, pRowInfo, &StatInfo);
        }
        else
        {
	   RetStat = NmsDbSeekNUpdateRow(
				pRowInfo,
				&StatInfo
			   	     );
        }

	if ((RetStat == WINS_SUCCESS) && (StatInfo.StatCode == NMSDB_SUCCESS))
	{
		//
		// If the client is an NBT thread, we increment the version
		// number since the record we inserted in the db is
		// owned by us (we could also check the owner id here).  If
		// the client is the replicator thread, we don't do anything
		//
		if (fIncVersNo)
		{
			NMSNMH_INC_VERS_COUNTER_M(
				NmsNmhMyMaxVersNo,
				NmsNmhMyMaxVersNo
					    );

			//
			// if fAddChgTrigger is TRUE, we pass RPL_PUSH_PROP
			// as the first parameter. Its value is TRUE. See
			// rpl.h
			//
			RPL_PUSH_NTF_M(
			  (WinsCnf.PushInfo.fAddChgTrigger ? RPL_PUSH_PROP :
				RPL_PUSH_NO_PROP), NULL, NULL, NULL);
		}
	}
	else
	{
		DBGPRINT1(ERR, "ChlUpdateDb: Update of record with name (%s) FAILED\n", pRowInfo->pName);

		RetStat = WINS_FAILURE;
	}
  }
  except (EXCEPTION_EXECUTE_HANDLER)
  {
		DBGPRINTEXC("ChlUpdateDb")
		WINSEVT_LOG_M(GetExceptionCode(), WINS_EVT_CANT_UPDATE_DB);
  }
	LeaveCriticalSection(&NmsNmhNamRegCrtSec);

	DBGLEAVE("ChlUpdateDb\n");
	return (RetStat);
} //ChlUpdateDb()


VOID
InfRemWins(
	PCHL_REQ_WRK_ITM_T	pWrkItm
	  )

/*++

Routine Description:

	This function is called when a remote WINS has to be
	told to change the version stamp of a record that was
	pulled by the local WINS at replication.  The need for this
	has arisen because the pulled record collided with a record
	owned by the local WINS (both records being in the active
	state).
	
	
Arguments:
	pWrkItm - the work item that got queued to the name challenge
		  manager

Externals Used:
	None
	
Return Value:
	None

Error Handling:

Called by:
	
	ProcRsp	

Side Effects:

Comments:
	None
--*/
{
	COMM_HDL_T	DlgHdl;
	BYTE		ReqBuff[RPLMSGF_UPDVERSNO_REQ_SIZE];
	LPBYTE		pRspBuff;
	DWORD		ReqBuffLen;
	DWORD		RspBuffLen;
	NMSMSGF_ERR_CODE_E Rcode_e = 0;  //init to 0.  This is initialization
					 //is important since we update
					 //the LSB of Rcode_e with the
					 //the return status
					

	DBGENTER("InfRemWins\n");
try {

	//
	// Log an event since this is an important event to monitor (at
	// least initially)
	//
NONPORT("Change the following for transport independence")
	WINSEVT_LOG_INFO_D_M(pWrkItm->AddOfRemWins.Add.IPAdd,
				WINS_EVT_INF_REM_WINS);

	//
	// Start a dialogue to send the update version number request
	//	

   	//
   	// Init the pEnt field to NULL so that ECommEndDlg (in the
   	// exception handler) called as a result of an exception from
   	// behaves fine.
   	//
   	DlgHdl.pEnt = NULL;

	ECommStartDlg(
		&pWrkItm->AddOfRemWins,
		COMM_E_RPL,
		&DlgHdl	
		     );	


	RplMsgfFrmUpdVersNoReq(
				&ReqBuff[COMM_N_TCP_HDR_SZ],
				pWrkItm->NodeToReg.pName,
				pWrkItm->NodeToReg.NameLen,
				&ReqBuffLen
			      );
					

	//
	// Send the "Update Version number" request
	//
	ECommSndCmd(
			&DlgHdl,
			&ReqBuff[COMM_N_TCP_HDR_SZ],
			ReqBuffLen,
			&pRspBuff,
			&RspBuffLen
			);
	//
	// decipher the reponse to get the result code sent by the
	// remote WINS
	//			
	RplMsgfUfmUpdVersNoRsp(
				pRspBuff + 4,  //past the opcode
				(LPBYTE)&Rcode_e
			      );

	if (Rcode_e != NMSMSGF_E_SUCCESS)
	{
		DBGPRINT0(ERR, "Remote WINS could not update the version no. of its record");
		WINSEVT_LOG_M(pWrkItm->AddOfRemWins.Add.IPAdd, WINS_EVT_REM_WINS_CANT_UPD_VERS_NO);
FUTURES("Take some corrective action -- maybe")

	}

	//
	// deallocate the request and response buffers
	//
#if 0
	WinsMscDealloc(pReqBuff);
#endif
	ECommFreeBuff(pRspBuff - COMM_HEADER_SIZE);

 } // end of try block
		
except (EXCEPTION_EXECUTE_HANDLER) {

	DWORD  ExcCode = GetExceptionCode();
	DBGPRINT1(EXC, "InfRemWins: Got exception (%x)\n", ExcCode );
	if (ExcCode == WINS_EXC_COMM_FAIL)
	{
		DBGPRINT1(ERR, "InfRemWins: Could not inform WINS (%x) that it should update the version number for a record", pWrkItm->AddOfRemWins.Add.IPAdd);	
		//
		//insert a timer request for retrying
		//
		
FUTURES("Incorporate code to insert a timer request so that we can retry")
	}
	else
	{
		//severe error.
		DBGPRINT0(ERR, "InfRemWins: Some severe error was encountered\n");
	}
	WINSEVT_LOG_M(ExcCode, WINS_EVT_INF_REM_WINS_EXC);
   }	
	//
	// End the dialogue
	//
	ECommEndDlg( &DlgHdl );
	
	DBGLEAVE("InfRemWins\n");
	return;

} // InfRemWins()


STATUS
ProcAddList(
	PCHL_REQ_WRK_ITM_T	pReqWrkItm,
	PNMSMSGF_CNT_ADD_T	pCntAdd,
	LPBOOL			pfAdded
	)

/*++

Routine Description:
	
Arguments:
	pWrkItm - the work item that got queued to the name challenge
		  manager
	pCntAdd - List of addresses returned on a query

Externals Used:
	None
	
Return Value:
	None

Error Handling:

Called by:
	
	ProcRsp	

Side Effects:

Comments:
	The function will never be called when the state
	of the entry to register is a TOMBSTONE or if the entry to register
	is a group.

--*/
{	
	DWORD  i, n;
	DWORD  NoOfAddsToReg;
	STATUS RetStat = WINS_SUCCESS;
        PNMSDB_GRP_MEM_ENTRY_T  pMem;
        PCOMM_ADD_T  pAddInRsp;
	
	DBGENTER("ProcAddList\n");
	*pfAdded = FALSE;  //no address of conflicting entry has yet been
			   //added to list of addresses of record to register

	//
	// If the node to register is a unique record
	//
	if (pReqWrkItm->NodeToReg.EntTyp == NMSDB_UNIQUE_ENTRY)
	{
		NoOfAddsToReg = 1;
		pReqWrkItm->NodeToReg.NodeAdds.Mem[0].Add =
						pReqWrkItm->AddToReg;
		pReqWrkItm->NodeToReg.NodeAdds.Mem[0].OwnerId =
						pReqWrkItm->NodeToReg.OwnerId;
		pReqWrkItm->NodeToReg.NodeAdds.Mem[0].TimeStamp =
						pReqWrkItm->NodeToReg.TimeStamp;
		pReqWrkItm->NodeToReg.NodeAdds.NoOfMems = 1;
						
	}
	else  // has to be multihomed (see comment above)
	{
	   NoOfAddsToReg = pReqWrkItm->NodeToReg.NodeAdds.NoOfMems;

	   //
	   // The addresses are already there in NodeToReg.NodeAdds structure
	   //
	
	}

	//
	// If the address(es) to register are not a subset of the addresses
	// returned (i.e. atleast one address to register is not there in
	// the list returned), we return FAILURE.
	//

	//
	// Loop over all addresses to register
	//
	for (i=0; i < NoOfAddsToReg; i++)
	{
		//
		// Compare with each address returned to see if there is
		// a match. Note: pCntAdd->NoOfAdds is > 1 (this function
		// isn't called otherwise).
		//
		for (n=0; n < pCntAdd->NoOfAdds; n++)
		{
PERF("use pointer arithmetic")
			if (pReqWrkItm->NodeToReg.NodeAdds.Mem[i].Add.Add.IPAdd ==
					pCntAdd->Add[n].Add.IPAdd)
			{
				//
				// There is a match, break out so that we can
				// can get to the next address in the list of
				// addresses to register
				//
				break;
			}
		}

		//
		// if there was no match, we have an address to register that
		// either the queried (challenged) node does not have or refuses
		// to divulge to us.  We must reject the registration/refresh
		//
		if (n == pCntAdd->NoOfAdds)
		{
			RetStat = WINS_FAILURE;
			break;
		}
      }

      //
      // The address(es) to register are a subset of the addresses returned
      // by the node (on a query)
      //
      if ( RetStat == WINS_SUCCESS)
      {
       	DWORD Index;

        //
        // Remove those members in the conflicting record that are
        // not in the list returned by the node
        //
	for (
		    i=0, pMem = pReqWrkItm->NodeAddsInCnf.Mem;
			i < min(pReqWrkItm->NodeAddsInCnf.NoOfMems,
				 NMSMSGF_MAX_NO_MULTIH_ADDS);
			i++, pMem++
		    )
        {
		    pAddInRsp =  pCntAdd->Add;
		    for (n=0; n < pCntAdd->NoOfAdds; n++, pAddInRsp++)
		    {
PERF("use pointer arithmetic")
			   if (pMem->Add.Add.IPAdd == pAddInRsp->Add.IPAdd)
			   {
				//
				// There is a match, break out so that we can
				// can get to the next address in the list of
				// addresses in the conflicting record
				//
				break;
			   }
		     }
             if (n == pCntAdd->NoOfAdds)
             {
                //
                // remove the conflicting member from the list
                // This is done by setting its address to NONE.  Later
                // on, we simply won't add this address.
                //
                DBGPRINT3(CHL, "ProcAddList: Removing member (%x) from list of name = (%s)[%x]\n", pMem->Add.Add.IPAdd, pReqWrkItm->NodeToReg.Name, pReqWrkItm->NodeToReg.Name[15]);
                pMem->Add.Add.IPAdd = INADDR_NONE;

             }
        }

        DBGPRINT0(CHL, "ProcAddList: Add conflicting record members\n");

	//
	// The record in conflict has to be ACTIVE
	// (otherwise this function wouldn't have been called -- See
	// the clash functions in nmsnmh.c).  We add all those addresses
	// in the active conflicting record to the list of addresses in
	// the record to register that are not there in it already
	//

	//
	// Add to list of addresses to register all the addresses in
	// the conflicting record.  Note: The conflicting record
	// will not have any address in common with the record
	// to register (common addresses were removed in the clash
	// handling functions of nmsnmh.c via MemInGrp())
	//
	
	//
	// NOTE: the NoOfMems of the NodeAddsInCnf field is guaranteed
	// to be > 0
	//
        //
        // Also NOTE: If the challenged node returned us a list > 25 members
        // long and our list of members to register can no accommodate
        // all the members that need to be added, we will just add those
        // that can be added without violating the NMSMSGF_MAX_NO_MULTIH_ADDS
        // constraint.  The members added could be 0 if we already have
        // the first 25 in our list.  Neverthless we will update our
        // db entry.  This is because some of the conflicting record's
        // members may be old. They will get removed this way (we don't
        // compare the list returned by the challenged node with what is
        // in the conflicting record currently, so old entries will be
        // there until they are scavenged or fall off).
        //
	Index = pReqWrkItm->NodeToReg.NodeAdds.NoOfMems;
	pMem = pReqWrkItm->NodeAddsInCnf.Mem;
	for (   i=0;
		i < min(pReqWrkItm->NodeAddsInCnf.NoOfMems,
				 (NMSMSGF_MAX_NO_MULTIH_ADDS - Index));
			i++, pMem++
	     )
	{
		//
		// we need to add the conflicting record's
		// address into the registering record's
		// list of addresses
		//
                if (pMem->Add.Add.IPAdd != INADDR_NONE)
                {
		  pReqWrkItm->NodeToReg.NodeAdds.Mem[
			 	pReqWrkItm->NodeToReg.NodeAdds.NoOfMems
						] = *pMem;
		  pReqWrkItm->NodeToReg.NodeAdds.NoOfMems++;
                }
	}	
		
	//
	// Setting *pfAdded to TRUE will increment the version number.
	// We do want to increment the version number because
	// the reason we are here means one of the following:
	//
	//  	1)We got a refresh (unique) for an address not in the
	//        conf. rec.
	//	2)We got a registration for an address that is/is not
	// 	  there in the conflicting record.
	//
	//   For the first case above, we definitely want to increment
	//   the version no.  For the second case, it is not strictly
	//   required but is preferable for syncing up entries at
	//   different WINS servers right away.
	//
	*pfAdded = TRUE;

	//
	// If the record to register was a unique record
	// change its type to MULTIHOMED.
	//
	if ( NMSDB_ENTRY_UNIQUE_M(pReqWrkItm->NodeToReg.EntTyp) )
	{
		pReqWrkItm->NodeToReg.EntTyp = NMSDB_MULTIHOMED_ENTRY;
	}

      }

      DBGLEAVE("ProcAddList\n");
      return(RetStat);
}