This graph shows which files directly or indirectly include this file:

Functions
NTSTATUS	RawIPSendDatagram (PADDRESS_FILE AddrFile, PTDI_CONNECTION_INFORMATION ConnInfo, PCHAR Buffer, ULONG DataSize, PULONG DataUsed)

VOID	RawIpReceive (PIP_INTERFACE Interface, PIP_PACKET IPPacket)

NTSTATUS	RawIPStartup (VOID)

NTSTATUS	RawIPShutdown (VOID)

NTSTATUS	AddGenericHeaderIPv4 (PADDRESS_FILE AddrFile, PIP_ADDRESS RemoteAddress, USHORT RemotePort, PIP_ADDRESS LocalAddress, USHORT LocalPort, PIP_PACKET IPPacket, UINT DataLength, UINT Protocol, UINT ExtraLength, PVOID *NextHeader)

Function Documentation

◆ AddGenericHeaderIPv4()

NTSTATUS AddGenericHeaderIPv4	(	PADDRESS_FILE	AddrFile,
		PIP_ADDRESS	RemoteAddress,
		USHORT	RemotePort,
		PIP_ADDRESS	LocalAddress,
		USHORT	LocalPort,
		PIP_PACKET	IPPacket,
		UINT	DataLength,
		UINT	Protocol,
		UINT	ExtraLength,
		PVOID *	NextHeader
	)

Definition at line 13 of file rawip.c.

 {
     PIPv4_HEADER IPHeader;
     ULONG BufferSize;
 
     TI_DbgPrint(MID_TRACE, ("Packet: %x NdisPacket %x\n",
                 IPPacket, IPPacket->NdisPacket));
 
     BufferSize = sizeof(IPv4_HEADER) + ExtraLength;
 
     GetDataPtr( IPPacket->NdisPacket,
         0,
         (PCHAR *)&IPPacket->Header,
         &IPPacket->TotalSize );
     IPPacket->MappedHeader = TRUE;
 
     IPPacket->HeaderSize = 20;
 
     TI_DbgPrint(MAX_TRACE, ("Allocated %d bytes for headers at 0x%X.\n",
                 BufferSize, IPPacket->Header));
     TI_DbgPrint(MAX_TRACE, ("Packet total length %d\n", IPPacket->TotalSize));
 
     /* Build IPv4 header */
     IPHeader = (PIPv4_HEADER)IPPacket->Header;
     /* Version = 4, Length = 5 DWORDs */
     IPHeader->VerIHL = 0x45;
     /* Normal Type-of-Service */
     IPHeader->Tos = 0;
     /* Length of header and data */
     IPHeader->TotalLength = WH2N((USHORT)IPPacket->TotalSize);
     /* Identification */
     IPHeader->Id = (USHORT)Random();
     /* One fragment at offset 0 */
     IPHeader->FlagsFragOfs = 0;
     /* Time-to-Live */
     IPHeader->Ttl = AddrFile->TTL;
     /* Protocol */
     IPHeader->Protocol = Protocol;
     /* Checksum is 0 (for later calculation of this) */
     IPHeader->Checksum = 0;
     /* Source address */
     IPHeader->SrcAddr = LocalAddress->Address.IPv4Address;
     /* Destination address. FIXME: IPv4 only */
     IPHeader->DstAddr = RemoteAddress->Address.IPv4Address;
 
     /* Build RawIp header */
     *NextHeader = (((PCHAR)IPHeader) + sizeof(IPv4_HEADER));
     IPPacket->Data = ((PCHAR)*NextHeader) + ExtraLength;
 
     return STATUS_SUCCESS;
 }

Referenced by AddUDPHeaderIPv4(), and BuildRawIpPacket().

◆ RawIpReceive()

VOID RawIpReceive	(	PIP_INTERFACE	Interface,
		PIP_PACKET	IPPacket
	)

Definition at line 267 of file rawip.c.

 {
   AF_SEARCH SearchContext;
   PIPv4_HEADER IPv4Header;
   PADDRESS_FILE AddrFile;
   PIP_ADDRESS DstAddress, SrcAddress;
   UINT DataSize;
 
   TI_DbgPrint(MAX_TRACE, ("Called.\n"));
 
   switch (IPPacket->Type) {
   /* IPv4 packet */
   case IP_ADDRESS_V4:
     IPv4Header = IPPacket->Header;
     DstAddress = &IPPacket->DstAddr;
     SrcAddress = &IPPacket->SrcAddr;
     DataSize = IPPacket->TotalSize;
     break;
 
   /* IPv6 packet */
   case IP_ADDRESS_V6:
     TI_DbgPrint(MIN_TRACE, ("Discarded IPv6 datagram (%i bytes).\n", IPPacket->TotalSize));
 
     /* FIXME: IPv6 is not supported */
     return;
 
   default:
     return;
   }
 
   /* Locate a receive request on destination address file object
      and deliver the packet if one is found. If there is no receive
      request on the address file object, call the associated receive
      handler. If no receive handler is registered, drop the packet */
 
   AddrFile = AddrSearchFirst(DstAddress,
                              0,
                              IPv4Header->Protocol,
                              &SearchContext);
   if (AddrFile) {
     do {
       DGDeliverData(AddrFile,
             SrcAddress,
                     DstAddress,
                     0,
                     0,
                     IPPacket,
                     DataSize);
       DereferenceObject(AddrFile);
     } while ((AddrFile = AddrSearchNext(&SearchContext)) != NULL);
   } else {
     /* There are no open address files that will take this datagram */
     /* FIXME: IPv4 only */
     TI_DbgPrint(MID_TRACE, ("Cannot deliver IPv4 raw datagram to address (0x%X).\n",
                             DN2H(DstAddress->Address.IPv4Address)));
 
     /* FIXME: Send ICMP reply */
   }
   TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
 }

