/*++
Copyright (c) 1994 Microsoft Corporation
Copyright (c) 1993 Micro Computer Systems, Inc.
Module Name:
net\svcdlls\nwsap\server\wancheck.c
Abstract:
These routines handle the WAN cards going up and down.
Author:
Brian Walker (MCS) 06-15-1993
Revision History:
--*/
#include "precomp.h"
#pragma hdrstop
/** Structure of data we pass to IPX for the ADDRESS_NOTIFY **/
typedef struct {
UCHAR Reserved[20]; /* Reserved for IPX use */
IPX_ADDRESS_DATA IpxData; /* Information structure we get */
HANDLE EventHandle; /* Handle for IPX to signal */
} IPX_ADDRESS_DATA_EXTENDED;
/** **/
typedef struct {
LIST_ENTRY ListEntry;
IPX_ADDRESS_DATA_EXTENDED Data;
} SAP_WANTRACK, *PSAP_WANTRACK;
#define SAP_WANTRACK_SIZE sizeof(SAP_WANTRACK)
/** **/
SOCKET SapWanSocket = INVALID_SOCKET;
/** Internal Function Prototypes **/
DWORD WINAPI
SapWanCheckThread(
LPVOID Threadparm);
DWORD WINAPI
SapWanWorkerThread(
LPVOID Threadparm);
VOID
SapWanCardUp(
PIPX_ADDRESS_DATA IpxData);
VOID
SapWanCardDown(
PIPX_ADDRESS_DATA IpxData);
/*++
*******************************************************************
S a p W a n I n i t
Routine Description:
This routine initializes the WAN monitoring portion of the Sap Agent.
Arguments:
None
Return Value:
0 = OK
Else = Error
*******************************************************************
--*/
INT
SapWanInit(
VOID)
{
HANDLE Handle;
DWORD Threadid;
DWORD Error;
INT rc;
INT i;
INT Length;
SOCKADDR_IPX Bindaddr;
/** Initialize the sockets interface **/
WSADATA wsadata;
rc = WSAStartup(0x0101, &wsadata);
if (rc) {
SapEventId = NWSAP_EVENT_WSASTARTUP_FAILED;
return rc;
}
/**
Create an event to use to wait with. We use this
with the ADDRESS_NOTIFY socket option.
**/
SapWanEvent = CreateEvent(
NULL, /* No security */
FALSE, /* Auto reset */
FALSE, /* Initial state = Not signalled */
NULL); /* No name */
if (SapWanEvent == NULL) {
SapError = GetLastError();
SapEventId = NWSAP_EVENT_WANEVENT_ERROR;
return -1;
}
/**
Allocate a block of memory for the
list of handles that we use to store the
NOTIFY threads with.
**/
Length = SapNumWanNotifyThreads * sizeof(HANDLE),
SapWanNotifyHandlesBuf = SAP_MALLOC(
Length,
"SapWanNoifyThreadHandles");
if (SapWanNotifyHandlesBuf == NULL) {
SapError = GetLastError();
SapEventId = NWSAP_EVENT_WANHANDLEMEMORY_ERROR;
return -1;
}
memset(SapWanNotifyHandlesBuf, 0, Length);
/** Create a semaphore for the threads to wait on **/
SapWanCurBackup = 0;
SapWanCurFree = 0;
SapWanSem = CreateSemaphore(NULL, 0, 0x7FFFFFFF, NULL);
if (SapWanSem == NULL) {
SapError = GetLastError();
SapEventId = NWSAP_EVENT_WANSEM_FAIL;
return -1;
}
/** Open a socket to do the getsockopt on **/
SapWanSocket = socket(AF_IPX, SOCK_DGRAM, NSPROTO_IPX);
if (SapWanSocket == INVALID_SOCKET) {
SapError = h_errno;
SapEventId = NWSAP_EVENT_WANSOCKET_FAILED;
return -1;
}
/** Bind to any old address **/
memset(&Bindaddr, 0, sizeof(SOCKADDR_IPX));
Bindaddr.sa_family = AF_IPX;
rc = bind(SapWanSocket, (PSOCKADDR)&Bindaddr, sizeof(SOCKADDR_IPX));
if (rc == -1) {
SapError = h_errno;
SapEventId = NWSAP_EVENT_WANBIND_FAILED;
return -1;
}
/**
Create the worker thread.
We count this thread as running before we start it
for synchronization. If the start fails - then we will
dec this count
**/
SAP_INC_THREAD_COUNT("Wan Start 1", NULL);
/** Start the thread **/
Handle = CreateThread(
NULL, /* Security Ptr */
0, /* Initial stack size */
SapWanWorkerThread, /* Thread Function */
(LPVOID)NULL, /* Parm for the thread */
0, /* Creation Flags */
&Threadid); /* Ptr to thread id */
if (Handle == NULL) {
/** **/
Error = GetLastError();
IF_DEBUG(INITIALIZATION_ERRORS) {
SS_PRINT(("NWSAP: Error starting WAN worker thread = %d\n", Error));
}
/** Dec the thread count **/
SAP_DEC_THREAD_COUNT("Wan Start 1 Error", NULL);
/** Log the error **/
SsLogEvent(NWSAP_EVENT_STARTWANWORKER_ERROR, 0, NULL, Error);
/** Return Error **/
return -1;
}
/** We can close this handle **/
CloseHandle(Handle);
/**
Create the wait thread.
We count this thread as running before we start it
for synchronization. If the start fails - then we will
dec this count
**/
for (i = 0 ; i < SapNumWanNotifyThreads ; i++) {
SAP_INC_THREAD_COUNT("Wan Start 2", NULL);
/** Start the thread **/
SapWanNotifyHandlesBuf[i] = CreateThread(
NULL, /* Security Ptr */
0, /* Initial stack size */
SapWanCheckThread, /* Thread Function */
(LPVOID)i, /* Parm for the thread */
0, /* Creation Flags */
&Threadid); /* Ptr to thread id */
if (SapWanNotifyHandlesBuf[i] == NULL) {
/** **/
Error = GetLastError();
IF_DEBUG(INITIALIZATION_ERRORS) {
SS_PRINT(("NWSAP: Error starting WAN check thread = %d\n", Error));
}
/** Dec the thread count **/
SAP_DEC_THREAD_COUNT("Wan Start 2 Error", NULL);
/** Log the error **/
SsLogEvent(NWSAP_EVENT_STARTWANCHECK_ERROR, 0, NULL, Error);
/** Return Error **/
return -1;
}
}
/** Init OK **/
return 0;
}
/*++
*******************************************************************
S a p W a n S h u t d o w n
Routine Description:
When we are terminating, this routine will clean
up everything.
Arguments:
None
Return Value:
Nothing
*******************************************************************
--*/
VOID
SapWanShutdown(
VOID)
{
PLIST_ENTRY Listp;
PSAP_WANTRACK Wanp;
/** Close the semaphore handle **/
if (SapWanSem != NULL)
CloseHandle(SapWanSem);
/** Close the handle **/
if (SapWanSocket != INVALID_SOCKET)
closesocket(SapWanSocket);
/** Cleanup the free list **/
while (!IsListEmpty(&SapWanRecvList)) {
Listp = RemoveHeadList(&SapWanRecvList);
Wanp = CONTAINING_RECORD(Listp, SAP_WANTRACK, ListEntry);
SAP_FREE(Wanp, "Wan Shutdown Recv List");
}
while (!IsListEmpty(&SapWanFreeList)) {
Listp = RemoveHeadList(&SapWanFreeList);
Wanp = CONTAINING_RECORD(Listp, SAP_WANTRACK, ListEntry);
SAP_FREE(Wanp, "Wan Shutdown Free List");
}
/** All Done **/
return;
}
/*++
*******************************************************************
S a p W a n C h e c k T h r e a d
Routine Description:
This thread keeps a getsockopt down to the IPX driver
to look for WANs that are going up or down.
Arguments:
Threadparm = Thread parameter from CreateThread
Return Value:
0 Always
*******************************************************************
--*/
DWORD WINAPI
SapWanCheckThread(
LPVOID Threadparm)
{
PSAP_WANTRACK Trackp;
PLIST_ENTRY Listp;
INT Length;
INT rc;
DWORD Error;
INT Index;
/** **/
Index = (INT)Threadparm;
/** **/
while (1) {
/** Get a buffer to do this with **/
ACQUIRE_WANFREETABLE_LOCK();
if (SapWanCurFree) {
Listp = RemoveHeadList(&SapWanFreeList);
Trackp = CONTAINING_RECORD(Listp, SAP_WANTRACK, ListEntry);
SapWanCurFree--;
}
else {
Trackp = SAP_MALLOC(SAP_WANTRACK_SIZE, "Alloc Trackp");
}
RELEASE_WANFREETABLE_LOCK();
/** If no memory **/
if (Trackp == NULL) {
IF_DEBUG(ERRORS) {
SS_PRINT(("WanCheckThread: No memory\n"));
}
break;
}
/** Set the handle that we use for waiting on the event **/
Trackp->Data.EventHandle = SapWanEvent;
/** Issue the Getsockopt **/
Length = sizeof(IPX_ADDRESS_DATA_EXTENDED);
rc = getsockopt(
SapWanSocket,
NSPROTO_IPX,
IPX_ADDRESS_NOTIFY,
(PVOID)&Trackp->Data,
&Length);
/** If we get an error - just free the entry and bomb out **/
if (rc == -1) {
Error = h_errno;
IF_DEBUG(ERRORS) {
SS_PRINT(("WanCheckThread: terminate w/error 1 = %d\n", Error));
}
SAP_FREE(Trackp, "ADDR NOTIFY ERROR");
break;
}
/** Wait on the event to signal **/
Error = WaitForSingleObject(SapWanEvent, INFINITE);
/** If the wait failed - just free the entry and bomb out **/
if (Error == 0xFFFFFFFF) {
Error = GetLastError();
IF_DEBUG(ERRORS) {
SS_PRINT(("WanCheckThread: terminate w/error 2 = %d\n", Error));
}
SAP_FREE(Trackp, "ADDR WAIT ERROR");
break;
}
/**
If the server is going down - get out now
**/
if (!SsInitialized) {
SAP_FREE(Trackp, "Wan - Server down");
break;
}
/** Put the entry in the list **/
InitializeListHead(&Trackp->ListEntry);
ACQUIRE_WANRECVTABLE_LOCK();
InsertTailList(&SapWanRecvList, &Trackp->ListEntry);
SapWanCurBackup++;
RELEASE_WANRECVTABLE_LOCK();
/** Release the semaphore to run the worker thread **/
ReleaseSemaphore(SapWanSem, 1, NULL);
}
/**
Take us out of the table
**/
ACQUIRE_THREADCOUNT_LOCK();
if (SapWanNotifyHandlesBuf) {
if (SapWanNotifyHandlesBuf[Index]) {
SapWanNotifyHandlesBuf[Index] = NULL;
RELEASE_THREADCOUNT_LOCK();
SAP_DEC_THREAD_COUNT("Wan Check Thread Termination", NULL);
}
else {
RELEASE_THREADCOUNT_LOCK();
}
}
else {
RELEASE_THREADCOUNT_LOCK();
}
/** Just leave **/
return 0;
}
/*++
*******************************************************************
S a p W a n W o r k e r T h r e a d
Routine Description:
This thread takes blocks from the SapWanCheckThread
and processes them.
Arguments:
Threadparm = Thread parameter from CreateThread
Return Value:
0 Always
*******************************************************************
--*/
DWORD WINAPI
SapWanWorkerThread(
LPVOID Threadparm)
{
NTSTATUS Status;
PSAP_WANTRACK Trackp;
PLIST_ENTRY Listp;
/** **/
while (SsInitialized) {
/** Wait for a request to show up **/
Status = WaitForSingleObjectEx(SapWanSem, INFINITE, TRUE);
/** If stopping - just leave **/
if (!SsInitialized) {
IF_DEBUG(TERMINATION) {
SS_PRINT(("NWSAP: Wan Worker Thread: Breaking out for stop\n"));
}
break;
}
/** If error - just ignore it **/
if (!NT_SUCCESS(Status)) {
IF_DEBUG(ERRORS) {
SS_PRINT(("NWSAP: Wan Worker: Wait failed: Status = 0x%lx\n", Status));
}
continue;
}
/** Get ownership of the worker list **/
ACQUIRE_WANRECVTABLE_LOCK();
/** Get an entry from the list **/
if (!IsListEmpty(&SapWanRecvList)) {
SS_ASSERT(SapWanCurBackup != 0);
Listp = RemoveHeadList(&SapWanRecvList);
Trackp = CONTAINING_RECORD(Listp, SAP_WANTRACK, ListEntry);
SapWanCurBackup--;
}
else {
SS_ASSERT(SapWanCurBackup == 0);
Trackp = NULL;
}
/** Release the lock on the list **/
RELEASE_WANRECVTABLE_LOCK();
/** If no packet - error **/
if (Trackp == NULL) {
IF_DEBUG(ERRORS) {
SS_PRINT(("NWSAP: WAN WORKER: Wait came back but no block ready\n"));
}
continue;
}
/** Handle the data here **/
if (Trackp->Data.IpxData.status == TRUE)
SapWanCardUp(&Trackp->Data.IpxData);
else
SapWanCardDown(&Trackp->Data.IpxData);
/**
If there is room in the FREE list - then put
this entry in the free list, else just free
the memory back to heap.
**/
ACQUIRE_WANFREETABLE_LOCK();
if (SapWanCurFree < SapWanMaxFree) {
InsertTailList(&SapWanFreeList, &Trackp->ListEntry);
SapWanCurFree++;
}
else {
SAP_FREE(Trackp, "FREE WAN TRACK 1");
}
RELEASE_WANFREETABLE_LOCK();
}
/** We are terminating - uncount and set event if need to **/
SAP_DEC_THREAD_COUNT("Wan Worker Terminate", NULL);
/** All Done **/
return 0;
}
/*++
*******************************************************************
S a p W a n C a r d U p
Routine Description:
This routine is called when a new adapter is added. We
will handle setting up this new adapter.
Arguments:
IpxData = Ptr to an IPX_ADDRESS_DATA structure that we
got from the transport
Return Value:
Nothing
*******************************************************************
--*/
VOID
SapWanCardUp(
PIPX_ADDRESS_DATA IpxData)
{
PSAP_CARD Cardptr;
INT Retcode;
/** Make sure that this card does not already exist **/
IF_DEBUG(WAN) {
SS_PRINT(("NWSAP: SapWanCardUp: Adapnum = %d\n", IpxData->adapternum));
}
ACQUIRE_CARDLIST_WRITERS_LOCK(Retcode, "Wancheck up 1");
if (Retcode) {
IF_DEBUG(ERRORS) {
SS_PRINT(("NWSAP: SapWanCardUp: Error getting card writers lock\n"));
}
return;
}
Cardptr = SapCardHead;
while (Cardptr) {
if (Cardptr->Number == IpxData->adapternum)
break;
Cardptr = Cardptr->Next;
}
/** If card already here - just leave **/
if (Cardptr) {
RELEASE_CARDLIST_WRITERS_LOCK("Wancheck up 1");
return;
}
/** Allocate an entry for this card **/
Cardptr = SAP_MALLOC(SAP_CARD_SIZE, "SapWanCardUp");
if (Cardptr == NULL) {
/** Release the lock **/
RELEASE_CARDLIST_WRITERS_LOCK("Wancheck up 2");
IF_DEBUG(ERRORS) {
SS_PRINT(("NWSAP: SapWanCardUp: Error allocating memory\n"));
}
/** Log the error **/
SsLogEvent(
NWSAP_EVENT_CARDMALLOC_FAILED,
0,
NULL,
0);
/** And Leave **/
return;
}
/** Fill in this card **/
Cardptr->Next = NULL;
SAP_COPY_NETNUM(Cardptr->Netnum, IpxData->netnum);
SAP_COPY_NODENUM(Cardptr->Nodenum, IpxData->nodenum);
Cardptr->Linkspeed = IpxData->linkspeed;
Cardptr->Wanflag = IpxData->wan;
Cardptr->Maxpkt = IpxData->maxpkt;
Cardptr->Number = (UCHAR)IpxData->adapternum;
Cardptr->ReqCount = 1; /* Send one extra general request */
/** For building with **/
Cardptr->Plist.Curnum = 0;
Cardptr->Plist.Curpkt = NULL;
Cardptr->Plist.Curptr = NULL;
Cardptr->Plist.PktHead = NULL;
Cardptr->Plist.PktTail = NULL;
Cardptr->Plist.NumPkts = 0;
/** Put this card in the list **/
if (SapCardHead)
SapCardTail->Next = Cardptr;
else
SapCardHead = Cardptr;
SapCardTail = Cardptr;
SapNumCards++; /* Count the card */
/**
If we are still starting up - then
we just leave. If not, then we send
a general request on this netnum.
**/
if (SapCardInitDone == 0) {
RELEASE_CARDLIST_WRITERS_LOCK("WanCardUp X1");
return;
}
/**
Send a general request on this network number to
get our table filled up for this network
**/
RELEASE_CARDLIST_WRITERS_LOCK("WanCardUp X2");
SapSendGeneralRequest(FALSE, IpxData->netnum);
/** All Done **/
return;
}
/*++
*******************************************************************
S a p W a n C a r d D o w n
Routine Description:
This routine is called when an adapter is removed from the
transports list. We cleanup everything that had to do with
this adapter.
Arguments:
IpxData = Ptr to an IPX_ADDRESS_DATA structure that we
got from the transport
Return Value:
Nothing
*******************************************************************
--*/
VOID
SapWanCardDown(
PIPX_ADDRESS_DATA IpxData)
{
PSAP_CARD Cardptr;
PSAP_CARD BCardptr;
INT Status;
INT Cardnum;
/** **/
IF_DEBUG(WAN) {
SS_PRINT(("NWSAP: SapWanCardDown: Adapnum = %d\n", IpxData->adapternum));
}
/** Take the entry out of the card list **/
Cardnum = IpxData->adapternum;
ACQUIRE_CARDLIST_WRITERS_LOCK(Status, "WanCardDown");
if (Status) {
IF_DEBUG(ERRORS) {
SS_PRINT(("NWSAP: SapWanCardDown: Error getting cardlist writers lock\n"));
}
return;
}
/** **/
Cardptr = SapCardHead;
BCardptr = NULL;
while (Cardptr) {
/** If this is it - take it out of the list **/
if (Cardptr->Number == Cardnum) {
if (BCardptr)
BCardptr->Next = Cardptr->Next;
else
SapCardHead = Cardptr->Next;
if (Cardptr == SapCardTail)
SapCardTail = BCardptr;
SapNumCards--; /* Uncount the card */
break;
}
/** Goto the next entry **/
BCardptr = Cardptr;
Cardptr = Cardptr->Next;
}
/**
If we are still starting up - then
we just leave. If not, then we need to go
cleanup for this card.
**/
if (SapCardInitDone == 0) {
RELEASE_CARDLIST_WRITERS_LOCK("WanCardDown X1");
return;
}
/** Go shutdown the card now **/
RELEASE_CARDLIST_WRITERS_LOCK("WanCardDown X2");
if (Cardptr)
SapCleanupDownedCard(Cardnum);
/** All Done **/
return;
}
/*++
*******************************************************************
S a p R e c h e c k A l l C a r d s
Routine Description:
This routine goes thru and checks all cards occassionally
to make sure that they are still valid. This is called
from the send thread.
Arguments:
None
Return Value:
Nothing
*******************************************************************
--*/
VOID
SapRecheckAllCards(
VOID)
{
INT Cardnum;
INT rc;
INT Length;
IPX_ADDRESS_DATA Addrdata;
/** Get the list of cards we have **/
Cardnum = 0;
while (Cardnum != SapMaxCardIndex) {
/** Fill in this entry **/
Addrdata.adapternum = Cardnum;
Length = sizeof(IPX_ADDRESS_DATA);
rc = getsockopt(
SapSocket,
NSPROTO_IPX,
IPX_ADDRESS,
(PCHAR)&Addrdata,
&Length);
/**
If this card is active - call to make sure it
is in our list.
If this card is inactive - call to make sure it
is not in our list.
Only check this if the getsockopt was OK.
**/
if (rc == 0) {
if (Addrdata.status == TRUE)
SapWanCardUp(&Addrdata);
else
SapWanCardDown(&Addrdata);
}
/** Goto the next card number **/
Cardnum++;
}
/** All Done **/
return;
}
/*++
*******************************************************************
S a p C h e c k S e n d G e n e r a l R e q u e s t
Routine Description:
This routine is called by the main send thread to check
if we need to send a GENERAL REQUEST out.
When a WAN card comes up, we send a general request.
We send the request multiple times in case it got
missed.
Arguments:
None
Return Value:
Nothing
*******************************************************************
--*/
#define SAPMAX_GENREQBUF 40 /* Max we can do at once */
VOID
SapCheckSendGeneralRequest(
VOID)
{
PSAP_CARD Cardptr;
PUCHAR NetPtr;
UCHAR NetBuf[SAPMAX_GENREQBUF * SAP_NET_LEN];
INT NumNets = 0;
/**
Even though we change the cards ReqCount entry
here, we get a READERS lock because No one else
is allowed to change this.
**/
ACQUIRE_CARDLIST_READERS_LOCK("CheckSendGenReq Entry");
/**
See if any cards need the advertise sent again. We
keep a count in the card structure for this.
If we find one - copy the network number to a
private buffer for us to send out of later.
**/
NetPtr = NetBuf;
Cardptr = SapCardHead;
while (Cardptr) {
if (Cardptr->ReqCount) {
/** Dec the send again count on this adapter **/
Cardptr->ReqCount--;
/** Save off the network number **/
SAP_COPY_NETNUM(NetPtr, Cardptr->Netnum);
NetPtr += SAP_NET_LEN;
/** If we hit max - just dump out **/
NumNets++;
if (NumNets == SAPMAX_GENREQBUF)
break;
}
Cardptr = Cardptr->Next;
}
RELEASE_CARDLIST_READERS_LOCK("CheckSendGenReq X1");
/**
Send a general request on this network number to
get our table filled up for this network
**/
NetPtr = NetBuf;
while (NumNets--) {
SapSendGeneralRequest(FALSE, NetPtr);
NetPtr += SAP_NET_LEN;
}
/** All Done **/
return;
}
