MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Impl.h

   1 /** @file
   2   Ip4 internal functions and type defintions.
   3
   4 Copyright (c) 2005 - 2015, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #ifndef __EFI_IP4_IMPL_H__
  16 #define __EFI_IP4_IMPL_H__
  17
  18 #include <Uefi.h>
  19
  20 #include <Protocol/IpSec.h>
  21 #include <Protocol/Ip4.h>
  22 #include <Protocol/Ip4Config2.h>
  23 #include <Protocol/Arp.h>
  24 #include <Protocol/ManagedNetwork.h>
  25 #include <Protocol/Dhcp4.h>
  26 #include <Protocol/HiiConfigRouting.h>
  27 #include <Protocol/HiiConfigAccess.h>
  28
  29 #include <Library/DebugLib.h>
  30 #include <Library/UefiRuntimeServicesTableLib.h>
  31 #include <Library/UefiDriverEntryPoint.h>
  32 #include <Library/UefiBootServicesTableLib.h>
  33 #include <Library/BaseLib.h>
  34 #include <Library/UefiLib.h>
  35 #include <Library/NetLib.h>
  36 #include <Library/BaseMemoryLib.h>
  37 #include <Library/MemoryAllocationLib.h>
  38 #include <Library/DpcLib.h>
  39 #include <Library/PrintLib.h>
  40 #include <Library/DevicePathLib.h>
  41 #include <Library/HiiLib.h>
  42 #include <Library/UefiHiiServicesLib.h>
  43
  44 #include "Ip4Common.h"
  45 #include "Ip4Driver.h"
  46 #include "Ip4If.h"
  47 #include "Ip4Icmp.h"
  48 #include "Ip4Option.h"
  49 #include "Ip4Igmp.h"
  50 #include "Ip4Route.h"
  51 #include "Ip4Input.h"
  52 #include "Ip4Output.h"
  53 #include "Ip4Config2Impl.h"
  54 #include "Ip4Config2Nv.h"
  55 #include "Ip4NvData.h"
  56
  57 #define IP4_PROTOCOL_SIGNATURE  SIGNATURE_32 ('I', 'P', '4', 'P')
  58 #define IP4_SERVICE_SIGNATURE   SIGNATURE_32 ('I', 'P', '4', 'S')
  59
  60 //
  61 // The state of IP4 protocol. It starts from UNCONFIGED. if it is
  62 // successfully configured, it goes to CONFIGED. if configure NULL
  63 // is called, it becomes UNCONFIGED again. If (partly) destroyed, it
  64 // becomes DESTROY.
  65 //
  66 #define IP4_STATE_UNCONFIGED    0
  67 #define IP4_STATE_CONFIGED      1
  68 #define IP4_STATE_DESTROY       2
  69
  70 //
  71 // The state of IP4 service. It starts from UNSTARTED. It transits
  72 // to STARTED if autoconfigure is started. If default address is
  73 // configured, it becomes CONFIGED. and if partly destroyed, it goes
  74 // to DESTROY.
  75 //
  76 #define IP4_SERVICE_UNSTARTED   0
  77 #define IP4_SERVICE_STARTED     1
  78 #define IP4_SERVICE_CONFIGED    2
  79 #define IP4_SERVICE_DESTROY     3
  80
  81
  82 ///
  83 /// IP4_TXTOKEN_WRAP wraps the upper layer's transmit token.
  84 /// The user's data is kept in the Packet. When fragment is
  85 /// needed, each fragment of the Packet has a reference to the
  86 /// Packet, no data is actually copied. The Packet will be
  87 /// released when all the fragments of it have been recycled by
  88 /// MNP. Upon then, the IP4_TXTOKEN_WRAP will be released, and
  89 /// user's event signalled.
  90 ///
  91 typedef struct {
  92   IP4_PROTOCOL              *IpInstance;
  93   EFI_IP4_COMPLETION_TOKEN  *Token;
  94   EFI_EVENT                 IpSecRecycleSignal;
  95   NET_BUF                   *Packet;
  96   BOOLEAN                   Sent;
  97   INTN                      Life;
  98 } IP4_TXTOKEN_WRAP;
  99
 100 ///
 101 /// IP4_IPSEC_WRAP wraps the packet received from MNP layer. The packet
 102 /// will be released after it has been processed by the receiver. Upon then,
 103 /// the IP4_IPSEC_WRAP will be released, and the IpSecRecycleSignal will be signaled
 104 /// to notice IPsec to free the resources.
 105 ///
 106 typedef struct {
 107   EFI_EVENT                 IpSecRecycleSignal;
 108   NET_BUF                   *Packet;
 109 } IP4_IPSEC_WRAP;
 110
 111 ///
 112 /// IP4_RXDATA_WRAP wraps the data IP4 child delivers to the
 113 /// upper layers. The received packet is kept in the Packet.
 114 /// The Packet itself may be constructured from some fragments.
 115 /// All the fragments of the Packet is organized by a
 116 /// IP4_ASSEMBLE_ENTRY structure. If the Packet is recycled by
 117 /// the upper layer, the assemble entry and its associated
 118 /// fragments will be freed at last.
 119 ///
 120 typedef struct {
 121   LIST_ENTRY                Link;
 122   IP4_PROTOCOL              *IpInstance;
 123   NET_BUF                   *Packet;
 124   EFI_IP4_RECEIVE_DATA      RxData;
 125 } IP4_RXDATA_WRAP;
 126
 127
 128 struct _IP4_PROTOCOL {
 129   UINT32                    Signature;
 130
 131   EFI_IP4_PROTOCOL          Ip4Proto;
 132   EFI_HANDLE                Handle;
 133   INTN                      State;
 134
 135   IP4_SERVICE               *Service;
 136   LIST_ENTRY                Link;       // Link to all the IP protocol from the service
 137
 138   //
 139   // User's transmit/receive tokens, and received/deliverd packets
 140   //
 141   NET_MAP                   RxTokens;
 142   NET_MAP                   TxTokens;   // map between (User's Token, IP4_TXTOKE_WRAP)
 143   LIST_ENTRY                Received;   // Received but not delivered packet
 144   LIST_ENTRY                Delivered;  // Delivered and to be recycled packets
 145   EFI_LOCK                  RecycleLock;
 146
 147   //
 148   // Instance's address and route tables. There are two route tables.
 149   // RouteTable is used by the IP4 driver to route packet. EfiRouteTable
 150   // is used to communicate the current route info to the upper layer.
 151   //
 152   IP4_INTERFACE             *Interface;
 153   LIST_ENTRY                AddrLink;   // Ip instances with the same IP address.
 154   IP4_ROUTE_TABLE           *RouteTable;
 155
 156   EFI_IP4_ROUTE_TABLE       *EfiRouteTable;
 157   UINT32                    EfiRouteCount;
 158
 159   //
 160   // IGMP data for this instance
 161   //
 162   IP4_ADDR                  *Groups;    // stored in network byte order
 163   UINT32                    GroupCount;
 164
 165   EFI_IP4_CONFIG_DATA       ConfigData;
 166
 167 };
 168
 169 struct _IP4_SERVICE {
 170   UINT32                          Signature;
 171   EFI_SERVICE_BINDING_PROTOCOL    ServiceBinding;
 172   INTN                            State;
 173
 174   //
 175   // List of all the IP instances and interfaces, and default
 176   // interface and route table and caches.
 177   //
 178   UINTN                           NumChildren;
 179   LIST_ENTRY                      Children;
 180
 181   LIST_ENTRY                      Interfaces;
 182
 183   IP4_INTERFACE                   *DefaultInterface;
 184   IP4_ROUTE_TABLE                 *DefaultRouteTable;
 185
 186   //
 187   // Ip reassemble utilities, and IGMP data
 188   //
 189   IP4_ASSEMBLE_TABLE              Assemble;
 190   IGMP_SERVICE_DATA               IgmpCtrl;
 191
 192   //
 193   // Low level protocol used by this service instance
 194   //
 195   EFI_HANDLE                      Image;
 196   EFI_HANDLE                      Controller;
 197
 198   EFI_HANDLE                      MnpChildHandle;
 199   EFI_MANAGED_NETWORK_PROTOCOL    *Mnp;
 200
 201   EFI_MANAGED_NETWORK_CONFIG_DATA MnpConfigData;
 202   EFI_SIMPLE_NETWORK_MODE         SnpMode;
 203
 204   EFI_EVENT                       Timer;
 205
 206   EFI_EVENT                       ReconfigEvent;
 207
 208   //
 209   // Underlying media present status.
 210   //
 211   BOOLEAN                         MediaPresent;
 212
 213   //
 214   // IPv4 Configuration II Protocol instance
 215   //
 216   IP4_CONFIG2_INSTANCE            Ip4Config2Instance;
 217
 218   CHAR16                          *MacString;
 219
 220   UINT32                          MaxPacketSize;
 221   UINT32                          OldMaxPacketSize; ///< The MTU before IPsec enable.
 222 };
 223
 224 #define IP4_INSTANCE_FROM_PROTOCOL(Ip4) \
 225           CR ((Ip4), IP4_PROTOCOL, Ip4Proto, IP4_PROTOCOL_SIGNATURE)
 226
 227 #define IP4_SERVICE_FROM_PROTOCOL(Sb)   \
 228           CR ((Sb), IP4_SERVICE, ServiceBinding, IP4_SERVICE_SIGNATURE)
 229
 230 #define IP4_SERVICE_FROM_CONFIG2_INSTANCE(This) \
 231   CR (This, IP4_SERVICE, Ip4Config2Instance, IP4_SERVICE_SIGNATURE)
 232
 233
 234 #define IP4_NO_MAPPING(IpInstance) (!(IpInstance)->Interface->Configured)
 235
 236 extern EFI_IP4_PROTOCOL mEfiIp4ProtocolTemplete;
 237
 238 /**
 239   Config the MNP parameter used by IP. The IP driver use one MNP
 240   child to transmit/receive frames. By default, it configures MNP
 241   to receive unicast/multicast/broadcast. And it will enable/disable
 242   the promiscous receive according to whether there is IP child
 243   enable that or not. If Force is FALSE, it will iterate through
 244   all the IP children to check whether the promiscuous receive
 245   setting has been changed. If it hasn't been changed, it won't
 246   reconfigure the MNP. If Force is TRUE, the MNP is configured no
 247   matter whether that is changed or not.
 248
 249   @param[in]  IpSb               The IP4 service instance that is to be changed.
 250   @param[in]  Force              Force the configuration or not.
 251
 252   @retval EFI_SUCCESS            The MNP is successfully configured/reconfigured.
 253   @retval Others                 Configuration failed.
 254
 255 **/
 256 EFI_STATUS
 257 Ip4ServiceConfigMnp (
 258   IN IP4_SERVICE            *IpSb,
 259   IN BOOLEAN                Force
 260   );
 261
 262 /**
 263   Intiialize the IP4_PROTOCOL structure to the unconfigured states.
 264
 265   @param  IpSb                   The IP4 service instance.
 266   @param  IpInstance             The IP4 child instance.
 267
 268 **/
 269 VOID
 270 Ip4InitProtocol (
 271   IN     IP4_SERVICE            *IpSb,
 272   IN OUT IP4_PROTOCOL           *IpInstance
 273   );
 274
 275 /**
 276   Clean up the IP4 child, release all the resources used by it.
 277
 278   @param[in]  IpInstance         The IP4 child to clean up.
 279
 280   @retval EFI_SUCCESS            The IP4 child is cleaned up.
 281   @retval EFI_DEVICE_ERROR       Some resources failed to be released.
 282
 283 **/
 284 EFI_STATUS
 285 Ip4CleanProtocol (
 286   IN  IP4_PROTOCOL          *IpInstance
 287   );
 288
 289 /**
 290   Cancel the user's receive/transmit request.
 291
 292   @param[in]  IpInstance         The IP4 child.
 293   @param[in]  Token              The token to cancel. If NULL, all token will be
 294                                  cancelled.
 295
 296   @retval EFI_SUCCESS            The token is cancelled.
 297   @retval EFI_NOT_FOUND          The token isn't found on either the
 298                                  transmit/receive queue.
 299   @retval EFI_DEVICE_ERROR       Not all token is cancelled when Token is NULL.
 300
 301 **/
 302 EFI_STATUS
 303 Ip4Cancel (
 304   IN IP4_PROTOCOL             *IpInstance,
 305   IN EFI_IP4_COMPLETION_TOKEN *Token          OPTIONAL
 306   );
 307
 308 /**
 309   Change the IP4 child's multicast setting. The caller
 310   should make sure that the parameters is valid.
 311
 312   @param[in]  IpInstance             The IP4 child to change the setting.
 313   @param[in]  JoinFlag               TRUE to join the group, otherwise leave it
 314   @param[in]  GroupAddress           The target group address
 315
 316   @retval EFI_ALREADY_STARTED    Want to join the group, but already a member of it
 317   @retval EFI_OUT_OF_RESOURCES   Failed to allocate some resources.
 318   @retval EFI_DEVICE_ERROR       Failed to set the group configuraton
 319   @retval EFI_SUCCESS            Successfully updated the group setting.
 320   @retval EFI_NOT_FOUND          Try to leave the group which it isn't a member.
 321
 322 **/
 323 EFI_STATUS
 324 Ip4Groups (
 325   IN IP4_PROTOCOL           *IpInstance,
 326   IN BOOLEAN                JoinFlag,
 327   IN EFI_IPv4_ADDRESS       *GroupAddress       OPTIONAL
 328   );
 329
 330 /**
 331   The heart beat timer of IP4 service instance. It times out
 332   all of its IP4 children's received-but-not-delivered and
 333   transmitted-but-not-recycle packets, and provides time input
 334   for its IGMP protocol.
 335
 336   @param[in]  Event                  The IP4 service instance's heart beat timer.
 337   @param[in]  Context                The IP4 service instance.
 338
 339 **/
 340 VOID
 341 EFIAPI
 342 Ip4TimerTicking (
 343   IN EFI_EVENT              Event,
 344   IN VOID                   *Context
 345   );
 346
 347 /**
 348   Decrease the life of the transmitted packets. If it is
 349   decreased to zero, cancel the packet. This function is
 350   called by Ip4PacketTimerTicking which time out both the
 351   received-but-not-delivered and transmitted-but-not-recycle
 352   packets.
 353
 354   @param[in]  Map                    The IP4 child's transmit map.
 355   @param[in]  Item                   Current transmitted packet.
 356   @param[in]  Context                Not used.
 357
 358   @retval EFI_SUCCESS            Always returns EFI_SUCCESS.
 359
 360 **/
 361 EFI_STATUS
 362 EFIAPI
 363 Ip4SentPacketTicking (
 364   IN NET_MAP                *Map,
 365   IN NET_MAP_ITEM           *Item,
 366   IN VOID                   *Context
 367   );
 368
 369 /**
 370   The callback function for the net buffer which wraps the user's
 371   transmit token. Although it seems this function is pretty simple,
 372   there are some subtle things.
 373   When user requests the IP to transmit a packet by passing it a
 374   token, the token is wrapped in an IP4_TXTOKEN_WRAP and the data
 375   is wrapped in an net buffer. the net buffer's Free function is
 376   set to Ip4FreeTxToken. The Token and token wrap are added to the
 377   IP child's TxToken map. Then the buffer is passed to Ip4Output for
 378   transmission. If something error happened before that, the buffer
 379   is freed, which in turn will free the token wrap. The wrap may
 380   have been added to the TxToken map or not, and the user's event
 381   shouldn't be fired because we are still in the EfiIp4Transmit. If
 382   the buffer has been sent by Ip4Output, it should be removed from
 383   the TxToken map and user's event signaled. The token wrap and buffer
 384   are bound together. Check the comments in Ip4Output for information
 385   about IP fragmentation.
 386
 387   @param[in]  Context                The token's wrap.
 388
 389 **/
 390 VOID
 391 EFIAPI
 392 Ip4FreeTxToken (
 393   IN VOID                   *Context
 394   );
 395
 396 extern EFI_IPSEC2_PROTOCOL   *mIpSec;
 397
 398 #endif