mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3914 lines
120 KiB
3914 lines
120 KiB
/*++
|
|
|
|
Copyright (c) 1989-1993 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
Namesrv.c
|
|
|
|
Abstract:
|
|
|
|
This file contains the name service functions called by other parts of
|
|
the NBT code. (QueryNameOnNet, FindName, RegisterName). It also contains
|
|
the completion routines for the timeouts associated with these functions.
|
|
|
|
The pScope values that are passed around from one routine to the next
|
|
point to the scope string for the name. If there is no scope then the
|
|
pScope ptr points at a single character '\0' - signifying a string of
|
|
zero length. Therefore the check for scope is "if (*pScope != 0)"
|
|
|
|
Author:
|
|
|
|
Jim Stewart (Jimst) 10-2-92
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#include "namesrv.tmh"
|
|
|
|
//
|
|
// function prototypes for completion routines that are local to this file
|
|
//
|
|
NTSTATUS
|
|
AddToPendingList(
|
|
IN PCHAR pName,
|
|
OUT tNAMEADDR **ppNameAddr
|
|
);
|
|
|
|
VOID
|
|
MSnodeCompletion(
|
|
PVOID pContext,
|
|
PVOID pContext2,
|
|
tTIMERQENTRY *pTimerQEntry
|
|
);
|
|
|
|
VOID
|
|
MSnodeRegCompletion(
|
|
PVOID pContext,
|
|
PVOID pContext2,
|
|
tTIMERQENTRY *pTimerQEntry
|
|
);
|
|
|
|
VOID
|
|
SetWinsDownFlag(
|
|
tDEVICECONTEXT *pDeviceContext
|
|
);
|
|
|
|
VOID
|
|
ReleaseCompletion(
|
|
PVOID pContext,
|
|
PVOID pContext2,
|
|
tTIMERQENTRY *pTimerQEntry
|
|
);
|
|
|
|
VOID
|
|
NextRefresh(
|
|
IN PVOID pNameAdd,
|
|
IN NTSTATUS status
|
|
);
|
|
|
|
VOID
|
|
GetNextName(
|
|
IN tNAMEADDR *pNameAddrIn,
|
|
OUT tNAMEADDR **ppNameAddr
|
|
);
|
|
|
|
NTSTATUS
|
|
StartRefresh(
|
|
IN tNAMEADDR *pNameAddr,
|
|
IN tDGRAM_SEND_TRACKING *pTracker,
|
|
IN CTELockHandle *pJointLockOldIrq,
|
|
IN BOOLEAN ResetDevice
|
|
);
|
|
|
|
VOID
|
|
NextKeepAlive(
|
|
IN tDGRAM_SEND_TRACKING *pTracker,
|
|
IN NTSTATUS statuss,
|
|
IN ULONG Info
|
|
);
|
|
|
|
VOID
|
|
GetNextKeepAlive(
|
|
tDEVICECONTEXT *pDeviceContext,
|
|
tDEVICECONTEXT **ppDeviceContextOut,
|
|
tLOWERCONNECTION *pLowerConnIn,
|
|
tLOWERCONNECTION **ppLowerConnOut,
|
|
tDGRAM_SEND_TRACKING *pTracker
|
|
);
|
|
|
|
VOID
|
|
WinsDownTimeout(
|
|
PVOID pContext,
|
|
PVOID pContext2,
|
|
tTIMERQENTRY *pTimerQEntry
|
|
);
|
|
|
|
BOOL
|
|
AppropriateNodeType(
|
|
IN PCHAR pName,
|
|
IN ULONG NodeType
|
|
);
|
|
|
|
BOOL
|
|
IsBrowserName(
|
|
IN PCHAR pName
|
|
);
|
|
|
|
#if DBG
|
|
unsigned char Buff[256];
|
|
unsigned char Loc;
|
|
#endif
|
|
|
|
//******************* Pageable Routine Declarations ****************
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma CTEMakePageable(PAGE, DelayedSessionKeepAlive)
|
|
#endif
|
|
//******************* Pageable Routine Declarations ****************
|
|
|
|
//----------------------------------------------------------------------------
|
|
NTSTATUS
|
|
AddToPendingList(
|
|
IN PCHAR pName,
|
|
OUT tNAMEADDR **ppNameAddr
|
|
)
|
|
/*++
|
|
Routine Description:
|
|
|
|
This routine Adds a name query request to the PendingNameQuery list.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
The function value is the status of the operation.
|
|
|
|
|
|
--*/
|
|
{
|
|
tNAMEADDR *pNameAddr;
|
|
|
|
pNameAddr = NbtAllocMem(sizeof(tNAMEADDR),NBT_TAG('R'));
|
|
if (pNameAddr)
|
|
{
|
|
CTEZeroMemory(pNameAddr,sizeof(tNAMEADDR));
|
|
|
|
CTEMemCopy(pNameAddr->Name,pName,NETBIOS_NAME_SIZE);
|
|
pNameAddr->NameTypeState = STATE_RESOLVING | NBT_UNIQUE;
|
|
pNameAddr->Verify = REMOTE_NAME;
|
|
pNameAddr->TimeOutCount = NbtConfig.RemoteTimeoutCount;
|
|
NBT_REFERENCE_NAMEADDR (pNameAddr, REF_NAME_QUERY_ON_NET);
|
|
|
|
InsertTailList(&NbtConfig.PendingNameQueries, &pNameAddr->Linkage);
|
|
|
|
*ppNameAddr = pNameAddr;
|
|
return(STATUS_SUCCESS);
|
|
}
|
|
else
|
|
{
|
|
return(STATUS_INSUFFICIENT_RESOURCES);
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
NTSTATUS
|
|
QueryNameOnNet(
|
|
IN PCHAR pName,
|
|
IN PCHAR pScope,
|
|
IN USHORT uType,
|
|
IN tDGRAM_SEND_TRACKING *pTrackerClientContext,
|
|
IN PVOID pClientCompletion,
|
|
IN ULONG LocalNodeType,
|
|
IN tNAMEADDR *pNameAddrIn,
|
|
IN tDEVICECONTEXT *pDeviceContext,
|
|
IN CTELockHandle *pJointLockOldIrq
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine attempts to resolve a name on the network either by a
|
|
broadcast or by talking to the NS depending on the type of node. (M,P or B)
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
The function value is the status of the operation.
|
|
|
|
Called By: ProxyQueryFromNet() in proxy.c, NbtConnect() in name.c
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG Timeout;
|
|
USHORT Retries;
|
|
NTSTATUS status;
|
|
PVOID pCompletionRoutine;
|
|
tDGRAM_SEND_TRACKING *pTrackerQueryNet;
|
|
tNAMEADDR *pNameAddr;
|
|
LPVOID pContext2 = NULL;
|
|
CHAR cNameType = pName[NETBIOS_NAME_SIZE-1];
|
|
BOOL SendFlag = TRUE;
|
|
LONG IpAddr = 0;
|
|
ULONG Flags;
|
|
|
|
status = GetTracker(&pTrackerQueryNet, NBT_TRACKER_QUERY_NET);
|
|
if (!NT_SUCCESS(status))
|
|
{
|
|
return(status);
|
|
}
|
|
|
|
if (pTrackerClientContext) // This will be NULL for Proxy requests
|
|
{
|
|
pTrackerClientContext->pTrackerWorker = pTrackerQueryNet;
|
|
}
|
|
|
|
//
|
|
// put the name in the remote cache to keep track of it while it resolves...
|
|
//
|
|
pNameAddr = NULL;
|
|
if (!pNameAddrIn)
|
|
{
|
|
status = AddToPendingList(pName,&pNameAddr);
|
|
|
|
if (!NT_SUCCESS(status))
|
|
{
|
|
FreeTracker(pTrackerQueryNet,RELINK_TRACKER);
|
|
return(status);
|
|
}
|
|
|
|
// fill in the record with the name and IpAddress
|
|
pNameAddr->NameTypeState = (uType == NBT_UNIQUE) ? NAMETYPE_UNIQUE : NAMETYPE_GROUP;
|
|
}
|
|
else
|
|
{
|
|
status = STATUS_SUCCESS;
|
|
pNameAddr = pNameAddrIn;
|
|
pNameAddr->RefCount = 1;
|
|
}
|
|
|
|
CHECK_PTR(pNameAddr);
|
|
pNameAddr->NameTypeState &= ~NAME_STATE_MASK;
|
|
pNameAddr->NameTypeState |= STATE_RESOLVING;
|
|
pNameAddr->Ttl = NbtConfig.RemoteHashTtl;
|
|
//
|
|
// put a pointer to the tracker here so that other clients attempting to
|
|
// query the same name at the same time can tack their trackers onto
|
|
// the end of this one. - i.e. This is the tracker for the
|
|
// datagram send, or connect, not the name query.
|
|
//
|
|
pNameAddr->pTracker = pTrackerClientContext;
|
|
pNameAddr->pTimer = NULL;
|
|
|
|
#ifdef PROXY_NODE
|
|
//
|
|
// If the node type is PROXY, it means that the request is being sent
|
|
// as a result of hearing a name registration or a name query on the net.
|
|
//
|
|
// If the node type is not == PROXY (i.e. it is MSNODE | PROXY,
|
|
// PNODE | PROXY, MSNODE, PNODE, etc, then the request is being sent as
|
|
// a result of a client request
|
|
//
|
|
// Refer: RegOrQueryFromNet in Proxy.c
|
|
//
|
|
// This field is used in QueryFromNet() to determine whether or not
|
|
// to revert to Broadcast
|
|
//
|
|
#endif
|
|
if(LocalNodeType & PROXY)
|
|
{
|
|
pNameAddr->ProxyReqType = (LocalNodeType & PROXY_REG)? NAMEREQ_PROXY_REGISTRATION: NAMEREQ_PROXY_QUERY;
|
|
LocalNodeType &= (~PROXY_REG); // Turn it off for safe
|
|
}
|
|
else
|
|
{
|
|
pNameAddr->ProxyReqType = NAMEREQ_REGULAR;
|
|
LocalNodeType = AppropriateNodeType( pName, LocalNodeType );
|
|
}
|
|
|
|
// keep a ptr to the Ascii name so that we can remove the name from the
|
|
// hash table later if the query fails.
|
|
CHECK_PTR(pTrackerQueryNet);
|
|
pTrackerQueryNet->pNameAddr = pNameAddr;
|
|
pTrackerQueryNet->SendBuffer.pDgramHdr = NULL; // set to NULL to catch any erroneous frees.
|
|
pTrackerQueryNet->pDeviceContext = pDeviceContext;
|
|
//
|
|
// set the ref count high enough so that a pdu from the wire cannot
|
|
// free the tracker while UdpSendNsBcast is running - i.e. between starting
|
|
// the timer and actually sending the datagram.
|
|
//
|
|
pTrackerQueryNet->RefCount = 2;
|
|
#ifdef MULTIPLE_WINS
|
|
// Set the info for the Extra Name Servers (in addition to Pri & Sec WINs)
|
|
pTrackerQueryNet->NSOthersLeft = pDeviceContext->lNumOtherServers;
|
|
pTrackerQueryNet->NSOthersIndex = pDeviceContext->lLastResponsive;
|
|
#endif
|
|
|
|
//
|
|
// Set a few values as a precursor to registering the name either by
|
|
// broadcast or with the name server
|
|
//
|
|
#ifdef PROXY_NODE
|
|
IF_PROXY(LocalNodeType)
|
|
{
|
|
pCompletionRoutine = ProxyTimerComplFn;
|
|
pContext2 = pTrackerClientContext;
|
|
pTrackerClientContext = NULL;
|
|
|
|
if ((pDeviceContext->lNameServerAddress == LOOP_BACK) ||
|
|
pDeviceContext->WinsIsDown) {
|
|
Retries = pNbtGlobConfig->uNumBcasts;
|
|
Timeout = (ULONG)pNbtGlobConfig->uBcastTimeout;
|
|
pTrackerQueryNet->Flags = NBT_BROADCAST;
|
|
} else {
|
|
Retries = (USHORT)pNbtGlobConfig->uNumRetries;
|
|
Timeout = (ULONG)pNbtGlobConfig->uRetryTimeout;
|
|
pTrackerQueryNet->Flags = NBT_NAME_SERVER;
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
if (NbtConfig.UseDnsOnly)
|
|
{
|
|
IF_DBG(NBT_DEBUG_NAMESRV)
|
|
KdPrint (("Nbt.QueryNameOnNet: Shorting out Query path to do DNS only for %16.16s<%X>\n",
|
|
pName,pName[15]));
|
|
|
|
//
|
|
// Short out query over wire
|
|
//
|
|
Retries = 1;
|
|
Timeout = 10;
|
|
SendFlag = FALSE;
|
|
pCompletionRoutine = MSnodeCompletion;
|
|
|
|
//
|
|
// For BNODE or MSNODE, the last stage is Broadcast
|
|
//
|
|
if (LocalNodeType & (BNODE | MSNODE))
|
|
{
|
|
pTrackerQueryNet->Flags = NBT_BROADCAST;
|
|
}
|
|
//
|
|
// For PNODE or MNODE, the last stage is Secondary Wins server
|
|
//
|
|
else
|
|
{
|
|
pTrackerQueryNet->Flags = NBT_NAME_SERVER_BACKUP;
|
|
}
|
|
|
|
pTrackerClientContext->ResolutionContextFlags = 0xff;
|
|
}
|
|
else if ((pTrackerClientContext->pFailedIpAddresses) &&
|
|
(pTrackerClientContext->ResolutionContextFlags))
|
|
{
|
|
//
|
|
// We are reattempting the query after the previous attempt failed!
|
|
//
|
|
pTrackerQueryNet->Flags = pTrackerClientContext->ResolutionContextFlags;
|
|
pTrackerQueryNet->NSOthersIndex = pTrackerClientContext->NSOthersIndex;
|
|
pTrackerQueryNet->NSOthersLeft = pTrackerClientContext->NSOthersLeft;
|
|
|
|
//
|
|
// Set the Retries to 1 by default so that we can immediately proceed
|
|
// to the next stage in the querying process
|
|
//
|
|
Retries = 1;
|
|
Timeout = 10;
|
|
SendFlag = FALSE;
|
|
pCompletionRoutine = MSnodeCompletion;
|
|
}
|
|
else
|
|
{
|
|
Retries = pNbtGlobConfig->uNumRetries;
|
|
Timeout = (ULONG)pNbtGlobConfig->uRetryTimeout;
|
|
pCompletionRoutine = MSnodeCompletion;
|
|
pTrackerQueryNet->Flags = NBT_NAME_SERVER;
|
|
|
|
// use broadcast if no name server address for MSNODE or Wins down,
|
|
// or it is Bnode,Mnode.
|
|
// for Pnode, just allow it to do the name query on the loop back
|
|
// address
|
|
//
|
|
if ((LocalNodeType & (MNODE | BNODE)) ||
|
|
((LocalNodeType & MSNODE) &&
|
|
((pDeviceContext->lNameServerAddress == LOOP_BACK) ||
|
|
pDeviceContext->WinsIsDown)))
|
|
{
|
|
Retries = pNbtGlobConfig->uNumBcasts;
|
|
Timeout = (ULONG)pNbtGlobConfig->uBcastTimeout;
|
|
pTrackerQueryNet->Flags = NBT_BROADCAST;
|
|
}
|
|
else if ((pDeviceContext->lNameServerAddress == LOOP_BACK) ||
|
|
(pDeviceContext->WinsIsDown))
|
|
{
|
|
//
|
|
// short out timeout when no wins server configured -for PNODE
|
|
//
|
|
Retries = 1;
|
|
Timeout = 10;
|
|
pTrackerQueryNet->Flags = NBT_NAME_SERVER_BACKUP;
|
|
}
|
|
|
|
//
|
|
// no sense doing a name query out an adapter with no Ip address
|
|
//
|
|
if (pTrackerClientContext)
|
|
{
|
|
Flags = pTrackerClientContext->Flags;
|
|
}
|
|
else
|
|
{
|
|
Flags = 0;
|
|
}
|
|
|
|
if ((pDeviceContext->IpAddress == 0) || (IpAddr = Nbt_inet_addr(pName, Flags)))
|
|
{
|
|
Retries = 1;
|
|
Timeout = 10;
|
|
pTrackerQueryNet->Flags = NBT_BROADCAST;
|
|
SendFlag = FALSE;
|
|
if (LocalNodeType & (PNODE | MNODE))
|
|
{
|
|
pTrackerQueryNet->Flags = NBT_NAME_SERVER_BACKUP;
|
|
}
|
|
}
|
|
}
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,*pJointLockOldIrq);
|
|
|
|
|
|
// do a name query... will always return status pending...
|
|
// the pNameAddr structure cannot get deleted out from under us since
|
|
// only a timeout on the send (3 retries) will remove the name. Any
|
|
// response from the net will tend to keep the name (change state to Resolved)
|
|
//
|
|
|
|
//
|
|
// Bug: 22542 - prevent broadcast of remote adapter status on net view of limited subnet b'cast address.
|
|
// In order to test for subnet broadcasts, we need to match against the subnet masks of all adapters. This
|
|
// is expensive and not done.
|
|
// Just check for the limited bcast.
|
|
//
|
|
if (IpAddr == 0xffffffff)
|
|
{
|
|
KdPrint(("Nbt.QueryNameOnNet: Query on Limited broadcast - failed\n"));
|
|
status = STATUS_BAD_NETWORK_PATH;
|
|
}
|
|
else
|
|
{
|
|
status = UdpSendNSBcast(pNameAddr,
|
|
pScope,
|
|
pTrackerQueryNet,
|
|
pCompletionRoutine,
|
|
pTrackerClientContext,
|
|
pClientCompletion,
|
|
Retries,
|
|
Timeout,
|
|
eNAME_QUERY,
|
|
SendFlag);
|
|
if (!NT_SUCCESS(status)) {
|
|
NbtTrace(NBT_TRACE_NAMESRV, ("UdpSendNSBcast return %!status! for %!NBTNAME!<%02x>",
|
|
status, pNameAddr->Name, (unsigned)pNameAddr->Name[15]));
|
|
}
|
|
}
|
|
|
|
// a successful send means, Don't complete the Irp. Status Pending is
|
|
// returned to ntisol.c to tell that code not to complete the irp. The
|
|
// irp will be completed when this send either times out or a response
|
|
// is heard. In the event of an error in the send, allow that return
|
|
// code to propagate back and result in completing the irp - i.e. if
|
|
// there isn't enough memory to allocate a buffer or some such thing
|
|
//
|
|
CTESpinLock(&NbtConfig.JointLock,*pJointLockOldIrq);
|
|
NBT_DEREFERENCE_TRACKER (pTrackerQueryNet, TRUE);
|
|
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
LOCATION(0x49);
|
|
|
|
// this return must be here to avoid freeing the tracker below.
|
|
status = STATUS_PENDING;
|
|
}
|
|
else
|
|
{
|
|
LOCATION(0x50);
|
|
|
|
IF_DBG(NBT_DEBUG_NAMESRV)
|
|
KdPrint(("Nbt.QueryNameOnNet: Query failed - bad retcode from UdpSendNsBcast = %X\n", status));
|
|
|
|
//
|
|
// UdpSendNsBcast should not fail AND start the timer, therefore there
|
|
// is no need to worry about stopping the timer here.
|
|
//
|
|
CHECK_PTR(pNameAddr);
|
|
pNameAddr->pTimer = NULL;
|
|
if (pTrackerClientContext)
|
|
{
|
|
pTrackerClientContext->pTrackerWorker = NULL;
|
|
}
|
|
|
|
//
|
|
// This will free the tracker
|
|
//
|
|
NBT_DEREFERENCE_TRACKER (pTrackerQueryNet, TRUE);
|
|
NBT_DEREFERENCE_NAMEADDR (pNameAddr, REF_NAME_QUERY_ON_NET, TRUE);
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
|
|
|
|
#ifdef MULTIPLE_WINS
|
|
//----------------------------------------------------------------------------
|
|
NTSTATUS
|
|
ContinueQueryNameOnNet(
|
|
IN tDGRAM_SEND_TRACKING *pTracker,
|
|
IN PUCHAR pName,
|
|
IN tDEVICECONTEXT *pDeviceContext,
|
|
IN PVOID QueryCompletion,
|
|
IN OUT BOOLEAN *pfNameReferenced
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
This routine handles re-querying a name on the network.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Values:
|
|
|
|
NTSTATUS - status of the request
|
|
|
|
--*/
|
|
{
|
|
CTELockHandle OldIrq2;
|
|
ULONG lNameType;
|
|
NTSTATUS status;
|
|
tNAMEADDR *pNameAddr;
|
|
tIPADDRESS IpAddress;
|
|
|
|
ASSERT (!IsDeviceNetbiosless(pDeviceContext));
|
|
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq2);
|
|
|
|
//
|
|
// Name and Tracker should be currently Referenced!
|
|
//
|
|
ASSERT (NBT_VERIFY_HANDLE (pTracker, NBT_VERIFY_TRACKER));
|
|
ASSERT (NBT_VERIFY_HANDLE2(pTracker->pNameAddr, LOCAL_NAME, REMOTE_NAME));
|
|
|
|
//
|
|
// If no one else is referencing the name, then delete it from
|
|
// the hash table.
|
|
//
|
|
pTracker->pNameAddr->NameTypeState &= ~NAME_STATE_MASK;
|
|
pTracker->pNameAddr->NameTypeState |= STATE_RELEASED;
|
|
if ((pTracker->pNameAddr->Verify == REMOTE_NAME) &&
|
|
(pTracker->pNameAddr->NameTypeState & STATE_RESOLVED) &&
|
|
(pTracker->pNameAddr->RefCount == 2))
|
|
{
|
|
NBT_DEREFERENCE_NAMEADDR (pTracker->pNameAddr, REF_NAME_REMOTE, TRUE);
|
|
}
|
|
NBT_DEREFERENCE_NAMEADDR (pTracker->pNameAddr, REF_NAME_CONNECT, TRUE);
|
|
pTracker->pNameAddr = NULL;
|
|
*pfNameReferenced = FALSE;
|
|
|
|
//
|
|
// no sense re-doing a name query if:
|
|
// the request has been cancelled, or
|
|
// adapter has no Ip address, or
|
|
// the name given is itself an IP address!
|
|
// the previous query had finished querying all the WINS servers
|
|
//
|
|
if ((pTracker->Flags & TRACKER_CANCELLED) ||
|
|
(!pDeviceContext->IpAddress) ||
|
|
(Nbt_inet_addr(pName, SESSION_SETUP_FLAG)) ||
|
|
(pTracker->ResolutionContextFlags == 0xff))
|
|
{
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq2);
|
|
return (STATUS_BAD_NETWORK_PATH);
|
|
}
|
|
|
|
//
|
|
// Save the last Ip address we tried as bad!
|
|
//
|
|
if (!pTracker->pFailedIpAddresses)
|
|
{
|
|
if (!(pTracker->pFailedIpAddresses =
|
|
NbtAllocMem ((MAX_FAILED_IP_ADDRESSES) * sizeof(tIPADDRESS), NBT_TAG2('04'))))
|
|
{
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq2);
|
|
return (STATUS_INSUFFICIENT_RESOURCES);
|
|
}
|
|
CTEZeroMemory(pTracker->pFailedIpAddresses,(MAX_FAILED_IP_ADDRESSES) * sizeof(tIPADDRESS));
|
|
}
|
|
pTracker->pFailedIpAddresses[pTracker->LastFailedIpIndex] = pTracker->RemoteIpAddress;
|
|
pTracker->LastFailedIpIndex = (pTracker->LastFailedIpIndex+1) % MAX_FAILED_IP_ADDRESSES;
|
|
|
|
// check the Remote table to see if the name has been resolved
|
|
// by someone else
|
|
//
|
|
if ((pNameAddr = FindNameRemoteThenLocal(pTracker, &IpAddress, &lNameType)) &&
|
|
(IpAddress) &&
|
|
(pNameAddr->NameTypeState & STATE_RESOLVED) &&
|
|
(IpAddress != pTracker->RemoteIpAddress))
|
|
{
|
|
//
|
|
// We have another address to try!
|
|
//
|
|
NBT_REFERENCE_NAMEADDR (pNameAddr, REF_NAME_CONNECT);
|
|
*pfNameReferenced = TRUE;
|
|
pNameAddr->TimeOutCount = NbtConfig.RemoteTimeoutCount;
|
|
pTracker->pNameAddr = pNameAddr;
|
|
|
|
// set the session state to NBT_CONNECTING
|
|
CHECK_PTR(pTracker->pConnEle);
|
|
SET_STATE_UPPER (pTracker->pConnEle, NBT_CONNECTING);
|
|
pTracker->pConnEle->BytesRcvd = 0;;
|
|
pTracker->pConnEle->ReceiveIndicated = 0;
|
|
// keep track of the other end's ip address
|
|
pTracker->pConnEle->pLowerConnId->SrcIpAddr = htonl(IpAddress);
|
|
SET_STATE_LOWER (pTracker->pConnEle->pLowerConnId, NBT_CONNECTING);
|
|
pTracker->pTrackerWorker = NULL;
|
|
|
|
IF_DBG(NBT_DEBUG_NAMESRV)
|
|
KdPrint(("Nbt.NbtConnectCommon: Setting Up Session(cached entry!!) to %16.16s <%X>\n",
|
|
pNameAddr->Name,pNameAddr->Name[15]));
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq2);
|
|
|
|
//
|
|
// Now, setup the Tcp connection
|
|
//
|
|
status = TcpSessionStart (pTracker,
|
|
IpAddress,
|
|
(tDEVICECONTEXT *)pTracker->pDeviceContext,
|
|
SessionStartupContinue,
|
|
pTracker->DestPort);
|
|
}
|
|
else
|
|
{
|
|
status = QueryNameOnNet (pName,
|
|
NbtConfig.pScope,
|
|
NBT_UNIQUE,
|
|
pTracker,
|
|
QueryCompletion,
|
|
NodeType & NODE_MASK,
|
|
NULL,
|
|
pDeviceContext,
|
|
&OldIrq2);
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq2);
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
#endif
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
MSnodeCompletion(
|
|
PVOID pContext,
|
|
PVOID pContext2,
|
|
tTIMERQENTRY *pTimerQEntry
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called by the timer code when the timer expires. It must
|
|
decide if another name query should be done, and if not, then it calls the
|
|
client's completion routine (in completion2).
|
|
This routine handles the broadcast portion of the name queries (i.e.
|
|
those name queries that go out as broadcasts).
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
The function value is the status of the operation.
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
tDGRAM_SEND_TRACKING *pTracker;
|
|
CTELockHandle OldIrq;
|
|
COMPLETIONCLIENT pClientCompletion;
|
|
ULONG Flags;
|
|
tDGRAM_SEND_TRACKING *pClientTracker;
|
|
ULONG LocalNodeType;
|
|
|
|
pTracker = (tDGRAM_SEND_TRACKING *)pContext;
|
|
LocalNodeType = AppropriateNodeType( pTracker->pNameAddr->Name, NodeType );
|
|
|
|
//
|
|
// check if the client completion routine is still set. If not then the
|
|
// timer has been cancelled and this routine should just clean up its
|
|
// buffers associated with the tracker.
|
|
//
|
|
if (!pTimerQEntry)
|
|
{
|
|
// return the tracker block to its queue
|
|
pTracker->pNameAddr->pTimer = NULL;
|
|
NBT_DEREFERENCE_NAMEADDR (pTracker->pNameAddr, REF_NAME_QUERY_ON_NET, TRUE);
|
|
NBT_DEREFERENCE_TRACKER(pTracker, TRUE);
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
// to prevent a client from stopping the timer and deleting the
|
|
// pNameAddr, grab the lock and check if the timer has been stopped
|
|
//
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq);
|
|
ASSERT (NBT_VERIFY_HANDLE (pTracker->pNameAddr, REMOTE_NAME));
|
|
|
|
//
|
|
// StopTimer could have been called before we acquired the lock, so
|
|
// check for this
|
|
// Bug#: 229616
|
|
//
|
|
if (!pTimerQEntry->ClientCompletion)
|
|
{
|
|
pTracker->pNameAddr->pTimer = NULL;
|
|
NBT_DEREFERENCE_NAMEADDR (pTracker->pNameAddr, REF_NAME_QUERY_ON_NET, TRUE);
|
|
NBT_DEREFERENCE_TRACKER(pTracker, TRUE);
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
|
|
return;
|
|
}
|
|
|
|
if (pTimerQEntry->Flags & TIMER_RETIMED)
|
|
{
|
|
pTimerQEntry->Flags &= ~TIMER_RETIMED;
|
|
pTimerQEntry->Flags |= TIMER_RESTART;
|
|
//
|
|
// if we are not bound to this card than use a very short timeout
|
|
//
|
|
if (!pTracker->pDeviceContext->IpAddress)
|
|
{
|
|
pTimerQEntry->DeltaTime = 10;
|
|
}
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
return;
|
|
}
|
|
|
|
pClientTracker = (tDGRAM_SEND_TRACKING *)pTimerQEntry->ClientContext;
|
|
|
|
//
|
|
// if the tracker has been cancelled, don't do any more queries
|
|
//
|
|
if (pClientTracker->Flags & TRACKER_CANCELLED)
|
|
{
|
|
IF_DBG(NBT_DEBUG_NAMESRV)
|
|
KdPrint(("Nbt.MSnodeCompletion: tracker flag cancelled\n"));
|
|
|
|
//
|
|
// In case the timer has been stopped, we coordinate
|
|
// through the pClientCompletionRoutine Value with StopTimer.
|
|
//
|
|
pClientCompletion = pTimerQEntry->ClientCompletion;
|
|
|
|
//
|
|
// remove from the PendingNameQueries list
|
|
//
|
|
RemoveEntryList(&pTracker->pNameAddr->Linkage);
|
|
InitializeListHead(&pTracker->pNameAddr->Linkage);
|
|
|
|
// remove the link from the name table to this timer block
|
|
CHECK_PTR(((tNAMEADDR *)pTimerQEntry->pCacheEntry));
|
|
((tNAMEADDR *)pTimerQEntry->pCacheEntry)->pTimer = NULL;
|
|
//
|
|
// to synch. with the StopTimer routine, Null the client completion
|
|
// routine so it gets called just once.
|
|
//
|
|
CHECK_PTR(pTimerQEntry);
|
|
pTimerQEntry->ClientCompletion = NULL;
|
|
|
|
//
|
|
// remove the name from the hash table, since it did not
|
|
// resolve
|
|
//
|
|
CHECK_PTR(pTracker->pNameAddr);
|
|
pTracker->pNameAddr->NameTypeState &= ~NAME_STATE_MASK;
|
|
pTracker->pNameAddr->NameTypeState |= STATE_RELEASED;
|
|
pTracker->pNameAddr->pTimer = NULL;
|
|
|
|
NBT_DEREFERENCE_NAMEADDR (pTracker->pNameAddr, REF_NAME_QUERY_ON_NET, TRUE);
|
|
pTracker->pNameAddr = NULL;
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
|
|
// there can be a list of trackers Q'd up on this name
|
|
// query, so we must complete all of them!
|
|
//
|
|
CompleteClientReq(pClientCompletion, pClientTracker, STATUS_CANCELLED);
|
|
|
|
// return the tracker block to its queue
|
|
LOCATION(0x51);
|
|
NBT_DEREFERENCE_TRACKER(pTracker, FALSE);
|
|
|
|
return;
|
|
}
|
|
|
|
// if number of retries is not zero then continue trying to contact the
|
|
// Name Server.
|
|
//
|
|
if (!(--pTimerQEntry->Retries))
|
|
{
|
|
|
|
// set the retry count again
|
|
//
|
|
pTimerQEntry->Retries = NbtConfig.uNumRetries;
|
|
Flags = pTracker->Flags;
|
|
pTracker->Flags &= ~(NBT_NAME_SERVER_BACKUP
|
|
#ifdef MULTIPLE_WINS
|
|
| NBT_NAME_SERVER_OTHERS
|
|
#endif
|
|
| NBT_NAME_SERVER
|
|
| NBT_BROADCAST);
|
|
|
|
if ((Flags & NBT_BROADCAST) && (LocalNodeType & MNODE) &&
|
|
(pTracker->pDeviceContext->lNameServerAddress != LOOP_BACK) &&
|
|
!pTracker->pDeviceContext->WinsIsDown)
|
|
{
|
|
LOCATION(0x44);
|
|
// *** MNODE ONLY ***
|
|
//
|
|
// Can't Resolve through broadcast, so try the name server
|
|
//
|
|
pTracker->Flags |= NBT_NAME_SERVER;
|
|
|
|
// set a different timeout for name resolution through WINS
|
|
//
|
|
pTimerQEntry->DeltaTime = NbtConfig.uRetryTimeout;
|
|
|
|
}
|
|
else if ((Flags & NBT_NAME_SERVER) && !(LocalNodeType & BNODE))
|
|
{
|
|
LOCATION(0x47);
|
|
// *** NOT BNODE ***
|
|
//
|
|
// Can't reach the name server, so try the backup
|
|
//
|
|
pTracker->Flags |= NBT_NAME_SERVER_BACKUP;
|
|
//
|
|
// short out the timeout if no backup name server
|
|
//
|
|
if ((pTracker->pDeviceContext->lBackupServer == LOOP_BACK) ||
|
|
pTracker->pDeviceContext->WinsIsDown)
|
|
{
|
|
pTimerQEntry->Retries = 1;
|
|
pTimerQEntry->DeltaTime = 10;
|
|
|
|
}
|
|
|
|
}
|
|
#ifdef MULTIPLE_WINS
|
|
else if ((Flags & NBT_NAME_SERVER_BACKUP) && !(LocalNodeType & BNODE))
|
|
{
|
|
//
|
|
// Main backup and possibly some of the "others" have
|
|
// failed, see if there are any (more) "others" left
|
|
//
|
|
USHORT Index = pTracker->NSOthersIndex;
|
|
USHORT NumBackups = pTracker->pDeviceContext->lNumOtherServers;
|
|
|
|
pTracker->Flags |= NBT_NAME_SERVER_OTHERS;
|
|
|
|
if (Flags & NBT_NAME_SERVER_OTHERS) // not 1st time here
|
|
{ // so, move to next server
|
|
pTracker->NSOthersLeft--;
|
|
if (Index >= NumBackups-1)
|
|
{
|
|
Index = 0;
|
|
}
|
|
else
|
|
{
|
|
Index++;
|
|
}
|
|
}
|
|
|
|
while ((pTracker->NSOthersLeft > 0) &&
|
|
(LOOP_BACK == pTracker->pDeviceContext->lOtherServers[Index]))
|
|
{
|
|
pTracker->NSOthersLeft--;
|
|
if (Index >= NumBackups-1)
|
|
{
|
|
Index = 0;
|
|
}
|
|
else
|
|
{
|
|
Index++;
|
|
}
|
|
}
|
|
pTracker->NSOthersIndex = Index;
|
|
|
|
//
|
|
// short out the timeout if we did not find any "other" name servers
|
|
//
|
|
if (0 == pTracker->NSOthersLeft) // UdpSendNSBcast will do LOOP_BACK
|
|
{
|
|
pTimerQEntry->Retries = 1;
|
|
pTimerQEntry->DeltaTime = 10;
|
|
}
|
|
else
|
|
{
|
|
pTracker->Flags |= NBT_NAME_SERVER_BACKUP; // Try next "other" server on timeout
|
|
}
|
|
}
|
|
else if ((Flags & NBT_NAME_SERVER_OTHERS)
|
|
#else
|
|
else if ((Flags & NBT_NAME_SERVER_BACKUP)
|
|
#endif
|
|
&& (LocalNodeType & MSNODE))
|
|
{
|
|
LOCATION(0x46);
|
|
// *** MSNODE ONLY ***
|
|
//
|
|
// Can't reach the name server(s), so try broadcast name queries
|
|
//
|
|
pTracker->Flags |= NBT_BROADCAST;
|
|
|
|
// set a different timeout for broadcast name resolution
|
|
//
|
|
pTimerQEntry->DeltaTime = NbtConfig.uBcastTimeout;
|
|
pTimerQEntry->Retries = NbtConfig.uNumBcasts;
|
|
|
|
//
|
|
// Set the WinsIsDown Flag and start a timer so we don't
|
|
// try wins again for 15 seconds or so...only if we failed
|
|
// to reach WINS, rather than WINS returning a neg response.
|
|
//
|
|
if (!(Flags & WINS_NEG_RESPONSE))
|
|
{
|
|
SetWinsDownFlag(pTracker->pDeviceContext);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BOOLEAN bFound = FALSE;
|
|
LOCATION(0x45);
|
|
|
|
#ifdef MULTIPLE_WINS
|
|
// Signal termination of WINs server queries
|
|
pTracker->ResolutionContextFlags = NAME_RESOLUTION_DONE;
|
|
#endif
|
|
//
|
|
// see if the name is in the lmhosts file, if it ISN'T the
|
|
// proxy making the name query request!!
|
|
//
|
|
status = STATUS_UNSUCCESSFUL;
|
|
|
|
//
|
|
// In case the timer has been stopped, we coordinate
|
|
// through the pClientCompletionRoutine Value with StopTimer.
|
|
//
|
|
pClientCompletion = pTimerQEntry->ClientCompletion;
|
|
//
|
|
// the timeout has expired on the broadcast name resolution
|
|
// so call the client
|
|
//
|
|
|
|
//
|
|
// remove from the PendingNameQueries list
|
|
//
|
|
RemoveEntryList(&pTracker->pNameAddr->Linkage);
|
|
InitializeListHead(&pTracker->pNameAddr->Linkage);
|
|
|
|
// remove the link from the name table to this timer block
|
|
CHECK_PTR(((tNAMEADDR *)pTimerQEntry->pCacheEntry));
|
|
((tNAMEADDR *)pTimerQEntry->pCacheEntry)->pTimer = NULL;
|
|
//
|
|
// to synch. with the StopTimer routine, Null the client completion
|
|
// routine so it gets called just once.
|
|
//
|
|
CHECK_PTR(pTimerQEntry);
|
|
pTimerQEntry->ClientCompletion = NULL;
|
|
|
|
if (((NbtConfig.EnableLmHosts) ||
|
|
(NbtConfig.ResolveWithDns && !(pTracker->Flags & NO_DNS_RESOLUTION_FLAG))) &&
|
|
(pTracker->pNameAddr->ProxyReqType == NAMEREQ_REGULAR))
|
|
{
|
|
// only do this if the client completion routine has not
|
|
// been run yet.
|
|
//
|
|
if (pClientCompletion)
|
|
{
|
|
status = LmHostQueueRequest(pTracker,
|
|
pTimerQEntry->ClientContext,
|
|
pClientCompletion,
|
|
pTracker->pDeviceContext);
|
|
}
|
|
}
|
|
|
|
CHECK_PTR(pTimerQEntry);
|
|
CHECK_PTR(pTimerQEntry->pCacheEntry);
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
// if it is successfully queued to the Worker thread,
|
|
// then Null the ClientCompletion routine in the timerQ
|
|
// structure, letting
|
|
// the worker thread handle the rest of the name query
|
|
// resolution. Also null the timer ptr in the
|
|
// nameAddr entry in the name table.
|
|
//
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// remove the name from the hash table, since it did not
|
|
// resolve
|
|
//
|
|
CHECK_PTR(pTracker->pNameAddr);
|
|
pTracker->pNameAddr->NameTypeState &= ~NAME_STATE_MASK;
|
|
pTracker->pNameAddr->NameTypeState |= STATE_RELEASED;
|
|
pTracker->pNameAddr->pTimer = NULL;
|
|
|
|
NBT_DEREFERENCE_NAMEADDR (pTracker->pNameAddr, REF_NAME_QUERY_ON_NET, TRUE);
|
|
pTracker->pNameAddr = NULL;
|
|
|
|
pClientTracker = (tDGRAM_SEND_TRACKING *)pTimerQEntry->ClientContext;
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
|
|
// there can be a list of trackers Q'd up on this name
|
|
// query, so we must complete all of them!
|
|
//
|
|
CompleteClientReq(pClientCompletion, pClientTracker, STATUS_TIMEOUT);
|
|
|
|
// return the tracker block to its queue
|
|
LOCATION(0x51);
|
|
NBT_DEREFERENCE_TRACKER(pTracker, FALSE);
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
LOCATION(0x48);
|
|
NBT_REFERENCE_TRACKER(pTracker);
|
|
pTimerQEntry->Flags |= TIMER_RESTART;
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
status = UdpSendNSBcast(pTracker->pNameAddr,
|
|
NbtConfig.pScope,
|
|
pTracker,
|
|
NULL,NULL,NULL,
|
|
0,0,
|
|
eNAME_QUERY,
|
|
TRUE);
|
|
|
|
NBT_DEREFERENCE_TRACKER(pTracker, FALSE);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
SetWinsDownFlag(
|
|
tDEVICECONTEXT *pDeviceContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine sets the WinsIsDown flag if its not already set and
|
|
its not a Bnode. It starts a 15 second or so timer that un sets the
|
|
flag when it expires.
|
|
|
|
This routine must be called while holding the Joint Lock.
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
None
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
tTIMERQENTRY *pTimer;
|
|
|
|
if ((!pDeviceContext->WinsIsDown) && !(NodeType & BNODE))
|
|
{
|
|
status = StartTimer(WinsDownTimeout,
|
|
NbtConfig.WinsDownTimeout,
|
|
pDeviceContext, // context value
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
pDeviceContext,
|
|
&pTimer,
|
|
1, // retries
|
|
TRUE);
|
|
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
pDeviceContext->WinsIsDown = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
WinsDownTimeout(
|
|
PVOID pContext,
|
|
PVOID pContext2,
|
|
tTIMERQENTRY *pTimerQEntry
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called by the timer code when the timer expires.
|
|
It just sets the WinsIsDown boolean to False so that we will try WINS
|
|
again. In this way we will avoid talking to WINS during this timeout.
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
tDEVICECONTEXT *pDeviceContext = (tDEVICECONTEXT *)pContext;
|
|
CTELockHandle OldIrq;
|
|
|
|
if (!pTimerQEntry)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Hold the Joint Lock while traversing the list of devices
|
|
//
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq);
|
|
|
|
if (IsEntryInList (&pDeviceContext->Linkage, &NbtConfig.DeviceContexts))
|
|
{
|
|
pDeviceContext->WinsIsDown = FALSE;
|
|
}
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
|
|
IF_DBG(NBT_DEBUG_NAMESRV)
|
|
KdPrint(("Nbt.WinsDownTimeout: WINS DOWN Timed Out - Up again\n"));
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
CompleteClientReq(
|
|
COMPLETIONCLIENT pClientCompletion,
|
|
tDGRAM_SEND_TRACKING *pTracker,
|
|
NTSTATUS status
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called by completion routines to complete the client
|
|
request. It may involve completing several queued up requests.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
The function value is the status of the operation.
|
|
|
|
--*/
|
|
{
|
|
PLIST_ENTRY pEntry;
|
|
tDGRAM_SEND_TRACKING *pTrack;
|
|
tDEVICECONTEXT *pDeviceContext;
|
|
CTELockHandle OldIrq;
|
|
LIST_ENTRY ListEntry;
|
|
|
|
InitializeListHead (&ListEntry);
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq);
|
|
//
|
|
// set up a new list head for any queued name queries.
|
|
// since we may need to do a new name query below.
|
|
// The Proxy hits this routine with a Null Tracker, so check for that.
|
|
//
|
|
if (pTracker)
|
|
{
|
|
pDeviceContext = pTracker->pDeviceContext;
|
|
if( !IsListEmpty(&pTracker->TrackerList))
|
|
{
|
|
ListEntry.Flink = pTracker->TrackerList.Flink;
|
|
ListEntry.Flink->Blink = &ListEntry;
|
|
ListEntry.Blink = pTracker->TrackerList.Blink;
|
|
ListEntry.Blink->Flink = &ListEntry;
|
|
|
|
InitializeListHead (&pTracker->TrackerList);
|
|
}
|
|
}
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
|
|
(*pClientCompletion)(pTracker,status);
|
|
|
|
while (!IsListEmpty(&ListEntry))
|
|
{
|
|
pEntry = RemoveHeadList(&ListEntry);
|
|
pTrack = CONTAINING_RECORD(pEntry,tDGRAM_SEND_TRACKING,TrackerList);
|
|
|
|
//
|
|
// if the name query failed and there is another requested queued on
|
|
// a different device context, re-attempt the name query
|
|
//
|
|
if ((pTrack->pDeviceContext != pDeviceContext) &&
|
|
(status != STATUS_SUCCESS))
|
|
{
|
|
//
|
|
// setup the correct back link since this guy is now the list
|
|
// head. The Flink is ok unless the list is empty now.
|
|
//
|
|
pTrack->TrackerList.Blink = ListEntry.Blink;
|
|
pTrack->TrackerList.Blink->Flink = &pTrack->TrackerList;
|
|
|
|
if (pTrack->TrackerList.Flink == &ListEntry)
|
|
{
|
|
pTrack->TrackerList.Flink = &pTrack->TrackerList;
|
|
}
|
|
|
|
// do a name query on the next name in the list
|
|
// and then wait for it to complete before processing any more
|
|
// names on the list.
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq);
|
|
status = QueryNameOnNet (pTrack->pDestName,
|
|
NbtConfig.pScope,
|
|
NBT_UNIQUE, //use this as the default
|
|
(PVOID)pTrack,
|
|
pTrack->CompletionRoutine,
|
|
NodeType & NODE_MASK,
|
|
NULL,
|
|
pTrack->pDeviceContext,
|
|
&OldIrq);
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// get the completion routine for this tracker since it may be
|
|
// different than the tracker tied to the timer block. i.e.
|
|
// pCompletionClient passed to this routine.
|
|
//
|
|
pClientCompletion = pTrack->CompletionRoutine;
|
|
(*pClientCompletion)(pTrack,status);
|
|
}
|
|
} // while
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
NTSTATUS
|
|
NbtRegisterName(
|
|
IN enum eNbtLocation Location,
|
|
IN ULONG IpAddress,
|
|
IN PCHAR pName,
|
|
IN tNAMEADDR *pNameAddrIn,
|
|
IN tCLIENTELE *pClientEle,
|
|
IN PVOID pClientCompletion,
|
|
IN USHORT uAddressType,
|
|
IN tDEVICECONTEXT *pDeviceContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine registers a name from local or from the network depending
|
|
on the value of Location. (i.e. local node uses this routine as well
|
|
as the proxy code.. although it has only been tested with the local
|
|
node registering names so far - and infact the remote code has been
|
|
removed... since it is not used. All that remains is to remove
|
|
the Location parameter.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - success or not
|
|
|
|
--*/
|
|
{
|
|
ULONG Timeout;
|
|
USHORT Retries;
|
|
NTSTATUS status;
|
|
tNAMEADDR *pNameAddr;
|
|
USHORT uAddrType;
|
|
tDGRAM_SEND_TRACKING *pSentList= NULL;
|
|
CTELockHandle OldIrq1;
|
|
ULONG PrevNameTypeState;
|
|
ULONG LocalNodeType;
|
|
|
|
LocalNodeType = AppropriateNodeType( pName, NodeType );
|
|
|
|
if ((uAddressType == (USHORT)NBT_UNIQUE ) ||
|
|
(uAddressType == (USHORT)NBT_QUICK_UNIQUE))
|
|
{
|
|
uAddrType = NBT_UNIQUE;
|
|
}
|
|
else
|
|
{
|
|
uAddrType = NBT_GROUP;
|
|
}
|
|
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq1);
|
|
if (IpAddress)
|
|
{
|
|
status = AddToHashTable (pNbtGlobConfig->pLocalHashTbl,
|
|
pName,
|
|
NbtConfig.pScope,
|
|
IpAddress,
|
|
uAddrType,
|
|
NULL,
|
|
&pNameAddr,
|
|
pDeviceContext,
|
|
0);
|
|
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq1);
|
|
return(STATUS_UNSUCCESSFUL);
|
|
}
|
|
|
|
pNameAddr->RefreshMask = 0;
|
|
}
|
|
else
|
|
{
|
|
// in this case the name is already in the table, we just need
|
|
// to re-register it
|
|
//
|
|
status = FindInHashTable (pNbtGlobConfig->pLocalHashTbl, pName, NbtConfig.pScope, &pNameAddr);
|
|
if (!NT_SUCCESS(status))
|
|
{
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq1);
|
|
return(status);
|
|
}
|
|
|
|
ASSERT (pNameAddr == pNameAddrIn);
|
|
}
|
|
|
|
CHECK_PTR(pNameAddr);
|
|
if ((uAddressType != (USHORT)NBT_UNIQUE ) &&
|
|
(uAddressType != (USHORT)NBT_QUICK_UNIQUE))
|
|
{
|
|
// this means group name so use Bcast Addr - UdpSendDgram changes this
|
|
// value to the Broadcast address of the particular adapter
|
|
// when is sees the 0. So when we send to a group name that is
|
|
// also registered on this node, it will go out as a broadcast
|
|
// to the subnet as well as to this node.
|
|
pNameAddr->IpAddress = 0;
|
|
}
|
|
|
|
#ifdef _NETBIOSLESS
|
|
if (IsDeviceNetbiosless(pDeviceContext)) // The Smb Device is not adapter specific
|
|
{
|
|
pNameAddr->NameFlags |= NAME_REGISTERED_ON_SMBDEV;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
//
|
|
// start with the refreshed bit not set
|
|
//
|
|
pNameAddr->RefreshMask &= ~pDeviceContext->AdapterMask;
|
|
pNameAddr->AdapterMask |= pDeviceContext->AdapterMask; // turn on the adapter bit in the Mask
|
|
}
|
|
|
|
pClientEle->pAddress->pNameAddr = pNameAddr; // save the local name ptr in the address element
|
|
pNameAddr->pAddressEle = pClientEle->pAddress; // store a back ptr to the address element
|
|
pNameAddr->Ttl = NbtConfig.MinimumTtl; // set to 2 minutes until we hear differently from the Name Server
|
|
|
|
PrevNameTypeState = pNameAddr->NameTypeState;
|
|
pNameAddr->NameTypeState &= ~(NAME_TYPE_MASK | NAME_STATE_MASK);
|
|
pNameAddr->NameTypeState |= (uAddrType == NBT_UNIQUE) ? NAMETYPE_UNIQUE : NAMETYPE_GROUP;
|
|
if ((PrevNameTypeState & NAMETYPE_QUICK) ||
|
|
(uAddressType >= (USHORT)NBT_QUICK_UNIQUE))
|
|
{
|
|
pNameAddr->NameTypeState |= NAMETYPE_QUICK;
|
|
}
|
|
|
|
//
|
|
// for "quick" adds, do not register the name on the net!
|
|
// however the name will get registered with the name server and
|
|
// refreshed later....if this is an MS or M or P node.
|
|
//
|
|
if ((pNameAddr->NameTypeState & NAMETYPE_QUICK) ||
|
|
(pName[0] == '*') || // broadcast netbios name does not get claimed on network
|
|
(IpAddress == LOOP_BACK) || // If no IP address, pretend the registration succeeded
|
|
(pDeviceContext->IpAddress == 0) || // names will be registered when we get an address
|
|
(IsDeviceNetbiosless (pDeviceContext)))
|
|
{
|
|
pNameAddr->NameTypeState |= STATE_RESOLVED;
|
|
status = STATUS_SUCCESS;
|
|
}
|
|
else if (NT_SUCCESS(status = GetTracker(&pSentList, NBT_TRACKER_REGISTER_NAME)))
|
|
{
|
|
pNameAddr->NameTypeState |= STATE_RESOLVING;
|
|
InitializeListHead(&pSentList->Linkage); // there is no list of things sent yet
|
|
|
|
// keep a ptr to the name so we can update the state of the name
|
|
// later when the registration completes
|
|
pSentList->pNameAddr = pNameAddr;
|
|
pSentList->pDeviceContext = pDeviceContext;
|
|
pSentList->RefCount = 2; // tracker can be deref'ed by a pdu from wire before UdpSendNsBcast is done
|
|
#ifdef MULTIPLE_WINS
|
|
pSentList->NSOthersIndex = 0; // Initialize for Name Server Queries
|
|
pSentList->NSOthersLeft = 0;
|
|
#endif
|
|
|
|
// the code must now register the name on the network, depending on the type of node
|
|
Retries = pNbtGlobConfig->uNumBcasts + 1;
|
|
Timeout = (ULONG)pNbtGlobConfig->uBcastTimeout;
|
|
pSentList->Flags = NBT_BROADCAST;
|
|
if (LocalNodeType & (PNODE | MSNODE))
|
|
{
|
|
// talk to the NS only to register the name
|
|
// ( the +1 does not actually result in a name reg, it
|
|
// is just compatible with the code for M node above since
|
|
// it uses the same completion routine).
|
|
//
|
|
Retries = (USHORT)pNbtGlobConfig->uNumRetries + 1;
|
|
Timeout = (ULONG)pNbtGlobConfig->uRetryTimeout;
|
|
pSentList->Flags = NBT_NAME_SERVER;
|
|
//
|
|
// if there is no Primary WINS server short out the timeout
|
|
// so it completes faster. For Hnode this means to go broadcast.
|
|
//
|
|
if ((pDeviceContext->lNameServerAddress == LOOP_BACK) ||
|
|
pDeviceContext->WinsIsDown)
|
|
{
|
|
if (LocalNodeType & MSNODE)
|
|
{
|
|
pSentList->Flags = NBT_BROADCAST;
|
|
Retries = (USHORT)pNbtGlobConfig->uNumBcasts + 1;
|
|
Timeout = (ULONG)pNbtGlobConfig->uBcastTimeout;
|
|
|
|
IncrementNameStats(NAME_REGISTRATION_SUCCESS, FALSE); // not name server register
|
|
}
|
|
else // its a Pnode
|
|
{
|
|
IF_DBG(NBT_DEBUG_NAMESRV)
|
|
KdPrint(("Nbt.NbtRegisterName: WINS DOWN - shorting out registration\n"));
|
|
|
|
Retries = 1;
|
|
Timeout = 10;
|
|
pSentList->Flags = NBT_NAME_SERVER_BACKUP;
|
|
}
|
|
}
|
|
}
|
|
|
|
// the name itself has a reference count too.
|
|
// make the count 2, so that pNameAddr won't get released until
|
|
// after NBT_DEREFERENCE_TRACKER is called below, since it writes to
|
|
// pNameAddr. Note that we must increment here rather than set = 2
|
|
// since it could be a multihomed machine doing the register at
|
|
// the same time we are sending a datagram to that name.
|
|
//
|
|
NBT_REFERENCE_NAMEADDR (pNameAddr, REF_NAME_REGISTER);
|
|
|
|
pDeviceContext->DeviceRefreshState |= NBT_D_REFRESHING_NOW;
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq1);
|
|
|
|
// start the timer in this routine.
|
|
status = UdpSendNSBcast(pNameAddr,
|
|
NbtConfig.pScope,
|
|
pSentList,
|
|
(PVOID) MSnodeRegCompletion,
|
|
pClientEle,
|
|
pClientCompletion,
|
|
Retries,
|
|
Timeout,
|
|
eNAME_REGISTRATION,
|
|
TRUE);
|
|
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq1);
|
|
|
|
CHECK_PTR(pNameAddr);
|
|
NBT_DEREFERENCE_TRACKER (pSentList, TRUE); // possibly frees the tracker
|
|
NBT_DEREFERENCE_NAMEADDR (pNameAddr, REF_NAME_REGISTER, TRUE);
|
|
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
status = STATUS_PENDING;
|
|
}
|
|
else // We failed to allocate resources, or the timer failed to start
|
|
{
|
|
IF_DBG(NBT_DEBUG_NAMESRV)
|
|
KdPrint(("Nbt.NbtRegisterName: UdpSendNsBcast returned ERROR = %x\n", status));
|
|
NbtTrace(NBT_TRACE_NAMESRV, ("UdpSendNSBcast return %!status! for %!NBTNAME!<%02x>",
|
|
status, pNameAddr->Name, (unsigned)pNameAddr->Name[15]));
|
|
|
|
NBT_DEREFERENCE_TRACKER (pSentList, TRUE);
|
|
}
|
|
}
|
|
|
|
if (!NT_SUCCESS(status))
|
|
{
|
|
if (!IsDeviceNetbiosless(pDeviceContext)) // The Smb Device is not adapter specific
|
|
{
|
|
pNameAddr->AdapterMask &= (~pDeviceContext->AdapterMask); // turn off the adapter bit in the Mask
|
|
}
|
|
pNameAddr->NameTypeState = PrevNameTypeState;
|
|
}
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq1);
|
|
|
|
return(status);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
MSnodeRegCompletion(
|
|
PVOID pContext,
|
|
PVOID pContext2,
|
|
tTIMERQENTRY *pTimerQEntry
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called by the timer code when the timer expires. It must
|
|
decide if another name registration should be done, and if not, then it calls the
|
|
client's completion routine (in completion2).
|
|
It first attempts to register a name via Broadcast, then it attempts
|
|
NameServer name registration.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
The function value is the status of the operation.
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
tDGRAM_SEND_TRACKING *pTracker;
|
|
ULONG Flags;
|
|
CTELockHandle OldIrq;
|
|
enum eNSTYPE PduType;
|
|
ULONG LocalNodeType;
|
|
|
|
pTracker = (tDGRAM_SEND_TRACKING *)pContext;
|
|
PduType = eNAME_REGISTRATION;
|
|
|
|
LocalNodeType = AppropriateNodeType( pTracker->pNameAddr->Name, NodeType );
|
|
|
|
//
|
|
// check if the client completion routine is still set. If not then the
|
|
// timer has been cancelled and this routine should just clean up its
|
|
// buffers associated with the tracker.
|
|
//
|
|
if (!pTimerQEntry)
|
|
{
|
|
// return the tracker block to its queue
|
|
LOCATION(0x55);
|
|
pTracker->pNameAddr->pTimer = NULL;
|
|
NBT_DEREFERENCE_TRACKER(pTracker, TRUE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// to prevent a client from stopping the timer and deleting the
|
|
// pNameAddr, grab the lock and check if the timer has been stopped
|
|
//
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq);
|
|
if (pTimerQEntry->Flags & TIMER_RETIMED)
|
|
{
|
|
pTimerQEntry->Flags &= ~TIMER_RETIMED;
|
|
pTimerQEntry->Flags |= TIMER_RESTART;
|
|
|
|
if ((!pTracker->pDeviceContext->IpAddress) ||
|
|
(pTracker->Flags & NBT_NAME_SERVER) &&
|
|
(pTracker->pDeviceContext->lNameServerAddress == LOOP_BACK))
|
|
{
|
|
// when the address is loop back there is no wins server
|
|
// so shorten the timeout.
|
|
//
|
|
pTimerQEntry->DeltaTime = 10;
|
|
}
|
|
else if ((pTracker->Flags & NBT_NAME_SERVER_BACKUP) &&
|
|
(pTracker->pDeviceContext->lBackupServer == LOOP_BACK))
|
|
{
|
|
// when the address is loop back there is no wins server
|
|
// so shorten the timeout.
|
|
//
|
|
pTimerQEntry->DeltaTime = 10;
|
|
}
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
return;
|
|
}
|
|
|
|
if (!pTimerQEntry->ClientCompletion)
|
|
{
|
|
NBT_DEREFERENCE_TRACKER(pTracker, TRUE); // Bug #: 230925
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
return;
|
|
}
|
|
|
|
// if number of retries is not zero then continue trying to contact the Name Server
|
|
//
|
|
if (--pTimerQEntry->Retries)
|
|
{
|
|
// change the name reg pdu to a name overwrite request for the
|
|
// final broadcast ( turn off Recursion Desired bit)
|
|
//
|
|
if (pTimerQEntry->Retries == 1)
|
|
{
|
|
if (pTracker->Flags & NBT_BROADCAST)
|
|
{
|
|
// do a broadcast name registration... on the last broadcast convert it to
|
|
// a Name OverWrite Request by clearing the "Recursion Desired" bit
|
|
// in the header
|
|
//
|
|
PduType = eNAME_REGISTRATION_OVERWRITE;
|
|
}
|
|
else if (LocalNodeType & (PNODE | MSNODE))
|
|
{
|
|
// we want the Pnode to timeout again, right away and fall
|
|
// through to handle Timed out name registration - i.e. it
|
|
// does not do the name overwrite demand like the B,M,&MS nodes
|
|
//
|
|
pTimerQEntry->Flags |= TIMER_RESTART;
|
|
pTimerQEntry->DeltaTime = 5;
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Flags = pTracker->Flags;
|
|
pTracker->Flags &= ~(NBT_BROADCAST | NBT_NAME_SERVER);
|
|
// set a different timeout for nameserver name registration
|
|
//
|
|
pTimerQEntry->DeltaTime = NbtConfig.uRetryTimeout;
|
|
pTimerQEntry->Retries = NbtConfig.uNumRetries + 1;
|
|
|
|
if ((Flags & NBT_BROADCAST) && (LocalNodeType & MNODE))
|
|
{
|
|
//
|
|
// Registered through broadcast, so try the name server now.
|
|
IncrementNameStats(NAME_REGISTRATION_SUCCESS, FALSE); // not name server register
|
|
pTracker->Flags |= NBT_NAME_SERVER;
|
|
if ((pTracker->pDeviceContext->lNameServerAddress == LOOP_BACK) ||
|
|
pTracker->pDeviceContext->WinsIsDown)
|
|
{
|
|
pTimerQEntry->DeltaTime = 10;
|
|
pTimerQEntry->Retries = 1;
|
|
}
|
|
}
|
|
else if ((Flags & NBT_NAME_SERVER) && !(LocalNodeType & BNODE))
|
|
{
|
|
//
|
|
// Can't reach the name server, so try the backup
|
|
pTracker->Flags |= NBT_NAME_SERVER_BACKUP;
|
|
//
|
|
// short out the timer if no backup server
|
|
//
|
|
if ((pTracker->pDeviceContext->lBackupServer == LOOP_BACK) ||
|
|
pTracker->pDeviceContext->WinsIsDown)
|
|
{
|
|
pTimerQEntry->DeltaTime = 10;
|
|
pTimerQEntry->Retries = 1;
|
|
}
|
|
}
|
|
else if ((LocalNodeType & MSNODE) && !(Flags & NBT_BROADCAST))
|
|
{
|
|
if (Flags & NBT_NAME_SERVER_BACKUP)
|
|
{
|
|
// the msnode switches to broadcast if all else fails
|
|
//
|
|
pTracker->Flags |= NBT_BROADCAST;
|
|
IncrementNameStats(NAME_REGISTRATION_SUCCESS, FALSE); // not name server register
|
|
|
|
//
|
|
// change the timeout and retries since broadcast uses a shorter timeout
|
|
//
|
|
pTimerQEntry->DeltaTime = NbtConfig.uBcastTimeout;
|
|
pTimerQEntry->Retries = (USHORT)pNbtGlobConfig->uNumBcasts + 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (LocalNodeType & BNODE)
|
|
{
|
|
IncrementNameStats(NAME_REGISTRATION_SUCCESS, FALSE); // not name server register
|
|
}
|
|
//
|
|
// the timeout has expired on the name registration
|
|
// so call the client
|
|
//
|
|
|
|
// return the tracker block to its queue
|
|
LOCATION(0x54);
|
|
|
|
//
|
|
// start a timer to stop using WINS for a short period of
|
|
// time. Do this only if we had sent the last registration
|
|
// to a Wins server
|
|
//
|
|
if (!(Flags & NBT_BROADCAST) && pTracker->pDeviceContext->lNameServerAddress != LOOP_BACK)
|
|
{
|
|
SetWinsDownFlag(pTracker->pDeviceContext);
|
|
}
|
|
|
|
NBT_DEREFERENCE_TRACKER(pTracker, TRUE);
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
status = STATUS_SUCCESS;
|
|
InterlockedCallCompletion(pTimerQEntry,status);
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
NBT_REFERENCE_TRACKER (pTracker);
|
|
pTimerQEntry->Flags |= TIMER_RESTART;
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
status = UdpSendNSBcast(pTracker->pNameAddr,
|
|
NbtConfig.pScope,
|
|
pTracker,
|
|
NULL,NULL,NULL,
|
|
0,0,
|
|
PduType,
|
|
TRUE);
|
|
|
|
NBT_DEREFERENCE_TRACKER(pTracker, FALSE);
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
RefreshRegCompletion(
|
|
PVOID pContext,
|
|
PVOID pContext2,
|
|
tTIMERQENTRY *pTimerQEntry
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles the name Refresh timeouts on packets sent to the Name
|
|
Service. I.e it sends refreshes to the nameserver until a response is
|
|
heard or the number of retries is exceeded.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
The function value is the status of the operation.
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
tDGRAM_SEND_TRACKING *pTracker;
|
|
tNAMEADDR *pNameAddr;
|
|
CTELockHandle OldIrq;
|
|
COMPLETIONCLIENT pCompletionClient;
|
|
|
|
|
|
pTracker = (tDGRAM_SEND_TRACKING *)pContext;
|
|
|
|
if (!pTimerQEntry)
|
|
{
|
|
pTracker->pNameAddr->pTimer = NULL;
|
|
NbtConfig.GlobalRefreshState &= ~NBT_G_REFRESHING_NOW;
|
|
return;
|
|
}
|
|
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq);
|
|
|
|
//
|
|
// check if the timer has been stopped yet, since stopping the timer
|
|
// nulls the client completion routine. If not null, increment the
|
|
// tracker refcount, so that the last refresh completing cannot
|
|
// free the tracker out from under us.
|
|
//
|
|
if (!(pCompletionClient = pTimerQEntry->ClientCompletion))
|
|
{
|
|
NbtConfig.GlobalRefreshState &= ~NBT_G_REFRESHING_NOW;
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
return;
|
|
}
|
|
|
|
// if still some count left and not refreshed yet
|
|
// then do another refresh request
|
|
//
|
|
pNameAddr = pTracker->pNameAddr;
|
|
|
|
if (--pTimerQEntry->Retries)
|
|
{
|
|
NBT_REFERENCE_TRACKER (pTracker);
|
|
pTimerQEntry->Flags |= TIMER_RESTART;
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
status = UdpSendNSBcast(pTracker->pNameAddr,
|
|
NbtConfig.pScope,
|
|
pTracker,
|
|
NULL,NULL,NULL,
|
|
0,0,
|
|
pTracker->AddressType,
|
|
TRUE);
|
|
|
|
// always restart even if the above send fails, since it might succeed
|
|
// later.
|
|
NBT_DEREFERENCE_TRACKER(pTracker, FALSE);
|
|
}
|
|
else
|
|
{
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
// this calls the completion routine synchronizing with the
|
|
// timer expiry code.
|
|
InterlockedCallCompletion(pTimerQEntry,STATUS_TIMEOUT);
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
NTSTATUS
|
|
ReleaseNameOnNet(
|
|
tNAMEADDR *pNameAddr,
|
|
PCHAR pScope,
|
|
PVOID pClientCompletion,
|
|
ULONG LocalNodeType,
|
|
tDEVICECONTEXT *pDeviceContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine deletes a name on the network either by a
|
|
broadcast or by talking to the NS depending on the type of node. (M,P or B)
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
The function value is the status of the operation.
|
|
|
|
Called By: ProxyQueryFromNet() in proxy.c, NbtConnect() in name.c
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG Timeout;
|
|
USHORT Retries;
|
|
NTSTATUS status=STATUS_UNSUCCESSFUL;
|
|
tDGRAM_SEND_TRACKING *pTracker;
|
|
CTELockHandle OldIrq;
|
|
tTIMERQENTRY *pTimer;
|
|
|
|
status = GetTracker(&pTracker, NBT_TRACKER_RELEASE_NAME);
|
|
if (!NT_SUCCESS(status))
|
|
{
|
|
return(status);
|
|
}
|
|
pTracker->pDeviceContext = pDeviceContext;
|
|
pTracker->pNameAddr = pNameAddr;
|
|
pTracker->SendBuffer.pDgramHdr = NULL; // set to NULL to catch any erroneous frees.
|
|
pTracker->RefCount = 3; // We use the same tracker for the CompletionContext + Request
|
|
|
|
// Set a few values as a precursor to releasing the name either by
|
|
// broadcast or with the name server
|
|
//
|
|
LocalNodeType = AppropriateNodeType( pNameAddr->Name, LocalNodeType );
|
|
switch (LocalNodeType & NODE_MASK)
|
|
{
|
|
case MSNODE:
|
|
case MNODE:
|
|
case PNODE:
|
|
|
|
pTracker->Flags = NBT_NAME_SERVER;
|
|
Timeout = (ULONG)pNbtGlobConfig->uRetryTimeout;
|
|
Retries = (USHORT)pNbtGlobConfig->uNumRetries;
|
|
|
|
break;
|
|
|
|
case BNODE:
|
|
default:
|
|
|
|
pTracker->Flags = NBT_BROADCAST;
|
|
Timeout = (ULONG)pNbtGlobConfig->uBcastTimeout;
|
|
#ifndef VXD
|
|
Retries = (USHORT)pNbtGlobConfig->uNumBcasts;
|
|
#else
|
|
Retries = (USHORT)1;
|
|
#endif
|
|
}
|
|
|
|
//
|
|
// Release name on the network
|
|
//
|
|
IF_DBG(NBT_DEBUG_NAMESRV)
|
|
KdPrint(("Nbt.ReleaseNameOnNet: Doing Name Release on name %16.16s<%X>\n",
|
|
pNameAddr->Name,pNameAddr->Name[15]));
|
|
|
|
status = UdpSendNSBcast(pNameAddr,
|
|
pScope,
|
|
pTracker,
|
|
ReleaseCompletion,
|
|
pTracker,
|
|
pClientCompletion,
|
|
Retries,
|
|
Timeout,
|
|
eNAME_RELEASE,
|
|
TRUE);
|
|
|
|
NBT_DEREFERENCE_TRACKER(pTracker, FALSE);
|
|
|
|
if (!NT_SUCCESS(status))
|
|
{
|
|
NTSTATUS Locstatus;
|
|
COMPLETIONCLIENT pCompletion;
|
|
PVOID pContext;
|
|
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq);
|
|
|
|
IF_DBG(NBT_DEBUG_NAMESRV)
|
|
KdPrint(("Nbt.ReleaseNameOnNet: UdpSendNSBcast failed - retcode = %X\n", status));
|
|
|
|
// Stopping the timer will call ReleaseCompletion which will
|
|
// free the tracker
|
|
//
|
|
pCompletion = NULL;
|
|
CHECK_PTR(pNameAddr);
|
|
if (pTimer = pNameAddr->pTimer)
|
|
{
|
|
pNameAddr->pTimer = NULL;
|
|
Locstatus = StopTimer(pTimer,&pCompletion,&pContext);
|
|
}
|
|
else
|
|
{
|
|
// no timer setup, so just free the tracker
|
|
//
|
|
FreeTracker(pTracker, RELINK_TRACKER);
|
|
}
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
ReleaseCompletion(
|
|
PVOID pContext,
|
|
PVOID pContext2,
|
|
tTIMERQENTRY *pTimerQEntry
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called by the timer code when the timer expires. It must
|
|
decide if another name query should be done, and if not, then it calls the
|
|
client's completion routine (in completion2).
|
|
This routine handles both the broadcast portion of the name queries and
|
|
the WINS server directed sends.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
The function value is the status of the operation.
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
tDGRAM_SEND_TRACKING *pTracker;
|
|
ULONG LocalNodeType;
|
|
BOOLEAN fRetry;
|
|
CTELockHandle OldIrq;
|
|
|
|
pTracker = (tDGRAM_SEND_TRACKING *)pContext;
|
|
|
|
if (!pTimerQEntry)
|
|
{
|
|
pTracker->pNameAddr->pTimer = NULL;
|
|
NBT_DEREFERENCE_TRACKER (pTracker, TRUE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// There could be a scenario here where this name is currently being
|
|
// released, but we just got a new client with the same name -- in that
|
|
// case NbtOpenAddress will set the ReleaseMask to 0, so we stop
|
|
// releasing the name on that device if that happens!
|
|
//
|
|
if (!(pTracker->pNameAddr->ReleaseMask))
|
|
{
|
|
LocalNodeType = BNODE;
|
|
pTimerQEntry->Retries = 1;
|
|
}
|
|
else if (IsBrowserName(pTracker->pNameAddr->Name))
|
|
{
|
|
LocalNodeType = BNODE;
|
|
}
|
|
else
|
|
{
|
|
LocalNodeType = NodeType;
|
|
}
|
|
|
|
fRetry = TRUE;
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq);
|
|
if (IsEntryInList (&pTracker->pDeviceContext->Linkage, &NbtConfig.DeviceContexts))
|
|
{
|
|
// if number of retries is not zero then continue trying
|
|
// to contact the Name Server.
|
|
//
|
|
if (!(--pTimerQEntry->Retries))
|
|
{
|
|
if ((LocalNodeType & MNODE) &&
|
|
(pTracker->Flags & NBT_NAME_SERVER))
|
|
{
|
|
//
|
|
// try broadcast
|
|
//
|
|
pTracker->Flags &= ~NBT_NAME_SERVER;
|
|
pTracker->Flags |= NBT_BROADCAST;
|
|
|
|
// set a different timeout for broadcast name resolution
|
|
//
|
|
pTimerQEntry->DeltaTime = NbtConfig.uBcastTimeout;
|
|
pTimerQEntry->Retries = NbtConfig.uNumBcasts;
|
|
}
|
|
else
|
|
{
|
|
fRetry = FALSE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fRetry = FALSE;
|
|
}
|
|
|
|
#ifdef VXD
|
|
if (fRetry)
|
|
#else
|
|
if ((fRetry) &&
|
|
(NBT_REFERENCE_DEVICE (pTracker->pDeviceContext, REF_DEV_NAME_REL, TRUE)))
|
|
#endif // VXD
|
|
{
|
|
NBT_REFERENCE_TRACKER (pTracker);
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
|
|
status = UdpSendNSBcast(pTracker->pNameAddr,
|
|
NbtConfig.pScope,
|
|
pTracker,
|
|
NULL,NULL,NULL,
|
|
0,0,
|
|
eNAME_RELEASE,
|
|
TRUE);
|
|
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq);
|
|
#ifndef VXD
|
|
NBT_DEREFERENCE_DEVICE (pTracker->pDeviceContext, REF_DEV_NAME_REL, TRUE);
|
|
#endif !VXD
|
|
NBT_DEREFERENCE_TRACKER (pTracker, TRUE);
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
|
|
pTimerQEntry->Flags |= TIMER_RESTART;
|
|
return;
|
|
}
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
|
|
//
|
|
// the timeout has expired on the name release
|
|
// or the Device on which we were releasing the name
|
|
// could have gone away, so call the client
|
|
//
|
|
status = InterlockedCallCompletion(pTimerQEntry,STATUS_TIMEOUT);
|
|
|
|
// return the tracker block to its queue if we successfully
|
|
// called the completion routine since someone else might
|
|
// have done a Stop timer at this very moment and freed the
|
|
// tracker already (i.e. the last else clause in this routine).
|
|
//
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
NBT_DEREFERENCE_TRACKER(pTracker, FALSE);
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
NameReleaseDone(
|
|
PVOID pContext,
|
|
NTSTATUS Status
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called when a name is released on the network. Its
|
|
main, role in life is to free the memory in Context, which is the pAddressEle
|
|
structure.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
The function value is the status of the operation.
|
|
|
|
Called By Release Completion (above)
|
|
--*/
|
|
|
|
{
|
|
CTELockHandle OldIrq1;
|
|
tDEVICECONTEXT *pDeviceContext;
|
|
tDGRAM_SEND_TRACKING *pTracker = (tDGRAM_SEND_TRACKING *) pContext;
|
|
tNAMEADDR *pNameAddr = pTracker->pNameAddr;
|
|
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq1);
|
|
NBT_DEREFERENCE_TRACKER(pTracker, TRUE);
|
|
|
|
pNameAddr->pTimer = NULL; // Since we could be starting a new Timer below
|
|
//
|
|
// Before releasing this name, see if this name is registered on
|
|
// any more devices
|
|
// WARNING -- Do not touch the current pTracker->DeviceContext since the
|
|
// the device may have gone away
|
|
//
|
|
while (pDeviceContext = GetAndRefNextDeviceFromNameAddr (pNameAddr))
|
|
{
|
|
//
|
|
// Increment the RefCounts for the structures we need to keep around
|
|
// They will be Dereferenced when the Name Release has completed
|
|
//
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq1);
|
|
|
|
Status = ReleaseNameOnNet(pNameAddr,
|
|
NbtConfig.pScope,
|
|
NameReleaseDone,
|
|
NodeType,
|
|
pDeviceContext);
|
|
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq1);
|
|
#ifndef VXD
|
|
NBT_DEREFERENCE_DEVICE (pDeviceContext, REF_DEV_GET_REF, TRUE);
|
|
#endif // !VXD
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq1);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// We failed to release the name on this Device, so try the
|
|
// next Device!
|
|
//
|
|
}
|
|
|
|
NBT_DEREFERENCE_NAMEADDR (pNameAddr, REF_NAME_RELEASE, TRUE);
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq1);
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
NTSTATUS
|
|
StartRefresh(
|
|
IN tNAMEADDR *pNameAddr,
|
|
IN tDGRAM_SEND_TRACKING *pTracker,
|
|
IN CTELockHandle *pJointLockOldIrq,
|
|
IN BOOLEAN ResetDevice
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles refreshing a name with the Name server.
|
|
|
|
The idea is to set the timeout to T/8 and check for names with the Refresh
|
|
bit cleared - re-registering those names. At T=4 and T=0, clear all bits
|
|
and refresh all names. The Inbound code sets the refresh bit when it gets a
|
|
refresh response from the NS.
|
|
The JointLock is held while this routine is called, and the last Irql is
|
|
passed in pJointLockOldIrq
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
tDEVICECONTEXT *pDeviceContext = NULL;
|
|
BOOLEAN NewTracker = FALSE;
|
|
|
|
if (!pTracker)
|
|
{
|
|
LOCATION(0x9);
|
|
|
|
status = GetTracker(&pTracker, NBT_TRACKER_REFRESH_NAME);
|
|
if (!NT_SUCCESS(status))
|
|
{
|
|
return(STATUS_INSUFFICIENT_RESOURCES);
|
|
}
|
|
|
|
// need to prevent the tracker from being freed by a pdu from
|
|
// the wire before the UdpSendNsBcast is done
|
|
//
|
|
pTracker->RefCount = 1;
|
|
|
|
NewTracker = TRUE;
|
|
}
|
|
|
|
// set the name to be refreshed in the tracker block
|
|
pTracker->pNameAddr = pNameAddr;
|
|
|
|
// this is set true when a new name gets refreshed
|
|
//
|
|
if ((ResetDevice) || (NewTracker))
|
|
{
|
|
PLIST_ENTRY pEntry, pHead;
|
|
CTEULONGLONG AdapterMask;
|
|
|
|
LOCATION(0xb);
|
|
|
|
//
|
|
// Identify the Adapters which have not been refreshed
|
|
// Then, get the lowest Adapter number and Refresh on it
|
|
//
|
|
pHead = &NbtConfig.DeviceContexts;
|
|
AdapterMask = pNameAddr->AdapterMask & ~(pNameAddr->RefreshMask);
|
|
AdapterMask = ~(AdapterMask - 1) & AdapterMask;
|
|
|
|
ASSERT (AdapterMask);
|
|
while (AdapterMask)
|
|
{
|
|
//
|
|
// Travel to the actual device for this Adapter number
|
|
//
|
|
pEntry = pHead->Flink;
|
|
while (pEntry != pHead)
|
|
{
|
|
pDeviceContext = CONTAINING_RECORD(pEntry,tDEVICECONTEXT,Linkage);
|
|
if (pDeviceContext->AdapterMask == AdapterMask)
|
|
{
|
|
//
|
|
// Found a valid device on which this name is registered
|
|
//
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
pDeviceContext = NULL;
|
|
}
|
|
|
|
//
|
|
// Go to next device
|
|
//
|
|
pEntry = pEntry->Flink;
|
|
}
|
|
|
|
if (pDeviceContext)
|
|
{
|
|
//
|
|
// Found a Device to do a NameRefresh on
|
|
//
|
|
break;
|
|
}
|
|
|
|
//
|
|
// This is an error case -- the device for this adapter number
|
|
// does not exist. Remove it from the Adapter and Refresh masks
|
|
//
|
|
pNameAddr->AdapterMask &= ~AdapterMask;
|
|
pNameAddr->RefreshMask &= ~AdapterMask;
|
|
|
|
AdapterMask = pNameAddr->AdapterMask & ~(pNameAddr->RefreshMask);
|
|
AdapterMask = ~(AdapterMask - 1) & AdapterMask;
|
|
}
|
|
|
|
if (!pDeviceContext)
|
|
{
|
|
IF_DBG(NBT_DEBUG_REFRESH)
|
|
KdPrint(("Nbt.StartRefresh: Failed to Refresh <%16.16s:%x>!! no valid adapter ****\n",
|
|
pNameAddr->Name, pNameAddr->Name[15]));
|
|
NBT_DEREFERENCE_TRACKER(pTracker, TRUE);
|
|
return(STATUS_UNSUCCESSFUL);
|
|
}
|
|
|
|
#ifndef VXD
|
|
IF_DBG(NBT_DEBUG_REFRESH)
|
|
KdPrint(("Nbt.StartRefresh: Refresh adapter: %lx:%lx, dev.nm: %lx for name: %lx\n",
|
|
AdapterMask, pDeviceContext->BindName.Buffer, pNameAddr));
|
|
#endif // !VXD
|
|
|
|
pTracker->pDeviceContext = pDeviceContext;
|
|
//
|
|
// Clear the transaction Id so that CreatePdu will increment
|
|
// it for this new name
|
|
//
|
|
CHECK_PTR(pTracker);
|
|
pTracker->TransactionId = 0;
|
|
}
|
|
|
|
pTracker->pDeviceContext->DeviceRefreshState |= NBT_D_REFRESHING_NOW;
|
|
pDeviceContext = pTracker->pDeviceContext;
|
|
pTracker->AddressType = eNAME_REFRESH;
|
|
// Check if we need to refresh to the primary or backup
|
|
|
|
if ((pDeviceContext->IpAddress) &&
|
|
(pTracker->pDeviceContext->lNameServerAddress == LOOP_BACK) &&
|
|
(pNameAddr->NameTypeState & STATE_CONFLICT) &&
|
|
(!pNameAddr->ConflictMask))
|
|
{
|
|
//
|
|
// Broadcast the Refresh to ensure no conflict
|
|
//
|
|
pTracker->Flags = NBT_BROADCAST;
|
|
pTracker->AddressType = eNAME_REGISTRATION;
|
|
}
|
|
else if (pTracker->pDeviceContext->RefreshToBackup)
|
|
{
|
|
pTracker->Flags = NBT_NAME_SERVER_BACKUP;
|
|
}
|
|
else
|
|
{
|
|
pTracker->Flags = NBT_NAME_SERVER;
|
|
}
|
|
|
|
// this accounts for the dereference done after the call to
|
|
// send the datagram below.
|
|
NBT_REFERENCE_TRACKER (pTracker);
|
|
CTESpinFree(&NbtConfig.JointLock,*pJointLockOldIrq);
|
|
|
|
status = UdpSendNSBcast(pNameAddr,
|
|
NbtConfig.pScope,
|
|
pTracker,
|
|
RefreshRegCompletion,
|
|
pTracker,
|
|
NextRefresh,
|
|
NbtConfig.uNumRetries,
|
|
NbtConfig.uRetryTimeout,
|
|
pTracker->AddressType,
|
|
TRUE);
|
|
|
|
CTESpinLock(&NbtConfig.JointLock,*pJointLockOldIrq);
|
|
NBT_DEREFERENCE_TRACKER(pTracker, TRUE);
|
|
|
|
LOCATION(0x57);
|
|
|
|
if (!NT_SUCCESS(status))
|
|
{
|
|
LOCATION(0xe);
|
|
IF_DBG(NBT_DEBUG_REFRESH)
|
|
KdPrint(("Nbt.StartRefresh: Failed to send Refresh!! status = %X****\n",status));
|
|
//
|
|
// This will free the tracker. Name refresh will stop until
|
|
// the next refresh timeout and at that point it will attempt
|
|
// to refresh the names again.
|
|
//
|
|
NBT_DEREFERENCE_TRACKER(pTracker, TRUE);
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
GetNextName(
|
|
IN tNAMEADDR *pNameAddrIn,
|
|
OUT tNAMEADDR **ppNameAddr
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine finds the next name to refresh, including incrementing the
|
|
reference count so that the name cannot be deleted during the refresh.
|
|
The JointLock spin lock is held before calling this routine.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
PLIST_ENTRY pHead;
|
|
PLIST_ENTRY pEntry;
|
|
LONG i, iIndex;
|
|
tNAMEADDR *pNameAddr;
|
|
tHASHTABLE *pHashTable;
|
|
|
|
|
|
pHashTable = NbtConfig.pLocalHashTbl;
|
|
|
|
for (i= NbtConfig.CurrentHashBucket;i < pHashTable->lNumBuckets ;i++ )
|
|
{
|
|
//
|
|
// use the last name as the current position in the linked list
|
|
// only if that name is still resolved, otherwise start at the
|
|
// begining of the hash list, incase the name got deleted in the
|
|
// mean time.
|
|
//
|
|
if (pNameAddrIn)
|
|
{
|
|
//
|
|
// The Address for this name is Referenced, so it has to be a valid name!
|
|
//
|
|
ASSERT (NBT_VERIFY_HANDLE (pNameAddrIn, LOCAL_NAME));
|
|
|
|
if ((pNameAddrIn->NameTypeState & STATE_CONFLICT) &&
|
|
(!pNameAddrIn->ConflictMask) &&
|
|
(!(pNameAddrIn->NameTypeState & REFRESH_FAILED)))
|
|
{
|
|
//
|
|
// If we succeeded in Refreshing on all adapters,
|
|
// remove the name from the Conflict state
|
|
//
|
|
pNameAddrIn->NameTypeState &= (~NAME_STATE_MASK);
|
|
pNameAddrIn->NameTypeState |= STATE_RESOLVED;
|
|
}
|
|
|
|
// first hash the name to an index
|
|
// take the lower nibble of the first 2 characters.. mod table size
|
|
iIndex = ((pNameAddrIn->Name[0] & 0x0F) << 4) + (pNameAddrIn->Name[1] & 0x0F);
|
|
iIndex = iIndex % pHashTable->lNumBuckets;
|
|
|
|
if (iIndex != NbtConfig.CurrentHashBucket)
|
|
{
|
|
//
|
|
// Someone else is refreshing right now!
|
|
//
|
|
*ppNameAddr = NULL;
|
|
return;
|
|
}
|
|
|
|
pHead = &NbtConfig.pLocalHashTbl->Bucket[NbtConfig.CurrentHashBucket];
|
|
pEntry = pNameAddrIn->Linkage.Flink;
|
|
|
|
pNameAddrIn = NULL;
|
|
}
|
|
else
|
|
{
|
|
pHead = &pHashTable->Bucket[i];
|
|
pEntry = pHead->Flink;
|
|
}
|
|
|
|
while (pEntry != pHead)
|
|
{
|
|
pNameAddr = CONTAINING_RECORD(pEntry,tNAMEADDR,Linkage);
|
|
pEntry = pEntry->Flink;
|
|
|
|
// don't refresh scope names or names in conflict or that are the
|
|
// broadcast name "* " or quick unique names - i.e. the permanent
|
|
// name is nametype quick
|
|
//
|
|
if ((pNameAddr->Name[0] != '*') &&
|
|
(!(pNameAddr->NameTypeState & NAMETYPE_QUICK)) &&
|
|
(pNameAddr->pAddressEle) && // Not currently being closed down!
|
|
((pNameAddr->NameTypeState & STATE_RESOLVED) ||
|
|
((pNameAddr->NameTypeState & STATE_CONFLICT) && (!pNameAddr->ConflictMask))))
|
|
{
|
|
// check if the name has been refreshed yet
|
|
//
|
|
// Refresh this name only if any of the non-refreshed bits in
|
|
// the RefreshMask match any of the bits for the adapters this
|
|
// device is registered on!
|
|
pNameAddr->NameTypeState &= (~REFRESH_FAILED); // Will be set on Failure
|
|
if (pNameAddr->AdapterMask & ~pNameAddr->RefreshMask)
|
|
{
|
|
// increment the reference count so that this name cannot
|
|
// disappear while it is being refreshed and mess up the linked list
|
|
NBT_REFERENCE_ADDRESS (pNameAddr->pAddressEle, REF_ADDR_REFRESH);
|
|
|
|
NbtConfig.CurrentHashBucket = (USHORT)i;
|
|
|
|
*ppNameAddr = pNameAddr;
|
|
return;
|
|
}
|
|
else if (pNameAddr->NameTypeState & STATE_CONFLICT)
|
|
{
|
|
pNameAddr->NameTypeState &= (~NAME_STATE_MASK);
|
|
pNameAddr->NameTypeState |= STATE_RESOLVED;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
*ppNameAddr = NULL;
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
NextRefresh(
|
|
IN PVOID pContext,
|
|
IN NTSTATUS CompletionStatus
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine queues the work to an Executive worker thread to handle
|
|
refreshing the next name.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
tDGRAM_SEND_TRACKING *pTracker;
|
|
CTELockHandle OldIrq;
|
|
|
|
pTracker = (tDGRAM_SEND_TRACKING *) pContext;
|
|
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq);
|
|
pTracker->pNameAddr->pTimer = NULL; // Set the timer to NULL!
|
|
|
|
if (!(NBT_VERIFY_HANDLE (pTracker->pDeviceContext, NBT_VERIFY_DEVCONTEXT)))
|
|
{
|
|
//
|
|
// Since the Device is going away, let's assume we succeeded
|
|
//
|
|
CompletionStatus = STATUS_SUCCESS;
|
|
pTracker->pDeviceContext = NULL;
|
|
}
|
|
|
|
if (!NT_SUCCESS(CTEQueueForNonDispProcessing (DelayedNextRefresh,
|
|
pTracker,
|
|
ULongToPtr(CompletionStatus), // Sundown: zero-extended.
|
|
NULL,
|
|
pTracker->pDeviceContext,
|
|
TRUE)))
|
|
{
|
|
IF_DBG(NBT_DEBUG_REFRESH)
|
|
KdPrint (("Nbt.NextRefresh: Failed to Enqueu DelayedNextRefresh!!!\n"));
|
|
|
|
NBT_DEREFERENCE_TRACKER (pTracker, TRUE);
|
|
NbtConfig.GlobalRefreshState &= ~NBT_G_REFRESHING_NOW;
|
|
}
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
DelayedNextRefresh(
|
|
IN tDGRAM_SEND_TRACKING *pTracker,
|
|
IN PVOID pClientContext,
|
|
IN PVOID pUnused1,
|
|
IN tDEVICECONTEXT *pDeviceContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles sending subsequent refreshes to the name server.
|
|
This is the "Client Completion" routine of the Timer started above.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
CTELockHandle OldIrq;
|
|
tNAMEADDR *pNameAddr;
|
|
tNAMEADDR *pNameAddrNext;
|
|
NTSTATUS status;
|
|
PLIST_ENTRY pEntry, pHead;
|
|
CTEULONGLONG AdapterMask;
|
|
BOOLEAN fAbleToReachWins = FALSE;
|
|
BOOLEAN fResetDevice = FALSE;
|
|
NTSTATUS CompletionStatus;
|
|
|
|
CompletionStatus = (NTSTATUS) (ULONG_PTR) pClientContext;
|
|
pNameAddr = pTracker->pNameAddr;
|
|
ASSERT(pNameAddr);
|
|
|
|
//
|
|
// grab the resource so that a name refresh response cannot start running this
|
|
// code in a different thread before this thread has exited this routine,
|
|
// otherwise the tracker can get dereferenced twice and blown away.
|
|
//
|
|
CTEExAcquireResourceExclusive(&NbtConfig.Resource,TRUE);
|
|
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq);
|
|
LOCATION(0x1);
|
|
// turn on the bit corresponding to this adapter, since the name refresh
|
|
// completed ok
|
|
//
|
|
if (CompletionStatus == STATUS_SUCCESS)
|
|
{
|
|
if (pDeviceContext)
|
|
{
|
|
//
|
|
// turn on the bit corresponding to this adapter, since the name refresh
|
|
// completed ok
|
|
//
|
|
pNameAddr->RefreshMask |= pDeviceContext->AdapterMask;
|
|
}
|
|
fAbleToReachWins = TRUE;
|
|
}
|
|
else if (CompletionStatus == STATUS_TIMEOUT)
|
|
{
|
|
if (pNameAddr->NameTypeState & STATE_CONFLICT)
|
|
{
|
|
if ((!pDeviceContext->IpAddress) ||
|
|
(pDeviceContext->lNameServerAddress == LOOP_BACK))
|
|
{
|
|
//
|
|
// Let us assume we succeeded
|
|
fAbleToReachWins = TRUE;
|
|
}
|
|
else
|
|
{
|
|
pNameAddr->NameTypeState |= REFRESH_FAILED;
|
|
}
|
|
}
|
|
}
|
|
else // CompletionStatus != STATUS_TIMEOUT
|
|
{
|
|
LOCATION(0x3);
|
|
// if the timer times out and we did not get to the name server, then
|
|
// that is not an error. However, any other bad status
|
|
// must be a negative response to a name refresh so mark the name
|
|
// in conflict
|
|
//
|
|
pNameAddr->NameTypeState &= ~NAME_STATE_MASK;
|
|
pNameAddr->NameTypeState |= STATE_CONFLICT;
|
|
pNameAddr->ConflictMask |= pDeviceContext->AdapterMask;
|
|
fAbleToReachWins = TRUE;
|
|
}
|
|
|
|
// for the multihomed case a failure to reach wins out one of the adapters
|
|
// is not necessarily a failure to reach any WINS. Since this flag
|
|
// is just an optimization to prevent clients from continually trying to
|
|
// register all of their names if WINS is unreachable, we can ignore the
|
|
// optimization for the multihomed case. The few nodes that are
|
|
// multihomed will not create that much traffic compared to possibly
|
|
// thousands that are singly homed clients.
|
|
if (NbtConfig.MultiHomed)
|
|
{
|
|
fAbleToReachWins = TRUE;
|
|
}
|
|
|
|
LOCATION(0x8);
|
|
//
|
|
// still more adapters to check ...
|
|
//
|
|
// go to the next device context and refresh the name there
|
|
// using the same tracker.
|
|
// look for a device context with a valid IP address since there is
|
|
// no sense in refreshing names out unconnected RAS links.
|
|
//
|
|
|
|
if (pDeviceContext)
|
|
{
|
|
//
|
|
// check if any higher bits are set inthe AdapterMask
|
|
//
|
|
AdapterMask = pTracker->pDeviceContext->AdapterMask;
|
|
AdapterMask = AdapterMask << 1;
|
|
pDeviceContext = NULL;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// The Device we were Refreshing on has gone away, but we don't
|
|
// know which one it was, so ReRefresh!
|
|
//
|
|
AdapterMask = 1;
|
|
}
|
|
|
|
//
|
|
// If we have finished refreshing on all devices for this name, get the next name
|
|
//
|
|
if ( (!(AdapterMask) ||
|
|
(AdapterMask > (pNameAddr->AdapterMask & ~pNameAddr->RefreshMask))) )
|
|
{
|
|
// *** clean up the previously refreshed name ***
|
|
|
|
// if we failed to reach WINS on the last refresh, stop refreshing
|
|
// until the next time interval. This cuts down on network traffic.
|
|
//
|
|
if (fAbleToReachWins)
|
|
{
|
|
GetNextName(pNameAddr,&pNameAddrNext);
|
|
AdapterMask = 1;
|
|
fResetDevice = TRUE;
|
|
}
|
|
else
|
|
{
|
|
pNameAddrNext = NULL;
|
|
}
|
|
|
|
//
|
|
// Dereference the previous address after calling GetNextName
|
|
// since it cause the Name to get free'ed
|
|
//
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
NBT_DEREFERENCE_ADDRESS (pNameAddr->pAddressEle, REF_ADDR_REFRESH);
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq);
|
|
|
|
pNameAddr = pNameAddrNext;
|
|
}
|
|
|
|
pHead = &NbtConfig.DeviceContexts;
|
|
while (pNameAddr)
|
|
{
|
|
//
|
|
// Get mask of Adapters left to Refresh on; after that, get the lowest adapter number
|
|
//
|
|
AdapterMask = ~(AdapterMask-1) & (pNameAddr->AdapterMask & ~(pNameAddr->RefreshMask));
|
|
AdapterMask &= ~(AdapterMask - 1);
|
|
|
|
//
|
|
// Travel to the actual device for this Adapter number
|
|
//
|
|
pEntry = pHead->Flink;
|
|
while (pEntry != pHead)
|
|
{
|
|
pDeviceContext = CONTAINING_RECORD(pEntry,tDEVICECONTEXT,Linkage);
|
|
//
|
|
// Check if this Device matches the AdapterMask and also has
|
|
// a valid ip address and name server address
|
|
//
|
|
if (pDeviceContext->AdapterMask == AdapterMask)
|
|
{
|
|
if ((pDeviceContext->IpAddress != 0) &&
|
|
((pDeviceContext->lNameServerAddress != LOOP_BACK)) ||
|
|
((pNameAddr->NameTypeState & STATE_CONFLICT) && (!pNameAddr->ConflictMask)))
|
|
{
|
|
//
|
|
// Found a valid device on which this name is registered
|
|
//
|
|
IF_DBG(NBT_DEBUG_REFRESH)
|
|
KdPrint(("Nbt.DelayedNextRefresh: Adapter <%lx:%lx>, Name <%15.15s:%X>\n",
|
|
AdapterMask,pNameAddr->Name,pNameAddr->Name[15]));
|
|
|
|
pTracker->pDeviceContext = pDeviceContext;
|
|
|
|
// remove the previous timer from the AddressEle since StartRefresh
|
|
// will start a new timer - safety measure and probably not required!
|
|
//
|
|
CHECK_PTR(pNameAddr);
|
|
pNameAddr->pTimer = NULL;
|
|
|
|
// this call sends out a name registration PDU on a different adapter
|
|
// to (potentially) a different name server. The Name service PDU
|
|
// is the same as the last one though...no need to create a new one.
|
|
//
|
|
status = StartRefresh(pNameAddr, pTracker, &OldIrq, fResetDevice);
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
if (!NT_SUCCESS(status))
|
|
{
|
|
NBT_DEREFERENCE_ADDRESS (pNameAddr->pAddressEle, REF_ADDR_REFRESH);
|
|
NbtConfig.GlobalRefreshState &= ~NBT_G_REFRESHING_NOW;
|
|
KdPrint(("Nbt.DelayedNextRefresh: ERROR -- Refreshing <%-15.15s:%x>, status=<%X>\n",
|
|
pNameAddr->Name,pNameAddr->Name[15], status));
|
|
}
|
|
|
|
goto ExitRoutine;
|
|
}
|
|
|
|
//
|
|
// This Device from AdapterMask did not have a valid IP or WINS address
|
|
//
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
pDeviceContext = NULL;
|
|
}
|
|
|
|
//
|
|
// Go to next device
|
|
//
|
|
pEntry = pEntry->Flink;
|
|
}
|
|
|
|
//
|
|
// If we reached here with a non-NULL pDeviceContext, then it means that
|
|
// the Device did not have a valid IP address or Name Server address
|
|
// otherwise ...
|
|
//
|
|
if (!pDeviceContext)
|
|
{
|
|
//
|
|
//
|
|
// Error case:
|
|
// It could be that an adapter was removed while we were looping
|
|
//
|
|
KdPrint (("Nbt.DelayedNextRefresh: AdapterMask <%lx:%lx> no longer exists!\n", AdapterMask));
|
|
pNameAddr->AdapterMask &= ~AdapterMask;
|
|
pNameAddr->RefreshMask &= ~AdapterMask;
|
|
}
|
|
|
|
//
|
|
// Go to the next adapter
|
|
//
|
|
AdapterMask = AdapterMask << 1;
|
|
|
|
|
|
//
|
|
// Check if this name has any more adapters on which it can be refreshed
|
|
//
|
|
if ( (!(AdapterMask) ||
|
|
(AdapterMask > (pNameAddr->AdapterMask & ~pNameAddr->RefreshMask))) )
|
|
{
|
|
// *** clean up the previously refreshed name ***
|
|
|
|
if (fAbleToReachWins)
|
|
{
|
|
//
|
|
// No more adapters on which to Refresh for the previous name
|
|
// Get the next name in the hash table
|
|
//
|
|
GetNextName(pNameAddr,&pNameAddrNext);
|
|
AdapterMask = 1;
|
|
fResetDevice = TRUE;
|
|
pHead = &NbtConfig.DeviceContexts;
|
|
}
|
|
else
|
|
{
|
|
pNameAddrNext = NULL;
|
|
}
|
|
|
|
//
|
|
// Dereference the previous address after calling GetNextName
|
|
// since it cause the Name to get free'ed
|
|
//
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
NBT_DEREFERENCE_ADDRESS (pNameAddr->pAddressEle, REF_ADDR_REFRESH);
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq);
|
|
|
|
pNameAddr = pNameAddrNext;
|
|
}
|
|
}
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
|
|
if (!pNameAddr)
|
|
{
|
|
LOCATION(0x7);
|
|
// we finally delete the tracker here after using it to refresh
|
|
// all of the names. It is not deleted in the RefreshCompletion
|
|
// routine anymore!
|
|
//
|
|
NBT_DEREFERENCE_TRACKER(pTracker, FALSE);
|
|
NbtConfig.GlobalRefreshState &= ~NBT_G_REFRESHING_NOW;
|
|
}
|
|
|
|
|
|
ExitRoutine:
|
|
|
|
CTEExReleaseResource(&NbtConfig.Resource);
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
WakeupRefreshTimeout(
|
|
PVOID pContext,
|
|
PVOID pContext2,
|
|
tTIMERQENTRY *pTimerQEntry
|
|
)
|
|
{
|
|
if (NbtConfig.pWakeupRefreshTimer)
|
|
{
|
|
NbtConfig.pWakeupRefreshTimer = NULL;
|
|
ReRegisterLocalNames (NULL, FALSE);
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
RefreshTimeout(
|
|
PVOID pContext,
|
|
PVOID pContext2,
|
|
tTIMERQENTRY *pTimerQEntry
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles is the timeout handler for name refreshes to
|
|
WINS. It just queues the request to the Executive worker thread so that
|
|
the work can be done at non-dispatch level. If there is currently a
|
|
refresh going on, then the routine simply restarts the timer and
|
|
exits.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
CTELockHandle OldIrq;
|
|
|
|
if (!pTimerQEntry)
|
|
{
|
|
NbtConfig.pRefreshTimer = NULL;
|
|
return;
|
|
}
|
|
|
|
CHECK_PTR(pTimerQEntry);
|
|
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq);
|
|
if (NodeType & BNODE)
|
|
{
|
|
pTimerQEntry->Flags = 0; // Do not restart the timer
|
|
NbtConfig.pRefreshTimer = NULL;
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
return;
|
|
}
|
|
|
|
if (!(NbtConfig.GlobalRefreshState & NBT_G_REFRESHING_NOW))
|
|
{
|
|
// this is a global flag that prevents a second refresh
|
|
// from starting when one is currently going on.
|
|
//
|
|
|
|
if (NT_SUCCESS(CTEQueueForNonDispProcessing (DelayedRefreshBegin,
|
|
NULL, NULL, NULL, NULL, TRUE)))
|
|
{
|
|
NbtConfig.GlobalRefreshState |= NBT_G_REFRESHING_NOW;
|
|
}
|
|
} // doing refresh now
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
|
|
// set any new timeout value and restart the timer
|
|
//
|
|
pTimerQEntry->DeltaTime = NbtConfig.MinimumTtl/NbtConfig.RefreshDivisor;
|
|
pTimerQEntry->Flags |= TIMER_RESTART;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
DelayedRefreshBegin(
|
|
IN tDGRAM_SEND_TRACKING *pUnused1,
|
|
IN PVOID pUnused2,
|
|
IN PVOID pUnused3,
|
|
IN tDEVICECONTEXT *pUnused4
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles starting up sending name refreshes to the name server.
|
|
|
|
The idea is to set the timeout to T/8 and check for names with the Refresh
|
|
bit cleared - re-registering those names. At T=4 and T=0, clear all bits
|
|
and refresh all names. The Inbound code sets the refresh bit when it gets a
|
|
refresh response from the NS.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
CTELockHandle OldIrq;
|
|
tNAMEADDR *pNameAddr;
|
|
NTSTATUS status;
|
|
tHASHTABLE *pHashTable;
|
|
LONG i;
|
|
PLIST_ENTRY pHead;
|
|
PLIST_ENTRY pEntry;
|
|
tDEVICECONTEXT *pDeviceContext;
|
|
CTEULONGLONG Adapter;
|
|
BOOLEAN fTimeToSwitch = FALSE;
|
|
BOOLEAN fTimeToRefresh = FALSE;
|
|
USHORT TimeoutsBeforeSwitching;
|
|
ULONG TimeoutsBeforeNextRefresh;
|
|
CTESystemTime CurrentTime;
|
|
ULONG TimeoutDelta;
|
|
USHORT NumTimeoutIntervals;
|
|
|
|
//
|
|
// If the refresh timeout has been set to the maximum value then do
|
|
// not send any refreshes to the name server
|
|
//
|
|
if (NbtConfig.MinimumTtl == NBT_MAXIMUM_TTL)
|
|
{
|
|
NbtConfig.GlobalRefreshState &= ~NBT_G_REFRESHING_NOW;
|
|
return;
|
|
}
|
|
|
|
LOCATION(0x12);
|
|
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq);
|
|
|
|
CTEQuerySystemTime (CurrentTime);
|
|
ExSystemTimeToLocalTime (&CurrentTime, &CurrentTime);
|
|
TimeoutDelta = NbtConfig.MinimumTtl/NbtConfig.RefreshDivisor;
|
|
NumTimeoutIntervals = (USHORT)
|
|
(((CurrentTime.QuadPart - NbtConfig.LastRefreshTime.QuadPart) + ((LONGLONG)TimeoutDelta*10000/2))
|
|
/ ((LONGLONG)TimeoutDelta*10000)); // in 100 nano second units
|
|
NbtConfig.LastRefreshTime = CurrentTime;
|
|
|
|
//
|
|
// NumTimeoutIntervals > 1 if we were sleeping
|
|
//
|
|
if (NumTimeoutIntervals > 1)
|
|
{
|
|
//
|
|
// If we crossed Ttl/2 or Ttl while sleeping, refresh all names
|
|
//
|
|
TimeoutsBeforeNextRefresh = (NbtConfig.RefreshDivisor/2)
|
|
- (NbtConfig.sTimeoutCount % (NbtConfig.RefreshDivisor/2));
|
|
NbtConfig.sTimeoutCount += NumTimeoutIntervals; // Up the timeout count
|
|
//
|
|
// Refresh all of the names if
|
|
// a) we crossed Ttl/2 during sleep, or
|
|
// b) we are within Ttl/4 of the Ttl
|
|
//
|
|
if ((NumTimeoutIntervals > TimeoutsBeforeNextRefresh) ||
|
|
((NbtConfig.RefreshDivisor-NbtConfig.sTimeoutCount) < (NbtConfig.RefreshDivisor/4)))
|
|
{
|
|
fTimeToRefresh = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NbtConfig.sTimeoutCount++; // Up the timeout count for this cycle!
|
|
|
|
//
|
|
// If it has been over an hour (DEFAULT_SWITCH_TTL) since we last switched,
|
|
// then set fTimeToSwitch = TRUE
|
|
//
|
|
TimeoutsBeforeSwitching =(USHORT)((DEFAULT_SWITCH_TTL*NbtConfig.RefreshDivisor)/NbtConfig.MinimumTtl);
|
|
fTimeToSwitch = (NbtConfig.sTimeoutCount - NbtConfig.LastSwitchTimeoutCount)
|
|
>= TimeoutsBeforeSwitching;
|
|
fTimeToRefresh = (NbtConfig.sTimeoutCount >= (NbtConfig.RefreshDivisor/2));
|
|
|
|
if (fTimeToSwitch)
|
|
{
|
|
NbtConfig.LastSwitchTimeoutCount = NbtConfig.sTimeoutCount;
|
|
}
|
|
}
|
|
|
|
NbtConfig.sTimeoutCount %= NbtConfig.RefreshDivisor;
|
|
|
|
//
|
|
// Reset the clock if we are Refreshing everything
|
|
//
|
|
if (fTimeToRefresh)
|
|
{
|
|
NbtConfig.sTimeoutCount = 0;
|
|
fTimeToSwitch = FALSE;
|
|
}
|
|
|
|
//
|
|
// Set some special-case information
|
|
//
|
|
if (0 == NbtConfig.sTimeoutCount)
|
|
{
|
|
NbtConfig.LastSwitchTimeoutCount = 0;
|
|
}
|
|
|
|
IF_DBG(NBT_DEBUG_REFRESH)
|
|
KdPrint(("Nbt.DelayedRefreshBegin: fTimeToRefresh=<%d>,fTimeToSwitch=<%d>, MinTtl=<%d>, RefDiv=<%d>\n"
|
|
"TimeoutCount: %d, LastSwTimeoutCount: %d\n",
|
|
fTimeToRefresh, fTimeToSwitch, NbtConfig.MinimumTtl, NbtConfig.RefreshDivisor,
|
|
NbtConfig.sTimeoutCount, NbtConfig.LastSwitchTimeoutCount));
|
|
|
|
//
|
|
// go through the local table clearing the REFRESHED bit and sending
|
|
// name refreshes to the name server
|
|
//
|
|
pHashTable = NbtConfig.pLocalHashTbl;
|
|
if (fTimeToRefresh || fTimeToSwitch)
|
|
{
|
|
CTEULONGLONG ToRefreshMask = 0;
|
|
PLIST_ENTRY pHead1,pEntry1;
|
|
|
|
for (i=0 ;i < pHashTable->lNumBuckets ;i++ )
|
|
{
|
|
pHead = &pHashTable->Bucket[i];
|
|
pEntry = pHead->Flink;
|
|
|
|
//
|
|
// Go through each name in each bucket of the hashtable
|
|
//
|
|
while (pEntry != pHead)
|
|
{
|
|
pNameAddr = CONTAINING_RECORD(pEntry,tNAMEADDR,Linkage);
|
|
CHECK_PTR(pNameAddr);
|
|
|
|
// don't refresh scope names or names in conflict or that are the
|
|
// broadcast name "* ", or Quick added names.(since these are
|
|
// not registered on the network)
|
|
//
|
|
if (!(pNameAddr->NameTypeState & STATE_RESOLVED) ||
|
|
(pNameAddr->Name[0] == '*') ||
|
|
(IsBrowserName(pNameAddr->Name)) ||
|
|
(pNameAddr->NameTypeState & NAMETYPE_QUICK))
|
|
{
|
|
pEntry = pEntry->Flink;
|
|
continue;
|
|
}
|
|
|
|
|
|
if (fTimeToRefresh)
|
|
{
|
|
//
|
|
// Clear the refreshed bits so all names get refreshed if we are
|
|
// at interval 0 or interval NbtConfig.RefreshDivisor/2
|
|
//
|
|
pNameAddr->RefreshMask = 0;
|
|
}
|
|
|
|
//
|
|
// Set the ToRefreshMask to include any Devices not Refreshed previously
|
|
//
|
|
ToRefreshMask |= (pNameAddr->AdapterMask & ~pNameAddr->RefreshMask);
|
|
|
|
pEntry = pEntry->Flink; // next hash table entry
|
|
}
|
|
} // for ( .. pHashTable .. )
|
|
|
|
//
|
|
// Go through each adapter checking if a name needs to be Refreshed on this adapter.
|
|
//
|
|
pHead1 = &NbtConfig.DeviceContexts;
|
|
pEntry1 = pHead1->Flink;
|
|
while (pEntry1 != pHead1)
|
|
{
|
|
pDeviceContext = CONTAINING_RECORD(pEntry1,tDEVICECONTEXT,Linkage);
|
|
pEntry1 = pEntry1->Flink;
|
|
|
|
//
|
|
// If we are currently switched to the backup, then try
|
|
// to switch back to the primary
|
|
//
|
|
if (pDeviceContext->SwitchedToBackup)
|
|
{
|
|
SwitchToBackup(pDeviceContext);
|
|
pDeviceContext->RefreshToBackup = FALSE;
|
|
}
|
|
else if (fTimeToRefresh) // If this is a fresh Refresh cycle, restart from the primary
|
|
{
|
|
pDeviceContext->RefreshToBackup = FALSE;
|
|
}
|
|
else if ((pDeviceContext->AdapterMask & ToRefreshMask) && // do we need to switch on this device
|
|
(pDeviceContext->lBackupServer != LOOP_BACK))
|
|
{
|
|
pDeviceContext->RefreshToBackup = ~pDeviceContext->RefreshToBackup;
|
|
}
|
|
}
|
|
}
|
|
|
|
// always start at the first name in the hash table. As each name gets
|
|
// refreshed NextRefresh will be hit to get the next name etc..
|
|
//
|
|
NbtConfig.CurrentHashBucket = 0;
|
|
GetNextName(NULL,&pNameAddr); // get the next(first) name in the hash table
|
|
|
|
status = STATUS_UNSUCCESSFUL;
|
|
if (pNameAddr)
|
|
{
|
|
LOCATION(0x13);
|
|
status = StartRefresh(pNameAddr, NULL, &OldIrq, TRUE);
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
|
|
//
|
|
// If this routine fails then the address element increment done in
|
|
// GetNextName has to be undone here
|
|
//
|
|
if (!NT_SUCCESS(status))
|
|
{
|
|
NbtConfig.GlobalRefreshState &= ~NBT_G_REFRESHING_NOW;
|
|
NBT_DEREFERENCE_ADDRESS (pNameAddr->pAddressEle, REF_ADDR_REFRESH);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NbtConfig.GlobalRefreshState &= ~NBT_G_REFRESHING_NOW;
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
}
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
RemoteHashTimeout(
|
|
PVOID pContext,
|
|
PVOID pContext2,
|
|
tTIMERQENTRY *pTimerQEntry
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles deleting names in the Remote Hash table that are
|
|
old. The basic alorithm scans the table looking at the Timed_out bit.
|
|
If it is set then the name is deleted, otherwise the bit is set. This
|
|
means the names can live as long as 2*Timeout or as little as Timeout.
|
|
So set the Timeout to 6 Minutes and names live 9 minutes +- 3 minutes.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
CTELockHandle OldIrq;
|
|
CTELockHandle OldIrq1;
|
|
tNAMEADDR *pNameAddr;
|
|
tHASHTABLE *pHashTable;
|
|
LONG i;
|
|
PLIST_ENTRY pHead;
|
|
PLIST_ENTRY pEntry;
|
|
PLIST_ENTRY pDeviceHead;
|
|
PLIST_ENTRY pDeviceEntry;
|
|
tDEVICECONTEXT *pDeviceContext;
|
|
tLOWERCONNECTION *pLowerConn;
|
|
ULONG TimeoutCount;
|
|
|
|
if (!pTimerQEntry)
|
|
{
|
|
//
|
|
// The Timer is being cancelled
|
|
//
|
|
NbtConfig.pRemoteHashTimer = NULL;
|
|
return;
|
|
}
|
|
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq);
|
|
|
|
//
|
|
// Update the Remote cache timestamp
|
|
//
|
|
NbtConfig.CacheTimeStamp++;
|
|
|
|
//
|
|
// go through the remote table deleting names that have timeout bits
|
|
// set and setting the bits for names that have the bit clear
|
|
//
|
|
pHashTable = NbtConfig.pRemoteHashTbl;
|
|
for (i=0;i < pHashTable->lNumBuckets ;i++ )
|
|
{
|
|
pHead = &pHashTable->Bucket[i];
|
|
pEntry = pHead->Flink;
|
|
while (pEntry != pHead)
|
|
{
|
|
pNameAddr = CONTAINING_RECORD(pEntry,tNAMEADDR,Linkage);
|
|
pEntry = pEntry->Flink;
|
|
//
|
|
// do not delete scope entries, and do not delete names that
|
|
// that are still resolving, and do not delete names that are
|
|
// being used by someone (refcount > 1)
|
|
//
|
|
if ((pNameAddr->NameTypeState & (STATE_RESOLVED | STATE_RELEASED)) &&
|
|
(pNameAddr->RefCount <= 1))
|
|
{
|
|
if ((pNameAddr->TimeOutCount == 0) ||
|
|
((pContext == NbtConfig.pRemoteHashTbl) &&
|
|
!(pNameAddr->NameTypeState & NAMETYPE_SCOPE)))
|
|
{
|
|
NBT_DEREFERENCE_NAMEADDR (pNameAddr, REF_NAME_REMOTE, TRUE);
|
|
}
|
|
else if (!(pNameAddr->NameTypeState & NAMETYPE_SCOPE))
|
|
{
|
|
pNameAddr->TimeOutCount--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// *** Inbound Connections Cleanup *** //
|
|
|
|
//
|
|
// Go through each Device and cleanup any lingering connections waiting in the Inbound state
|
|
// Start with the SmbDevice
|
|
//
|
|
pDeviceHead = pDeviceEntry = &NbtConfig.DeviceContexts;
|
|
if (pNbtSmbDevice)
|
|
{
|
|
pDeviceContext = pNbtSmbDevice;
|
|
}
|
|
else if ((pDeviceEntry = pDeviceEntry->Flink) != pDeviceHead)
|
|
{
|
|
pDeviceContext = CONTAINING_RECORD(pDeviceEntry,tDEVICECONTEXT,Linkage);
|
|
}
|
|
else
|
|
{
|
|
pDeviceContext = NULL;
|
|
}
|
|
|
|
while (pDeviceContext)
|
|
{
|
|
CTESpinLock(pDeviceContext,OldIrq1);
|
|
|
|
//
|
|
// Set the timeout based on the Resource usage!
|
|
//
|
|
if (pDeviceContext->NumWaitingForInbound > NbtConfig.MaxBackLog)
|
|
{
|
|
TimeoutCount = MIN_INBOUND_STATE_TIMEOUT / REMOTE_HASH_TIMEOUT; // Minimum Timeout value
|
|
}
|
|
else if (pDeviceContext->NumWaitingForInbound > NbtConfig.MaxBackLog/2)
|
|
{
|
|
TimeoutCount = MED_INBOUND_STATE_TIMEOUT / REMOTE_HASH_TIMEOUT; // Medium Timeout value
|
|
}
|
|
else
|
|
{
|
|
TimeoutCount = MAX_INBOUND_STATE_TIMEOUT / REMOTE_HASH_TIMEOUT; // Maximum Timeout Value
|
|
}
|
|
|
|
//
|
|
// Now go through the list of Inbound connections and see if
|
|
// we need to cleanup any that have lingering around for too long!
|
|
//
|
|
pHead = &pDeviceContext->WaitingForInbound;
|
|
pEntry = pHead->Flink;
|
|
while (pEntry != pHead)
|
|
{
|
|
pLowerConn = CONTAINING_RECORD(pEntry,tLOWERCONNECTION,Linkage);
|
|
pEntry = pEntry->Flink;
|
|
|
|
pLowerConn->TimeUnitsInLastState++;
|
|
|
|
if (pLowerConn->TimeUnitsInLastState > TimeoutCount)
|
|
{
|
|
RemoveEntryList (&pLowerConn->Linkage);
|
|
InitializeListHead (&pLowerConn->Linkage);
|
|
SET_STATE_LOWER(pLowerConn, NBT_IDLE); // so that Inbound doesn't start processing it!
|
|
if (pLowerConn->SpecialAlloc)
|
|
{
|
|
InterlockedDecrement(&pLowerConn->pDeviceContext->NumSpecialLowerConn);
|
|
}
|
|
else
|
|
{
|
|
CTEQueueForNonDispProcessing (DelayedAllocLowerConn,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
pLowerConn->pDeviceContext,
|
|
TRUE);
|
|
}
|
|
|
|
ASSERT (pLowerConn->RefCount == 2);
|
|
NBT_DEREFERENCE_LOWERCONN (pLowerConn, REF_LOWC_WAITING_INBOUND, TRUE); // RefCount: 2 -> 1
|
|
NBT_DEREFERENCE_LOWERCONN (pLowerConn, REF_LOWC_CREATE, TRUE); // Close all the Tcp handles
|
|
InterlockedDecrement (&pDeviceContext->NumWaitingForInbound);
|
|
}
|
|
} // pDeviceContext->WaitingForInbound List
|
|
|
|
CTESpinFree(pDeviceContext,OldIrq1);
|
|
|
|
if ((pDeviceEntry = pDeviceEntry->Flink) != pDeviceHead)
|
|
{
|
|
pDeviceContext = CONTAINING_RECORD(pDeviceEntry,tDEVICECONTEXT,Linkage);
|
|
}
|
|
else
|
|
{
|
|
pDeviceContext = NULL;
|
|
}
|
|
} // NbtConfig.DeviceContexts List
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq);
|
|
|
|
// restart the timer
|
|
//
|
|
pTimerQEntry->Flags |= TIMER_RESTART;
|
|
|
|
return;
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
NextKeepAlive(
|
|
IN tDGRAM_SEND_TRACKING *pTracker,
|
|
IN NTSTATUS status,
|
|
IN ULONG Info
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles sending subsequent KeepAlives for sessions.
|
|
This is the "Client Completion" routine of the TdiSend that sends the
|
|
keep alive on the session.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
tLOWERCONNECTION *pLowerConnLast;
|
|
tLOWERCONNECTION *pLowerConn;
|
|
tDEVICECONTEXT *pDeviceContext;
|
|
|
|
PUSH_LOCATION(0x92);
|
|
pDeviceContext = pTracker->pDeviceContext;
|
|
pLowerConnLast = (tLOWERCONNECTION *)pTracker->pClientEle;
|
|
|
|
// get the next session to send a keep alive on, if there is one, otherwise
|
|
// free the session header block.
|
|
//
|
|
GetNextKeepAlive (pDeviceContext, &pDeviceContext, pLowerConnLast, &pLowerConn, pTracker);
|
|
|
|
NBT_DEREFERENCE_LOWERCONN (pLowerConnLast, REF_LOWC_KEEP_ALIVE, FALSE);
|
|
status = STATUS_UNSUCCESSFUL;
|
|
|
|
if (pLowerConn)
|
|
{
|
|
pTracker->pDeviceContext = pDeviceContext;
|
|
pTracker->pClientEle = (tCLIENTELE *)pLowerConn;
|
|
|
|
ASSERT((pTracker->SendBuffer.HdrLength + pTracker->SendBuffer.Length) == 4);
|
|
PUSH_LOCATION(0x91);
|
|
#ifndef VXD
|
|
// this may wind up the stack if the completion occurs synchronously,
|
|
// because the completion routine is this routine, so call a routine
|
|
// that sets up a dpc to to the send, which will not run until this
|
|
// procedure returns and we get out of raised irql.
|
|
//
|
|
status = NTSendSession (pTracker, pLowerConn, NextKeepAlive);
|
|
#else
|
|
(void) TcpSendSession (pTracker, pLowerConn, NextKeepAlive);
|
|
status = STATUS_SUCCESS;
|
|
#endif
|
|
}
|
|
|
|
if (!NT_SUCCESS(status))
|
|
{
|
|
if (pLowerConn)
|
|
{
|
|
NBT_DEREFERENCE_LOWERCONN (pLowerConn, REF_LOWC_KEEP_ALIVE, FALSE);
|
|
}
|
|
|
|
FreeTracker(pTracker,FREE_HDR | RELINK_TRACKER);
|
|
}
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
GetNextKeepAlive(
|
|
tDEVICECONTEXT *pDeviceContext,
|
|
tDEVICECONTEXT **ppDeviceContextOut,
|
|
tLOWERCONNECTION *pLowerConnIn,
|
|
tLOWERCONNECTION **ppLowerConnOut,
|
|
tDGRAM_SEND_TRACKING *pTracker
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles sending session keep Alives to the other end of a
|
|
connection about once a minute or so.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
CTELockHandle OldIrq;
|
|
CTELockHandle OldIrq1;
|
|
CTELockHandle OldIrq2;
|
|
tLOWERCONNECTION *pLowerConn;
|
|
PLIST_ENTRY pHead;
|
|
PLIST_ENTRY pEntry;
|
|
PLIST_ENTRY pHeadDevice;
|
|
PLIST_ENTRY pEntryDevice;
|
|
NTSTATUS status;
|
|
tDEVICECONTEXT *pEntryDeviceContext;
|
|
|
|
*ppLowerConnOut = NULL;
|
|
|
|
//
|
|
// loop through all the adapter cards looking at all connections
|
|
//
|
|
CTESpinLock(&NbtConfig.JointLock,OldIrq1);
|
|
|
|
//
|
|
// Verify that the Device passed in is a valid device,
|
|
// otherwise either pick the next Device, or fail
|
|
//
|
|
status = STATUS_UNSUCCESSFUL;
|
|
pEntryDevice = pHeadDevice = &NbtConfig.DeviceContexts;
|
|
while ((pEntryDevice = pEntryDevice->Flink) != pHeadDevice)
|
|
{
|
|
pEntryDeviceContext = CONTAINING_RECORD(pEntryDevice,tDEVICECONTEXT,Linkage);
|
|
if ((pEntryDeviceContext == pDeviceContext) ||
|
|
(pEntryDeviceContext->AdapterNumber > pTracker->RCount))
|
|
{
|
|
if (pEntryDeviceContext != pDeviceContext)
|
|
{
|
|
pLowerConnIn = NULL;
|
|
}
|
|
pDeviceContext = pEntryDeviceContext;
|
|
status = STATUS_SUCCESS;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!NT_SUCCESS(status))
|
|
{
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq1);
|
|
return;
|
|
}
|
|
|
|
pEntryDevice = &pDeviceContext->Linkage;
|
|
while (pEntryDevice != pHeadDevice)
|
|
{
|
|
pDeviceContext = CONTAINING_RECORD(pEntryDevice,tDEVICECONTEXT,Linkage);
|
|
pEntryDevice = pEntryDevice->Flink;
|
|
|
|
// grab the device context spin lock so that the lower connection
|
|
// element does not get removed from the Q while we are checking the
|
|
// connection state
|
|
//
|
|
CTESpinLock(pDeviceContext,OldIrq);
|
|
pHead = &pDeviceContext->LowerConnection;
|
|
//
|
|
// get the next lower connection after this one one the list, but
|
|
// be sure this connection is still on the active list by checking
|
|
// the state.
|
|
//
|
|
// If this connection has been cleaned up in OutOfRsrcKill, then dont trust the linkages.
|
|
//
|
|
if (pLowerConnIn &&
|
|
!pLowerConnIn->OutOfRsrcFlag &&
|
|
((pLowerConnIn->State == NBT_SESSION_UP) ||
|
|
(pLowerConnIn->State == NBT_SESSION_INBOUND)))
|
|
{
|
|
pEntry = pLowerConnIn->Linkage.Flink;
|
|
pLowerConnIn = NULL;
|
|
}
|
|
else
|
|
{
|
|
pEntry = pHead->Flink;
|
|
}
|
|
|
|
while (pEntry != pHead)
|
|
{
|
|
pLowerConn = CONTAINING_RECORD(pEntry,tLOWERCONNECTION,Linkage);
|
|
|
|
//
|
|
// Inbound connections can hang around forever in that state if
|
|
// the session setup message never gets sent, so send keep
|
|
// alives on those too.
|
|
//
|
|
if ((pLowerConn->State == NBT_SESSION_UP) ||
|
|
(pLowerConn->State == NBT_SESSION_INBOUND))
|
|
{
|
|
|
|
// grab the spin lock, recheck the state and
|
|
// increment the reference count so that this connection cannot
|
|
// disappear while the keep alive is being sent and mess up
|
|
// the linked list.
|
|
CTESpinLock(pLowerConn,OldIrq2);
|
|
if ((pLowerConn->State != NBT_SESSION_UP ) &&
|
|
(pLowerConn->State != NBT_SESSION_INBOUND))
|
|
{
|
|
// this connection is probably back on the free connection
|
|
// list, so we will never satisfy the pEntry = pHead and
|
|
// loop forever, so just get out and send keepalives on the
|
|
// next timeout
|
|
//
|
|
pEntry = pEntry->Flink;
|
|
PUSH_LOCATION(0x91);
|
|
CTESpinFree(pLowerConn,OldIrq2);
|
|
break;
|
|
|
|
}
|
|
else if (pLowerConn->RefCount >= 3 )
|
|
{
|
|
//
|
|
// already a keep alive on this connection, or we
|
|
// are currently in the receive handler and do not
|
|
// need to send a keep alive.
|
|
//
|
|
pEntry = pEntry->Flink;
|
|
PUSH_LOCATION(0x93);
|
|
CTESpinFree(pLowerConn,OldIrq2);
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// found a connection to send a keep alive on
|
|
//
|
|
NBT_REFERENCE_LOWERCONN (pLowerConn, REF_LOWC_KEEP_ALIVE);
|
|
//
|
|
// return the current position in the list of connections
|
|
//
|
|
pTracker->RCount = pDeviceContext->AdapterNumber;
|
|
*ppLowerConnOut = pLowerConn;
|
|
*ppDeviceContextOut = pDeviceContext;
|
|
|
|
CTESpinFree(pLowerConn,OldIrq2);
|
|
CTESpinFree(pDeviceContext,OldIrq);
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq1);
|
|
|
|
return;
|
|
}
|
|
|
|
pEntry = pEntry->Flink;
|
|
}
|
|
|
|
CTESpinFree(pDeviceContext,OldIrq);
|
|
}
|
|
|
|
CTESpinFree(&NbtConfig.JointLock,OldIrq1);
|
|
return;
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
SessionKeepAliveTimeout(
|
|
PVOID pContext,
|
|
PVOID pContext2,
|
|
tTIMERQENTRY *pTimerQEntry
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles starting the non dispatch level routine to send
|
|
keep alives.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
if (!pTimerQEntry)
|
|
{
|
|
NbtConfig.pSessionKeepAliveTimer = NULL;
|
|
return;
|
|
}
|
|
|
|
CHECK_PTR(pTimerQEntry);
|
|
if (!NT_SUCCESS(CTEQueueForNonDispProcessing (DelayedSessionKeepAlive,
|
|
NULL, NULL, NULL, NULL, FALSE)))
|
|
{
|
|
IF_DBG(NBT_DEBUG_REFRESH)
|
|
KdPrint (("Nbt.SessionKeepAliveTimeout: Failed to Queue DelayedSessionKeepAlive!!!\n"));
|
|
}
|
|
|
|
// restart the timer
|
|
//
|
|
pTimerQEntry->Flags |= TIMER_RESTART;
|
|
|
|
return;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
DelayedSessionKeepAlive(
|
|
IN tDGRAM_SEND_TRACKING *Unused1,
|
|
IN PVOID Unused2,
|
|
IN PVOID Unused3,
|
|
IN tDEVICECONTEXT *pUnused4
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles sending session keep Alives to the other end of a
|
|
connection about once a minute or so.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
tLOWERCONNECTION *pLowerConn;
|
|
tDEVICECONTEXT *pDeviceContext;
|
|
tSESSIONHDR *pSessionHdr;
|
|
tDGRAM_SEND_TRACKING *pTracker;
|
|
|
|
|
|
CTEPagedCode();
|
|
|
|
if (!(pSessionHdr = (tSESSIONHDR *)NbtAllocMem(sizeof(tSESSIONERROR),NBT_TAG('S'))))
|
|
{
|
|
return;
|
|
}
|
|
|
|
// get a tracker structure, which has a SendInfo structure in it
|
|
if (!NT_SUCCESS(status = GetTracker(&pTracker, NBT_TRACKER_KEEP_ALIVE)))
|
|
{
|
|
CTEMemFree((PVOID)pSessionHdr);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// go through the list of connections attached to each adapter and
|
|
// send a session keep alive pdu on each
|
|
//
|
|
pDeviceContext = CONTAINING_RECORD(NbtConfig.DeviceContexts.Flink,
|
|
tDEVICECONTEXT,Linkage);
|
|
|
|
// get the next session to send a keep alive on, if there is one, otherwise
|
|
// free the session header block.
|
|
//
|
|
pTracker->RCount = 0; // This field keeps track of the last device
|
|
GetNextKeepAlive(pDeviceContext, &pDeviceContext, NULL, &pLowerConn, pTracker);
|
|
if (pLowerConn)
|
|
{
|
|
// if we have found a connection, send the first keep alive. Subsequent
|
|
// keep alives will be sent by the completion routine, NextKeepAlive()
|
|
//
|
|
CHECK_PTR(pTracker);
|
|
pTracker->SendBuffer.pDgramHdr = (PVOID)pSessionHdr;
|
|
pTracker->SendBuffer.HdrLength = sizeof(tSESSIONHDR);
|
|
pTracker->SendBuffer.Length = 0;
|
|
pTracker->SendBuffer.pBuffer = NULL;
|
|
|
|
pSessionHdr->Flags = NBT_SESSION_FLAGS; // always zero
|
|
|
|
pTracker->pDeviceContext = pDeviceContext;
|
|
pTracker->pClientEle = (tCLIENTELE *)pLowerConn;
|
|
CHECK_PTR(pSessionHdr);
|
|
pSessionHdr->Type = NBT_SESSION_KEEP_ALIVE; // 85
|
|
pSessionHdr->Length = 0; // no data following the length byte
|
|
|
|
status = TcpSendSession(pTracker, pLowerConn, NextKeepAlive);
|
|
}
|
|
else
|
|
{
|
|
CTEMemFree((PVOID)pSessionHdr);
|
|
FreeTracker (pTracker, RELINK_TRACKER);
|
|
}
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
IncrementNameStats(
|
|
IN ULONG StatType,
|
|
IN BOOLEAN IsNameServer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine increments statistics on names that resolve either through
|
|
the WINS or through broadcast.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
|
|
//
|
|
// Increment the stattype if the name server is true, that way we can
|
|
// differentiate queries and registrations to the name server or not.
|
|
//
|
|
if (IsNameServer)
|
|
{
|
|
StatType += 2;
|
|
}
|
|
|
|
NameStatsInfo.Stats[StatType]++;
|
|
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
SaveBcastNameResolved(
|
|
IN PUCHAR pName
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine saves the name in LIFO list, so we can see the last
|
|
N names that resolved via broadcast.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
ULONG Index;
|
|
|
|
Index = NameStatsInfo.Index;
|
|
|
|
CTEMemCopy(&NameStatsInfo.NamesReslvdByBcast[Index],
|
|
pName,
|
|
NETBIOS_NAME_SIZE);
|
|
|
|
NameStatsInfo.Index++;
|
|
if (NameStatsInfo.Index >= SIZE_RESOLVD_BY_BCAST_CACHE)
|
|
{
|
|
NameStatsInfo.Index = 0;
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// These are names that should never be sent to WINS.
|
|
//
|
|
BOOL
|
|
IsBrowserName(
|
|
IN PCHAR pName
|
|
)
|
|
{
|
|
CHAR cNameType = pName[NETBIOS_NAME_SIZE - 1];
|
|
|
|
return (
|
|
(cNameType == 0x1E)
|
|
|| (cNameType == 0x1D)
|
|
|| (cNameType == 0x01)
|
|
);
|
|
}
|
|
|
|
//
|
|
// Returns the node type that should be used with a request,
|
|
// based on NetBIOS name type. This is intended to help the
|
|
// node to behave like a BNODE for browser names only.
|
|
//
|
|
AppropriateNodeType(
|
|
IN PCHAR pName,
|
|
IN ULONG NodeType
|
|
)
|
|
{
|
|
ULONG LocalNodeType = NodeType;
|
|
|
|
if (LocalNodeType & BNODE)
|
|
{
|
|
if ( IsBrowserName ( pName ) )
|
|
{
|
|
LocalNodeType &= BNODE;
|
|
}
|
|
}
|
|
return LocalNodeType;
|
|
}
|
|
|