/********************************************************************/ /** Microsoft LAN Manager **/ /** Copyright(c) Microsoft Corp., 1990-2000 **/ /********************************************************************/ /* :ts=4 */ //*** iploop.c - IP loopback routines. // // This file contains all the routines related to loopback #include "precomp.h" #include "iprtdef.h" #include "iproute.h" #include "tcpipbuf.h" #define LOOP_LOOKAHEAD MAX_HDR_SIZE + 8 extern int NumNTE; extern int NumActiveNTE; extern Interface *IFList; extern uint NumIF; extern BOOLEAN CopyToNdisSafe(PNDIS_BUFFER DestBuf, PNDIS_BUFFER * ppNextBuf, uchar * SrcBuf, uint Size, uint * StartOffset); CACHE_LINE_KSPIN_LOCK LoopLock; PNDIS_PACKET LoopXmitHead = (PNDIS_PACKET) NULL; PNDIS_PACKET LoopXmitTail = (PNDIS_PACKET) NULL; CTEEvent LoopXmitEvent; RouteInterface LoopInterface; // Loopback interface. uint LoopXmitRtnRunning = 0; int LoopGetEList(void *Context, TDIEntityID *EntityList, uint *Count); NetTableEntry *InitLoopback(IPConfigInfo * ConfigInfo); #ifdef ALLOC_PRAGMA #pragma alloc_text(PAGE, LoopGetEList) #pragma alloc_text(INIT, InitLoopback) #endif // ALLOC_PRAGMA uint LoopIndex; // Index of loop I/F. uint LoopInstance = INVALID_ENTITY_INSTANCE; // I/F instance of loopback I/F. NetTableEntry *LoopNTE; // Pointer to loopback NTE. IFEntry LoopIFE; // Loopback IF Entry. uchar LoopName[] = "MS TCP Loopback interface"; uint LoopEntityType = IF_MIB; //* LoopXmitRtn - Loopback xmit event routine. // // This is the delayed event routine called for a loopback transmit. // // Entry: Event - Pointer to event structure. // Context - Pointer to loopback NTE // // Returns: Nothing. // void LoopXmitRtn(CTEEvent *Event, void *Context) { PNDIS_PACKET Packet; // Pointer to packet being transmitted CTELockHandle Handle; PNDIS_BUFFER Buffer; // Current NDIS buffer being processed. uint TotalLength; // Total length of send. uint LookaheadLength; // Bytes in lookahead. uint Copied; // Bytes copied so far. uchar *CopyPtr; // Pointer to buffer being copied into. uchar *SrcPtr; // Pointer to buffer being copied from. uint SrcLength; // Length of src buffer. uchar LookaheadBuffer[LOOP_LOOKAHEAD]; uchar Rcvd = FALSE; #if !MILLEN KIRQL OldIrql; #endif // !MILLEN ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL); // // Raise IRQL so we can acquire locks at DPC level in the receive code. // On Windows ME, this is NOT done since receive indications are in the // context of a global event rather than DPC (in fact due to TDI client // restrictions, TCP/IP can't indicate up at DPC, so care must be taken). // #if !MILLEN KeEnterCriticalRegion(); KeRaiseIrql(DISPATCH_LEVEL, &OldIrql); #endif // !MILLEN CTEGetLockAtDPC(&LoopLock.Lock, &Handle); if (LoopXmitRtnRunning) { CTEFreeLockFromDPC(&LoopLock.Lock, Handle); #if !MILLEN KeLowerIrql(OldIrql); KeLeaveCriticalRegion(); #endif // !MILLEN return; } LoopXmitRtnRunning = 1; for (;;) { Packet = LoopXmitHead; // Get the next packet from the list. if (Packet != (PNDIS_PACKET) NULL) { LoopXmitHead = *(PNDIS_PACKET *) Packet->MacReserved; LoopIFE.if_outqlen--; CTEFreeLockFromDPC(&LoopLock.Lock, Handle); } else { // Nothing left to do. LoopXmitRtnRunning = 0; CTEFreeLockFromDPC(&LoopLock.Lock, Handle); break; } // See if the interface is up. If it's not, we can't deliver it. if (LoopIFE.if_adminstatus == IF_STATUS_UP) { NdisQueryPacket(Packet, NULL, NULL, &Buffer, &TotalLength); LoopIFE.if_outoctets += TotalLength; LoopIFE.if_inoctets += TotalLength; LookaheadLength = MIN(LOOP_LOOKAHEAD, TotalLength); Copied = 0; CopyPtr = LookaheadBuffer; while (Copied < LookaheadLength) { uint ThisCopy; // Bytes to copy this time. ASSERT(Buffer); TcpipQueryBuffer(Buffer, &SrcPtr, &SrcLength, NormalPagePriority); if (SrcPtr == NULL) { IPSendComplete(Context, Packet, NDIS_STATUS_RESOURCES); CTEGetLockAtDPC(&LoopLock.Lock, &Handle); LoopXmitRtnRunning = 0; LoopIFE.if_indiscards++; CTEFreeLockFromDPC(&LoopLock.Lock, Handle); #if !MILLEN KeLowerIrql(OldIrql); KeLeaveCriticalRegion(); #endif // !MILLEN return; } ThisCopy = MIN(SrcLength, LookaheadLength - Copied); RtlCopyMemory(CopyPtr, SrcPtr, ThisCopy); Copied += ThisCopy; CopyPtr += ThisCopy; NdisGetNextBuffer(Buffer, &Buffer); } Rcvd = TRUE; LoopIFE.if_inucastpkts++; // Call the RcvPacket Handler IPRcvPacket(Context, LookaheadBuffer, LookaheadLength, TotalLength, (NDIS_HANDLE) Packet, 0, FALSE, 0, NULL, (PINT) Packet, NULL); } else { LoopIFE.if_indiscards++; } IPSendComplete(Context, Packet, NDIS_STATUS_SUCCESS); #if !MILLEN // // Give other threads a chance to run. // Block special k mode APC delivery // so that thread will not be blocked // in a completion routine // KeLowerIrql(OldIrql); KeRaiseIrql(DISPATCH_LEVEL, &OldIrql); #endif // !MILLEN CTEGetLockAtDPC(&LoopLock.Lock, &Handle); } if (Rcvd) { IPRcvComplete(); } #if !MILLEN KeLowerIrql(OldIrql); KeLeaveCriticalRegion(); #endif // !MILLEN } //** LoopXmit - Transmit a loopback packet. // // This is the routine called when we need to transmit a packet to ourselves. // We put the packet on our loopback list, and schedule an event to deal // with it. // // Entry: Context - Pointer to the loopback NTE. // Packet - Pointer to packet to be transmitted. // Dest - Destination addres of packet. // RCE - Pointer to RCE (should be NULL). // // Returns: NDIS_STATUS_PENDING // NDIS_STATUS __stdcall LoopXmit(void *Context, PNDIS_PACKET *PacketArray, uint NoPackets, IPAddr Dest, RouteCacheEntry * RCE, void *LinkCtxt) { PNDIS_PACKET *PacketPtr; CTELockHandle Handle; PNDIS_PACKET Packet = *PacketArray; ASSERT(NoPackets == 1); LoopIFE.if_outucastpkts++; if (LoopIFE.if_adminstatus == IF_STATUS_UP) { PacketPtr = (PNDIS_PACKET *) Packet->MacReserved; *PacketPtr = (PNDIS_PACKET) NULL; CTEGetLock(&LoopLock.Lock, &Handle); if (LoopXmitHead == (PNDIS_PACKET) NULL) { // Xmit. Q is empty LoopXmitHead = Packet; } else { // Xmit. Q is not empty PacketPtr = (PNDIS_PACKET *) LoopXmitTail->MacReserved; *PacketPtr = Packet; } LoopXmitTail = Packet; LoopIFE.if_outqlen++; if (!LoopXmitRtnRunning) { CTEScheduleDelayedEvent(&LoopXmitEvent, Context); } CTEFreeLock(&LoopLock.Lock, Handle); return NDIS_STATUS_PENDING; } else { LoopIFE.if_outdiscards++; return NDIS_STATUS_SUCCESS; } } //* LoopXfer - Loopback transfer data routine. // // Called when we need to transfer data for the loopback net. The input // TDContext is the original packet. // // Entry: Context - Pointer to loopback NTE. // TDContext - Original packet that was sent. // Dummy - Unused // Offset - Offset in frame from which to start copying. // BytesToCopy - Number of bytes to copy. // DestPacket - Packet describing buffer to copy into. // BytesCopied - Place to return bytes copied. // // Returns: NDIS_STATUS_SUCCESS // NDIS_STATUS __stdcall LoopXfer(void *Context, NDIS_HANDLE TDContext, uint Dummy, uint Offset, uint BytesToCopy, PNDIS_PACKET DestPacket, uint *BytesCopied) { PNDIS_BUFFER SrcBuffer; // Current buffer we're copying from. PNDIS_PACKET SrcPacket = (PNDIS_PACKET) TDContext; uchar *SrcPtr; // Where we're copying from. uint SrcLength; // Length of current src buffer. PNDIS_BUFFER DestBuffer; // Buffer we're copying to. uchar *DestPtr; // Where we're copying to. uint DestLength; // Length of current dest. buffer. uint Copied; // Length we've copied so far. NDIS_STATUS Status; // First, skip over Offset bytes in the packet. NdisQueryPacket(SrcPacket, NULL, NULL, &SrcBuffer, NULL); ASSERT(SrcBuffer); TcpipQueryBuffer(SrcBuffer, &SrcPtr, &SrcLength, NormalPagePriority); if (SrcPtr == NULL) { return NDIS_STATUS_RESOURCES; } while (Offset >= SrcLength) { Offset -= SrcLength; NdisGetNextBuffer(SrcBuffer, &SrcBuffer); ASSERT(SrcBuffer); TcpipQueryBuffer(SrcBuffer, &SrcPtr, &SrcLength, NormalPagePriority); if (SrcPtr == NULL) { return NDIS_STATUS_RESOURCES; } } // Update Src pointer and length. SrcPtr += Offset; SrcLength -= Offset; // Set up the destination pointers and lengths. NdisQueryPacket(DestPacket, NULL, NULL, &DestBuffer, NULL); TcpipQueryBuffer(DestBuffer, &DestPtr, &DestLength, NormalPagePriority); if (DestPtr == NULL) { return NDIS_STATUS_RESOURCES; } Copied = 0; Status = NDIS_STATUS_SUCCESS; while (BytesToCopy) { uint ThisCopy; // What we're copying this time. ThisCopy = MIN(SrcLength, DestLength); RtlCopyMemory(DestPtr, SrcPtr, ThisCopy); Copied += ThisCopy; DestPtr += ThisCopy; SrcPtr += ThisCopy; BytesToCopy -= ThisCopy; SrcLength -= ThisCopy; DestLength -= ThisCopy; if (!SrcLength) { // We've exhausted the source buffer. NdisGetNextBuffer(SrcBuffer, &SrcBuffer); if (!SrcBuffer) { ASSERT(0 == BytesToCopy); break; // Copy is done. } TcpipQueryBuffer(SrcBuffer, &SrcPtr, &SrcLength, NormalPagePriority); if (SrcPtr == NULL && BytesToCopy) { Status = NDIS_STATUS_RESOURCES; break; } } if (!DestLength) { // We've exhausted the destination buffer. NdisGetNextBuffer(DestBuffer, &DestBuffer); if (!DestBuffer) { ASSERT(0 == BytesToCopy); break; // Copy is done. } TcpipQueryBuffer(DestBuffer, &DestPtr, &DestLength, NormalPagePriority); if (DestPtr == NULL && BytesToCopy) { Status = NDIS_STATUS_RESOURCES; break; } } } if (Status == NDIS_STATUS_SUCCESS) { *BytesCopied = Copied; } return Status; } //* LoopClose - Loopback close routine. // // This is the loopback close routine. It does nothing but return. // // Entry: Context - Unused. // // Returns: Nothing. // void __stdcall LoopClose(void *Context) { } //* LoopInvalidate - Invalidate an RCE. // // The loopback invalidate RCE routine. It also does nothing. // // Entry: Context - Unused. // RCE - Pointer to RCE to be invalidated. // // Returns: Nothing. // void __stdcall LoopInvalidate(void *Context, RouteCacheEntry * RCE) { } //* LoopQInfo - Loopback query information handler. // // Called when the upper layer wants to query information about the loopback // interface. // // Input: IFContext - Interface context (unused). // ID - TDIObjectID for object. // Buffer - Buffer to put data into. // Size - Pointer to size of buffer. On return, filled with // bytes copied. // Context - Pointer to context block. // // Returns: Status of attempt to query information. // int __stdcall LoopQInfo(void *IFContext, TDIObjectID * ID, PNDIS_BUFFER Buffer, uint * Size, void *Context) { uint Offset = 0; uint BufferSize = *Size; uint Entity; uint Instance; BOOLEAN fStatus; Entity = ID->toi_entity.tei_entity; Instance = ID->toi_entity.tei_instance; // First, make sure it's possibly an ID we can handle. if (Entity != IF_ENTITY || Instance != LoopInstance) { return TDI_INVALID_REQUEST; } *Size = 0; // In case of an error. if (ID->toi_type != INFO_TYPE_PROVIDER) return TDI_INVALID_PARAMETER; if (ID->toi_class == INFO_CLASS_GENERIC) { if (ID->toi_id == ENTITY_TYPE_ID) { // He's trying to see what type we are. if (BufferSize >= sizeof(uint)) { fStatus = CopyToNdisSafe(Buffer, NULL, (uchar *) &LoopEntityType, sizeof(uint), &Offset); if (fStatus == FALSE) { return (TDI_NO_RESOURCES); } return TDI_SUCCESS; } else return TDI_BUFFER_TOO_SMALL; } return TDI_INVALID_PARAMETER; } else if (ID->toi_class != INFO_CLASS_PROTOCOL) return TDI_INVALID_PARAMETER; // If he's asking for MIB statistics, then return them, otherwise fail // the request. if (ID->toi_id == IF_MIB_STATS_ID) { // He's asking for statistics. Make sure his buffer is at least big // enough to hold the fixed part. if (BufferSize < IFE_FIXED_SIZE) { return TDI_BUFFER_TOO_SMALL; } // He's got enough to hold the fixed part. Copy our IFE structure // into his buffer. fStatus = CopyToNdisSafe(Buffer, &Buffer, (uchar *) & LoopIFE, IFE_FIXED_SIZE, &Offset); if (fStatus == TRUE) { // See if he has room for the descriptor string. if (BufferSize >= (IFE_FIXED_SIZE + sizeof(LoopName))) { // He has room. Copy it. fStatus = CopyToNdisSafe(Buffer, NULL, LoopName, sizeof(LoopName), &Offset); if (fStatus == TRUE) { *Size = IFE_FIXED_SIZE + sizeof(LoopName); return TDI_SUCCESS; } } else { // Not enough room to copy the desc. string. *Size = IFE_FIXED_SIZE; return TDI_BUFFER_OVERFLOW; } } return TDI_NO_RESOURCES; } return TDI_INVALID_PARAMETER; } //* LoopSetInfo - Loopback set information handler. // // The loopback set information handler. We support setting of an I/F admin // status. // // Input: Context - Pointer to I/F to set on. // ID - The object ID // Buffer - Pointer to buffer containing value to set. // Size - Size in bytes of Buffer. // // Returns: Status of attempt to set information. // int __stdcall LoopSetInfo(void *Context, TDIObjectID *ID, void *Buffer, uint Size) { IFEntry *IFE = (IFEntry *) Buffer; uint Entity, Instance, Status; Entity = ID->toi_entity.tei_entity; Instance = ID->toi_entity.tei_instance; // First, make sure it's possibly an ID we can handle. if (Entity != IF_ENTITY || Instance != LoopInstance) { return TDI_INVALID_REQUEST; } if (ID->toi_class != INFO_CLASS_PROTOCOL || ID->toi_type != INFO_TYPE_PROVIDER) { return TDI_INVALID_PARAMETER; } // It's for the I/F level, see if it's for the statistics. if (ID->toi_id == IF_MIB_STATS_ID) { // It's for the stats. Make sure it's a valid size. if (Size >= IFE_FIXED_SIZE) { // It's a valid size. See what he wants to do. Status = IFE->if_adminstatus; if (Status == IF_STATUS_UP || Status == IF_STATUS_DOWN) LoopIFE.if_adminstatus = Status; else if (Status != IF_STATUS_TESTING) return TDI_INVALID_PARAMETER; return TDI_SUCCESS; } else return TDI_INVALID_PARAMETER; } return TDI_INVALID_PARAMETER; } //* LoopAddAddr - Dummy loopback add address routine. // // Called at init time when we need to initialize ourselves. // uint __stdcall LoopAddAddr(void *Context, uint Type, IPAddr Address, IPMask Mask, void *Context2) { return TRUE; } //* LoopDelAddr - Dummy loopback del address routine. // // Called at init time when we need to initialize ourselves. // uint __stdcall LoopDelAddr(void *Context, uint Type, IPAddr Address, IPMask Mask) { return TRUE; } #pragma BEGIN_INIT extern int InitNTE(NetTableEntry *); extern int InitInterface(NetTableEntry *); //* LoopGetEList - Get the entity list. // // Called at init time to get an entity list. We fill our stuff in and return. // // Input: Context - Unused. // EntityList - Pointer to entity list to be filled in. // Count - Pointer to number of entries in the list. // // Returns Status of attempt to get the info. // int __stdcall LoopGetEList(void *Context, TDIEntityID *EntityList, uint *Count) { uint MyIFBase; uint i; TDIEntityID *IFEntity; // Walk down the list, looking for existing IF entities, and // adjust our base instance accordingly. MyIFBase = 0; IFEntity = NULL; for (i = 0; i < *Count; i++, EntityList++) { if (EntityList->tei_entity == IF_ENTITY) // if we are already on the list remember our entity item // o/w find an instance # for us. if (EntityList->tei_instance == LoopInstance && EntityList->tei_instance != INVALID_ENTITY_INSTANCE) { IFEntity = EntityList; break; } else { MyIFBase = MAX(MyIFBase, EntityList->tei_instance + 1); } } if (IFEntity == NULL) { // we are not on the list. // make sure we have the room for it. if (*Count >= MAX_TDI_ENTITIES) { return FALSE; } LoopInstance = MyIFBase; // Now fill it in. EntityList->tei_entity = IF_ENTITY; EntityList->tei_instance = MyIFBase; (*Count)++; } return TRUE; } //** InitLoopback - Initialize the loopback NTE. // // This function initialized the loopback NTE. We set up the the MSS and // pointer to the various pseudo-link routines, then call InitNTE and return. // // Entry: ConfigInfo - Pointer to config. info structure. // // Returns: TRUE if we initialized, FALSE if we didn't. // NetTableEntry * InitLoopback(IPConfigInfo * ConfigInfo) { LLIPBindInfo ARPInfo; LoopNTE = CTEAllocMem(sizeof(NetTableEntry)); if (LoopNTE == NULL) return LoopNTE; RtlZeroMemory(LoopNTE, sizeof(NetTableEntry)); RtlZeroMemory(&LoopInterface, sizeof(RouteInterface)); LoopNTE->nte_addr = LOOPBACK_ADDR; LoopNTE->nte_mask = CLASSA_MASK; LoopNTE->nte_icmpseq = 1; LoopNTE->nte_flags = NTE_VALID | NTE_ACTIVE | NTE_PRIMARY; CTEInitLock(&LoopNTE->nte_lock); CTEInitLock(&LoopInterface.ri_if.if_lock); LoopNTE->nte_mss = LOOPBACK_MSS; LoopNTE->nte_if = (Interface *) & LoopInterface; LoopInterface.ri_if.if_lcontext = LoopNTE; LoopInterface.ri_if.if_xmit = LoopXmit; LoopInterface.ri_if.if_transfer = LoopXfer; LoopInterface.ri_if.if_close = LoopClose; LoopInterface.ri_if.if_invalidate = LoopInvalidate; LoopInterface.ri_if.if_qinfo = LoopQInfo; LoopInterface.ri_if.if_setinfo = LoopSetInfo; LoopInterface.ri_if.if_getelist = LoopGetEList; LoopInterface.ri_if.if_addaddr = LoopAddAddr; LoopInterface.ri_if.if_deladdr = LoopDelAddr; LoopInterface.ri_if.if_bcast = IP_LOCAL_BCST; LoopInterface.ri_if.if_speed = 10000000; LoopInterface.ri_if.if_mtu = LOOPBACK_MSS; LoopInterface.ri_if.if_llipflags = LIP_COPY_FLAG; LOCKED_REFERENCE_IF(&LoopInterface.ri_if); LoopInterface.ri_if.if_order = MAXLONG; ARPInfo.lip_mss = LOOPBACK_MSS + sizeof(IPHeader); ARPInfo.lip_index = LoopIndex; ARPInfo.lip_close = LoopClose; ARPInfo.lip_addaddr = LoopAddAddr; ARPInfo.lip_deladdr = LoopDelAddr; ARPInfo.lip_flags = LIP_COPY_FLAG; LoopIndex = NumIF + 1; LoopInterface.ri_if.if_index = LoopIndex; CTEInitEvent(&LoopXmitEvent, LoopXmitRtn); CTEInitLock(&LoopLock.Lock); LoopIFE.if_index = LoopIndex; LoopIFE.if_type = IF_TYPE_SOFTWARE_LOOPBACK; LoopIFE.if_mtu = ARPInfo.lip_mss; LoopIFE.if_speed = 10000000; LoopIFE.if_adminstatus = IF_STATUS_UP; LoopIFE.if_operstatus = IF_OPER_STATUS_OPERATIONAL; LoopIFE.if_lastchange = GetTimeTicks(); LoopIFE.if_descrlen = sizeof(LoopName); IFList = (Interface *) & LoopInterface; NumIF++; NumNTE++; if (!InitInterface(LoopNTE)) return NULL; if (!InitNTE(LoopNTE)) return NULL; NumActiveNTE++; return LoopNTE; } #pragma END_INIT