MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.c

   1 /** @file
   2   Help functions to access UDP service, it is used by both the DHCP and MTFTP.
   3
   4 Copyright (c) 2005 - 2009, Intel Corporation.<BR>
   5 All rights reserved. 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<BR>
   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 #include <Uefi.h>
  15
  16 #include <Protocol/Udp4.h>
  17 #include <Protocol/Udp6.h>
  18
  19 #include <Library/UdpIoLib.h>
  20 #include <Library/BaseLib.h>
  21 #include <Library/DebugLib.h>
  22 #include <Library/UefiBootServicesTableLib.h>
  23 #include <Library/MemoryAllocationLib.h>
  24 #include <Library/BaseMemoryLib.h>
  25 #include <Library/DpcLib.h>
  26
  27
  28 /**
  29   Free a UDP_TX_TOKEN. The TX event is closed.
  30
  31   @param[in]  TxToken                 The UDP_TX_TOKEN to release.
  32
  33 **/
  34 VOID
  35 UdpIoFreeTxToken (
  36   IN UDP_TX_TOKEN           *TxToken
  37   )
  38 {
  39
  40   if (TxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
  41     gBS->CloseEvent (TxToken->Token.Udp4.Event);
  42   } else if (TxToken->UdpIo->UdpVersion == UDP_IO_UDP6_VERSION) {
  43     gBS->CloseEvent (TxToken->Token.Udp6.Event);
  44   } else {
  45     ASSERT (FALSE);
  46   }
  47
  48   FreePool (TxToken);
  49 }
  50
  51 /**
  52   Free a UDP_RX_TOKEN. The RX event is closed.
  53
  54   @param[in]  RxToken                 The UDP_RX_TOKEN to release.
  55
  56 **/
  57 VOID
  58 UdpIoFreeRxToken (
  59   IN UDP_RX_TOKEN           *RxToken
  60   )
  61 {
  62   if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
  63     gBS->CloseEvent (RxToken->Token.Udp4.Event);
  64   } else if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP6_VERSION) {
  65     gBS->CloseEvent (RxToken->Token.Udp6.Event);
  66   } else {
  67     ASSERT (FALSE);
  68   }
  69
  70   FreePool (RxToken);
  71 }
  72
  73 /**
  74   The callback function when the packet is sent by UDP.
  75
  76   It will remove the packet from the local list then call
  77   the packet owner's callback function set by UdpIoSendDatagram.
  78
  79   @param[in]  Context               The UDP TX Token.
  80
  81 **/
  82 VOID
  83 EFIAPI
  84 UdpIoOnDgramSentDpc (
  85   IN VOID                   *Context
  86   )
  87 {
  88   UDP_TX_TOKEN              *TxToken;
  89
  90   TxToken = (UDP_TX_TOKEN *) Context;
  91   ASSERT (TxToken->Signature == UDP_IO_TX_SIGNATURE);
  92   ASSERT ((TxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
  93           (TxToken->UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));
  94
  95   RemoveEntryList (&TxToken->Link);
  96
  97   if (TxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
  98     TxToken->CallBack (TxToken->Packet, NULL, TxToken->Token.Udp4.Status, TxToken->Context);
  99   } else {
 100     TxToken->CallBack (TxToken->Packet, NULL, TxToken->Token.Udp6.Status, TxToken->Context);
 101   }
 102
 103   UdpIoFreeTxToken (TxToken);
 104 }
 105
 106 /**
 107   Request UdpIoOnDgramSentDpc as a DPC at TPL_CALLBACK.
 108
 109   @param[in]  Event                 The event signaled.
 110   @param[in]  Context               The UDP TX Token.
 111
 112 **/
 113 VOID
 114 EFIAPI
 115 UdpIoOnDgramSent (
 116   IN EFI_EVENT              Event,
 117   IN VOID                   *Context
 118   )
 119 {
 120   //
 121   // Request UdpIoOnDgramSentDpc as a DPC at TPL_CALLBACK
 122   //
 123   QueueDpc (TPL_CALLBACK, UdpIoOnDgramSentDpc, Context);
 124 }
 125
 126 /**
 127   Recycle the received UDP data.
 128
 129   @param[in]  Context               The UDP_RX_TOKEN.
 130
 131 **/
 132 VOID
 133 EFIAPI
 134 UdpIoRecycleDgram (
 135   IN VOID                   *Context
 136   )
 137 {
 138   UDP_RX_TOKEN              *RxToken;
 139
 140   RxToken = (UDP_RX_TOKEN *) Context;
 141
 142   if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
 143     gBS->SignalEvent (RxToken->Token.Udp4.Packet.RxData->RecycleSignal);
 144   } else if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP6_VERSION) {
 145     gBS->SignalEvent (RxToken->Token.Udp6.Packet.RxData->RecycleSignal);
 146   } else {
 147     ASSERT (FALSE);
 148   }
 149
 150   UdpIoFreeRxToken (RxToken);
 151 }
 152
 153 /**
 154   The event handle for UDP receive request.
 155
 156   It will build a NET_BUF from the recieved UDP data, then deliver it
 157   to the receiver.
 158
 159   @param[in]  Context               The UDP RX token.
 160
 161 **/
 162 VOID
 163 EFIAPI
 164 UdpIoOnDgramRcvdDpc (
 165   IN VOID                   *Context
 166   )
 167 {
 168   EFI_STATUS                Status;
 169   VOID                      *Token;
 170   VOID                      *RxData;
 171   VOID                      *Session;
 172   UDP_RX_TOKEN              *RxToken;
 173   UDP_END_POINT             EndPoint;
 174   NET_BUF                   *Netbuf;
 175
 176   RxToken = (UDP_RX_TOKEN *) Context;
 177
 178   ZeroMem (&EndPoint, sizeof(UDP_END_POINT));
 179
 180   ASSERT ((RxToken->Signature == UDP_IO_RX_SIGNATURE) &&
 181           (RxToken == RxToken->UdpIo->RecvRequest));
 182
 183   ASSERT ((RxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
 184           (RxToken->UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));
 185
 186   //
 187   // Clear the receive request first in case that the caller
 188   // wants to restart the receive in the callback.
 189   //
 190   RxToken->UdpIo->RecvRequest = NULL;
 191
 192   if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
 193     Token  = &RxToken->Token.Udp4;
 194     RxData = ((EFI_UDP4_COMPLETION_TOKEN *) Token)->Packet.RxData;
 195     Status = ((EFI_UDP4_COMPLETION_TOKEN *) Token)->Status;
 196   } else {
 197     Token  = &RxToken->Token.Udp6;
 198     RxData = ((EFI_UDP6_COMPLETION_TOKEN *) Token)->Packet.RxData;
 199     Status = ((EFI_UDP6_COMPLETION_TOKEN *) Token)->Status;
 200   }
 201
 202   if (EFI_ERROR (Status) || RxData == NULL) {
 203     if (Status != EFI_ABORTED) {
 204       //
 205       // Invoke the CallBack only if the reception is not actively aborted.
 206       //
 207       RxToken->CallBack (NULL, NULL, Status, RxToken->Context);
 208     }
 209
 210     UdpIoFreeRxToken (RxToken);
 211     return;
 212   }
 213
 214   //
 215   // Build a NET_BUF from the UDP receive data, then deliver it up.
 216   //
 217   if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
 218
 219     Netbuf = NetbufFromExt (
 220                (NET_FRAGMENT *)((EFI_UDP4_RECEIVE_DATA *) RxData)->FragmentTable,
 221                ((EFI_UDP4_RECEIVE_DATA *) RxData)->FragmentCount,
 222                0,
 223                (UINT32) RxToken->HeadLen,
 224                UdpIoRecycleDgram,
 225                RxToken
 226                );
 227
 228     if (Netbuf == NULL) {
 229       gBS->SignalEvent (((EFI_UDP4_RECEIVE_DATA *) RxData)->RecycleSignal);
 230       RxToken->CallBack (NULL, NULL, EFI_OUT_OF_RESOURCES, RxToken->Context);
 231
 232       UdpIoFreeRxToken (RxToken);
 233       return;
 234     }
 235
 236     Session             = &((EFI_UDP4_RECEIVE_DATA *) RxData)->UdpSession;
 237     EndPoint.LocalPort  = ((EFI_UDP4_SESSION_DATA *) Session)->DestinationPort;
 238     EndPoint.RemotePort = ((EFI_UDP4_SESSION_DATA *) Session)->SourcePort;
 239
 240     CopyMem (
 241       &EndPoint.LocalAddr,
 242       &((EFI_UDP4_SESSION_DATA *) Session)->DestinationAddress,
 243       sizeof (EFI_IPv4_ADDRESS)
 244       );
 245
 246     CopyMem (
 247       &EndPoint.RemoteAddr,
 248       &((EFI_UDP4_SESSION_DATA *) Session)->SourceAddress,
 249       sizeof (EFI_IPv4_ADDRESS)
 250       );
 251
 252     EndPoint.LocalAddr.Addr[0]  = NTOHL (EndPoint.LocalAddr.Addr[0]);
 253     EndPoint.RemoteAddr.Addr[0] = NTOHL (EndPoint.RemoteAddr.Addr[0]);
 254   } else {
 255
 256     Netbuf = NetbufFromExt (
 257                (NET_FRAGMENT *)((EFI_UDP6_RECEIVE_DATA *) RxData)->FragmentTable,
 258                ((EFI_UDP6_RECEIVE_DATA *) RxData)->FragmentCount,
 259                0,
 260                (UINT32) RxToken->HeadLen,
 261                UdpIoRecycleDgram,
 262                RxToken
 263                );
 264
 265     if (Netbuf == NULL) {
 266       gBS->SignalEvent (((EFI_UDP6_RECEIVE_DATA *) RxData)->RecycleSignal);
 267       RxToken->CallBack (NULL, NULL, EFI_OUT_OF_RESOURCES, RxToken->Context);
 268
 269       UdpIoFreeRxToken (RxToken);
 270       return;
 271     }
 272
 273     Session             = &((EFI_UDP6_RECEIVE_DATA *) RxData)->UdpSession;
 274     EndPoint.LocalPort  = ((EFI_UDP6_SESSION_DATA *) Session)->DestinationPort;
 275     EndPoint.RemotePort = ((EFI_UDP6_SESSION_DATA *) Session)->SourcePort;
 276
 277     CopyMem (
 278       &EndPoint.LocalAddr,
 279       &((EFI_UDP6_SESSION_DATA *) Session)->DestinationAddress,
 280       sizeof (EFI_IPv6_ADDRESS)
 281       );
 282
 283     CopyMem (
 284       &EndPoint.RemoteAddr,
 285       &((EFI_UDP6_SESSION_DATA *) Session)->SourceAddress,
 286       sizeof (EFI_IPv6_ADDRESS)
 287       );
 288
 289     Ip6Swap128 (&EndPoint.LocalAddr.v6);
 290     Ip6Swap128 (&EndPoint.RemoteAddr.v6);
 291   }
 292
 293   RxToken->CallBack (Netbuf, &EndPoint, EFI_SUCCESS, RxToken->Context);
 294 }
 295
 296 /**
 297   Request UdpIoOnDgramRcvdDpc() as a DPC at TPL_CALLBACK.
 298
 299   @param[in]  Event                 The UDP receive request event.
 300   @param[in]  Context               The UDP RX token.
 301
 302 **/
 303 VOID
 304 EFIAPI
 305 UdpIoOnDgramRcvd (
 306   IN EFI_EVENT              Event,
 307   IN VOID                   *Context
 308   )
 309 {
 310   //
 311   // Request UdpIoOnDgramRcvdDpc as a DPC at TPL_CALLBACK
 312   //
 313   QueueDpc (TPL_CALLBACK, UdpIoOnDgramRcvdDpc, Context);
 314 }
 315
 316 /**
 317   Create a UDP_RX_TOKEN to wrap the request.
 318
 319   @param[in]  UdpIo                 The UdpIo to receive packets from.
 320   @param[in]  CallBack              The function to call when receive finished.
 321   @param[in]  Context               The opaque parameter to the CallBack.
 322   @param[in]  HeadLen               The head length to reserver for the packet.
 323
 324   @return The Wrapped request or NULL if failed to allocate resources or some errors happened.
 325
 326 **/
 327 UDP_RX_TOKEN *
 328 UdpIoCreateRxToken (
 329   IN UDP_IO                 *UdpIo,
 330   IN UDP_IO_CALLBACK        CallBack,
 331   IN VOID                   *Context,
 332   IN UINT32                 HeadLen
 333   )
 334 {
 335   UDP_RX_TOKEN              *Token;
 336   EFI_STATUS                Status;
 337
 338   ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
 339           (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));
 340
 341   Token = AllocatePool (sizeof (UDP_RX_TOKEN));
 342
 343   if (Token == NULL) {
 344     return NULL;
 345   }
 346
 347   Token->Signature              = UDP_IO_RX_SIGNATURE;
 348   Token->UdpIo                  = UdpIo;
 349   Token->CallBack               = CallBack;
 350   Token->Context                = Context;
 351   Token->HeadLen                = HeadLen;
 352
 353   if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
 354
 355     Token->Token.Udp4.Status        = EFI_NOT_READY;
 356     Token->Token.Udp4.Packet.RxData = NULL;
 357
 358     Status = gBS->CreateEvent (
 359                     EVT_NOTIFY_SIGNAL,
 360                     TPL_NOTIFY,
 361                     UdpIoOnDgramRcvd,
 362                     Token,
 363                     &Token->Token.Udp4.Event
 364                     );
 365     } else {
 366
 367     Token->Token.Udp6.Status        = EFI_NOT_READY;
 368     Token->Token.Udp6.Packet.RxData = NULL;
 369
 370     Status = gBS->CreateEvent (
 371                     EVT_NOTIFY_SIGNAL,
 372                     TPL_NOTIFY,
 373                     UdpIoOnDgramRcvd,
 374                     Token,
 375                     &Token->Token.Udp6.Event
 376                     );
 377   }
 378
 379
 380   if (EFI_ERROR (Status)) {
 381     FreePool (Token);
 382     return NULL;
 383   }
 384
 385   return Token;
 386 }
 387
 388 /**
 389   Wrap a transmit request into a new created UDP_TX_TOKEN.
 390
 391   @param[in]  UdpIo                 The UdpIo to send packet to.
 392   @param[in]  Packet                The user's packet.
 393   @param[in]  EndPoint              The local and remote access point.
 394   @param[in]  Gateway               The overrided next hop.
 395   @param[in]  CallBack              The function to call when transmission completed.
 396   @param[in]  Context               The opaque parameter to the call back.
 397
 398   @return The wrapped transmission request or NULL if failed to allocate resources
 399           or for some errors.
 400
 401 **/
 402 UDP_TX_TOKEN *
 403 UdpIoCreateTxToken (
 404   IN UDP_IO                 *UdpIo,
 405   IN NET_BUF                *Packet,
 406   IN UDP_END_POINT          *EndPoint OPTIONAL,
 407   IN EFI_IP_ADDRESS         *Gateway  OPTIONAL,
 408   IN UDP_IO_CALLBACK        CallBack,
 409   IN VOID                   *Context
 410   )
 411 {
 412   UDP_TX_TOKEN              *TxToken;
 413   VOID                      *Token;
 414   VOID                      *Data;
 415   EFI_STATUS                Status;
 416   UINT32                    Count;
 417   UINTN                     Size;
 418   IP4_ADDR                  Ip;
 419
 420   ASSERT (Packet != NULL);
 421   ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
 422           (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));
 423
 424   if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
 425     Size = sizeof (UDP_TX_TOKEN) + sizeof (EFI_UDP4_FRAGMENT_DATA) * (Packet->BlockOpNum - 1);
 426   } else {
 427     Size = sizeof (UDP_TX_TOKEN) + sizeof (EFI_UDP6_FRAGMENT_DATA) * (Packet->BlockOpNum - 1);
 428   }
 429
 430   TxToken = AllocatePool (Size);
 431
 432   if (TxToken == NULL) {
 433     return NULL;
 434   }
 435
 436   TxToken->Signature = UDP_IO_TX_SIGNATURE;
 437   InitializeListHead (&TxToken->Link);
 438
 439   TxToken->UdpIo     = UdpIo;
 440   TxToken->CallBack  = CallBack;
 441   TxToken->Packet    = Packet;
 442   TxToken->Context   = Context;
 443
 444   Token              = &(TxToken->Token);
 445   Count              = Packet->BlockOpNum;
 446
 447   if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
 448
 449     ((EFI_UDP4_COMPLETION_TOKEN *) Token)->Status = EFI_NOT_READY;
 450
 451     Status = gBS->CreateEvent (
 452                     EVT_NOTIFY_SIGNAL,
 453                     TPL_NOTIFY,
 454                     UdpIoOnDgramSent,
 455                     TxToken,
 456                     &((EFI_UDP4_COMPLETION_TOKEN *) Token)->Event
 457                     );
 458
 459     if (EFI_ERROR (Status)) {
 460       FreePool (TxToken);
 461       return NULL;
 462     }
 463
 464     Data = &(TxToken->Data.Udp4);
 465     ((EFI_UDP4_COMPLETION_TOKEN *) Token)->Packet.TxData = Data;
 466
 467     ((EFI_UDP4_TRANSMIT_DATA *) Data)->UdpSessionData    = NULL;
 468     ((EFI_UDP4_TRANSMIT_DATA *) Data)->GatewayAddress    = NULL;
 469     ((EFI_UDP4_TRANSMIT_DATA *) Data)->DataLength        = Packet->TotalSize;
 470
 471     NetbufBuildExt (
 472       Packet,
 473       (NET_FRAGMENT *)((EFI_UDP4_TRANSMIT_DATA *) Data)->FragmentTable,
 474       &Count
 475       );
 476
 477     ((EFI_UDP4_TRANSMIT_DATA *) Data)->FragmentCount     = Count;
 478
 479     if (EndPoint != NULL) {
 480       Ip = HTONL (EndPoint->LocalAddr.Addr[0]);
 481       CopyMem (
 482         &TxToken->Session.Udp4.SourceAddress,
 483         &Ip,
 484         sizeof (EFI_IPv4_ADDRESS)
 485         );
 486
 487       Ip = HTONL (EndPoint->RemoteAddr.Addr[0]);
 488       CopyMem (
 489         &TxToken->Session.Udp4.DestinationAddress,
 490         &Ip,
 491         sizeof (EFI_IPv4_ADDRESS)
 492         );
 493
 494       TxToken->Session.Udp4.SourcePort                   = EndPoint->LocalPort;
 495       TxToken->Session.Udp4.DestinationPort              = EndPoint->RemotePort;
 496       ((EFI_UDP4_TRANSMIT_DATA *) Data)->UdpSessionData  = &(TxToken->Session.Udp4);
 497     }
 498
 499     if (Gateway != NULL && (Gateway->Addr[0] != 0)) {
 500       Ip = HTONL (Gateway->Addr[0]);
 501       CopyMem (&TxToken->Gateway, &Ip, sizeof (EFI_IPv4_ADDRESS));
 502       ((EFI_UDP4_TRANSMIT_DATA *) Data)->GatewayAddress = &TxToken->Gateway;
 503     }
 504
 505   } else {
 506
 507     ((EFI_UDP6_COMPLETION_TOKEN *) Token)->Status = EFI_NOT_READY;
 508
 509     Status = gBS->CreateEvent (
 510                     EVT_NOTIFY_SIGNAL,
 511                     TPL_NOTIFY,
 512                     UdpIoOnDgramSent,
 513                     TxToken,
 514                     &((EFI_UDP6_COMPLETION_TOKEN *) Token)->Event
 515                     );
 516
 517     if (EFI_ERROR (Status)) {
 518       FreePool (TxToken);
 519       return NULL;
 520     }
 521
 522     Data = &(TxToken->Data.Udp6);
 523     ((EFI_UDP6_COMPLETION_TOKEN *) Token)->Packet.TxData  = Data;
 524     ((EFI_UDP6_TRANSMIT_DATA *) Data)->UdpSessionData     = NULL;
 525     ((EFI_UDP6_TRANSMIT_DATA *) Data)->DataLength         = Packet->TotalSize;
 526
 527     NetbufBuildExt (
 528       Packet,
 529       (NET_FRAGMENT *)((EFI_UDP6_TRANSMIT_DATA *) Data)->FragmentTable,
 530       &Count
 531       );
 532
 533     ((EFI_UDP6_TRANSMIT_DATA *) Data)->FragmentCount      = Count;
 534
 535     if (EndPoint != NULL) {
 536       CopyMem (
 537         &TxToken->Session.Udp6.SourceAddress,
 538         &EndPoint->LocalAddr.v6,
 539         sizeof(EFI_IPv6_ADDRESS)
 540         );
 541
 542       CopyMem (
 543         &TxToken->Session.Udp6.DestinationAddress,
 544         &EndPoint->RemoteAddr.v6,
 545         sizeof(EFI_IPv6_ADDRESS)
 546         );
 547
 548       TxToken->Session.Udp6.SourcePort                   = EndPoint->LocalPort;
 549       TxToken->Session.Udp6.DestinationPort              = EndPoint->RemotePort;
 550       ((EFI_UDP6_TRANSMIT_DATA *) Data)->UdpSessionData  = &(TxToken->Session.Udp6);
 551     }
 552   }
 553
 554   return TxToken;
 555 }
 556
 557 /**
 558   Creates a UDP_IO to access the UDP service. It creates and configures
 559   a UDP child.
 560
 561   It locates the UDP service binding prototype on the Controller parameter
 562   uses the UDP service binding prototype to create a UDP child (also known as
 563   a UDP instance) configures the UDP child by calling Configure function prototype.
 564   Any failures in creating or configuring the UDP child return NULL for failure.
 565
 566   @param[in]  Controller            The controller that has the UDP service binding.
 567                                     protocol installed.
 568   @param[in]  ImageHandle           The image handle for the driver.
 569   @param[in]  Configure             The function to configure the created UDP child.
 570   @param[in]  UdpVersion            The UDP protocol version, UDP4 or UDP6.
 571   @param[in]  Context               The opaque parameter for the Configure funtion.
 572
 573   @return Newly-created UDP_IO or NULL if failed.
 574
 575 **/
 576 UDP_IO *
 577 EFIAPI
 578 UdpIoCreateIo (
 579   IN  EFI_HANDLE            Controller,
 580   IN  EFI_HANDLE            ImageHandle,
 581   IN  UDP_IO_CONFIG         Configure,
 582   IN  UINT8                 UdpVersion,
 583   IN  VOID                  *Context
 584   )
 585 {
 586   UDP_IO                    *UdpIo;
 587   EFI_STATUS                Status;
 588
 589   ASSERT (Configure != NULL);
 590   ASSERT ((UdpVersion == UDP_IO_UDP4_VERSION) || (UdpVersion == UDP_IO_UDP6_VERSION));
 591
 592   UdpIo = AllocatePool (sizeof (UDP_IO));
 593
 594   if (UdpIo == NULL) {
 595     return NULL;
 596   }
 597
 598   UdpIo->UdpVersion   = UdpVersion;
 599   UdpIo->Signature    = UDP_IO_SIGNATURE;
 600   InitializeListHead (&UdpIo->Link);
 601   UdpIo->RefCnt       = 1;
 602
 603   UdpIo->Controller   = Controller;
 604   UdpIo->Image        = ImageHandle;
 605
 606   InitializeListHead (&UdpIo->SentDatagram);
 607   UdpIo->RecvRequest  = NULL;
 608   UdpIo->UdpHandle    = NULL;
 609
 610   if (UdpVersion == UDP_IO_UDP4_VERSION) {
 611     //
 612     // Create a UDP child then open and configure it
 613     //
 614     Status = NetLibCreateServiceChild (
 615                Controller,
 616                ImageHandle,
 617                &gEfiUdp4ServiceBindingProtocolGuid,
 618                &UdpIo->UdpHandle
 619                );
 620
 621     if (EFI_ERROR (Status)) {
 622       goto FREE_MEM;
 623     }
 624
 625     Status = gBS->OpenProtocol (
 626                     UdpIo->UdpHandle,
 627                     &gEfiUdp4ProtocolGuid,
 628                     (VOID **) &UdpIo->Protocol.Udp4,
 629                     ImageHandle,
 630                     Controller,
 631                     EFI_OPEN_PROTOCOL_BY_DRIVER
 632                     );
 633
 634     if (EFI_ERROR (Status)) {
 635       goto FREE_CHILD;
 636     }
 637
 638     if (EFI_ERROR (Configure (UdpIo, Context))) {
 639       goto CLOSE_PROTOCOL;
 640     }
 641
 642     Status = UdpIo->Protocol.Udp4->GetModeData (
 643                                      UdpIo->Protocol.Udp4,
 644                                      NULL,
 645                                      NULL,
 646                                      NULL,
 647                                      &UdpIo->SnpMode
 648                                      );
 649
 650     if (EFI_ERROR (Status)) {
 651       goto CLOSE_PROTOCOL;
 652     }
 653
 654   } else {
 655
 656     Status = NetLibCreateServiceChild (
 657                Controller,
 658                ImageHandle,
 659                &gEfiUdp6ServiceBindingProtocolGuid,
 660                &UdpIo->UdpHandle
 661                );
 662
 663     if (EFI_ERROR (Status)) {
 664       goto FREE_MEM;
 665     }
 666
 667     Status = gBS->OpenProtocol (
 668                     UdpIo->UdpHandle,
 669                     &gEfiUdp6ProtocolGuid,
 670                     (VOID **) &UdpIo->Protocol.Udp6,
 671                     ImageHandle,
 672                     Controller,
 673                     EFI_OPEN_PROTOCOL_BY_DRIVER
 674                     );
 675
 676     if (EFI_ERROR (Status)) {
 677       goto FREE_CHILD;
 678     }
 679
 680     if (EFI_ERROR (Configure (UdpIo, Context))) {
 681       goto CLOSE_PROTOCOL;
 682     }
 683
 684     Status = UdpIo->Protocol.Udp6->GetModeData (
 685                                      UdpIo->Protocol.Udp6,
 686                                      NULL,
 687                                      NULL,
 688                                      NULL,
 689                                      &UdpIo->SnpMode
 690                                      );
 691
 692     if (EFI_ERROR (Status)) {
 693       goto CLOSE_PROTOCOL;
 694     }
 695   }
 696
 697   return UdpIo;
 698
 699 CLOSE_PROTOCOL:
 700   if (UdpVersion == UDP_IO_UDP4_VERSION) {
 701     gBS->CloseProtocol (UdpIo->UdpHandle, &gEfiUdp4ProtocolGuid, ImageHandle, Controller);
 702   } else {
 703     gBS->CloseProtocol (UdpIo->UdpHandle, &gEfiUdp6ProtocolGuid, ImageHandle, Controller);
 704   }
 705
 706 FREE_CHILD:
 707   if (UdpVersion == UDP_IO_UDP4_VERSION) {
 708     NetLibDestroyServiceChild (
 709       Controller,
 710       ImageHandle,
 711       &gEfiUdp4ServiceBindingProtocolGuid,
 712       UdpIo->UdpHandle
 713       );
 714   } else {
 715     NetLibDestroyServiceChild (
 716       Controller,
 717       ImageHandle,
 718       &gEfiUdp6ServiceBindingProtocolGuid,
 719       UdpIo->UdpHandle
 720       );
 721   }
 722
 723 FREE_MEM:
 724   FreePool (UdpIo);
 725   return NULL;
 726 }
 727
 728 /**
 729   Cancel all the sent datagram that pass the selection criteria of ToCancel.
 730   If ToCancel is NULL, all the datagrams are cancelled.
 731
 732   @param[in]  UdpIo                 The UDP_IO to cancel packet.
 733   @param[in]  IoStatus              The IoStatus to return to the packet owners.
 734   @param[in]  ToCancel              The select funtion to test whether to cancel this
 735                                     packet or not.
 736   @param[in]  Context               The opaque parameter to the ToCancel.
 737
 738 **/
 739 VOID
 740 EFIAPI
 741 UdpIoCancelDgrams (
 742   IN UDP_IO                 *UdpIo,
 743   IN EFI_STATUS             IoStatus,
 744   IN UDP_IO_TO_CANCEL       ToCancel,        OPTIONAL
 745   IN VOID                   *Context
 746   )
 747 {
 748   LIST_ENTRY                *Entry;
 749   LIST_ENTRY                *Next;
 750   UDP_TX_TOKEN              *TxToken;
 751
 752   ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
 753           (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));
 754
 755   NET_LIST_FOR_EACH_SAFE (Entry, Next, &UdpIo->SentDatagram) {
 756     TxToken = NET_LIST_USER_STRUCT (Entry, UDP_TX_TOKEN, Link);
 757
 758     if ((ToCancel == NULL) || (ToCancel (TxToken, Context))) {
 759
 760       if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
 761         UdpIo->Protocol.Udp4->Cancel (UdpIo->Protocol.Udp4, &TxToken->Token.Udp4);
 762       } else {
 763         UdpIo->Protocol.Udp6->Cancel (UdpIo->Protocol.Udp6, &TxToken->Token.Udp6);
 764       }
 765     }
 766   }
 767 }
 768
 769 /**
 770   Free the UDP_IO and all its related resources.
 771
 772   The function will cancel all sent datagram and receive request.
 773
 774   @param[in]  UdpIo             The UDP_IO to free.
 775
 776   @retval EFI_SUCCESS           The UDP_IO is freed.
 777
 778 **/
 779 EFI_STATUS
 780 EFIAPI
 781 UdpIoFreeIo (
 782   IN  UDP_IO           *UdpIo
 783   )
 784 {
 785   UDP_RX_TOKEN         *RxToken;
 786
 787   ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
 788           (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));
 789
 790   //
 791   // Cancel all the sent datagram and receive requests. The
 792   // callbacks of transmit requests are executed to allow the
 793   // caller to release the resource. The callback of receive
 794   // request are NOT executed. This is because it is most
 795   // likely that the current user of the UDP IO port is closing
 796   // itself.
 797   //
 798   UdpIoCancelDgrams (UdpIo, EFI_ABORTED, NULL, NULL);
 799
 800   if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
 801
 802     if ((RxToken = UdpIo->RecvRequest) != NULL) {
 803       UdpIo->Protocol.Udp4->Cancel (UdpIo->Protocol.Udp4, &RxToken->Token.Udp4);
 804     }
 805
 806     //
 807     // Close then destory the Udp4 child
 808     //
 809     gBS->CloseProtocol (
 810            UdpIo->UdpHandle,
 811            &gEfiUdp4ProtocolGuid,
 812            UdpIo->Image,
 813            UdpIo->Controller
 814            );
 815
 816     NetLibDestroyServiceChild (
 817       UdpIo->Controller,
 818       UdpIo->Image,
 819       &gEfiUdp4ServiceBindingProtocolGuid,
 820       UdpIo->UdpHandle
 821       );
 822
 823   } else {
 824
 825     if ((RxToken = UdpIo->RecvRequest) != NULL) {
 826       UdpIo->Protocol.Udp6->Cancel (UdpIo->Protocol.Udp6, &RxToken->Token.Udp6);
 827     }
 828
 829     //
 830     // Close then destory the Udp6 child
 831     //
 832     gBS->CloseProtocol (
 833            UdpIo->UdpHandle,
 834            &gEfiUdp6ProtocolGuid,
 835            UdpIo->Image,
 836            UdpIo->Controller
 837            );
 838
 839     NetLibDestroyServiceChild (
 840       UdpIo->Controller,
 841       UdpIo->Image,
 842       &gEfiUdp6ServiceBindingProtocolGuid,
 843       UdpIo->UdpHandle
 844       );
 845     }
 846
 847   if (!IsListEmpty(&UdpIo->Link)) {
 848     RemoveEntryList (&UdpIo->Link);
 849   }
 850
 851   FreePool (UdpIo);
 852   return EFI_SUCCESS;
 853 }
 854
 855
 856 /**
 857   Clean up the UDP_IO without freeing it. The function is called when
 858   user wants to re-use the UDP_IO later.
 859
 860   It will release all the transmitted datagrams and receive request. It will
 861   also configure NULL for the UDP instance.
 862
 863   @param[in]  UdpIo                 The UDP_IO to clean up.
 864
 865 **/
 866 VOID
 867 EFIAPI
 868 UdpIoCleanIo (
 869   IN  UDP_IO                *UdpIo
 870   )
 871 {
 872   UDP_RX_TOKEN              *RxToken;
 873
 874   ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
 875           (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));
 876
 877   //
 878   // Cancel all the sent datagram and receive requests.
 879   //
 880   UdpIoCancelDgrams (UdpIo, EFI_ABORTED, NULL, NULL);
 881
 882   if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
 883     if ((RxToken = UdpIo->RecvRequest) != NULL) {
 884       UdpIo->Protocol.Udp4->Cancel (UdpIo->Protocol.Udp4, &RxToken->Token.Udp4);
 885     }
 886
 887     UdpIo->Protocol.Udp4->Configure (UdpIo->Protocol.Udp4, NULL);
 888
 889   } else {
 890     if ((RxToken = UdpIo->RecvRequest) != NULL) {
 891       UdpIo->Protocol.Udp6->Cancel (UdpIo->Protocol.Udp6, &RxToken->Token.Udp6);
 892     }
 893
 894     UdpIo->Protocol.Udp6->Configure (UdpIo->Protocol.Udp6, NULL);
 895   }
 896 }
 897
 898 /**
 899   Send a packet through the UDP_IO.
 900
 901   The packet will be wrapped in UDP_TX_TOKEN. Function Callback will be called
 902   when the packet is sent. The optional parameter EndPoint overrides the default
 903   address pair if specified.
 904
 905   @param[in]  UdpIo                 The UDP_IO to send the packet through.
 906   @param[in]  Packet                The packet to send.
 907   @param[in]  EndPoint              The local and remote access point. Override the
 908                                     default address pair set during configuration.
 909   @param[in]  Gateway               The gateway to use.
 910   @param[in]  CallBack              The function being called when packet is
 911                                     transmitted or failed.
 912   @param[in]  Context               The opaque parameter passed to CallBack.
 913
 914   @retval EFI_OUT_OF_RESOURCES  Failed to allocate resource for the packet.
 915   @retval EFI_SUCCESS           The packet is successfully delivered to UDP  for
 916                                 transmission.
 917
 918 **/
 919 EFI_STATUS
 920 EFIAPI
 921 UdpIoSendDatagram (
 922   IN  UDP_IO                *UdpIo,
 923   IN  NET_BUF               *Packet,
 924   IN  UDP_END_POINT         *EndPoint OPTIONAL,
 925   IN  EFI_IP_ADDRESS        *Gateway  OPTIONAL,
 926   IN  UDP_IO_CALLBACK       CallBack,
 927   IN  VOID                  *Context
 928   )
 929 {
 930   UDP_TX_TOKEN              *TxToken;
 931   EFI_STATUS                Status;
 932
 933   ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
 934           (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));
 935
 936   TxToken = UdpIoCreateTxToken (UdpIo, Packet, EndPoint, Gateway, CallBack, Context);
 937
 938   if (TxToken == NULL) {
 939     return EFI_OUT_OF_RESOURCES;
 940   }
 941
 942   //
 943   // Insert the tx token into SendDatagram list before transmitting it. Remove
 944   // it from the list if the returned status is not EFI_SUCCESS.
 945   //
 946   InsertHeadList (&UdpIo->SentDatagram, &TxToken->Link);
 947
 948   if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
 949     Status = UdpIo->Protocol.Udp4->Transmit (UdpIo->Protocol.Udp4, &TxToken->Token.Udp4);
 950   } else {
 951     Status = UdpIo->Protocol.Udp6->Transmit (UdpIo->Protocol.Udp6, &TxToken->Token.Udp6);
 952   }
 953
 954   if (EFI_ERROR (Status)) {
 955     RemoveEntryList (&TxToken->Link);
 956     UdpIoFreeTxToken (TxToken);
 957     return Status;
 958   }
 959
 960   return EFI_SUCCESS;
 961 }
 962
 963
 964 /**
 965   The select function to cancel a single sent datagram.
 966
 967   @param[in]  Token                 The UDP_TX_TOKEN to test against
 968   @param[in]  Context               The NET_BUF of the sent datagram
 969
 970   @retval TRUE              The packet is to be cancelled.
 971   @retval FALSE             The packet is not to be cancelled.
 972 **/
 973 BOOLEAN
 974 EFIAPI
 975 UdpIoCancelSingleDgram (
 976   IN UDP_TX_TOKEN           *Token,
 977   IN VOID                   *Context
 978   )
 979 {
 980   NET_BUF                   *Packet;
 981
 982   Packet = (NET_BUF *) Context;
 983
 984   if (Token->Packet == Packet) {
 985     return TRUE;
 986   }
 987
 988   return FALSE;
 989 }
 990
 991 /**
 992   Cancel a single sent datagram.
 993
 994   @param[in]  UdpIo                 The UDP_IO to cancel the packet from
 995   @param[in]  Packet                The packet to cancel
 996
 997 **/
 998 VOID
 999 EFIAPI
