1 files changed, 1019 insertions, 0 deletions

diff --git a/private/ntos/nbt/vxd/newdns.c b/private/ntos/nbt/vxd/newdns.c
new file mode 100644
index 000000000..9bcf78d4b
--- /dev/null
+++ b/private/ntos/nbt/vxd/newdns.c
@@ -0,0 +1,1019 @@
+/*++
+
+Copyright (c) 1989-1996  Microsoft Corporation
+
+Module Name:
+
+    DNS.c
+
+Abstract:
+
+    VxD-specific DNS routines.
+
+    This stuff will all be obsolete when we get proper services for
+    Windows.  Then we will just call Winsock for DNS name resolution.
+
+Author:
+
+    Earle R. Horton (ERH) 13-Feb-1996
+
+Revision History:
+
+--*/
+
+#include "nbtprocs.h"
+
+//----------------------------------------------------------------------------
+ULONG
+DoDnsResolveDirect(
+    PNCB pncb,
+    PUCHAR pzDnsName,
+    PULONG pIpAddress
+)
+{
+	PDNS_DIRECT_WORK_ITEM_CONTEXT	pContext;
+	PUCHAR							pch;
+	tDEVICECONTEXT					*pDeviceContext;
+	ULONG							status;
+    CTELockHandle   	            OldIrq;
+
+	pDeviceContext = GetDeviceContext( pncb ) ;
+
+	if ( pDeviceContext == NULL )
+	{
+	    return NRC_BRIDGE ;
+	}
+
+	//
+	// If the primary DNS server is not defined, just return error.
+	// Return command timed out here.
+	//
+	if ( (!pDeviceContext->lDnsServerAddress) ||
+	    ( pDeviceContext->lDnsServerAddress == LOOP_BACK) )
+	{
+	  return( NRC_NOCALL );
+	}
+
+	pContext = CTEAllocMem( sizeof(DNS_DIRECT_WORK_ITEM_CONTEXT) );
+
+	if ( pContext == NULL )
+	{
+		return NRC_NORESOURCES;
+	}
+
+	CTEZeroMemory( pContext, sizeof(DNS_DIRECT_WORK_ITEM_CONTEXT) );
+
+    pContext->pDeviceContext = pDeviceContext;
+	pContext->pNCB = pncb;
+	pContext->pzDnsName = pzDnsName;
+	pContext->pIpAddress = pIpAddress;
+
+	pContext->TransactId =  htons(GetTransactId() + DIRECT_DNS_NAME_QUERY_BASE );
+	pContext->pchDomainName = NbtConfig.pDomainName;
+	pContext->Flags = DNS_DIRECT_DNS_SERVER;
+
+	for ( pch = &pzDnsName[0] ; *pch++ != '\0' ; )
+	{
+		if ( pch[0] == '.' )
+		{
+			pContext->Flags |= DNS_DIRECT_NAME_HAS_DOTS;
+			pContext->pchDomainName = NULL;
+		}
+	}
+
+	//
+	// Put on the pending name queries list again so that when the query
+	// response comes in from DNS we can find the context.
+	//
+    CTESpinLock(&NbtConfig.JointLock,OldIrq);
+
+	InsertTailList(&NbtConfig.DNSDirectNameQueries,
+	               &pContext->Linkage
+	               );
+
+    CTESpinFree(&NbtConfig.JointLock,OldIrq);
+
+	status = UdpSendDNSBcastDirect( pContext,
+									(ULONG)pNbtGlobConfig->uRetryTimeout,
+									(ULONG)pNbtGlobConfig->uNumRetries
+									);
+
+    pncb->ncb_retcode = pncb->ncb_cmd_cplt = status ;
+
+	if ( status != NRC_PENDING )
+	{
+        pncb->ncb_retcode = pncb->ncb_cmd_cplt = status ;
+
+		DnsUnlinkAndCompleteDirect( pContext );
+	}
+	else
+	{
+		status = NRC_GOODRET;
+	}
+	
+	return status;
+}
+
+//----------------------------------------------------------------------------
+NTSTATUS
+UdpSendDNSBcastDirect(
+	IN	PDNS_DIRECT_WORK_ITEM_CONTEXT	pContext,
+	IN	ULONG							Timeout,
+	IN	ULONG							Retries
+)
+/*++
+
+Routine Description:
+
+    This routine sends a name query directed to the name server.
+
+Arguments:
+
+
+Return Value:
+
+    NTSTATUS - success or not
+
+History:
+
+	Adapted from UdpSendNSBcast() in "udpsend.c."
+
+		Earle R. Horton (earleh) March 18, 1996
+
+--*/
+{
+    NTSTATUS                    status;
+    tNAMEHDR                    *pNameHdr;
+    ULONG                       uLength;
+    ULONG                       uSentSize;
+    CTELockHandle               OldIrq;
+    ULONG                       IpAddress;
+    tTIMERQENTRY                *pTimerQEntry;
+    TDI_REQUEST                 TdiRequest;
+	PDNS_DIRECT_SEND_CONTEXT	pSendContext;
+
+    pSendContext = CreateSendContextDirect(
+                   pContext->pzDnsName,
+                   pContext->pchDomainName,
+                   (PVOID)&pNameHdr,
+                   &uLength,
+                   pContext);
+
+    if (pSendContext == NULL)
+	{
+        IF_DBG(NBT_DEBUG_NAMESRV)
+        KdPrint(("Nbt:Failed to Create Pdu to send to DNS.\n"));
+        return( NRC_NORES );
+    }
+
+    CTESpinLock(&NbtConfig.JointLock,OldIrq);
+
+    TdiRequest.Handle.AddressHandle = (PVOID)pContext->pDeviceContext->pNameServerFileObject;
+
+    // the completion routine is setup to free the pDgramTracker memory block
+    TdiRequest.RequestNotifyObject = SendDNSBcastDoneDirect;
+    TdiRequest.RequestContext = (PVOID)pSendContext;
+
+    // start the timer now...We didn't start it before because it could
+    // have expired during the dgram setup, perhaps before the Context was
+    // fully setup.
+    //
+    if (Timeout)
+    {
+        status = StartTimer(
+        					Timeout,
+                            pContext,
+                            NULL,
+                            DnsCompletionDirect,
+                            NULL,
+                            NULL,
+                            (USHORT)Retries,
+                            &pTimerQEntry
+                            );
+
+        if (!NT_SUCCESS(status))
+        {
+            // we need to differentiate the timer failing versus lack
+            // of resources
+            CTESpinFree(&NbtConfig.JointLock,OldIrq);
+            CTEMemFree(pSendContext);
+
+            return( NRC_NORES );
+        }
+        //
+        // Cross link the nameaddr and the timer so we can stop the timer
+        // when the name query response occurs
+        //
+        pTimerQEntry->pCacheEntry = pContext;
+        pContext->pTimer = pTimerQEntry;
+    }
+
+    //
+    // in the event that DHCP has just removed the IP address, just cancel
+    // the request
+	//
+    if (pContext->pDeviceContext->IpAddress == 0)
+    {
+		StopTimer ( pContext->pTimer, NULL, NULL );
+		pContext->Flags |= DNS_DIRECT_CANCELLED;
+    }
+
+    CTESpinFree(&NbtConfig.JointLock,OldIrq);
+
+    (VOID) TdiSendDatagram(
+		&TdiRequest,
+		&pSendContext->SendInfo,
+		uLength,
+		&uSentSize,
+		&pSendContext->SendBuffer,
+		NBT_NAME_SERVICE
+	);
+
+    return( NRC_PENDING );
+}
+
+//----------------------------------------------------------------------------
+VOID
+SendDNSBcastDoneDirect(
+    IN  PVOID       pSendContext,
+    IN  NTSTATUS    status,
+    IN  ULONG       lInfo
+)
+{
+   CTEMemFree(pSendContext);
+}
+
+//----------------------------------------------------------------------------
+BOOL
+DoDnsCancelDirect(
+    PNCB pncb
+)
+{
+    PLIST_ENTRY     		pHead;
+    PLIST_ENTRY     		pEntry;
+	PDNS_DIRECT_WORK_ITEM_CONTEXT
+							pContext;
+	CTELockHandle           OldIrq;
+	BOOL					RetVal = FALSE;
+
+    pHead = pEntry = &NbtConfig.DNSDirectNameQueries;
+
+	CTESpinLock(&NbtConfig.JointLock,OldIrq);
+
+    while ((pEntry = pEntry->Flink) != pHead)
+    {
+    	pContext = CONTAINING_RECORD(pEntry,DNS_DIRECT_WORK_ITEM_CONTEXT,Linkage);
+		if ( pContext->pNCB == pncb )
+		{
+			StopTimer ( pContext->pTimer, NULL, NULL );
+			pContext->Flags |= DNS_DIRECT_CANCELLED;
+			RetVal = TRUE;
+			break;
+		}
+	}
+
+	CTESpinFree(&NbtConfig.JointLock,OldIrq);
+
+	return RetVal;
+}
+
+//----------------------------------------------------------------------------
+/*++
+
+Routine Description:
+
+    This routine is called by the timer code when the timer expires. It must
+    decide if another name query should be sent to the DNS server, and if not,
+    then it completes the request.
+
+Arguments:
+
+
+Notes:
+--*/
+VOID
+DnsCompletionDirect(
+    PVOID               pvContext,
+    PVOID               pvContext2,
+    tTIMERQENTRY        *pTimerQEntry
+)
+{
+	PDNS_DIRECT_WORK_ITEM_CONTEXT	pContext;
+	tDEVICECONTEXT          		*pDeviceContext;
+
+	NTSTATUS                 status;
+	CTELockHandle            OldIrq;
+	PCHAR                    pchDomainName;
+	USHORT                   Flags;
+	BOOL                     fOneMoreTry;
+
+	KdPrint(("DnsCompletion entered\r\n"));
+
+	pContext = (PDNS_DIRECT_WORK_ITEM_CONTEXT)pvContext;
+
+
+	// if the client completion routine is not set anymore, then the
+	// timer has been cancelled or completed and this routine should
+	// just clean up its buffers associated with the tracker (and return)
+	//
+	if (!pTimerQEntry)
+	{
+		// complete the request
+		LOCATION(0x52);
+		DnsUnlinkAndCompleteDirect( pContext );
+		return;
+	}
+
+
+	//
+	// to prevent a client from stopping the timer and deleting the
+	// pContext, grab the lock and check if the timer has been stopped
+	//
+	CTESpinLock(&NbtConfig.JointLock,OldIrq);
+
+	pDeviceContext = pContext->pDeviceContext;
+
+	if (pTimerQEntry->Flags & TIMER_RETIMED)
+	{
+		//
+		// Got a wait ACK from the server.
+		//
+		pTimerQEntry->Flags &= ~TIMER_RETIMED;
+		pTimerQEntry->Flags |= TIMER_RESTART;
+		//
+		// if we are not bound to this card than use a very short timeout
+		//
+		if (
+			(!pDeviceContext->pNameServerFileObject)
+			|| (pContext->Flags & DNS_DIRECT_CANCELLED)
+		)
+		{
+		  pTimerQEntry->DeltaTime = 10;
+		}
+
+		CTESpinFree(&NbtConfig.JointLock,OldIrq);
+		return;
+	}
+
+	  // If done with all the (3) retries with primary, try secondary DNS srvr
+	  // If secondary not defined, or done with secondary as well, stop.
+	  //
+
+	fOneMoreTry = TRUE;
+
+	if (!(--pTimerQEntry->Retries))
+	{
+		//
+		// if backup server is not defined, or if it is defined but we just
+		// finished trying backup server, go back and try primary server for
+		// "other domains"
+		// e.g. DNSDomains was defined as "msft.dom2.com,msft.dom3.com,msft.dom"
+		// We were pointing at msft.dom2.com.  Now, we are done with that (and
+		// didn't get a response), so try msft.dom3.com
+		//
+		if ( ( !pDeviceContext->lDnsBackupServer ) ||
+		   (  pDeviceContext->lDnsBackupServer == LOOP_BACK ) ||
+		   (  pContext->Flags & DNS_DIRECT_DNS_BACKUP) )
+		{
+			//
+			// if we just got done trying primary domain name, try all the
+			// "other domains" specified
+			//
+			if (pContext->pchDomainName == NbtConfig.pDomainName)
+			{
+				pContext->pchDomainName = NbtConfig.pDNSDomains;
+				if ( pContext->pchDomainName )
+				{
+					pContext->Flags &= ~DNS_DIRECT_DNS_BACKUP;
+					pContext->Flags |= DNS_DIRECT_DNS_SERVER;
+					pTimerQEntry->Retries = NbtConfig.uNumRetries;
+				}
+				else
+				{
+					fOneMoreTry = FALSE;
+				}
+			}
+
+			//
+			// if we had already started on "other domains", advance to the
+			// next domain within "other domains"
+			//
+			else if ( pContext->pchDomainName )
+			{
+				pchDomainName = pContext->pchDomainName;
+				while( *pchDomainName != ',' &&     // dom names separated by comma
+				       *pchDomainName != ' ' &&     // or space
+				       *pchDomainName != '\0' )
+				{
+					pchDomainName++;
+				}
+
+				if ( *pchDomainName == '\0' )
+				   	fOneMoreTry = FALSE;
+				else
+				{
+					pchDomainName++;
+					pContext->pchDomainName = pchDomainName;
+					pContext->Flags &= ~DNS_DIRECT_DNS_BACKUP;
+					pContext->Flags |= DNS_DIRECT_DNS_SERVER;
+					pTimerQEntry->Retries = NbtConfig.uNumRetries;
+				}
+			}
+			else
+			{
+				fOneMoreTry = FALSE;
+			}
+		}
+
+		 // ok, prepare to try the backup server
+		else
+		{
+			 pTimerQEntry->Retries = NbtConfig.uNumRetries;
+
+			 pContext->Flags &= ~DNS_DIRECT_DNS_SERVER;
+			 pContext->Flags |= DNS_DIRECT_DNS_BACKUP;
+		}
+	}
+
+	  // we aren't done yet: send one more query and restart the timer
+	if (fOneMoreTry)
+	{
+		CTESpinFree(&NbtConfig.JointLock,OldIrq);
+
+		status = UdpSendDNSBcastDirect( pContext,	0, 0 );
+
+		pTimerQEntry->Flags |= TIMER_RESTART;
+
+		KdPrint(("One more DNS query sent out\r\n"));
+	}
+
+      // yup, all done: didn't find the name!
+	else
+	{
+		pTimerQEntry->Flags |= TIMER_RESTART;
+		StopTimer(pTimerQEntry,NULL,NULL);
+		CTESpinFree(&NbtConfig.JointLock,OldIrq);
+	}
+}
+
+//----------------------------------------------------------------------------
+/*++
+
+Routine Description:
+
+    This routine "actually" completes the request, either by completing the
+	asociated NCB with some kind of failure, or passing it off to the
+	main NCB processing code.
+
+Arguments:
+
+
+Notes:
+--*/
+VOID
+DnsActualCompletionDirect(
+    IN NBT_WORK_ITEM_CONTEXT * pnbtContext
+)
+{
+    PDNS_DIRECT_WORK_ITEM_CONTEXT pContext = pnbtContext->pClientContext;
+    uchar	errNCB = NRC_GOODRET ;
+    NCB   * pNCB = pContext->pNCB;
+
+	if ( pNCB->ncb_cmd_cplt == NRC_PENDING )
+	{
+		//
+		// Failed to resolve the name, or request was cancelled.
+		//
+		if ( pContext->pIpAddress[0] == 0 )
+		{
+			errNCB = NRC_CMDTMO;
+		}
+		else if ( pContext->Flags & DNS_DIRECT_CANCELLED )
+		{
+			errNCB = NRC_CMDCAN;
+		}
+		else
+		{
+			errNCB = VNBT_NCB_X ( pContext->pNCB, NULL, pContext->pIpAddress, NULL, 0 );
+		}
+		if ( errNCB != NRC_GOODRET )
+		{
+	        pNCB->ncb_retcode = pNCB->ncb_cmd_cplt = errNCB ;
+		    //
+		    // call the post-routine only if the post-routine has been specified!
+		    //
+		    if ( pNCB->ncb_post )
+		    {
+		        typedef void (CALLBACK * VXDNCBPost )( void ) ;
+		        VXDNCBPost ncbpost = (VXDNCBPost) pNCB->ncb_post ;
+
+		        //
+		        //  Clients are expecting EBX to point to the NCB (instead of
+		        //  pushing it on the stack...).  The post routine may trash
+		        //  ebp also, so save it.
+		        //
+		        _asm  pushad ;
+		        _asm  mov   ebx, pNCB ;
+		        ncbpost() ;
+		        _asm  popad ;
+		    }
+		}
+	}
+
+    CTEMemFree(pContext);
+    CTEMemFree(pnbtContext);
+}
+
+//----------------------------------------------------------------------------
+VOID
+DnsUnlinkAndCompleteDirect(
+    IN PDNS_DIRECT_WORK_ITEM_CONTEXT pContext
+)
+/*++
+
+Routine Description:
+
+    This routine unlinks and completes the request.
+
+Arguments:
+
+
+Notes:
+--*/
+{
+	RemoveEntryList(&pContext->Linkage);
+
+	VxdScheduleDelayedCall ( NULL,
+							 pContext,
+							 NULL,
+							 DnsActualCompletionDirect,
+							 pContext->pDeviceContext
+						   );
+}
+
+//----------------------------------------------------------------------------
+VOID
+ProcessDnsResponseDirect(
+    IN  tDEVICECONTEXT      *pDeviceContext,
+    IN  PVOID               pSrcAddress,
+    IN  tNAMEHDR UNALIGNED  *pNameHdr,
+    IN  LONG                lNumBytes,
+    IN  USHORT              OpCodeFlags
+    )
+/*++
+
+Routine Description:
+
+    This function sets the state of the name being resolved appropriately
+    depending on whether DNS sends a positive or a negative response to our
+    query; calls the client completion routine and stops any more DNS queries
+    from going.
+
+Arguments:
+
+
+Return Value:
+
+    NTSTATUS - STATUS_SUCCESS or STATUS_UNSUCCESSFUL
+
+--*/
+{						
+	NTSTATUS				status;
+    tDNS_QUERYRESP  UNALIGNED   *pQuery;
+    PLIST_ENTRY     		pHead;
+    PLIST_ENTRY     		pEntry;
+	PDNS_DIRECT_WORK_ITEM_CONTEXT
+							pContext;
+    COMPLETIONCLIENT        pClientCompletion;
+    PVOID                   Context;
+    PTRANSPORT_ADDRESS      pSourceAddress;
+    ULONG                   SrcAddress;
+    ULONG                   IpAddress;
+    tTIMERQENTRY            *pTimer = NULL;
+    CTELockHandle           OldIrq1;
+    LONG                    lNameSize;
+    LONG                    lTraversedSoFar=0;
+    CHAR                    pJunkBuf[NETBIOS_NAME_SIZE];
+    PUCHAR                  pchQry;
+
+    // make sure this is a response
+
+    if ( !(OpCodeFlags & OP_RESPONSE) )
+    {
+        CDbgPrint(DBGFLAG_ERROR,("ProcessDnsResponseDirect: Bad OpCodeFlags\r\n"));
+
+        return;
+    }
+
+    pSourceAddress = (PTRANSPORT_ADDRESS)pSrcAddress;
+    SrcAddress     = ntohl(((PTDI_ADDRESS_IP)&pSourceAddress->Address[0].Address[0])->in_addr);
+
+    CTESpinLock(&NbtConfig.JointLock,OldIrq1);
+
+	if ( ( pContext = FindContextDirect( pNameHdr->TransactId ) ) != NULL )
+
+	{
+		pContext->Flags |= DNS_DIRECT_ANSWERED;
+		if ( pTimer = pContext->pTimer )
+		{
+		    //
+		    // If the response we received doesn't resolve the name, we silently return,
+		    // but make sure reties is set to 1 so that when timer fires again, we don't
+		    // send another name query to the same server but instead timeout the
+		    // attempt on this server
+		    //
+	        pTimer->Retries = 1;
+		}
+	    //
+	    // check the pdu size for errors
+	    //
+	    if (lNumBytes < DNS_MINIMUM_QUERYRESPONSE)
+	    {
+	        CDbgPrint(DBGFLAG_ERROR,("ProcessDnsResponseDirect: Bad lNumBytes\r\n"));
+			goto done;
+	    }
+
+//
+// BUGBUG: should we require authoritative responses from DNS servers?
+//
+
+	    //
+	    // if it's a negative response, quit now!
+	    //
+	    if (IS_NEG_RESPONSE(OpCodeFlags))
+	    {
+			goto done;
+	    }
+
+	    //
+	    // if there is no answer section, return!
+	    //
+	    if ( !pNameHdr->AnCount )
+	    {
+	        CDbgPrint(DBGFLAG_ERROR,("ProcessDnsResponseDirect: No answer section\r\n"));
+			goto done;
+	    }
+
+	    //
+	    // lNameSize is the length of the entire name, excluding the length byte
+	    // for the first label (including length bytes of subsequent labels) and
+	    // including the trailing 0 (tNAMEHDR struc takes care for 1st byte)
+	    //
+	    DnsExtractName( (PCHAR)&pNameHdr->NameRR.NameLength,
+                        lNumBytes,
+                        pJunkBuf,
+                        &lNameSize
+	                    );
+	    pchQry = (PUCHAR)&pNameHdr->NameRR.NetBiosName[lNameSize];
+
+	    lTraversedSoFar += lNameSize;
+
+	    //
+	    // if the Question section is returned with the response then we have
+	    // a little more work to do!  In this case, pQuery is pointing at the
+	    // beginning of the QTYPE field (end of the QNAME)
+	    //
+	    if ( pNameHdr->QdCount )
+	    {
+	       pchQry += sizeof(tQUESTIONMODS);
+	       lTraversedSoFar += sizeof(tQUESTIONMODS);
+
+	       // most common case: 1st byte will be 0xC0, which means next byte points
+	       // to the actual name.  We don't care about the name, so we skip over
+	       // both the bytes
+	       //
+	       if ( (*pchQry) == PTR_TO_NAME )
+	       {
+	          pchQry += sizeof(tDNS_LABEL);
+	          lTraversedSoFar += sizeof(tDNS_LABEL);
+	       }
+
+	       //
+	       // if some implementation doesn't optimize and copies the whole name
+	       // again, skip over the length of the name
+	       //
+	       else
+	       {
+	          pchQry += (lNameSize+1);   // +1 because of the 1st length byte!
+	          lTraversedSoFar += (lNameSize+1);
+	       }
+	    }
+
+	    pQuery = (tDNS_QUERYRESP *)pchQry;
+
+	    //
+	    // if this rr is telling us about canonical name, skip over it and go to
+	    // where the ipaddr is
+	    //
+	    if (ntohs(pQuery->RrType) == DNS_CNAME)
+	    {
+	        //
+	        // since this is CNAME, there is no ipaddr.  Instead, the data is the
+	        // canonical name whose length we are adding, and subtract ipaddr's len
+	        //
+	        pchQry += (sizeof(tDNS_QUERYRESP) - sizeof(ULONG));
+	        pchQry += ntohs(pQuery->Length);
+	        lTraversedSoFar += ntohs(pQuery->Length) + sizeof(tDNS_QUERYRESP) - sizeof(ULONG);
+
+	        ASSERT(lNumBytes > lTraversedSoFar);
+
+	        // most common case: 1st byte will be 0xC0, which means next byte points
+	        // to the actual name.  We don't care about the name, so we skip over
+	        // both the bytes
+	        //
+	        if ( (*pchQry) == PTR_TO_NAME )
+	        {
+	           pchQry += sizeof(tDNS_LABEL);
+	           lTraversedSoFar += sizeof(tDNS_LABEL);
+	        }
+
+	        //
+	        // if some implementation doesn't optimize and copies the whole name
+	        // again, skip over the length of the name
+	        //
+	        else
+	        {
+	           // we have already taken the name out.  we are calling this routine
+	           // just to see how big the canonical name is (i.e.lNameSize), to skip
+	           // past it
+	           //
+	           DnsExtractName( pchQry,
+	                           lNumBytes-lTraversedSoFar,
+	                           pJunkBuf,
+	                           &lNameSize
+                               );
+
+	           //
+	           // lNameSize is the length of the entire name, excluding the length byte
+	           // for the first label (including length bytes of subsequent labels) and
+	           // including the trailing 0 (tNAMEHDR struc takes care for 1st byte)
+	           //
+	           pchQry += lNameSize+1;     // +1 for the length byte of first label
+
+	        }
+
+	        pQuery = (tDNS_QUERYRESP *)pchQry;
+	    }
+
+	    // if we came this far, it's a positive response.  do the needful.
+
+		IpAddress = ntohl(pQuery->IpAddress);
+
+		if ( !NbtWouldLoopback( IpAddress ) )
+		{
+			pContext->pIpAddress[0] = IpAddress;
+		}
+		else
+		{
+			pContext->Flags |= DNS_DIRECT_CANCELLED;
+		}
+
+        //
+        // Set the backup name server to be the main name server
+        // if we got a response from it.
+        //
+        if ( SrcAddress == pContext->pDeviceContext->lDnsBackupServer )
+        {
+           pContext->pDeviceContext->lDnsBackupServer =
+               pContext->pDeviceContext->lDnsServerAddress;
+
+           pContext->pDeviceContext->lDnsServerAddress = SrcAddress;
+        }
+
+		StopTimer(pTimer,NULL,NULL);
+	}
+
+done:
+
+    CTESpinFree(&NbtConfig.JointLock,OldIrq1);
+    return;
+}
+
+//----------------------------------------------------------------------------
+PDNS_DIRECT_SEND_CONTEXT
+CreateSendContextDirect(
+    IN  PCHAR       pName,
+    IN  PCHAR       pchDomainName,
+    OUT PVOID       *pHdrs,
+    OUT PULONG      pLength,
+    IN  PDNS_DIRECT_WORK_ITEM_CONTEXT	pContext
+    )
+/*++
+
+Routine Description:
+
+    This routine builds a name query pdu
+
+Arguments:
+
+
+Return Value:
+
+    PDNS_DIRECT_SEND_CONTEXT - a pointer to a data structure used for the datagram
+		send that must be freed by the datagram send completion routine
+
+--*/
+{
+    tNAMEHDR        *pNameHdr;
+    ULONG           uLength;
+    ULONG           uDomainNameSize;
+    tGENERALRR      *pGeneral;
+    CTELockHandle   OldIrq;
+	PDNS_DIRECT_SEND_CONTEXT
+					pSendContext;
+
+    uDomainNameSize = domnamelen(pchDomainName) + 1;   // +1 for len byte
+    if (uDomainNameSize > 1)
+    {
+        uDomainNameSize++;        // for the null byte
+    }
+
+    // size is size of the namehdr structure -1 for the NetbiosName[1]
+    // + the 32 bytes for the half ascii name +
+    // scope + size of the General RR structure
+    uLength = sizeof(DNS_DIRECT_SEND_CONTEXT) - 1
+			  + uDomainNameSize
+			  + sizeof(ULONG)
+			  + strlen(pName)
+			  + 1;
+
+    // Note that this memory must be deallocated when the send completes in
+    // SendDNSBcastDoneDirect()
+    pSendContext = NbtAllocMem((USHORT)uLength ,NBT_TAG('X'));
+
+    if (pSendContext)
+    {
+	    CTEZeroMemory((PVOID)pSendContext,uLength);
+
+		pNameHdr = &pSendContext->NameHdr;
+
+	    pNameHdr->TransactId = pContext->TransactId;
+	    pNameHdr->QdCount = 1;
+	    pNameHdr->AnCount = 0;
+	    pNameHdr->NsCount = 0;
+
+	    *pHdrs = (PVOID)pNameHdr;
+	    *pLength = uLength = uLength - ( sizeof(DNS_DIRECT_SEND_CONTEXT) - sizeof(tNAMEHDR) );
+
+	    // copy the netbios name ... adding the scope too
+		if ( pContext->Flags & DNS_DIRECT_NAME_HAS_DOTS )
+		{
+			char * p;
+			for ( p = pName ; *p != '.' ; p++ );
+			p[0] = '\0';
+		    pGeneral = (tGENERALRR *)DnsStoreName(
+		                    (PCHAR)&pNameHdr->NameRR.NameLength,
+		                    pName,
+		                    &p[1],
+		                    eDIRECT_DNS_NAME_QUERY);
+			p[0] = '.';
+		}
+		else
+		{
+		    pGeneral = (tGENERALRR *)DnsStoreName(
+		                    (PCHAR)&pNameHdr->NameRR.NameLength,
+		                    pName,
+		                    pContext->pchDomainName,
+		                    eDIRECT_DNS_NAME_QUERY);
+		}
+
+
+	    pGeneral->Question.QuestionTypeClass = htonl(QUEST_DNSINTERNET);
+
+	    pNameHdr->OpCodeFlags = (FL_RECURDESIRE);
+
+	    pNameHdr->ArCount = 0;
+
+	    pSendContext->SendBuffer.pDgramHdr = pNameHdr;
+	    pSendContext->SendBuffer.HdrLength = uLength;
+	    pSendContext->SendBuffer.pBuffer   = NULL;
+	    pSendContext->SendBuffer.Length    = 0;
+		pSendContext->SendInfo.RemoteAddressLength = sizeof(pSendContext->NameServerAddress);
+		pSendContext->SendInfo.RemoteAddress = (PTRANSPORT_ADDRESS)&pSendContext->NameServerAddress;
+		pSendContext->NameServerAddress.TAAddressCount = 1;
+		pSendContext->NameServerAddress.Address[0].AddressLength = sizeof(TDI_ADDRESS_IP);
+		pSendContext->NameServerAddress.Address[0].AddressType = TDI_ADDRESS_TYPE_IP;
+		pSendContext->NameServerAddress.Address[0].Address[0].sin_port = htons(NbtConfig.DnsServerPort);
+		if ( pContext->Flags & DNS_DIRECT_DNS_SERVER )
+		{
+			pSendContext->NameServerAddress.Address[0].Address[0].in_addr = htonl(pContext->pDeviceContext->lDnsServerAddress);
+		}
+		else
+		{
+			pSendContext->NameServerAddress.Address[0].Address[0].in_addr = htonl(pContext->pDeviceContext->lDnsBackupServer);
+		}
+    }
+
+    return(pSendContext);
+}
+
+//----------------------------------------------------------------------------
+PDNS_DIRECT_WORK_ITEM_CONTEXT
+FindContextDirect(
+	USHORT	TransactionId
+)
+/*++
+
+Routine Description:
+
+    This routine find the DNS_DIRECT_WORK_ITEM_CONTEXT having the given
+	TransactId
+
+Arguments:
+
+
+Return Value:
+
+    PDNS_DIRECT_SEND_CONTEXT - a pointer to the pContext having the given
+	TransactId, or NULL
+
+Notes:
+
+	Called with NbtConfig.JointLock held
+
+--*/
+{
+    PLIST_ENTRY     		pHead;
+    PLIST_ENTRY     		pEntry;
+	PDNS_DIRECT_WORK_ITEM_CONTEXT
+							pContext;
+
+    pHead = pEntry = &NbtConfig.DNSDirectNameQueries;
+
+    while ((pEntry = pEntry->Flink) != pHead)
+    {
+        pContext = CONTAINING_RECORD(pEntry,DNS_DIRECT_WORK_ITEM_CONTEXT,Linkage);
+		if ( pContext->TransactId == TransactionId )
+		{
+			return pContext;
+		}
+	}
+	return NULL;
+}
+
+//----------------------------------------------------------------------------
+VOID
+IpToAscii(
+	IN	DWORD		IpAddress,
+	IN OUT PCHAR	pcAscii
+)
+/*++
+
+Routine Description:
+
+    This routine converts an IP address to a NetBIOS name.
+
+Arguments:
+
+	DWORD	IP address
+	PCHAR 	String pointer allocated for 16 bytes
+						
+Return Value:
+
+    Note
+
+Notes:
+
+	This is a gigantic hack designed to get "net use \\<dnsname>"
+	working under Windows 95 OPK2 without destabilizing the existing
+	code base over much.
+
+--*/
+{
+	PCHAR 	pcIpAddressBytes = ( (PCHAR) &IpAddress ) + 3;
+	PCHAR	pcIp = pcAscii;
+
+	int i,j,k,l,m;
+
+	memset ( pcAscii, 0x20, NETBIOS_NAME_SIZE );
+
+	for ( i = 4 ; i-- > 0 ; )
+	{
+
+		j = *pcIpAddressBytes-- & 0x000000FF;
+		k = j/100;
+		l = (j%100)/10;
+		m = j%10;
+
+		if ( k )
+		{
+			*pcIp++ = k + '0';
+			*pcIp++ = l + '0';
+		}
+
+		else if ( l )
+		{
+			*pcIp++ = l + '0';
+		}
+
+		*pcIp++ = m + '0';
+
+		if ( i )
+		{
+			*pcIp++ = '.';
+		}
+
+	}
+
+}
+