rawip.c File Reference

#include "precomp.h"

Include dependency graph for rawip.c:

Go to the source code of this file.

Functions
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)
NTSTATUS	BuildRawIpPacket (PADDRESS_FILE AddrFile, PIP_PACKET Packet, PIP_ADDRESS RemoteAddress, USHORT RemotePort, PIP_ADDRESS LocalAddress, USHORT LocalPort, PCHAR DataBuffer, UINT DataLen)
NTSTATUS	RawIPSendDatagram (PADDRESS_FILE AddrFile, PTDI_CONNECTION_INFORMATION ConnInfo, PCHAR BufferData, ULONG DataSize, PULONG DataUsed)
VOID	RawIpReceive (PIP_INTERFACE Interface, PIP_PACKET IPPacket)
NTSTATUS	RawIPStartup (VOID)
NTSTATUS	RawIPShutdown (VOID)

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 = sizeof(IPv4_HEADER);
 
    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().

BuildRawIpPacket()

NTSTATUS BuildRawIpPacket	(	PADDRESS_FILE	AddrFile,
		PIP_PACKET	Packet,
		PIP_ADDRESS	RemoteAddress,
		USHORT	RemotePort,
		PIP_ADDRESS	LocalAddress,
		USHORT	LocalPort,
		PCHAR	DataBuffer,
		UINT	DataLen
	)

Definition at line 86 of file rawip.c.

{
    NTSTATUS Status;
    PCHAR Payload;
 
    TI_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    /* FIXME: Assumes IPv4 */
    IPInitializePacket(Packet, IP_ADDRESS_V4);
 
    Packet->TotalSize = sizeof(IPv4_HEADER) + DataLen;
 
    /* Prepare packet */
    Status = AllocatePacketWithBuffer( &Packet->NdisPacket,
                       NULL,
                       Packet->TotalSize );
 
    if( !NT_SUCCESS(Status) ) return Status;
 
    TI_DbgPrint(MID_TRACE, ("Allocated packet: %x\n", Packet->NdisPacket));
    TI_DbgPrint(MID_TRACE, ("Local Addr : %s\n", A2S(LocalAddress)));
    TI_DbgPrint(MID_TRACE, ("Remote Addr: %s\n", A2S(RemoteAddress)));
 
    switch (RemoteAddress->Type) {
    case IP_ADDRESS_V4:
    Status = AddGenericHeaderIPv4
            (AddrFile, RemoteAddress, RemotePort,
             LocalAddress, LocalPort, Packet, DataLen,
             AddrFile->Protocol,
             0, (PVOID *)&Payload );
    break;
    case IP_ADDRESS_V6:
    /* FIXME: Support IPv6 */
        Status = STATUS_UNSUCCESSFUL;
    TI_DbgPrint(MIN_TRACE, ("IPv6 RawIp datagrams are not supported.\n"));
        break;
 
    default:
    Status = STATUS_UNSUCCESSFUL;
        TI_DbgPrint(MIN_TRACE, ("Bad Address Type %d\n", RemoteAddress->Type));
    break;
    }
 
    if( !NT_SUCCESS(Status) ) {
        TI_DbgPrint(MIN_TRACE, ("Cannot add header. Status = (0x%X)\n",
                                Status));
        Packet->Free(Packet);
        return Status;
    }
 
    TI_DbgPrint(MID_TRACE, ("Copying data (hdr %x data %x (%d))\n",
                Packet->Header, Packet->Data,
                (PCHAR)Packet->Data - (PCHAR)Packet->Header));
 
    RtlCopyMemory( Packet->Data, DataBuffer, DataLen );
 
    Packet->Flags |= IP_PACKET_FLAG_RAW;
 
    TI_DbgPrint(MID_TRACE, ("Displaying packet\n"));
 
    DISPLAY_IP_PACKET(Packet);
 
    TI_DbgPrint(MID_TRACE, ("Leaving\n"));
 
    return STATUS_SUCCESS;
}

Referenced by ICMPReply(), and RawIPSendDatagram().

RawIpReceive()

VOID RawIpReceive	(	PIP_INTERFACE	Interface,
		PIP_PACKET	IPPacket
	)

Definition at line 266 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	BufferData,
		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;
 
    LockObject(AddrFile);
 
    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);
            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);
            return STATUS_NETWORK_UNREACHABLE;
        }
 
        LocalAddress = NCE->Interface->Unicast;
    }
    else
    {
        if(!(NCE = NBLocateNeighbor( &LocalAddress, NULL ))) {
            UnlockObject(AddrFile);
            return STATUS_INVALID_PARAMETER;
        }
    }
 
    Status = BuildRawIpPacket( AddrFile,
                               &Packet,
                               &RemoteAddress,
                               RemotePort,
                               &LocalAddress,
                               AddrFile->Port,
                               BufferData,
                               DataSize );
 
    UnlockObject(AddrFile);
 
    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(), and ICMPSendDatagram().

RawIPShutdown()

NTSTATUS RawIPShutdown

(

VOID

)

Definition at line 353 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 337 of file rawip.c.

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

Referenced by DriverEntry().