696 lines
24 KiB
C
696 lines
24 KiB
C
|
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil -*- (for GNU Emacs)
|
||
|
|
//
|
||
|
|
// Copyright (c) 1985-2000 Microsoft Corporation
|
||
|
|
//
|
||
|
|
// This file is part of the Microsoft Research IPv6 Network Protocol Stack.
|
||
|
|
// You should have received a copy of the Microsoft End-User License Agreement
|
||
|
|
// for this software along with this release; see the file "license.txt".
|
||
|
|
// If not, please see http://www.research.microsoft.com/msripv6/license.htm,
|
||
|
|
// or write to Microsoft Research, One Microsoft Way, Redmond, WA 98052-6399.
|
||
|
|
//
|
||
|
|
// Abstract:
|
||
|
|
//
|
||
|
|
// Raw IP interface code. This file contains the code for the raw IP
|
||
|
|
// interface functions, principally send and receive datagram.
|
||
|
|
//
|
||
|
|
|
||
|
|
|
||
|
|
#include "oscfg.h"
|
||
|
|
#include "ndis.h"
|
||
|
|
#include "ip6imp.h"
|
||
|
|
#include "ip6def.h"
|
||
|
|
#include "tdi.h"
|
||
|
|
#include "tdistat.h"
|
||
|
|
#include "tdint.h"
|
||
|
|
#include "tdistat.h"
|
||
|
|
#include "queue.h"
|
||
|
|
#include "transprt.h"
|
||
|
|
#include "addr.h"
|
||
|
|
#include "raw.h"
|
||
|
|
#include "info.h"
|
||
|
|
#include "route.h"
|
||
|
|
#include "security.h"
|
||
|
|
|
||
|
|
#define NO_TCP_DEFS 1
|
||
|
|
#include "tcpdeb.h"
|
||
|
|
|
||
|
|
//
|
||
|
|
// REVIEW: Shouldn't this be in an include file somewhere?
|
||
|
|
//
|
||
|
|
#ifdef POOL_TAGGING
|
||
|
|
|
||
|
|
#ifdef ExAllocatePool
|
||
|
|
#undef ExAllocatePool
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#define ExAllocatePool(type, size) ExAllocatePoolWithTag(type, size, '6WAR')
|
||
|
|
|
||
|
|
#endif // POOL_TAGGING
|
||
|
|
|
||
|
|
|
||
|
|
extern KSPIN_LOCK AddrObjTableLock;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
//* RawSend - Send a raw datagram.
|
||
|
|
//
|
||
|
|
// The real send datagram routine. We assume that the busy bit is
|
||
|
|
// set on the input AddrObj, and that the address of the SendReq
|
||
|
|
// has been verified.
|
||
|
|
//
|
||
|
|
// We start by sending the input datagram, and we loop until there's
|
||
|
|
// nothing left on the send queue.
|
||
|
|
//
|
||
|
|
void // Returns: Nothing.
|
||
|
|
RawSend(
|
||
|
|
AddrObj *SrcAO, // Address Object of endpoint doing the send.
|
||
|
|
DGSendReq *SendReq) // Datagram send request describing the send.
|
||
|
|
{
|
||
|
|
KIRQL Irql0;
|
||
|
|
RouteCacheEntry *RCE;
|
||
|
|
NetTableEntryOrInterface *NTEorIF;
|
||
|
|
NetTableEntry *NTE;
|
||
|
|
Interface *IF;
|
||
|
|
IPv6Header UNALIGNED *IP;
|
||
|
|
PNDIS_PACKET Packet;
|
||
|
|
PNDIS_BUFFER RawBuffer;
|
||
|
|
void *Memory;
|
||
|
|
IP_STATUS Status;
|
||
|
|
NDIS_STATUS NdisStatus;
|
||
|
|
TDI_STATUS ErrorValue;
|
||
|
|
uint Offset;
|
||
|
|
uint HeaderLength;
|
||
|
|
int Hops;
|
||
|
|
|
||
|
|
CHECK_STRUCT(SrcAO, ao);
|
||
|
|
ASSERT(SrcAO->ao_usecnt != 0);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Loop while we have something to send, and can get
|
||
|
|
// the resources to send it.
|
||
|
|
//
|
||
|
|
for (;;) {
|
||
|
|
|
||
|
|
CHECK_STRUCT(SendReq, dsr);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Determine NTE to send on (if user cares).
|
||
|
|
// We do this prior to allocating packet header buffers so
|
||
|
|
// we know how much room to leave for the link-level header.
|
||
|
|
//
|
||
|
|
if (!IsUnspecified(&SrcAO->ao_addr)) {
|
||
|
|
//
|
||
|
|
// We need to get the NTE of this bound address.
|
||
|
|
//
|
||
|
|
NTE = FindNetworkWithAddress(&SrcAO->ao_addr, SrcAO->ao_scope_id);
|
||
|
|
if (NTE == NULL) {
|
||
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_USER_ERROR,
|
||
|
|
"RawSend: Bad source address\n"));
|
||
|
|
ErrorValue = TDI_INVALID_REQUEST;
|
||
|
|
ReturnError:
|
||
|
|
//
|
||
|
|
// If possible, complete the request with an error.
|
||
|
|
// Free the request structure.
|
||
|
|
//
|
||
|
|
if (SendReq->dsr_rtn != NULL)
|
||
|
|
(*SendReq->dsr_rtn)(SendReq->dsr_context,
|
||
|
|
ErrorValue, 0);
|
||
|
|
KeAcquireSpinLock(&DGSendReqLock, &Irql0);
|
||
|
|
FreeDGSendReq(SendReq);
|
||
|
|
KeReleaseSpinLock(&DGSendReqLock, Irql0);
|
||
|
|
goto SendComplete;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
//
|
||
|
|
// We are not binding to any address.
|
||
|
|
//
|
||
|
|
NTE = NULL;
|
||
|
|
}
|
||
|
|
NTEorIF = CastFromNTE(NTE);
|
||
|
|
//
|
||
|
|
// If this is a multicast packet, check if the application
|
||
|
|
// has specified an interface. Note that ao_mcast_if
|
||
|
|
// overrides ao_addr if both are specified and they conflict.
|
||
|
|
//
|
||
|
|
if (IsMulticast(&SendReq->dsr_addr) && (SrcAO->ao_mcast_if != 0) &&
|
||
|
|
((NTE == NULL) || (NTE->IF->Index != SrcAO->ao_mcast_if))) {
|
||
|
|
if (NTE != NULL) {
|
||
|
|
ReleaseNTE(NTE);
|
||
|
|
NTE = NULL;
|
||
|
|
}
|
||
|
|
IF = FindInterfaceFromIndex(SrcAO->ao_mcast_if);
|
||
|
|
if (IF == NULL) {
|
||
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_USER_ERROR,
|
||
|
|
"RawSend: Bad mcast interface number\n"));
|
||
|
|
ErrorValue = TDI_INVALID_REQUEST;
|
||
|
|
goto ReturnError;
|
||
|
|
}
|
||
|
|
NTEorIF = CastFromIF(IF);
|
||
|
|
} else {
|
||
|
|
IF = NULL;
|
||
|
|
}
|
||
|
|
//
|
||
|
|
// Get the route.
|
||
|
|
//
|
||
|
|
Status = RouteToDestination(&SendReq->dsr_addr, SendReq->dsr_scope_id,
|
||
|
|
NTEorIF, RTD_FLAG_NORMAL, &RCE);
|
||
|
|
if (IF != NULL)
|
||
|
|
ReleaseIF(IF);
|
||
|
|
if (Status != IP_SUCCESS) {
|
||
|
|
//
|
||
|
|
// Failed to get a route to the destination. Error out.
|
||
|
|
//
|
||
|
|
if ((Status == IP_PARAMETER_PROBLEM) ||
|
||
|
|
(Status == IP_BAD_ROUTE))
|
||
|
|
ErrorValue = TDI_BAD_ADDR;
|
||
|
|
else if (Status == IP_NO_RESOURCES)
|
||
|
|
ErrorValue = TDI_NO_RESOURCES;
|
||
|
|
else
|
||
|
|
ErrorValue = TDI_DEST_UNREACHABLE;
|
||
|
|
if (NTE != NULL)
|
||
|
|
ReleaseNTE(NTE);
|
||
|
|
goto ReturnError;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If our address object didn't have a source address,
|
||
|
|
// take the one of the sending net from the RCE.
|
||
|
|
// Otherwise, use address from AO.
|
||
|
|
//
|
||
|
|
if (NTE == NULL) {
|
||
|
|
NTE = RCE->NTE;
|
||
|
|
AddRefNTE(NTE);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Allocate a packet header to anchor the buffer list.
|
||
|
|
//
|
||
|
|
NdisAllocatePacket(&NdisStatus, &Packet, IPv6PacketPool);
|
||
|
|
if (NdisStatus != NDIS_STATUS_SUCCESS) {
|
||
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_NTOS_ERROR,
|
||
|
|
"RawSend: Couldn't allocate packet header!?!\n"));
|
||
|
|
//
|
||
|
|
// If we can't get a packet header from the pool, we push
|
||
|
|
// the send request back on the queue and queue the address
|
||
|
|
// object for when we get resources.
|
||
|
|
//
|
||
|
|
OutOfResources:
|
||
|
|
ReleaseRCE(RCE);
|
||
|
|
ReleaseNTE(NTE);
|
||
|
|
KeAcquireSpinLock(&SrcAO->ao_lock, &Irql0);
|
||
|
|
PUSHQ(&SrcAO->ao_sendq, &SendReq->dsr_q);
|
||
|
|
PutPendingQ(SrcAO);
|
||
|
|
KeReleaseSpinLock(&SrcAO->ao_lock, Irql0);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
InitializeNdisPacket(Packet);
|
||
|
|
PC(Packet)->CompletionHandler = DGSendComplete;
|
||
|
|
PC(Packet)->CompletionData = SendReq;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Create our header buffer.
|
||
|
|
// It will contain the link-level header and possibly the
|
||
|
|
// IPv6 header. The user has the option of contributing
|
||
|
|
// the IPv6 header, otherwise we generate it below.
|
||
|
|
//
|
||
|
|
Offset = HeaderLength = RCE->NCE->IF->LinkHeaderSize;
|
||
|
|
if (!AO_HDRINCL(SrcAO))
|
||
|
|
HeaderLength += sizeof(*IP);
|
||
|
|
if (HeaderLength > 0) {
|
||
|
|
Memory = ExAllocatePool(NonPagedPool, HeaderLength);
|
||
|
|
if (Memory == NULL) {
|
||
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_NTOS_ERROR,
|
||
|
|
"RawSend: couldn't allocate header memory!?!\n"));
|
||
|
|
NdisFreePacket(Packet);
|
||
|
|
goto OutOfResources;
|
||
|
|
}
|
||
|
|
|
||
|
|
NdisAllocateBuffer(&NdisStatus, &RawBuffer, IPv6BufferPool,
|
||
|
|
Memory, HeaderLength);
|
||
|
|
if (NdisStatus != NDIS_STATUS_SUCCESS) {
|
||
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_NTOS_ERROR,
|
||
|
|
"RawSend: couldn't allocate buffer!?!\n"));
|
||
|
|
ExFreePool(Memory);
|
||
|
|
NdisFreePacket(Packet);
|
||
|
|
goto OutOfResources;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Link the data buffers from the send request onto the buffer
|
||
|
|
// chain headed by our header buffer. Then attach this chain
|
||
|
|
// to the packet.
|
||
|
|
//
|
||
|
|
NDIS_BUFFER_LINKAGE(RawBuffer) = SendReq->dsr_buffer;
|
||
|
|
NdisChainBufferAtFront(Packet, RawBuffer);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
NdisChainBufferAtFront(Packet, SendReq->dsr_buffer);
|
||
|
|
|
||
|
|
//
|
||
|
|
// We now have all the resources we need to send.
|
||
|
|
// Prepare the actual packet.
|
||
|
|
//
|
||
|
|
|
||
|
|
if (!AO_HDRINCL(SrcAO)) {
|
||
|
|
//
|
||
|
|
// We can not allow the user to supply extension headers.
|
||
|
|
// IPv6Send assumes that any extension headers are
|
||
|
|
// syntactically correct and resident in the first buffer.
|
||
|
|
// Currently TCPCreate prevents the user from opening raw
|
||
|
|
// sockets with extension header protocols.
|
||
|
|
//
|
||
|
|
ASSERT(!IsExtensionHeader(SrcAO->ao_prot));
|
||
|
|
|
||
|
|
//
|
||
|
|
// We need to provide the IPv6 header.
|
||
|
|
// Place it after the link-layer header.
|
||
|
|
//
|
||
|
|
IP = (IPv6Header UNALIGNED *)((uchar *)Memory + Offset);
|
||
|
|
IP->VersClassFlow = IP_VERSION;
|
||
|
|
IP->NextHeader = SrcAO->ao_prot;
|
||
|
|
IP->Source = NTE->Address;
|
||
|
|
IP->Dest = SendReq->dsr_addr;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Apply the multicast or unicast hop limit, as appropriate.
|
||
|
|
//
|
||
|
|
if (IsMulticast(AlignAddr(&IP->Dest))) {
|
||
|
|
//
|
||
|
|
// Also disable multicast loopback, if requested.
|
||
|
|
//
|
||
|
|
if (! SrcAO->ao_mcast_loop)
|
||
|
|
PC(Packet)->Flags |= NDIS_FLAGS_DONT_LOOPBACK;
|
||
|
|
Hops = SrcAO->ao_mcast_hops;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
Hops = SrcAO->ao_ucast_hops;
|
||
|
|
if (Hops != -1)
|
||
|
|
IP->HopLimit = (uchar) Hops;
|
||
|
|
else
|
||
|
|
IP->HopLimit = (uchar) RCE->NCE->IF->CurHopLimit;
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// Everything's ready. Now send the packet.
|
||
|
|
//
|
||
|
|
// Note that IPv6Send does not return a status code.
|
||
|
|
// Instead it *always* completes the packet
|
||
|
|
// with an appropriate status code.
|
||
|
|
//
|
||
|
|
IPv6Send(Packet, Offset, IP, SendReq->dsr_size, RCE, 0,
|
||
|
|
SrcAO->ao_prot, 0, 0);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
//
|
||
|
|
// Our header buffer contains only the link-level header.
|
||
|
|
// The IPv6 header and any extension headers are expected to
|
||
|
|
// be provided by the user. In some cases the kernel
|
||
|
|
// will attempt to access the IPv6 header so we must
|
||
|
|
// ensure that the mappings exist now.
|
||
|
|
//
|
||
|
|
if (! MapNdisBuffers(NdisFirstBuffer(Packet))) {
|
||
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_NTOS_ERROR,
|
||
|
|
"RawSend(%p): buffer mapping failed\n",
|
||
|
|
Packet));
|
||
|
|
IPv6SendComplete(NULL, Packet, IP_GENERAL_FAILURE);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
//
|
||
|
|
// Everything's ready. Now send the packet.
|
||
|
|
//
|
||
|
|
IPv6SendND(Packet, HeaderLength,
|
||
|
|
RCE->NCE, &(RCE->NTE->Address));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
UStats.us_outdatagrams++;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Release the route.
|
||
|
|
//
|
||
|
|
ReleaseRCE(RCE);
|
||
|
|
ReleaseNTE(NTE);
|
||
|
|
|
||
|
|
SendComplete:
|
||
|
|
|
||
|
|
//
|
||
|
|
// Check the send queue for more to send.
|
||
|
|
//
|
||
|
|
KeAcquireSpinLock(&SrcAO->ao_lock, &Irql0);
|
||
|
|
if (!EMPTYQ(&SrcAO->ao_sendq)) {
|
||
|
|
//
|
||
|
|
// More to go. Dequeue next request and loop back to top.
|
||
|
|
//
|
||
|
|
DEQUEUE(&SrcAO->ao_sendq, SendReq, DGSendReq, dsr_q);
|
||
|
|
KeReleaseSpinLock(&SrcAO->ao_lock, Irql0);
|
||
|
|
} else {
|
||
|
|
//
|
||
|
|
// Nothing more to send.
|
||
|
|
//
|
||
|
|
CLEAR_AO_REQUEST(SrcAO, AO_SEND);
|
||
|
|
KeReleaseSpinLock(&SrcAO->ao_lock, Irql0);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//* RawDeliver - Deliver a datagram to a user.
|
||
|
|
//
|
||
|
|
// This routine delivers a datagram to a raw user. We're called with
|
||
|
|
// the AddrObj to deliver on, and with the AddrObjTable lock held.
|
||
|
|
// We try to find a receive on the specified AddrObj, and if we do
|
||
|
|
// we remove it and copy the data into the buffer. Otherwise we'll
|
||
|
|
// call the receive datagram event handler, if there is one. If that
|
||
|
|
// fails we'll discard the datagram.
|
||
|
|
//
|
||
|
|
void // Returns: Nothing.
|
||
|
|
RawDeliver(
|
||
|
|
AddrObj *RcvAO, // Address object to receive the datagram.
|
||
|
|
IPv6Packet *Packet, // Packet handed up by IP.
|
||
|
|
uint SrcScopeId, // Scope id for source address.
|
||
|
|
KIRQL Irql0) // IRQL prior to acquiring AddrObj table lock.
|
||
|
|
{
|
||
|
|
Queue *CurrentQ;
|
||
|
|
KIRQL Irql1;
|
||
|
|
DGRcvReq *RcvReq;
|
||
|
|
uint BytesTaken = 0;
|
||
|
|
uchar AddressBuffer[TCP_TA_SIZE];
|
||
|
|
uint RcvdSize;
|
||
|
|
EventRcvBuffer *ERB = NULL;
|
||
|
|
uint Position = Packet->Position;
|
||
|
|
uint Length = Packet->TotalSize;
|
||
|
|
|
||
|
|
CHECK_STRUCT(RcvAO, ao);
|
||
|
|
|
||
|
|
KeAcquireSpinLock(&RcvAO->ao_lock, &Irql1);
|
||
|
|
KeReleaseSpinLock(&AddrObjTableLock, Irql1);
|
||
|
|
|
||
|
|
if (AO_VALID(RcvAO)) {
|
||
|
|
|
||
|
|
CurrentQ = QHEAD(&RcvAO->ao_rcvq);
|
||
|
|
|
||
|
|
// Walk the list, looking for a receive buffer that matches.
|
||
|
|
while (CurrentQ != QEND(&RcvAO->ao_rcvq)) {
|
||
|
|
RcvReq = QSTRUCT(DGRcvReq, CurrentQ, drr_q);
|
||
|
|
|
||
|
|
CHECK_STRUCT(RcvReq, drr);
|
||
|
|
|
||
|
|
//
|
||
|
|
// If this request is a wildcard request (accept from anywhere),
|
||
|
|
// or matches the source IP address and scope id, deliver it.
|
||
|
|
//
|
||
|
|
if (IsUnspecified(&RcvReq->drr_addr) ||
|
||
|
|
(IP6_ADDR_EQUAL(&RcvReq->drr_addr, Packet->SrcAddr) &&
|
||
|
|
(RcvReq->drr_scope_id == SrcScopeId))) {
|
||
|
|
|
||
|
|
TDI_STATUS Status;
|
||
|
|
|
||
|
|
// Remove this from the queue.
|
||
|
|
REMOVEQ(&RcvReq->drr_q);
|
||
|
|
|
||
|
|
// We're done. We can free the AddrObj lock now.
|
||
|
|
KeReleaseSpinLock(&RcvAO->ao_lock, Irql0);
|
||
|
|
|
||
|
|
// Copy the data, and then complete the request.
|
||
|
|
RcvdSize = CopyToBufferChain(RcvReq->drr_buffer, 0,
|
||
|
|
Packet->NdisPacket,
|
||
|
|
Position,
|
||
|
|
Packet->FlatData,
|
||
|
|
MIN(Length, RcvReq->drr_size));
|
||
|
|
|
||
|
|
ASSERT(RcvdSize <= RcvReq->drr_size);
|
||
|
|
|
||
|
|
Status = UpdateConnInfo(RcvReq->drr_conninfo, Packet->SrcAddr,
|
||
|
|
SrcScopeId, 0);
|
||
|
|
|
||
|
|
UStats.us_indatagrams++;
|
||
|
|
|
||
|
|
(*RcvReq->drr_rtn)(RcvReq->drr_context, Status, RcvdSize);
|
||
|
|
|
||
|
|
FreeDGRcvReq(RcvReq);
|
||
|
|
|
||
|
|
return; // All done.
|
||
|
|
}
|
||
|
|
|
||
|
|
// Not a matching request. Get the next one off the queue.
|
||
|
|
CurrentQ = QNEXT(CurrentQ);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// We've walked the list, and not found a buffer.
|
||
|
|
// Call the receive handler now, if we have one.
|
||
|
|
//
|
||
|
|
if (RcvAO->ao_rcvdg != NULL) {
|
||
|
|
PRcvDGEvent RcvEvent = RcvAO->ao_rcvdg;
|
||
|
|
PVOID RcvContext = RcvAO->ao_rcvdgcontext;
|
||
|
|
TDI_STATUS RcvStatus;
|
||
|
|
ULONG Flags = TDI_RECEIVE_COPY_LOOKAHEAD;
|
||
|
|
int BufferSize = 0;
|
||
|
|
PVOID BufferToSend = NULL;
|
||
|
|
uchar *CurrPosition;
|
||
|
|
|
||
|
|
REF_AO(RcvAO);
|
||
|
|
KeReleaseSpinLock(&RcvAO->ao_lock, Irql0);
|
||
|
|
|
||
|
|
BuildTDIAddress(AddressBuffer, Packet->SrcAddr, SrcScopeId, 0);
|
||
|
|
|
||
|
|
UStats.us_indatagrams++;
|
||
|
|
|
||
|
|
// If the IPV6_PKTINFO or IPV6_HOPLIMIT options were set, then
|
||
|
|
// create the control information to be passed to the handler.
|
||
|
|
// Currently this is the only place such options are filled in,
|
||
|
|
// so we just have one buffer. If other places are added in the
|
||
|
|
// future, we may want to support a list or array of buffers to
|
||
|
|
// copy into the user's buffer.
|
||
|
|
//
|
||
|
|
if (AO_PKTINFO(RcvAO)) {
|
||
|
|
BufferSize += TDI_CMSG_SPACE(sizeof(IN6_PKTINFO));
|
||
|
|
}
|
||
|
|
if (AO_RCV_HOPLIMIT(RcvAO)) {
|
||
|
|
BufferSize += TDI_CMSG_SPACE(sizeof(int));
|
||
|
|
}
|
||
|
|
if (BufferSize > 0) {
|
||
|
|
CurrPosition = BufferToSend = ExAllocatePool(NonPagedPool,
|
||
|
|
BufferSize);
|
||
|
|
if (BufferToSend == NULL) {
|
||
|
|
BufferSize = 0;
|
||
|
|
} else {
|
||
|
|
if (AO_PKTINFO(RcvAO)) {
|
||
|
|
DGFillIpv6PktInfo(&Packet->IP->Dest,
|
||
|
|
Packet->NTEorIF->IF->Index,
|
||
|
|
&CurrPosition);
|
||
|
|
|
||
|
|
// Set the receive flag so the receive handler knows
|
||
|
|
// we are passing up control info.
|
||
|
|
//
|
||
|
|
Flags |= TDI_RECEIVE_CONTROL_INFO;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (AO_RCV_HOPLIMIT(RcvAO)) {
|
||
|
|
DGFillIpv6HopLimit(Packet->IP->HopLimit, &CurrPosition);
|
||
|
|
|
||
|
|
Flags |= TDI_RECEIVE_CONTROL_INFO;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
RcvStatus = (*RcvEvent)(RcvContext, TCP_TA_SIZE,
|
||
|
|
(PTRANSPORT_ADDRESS)AddressBuffer,
|
||
|
|
BufferSize, BufferToSend, Flags,
|
||
|
|
Packet->ContigSize, Length, &BytesTaken,
|
||
|
|
Packet->Data, &ERB);
|
||
|
|
|
||
|
|
if (BufferToSend) {
|
||
|
|
ExFreePool(BufferToSend);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (RcvStatus == TDI_MORE_PROCESSING) {
|
||
|
|
PIO_STACK_LOCATION IrpSp;
|
||
|
|
PTDI_REQUEST_KERNEL_RECEIVEDG DatagramInformation;
|
||
|
|
|
||
|
|
//
|
||
|
|
// We were passed back a receive buffer. Copy the data in now.
|
||
|
|
// Receive event handler can't have taken more than was in the
|
||
|
|
// indicated buffer, but in debug builds we'll check this.
|
||
|
|
//
|
||
|
|
ASSERT(ERB != NULL);
|
||
|
|
ASSERT(BytesTaken <= Packet->ContigSize);
|
||
|
|
|
||
|
|
//
|
||
|
|
// For NT, ERBs are really IRPs.
|
||
|
|
//
|
||
|
|
IrpSp = IoGetCurrentIrpStackLocation(ERB);
|
||
|
|
DatagramInformation = (PTDI_REQUEST_KERNEL_RECEIVEDG)
|
||
|
|
&(IrpSp->Parameters);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Copy data to the IRP, skipping the bytes
|
||
|
|
// that were already taken.
|
||
|
|
//
|
||
|
|
Position += BytesTaken;
|
||
|
|
Length -= BytesTaken;
|
||
|
|
RcvdSize = CopyToBufferChain(ERB->MdlAddress, 0,
|
||
|
|
Packet->NdisPacket,
|
||
|
|
Position,
|
||
|
|
Packet->FlatData,
|
||
|
|
Length);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Update the return address info.
|
||
|
|
//
|
||
|
|
RcvStatus = UpdateConnInfo(
|
||
|
|
DatagramInformation->ReturnDatagramInformation,
|
||
|
|
Packet->SrcAddr, SrcScopeId, 0);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Complete the IRP.
|
||
|
|
//
|
||
|
|
ERB->IoStatus.Information = RcvdSize;
|
||
|
|
ERB->IoStatus.Status = RcvStatus;
|
||
|
|
IoCompleteRequest(ERB, 2);
|
||
|
|
|
||
|
|
} else {
|
||
|
|
ASSERT((RcvStatus == TDI_SUCCESS) ||
|
||
|
|
(RcvStatus == TDI_NOT_ACCEPTED));
|
||
|
|
ASSERT(ERB == NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
DELAY_DEREF_AO(RcvAO);
|
||
|
|
|
||
|
|
return;
|
||
|
|
|
||
|
|
} else
|
||
|
|
UStats.us_inerrors++;
|
||
|
|
|
||
|
|
//
|
||
|
|
// When we get here, we didn't have a buffer to put this data into.
|
||
|
|
// Fall through to the return case.
|
||
|
|
//
|
||
|
|
|
||
|
|
} else
|
||
|
|
UStats.us_inerrors++;
|
||
|
|
|
||
|
|
KeReleaseSpinLock(&RcvAO->ao_lock, Irql0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//* RawReceive - Receive a Raw datagram.
|
||
|
|
//
|
||
|
|
// This routine is called by IP when a Raw datagram arrives. We
|
||
|
|
// lookup the protocol/address pair in our address table, and deliver
|
||
|
|
// the data to any users we find.
|
||
|
|
//
|
||
|
|
// Note that we'll only get here if all headers in the packet
|
||
|
|
// preceeding the one we're filtering on were acceptable.
|
||
|
|
//
|
||
|
|
// We return TRUE if we find a receiver to take the packet, FALSE otherwise.
|
||
|
|
//
|
||
|
|
int
|
||
|
|
RawReceive(
|
||
|
|
IPv6Packet *Packet, // Packet IP handed up to us.
|
||
|
|
uchar Protocol) // Protocol we think we're handling.
|
||
|
|
{
|
||
|
|
Interface *IF = Packet->NTEorIF->IF;
|
||
|
|
KIRQL OldIrql;
|
||
|
|
AddrObj *ReceivingAO;
|
||
|
|
AOSearchContext Search;
|
||
|
|
AOMCastAddr *AMA, *PrevAMA;
|
||
|
|
int ReceiverFound = FALSE;
|
||
|
|
uint SrcScopeId, DestScopeId;
|
||
|
|
uint Loop;
|
||
|
|
|
||
|
|
//
|
||
|
|
// This being the raw receive routine, we perform no checks on
|
||
|
|
// the packet data.
|
||
|
|
//
|
||
|
|
|
||
|
|
//
|
||
|
|
// Verify IPSec was performed.
|
||
|
|
//
|
||
|
|
if (InboundSecurityCheck(Packet, Protocol, 0, 0, IF) != TRUE) {
|
||
|
|
//
|
||
|
|
// No policy was found or the policy found was to drop the packet.
|
||
|
|
//
|
||
|
|
KdPrintEx((DPFLTR_TCPIP6_ID, DPFLTR_NET_ERROR,
|
||
|
|
"RawReceive: IPSec Policy caused packet to be refused\n"));
|
||
|
|
return FALSE; // Drop packet.
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Set the source's scope id value as appropriate.
|
||
|
|
//
|
||
|
|
SrcScopeId = DetermineScopeId(Packet->SrcAddr, IF);
|
||
|
|
|
||
|
|
//
|
||
|
|
// At this point, we've decided it's okay to accept the packet.
|
||
|
|
// Figure out who to give this packet to.
|
||
|
|
//
|
||
|
|
if (IsMulticast(AlignAddr(&Packet->IP->Dest))) {
|
||
|
|
//
|
||
|
|
// This is a multicast packet, so we need to find all interested
|
||
|
|
// AddrObj's. We get the AddrObjTable lock, and then loop through
|
||
|
|
// all AddrObj's and give the packet to any who are listening to
|
||
|
|
// this multicast address, interface & protocol.
|
||
|
|
// REVIEW: We match on interface, NOT scope id. Multicast is weird.
|
||
|
|
//
|
||
|
|
KeAcquireSpinLock(&AddrObjTableLock, &OldIrql);
|
||
|
|
|
||
|
|
for (Loop = 0; Loop < AddrObjTableSize; Loop++) {
|
||
|
|
for (ReceivingAO = AddrObjTable[Loop]; ReceivingAO != NULL;
|
||
|
|
ReceivingAO = ReceivingAO->ao_next) {
|
||
|
|
|
||
|
|
CHECK_STRUCT(ReceivingAO, ao);
|
||
|
|
|
||
|
|
if (ReceivingAO->ao_prot != Protocol)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
if ((AMA = FindAOMCastAddr(ReceivingAO,
|
||
|
|
AlignAddr(&Packet->IP->Dest),
|
||
|
|
IF->Index, &PrevAMA,
|
||
|
|
FALSE)) == NULL)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
//
|
||
|
|
// We have a matching address object. Hand it the packet.
|
||
|
|
//
|
||
|
|
RawDeliver(ReceivingAO, Packet, SrcScopeId, OldIrql);
|
||
|
|
|
||
|
|
//
|
||
|
|
// RawDeliver released the AddrObjTableLock, so grab it again.
|
||
|
|
//
|
||
|
|
KeAcquireSpinLock(&AddrObjTableLock, &OldIrql);
|
||
|
|
ReceiverFound = TRUE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
} else {
|
||
|
|
//
|
||
|
|
// This is a unicast packet. Try to find some AddrObj(s) to
|
||
|
|
// give it to. We deliver to all matches, not just the first.
|
||
|
|
//
|
||
|
|
DestScopeId = DetermineScopeId(AlignAddr(&Packet->IP->Dest), IF);
|
||
|
|
KeAcquireSpinLock(&AddrObjTableLock, &OldIrql);
|
||
|
|
ReceivingAO = GetFirstAddrObj(AlignAddr(&Packet->IP->Dest),
|
||
|
|
DestScopeId, 0,
|
||
|
|
Protocol, &Search);
|
||
|
|
for (; ReceivingAO != NULL; ReceivingAO = GetNextAddrObj(&Search)) {
|
||
|
|
//
|
||
|
|
// We have a matching address object. Hand it the packet.
|
||
|
|
//
|
||
|
|
RawDeliver(ReceivingAO, Packet, SrcScopeId, OldIrql);
|
||
|
|
|
||
|
|
//
|
||
|
|
// RawDeliver released the AddrObjTableLock, so grab it again.
|
||
|
|
//
|
||
|
|
KeAcquireSpinLock(&AddrObjTableLock, &OldIrql);
|
||
|
|
ReceiverFound = TRUE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
KeReleaseSpinLock(&AddrObjTableLock, OldIrql);
|
||
|
|
|
||
|
|
return ReceiverFound;
|
||
|
|
}
|