Referenced by ICMPReceive(), and RawIPStartup().

◆ RawIPSendDatagram()

NTSTATUS RawIPSendDatagram	(	PADDRESS_FILE	AddrFile,
		PTDI_CONNECTION_INFORMATION	ConnInfo,
		PCHAR	Buffer,
		ULONG	DataSize,
		PULONG	DataUsed
	)

Definition at line 171 of file rawip.c.

 {
     IP_PACKET Packet;
     PTA_IP_ADDRESS RemoteAddressTa = (PTA_IP_ADDRESS)ConnInfo->RemoteAddress;
     IP_ADDRESS RemoteAddress,  LocalAddress;
     USHORT RemotePort;
     NTSTATUS Status;
     PNEIGHBOR_CACHE_ENTRY NCE;
     KIRQL OldIrql;
 
     LockObject(AddrFile, &OldIrql);
 
     TI_DbgPrint(MID_TRACE,("Sending Datagram(%x %x %x %d)\n",
                AddrFile, ConnInfo, BufferData, DataSize));
     TI_DbgPrint(MID_TRACE,("RemoteAddressTa: %x\n", RemoteAddressTa));
 
     switch( RemoteAddressTa->Address[0].AddressType ) {
         case TDI_ADDRESS_TYPE_IP:
             RemoteAddress.Type = IP_ADDRESS_V4;
             RemoteAddress.Address.IPv4Address =
             RemoteAddressTa->Address[0].Address[0].in_addr;
             RemotePort = RemoteAddressTa->Address[0].Address[0].sin_port;
             break;
 
         default:
             UnlockObject(AddrFile, OldIrql);
             return STATUS_UNSUCCESSFUL;
     }
 
     TI_DbgPrint(MID_TRACE,("About to get route to destination\n"));
 
     LocalAddress = AddrFile->Address;
     if (AddrIsUnspecified(&LocalAddress))
     {
         /* If the local address is unspecified (0),
          * then use the unicast address of the
          * interface we're sending over
          */
         if(!(NCE = RouteGetRouteToDestination( &RemoteAddress ))) {
             UnlockObject(AddrFile, OldIrql);
             return STATUS_NETWORK_UNREACHABLE;
         }
 
         LocalAddress = NCE->Interface->Unicast;
     }
     else
     {
         if(!(NCE = NBLocateNeighbor( &LocalAddress, NULL ))) {
             UnlockObject(AddrFile, OldIrql);
             return STATUS_INVALID_PARAMETER;
         }
     }
 
     Status = BuildRawIpPacket( AddrFile,
                                &Packet,
                                &RemoteAddress,
                                RemotePort,
                                &LocalAddress,
                                AddrFile->Port,
                                BufferData,
                                DataSize );
 
     UnlockObject(AddrFile, OldIrql);
 
     if( !NT_SUCCESS(Status) )
         return Status;
 
     TI_DbgPrint(MID_TRACE,("About to send datagram\n"));
 
     Status = IPSendDatagram(&Packet, NCE);
     if (!NT_SUCCESS(Status))
         return Status;
 
     *DataUsed = DataSize;
 
     TI_DbgPrint(MID_TRACE,("Leaving\n"));
 
     return STATUS_SUCCESS;
 }

Referenced by FileOpenAddress().

◆ RawIPShutdown()

NTSTATUS RawIPShutdown ( VOID )

Definition at line 356 of file rawip.c.

 {
   /* Deregister this protocol with IP layer */
   IPRegisterProtocol(IPPROTO_RAW, NULL);
 
   return STATUS_SUCCESS;
 }

Referenced by TiUnload().

◆ RawIPStartup()

NTSTATUS RawIPStartup ( VOID )

Definition at line 338 of file rawip.c.

 {
 #ifdef __NTDRIVER__
   RtlZeroMemory(&UDPStats, sizeof(UDP_STATISTICS));
 #endif
 
   /* Register this protocol with IP layer */
   IPRegisterProtocol(IPPROTO_RAW, RawIpReceive);
 
   return STATUS_SUCCESS;
 }