1000 UdpIoCancelSentDatagram (
1001   IN  UDP_IO                *UdpIo,
1002   IN  NET_BUF               *Packet
1003   )
1004 {
1005   UdpIoCancelDgrams (UdpIo, EFI_ABORTED, UdpIoCancelSingleDgram, Packet);
1006 }
1007
1008 /**
1009   Issue a receive request to the UDP_IO.
1010
1011   This function is called when upper-layer needs packet from UDP for processing.
1012   Only one receive request is acceptable at a time so a common usage model is
1013   to invoke this function inside its Callback function when the former packet
1014   is processed.
1015
1016   @param[in]  UdpIo                 The UDP_IO to receive the packet from.
1017   @param[in]  CallBack              The call back function to execute when the packet
1018                                     is received.
1019   @param[in]  Context               The opaque context passed to Callback.
1020   @param[in]  HeadLen               The length of the upper-layer's protocol header.
1021
1022   @retval EFI_ALREADY_STARTED   There is already a pending receive request. Only
1023                                 one receive request is supported at a time.
1024   @retval EFI_OUT_OF_RESOURCES  Failed to allocate needed resources.
1025   @retval EFI_SUCCESS           The receive request is issued successfully.
1026   @retval EFI_UNSUPPORTED       The UDP version in UDP_IO is not supported.
1027
1028 **/
1029 EFI_STATUS
1030 EFIAPI
1031 UdpIoRecvDatagram (
1032   IN  UDP_IO                *UdpIo,
1033   IN  UDP_IO_CALLBACK       CallBack,
1034   IN  VOID                  *Context,
1035   IN  UINT32                HeadLen
1036   )
1037 {
1038   UDP_RX_TOKEN              *RxToken;
1039   EFI_STATUS                Status;
1040
1041   ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
1042           (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));
1043
1044   if (UdpIo->RecvRequest != NULL) {
1045     return EFI_ALREADY_STARTED;
1046   }
1047
1048   RxToken = UdpIoCreateRxToken (UdpIo, CallBack, Context, HeadLen);
1049
1050   if (RxToken == NULL) {
1051     return EFI_OUT_OF_RESOURCES;
1052   }
1053
1054   UdpIo->RecvRequest = RxToken;
1055   if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
1056     Status = UdpIo->Protocol.Udp4->Receive (UdpIo->Protocol.Udp4, &RxToken->Token.Udp4);
1057   } else {
1058     Status = UdpIo->Protocol.Udp6->Receive (UdpIo->Protocol.Udp6, &RxToken->Token.Udp6);
1059   }
1060
1061   if (EFI_ERROR (Status)) {
1062     UdpIo->RecvRequest = NULL;
1063     UdpIoFreeRxToken (RxToken);
1064   }
1065
1066   return Status;
1067 }