/********************************************************************/
/** Microsoft LAN Manager **/
/** Copyright(c) Microsoft Corp., 1990-1993 **/
/********************************************************************/
/* :ts=4 */
//** DGRAM.C - Common datagram protocol code.
//
// This file contains the code common to both UDP and Raw IP.
//
#include "oscfg.h"
#include "ndis.h"
#include "cxport.h"
#include "ip.h"
#include "tdi.h"
#include "tdistat.h"
#ifdef VXD
#include "tdivxd.h"
#endif
#ifdef NT
#include "tdint.h"
#include "tdistat.h"
#endif
#include "queue.h"
#include "addr.h"
#include "dgram.h"
#include "tlcommon.h"
#include "info.h"
#define NO_TCP_DEFS 1
#include "tcpdeb.h"
#ifdef NT
#ifdef POOL_TAGGING
#ifdef ExAllocatePool
#undef ExAllocatePool
#endif
#define ExAllocatePool(type, size) ExAllocatePoolWithTag(type, size, 'dPCT')
#ifndef CTEAllocMem
#error "CTEAllocMem is not already defined - will override tagging"
#else
#undef CTEAllocMem
#endif
#define CTEAllocMem(size) ExAllocatePoolWithTag(NonPagedPool, size, 'dPCT')
#endif // POOL_TAGGING
#endif // NT
#define NUM_DG_HEADERS 5
#ifdef NT
#define DG_MAX_HDRS 0xffff
#else
#define DG_MAX_HDRS 100
#endif
ulong DGCurrentSendFree = 0;
ulong DGMaxSendFree = DG_MAX_HDRS;
EXTERNAL_LOCK(AddrObjTableLock)
DGSendReq *DGSendReqFree;
DEFINE_LOCK_STRUCTURE(DGSendReqLock)
#ifndef NT
DGRcvReq *DGRcvReqFree;
#else
SLIST_HEADER DGRcvReqFree;
#endif
DEFINE_LOCK_STRUCTURE(DGRcvReqFreeLock)
#ifdef DEBUG
uint NumSendReq = 0;
uint NumRcvReq = 0;
#endif
// Information for maintaining the DG Header structures and
// pending queue.
uint DGHeaderSize;
PNDIS_BUFFER DGHeaderList;
Queue DGHeaderPending;
Queue DGDelayed;
CTEEvent DGDelayedEvent;
extern IPInfo LocalNetInfo;
typedef struct DGHdrBPoolEntry {
struct DGHdrBPoolEntry *uhe_next;
NDIS_HANDLE uhe_handle;
uchar *uhe_buffer;
} DGHdrBPoolEntry;
DGHdrBPoolEntry *DGHdrBPoolList = NULL;
//
// All of the init code can be discarded.
//
#ifdef NT
#ifdef ALLOC_PRAGMA
int InitDG(uint MaxHeaderSize);
#pragma alloc_text(INIT, InitDG)
#endif // ALLOC_PRAGMA
#endif
#ifdef CHICAGO
extern int RegisterAddrChangeHndlr(void *Handler, uint Add);
extern void AddrChange(IPAddr Addr, IPMask Mask, void *Context,
uint Added);
#endif
//* GrowDGHeaderList - Try to grow the DG header list.
//
// Called when we run out of buffers on the DG header list, and need
// to grow it. We look to see if we're already at the maximum size, and
// if not we'll allocate the need structures and free them to the list.
// This routine must be called with the SendReq lock held.
//
// Input: Nothing.
//
// Returns: A pointer to a new DG header buffer if we have one, or NULL.
//
PNDIS_BUFFER
GrowDGHeaderList(void)
{
DGHdrBPoolEntry *NewEntry;
NDIS_STATUS Status;
uint HeaderSize;
uchar *DGSendHP;
uint i;
PNDIS_BUFFER Buffer;
PNDIS_BUFFER ReturnBuffer = NULL;
if (DGCurrentSendFree < DGMaxSendFree) {
// Still room to grow the list.
NewEntry = CTEAllocMem(sizeof(DGHdrBPoolEntry));
if (NewEntry == NULL) {
// Couldn't get the memory.
return NULL;
}
NdisAllocateBufferPool(&Status, &NewEntry->uhe_handle,
NUM_DG_HEADERS);
if (Status != NDIS_STATUS_SUCCESS) {
// Couldn't get a new set of buffers. Fail.
CTEFreeMem(NewEntry);
return NULL;
}
HeaderSize = DGHeaderSize + LocalNetInfo.ipi_hsize;
DGSendHP = CTEAllocMem(HeaderSize * NUM_DG_HEADERS);
if (DGSendHP == NULL) {
NdisFreeBufferPool(NewEntry->uhe_handle);
CTEFreeMem(NewEntry);
return NULL;
}
NewEntry->uhe_buffer = DGSendHP;
for (i = 0; i < NUM_DG_HEADERS; i++) {
NdisAllocateBuffer(&Status, &Buffer, NewEntry->uhe_handle,
DGSendHP + (i * HeaderSize), HeaderSize);
if (Status != NDIS_STATUS_SUCCESS) {
NdisFreeBufferPool(NewEntry->uhe_handle);
CTEFreeMem(NewEntry);
CTEFreeMem(DGSendHP);
return NULL;
}
if (i != 0)
FreeDGHeader(Buffer);
else
ReturnBuffer = Buffer;
}
DGCurrentSendFree += NUM_DG_HEADERS;
NewEntry->uhe_next = DGHdrBPoolList;
DGHdrBPoolList = NewEntry;
} else {
// At the limit already.
ReturnBuffer = NULL;
}
return ReturnBuffer;
}
//* GetDGHeader - Get a DG header buffer.
//
// The get header buffer routine. Called with the SendReqLock held.
//
// Input: Nothing.
//
// Output: A pointer to an NDIS buffer, or NULL.
//
_inline PNDIS_BUFFER
GetDGHeader(void)
{
PNDIS_BUFFER NewBuffer;
NewBuffer = DGHeaderList;
if (NewBuffer != NULL)
DGHeaderList = NDIS_BUFFER_LINKAGE(NewBuffer);
else
NewBuffer = GrowDGHeaderList();
return NewBuffer;
}
//* FreeDGHeader - Free a DG header buffer.
//
// The free header buffer routine. Called with the SendReqLock held.
//
// Input: Buffer to be freed.
//
// Output: Nothing.
//
void
FreeDGHeader(PNDIS_BUFFER FreedBuffer)
{
NDIS_BUFFER_LINKAGE(FreedBuffer) = DGHeaderList;
DGHeaderList = FreedBuffer;
}
//* PutPendingQ - Put an address object on the pending queue.
//
// Called when we've experienced a header buffer out of resources condition,
// and want to queue an AddrObj for later processing. We put the specified
// address object on the DGHeaderPending queue, set the OOR flag and clear
// the 'send request' flag. It is invariant in the system that the send
// request flag and the OOR flag are not set at the same time.
//
// This routine assumes that the caller holds the DGSendReqLock and the
// lock on the particular AddrObj.
//
// Input: QueueingAO - Pointer to address object to be queued.
//
// Returns: Nothing.
//
void
PutPendingQ(AddrObj *QueueingAO)
{
CTEStructAssert(QueueingAO, ao);
if (!AO_OOR(QueueingAO)) {
CLEAR_AO_REQUEST(QueueingAO, AO_SEND);
SET_AO_OOR(QueueingAO);
ENQUEUE(&DGHeaderPending, &QueueingAO->ao_pendq);
}
}
//* GetDGSendReq - Get a DG send request.
//
// Called when someone wants to allocate a DG send request. We assume
// the send request lock is held when we are called.
//
// Note: This routine and the corresponding free routine might
// be good candidates for inlining.
//
// Input: Nothing.
//
// Returns: Pointer to the SendReq, or NULL if none.
//
DGSendReq *
GetDGSendReq()
{
DGSendReq *NewReq;
NewReq = DGSendReqFree;
if (NewReq != NULL) {
CTEStructAssert(NewReq, dsr);
DGSendReqFree = (DGSendReq *)NewReq->dsr_q.q_next;
} else {
// Couldn't get a request, grow it. This is one area where we'll try
// to allocate memory with a lock held. Because of this, we've
// got to be careful about where we call this routine from.
NewReq = CTEAllocMem(sizeof(DGSendReq));
if (NewReq != NULL) {
#ifdef DEBUG
NewReq->dsr_sig = dsr_signature;
NumSendReq++;
#endif
}
}
return NewReq;
}
//* FreeDGSendReq - Free a DG send request.
//
// Called when someone wants to free a DG send request. It's assumed
// that the caller holds the SendRequest lock.
//
// Input: SendReq - SendReq to be freed.
//
// Returns: Nothing.
//
void
FreeDGSendReq(DGSendReq *SendReq)
{
CTEStructAssert(SendReq, dsr);
*(DGSendReq **)&SendReq->dsr_q.q_next = DGSendReqFree;
DGSendReqFree = SendReq;
}
//* GetDGRcvReq - Get a DG receive request.
//
// Called when we need to get a DG receive request.
//
// Input: Nothing.
//
// Returns: Pointer to new request, or NULL if none.
//
DGRcvReq *
GetDGRcvReq()
{
DGRcvReq *NewReq;
#ifdef VXD
NewReq = DGRcvReqFree;
if (NewReq != NULL) {
CTEStructAssert(NewReq, drr);
DGRcvReqFree = (DGRcvReq *)NewReq->drr_q.q_next;
} else {
// Couldn't get a request, grow it.
NewReq = CTEAllocMem(sizeof(DGRcvReq));
if (NewReq != NULL) {
#ifdef DEBUG
NewReq->drr_sig = drr_signature;
NumRcvReq++;
#endif
}
}
#endif // VXD
#ifdef NT
PSINGLE_LIST_ENTRY BufferLink;
Queue *QueuePtr;
BufferLink = ExInterlockedPopEntrySList(
&DGRcvReqFree,
&DGRcvReqFreeLock
);
if (BufferLink != NULL) {
QueuePtr = STRUCT_OF(Queue, BufferLink, q_next);
NewReq = STRUCT_OF(DGRcvReq, QueuePtr, drr_q);
CTEStructAssert(NewReq, drr);
}
else {
// Couldn't get a request, grow it.
NewReq = CTEAllocMem(sizeof(DGRcvReq));
if (NewReq != NULL) {
#ifdef DEBUG
NewReq->drr_sig = drr_signature;
ExInterlockedAddUlong(&NumRcvReq, 1, &DGRcvReqFreeLock);
#endif
}
}
#endif // NT
return NewReq;
}
//* FreeDGRcvReq - Free a DG rcv request.
//
// Called when someone wants to free a DG rcv request.
//
// Input: RcvReq - RcvReq to be freed.
//
// Returns: Nothing.
//
void
FreeDGRcvReq(DGRcvReq *RcvReq)
{
#ifdef VXD
CTEStructAssert(RcvReq, drr);
*(DGRcvReq **)&RcvReq->drr_q.q_next = DGRcvReqFree;
DGRcvReqFree = RcvReq;
#endif // VXD
#ifdef NT
PSINGLE_LIST_ENTRY BufferLink;
CTEStructAssert(RcvReq, drr);
BufferLink = STRUCT_OF(SINGLE_LIST_ENTRY, &(RcvReq->drr_q.q_next), Next);
ExInterlockedPushEntrySList(
&DGRcvReqFree,
BufferLink,
&DGRcvReqFreeLock
);
#endif // NT
}
//* DGDelayedEventProc - Handle a delayed event.
//
// This is the delayed event handler, used for out-of-resources conditions
// on AddrObjs. We pull from the delayed queue, and is the addr obj is
// not already busy we'll send the datagram.
//
// Input: Event - Pointer to the event structure.
// Context - Nothing.
//
// Returns: Nothing
//
void
DGDelayedEventProc(CTEEvent *Event, void *Context)
{
CTELockHandle HeaderHandle, AOHandle;
AddrObj *SendingAO;
DGSendProc SendProc;
CTEGetLock(&DGSendReqLock, &HeaderHandle);
while (!EMPTYQ(&DGDelayed)) {
DEQUEUE(&DGDelayed, SendingAO, AddrObj, ao_pendq);
CTEStructAssert(SendingAO, ao);
CTEGetLock(&SendingAO->ao_lock, &AOHandle);
CLEAR_AO_OOR(SendingAO);
if (!AO_BUSY(SendingAO)) {
DGSendReq *SendReq;
if (!EMPTYQ(&SendingAO->ao_sendq)) {
DEQUEUE(&SendingAO->ao_sendq, SendReq, DGSendReq, dsr_q);
CTEStructAssert(SendReq, dsr);
CTEAssert(SendReq->dsr_header != NULL);
SendingAO->ao_usecnt++;
SendProc = SendingAO->ao_dgsend;
CTEFreeLock(&SendingAO->ao_lock, AOHandle);
CTEFreeLock(&DGSendReqLock, HeaderHandle);
(*SendProc)(SendingAO, SendReq);
DEREF_AO(SendingAO);
CTEGetLock(&DGSendReqLock, &HeaderHandle);
} else {
CTEAssert(FALSE);
CTEFreeLock(&SendingAO->ao_lock, AOHandle);
}
} else {
SET_AO_REQUEST(SendingAO, AO_SEND);
CTEFreeLock(&SendingAO->ao_lock, AOHandle);
}
}
CTEFreeLock(&DGSendReqLock, HeaderHandle);
}
//* DGSendComplete - DG send complete handler.
//
// This is the routine called by IP when a send completes. We
// take the context passed back as a pointer to a SendRequest
// structure, and complete the caller's send.
//
// Input: Context - Context we gave on send (really a
// SendRequest structure).
// BufferChain - Chain of buffers sent.
//
// Returns: Nothing.
void
DGSendComplete(void *Context, PNDIS_BUFFER BufferChain)
{
DGSendReq *FinishedSR = (DGSendReq *)Context;
CTELockHandle HeaderHandle, AOHandle;
CTEReqCmpltRtn Callback; // Completion routine.
PVOID CallbackContext; // User context.
ushort SentSize;
AddrObj *AO;
CTEStructAssert(FinishedSR, dsr);
CTEGetLock(&DGSendReqLock, &HeaderHandle);
Callback = FinishedSR->dsr_rtn;
CallbackContext = FinishedSR->dsr_context;
SentSize = FinishedSR->dsr_size;
// If there's nothing on the header pending queue, just free the
// header buffer. Otherwise pull from the pending queue, give him the
// resource, and schedule an event to deal with him.
if (EMPTYQ(&DGHeaderPending)) {
FreeDGHeader(BufferChain);
} else {
DEQUEUE(&DGHeaderPending, AO, AddrObj, ao_pendq);
CTEStructAssert(AO, ao);
CTEGetLock(&AO->ao_lock, &AOHandle);
if (!EMPTYQ(&AO->ao_sendq)) {
DGSendReq *SendReq;
PEEKQ(&AO->ao_sendq, SendReq, DGSendReq, dsr_q);
SendReq->dsr_header = BufferChain; // Give him this buffer.
ENQUEUE(&DGDelayed, &AO->ao_pendq);
CTEFreeLock(&AO->ao_lock, AOHandle);
CTEScheduleEvent(&DGDelayedEvent, NULL);
} else {
// On the pending queue, but no sends!
DEBUGCHK;
CLEAR_AO_OOR(AO);
CTEFreeLock(&AO->ao_lock, AOHandle);
}
}
FreeDGSendReq(FinishedSR);
CTEFreeLock(&DGSendReqLock, HeaderHandle);
if (Callback != NULL)
(*Callback)(CallbackContext, TDI_SUCCESS, (uint)SentSize);
}
#ifdef NT
//
// NT supports cancellation of DG send/receive requests.
//
#define TCP_DEBUG_SEND_DGRAM 0x00000100
#define TCP_DEBUG_RECEIVE_DGRAM 0x00000200
extern ULONG TCPDebug;
VOID
TdiCancelSendDatagram(
AddrObj *SrcAO,
PVOID Context
)
{
CTELockHandle lockHandle;
DGSendReq *sendReq = NULL;
Queue *qentry;
BOOLEAN found = FALSE;
CTEStructAssert(SrcAO, ao);
CTEGetLock(&SrcAO->ao_lock, &lockHandle);
// Search the send list for the specified request.
for ( qentry = QNEXT(&(SrcAO->ao_sendq));
qentry != &(SrcAO->ao_sendq);
qentry = QNEXT(qentry)
) {
sendReq = STRUCT_OF(DGSendReq, qentry, dsr_q);
CTEStructAssert(sendReq, dsr);
if (sendReq->dsr_context == Context) {
//
// Found it. Dequeue
//
REMOVEQ(qentry);
found = TRUE;
IF_TCPDBG(TCP_DEBUG_SEND_DGRAM) {
TCPTRACE((
"TdiCancelSendDatagram: Dequeued item %lx\n",
Context
));
}
break;
}
}
CTEFreeLock(&SrcAO->ao_lock, lockHandle);
if (found) {
//
// Complete the request and free its resources.
//
(*sendReq->dsr_rtn)(sendReq->dsr_context, (uint) TDI_CANCELLED, 0);
CTEGetLock(&DGSendReqLock, &lockHandle);
if (sendReq->dsr_header != NULL) {
FreeDGHeader(sendReq->dsr_header);
}
FreeDGSendReq(sendReq);
CTEFreeLock(&DGSendReqLock, lockHandle);
}
} // TdiCancelSendDatagram
VOID
TdiCancelReceiveDatagram(
AddrObj *SrcAO,
PVOID Context
)
{
CTELockHandle lockHandle;
DGRcvReq *rcvReq = NULL;
Queue *qentry;
BOOLEAN found = FALSE;
CTEStructAssert(SrcAO, ao);
CTEGetLock(&SrcAO->ao_lock, &lockHandle);
// Search the send list for the specified request.
for ( qentry = QNEXT(&(SrcAO->ao_rcvq));
qentry != &(SrcAO->ao_rcvq);
qentry = QNEXT(qentry)
) {
rcvReq = STRUCT_OF(DGRcvReq, qentry, drr_q);
CTEStructAssert(rcvReq, drr);
if (rcvReq->drr_context == Context) {
//
// Found it. Dequeue
//
REMOVEQ(qentry);
found = TRUE;
IF_TCPDBG(TCP_DEBUG_SEND_DGRAM) {
TCPTRACE((
"TdiCancelReceiveDatagram: Dequeued item %lx\n",
Context
));
}
break;
}
}
CTEFreeLock(&SrcAO->ao_lock, lockHandle);
if (found) {
//
// Complete the request and free its resources.
//
(*rcvReq->drr_rtn)(rcvReq->drr_context, (uint) TDI_CANCELLED, 0);
FreeDGRcvReq(rcvReq);
}
} // TdiCancelReceiveDatagram
#endif // NT
//** TdiSendDatagram - TDI send datagram function.
//
// This is the user interface to the send datagram function. The
// caller specified a request structure, a connection info
// structure containing the address, and data to be sent.
// This routine gets a DG Send request structure to manage the
// send, fills the structure in, and calls DGSend to deal with
// it.
//
// Input: Request - Pointer to request structure.
// ConnInfo - Pointer to ConnInfo structure which points to
// remote address.
// DataSize - Size in bytes of data to be sent.
// BytesSent - Pointer to where to return size sent.
// Buffer - Pointer to buffer chain.
//
// Returns: Status of attempt to send.
//
TDI_STATUS
TdiSendDatagram(PTDI_REQUEST Request, PTDI_CONNECTION_INFORMATION ConnInfo,
uint DataSize, uint *BytesSent, PNDIS_BUFFER Buffer)
{
AddrObj *SrcAO; // Pointer to AddrObj for src.
DGSendReq *SendReq; // Pointer to send req for this request.
CTELockHandle Handle, SRHandle; // Lock handles for the AO and the
// send request.
TDI_STATUS ReturnValue;
DGSendProc SendProc;
// First, get a send request. We do this first because of MP issues
// if we port this to NT. We need to take the SendRequest lock before
// we take the AddrObj lock, to prevent deadlock and also because
// GetDGSendReq might yield, and the state of the AddrObj might
// change on us, so we don't want to yield after we've validated
// it.
CTEGetLock(&DGSendReqLock, &SRHandle);
SendReq = GetDGSendReq();
// Now get the lock on the AO, and make sure it's valid. We do this
// to make sure we return the correct error code.
#ifdef VXD
SrcAO = GetIndexedAO((uint)Request->Handle.AddressHandle);
if (SrcAO != NULL) {
#else
SrcAO = Request->Handle.AddressHandle;
#endif
CTEStructAssert(SrcAO, ao);
CTEGetLock(&SrcAO->ao_lock, &Handle);
if (AO_VALID(SrcAO)) {
// Make sure the size is reasonable.
if (DataSize <= SrcAO->ao_maxdgsize) {
// The AddrObj is valid. Now fill the address into the send request,
// if we've got one. If this works, we'll continue with the
// send.
if (SendReq != NULL) { // Got a send request.
if (GetAddress(ConnInfo->RemoteAddress, &SendReq->dsr_addr,
&SendReq->dsr_port)) {
SendReq->dsr_rtn = Request->RequestNotifyObject;
SendReq->dsr_context = Request->RequestContext;
SendReq->dsr_buffer = Buffer;
SendReq->dsr_size = (ushort)DataSize;
// We've filled in the send request. If the AO isn't
// already busy, try to get a DG header buffer and send
// this. If the AO is busy, or we can't get a buffer, queue
// until later. We try to get the header buffer here, as
// an optimazation to avoid having to retake the lock.
if (!AO_OOR(SrcAO)) { // AO isn't out of resources
if (!AO_BUSY(SrcAO)) { // or or busy
if ((SendReq->dsr_header = GetDGHeader()) != NULL) {
REF_AO(SrcAO); // Lock out exclusive
// activities.
SendProc = SrcAO->ao_dgsend;
CTEFreeLock(&SrcAO->ao_lock, Handle);
CTEFreeLock(&DGSendReqLock, SRHandle);
// Allright, just send it.
(*SendProc)(SrcAO, SendReq);
// See if any pending requests occured during
// the send. If so, call the request handler.
DEREF_AO(SrcAO);
return TDI_PENDING;
} else {
// We couldn't get a header buffer. Put this
// guy on the pending queue, and then fall
// through to the 'queue request' code.
PutPendingQ(SrcAO);
}
} else {
// AO is busy, set request for later
SET_AO_REQUEST(SrcAO, AO_SEND);
}
}
// AO is busy, or out of resources. Queue the send request
// for later.
SendReq->dsr_header = NULL;
ENQUEUE(&SrcAO->ao_sendq, &SendReq->dsr_q);
SendReq = NULL;
ReturnValue = TDI_PENDING;
}
else {
// The remote address was invalid.
ReturnValue = TDI_BAD_ADDR;
}
}
else {
// Send request was null, return no resources.
ReturnValue = TDI_NO_RESOURCES;
}
}
else {
// Buffer was too big, return an error.
ReturnValue = TDI_BUFFER_TOO_BIG;
}
}
else {
// The addr object is invalid, possibly because it's deleting.
ReturnValue = TDI_ADDR_INVALID;
}
CTEFreeLock(&SrcAO->ao_lock, Handle);
#ifdef VXD
}
else {
ReturnValue = TDI_ADDR_INVALID;
}
#endif
if (SendReq != NULL)
FreeDGSendReq(SendReq);
CTEFreeLock(&DGSendReqLock, SRHandle);
return TDI_ADDR_INVALID;
}
//** TdiReceiveDatagram - TDI receive datagram function.
//
// This is the user interface to the receive datagram function. The
// caller specifies a request structure, a connection info
// structure that acts as a filter on acceptable datagrams, a connection
// info structure to be filled in, and other parameters. We get a DGRcvReq
// structure, fill it in, and hang it on the AddrObj, where it will be removed
// later by incomig datagram handler.
//
// Input: Request - Pointer to request structure.
// ConnInfo - Pointer to ConnInfo structure which points to
// remote address.
// ReturnInfo - Pointer to ConnInfo structure to be filled in.
// RcvSize - Total size in bytes receive buffer.
// BytesRcvd - Pointer to where to return size received.
// Buffer - Pointer to buffer chain.
//
// Returns: Status of attempt to receive.
//
TDI_STATUS
TdiReceiveDatagram(PTDI_REQUEST Request, PTDI_CONNECTION_INFORMATION ConnInfo,
PTDI_CONNECTION_INFORMATION ReturnInfo, uint RcvSize, uint *BytesRcvd,
PNDIS_BUFFER Buffer)
{
AddrObj *RcvAO; // AddrObj that is receiving.
DGRcvReq *RcvReq; // Receive request structure.
CTELockHandle AOHandle;
uchar AddrValid;
RcvReq = GetDGRcvReq();
#ifdef VXD
RcvAO = GetIndexedAO((uint)Request->Handle.AddressHandle);
if (RcvAO != NULL) {
CTEStructAssert(RcvAO, ao);
#else
RcvAO = Request->Handle.AddressHandle;
CTEStructAssert(RcvAO, ao);
#endif
CTEGetLock(&RcvAO->ao_lock, &AOHandle);
if (AO_VALID(RcvAO)) {
IF_TCPDBG(TCP_DEBUG_RAW) {
TCPTRACE(("posting receive on AO %lx\n", RcvAO));
}
if (RcvReq != NULL) {
if (ConnInfo != NULL && ConnInfo->RemoteAddressLength != 0)
AddrValid = GetAddress(ConnInfo->RemoteAddress,
&RcvReq->drr_addr, &RcvReq->drr_port);
else {
AddrValid = TRUE;
RcvReq->drr_addr = NULL_IP_ADDR;
RcvReq->drr_port = 0;
}
if (AddrValid) {
// Everything'd valid. Fill in the receive request and queue it.
RcvReq->drr_conninfo = ReturnInfo;
RcvReq->drr_rtn = Request->RequestNotifyObject;
RcvReq->drr_context = Request->RequestContext;
RcvReq->drr_buffer = Buffer;
RcvReq->drr_size = RcvSize;
ENQUEUE(&RcvAO->ao_rcvq, &RcvReq->drr_q);
CTEFreeLock(&RcvAO->ao_lock, AOHandle);
return TDI_PENDING;
} else {
// Have an invalid filter address.
CTEFreeLock(&RcvAO->ao_lock, AOHandle);
FreeDGRcvReq(RcvReq);
return TDI_BAD_ADDR;
}
} else {
// Couldn't get a receive request.
CTEFreeLock(&RcvAO->ao_lock, AOHandle);
return TDI_NO_RESOURCES;
}
} else {
// The AddrObj isn't valid.
CTEFreeLock(&RcvAO->ao_lock, AOHandle);
}
#ifdef VXD
}
#endif
// The AddrObj is invalid or non-existent.
if (RcvReq != NULL)
FreeDGRcvReq(RcvReq);
return TDI_ADDR_INVALID;
}
#pragma BEGIN_INIT
//* InitDG - Initialize the DG stuff.
//
// Called during init time to initalize the DG code. We initialize
// our locks and request lists.
//
// Input: MaxHeaderSize - The maximum size of a datagram transport header,
// not including the IP header.
//
// Returns: True if we succeed, False if we fail.
//
int
InitDG(uint MaxHeaderSize)
{
PNDIS_BUFFER Buffer;
CTELockHandle Handle;
DGHeaderSize = MaxHeaderSize;
CTEInitLock(&DGSendReqLock);
CTEInitLock(&DGRcvReqFreeLock);
DGSendReqFree = NULL;
#ifndef NT
DGRcvReqFree = NULL;
#else
ExInitializeSListHead(&DGRcvReqFree);
#endif
CTEGetLock(&DGSendReqLock, &Handle);
Buffer = GrowDGHeaderList();
if (Buffer != NULL) {
FreeDGHeader(Buffer);
CTEFreeLock(&DGSendReqLock, Handle);
} else {
CTEFreeLock(&DGSendReqLock, Handle);
return FALSE;
}
INITQ(&DGHeaderPending);
INITQ(&DGDelayed);
CTEInitEvent(&DGDelayedEvent, DGDelayedEventProc);
return TRUE;
}
#pragma END_INIT
