MdeModulePkg/Universal/Network/Ip4Dxe/Ip4If.c

   1 /** @file
   2   Implement IP4 pesudo interface.
   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 #include "Ip4Impl.h"
  16
  17 //
  18 // Mac address with all zero, used to determine whethter the ARP
  19 // resolve succeeded. Failed ARP requests zero the MAC address buffer.
  20 //
  21 EFI_MAC_ADDRESS  mZeroMacAddress;
  22
  23 /**
  24   Callback funtion when frame transmission is finished. It will
  25   call the frame owner's callback function to tell it the result.
  26
  27   @param[in]  Context            Context which is point to the token.
  28
  29 **/
  30 VOID
  31 EFIAPI
  32 Ip4OnFrameSentDpc (
  33   IN VOID                    *Context
  34   );
  35
  36 /**
  37   Request Ip4OnFrameSentDpc as a DPC at TPL_CALLBACK.
  38
  39   @param[in]  Event              The transmit token's event.
  40   @param[in]  Context            Context which is point to the token.
  41
  42 **/
  43 VOID
  44 EFIAPI
  45 Ip4OnFrameSent (
  46   IN EFI_EVENT               Event,
  47   IN VOID                    *Context
  48   );
  49
  50 /**
  51   Callback function when ARP request are finished. It will cancelled
  52   all the queued frame if the ARP requests failed. Or transmit them
  53   if the request succeed.
  54
  55   @param[in]  Context           The context of the callback, a point to the ARP
  56                                 queue
  57
  58 **/
  59 VOID
  60 EFIAPI
  61 Ip4OnArpResolvedDpc (
  62   IN VOID                   *Context
  63   );
  64
  65 /**
  66   Request Ip4OnArpResolvedDpc as a DPC at TPL_CALLBACK.
  67
  68   @param  Event             The Arp request event.
  69   @param  Context           The context of the callback, a point to the ARP
  70                             queue.
  71
  72 **/
  73 VOID
  74 EFIAPI
  75 Ip4OnArpResolved (
  76   IN EFI_EVENT              Event,
  77   IN VOID                   *Context
  78   );
  79
  80 /**
  81   Received a frame from MNP, wrap it in net buffer then deliver
  82   it to IP's input function. The ownship of the packet also
  83   transferred to IP. When Ip is finished with this packet, it
  84   will call NetbufFree to release the packet, NetbufFree will
  85   again call the Ip4RecycleFrame to signal MNP's event and free
  86   the token used.
  87
  88   @param  Context               Context for the callback.
  89
  90 **/
  91 VOID
  92 EFIAPI
  93 Ip4OnFrameReceivedDpc (
  94   IN VOID                     *Context
  95   );
  96
  97 /**
  98   Request Ip4OnFrameReceivedDpc as a DPC at TPL_CALLBACK.
  99
 100   @param Event      The receive event delivered to MNP for receive.
 101   @param Context    Context for the callback.
 102
 103 **/
 104 VOID
 105 EFIAPI
 106 Ip4OnFrameReceived (
 107   IN EFI_EVENT                Event,
 108   IN VOID                     *Context
 109   );
 110
 111 /**
 112   Remove all the frames on the ARP queue that pass the FrameToCancel,
 113   that is, either FrameToCancel is NULL or it returns true for the frame.
 114
 115   @param[in]  ArpQue            ARP frame to remove the frames from.
 116   @param[in]  IoStatus          The status returned to the cancelled frames'
 117                                 callback function.
 118   @param[in]  FrameToCancel     Function to select which frame to cancel.
 119   @param[in]  Context           Opaque parameter to the FrameToCancel.
 120
 121 **/
 122 VOID
 123 Ip4CancelFrameArp (
 124   IN IP4_ARP_QUE            *ArpQue,
 125   IN EFI_STATUS             IoStatus,
 126   IN IP4_FRAME_TO_CANCEL    FrameToCancel  OPTIONAL,
 127   IN VOID                   *Context
 128   );
 129
 130
 131 /**
 132   Wrap a transmit request into a newly allocated IP4_LINK_TX_TOKEN.
 133
 134   @param[in]  Interface         The interface to send out to.
 135   @param[in]  IpInstance        The IpInstance that transmit the packet.  NULL if
 136                                 the packet is sent by the IP4 driver itself.
 137   @param[in]  Packet            The packet to transmit
 138   @param[in]  CallBack          Call back function to execute if transmission
 139                                 finished.
 140   @param[in]  Context           Opaque parameter to the call back.
 141
 142   @retval   Token               The wrapped token if succeed
 143   @retval   NULL                The wrapped token if NULL
 144
 145 **/
 146 IP4_LINK_TX_TOKEN *
 147 Ip4WrapLinkTxToken (
 148   IN IP4_INTERFACE          *Interface,
 149   IN IP4_PROTOCOL           *IpInstance     OPTIONAL,
 150   IN NET_BUF                *Packet,
 151   IN IP4_FRAME_CALLBACK     CallBack,
 152   IN VOID                   *Context
 153   )
 154 {
 155   EFI_MANAGED_NETWORK_COMPLETION_TOKEN  *MnpToken;
 156   EFI_MANAGED_NETWORK_TRANSMIT_DATA     *MnpTxData;
 157   IP4_LINK_TX_TOKEN                     *Token;
 158   EFI_STATUS                            Status;
 159   UINT32                                Count;
 160
 161   Token = AllocatePool (sizeof (IP4_LINK_TX_TOKEN) + \
 162             (Packet->BlockOpNum - 1) * sizeof (EFI_MANAGED_NETWORK_FRAGMENT_DATA));
 163
 164   if (Token == NULL) {
 165     return NULL;
 166   }
 167
 168   Token->Signature = IP4_FRAME_TX_SIGNATURE;
 169   InitializeListHead (&Token->Link);
 170
 171   Token->Interface  = Interface;
 172   Token->IpInstance = IpInstance;
 173   Token->CallBack   = CallBack;
 174   Token->Packet     = Packet;
 175   Token->Context    = Context;
 176   CopyMem (&Token->DstMac, &mZeroMacAddress, sizeof (Token->DstMac));
 177   CopyMem (&Token->SrcMac, &Interface->Mac, sizeof (Token->SrcMac));
 178
 179   MnpToken          = &(Token->MnpToken);
 180   MnpToken->Status  = EFI_NOT_READY;
 181
 182   Status = gBS->CreateEvent (
 183                   EVT_NOTIFY_SIGNAL,
 184                   TPL_NOTIFY,
 185                   Ip4OnFrameSent,
 186                   Token,
 187                   &MnpToken->Event
 188                   );
 189
 190   if (EFI_ERROR (Status)) {
 191     FreePool (Token);
 192     return NULL;
 193   }
 194
 195   MnpTxData                     = &Token->MnpTxData;
 196   MnpToken->Packet.TxData       = MnpTxData;
 197
 198   MnpTxData->DestinationAddress = &Token->DstMac;
 199   MnpTxData->SourceAddress      = &Token->SrcMac;
 200   MnpTxData->ProtocolType       = IP4_ETHER_PROTO;
 201   MnpTxData->DataLength         = Packet->TotalSize;
 202   MnpTxData->HeaderLength       = 0;
 203
 204   Count                         = Packet->BlockOpNum;
 205
 206   NetbufBuildExt (Packet, (NET_FRAGMENT *) MnpTxData->FragmentTable, &Count);
 207   MnpTxData->FragmentCount      = (UINT16)Count;
 208
 209   return Token;
 210 }
 211
 212
 213 /**
 214   Free the link layer transmit token. It will close the event
 215   then free the memory used.
 216
 217   @param[in]  Token                 Token to free
 218
 219 **/
 220 VOID
 221 Ip4FreeLinkTxToken (
 222   IN IP4_LINK_TX_TOKEN      *Token
 223   )
 224 {
 225   NET_CHECK_SIGNATURE (Token, IP4_FRAME_TX_SIGNATURE);
 226
 227   gBS->CloseEvent (Token->MnpToken.Event);
 228   FreePool (Token);
 229 }
 230
 231
 232 /**
 233   Create an IP_ARP_QUE structure to request ARP service.
 234
 235   @param[in]  Interface         The interface to send ARP from.
 236   @param[in]  DestIp            The destination IP (host byte order) to request MAC
 237                                 for
 238
 239   @return Point to newly created IP4_ARP_QUE if succeed, otherwise NULL.
 240
 241 **/
 242 IP4_ARP_QUE *
 243 Ip4CreateArpQue (
 244   IN IP4_INTERFACE          *Interface,
 245   IN IP4_ADDR               DestIp
 246   )
 247 {
 248   IP4_ARP_QUE               *ArpQue;
 249   EFI_STATUS                Status;
 250
 251   ArpQue = AllocatePool (sizeof (IP4_ARP_QUE));
 252
 253   if (ArpQue == NULL) {
 254     return NULL;
 255   }
 256
 257   ArpQue->Signature = IP4_FRAME_ARP_SIGNATURE;
 258   InitializeListHead (&ArpQue->Link);
 259
 260   InitializeListHead (&ArpQue->Frames);
 261   ArpQue->Interface = Interface;
 262
 263   Status = gBS->CreateEvent (
 264                   EVT_NOTIFY_SIGNAL,
 265                   TPL_NOTIFY,
 266                   Ip4OnArpResolved,
 267                   ArpQue,
 268                   &ArpQue->OnResolved
 269                   );
 270
 271   if (EFI_ERROR (Status)) {
 272     FreePool (ArpQue);
 273     return NULL;
 274   }
 275
 276   ArpQue->Ip  = DestIp;
 277   CopyMem (&ArpQue->Mac, &mZeroMacAddress, sizeof (ArpQue->Mac));
 278
 279   return ArpQue;
 280 }
 281
 282
 283 /**
 284   Remove all the transmit requests queued on the ARP queue, then free it.
 285
 286   @param[in]  ArpQue            Arp queue to free
 287   @param[in]  IoStatus          The transmit status returned to transmit requests'
 288                                 callback.
 289
 290 **/
 291 VOID
 292 Ip4FreeArpQue (
 293   IN IP4_ARP_QUE            *ArpQue,
 294   IN EFI_STATUS             IoStatus
 295   )
 296 {
 297   NET_CHECK_SIGNATURE (ArpQue, IP4_FRAME_ARP_SIGNATURE);
 298
 299   //
 300   // Remove all the frame waiting the ARP response
 301   //
 302   Ip4CancelFrameArp (ArpQue, IoStatus, NULL, NULL);
 303
 304   gBS->CloseEvent (ArpQue->OnResolved);
 305   FreePool (ArpQue);
 306 }
 307
 308
 309 /**
 310   Create a link layer receive token to wrap the receive request
 311
 312   @param[in]  Interface         The interface to receive from
 313   @param[in]  IpInstance        The instance that request the receive (NULL for IP4
 314                                 driver itself)
 315   @param[in]  CallBack          Call back function to execute when finished.
 316   @param[in]  Context           Opaque parameters to the callback
 317
 318   @return Point to created IP4_LINK_RX_TOKEN if succeed, otherwise NULL.
 319
 320 **/
 321 IP4_LINK_RX_TOKEN *
 322 Ip4CreateLinkRxToken (
 323   IN IP4_INTERFACE          *Interface,
 324   IN IP4_PROTOCOL           *IpInstance,
 325   IN IP4_FRAME_CALLBACK     CallBack,
 326   IN VOID                   *Context
 327   )
 328 {
 329   EFI_MANAGED_NETWORK_COMPLETION_TOKEN  *MnpToken;
 330   IP4_LINK_RX_TOKEN                     *Token;
 331   EFI_STATUS                            Status;
 332
 333   Token = AllocatePool (sizeof (IP4_LINK_RX_TOKEN));
 334   if (Token == NULL) {
 335     return NULL;
 336   }
 337
 338   Token->Signature  = IP4_FRAME_RX_SIGNATURE;
 339   Token->Interface  = Interface;
 340   Token->IpInstance = IpInstance;
 341   Token->CallBack   = CallBack;
 342   Token->Context    = Context;
 343
 344   MnpToken          = &Token->MnpToken;
 345   MnpToken->Status  = EFI_NOT_READY;
 346
 347   Status = gBS->CreateEvent (
 348                   EVT_NOTIFY_SIGNAL,
 349                   TPL_NOTIFY,
 350                   Ip4OnFrameReceived,
 351                   Token,
 352                   &MnpToken->Event
 353                   );
 354
 355   if (EFI_ERROR (Status)) {
 356     FreePool (Token);
 357     return NULL;
 358   }
 359
 360   MnpToken->Packet.RxData = NULL;
 361   return Token;
 362 }
 363
 364
 365 /**
 366   Free the link layer request token. It will close the event
 367   then free the memory used.
 368
 369   @param[in]  Token                 Request token to free.
 370
 371 **/
 372 VOID
 373 Ip4FreeFrameRxToken (
 374   IN IP4_LINK_RX_TOKEN      *Token
 375   )
 376 {
 377
 378   NET_CHECK_SIGNATURE (Token, IP4_FRAME_RX_SIGNATURE);
 379
 380   gBS->CloseEvent (Token->MnpToken.Event);
 381   FreePool (Token);
 382 }
 383
 384
 385 /**
 386   Remove all the frames on the ARP queue that pass the FrameToCancel,
 387   that is, either FrameToCancel is NULL or it returns true for the frame.
 388
 389   @param[in]  ArpQue            ARP frame to remove the frames from.
 390   @param[in]  IoStatus          The status returned to the cancelled frames'
 391                                 callback function.
 392   @param[in]  FrameToCancel     Function to select which frame to cancel.
 393   @param[in]  Context           Opaque parameter to the FrameToCancel.
 394
 395 **/
 396 VOID
 397 Ip4CancelFrameArp (
 398   IN IP4_ARP_QUE            *ArpQue,
 399   IN EFI_STATUS             IoStatus,
 400   IN IP4_FRAME_TO_CANCEL    FrameToCancel  OPTIONAL,
 401   IN VOID                   *Context
 402   )
 403 {
 404   LIST_ENTRY                *Entry;
 405   LIST_ENTRY                *Next;
 406   IP4_LINK_TX_TOKEN         *Token;
 407
 408   NET_LIST_FOR_EACH_SAFE (Entry, Next, &ArpQue->Frames) {
 409     Token = NET_LIST_USER_STRUCT (Entry, IP4_LINK_TX_TOKEN, Link);
 410
 411     if ((FrameToCancel == NULL) || FrameToCancel (Token, Context)) {
 412       RemoveEntryList (Entry);
 413
 414       Token->CallBack (Token->IpInstance, Token->Packet, IoStatus, 0, Token->Context);
 415       Ip4FreeLinkTxToken (Token);
 416     }
 417   }
 418 }
 419
 420
 421 /**
 422   Remove all the frames on the interface that pass the FrameToCancel,
 423   either queued on ARP queues or that have already been delivered to
 424   MNP and not yet recycled.
 425
 426   @param[in]  Interface         Interface to remove the frames from.
 427   @param[in]  IoStatus          The transmit status returned to the frames'
 428                                 callback.
 429   @param[in]  FrameToCancel     Function to select the frame to cancel, NULL to
 430                                 select all.
 431   @param[in]  Context           Opaque parameters passed to FrameToCancel.
 432
 433 **/
 434 VOID
 435 Ip4CancelFrames (
 436   IN IP4_INTERFACE          *Interface,
 437   IN EFI_STATUS             IoStatus,
 438   IN IP4_FRAME_TO_CANCEL    FrameToCancel    OPTIONAL,
 439   IN VOID                   *Context
 440   )
 441 {
 442   LIST_ENTRY                *Entry;
 443   LIST_ENTRY                *Next;
 444   IP4_ARP_QUE               *ArpQue;
 445   IP4_LINK_TX_TOKEN         *Token;
 446
 447   //
 448   // Cancel all the pending frames on ARP requests
 449   //
 450   NET_LIST_FOR_EACH_SAFE (Entry, Next, &Interface->ArpQues) {
 451     ArpQue = NET_LIST_USER_STRUCT (Entry, IP4_ARP_QUE, Link);
 452
 453     Ip4CancelFrameArp (ArpQue, IoStatus, FrameToCancel, Context);
 454
 455     if (IsListEmpty (&ArpQue->Frames)) {
 456       Interface->Arp->Cancel (Interface->Arp, &ArpQue->Ip, ArpQue->OnResolved);
 457     }
 458   }
 459
 460   //
 461   // Cancel all the frames that have been delivered to MNP
 462   // but not yet recycled.
 463   //
 464   NET_LIST_FOR_EACH_SAFE (Entry, Next, &Interface->SentFrames) {
 465     Token = NET_LIST_USER_STRUCT (Entry, IP4_LINK_TX_TOKEN, Link);
 466
 467     if ((FrameToCancel == NULL) || FrameToCancel (Token, Context)) {
 468       Interface->Mnp->Cancel (Interface->Mnp, &Token->MnpToken);
 469     }
 470   }
 471 }
 472
 473
 474 /**
 475   Create an IP4_INTERFACE. Delay the creation of ARP instance until
 476   the interface is configured.
 477
 478   @param[in]  Mnp               The shared MNP child of this IP4 service binding
 479                                 instance.
 480   @param[in]  Controller        The controller this IP4 service binding instance
 481                                 is installed. Most like the UNDI handle.
 482   @param[in]  ImageHandle       This driver's image handle.
 483
 484   @return Point to the created IP4_INTERFACE, otherwise NULL.
 485
 486 **/
 487 IP4_INTERFACE *
 488 Ip4CreateInterface (
 489   IN  EFI_MANAGED_NETWORK_PROTOCOL  *Mnp,
 490   IN  EFI_HANDLE                    Controller,
 491   IN  EFI_HANDLE                    ImageHandle
 492   )
 493 {
 494   IP4_INTERFACE             *Interface;
 495   EFI_SIMPLE_NETWORK_MODE   SnpMode;
 496
 497   Interface = AllocatePool (sizeof (IP4_INTERFACE));
 498
 499   if ((Interface == NULL) || (Mnp == NULL)) {
 500     return NULL;
 501   }
 502
 503   Interface->Signature = IP4_INTERFACE_SIGNATURE;
 504   InitializeListHead (&Interface->Link);
 505   Interface->RefCnt     = 1;
 506
 507   Interface->Ip         = IP4_ALLZERO_ADDRESS;
 508   Interface->SubnetMask = IP4_ALLZERO_ADDRESS;
 509   Interface->Configured = FALSE;
 510
 511   Interface->Controller = Controller;
 512   Interface->Image      = ImageHandle;
 513   Interface->Mnp        = Mnp;
 514   Interface->Arp        = NULL;
 515   Interface->ArpHandle  = NULL;
 516
 517   InitializeListHead (&Interface->ArpQues);
 518   InitializeListHead (&Interface->SentFrames);
 519
 520   Interface->RecvRequest = NULL;
 521
 522   //
 523   // Get the interface's Mac address and broadcast mac address from SNP
 524   //
 525   if (EFI_ERROR (Mnp->GetModeData (Mnp, NULL, &SnpMode))) {
 526     FreePool (Interface);
 527     return NULL;
 528   }
 529
 530   CopyMem (&Interface->Mac, &SnpMode.CurrentAddress, sizeof (Interface->Mac));
 531   CopyMem (&Interface->BroadcastMac, &SnpMode.BroadcastAddress, sizeof (Interface->BroadcastMac));
 532   Interface->HwaddrLen    = SnpMode.HwAddressSize;
 533
 534   InitializeListHead (&Interface->IpInstances);
 535   Interface->PromiscRecv = FALSE;
 536
 537   return Interface;
 538 }
 539
 540
 541 /**
 542   Set the interface's address, create and configure
 543   the ARP child if necessary.
 544
 545   @param  Interface         The interface to set the address.
 546   @param  IpAddr            The interface's IP address.
 547   @param  SubnetMask        The interface's netmask.
 548
 549   @retval EFI_SUCCESS           The interface is configured with Ip/netmask pair,
 550                                 and a ARP is created for it.
 551   @retval Others                Failed to set the interface's address.
 552
 553 **/
 554 EFI_STATUS
 555 Ip4SetAddress (
 556   IN OUT IP4_INTERFACE      *Interface,
 557   IN     IP4_ADDR           IpAddr,
 558   IN     IP4_ADDR           SubnetMask
 559   )
 560 {
 561   EFI_ARP_CONFIG_DATA       ArpConfig;
 562   EFI_STATUS                Status;
 563   INTN                      Type;
 564   INTN                      Len;
 565   IP4_ADDR                  Netmask;
 566
 567   NET_CHECK_SIGNATURE (Interface, IP4_INTERFACE_SIGNATURE);
 568
 569   //
 570   // Set the ip/netmask, then compute the subnet broadcast
 571   // and network broadcast for easy access. When computing
 572   // nework broadcast, the subnet mask is most like longer
 573   // than the default netmask (not subneted) as defined in
 574   // RFC793. If that isn't the case, we are aggregating the
 575   // networks, use the subnet's mask instead.
 576   //
 577   Interface->Ip             = IpAddr;
 578   Interface->SubnetMask     = SubnetMask;
 579   Interface->SubnetBrdcast  = (IpAddr | ~SubnetMask);
 580
 581   Type                      = NetGetIpClass (IpAddr);
 582   ASSERT (Type <= IP4_ADDR_CLASSC);
 583   Len                       = NetGetMaskLength (SubnetMask);
 584   ASSERT (Len < IP4_MASK_NUM);
 585   Netmask                   = gIp4AllMasks[MIN (Len, Type << 3)];
 586   Interface->NetBrdcast     = (IpAddr | ~Netmask);
 587
 588   //
 589   // Do clean up for Arp child
 590   //
 591   if (Interface->ArpHandle != NULL) {
 592     if (Interface->Arp != NULL) {
 593       gBS->CloseProtocol (
 594              Interface->ArpHandle,
 595              &gEfiArpProtocolGuid,
 596              Interface->Image,
 597              Interface->Controller
 598              );
 599
 600       Interface->Arp = NULL;
 601     }
 602
 603     NetLibDestroyServiceChild (
 604       Interface->Controller,
 605       Interface->Image,
 606       &gEfiArpServiceBindingProtocolGuid,
 607       &Interface->ArpHandle
 608       );
 609
 610     Interface->ArpHandle = NULL;
 611   }
 612
 613   //
 614   // If the address is NOT all zero, create then configure an ARP child.
 615   // Pay attention: DHCP configures its station address as 0.0.0.0/0
 616   //
 617   if (IpAddr != IP4_ALLZERO_ADDRESS) {
 618     Status = NetLibCreateServiceChild (
 619                Interface->Controller,
 620                Interface->Image,
 621                &gEfiArpServiceBindingProtocolGuid,
 622                &Interface->ArpHandle
 623                );
 624
 625     if (EFI_ERROR (Status)) {
 626       return Status;
 627     }
 628
 629     Status = gBS->OpenProtocol (
 630                     Interface->ArpHandle,
 631                     &gEfiArpProtocolGuid,
 632                     (VOID **) &Interface->Arp,
 633                     Interface->Image,
 634                     Interface->Controller,
 635                     EFI_OPEN_PROTOCOL_BY_DRIVER
 636                     );
 637
 638     if (EFI_ERROR (Status)) {
 639       goto ON_ERROR;
 640     }
 641
 642     IpAddr                    = HTONL (IpAddr);
 643     ArpConfig.SwAddressType   = IP4_ETHER_PROTO;
 644     ArpConfig.SwAddressLength = 4;
 645     ArpConfig.StationAddress  = &IpAddr;
 646     ArpConfig.EntryTimeOut    = 0;
 647     ArpConfig.RetryCount      = 0;
 648     ArpConfig.RetryTimeOut    = 0;
 649
 650     Status = Interface->Arp->Configure (Interface->Arp, &ArpConfig);
 651
 652     if (EFI_ERROR (Status)) {
 653       gBS->CloseProtocol (
 654              Interface->ArpHandle,
 655              &gEfiArpProtocolGuid,
 656              Interface->Image,
 657              Interface->Controller
 658              );
 659
 660       goto ON_ERROR;
 661     }
 662   }
 663
 664   Interface->Configured = TRUE;
 665   return EFI_SUCCESS;
 666
 667 ON_ERROR:
 668   NetLibDestroyServiceChild (
 669     Interface->Controller,
 670     Interface->Image,
 671     &gEfiArpServiceBindingProtocolGuid,
 672     &Interface->ArpHandle
 673     );
 674
 675   return Status;
 676 }
 677
 678
 679 /**
 680   Filter function to cancel all the frame related to an IP instance.
 681
 682   @param[in]  Frame             The transmit request to test whether to cancel
 683   @param[in]  Context           The context which is the Ip instance that issued
 684                                 the transmit.
 685
 686   @retval TRUE                  The frame belongs to this instance and is to be
 687                                 removed
 688   @retval FALSE                 The frame doesn't belong to this instance.
 689
 690 **/
 691 BOOLEAN
 692 Ip4CancelInstanceFrame (
 693   IN IP4_LINK_TX_TOKEN *Frame,
 694   IN VOID              *Context
 695   )
 696 {
 697   if (Frame->IpInstance == (IP4_PROTOCOL *) Context) {
 698     return TRUE;
 699   }
 700
 701   return FALSE;
 702 }
 703
 704
 705
 706 /**
 707   If there is a pending receive request, cancel it. Don't call
 708   the receive request's callback because this function can be only
 709   called if the instance or driver is tearing itself down. It
 710   doesn't make sense to call it back. But it is necessary to call
 711   the transmit token's callback to give it a chance to free the
 712   packet and update the upper layer's transmit request status, say
 713   that from the UDP.
 714
 715   @param[in]  Interface         The interface used by the IpInstance
 716
 717 **/
 718 VOID
 719 Ip4CancelReceive (
 720   IN IP4_INTERFACE          *Interface
 721   )
 722 {
 723   EFI_TPL                   OldTpl;
 724   IP4_LINK_RX_TOKEN         *Token;
 725
 726   if ((Token = Interface->RecvRequest) != NULL) {
 727     OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 728
 729     Interface->RecvRequest = NULL;
 730     Interface->Mnp->Cancel (Interface->Mnp, &Token->MnpToken);
 731
 732     gBS->RestoreTPL (OldTpl);
 733   }
 734 }
 735
 736
 737 /**
 738   Free the interface used by IpInstance. All the IP instance with
 739   the same Ip/Netmask pair share the same interface. It is reference
 740   counted. All the frames haven't been sent will be cancelled.
 741   Because the IpInstance is optional, the caller must remove
 742   IpInstance from the interface's instance list itself.
 743
 744   @param[in]  Interface         The interface used by the IpInstance.
 745   @param[in]  IpInstance        The Ip instance that free the interface. NULL if
 746                                 the Ip driver is releasing the default interface.
 747
 748   @retval EFI_SUCCESS           The interface use IpInstance is freed.
 749
 750 **/
 751 EFI_STATUS
 752 Ip4FreeInterface (
 753   IN  IP4_INTERFACE         *Interface,
 754   IN  IP4_PROTOCOL          *IpInstance           OPTIONAL
 755   )
 756 {
 757   NET_CHECK_SIGNATURE (Interface, IP4_INTERFACE_SIGNATURE);
 758   ASSERT (Interface->RefCnt > 0);
 759
 760   //
 761   // Remove all the pending transmit token related to this IP instance.
 762   //
 763   Ip4CancelFrames (Interface, EFI_ABORTED, Ip4CancelInstanceFrame, IpInstance);
 764
 765   if (--Interface->RefCnt > 0) {
 766     return EFI_SUCCESS;
 767   }
 768
 769   //
 770   // Destroy the interface if this is the last IP instance that
 771   // has the address. Remove all the system transmitted packets
 772   // from this interface, cancel the receive request if there is
 773   // one, and destroy the ARP requests.
 774   //
 775   Ip4CancelFrames (Interface, EFI_ABORTED, Ip4CancelInstanceFrame, NULL);
 776   Ip4CancelReceive (Interface);
 777
 778   ASSERT (IsListEmpty (&Interface->IpInstances));
 779   ASSERT (IsListEmpty (&Interface->ArpQues));
 780   ASSERT (IsListEmpty (&Interface->SentFrames));
 781
 782   if (Interface->Arp != NULL) {
 783     gBS->CloseProtocol (
 784           Interface->ArpHandle,
 785           &gEfiArpProtocolGuid,
 786           Interface->Image,
 787           Interface->Controller
 788           );
 789
 790     NetLibDestroyServiceChild (
 791       Interface->Controller,
 792       Interface->Image,
 793       &gEfiArpServiceBindingProtocolGuid,
 794       Interface->ArpHandle
 795       );
 796   }
 797
 798   RemoveEntryList (&Interface->Link);
 799   FreePool (Interface);
 800
 801   return EFI_SUCCESS;
 802 }
 803
 804
 805 /**
 806   Callback function when ARP request are finished. It will cancelled
 807   all the queued frame if the ARP requests failed. Or transmit them
 808   if the request succeed.
 809
 810   @param[in]  Context           The context of the callback, a point to the ARP
 811                                 queue
 812
 813 **/
 814 VOID
 815 EFIAPI
 816 Ip4OnArpResolvedDpc (
 817   IN VOID                   *Context
 818   )
 819 {
 820   LIST_ENTRY                *Entry;
 821   LIST_ENTRY                *Next;
 822   IP4_ARP_QUE               *ArpQue;
 823   IP4_INTERFACE             *Interface;
 824   IP4_LINK_TX_TOKEN         *Token;
 825   EFI_STATUS                Status;
 826
 827   ArpQue = (IP4_ARP_QUE *) Context;
 828   NET_CHECK_SIGNATURE (ArpQue, IP4_FRAME_ARP_SIGNATURE);
 829
 830   RemoveEntryList (&ArpQue->Link);
 831
 832   //
 833   // ARP resolve failed for some reason. Release all the frame
 834   // and ARP queue itself. Ip4FreeArpQue will call the frame's
 835   // owner back.
 836   //
 837   if (NET_MAC_EQUAL (&ArpQue->Mac, &mZeroMacAddress, ArpQue->Interface->HwaddrLen)) {
 838     Ip4FreeArpQue (ArpQue, EFI_NO_MAPPING);
 839
 840     return ;
 841   }
 842
 843   //
 844   // ARP resolve succeeded, Transmit all the frame. Release the ARP
 845   // queue. It isn't necessary for us to cache the ARP binding because
 846   // we always check the ARP cache first before transmit.
 847   //
 848   Interface = ArpQue->Interface;
 849
 850   NET_LIST_FOR_EACH_SAFE (Entry, Next, &ArpQue->Frames) {
 851     RemoveEntryList (Entry);
 852
 853     Token         = NET_LIST_USER_STRUCT (Entry, IP4_LINK_TX_TOKEN, Link);
 854     CopyMem (&Token->DstMac, &ArpQue->Mac, sizeof (Token->DstMac));
 855
 856     //
 857     // Insert the tx token before transmitting it via MNP as the FrameSentDpc
 858     // may be called before Mnp->Transmit returns which will remove this tx
 859     // token from the SentFrames list. Remove it from the list if the returned
 860     // Status of Mnp->Transmit is not EFI_SUCCESS as in this case the
 861     // FrameSentDpc won't be queued.
 862     //
 863     InsertTailList (&Interface->SentFrames, &Token->Link);
 864
 865     Status = Interface->Mnp->Transmit (Interface->Mnp, &Token->MnpToken);
 866     if (EFI_ERROR (Status)) {
 867       RemoveEntryList (Entry);
 868       Token->CallBack (Token->IpInstance, Token->Packet, Status, 0, Token->Context);
 869
 870       Ip4FreeLinkTxToken (Token);
 871       continue;
 872     }
 873   }
 874
 875   Ip4FreeArpQue (ArpQue, EFI_SUCCESS);
 876 }
 877
 878 /**
 879   Request Ip4OnArpResolvedDpc as a DPC at TPL_CALLBACK.
 880
 881   @param  Event             The Arp request event.
 882   @param  Context           The context of the callback, a point to the ARP
 883                             queue.
 884
 885 **/
 886 VOID
 887 EFIAPI
 888 Ip4OnArpResolved (
 889   IN EFI_EVENT              Event,
 890   IN VOID                   *Context
 891   )
 892 {
 893   //
 894   // Request Ip4OnArpResolvedDpc as a DPC at TPL_CALLBACK
 895   //
 896   QueueDpc (TPL_CALLBACK, Ip4OnArpResolvedDpc, Context);
 897 }
 898
 899
 900
 901 /**
 902   Callback funtion when frame transmission is finished. It will
 903   call the frame owner's callback function to tell it the result.
 904
 905   @param[in]  Context            Context which is point to the token.
 906
 907 **/
 908 VOID
 909 EFIAPI
 910 Ip4OnFrameSentDpc (
 911   IN VOID                    *Context
 912   )
 913 {
 914   IP4_LINK_TX_TOKEN         *Token;
 915
 916   Token = (IP4_LINK_TX_TOKEN *) Context;
 917   NET_CHECK_SIGNATURE (Token, IP4_FRAME_TX_SIGNATURE);
 918
 919   RemoveEntryList (&Token->Link);
 920
 921   Token->CallBack (
 922           Token->IpInstance,
 923           Token->Packet,
 924           Token->MnpToken.Status,
 925           0,
 926           Token->Context
 927           );
 928
 929   Ip4FreeLinkTxToken (Token);
 930 }
 931
 932 /**
 933   Request Ip4OnFrameSentDpc as a DPC at TPL_CALLBACK.
 934
 935   @param[in]  Event              The transmit token's event.
 936   @param[in]  Context            Context which is point to the token.
 937
 938 **/
 939 VOID
 940 EFIAPI
 941 Ip4OnFrameSent (
 942   IN EFI_EVENT               Event,
 943   IN VOID                    *Context
 944   )
 945 {
 946   //
 947   // Request Ip4OnFrameSentDpc as a DPC at TPL_CALLBACK
 948   //
 949   QueueDpc (TPL_CALLBACK, Ip4OnFrameSentDpc, Context);
 950 }
 951
 952
 953
 954 /**
 955   Send a frame from the interface. If the next hop is broadcast or
 956   multicast address, it is transmitted immediately. If the next hop
 957   is a unicast, it will consult ARP to resolve the NextHop's MAC.
 958   If some error happened, the CallBack won't be called. So, the caller
 959   must test the return value, and take action when there is an error.
 960
 961   @param[in]  Interface         The interface to send the frame from
 962   @param[in]  IpInstance        The IP child that request the transmission.  NULL
 963                                 if it is the IP4 driver itself.
 964   @param[in]  Packet            The packet to transmit.
 965   @param[in]  NextHop           The immediate destination to transmit the packet
 966                                 to.
 967   @param[in]  CallBack          Function to call back when transmit finished.
 968   @param[in]  Context           Opaque parameter to the call back.
 969
 970   @retval EFI_OUT_OF_RESOURCES  Failed to allocate resource to send the frame
 971   @retval EFI_NO_MAPPING        Can't resolve the MAC for the nexthop
 972   @retval EFI_SUCCESS           The packet is successfully transmitted.
 973   @retval other                 Other error occurs.
 974
 975 **/
 976 EFI_STATUS
 977 Ip4SendFrame (
 978   IN  IP4_INTERFACE         *Interface,
 979   IN  IP4_PROTOCOL          *IpInstance       OPTIONAL,
 980   IN  NET_BUF               *Packet,
 981   IN  IP4_ADDR              NextHop,
 982   IN  IP4_FRAME_CALLBACK    CallBack,
 983   IN  VOID                  *Context
 984   )
 985 {
 986   IP4_LINK_TX_TOKEN         *Token;
 987   LIST_ENTRY                *Entry;
 988   IP4_ARP_QUE               *ArpQue;
 989   EFI_ARP_PROTOCOL          *Arp;
 990   EFI_STATUS                Status;
 991
 992   ASSERT (Interface->Configured);
 993
 994   Token = Ip4WrapLinkTxToken (Interface, IpInstance, Packet, CallBack, Context);
 995
 996   if (Token == NULL) {
 997     return EFI_OUT_OF_RESOURCES;
 998   }
 999
1000   //
1001   // Get the destination MAC address for multicast and broadcasts.
1002   // Don't depend on ARP to solve the address since there maybe no
1003   // ARP at all. Ip4Output has set NextHop to 255.255.255.255 for
1004   // all the broadcasts.
1005   //
1006   if (NextHop == IP4_ALLONE_ADDRESS) {
1007     CopyMem (&Token->DstMac, &Interface->BroadcastMac, sizeof (Token->DstMac));
1008     goto SEND_NOW;
1009
1010   } else if (IP4_IS_MULTICAST (NextHop)) {
1011
1012     Status = Ip4GetMulticastMac (Interface->Mnp, NextHop, &Token->DstMac);
1013
1014     if (EFI_ERROR (Status)) {
1015       goto ON_ERROR;
1016     }
1017
1018     goto SEND_NOW;
1019   }
1020
1021   //
1022   // Can only send out multicast/broadcast if the IP address is zero
1023   //
1024   if ((Arp = Interface->Arp) == NULL) {
1025     Status = EFI_NO_MAPPING;
1026     goto ON_ERROR;
1027   }
1028
1029   //
1030   // First check whether this binding is in the ARP cache.
1031   //
1032   NextHop = HTONL (NextHop);
1033   Status  = Arp->Request (Arp, &NextHop, NULL, &Token->DstMac);
1034
1035   if (Status == EFI_SUCCESS) {
1036     goto SEND_NOW;
1037
1038   } else if (Status != EFI_NOT_READY) {
1039     goto ON_ERROR;
1040   }
1041
1042   //
1043   // Have to do asynchronous ARP resolution. First check
1044   // whether there is already a pending request.
1045   //
1046   ArpQue = NULL;
1047
1048   NET_LIST_FOR_EACH (Entry, &Interface->ArpQues) {
1049     ArpQue = NET_LIST_USER_STRUCT (Entry, IP4_ARP_QUE, Link);
1050
1051     if (ArpQue->Ip == NextHop) {
1052       break;
1053     }
1054   }
1055
1056   //
1057   // Found a pending ARP request, enqueue the frame then return
1058   //
1059   if (Entry != &Interface->ArpQues) {
1060     InsertTailList (&ArpQue->Frames, &Token->Link);
1061     return EFI_SUCCESS;
1062   }
1063
1064   //
1065   // First frame to NextHop, issue an asynchronous ARP requests
1066   //
1067   ArpQue = Ip4CreateArpQue (Interface, NextHop);
1068
1069   if (ArpQue == NULL) {
1070     Status = EFI_OUT_OF_RESOURCES;
1071     goto ON_ERROR;
1072   }
1073
1074   Status = Arp->Request (Arp, &ArpQue->Ip, ArpQue->OnResolved, ArpQue->Mac.Addr);
1075
1076   if (EFI_ERROR (Status) && (Status != EFI_NOT_READY)) {
1077     Ip4FreeArpQue (ArpQue, EFI_NO_MAPPING);
1078     goto ON_ERROR;
1079   }
1080
1081   InsertHeadList (&ArpQue->Frames, &Token->Link);
1082   InsertHeadList (&Interface->ArpQues, &ArpQue->Link);
1083   return EFI_SUCCESS;
1084
1085 SEND_NOW:
1086   //
1087   // Insert the tx token into the SentFrames list before calling Mnp->Transmit.
1088   // Remove it if the returned status is not EFI_SUCCESS.
1089   //
1090   InsertTailList (&Interface->SentFrames, &Token->Link);
1091   Status = Interface->Mnp->Transmit (Interface->Mnp, &Token->MnpToken);
1092   if (EFI_ERROR (Status)) {
1093     RemoveEntryList (&Interface->SentFrames);
1094     goto ON_ERROR;
1095   }
1096
1097   return EFI_SUCCESS;
1098
1099 ON_ERROR:
1100   Ip4FreeLinkTxToken (Token);
1101   return Status;
1102 }
1103
1104
1105 /**
1106   Call back function when the received packet is freed.
1107   Check Ip4OnFrameReceived for information.
1108
1109   @param  Context          Context, which is the IP4_LINK_RX_TOKEN.
1110
1111 **/
1112 VOID
1113 EFIAPI
1114 Ip4RecycleFrame (
1115   IN VOID                   *Context
1116   )
1117 {
1118   IP4_LINK_RX_TOKEN         *Frame;
1119
1120   Frame = (IP4_LINK_RX_TOKEN *) Context;
1121   NET_CHECK_SIGNATURE (Frame, IP4_FRAME_RX_SIGNATURE);
1122
1123   gBS->SignalEvent (Frame->MnpToken.Packet.RxData->RecycleEvent);
1124   Ip4FreeFrameRxToken (Frame);
1125 }
1126
1127
1128 /**
1129   Received a frame from MNP, wrap it in net buffer then deliver
1130   it to IP's input function. The ownship of the packet also
1131   transferred to IP. When Ip is finished with this packet, it
1132   will call NetbufFree to release the packet, NetbufFree will
1133   again call the Ip4RecycleFrame to signal MNP's event and free
1134   the token used.
1135
1136   @param  Context               Context for the callback.
1137
1138 **/
1139 VOID
1140 EFIAPI
1141 Ip4OnFrameReceivedDpc (
1142   IN VOID                     *Context
1143   )
1144 {
1145   EFI_MANAGED_NETWORK_COMPLETION_TOKEN  *MnpToken;
1146   EFI_MANAGED_NETWORK_RECEIVE_DATA      *MnpRxData;
1147   IP4_LINK_RX_TOKEN                     *Token;
1148   NET_FRAGMENT                          Netfrag;
1149   NET_BUF                               *Packet;
1150   UINT32                                Flag;
1151
1152   Token = (IP4_LINK_RX_TOKEN *) Context;
1153   NET_CHECK_SIGNATURE (Token, IP4_FRAME_RX_SIGNATURE);
1154
1155   //
1156   // First clear the interface's receive request in case the
1157   // caller wants to call Ip4ReceiveFrame in the callback.
1158   //
1159   Token->Interface->RecvRequest = NULL;
1160
1161   MnpToken  = &Token->MnpToken;
1162   MnpRxData = MnpToken->Packet.RxData;
1163
1164   if (EFI_ERROR (MnpToken->Status) || (MnpRxData == NULL)) {
1165     Token->CallBack (Token->IpInstance, NULL, MnpToken->Status, 0, Token->Context);
1166     Ip4FreeFrameRxToken (Token);
1167
1168     return ;
1169   }
1170
1171   //
1172   // Wrap the frame in a net buffer then deliever it to IP input.
1173   // IP will reassemble the packet, and deliver it to upper layer
1174   //
1175   Netfrag.Len  = MnpRxData->DataLength;
1176   Netfrag.Bulk = MnpRxData->PacketData;
1177
1178   Packet = NetbufFromExt (&Netfrag, 1, 0, IP4_MAX_HEADLEN, Ip4RecycleFrame, Token);
1179
1180   if (Packet == NULL) {
1181     gBS->SignalEvent (MnpRxData->RecycleEvent);
1182
1183     Token->CallBack (Token->IpInstance, NULL, EFI_OUT_OF_RESOURCES, 0, Token->Context);
1184     Ip4FreeFrameRxToken (Token);
1185
1186     return ;
1187   }
1188
1189   Flag  = (MnpRxData->BroadcastFlag ? IP4_LINK_BROADCAST : 0);
1190   Flag |= (MnpRxData->MulticastFlag ? IP4_LINK_MULTICAST : 0);
1191   Flag |= (MnpRxData->PromiscuousFlag ? IP4_LINK_PROMISC : 0);
1192
1193   Token->CallBack (Token->IpInstance, Packet, EFI_SUCCESS, Flag, Token->Context);
1194 }
1195
1196 /**
1197   Request Ip4OnFrameReceivedDpc as a DPC at TPL_CALLBACK.
1198
1199   @param Event      The receive event delivered to MNP for receive.
1200   @param Context    Context for the callback.
1201
1202 **/
1203 VOID
1204 EFIAPI
1205 Ip4OnFrameReceived (
1206   IN EFI_EVENT                Event,
1207   IN VOID                     *Context
1208   )
1209 {
1210   //
1211   // Request Ip4OnFrameReceivedDpc as a DPC at TPL_CALLBACK
1212   //
1213   QueueDpc (TPL_CALLBACK, Ip4OnFrameReceivedDpc, Context);
1214 }
1215
1216
1217 /**
1218   Request to receive the packet from the interface.
1219
1220   @param[in]  Interface         The interface to receive the frames from.
1221   @param[in]  IpInstance        The instance that requests the receive. NULL for
1222                                 the driver itself.
1223   @param[in]  CallBack          Function to call when receive finished.
1224   @param[in]  Context           Opaque parameter to the callback.
1225
1226   @retval EFI_ALREADY_STARTED   There is already a pending receive request.
1227   @retval EFI_OUT_OF_RESOURCES  Failed to allocate resource to receive.
1228   @retval EFI_SUCCESS           The recieve request has been started.
1229   @retval other                 Other error occurs.
1230
1231 **/
1232 EFI_STATUS
1233 Ip4ReceiveFrame (
1234   IN  IP4_INTERFACE         *Interface,
1235   IN  IP4_PROTOCOL          *IpInstance       OPTIONAL,
1236   IN  IP4_FRAME_CALLBACK    CallBack,
1237   IN  VOID                  *Context
1238   )
1239 {
1240   IP4_LINK_RX_TOKEN *Token;
1241   EFI_STATUS        Status;
1242
1243   NET_CHECK_SIGNATURE (Interface, IP4_INTERFACE_SIGNATURE);
1244
1245   if (Interface->RecvRequest != NULL) {
1246     return EFI_ALREADY_STARTED;
1247   }
1248
1249   Token = Ip4CreateLinkRxToken (Interface, IpInstance, CallBack, Context);
1250
1251   if (Token == NULL) {
1252     return EFI_OUT_OF_RESOURCES;
1253   }
1254
1255   Interface->RecvRequest = Token;
1256   Status = Interface->Mnp->Receive (Interface->Mnp, &Token->MnpToken);
1257   if (EFI_ERROR (Status)) {
1258     Interface->RecvRequest = NULL;
1259     Ip4FreeFrameRxToken (Token);
1260     return Status;
1261   }
1262   return EFI_SUCCESS;
1263 }