MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Input.h

   1 /** @file
   2
   3 Copyright (c) 2005 - 2009, Intel Corporation. All rights reserved.<BR>
   4 This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 **/
  13
  14 #ifndef __EFI_IP4_INPUT_H__
  15 #define __EFI_IP4_INPUT_H__
  16
  17 #define IP4_MIN_HEADLEN        20
  18 #define IP4_MAX_HEADLEN        60
  19 ///
  20 /// 8(ESP header) + 16(max IV) + 16(max padding) + 2(ESP tail) + 12(max ICV) = 54
  21 ///
  22 #define IP4_MAX_IPSEC_HEADLEN  54
  23
  24 #define IP4_ASSEMLE_HASH_SIZE  31
  25 #define IP4_FRAGMENT_LIFE      120
  26 #define IP4_MAX_PACKET_SIZE    65535
  27
  28 ///
  29 /// Per packet information for input process. LinkFlag specifies whether
  30 /// the packet is received as Link layer unicast, multicast or broadcast.
  31 /// The CastType is the IP layer cast type, such as IP multicast or unicast.
  32 /// Start, End and Length are staffs used to assemble the packets. Start
  33 /// is the sequence number of the first byte of data in the packet. Length
  34 /// is the number of bytes of data. End = Start + Length, that is, the
  35 /// sequence number of last byte + 1. Each assembled packet has a count down
  36 /// life. If it isn't consumed before Life reaches zero, the packet is released.
  37 ///
  38 typedef struct {
  39   UINTN                     LinkFlag;
  40   INTN                      CastType;
  41   INTN                      Start;
  42   INTN                      End;
  43   INTN                      Length;
  44   UINT32                    Life;
  45   EFI_STATUS                Status;
  46 } IP4_CLIP_INFO;
  47
  48 ///
  49 /// Structure used to assemble IP packets.
  50 ///
  51 typedef struct {
  52   LIST_ENTRY                Link;
  53
  54   //
  55   // Identity of one IP4 packet. Each fragment of a packet has
  56   // the same (Dst, Src, Id, Protocol).
  57   //
  58   IP4_ADDR                  Dst;
  59   IP4_ADDR                  Src;
  60   UINT16                    Id;
  61   UINT8                     Protocol;
  62
  63   INTN                      TotalLen;
  64   INTN                      CurLen;
  65   LIST_ENTRY                Fragments;  // List of all the fragments of this packet
  66
  67   IP4_HEAD                  *Head;      // IP head of the first fragment
  68   IP4_CLIP_INFO             *Info;      // Per packet info of the first fragment
  69   INTN                      Life;       // Count down life for the packet.
  70 } IP4_ASSEMBLE_ENTRY;
  71
  72 ///
  73 /// Each Ip service instance has an assemble table to reassemble
  74 /// the packets before delivery to its children. It is organized
  75 /// as hash table.
  76 ///
  77 typedef struct {
  78   LIST_ENTRY      Bucket[IP4_ASSEMLE_HASH_SIZE];
  79 } IP4_ASSEMBLE_TABLE;
  80
  81 #define IP4_GET_CLIP_INFO(Packet) ((IP4_CLIP_INFO *) ((Packet)->ProtoData))
  82
  83 #define IP4_ASSEMBLE_HASH(Dst, Src, Id, Proto)  \
  84           (((Dst) + (Src) + ((Id) << 16) + (Proto)) % IP4_ASSEMLE_HASH_SIZE)
  85
  86 #define IP4_RXDATA_WRAP_SIZE(NumFrag) \
  87           (sizeof (IP4_RXDATA_WRAP) + sizeof (EFI_IP4_FRAGMENT_DATA) * ((NumFrag) - 1))
  88
  89 /**
  90   Initialize an already allocated assemble table. This is generally
  91   the assemble table embedded in the IP4 service instance.
  92
  93   @param[in, out]  Table                  The assemble table to initialize.
  94
  95 **/
  96 VOID
  97 Ip4InitAssembleTable (
  98   IN OUT IP4_ASSEMBLE_TABLE     *Table
  99   );
 100
 101 /**
 102   Clean up the assemble table: remove all the fragments
 103   and assemble entries.
 104
 105   @param[in]  Table                  The assemble table to clean up
 106
 107 **/
 108 VOID
 109 Ip4CleanAssembleTable (
 110   IN IP4_ASSEMBLE_TABLE     *Table
 111   );
 112
 113 /**
 114   The IP4 input routine. It is called by the IP4_INTERFACE when a
 115   IP4 fragment is received from MNP.
 116
 117   @param[in]  Ip4Instance        The IP4 child that request the receive, most like
 118                                  it is NULL.
 119   @param[in]  Packet             The IP4 packet received.
 120   @param[in]  IoStatus           The return status of receive request.
 121   @param[in]  Flag               The link layer flag for the packet received, such
 122                                  as multicast.
 123   @param[in]  Context            The IP4 service instance that own the MNP.
 124
 125 **/
 126 VOID
 127 Ip4AccpetFrame (
 128   IN IP4_PROTOCOL           *Ip4Instance,
 129   IN NET_BUF                *Packet,
 130   IN EFI_STATUS             IoStatus,
 131   IN UINT32                 Flag,
 132   IN VOID                   *Context
 133   );
 134
 135 /**
 136   Demultiple the packet. the packet delivery is processed in two
 137   passes. The first pass will enque a shared copy of the packet
 138   to each IP4 child that accepts the packet. The second pass will
 139   deliver a non-shared copy of the packet to each IP4 child that
 140   has pending receive requests. Data is copied if more than one
 141   child wants to consume the packet because each IP child needs
 142   its own copy of the packet to make changes.
 143
 144   @param[in]  IpSb                   The IP4 service instance that received the packet
 145   @param[in]  Head                   The header of the received packet
 146   @param[in]  Packet                 The data of the received packet
 147
 148   @retval EFI_NOT_FOUND          No IP child accepts the packet
 149   @retval EFI_SUCCESS            The packet is enqueued or delivered to some IP
 150                                  children.
 151
 152 **/
 153 EFI_STATUS
 154 Ip4Demultiplex (
 155   IN IP4_SERVICE            *IpSb,
 156   IN IP4_HEAD               *Head,
 157   IN NET_BUF                *Packet
 158   );
 159
 160 /**
 161   Enqueue a received packet to all the IP children that share
 162   the same interface.
 163
 164   @param[in]  IpSb                   The IP4 service instance that receive the packet
 165   @param[in]  Head                   The header of the received packet
 166   @param[in]  Packet                 The data of the received packet
 167   @param[in]  IpIf                   The interface to enqueue the packet to
 168
 169   @return The number of the IP4 children that accepts the packet
 170
 171 **/
 172 INTN
 173 Ip4InterfaceEnquePacket (
 174   IN IP4_SERVICE            *IpSb,
 175   IN IP4_HEAD               *Head,
 176   IN NET_BUF                *Packet,
 177   IN IP4_INTERFACE          *IpIf
 178   );
 179
 180 /**
 181   Deliver the received packets to upper layer if there are both received
 182   requests and enqueued packets. If the enqueued packet is shared, it will
 183   duplicate it to a non-shared packet, release the shared packet, then
 184   deliver the non-shared packet up.
 185
 186   @param[in]  IpInstance         The IP child to deliver the packet up.
 187
 188   @retval EFI_OUT_OF_RESOURCES   Failed to allocate resources to deliver the
 189                                  packets.
 190   @retval EFI_SUCCESS            All the enqueued packets that can be delivered
 191                                  are delivered up.
 192
 193 **/
 194 EFI_STATUS
 195 Ip4InstanceDeliverPacket (
 196   IN IP4_PROTOCOL           *IpInstance
 197   );
 198
 199 /**
 200   Timeout the fragment and enqueued packets.
 201
 202   @param[in]  IpSb                   The IP4 service instance to timeout
 203
 204 **/
 205 VOID
 206 Ip4PacketTimerTicking (
 207   IN IP4_SERVICE            *IpSb
 208   );
 209
 210 /**
 211   The work function to locate IPsec protocol to process the inbound or
 212   outbound IP packets. The process routine handls the packet with following
 213   actions: bypass the packet, discard the packet, or protect the packet.
 214
 215   @param[in]       IpSb          The IP4 service instance
 216   @param[in]       Head          The The caller supplied IP4 header.
 217   @param[in, out]  Netbuf        The IP4 packet to be processed by IPsec
 218   @param[in]       Options       The caller supplied options
 219   @param[in]       OptionsLen    The length of the option
 220   @param[in]       Direction     The directionality in an SPD entry,
 221                                  EfiIPsecInBound or EfiIPsecOutBound
 222   @param[in]       Context       The token's wrap
 223
 224   @retval EFI_SUCCESS            The IPsec protocol is not available or disabled.
 225   @retval EFI_SUCCESS            The packet was bypassed and all buffers remain the same.
 226   @retval EFI_SUCCESS            The packet was protected.
 227   @retval EFI_ACCESS_DENIED      The packet was discarded.
 228   @retval EFI_OUT_OF_RESOURCES   There is no suffcient resource to complete the operation.
 229   @retval EFI_BUFFER_TOO_SMALL   The number of non-empty block is bigger than the
 230                                  number of input data blocks when build a fragment table.
 231
 232 **/
 233 EFI_STATUS
 234 Ip4IpSecProcessPacket (
 235   IN IP4_SERVICE            *IpSb,
 236   IN IP4_HEAD               *Head,
 237   IN OUT NET_BUF            **Netbuf,
 238   IN UINT8                  *Options,
 239   IN UINT32                 OptionsLen,
 240   IN EFI_IPSEC_TRAFFIC_DIR  Direction,
 241   IN VOID                   *Context
 242   );
 243
 244 #endif