NetworkPkg/HttpDxe/HttpProto.c

   1 /** @file
   2   Miscellaneous routines for HttpDxe driver.
   3
   4 Copyright (c) 2015 - 2016, Intel Corporation. All rights reserved.<BR>
   5 (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
   6 This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "HttpDriver.h"
  17
  18 /**
  19   The common notify function used in HTTP driver.
  20
  21   @param[in]  Event   The event signaled.
  22   @param[in]  Context The context.
  23
  24 **/
  25 VOID
  26 EFIAPI
  27 HttpCommonNotify (
  28   IN EFI_EVENT  Event,
  29   IN VOID       *Context
  30   )
  31 {
  32   if ((Event == NULL) || (Context == NULL)) {
  33     return ;
  34   }
  35
  36   *((BOOLEAN *) Context) = TRUE;
  37 }
  38
  39 /**
  40   The notify function associated with Tx4Token for Tcp4->Transmit() or Tx6Token for Tcp6->Transmit().
  41
  42   @param[in]  Context The context.
  43
  44 **/
  45 VOID
  46 EFIAPI
  47 HttpTcpTransmitNotifyDpc (
  48   IN VOID       *Context
  49   )
  50 {
  51   HTTP_TOKEN_WRAP          *Wrap;
  52   HTTP_PROTOCOL            *HttpInstance;
  53
  54   if (Context == NULL) {
  55     return ;
  56   }
  57
  58   Wrap         = (HTTP_TOKEN_WRAP *) Context;
  59   HttpInstance = Wrap->HttpInstance;
  60
  61   if (!HttpInstance->LocalAddressIsIPv6) {
  62       Wrap->HttpToken->Status = Wrap->TcpWrap.Tx4Token.CompletionToken.Status;
  63       gBS->SignalEvent (Wrap->HttpToken->Event);
  64
  65       //
  66       // Free resources.
  67       //
  68       if (Wrap->TcpWrap.Tx4Token.Packet.TxData->FragmentTable[0].FragmentBuffer != NULL) {
  69         FreePool (Wrap->TcpWrap.Tx4Token.Packet.TxData->FragmentTable[0].FragmentBuffer);
  70       }
  71
  72       if (Wrap->TcpWrap.Tx4Token.CompletionToken.Event != NULL) {
  73         gBS->CloseEvent (Wrap->TcpWrap.Tx4Token.CompletionToken.Event);
  74       }
  75
  76   } else {
  77     Wrap->HttpToken->Status = Wrap->TcpWrap.Tx6Token.CompletionToken.Status;
  78     gBS->SignalEvent (Wrap->HttpToken->Event);
  79
  80     //
  81     // Free resources.
  82     //
  83     if (Wrap->TcpWrap.Tx6Token.Packet.TxData->FragmentTable[0].FragmentBuffer != NULL) {
  84       FreePool (Wrap->TcpWrap.Tx6Token.Packet.TxData->FragmentTable[0].FragmentBuffer);
  85     }
  86
  87     if (Wrap->TcpWrap.Tx6Token.CompletionToken.Event != NULL) {
  88       gBS->CloseEvent (Wrap->TcpWrap.Tx6Token.CompletionToken.Event);
  89     }
  90   }
  91
  92
  93   Wrap->TcpWrap.IsTxDone = TRUE;
  94
  95   //
  96   // Check pending TxTokens and sent out.
  97   //
  98   NetMapIterate (&Wrap->HttpInstance->TxTokens, HttpTcpTransmit, NULL);
  99
 100 }
 101
 102 /**
 103   Request HttpTcpTransmitNotifyDpc as a DPC at TPL_CALLBACK.
 104
 105   @param  Event                 The receive event delivered to TCP for transmit.
 106   @param  Context               Context for the callback.
 107
 108 **/
 109 VOID
 110 EFIAPI
 111 HttpTcpTransmitNotify (
 112   IN EFI_EVENT                Event,
 113   IN VOID                     *Context
 114   )
 115 {
 116   //
 117   // Request HttpTcpTransmitNotifyDpc as a DPC at TPL_CALLBACK
 118   //
 119   QueueDpc (TPL_CALLBACK, HttpTcpTransmitNotifyDpc, Context);
 120 }
 121
 122 /**
 123   The notify function associated with Rx4Token for Tcp4->Receive () or Rx6Token for Tcp6->Receive().
 124
 125   @param[in]  Context The context.
 126
 127 **/
 128 VOID
 129 EFIAPI
 130 HttpTcpReceiveNotifyDpc (
 131   IN VOID       *Context
 132   )
 133 {
 134   HTTP_TOKEN_WRAP          *Wrap;
 135   NET_MAP_ITEM             *Item;
 136   UINTN                    Length;
 137   EFI_STATUS               Status;
 138   HTTP_PROTOCOL            *HttpInstance;
 139   BOOLEAN                  UsingIpv6;
 140
 141   if (Context == NULL) {
 142     return ;
 143   }
 144
 145   Wrap = (HTTP_TOKEN_WRAP *) Context;
 146   HttpInstance = Wrap->HttpInstance;
 147   UsingIpv6    = HttpInstance->LocalAddressIsIPv6;
 148
 149   if (UsingIpv6) {
 150     gBS->CloseEvent (Wrap->TcpWrap.Rx6Token.CompletionToken.Event);
 151     Wrap->TcpWrap.Rx6Token.CompletionToken.Event = NULL;
 152
 153     if (EFI_ERROR (Wrap->TcpWrap.Rx6Token.CompletionToken.Status)) {
 154       DEBUG ((EFI_D_ERROR, "HttpTcpReceiveNotifyDpc: %r!\n", Wrap->TcpWrap.Rx6Token.CompletionToken.Status));
 155       Wrap->HttpToken->Status = Wrap->TcpWrap.Rx6Token.CompletionToken.Status;
 156       gBS->SignalEvent (Wrap->HttpToken->Event);
 157
 158       Item = NetMapFindKey (&HttpInstance->RxTokens, Wrap->HttpToken);
 159       if (Item != NULL) {
 160         NetMapRemoveItem (&HttpInstance->RxTokens, Item, NULL);
 161       }
 162
 163       FreePool (Wrap);
 164       Wrap = NULL;
 165
 166       return ;
 167     }
 168
 169   } else {
 170     gBS->CloseEvent (Wrap->TcpWrap.Rx4Token.CompletionToken.Event);
 171     Wrap->TcpWrap.Rx4Token.CompletionToken.Event = NULL;
 172
 173     if (EFI_ERROR (Wrap->TcpWrap.Rx4Token.CompletionToken.Status)) {
 174       DEBUG ((EFI_D_ERROR, "HttpTcpReceiveNotifyDpc: %r!\n", Wrap->TcpWrap.Rx4Token.CompletionToken.Status));
 175       Wrap->HttpToken->Status = Wrap->TcpWrap.Rx4Token.CompletionToken.Status;
 176       gBS->SignalEvent (Wrap->HttpToken->Event);
 177
 178       Item = NetMapFindKey (&HttpInstance->RxTokens, Wrap->HttpToken);
 179       if (Item != NULL) {
 180         NetMapRemoveItem (&HttpInstance->RxTokens, Item, NULL);
 181       }
 182
 183       FreePool (Wrap);
 184       Wrap = NULL;
 185
 186       return ;
 187     }
 188   }
 189
 190   //
 191   // Check whether we receive a complete HTTP message.
 192   //
 193   ASSERT (HttpInstance->MsgParser != NULL);
 194   if (UsingIpv6) {
 195     Length = (UINTN) Wrap->TcpWrap.Rx6Data.FragmentTable[0].FragmentLength;
 196   } else {
 197     Length = (UINTN) Wrap->TcpWrap.Rx4Data.FragmentTable[0].FragmentLength;
 198   }
 199
 200   Status = HttpParseMessageBody (
 201              HttpInstance->MsgParser,
 202              Length,
 203              Wrap->HttpToken->Message->Body
 204              );
 205   if (EFI_ERROR (Status)) {
 206     return ;
 207   }
 208
 209   if (HttpIsMessageComplete (HttpInstance->MsgParser)) {
 210     //
 211     // Free the MsgParse since we already have a full HTTP message.
 212     //
 213     HttpFreeMsgParser (HttpInstance->MsgParser);
 214     HttpInstance->MsgParser = NULL;
 215   }
 216
 217   Wrap->HttpToken->Message->BodyLength = Length;
 218   ASSERT (HttpInstance->CacheBody == NULL);
 219   //
 220   // We receive part of header of next HTTP msg.
 221   //
 222   if (HttpInstance->NextMsg != NULL) {
 223     Wrap->HttpToken->Message->BodyLength = HttpInstance->NextMsg -
 224                                            (CHAR8 *) Wrap->HttpToken->Message->Body;
 225     HttpInstance->CacheLen = Length - Wrap->HttpToken->Message->BodyLength;
 226     if (HttpInstance->CacheLen != 0) {
 227       HttpInstance->CacheBody = AllocateZeroPool (HttpInstance->CacheLen);
 228       if (HttpInstance->CacheBody == NULL) {
 229         return ;
 230       }
 231       CopyMem (HttpInstance->CacheBody, HttpInstance->NextMsg, HttpInstance->CacheLen);
 232       HttpInstance->NextMsg = HttpInstance->CacheBody;
 233       HttpInstance->CacheOffset = 0;
 234     }
 235   }
 236
 237   Item = NetMapFindKey (&Wrap->HttpInstance->RxTokens, Wrap->HttpToken);
 238   if (Item != NULL) {
 239     NetMapRemoveItem (&Wrap->HttpInstance->RxTokens, Item, NULL);
 240   }
 241
 242
 243   Wrap->TcpWrap.IsRxDone = TRUE;
 244   if (UsingIpv6) {
 245     Wrap->HttpToken->Status = Wrap->TcpWrap.Rx6Token.CompletionToken.Status;
 246   } else {
 247     Wrap->HttpToken->Status = Wrap->TcpWrap.Rx4Token.CompletionToken.Status;
 248   }
 249
 250
 251   gBS->SignalEvent (Wrap->HttpToken->Event);
 252
 253   //
 254   // Check pending RxTokens and receive the HTTP message.
 255   //
 256   NetMapIterate (&Wrap->HttpInstance->RxTokens, HttpTcpReceive, NULL);
 257
 258   FreePool (Wrap);
 259   Wrap = NULL;
 260 }
 261
 262 /**
 263   Request HttpTcpReceiveNotifyDpc as a DPC at TPL_CALLBACK.
 264
 265   @param  Event                 The receive event delivered to TCP for receive.
 266   @param  Context               Context for the callback.
 267
 268 **/
 269 VOID
 270 EFIAPI
 271 HttpTcpReceiveNotify (
 272   IN EFI_EVENT                Event,
 273   IN VOID                     *Context
 274   )
 275 {
 276   //
 277   // Request HttpTcpTransmitNotifyDpc as a DPC at TPL_CALLBACK
 278   //
 279   QueueDpc (TPL_CALLBACK, HttpTcpReceiveNotifyDpc, Context);
 280 }
 281
 282 /**
 283   Create events for the TCP connection token and TCP close token.
 284
 285   @param[in]  HttpInstance       Pointer to HTTP_PROTOCOL structure.
 286
 287   @retval EFI_SUCCESS            The events are created successfully.
 288   @retval others                 Other error as indicated.
 289
 290 **/
 291 EFI_STATUS
 292 HttpCreateTcpConnCloseEvent (
 293   IN  HTTP_PROTOCOL        *HttpInstance
 294   )
 295 {
 296   EFI_STATUS               Status;
 297
 298   if (!HttpInstance->LocalAddressIsIPv6) {
 299     //
 300     // Create events for variuos asynchronous operations.
 301     //
 302     Status = gBS->CreateEvent (
 303                     EVT_NOTIFY_SIGNAL,
 304                     TPL_NOTIFY,
 305                     HttpCommonNotify,
 306                     &HttpInstance->IsTcp4ConnDone,
 307                     &HttpInstance->Tcp4ConnToken.CompletionToken.Event
 308                     );
 309     if (EFI_ERROR (Status)) {
 310       goto ERROR;
 311     }
 312
 313     //
 314     // Initialize Tcp4CloseToken
 315     //
 316     Status = gBS->CreateEvent (
 317                     EVT_NOTIFY_SIGNAL,
 318                     TPL_NOTIFY,
 319                     HttpCommonNotify,
 320                     &HttpInstance->IsTcp4CloseDone,
 321                     &HttpInstance->Tcp4CloseToken.CompletionToken.Event
 322                     );
 323     if (EFI_ERROR (Status)) {
 324       goto ERROR;
 325     }
 326
 327   } else {
 328     //
 329     // Create events for variuos asynchronous operations.
 330     //
 331     Status = gBS->CreateEvent (
 332                     EVT_NOTIFY_SIGNAL,
 333                     TPL_NOTIFY,
 334                     HttpCommonNotify,
 335                     &HttpInstance->IsTcp6ConnDone,
 336                     &HttpInstance->Tcp6ConnToken.CompletionToken.Event
 337                     );
 338     if (EFI_ERROR (Status)) {
 339       goto ERROR;
 340     }
 341
 342     //
 343     // Initialize Tcp6CloseToken
 344     //
 345     Status = gBS->CreateEvent (
 346                     EVT_NOTIFY_SIGNAL,
 347                     TPL_NOTIFY,
 348                     HttpCommonNotify,
 349                     &HttpInstance->IsTcp6CloseDone,
 350                     &HttpInstance->Tcp6CloseToken.CompletionToken.Event
 351                     );
 352     if (EFI_ERROR (Status)) {
 353       goto ERROR;
 354     }
 355   }
 356
 357   return EFI_SUCCESS;
 358
 359 ERROR:
 360   //
 361   // Error handling
 362   //
 363   HttpCloseTcpConnCloseEvent (HttpInstance);
 364
 365   return Status;
 366 }
 367
 368
 369 /**
 370   Close events in the TCP connection token and TCP close token.
 371
 372   @param[in]  HttpInstance   Pointer to HTTP_PROTOCOL structure.
 373
 374 **/
 375 VOID
 376 HttpCloseTcpConnCloseEvent (
 377   IN  HTTP_PROTOCOL        *HttpInstance
 378   )
 379 {
 380   ASSERT (HttpInstance != NULL);
 381
 382   if (HttpInstance->LocalAddressIsIPv6) {
 383     if (NULL != HttpInstance->Tcp6ConnToken.CompletionToken.Event) {
 384       gBS->CloseEvent (HttpInstance->Tcp6ConnToken.CompletionToken.Event);
 385       HttpInstance->Tcp6ConnToken.CompletionToken.Event = NULL;
 386     }
 387
 388     if (NULL != HttpInstance->Tcp6CloseToken.CompletionToken.Event) {
 389       gBS->CloseEvent(HttpInstance->Tcp6CloseToken.CompletionToken.Event);
 390       HttpInstance->Tcp6CloseToken.CompletionToken.Event = NULL;
 391     }
 392
 393   } else {
 394     if (NULL != HttpInstance->Tcp4ConnToken.CompletionToken.Event) {
 395       gBS->CloseEvent (HttpInstance->Tcp4ConnToken.CompletionToken.Event);
 396       HttpInstance->Tcp4ConnToken.CompletionToken.Event = NULL;
 397     }
 398
 399     if (NULL != HttpInstance->Tcp4CloseToken.CompletionToken.Event) {
 400       gBS->CloseEvent(HttpInstance->Tcp4CloseToken.CompletionToken.Event);
 401       HttpInstance->Tcp4CloseToken.CompletionToken.Event = NULL;
 402     }
 403   }
 404
 405 }
 406
 407 /**
 408   Create event for the TCP transmit token.
 409
 410   @param[in]  Wrap               Point to HTTP token's wrap data.
 411
 412   @retval EFI_SUCCESS            The events is created successfully.
 413   @retval others                 Other error as indicated.
 414
 415 **/
 416 EFI_STATUS
 417 HttpCreateTcpTxEvent (
 418   IN  HTTP_TOKEN_WRAP      *Wrap
 419   )
 420 {
 421   EFI_STATUS               Status;
 422   HTTP_PROTOCOL            *HttpInstance;
 423   HTTP_TCP_TOKEN_WRAP      *TcpWrap;
 424
 425   HttpInstance = Wrap->HttpInstance;
 426   TcpWrap      = &Wrap->TcpWrap;
 427
 428   if (!HttpInstance->LocalAddressIsIPv6) {
 429     Status = gBS->CreateEvent (
 430                     EVT_NOTIFY_SIGNAL,
 431                     TPL_NOTIFY,
 432                     HttpTcpTransmitNotify,
 433                     Wrap,
 434                     &TcpWrap->Tx4Token.CompletionToken.Event
 435                     );
 436     if (EFI_ERROR (Status)) {
 437       return Status;
 438     }
 439
 440     TcpWrap->Tx4Data.Push = TRUE;
 441     TcpWrap->Tx4Data.Urgent = FALSE;
 442     TcpWrap->Tx4Data.FragmentCount = 1;
 443     TcpWrap->Tx4Token.Packet.TxData = &Wrap->TcpWrap.Tx4Data;
 444     TcpWrap->Tx4Token.CompletionToken.Status = EFI_NOT_READY;
 445
 446   } else {
 447     Status = gBS->CreateEvent (
 448                     EVT_NOTIFY_SIGNAL,
 449                     TPL_NOTIFY,
 450                     HttpTcpTransmitNotify,
 451                     Wrap,
 452                     &TcpWrap->Tx6Token.CompletionToken.Event
 453                     );
 454     if (EFI_ERROR (Status)) {
 455       return Status;
 456     }
 457
 458     TcpWrap->Tx6Data.Push   = TRUE;
 459     TcpWrap->Tx6Data.Urgent = FALSE;
 460     TcpWrap->Tx6Data.FragmentCount  = 1;
 461     TcpWrap->Tx6Token.Packet.TxData = &Wrap->TcpWrap.Tx6Data;
 462     TcpWrap->Tx6Token.CompletionToken.Status =EFI_NOT_READY;
 463
 464   }
 465
 466   return EFI_SUCCESS;
 467 }
 468
 469 /**
 470   Create event for the TCP receive token which is used to receive HTTP header.
 471
 472   @param[in]  HttpInstance       Pointer to HTTP_PROTOCOL structure.
 473
 474   @retval EFI_SUCCESS            The events is created successfully.
 475   @retval others                 Other error as indicated.
 476
 477 **/
 478 EFI_STATUS
 479 HttpCreateTcpRxEventForHeader (
 480   IN  HTTP_PROTOCOL        *HttpInstance
 481   )
 482 {
 483   EFI_STATUS               Status;
 484
 485   if (!HttpInstance->LocalAddressIsIPv6) {
 486     Status = gBS->CreateEvent (
 487                     EVT_NOTIFY_SIGNAL,
 488                     TPL_NOTIFY,
 489                     HttpCommonNotify,
 490                     &HttpInstance->IsRxDone,
 491                     &HttpInstance->Rx4Token.CompletionToken.Event
 492                     );
 493     if (EFI_ERROR (Status)) {
 494       return Status;
 495     }
 496
 497     HttpInstance->Rx4Data.FragmentCount = 1;
 498     HttpInstance->Rx4Token.Packet.RxData = &HttpInstance->Rx4Data;
 499     HttpInstance->Rx4Token.CompletionToken.Status = EFI_NOT_READY;
 500
 501   } else {
 502     Status = gBS->CreateEvent (
 503                     EVT_NOTIFY_SIGNAL,
 504                     TPL_NOTIFY,
 505                     HttpCommonNotify,
 506                     &HttpInstance->IsRxDone,
 507                     &HttpInstance->Rx6Token.CompletionToken.Event
 508                     );
 509     if (EFI_ERROR (Status)) {
 510       return Status;
 511     }
 512
 513     HttpInstance->Rx6Data.FragmentCount  =1;
 514     HttpInstance->Rx6Token.Packet.RxData = &HttpInstance->Rx6Data;
 515     HttpInstance->Rx6Token.CompletionToken.Status = EFI_NOT_READY;
 516
 517   }
 518
 519
 520   return EFI_SUCCESS;
 521 }
 522
 523 /**
 524   Create event for the TCP receive token which is used to receive HTTP body.
 525
 526   @param[in]  Wrap               Point to HTTP token's wrap data.
 527
 528   @retval EFI_SUCCESS            The events is created successfully.
 529   @retval others                 Other error as indicated.
 530
 531 **/
 532 EFI_STATUS
 533 HttpCreateTcpRxEvent (
 534   IN  HTTP_TOKEN_WRAP      *Wrap
 535   )
 536 {
 537   EFI_STATUS               Status;
 538   HTTP_PROTOCOL            *HttpInstance;
 539   HTTP_TCP_TOKEN_WRAP      *TcpWrap;
 540
 541   HttpInstance = Wrap->HttpInstance;
 542   TcpWrap      = &Wrap->TcpWrap;
 543   if (!HttpInstance->LocalAddressIsIPv6) {
 544     Status = gBS->CreateEvent (
 545                     EVT_NOTIFY_SIGNAL,
 546                     TPL_NOTIFY,
 547                     HttpTcpReceiveNotify,
 548                     Wrap,
 549                     &TcpWrap->Rx4Token.CompletionToken.Event
 550                     );
 551     if (EFI_ERROR (Status)) {
 552       return Status;
 553     }
 554
 555     TcpWrap->Rx4Data.FragmentCount = 1;
 556     TcpWrap->Rx4Token.Packet.RxData = &Wrap->TcpWrap.Rx4Data;
 557     TcpWrap->Rx4Token.CompletionToken.Status = EFI_NOT_READY;
 558
 559   } else {
 560     Status = gBS->CreateEvent (
 561                     EVT_NOTIFY_SIGNAL,
 562                     TPL_NOTIFY,
 563                     HttpTcpReceiveNotify,
 564                     Wrap,
 565                     &TcpWrap->Rx6Token.CompletionToken.Event
 566                     );
 567     if (EFI_ERROR (Status)) {
 568       return Status;
 569     }
 570
 571     TcpWrap->Rx6Data.FragmentCount = 1;
 572     TcpWrap->Rx6Token.Packet.RxData = &Wrap->TcpWrap.Rx6Data;
 573     TcpWrap->Rx6Token.CompletionToken.Status = EFI_NOT_READY;
 574   }
 575
 576   return EFI_SUCCESS;
 577 }
 578
 579 /**
 580   Close Events for Tcp Receive Tokens for HTTP body and HTTP header.
 581
 582   @param[in]  Wrap               Pointer to HTTP token's wrap data.
 583
 584 **/
 585 VOID
 586 HttpCloseTcpRxEvent (
 587   IN  HTTP_TOKEN_WRAP      *Wrap
 588   )
 589 {
 590   HTTP_PROTOCOL            *HttpInstance;
 591
 592   ASSERT (Wrap != NULL);
 593   HttpInstance   = Wrap->HttpInstance;
 594
 595   if (HttpInstance->LocalAddressIsIPv6) {
 596     if (Wrap->TcpWrap.Rx6Token.CompletionToken.Event != NULL) {
 597       gBS->CloseEvent (Wrap->TcpWrap.Rx6Token.CompletionToken.Event);
 598     }
 599
 600     if (HttpInstance->Rx6Token.CompletionToken.Event != NULL) {
 601       gBS->CloseEvent (HttpInstance->Rx6Token.CompletionToken.Event);
 602       HttpInstance->Rx6Token.CompletionToken.Event = NULL;
 603     }
 604   } else {
 605     if (Wrap->TcpWrap.Rx4Token.CompletionToken.Event != NULL) {
 606       gBS->CloseEvent (Wrap->TcpWrap.Rx4Token.CompletionToken.Event);
 607     }
 608
 609     if (HttpInstance->Rx4Token.CompletionToken.Event != NULL) {
 610       gBS->CloseEvent (HttpInstance->Rx4Token.CompletionToken.Event);
 611       HttpInstance->Rx4Token.CompletionToken.Event = NULL;
 612     }
 613   }
 614 }
 615
 616 /**
 617   Intiialize the HTTP_PROTOCOL structure to the unconfigured state.
 618
 619   @param[in, out]  HttpInstance         Pointer to HTTP_PROTOCOL structure.
 620   @param[in]       IpVersion            Indicate us TCP4 protocol or TCP6 protocol.
 621
 622   @retval EFI_SUCCESS       HTTP_PROTOCOL structure is initialized successfully.
 623   @retval Others            Other error as indicated.
 624
 625 **/
 626 EFI_STATUS
 627 HttpInitProtocol (
 628   IN OUT HTTP_PROTOCOL           *HttpInstance,
 629   IN     BOOLEAN                 IpVersion
 630   )
 631 {
 632   EFI_STATUS                     Status;
 633   VOID                           *Interface;
 634   BOOLEAN                        UsingIpv6;
 635
 636   ASSERT (HttpInstance != NULL);
 637   UsingIpv6 = IpVersion;
 638
 639   if (!UsingIpv6) {
 640     //
 641     // Create TCP4 child.
 642     //
 643     Status = NetLibCreateServiceChild (
 644                HttpInstance->Service->ControllerHandle,
 645                HttpInstance->Service->ImageHandle,
 646                &gEfiTcp4ServiceBindingProtocolGuid,
 647                &HttpInstance->Tcp4ChildHandle
 648                );
 649
 650     if (EFI_ERROR (Status)) {
 651       goto ON_ERROR;
 652     }
 653
 654     Status = gBS->OpenProtocol (
 655                     HttpInstance->Tcp4ChildHandle,
 656                     &gEfiTcp4ProtocolGuid,
 657                     (VOID **) &Interface,
 658                     HttpInstance->Service->ImageHandle,
 659                     HttpInstance->Service->ControllerHandle,
 660                     EFI_OPEN_PROTOCOL_BY_DRIVER
 661                     );
 662
 663     if (EFI_ERROR (Status)) {
 664       goto ON_ERROR;
 665     }
 666
 667     Status = gBS->OpenProtocol (
 668                     HttpInstance->Tcp4ChildHandle,
 669                     &gEfiTcp4ProtocolGuid,
 670                     (VOID **) &HttpInstance->Tcp4,
 671                     HttpInstance->Service->ImageHandle,
 672                     HttpInstance->Handle,
 673                     EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 674                     );
 675     if (EFI_ERROR(Status)) {
 676       goto ON_ERROR;
 677     }
 678
 679     Status = gBS->OpenProtocol (
 680                     HttpInstance->Service->Tcp4ChildHandle,
 681                     &gEfiTcp4ProtocolGuid,
 682                     (VOID **) &Interface,
 683                     HttpInstance->Service->ImageHandle,
 684                     HttpInstance->Handle,
 685                     EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 686                     );
 687     if (EFI_ERROR(Status)) {
 688       goto ON_ERROR;
 689     }
 690   } else {
 691     //
 692     // Create TCP6 Child.
 693     //
 694     Status = NetLibCreateServiceChild (
 695                HttpInstance->Service->ControllerHandle,
 696                HttpInstance->Service->ImageHandle,
 697                &gEfiTcp6ServiceBindingProtocolGuid,
 698                &HttpInstance->Tcp6ChildHandle
 699                );
 700
 701     if (EFI_ERROR (Status)) {
 702       goto ON_ERROR;
 703     }
 704
 705     Status = gBS->OpenProtocol (
 706                     HttpInstance->Tcp6ChildHandle,
 707                     &gEfiTcp6ProtocolGuid,
 708                     (VOID **) &Interface,
 709                     HttpInstance->Service->ImageHandle,
 710                     HttpInstance->Service->ControllerHandle,
 711                     EFI_OPEN_PROTOCOL_BY_DRIVER
 712                     );
 713
 714     if (EFI_ERROR (Status)) {
 715       goto ON_ERROR;
 716     }
 717
 718     Status = gBS->OpenProtocol (
 719                     HttpInstance->Tcp6ChildHandle,
 720                     &gEfiTcp6ProtocolGuid,
 721                     (VOID **) &HttpInstance->Tcp6,
 722                     HttpInstance->Service->ImageHandle,
 723                     HttpInstance->Handle,
 724                     EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 725                     );
 726
 727     if (EFI_ERROR(Status)) {
 728       goto ON_ERROR;
 729     }
 730
 731     Status = gBS->OpenProtocol (
 732                     HttpInstance->Service->Tcp6ChildHandle,
 733                     &gEfiTcp6ProtocolGuid,
 734                     (VOID **) &Interface,
 735                     HttpInstance->Service->ImageHandle,
 736                     HttpInstance->Handle,
 737                     EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 738                     );
 739
 740     if (EFI_ERROR(Status)) {
 741       goto ON_ERROR;
 742     }
 743   }
 744
 745   HttpInstance->Url = AllocateZeroPool (HTTP_URL_BUFFER_LEN);
 746   if (HttpInstance->Url == NULL) {
 747     Status = EFI_OUT_OF_RESOURCES;
 748     goto ON_ERROR;
 749   }
 750
 751   return EFI_SUCCESS;
 752
 753 ON_ERROR:
 754
 755   if (HttpInstance->Tcp4ChildHandle != NULL) {
 756     gBS->CloseProtocol (
 757            HttpInstance->Tcp4ChildHandle,
 758            &gEfiTcp4ProtocolGuid,
 759            HttpInstance->Service->ImageHandle,
 760            HttpInstance->Service->ControllerHandle
 761            );
 762
 763     gBS->CloseProtocol (
 764            HttpInstance->Tcp4ChildHandle,
 765            &gEfiTcp4ProtocolGuid,
 766            HttpInstance->Service->ImageHandle,
 767            HttpInstance->Handle
 768            );
 769
 770     NetLibDestroyServiceChild (
 771       HttpInstance->Service->ControllerHandle,
 772       HttpInstance->Service->ImageHandle,
 773       &gEfiTcp4ServiceBindingProtocolGuid,
 774       HttpInstance->Tcp4ChildHandle
 775       );
 776   }
 777
 778   if (HttpInstance->Service->Tcp4ChildHandle != NULL) {
 779     gBS->CloseProtocol (
 780            HttpInstance->Service->Tcp4ChildHandle,
 781            &gEfiTcp4ProtocolGuid,
 782            HttpInstance->Service->ImageHandle,
 783            HttpInstance->Handle
 784            );
 785   }
 786
 787   if (HttpInstance->Tcp6ChildHandle != NULL) {
 788     gBS->CloseProtocol (
 789            HttpInstance->Tcp6ChildHandle,
 790            &gEfiTcp6ProtocolGuid,
 791            HttpInstance->Service->ImageHandle,
 792            HttpInstance->Service->ControllerHandle
 793            );
 794
 795     gBS->CloseProtocol (
 796            HttpInstance->Tcp6ChildHandle,
 797            &gEfiTcp6ProtocolGuid,
 798            HttpInstance->Service->ImageHandle,
 799            HttpInstance->Handle
 800            );
 801
 802     NetLibDestroyServiceChild (
 803       HttpInstance->Service->ControllerHandle,
 804       HttpInstance->Service->ImageHandle,
 805       &gEfiTcp6ServiceBindingProtocolGuid,
 806       HttpInstance->Tcp6ChildHandle
 807       );
 808   }
 809
 810   if (HttpInstance->Service->Tcp6ChildHandle != NULL) {
 811     gBS->CloseProtocol (
 812            HttpInstance->Service->Tcp6ChildHandle,
 813            &gEfiTcp6ProtocolGuid,
 814            HttpInstance->Service->ImageHandle,
 815            HttpInstance->Handle
 816            );
 817   }
 818
 819   return EFI_UNSUPPORTED;
 820
 821 }
 822
 823 /**
 824   Clean up the HTTP child, release all the resources used by it.
 825
 826   @param[in]  HttpInstance       The HTTP child to clean up.
 827
 828 **/
 829 VOID
 830 HttpCleanProtocol (
 831   IN  HTTP_PROTOCOL          *HttpInstance
 832   )
 833 {
 834   HttpCloseConnection (HttpInstance);
 835
 836   HttpCloseTcpConnCloseEvent (HttpInstance);
 837
 838   if (HttpInstance->TimeoutEvent != NULL) {
 839     gBS->CloseEvent (HttpInstance->TimeoutEvent);
 840     HttpInstance->TimeoutEvent = NULL;
 841   }
 842
 843   if (HttpInstance->CacheBody != NULL) {
 844     FreePool (HttpInstance->CacheBody);
 845     HttpInstance->CacheBody = NULL;
 846     HttpInstance->NextMsg   = NULL;
 847   }
 848
 849   if (HttpInstance->RemoteHost != NULL) {
 850     FreePool (HttpInstance->RemoteHost);
 851     HttpInstance->RemoteHost = NULL;
 852   }
 853
 854   if (HttpInstance->MsgParser != NULL) {
 855     HttpFreeMsgParser (HttpInstance->MsgParser);
 856     HttpInstance->MsgParser = NULL;
 857   }
 858
 859   if (HttpInstance->Url != NULL) {
 860     FreePool (HttpInstance->Url);
 861     HttpInstance->Url = NULL;
 862   }
 863
 864   NetMapClean (&HttpInstance->TxTokens);
 865   NetMapClean (&HttpInstance->RxTokens);
 866
 867   if (HttpInstance->Tcp4ChildHandle != NULL) {
 868     gBS->CloseProtocol (
 869            HttpInstance->Tcp4ChildHandle,
 870            &gEfiTcp4ProtocolGuid,
 871            HttpInstance->Service->ImageHandle,
 872            HttpInstance->Service->ControllerHandle
 873            );
 874
 875     gBS->CloseProtocol (
 876            HttpInstance->Tcp4ChildHandle,
 877            &gEfiTcp4ProtocolGuid,
 878            HttpInstance->Service->ImageHandle,
 879            HttpInstance->Handle
 880            );
 881
 882     NetLibDestroyServiceChild (
 883       HttpInstance->Service->ControllerHandle,
 884       HttpInstance->Service->ImageHandle,
 885       &gEfiTcp4ServiceBindingProtocolGuid,
 886       HttpInstance->Tcp4ChildHandle
 887       );
 888   }
 889
 890   if (HttpInstance->Service->Tcp4ChildHandle != NULL) {
 891     gBS->CloseProtocol (
 892            HttpInstance->Service->Tcp4ChildHandle,
 893            &gEfiTcp4ProtocolGuid,
 894            HttpInstance->Service->ImageHandle,
 895            HttpInstance->Handle
 896            );
 897   }
 898
 899   if (HttpInstance->Tcp6ChildHandle != NULL) {
 900     gBS->CloseProtocol (
 901            HttpInstance->Tcp6ChildHandle,
 902            &gEfiTcp6ProtocolGuid,
 903            HttpInstance->Service->ImageHandle,
 904            HttpInstance->Service->ControllerHandle
 905            );
 906
 907     gBS->CloseProtocol (
 908            HttpInstance->Tcp6ChildHandle,
 909            &gEfiTcp6ProtocolGuid,
 910            HttpInstance->Service->ImageHandle,
 911            HttpInstance->Handle
 912            );
 913
 914     NetLibDestroyServiceChild (
 915       HttpInstance->Service->ControllerHandle,
 916       HttpInstance->Service->ImageHandle,
 917       &gEfiTcp6ServiceBindingProtocolGuid,
 918       HttpInstance->Tcp6ChildHandle
 919       );
 920   }
 921
 922   if (HttpInstance->Service->Tcp6ChildHandle != NULL) {
 923     gBS->CloseProtocol (
 924            HttpInstance->Service->Tcp6ChildHandle,
 925            &gEfiTcp6ProtocolGuid,
 926            HttpInstance->Service->ImageHandle,
 927            HttpInstance->Handle
 928            );
 929   }
 930
 931   TlsCloseTxRxEvent (HttpInstance);
 932 }
 933
 934 /**
 935   Establish TCP connection with HTTP server.
 936
 937   @param[in]  HttpInstance       The HTTP instance private data.
 938
 939   @retval EFI_SUCCESS            The TCP connection is established.
 940   @retval Others                 Other error as indicated.
 941
 942 **/
 943 EFI_STATUS
 944 HttpCreateConnection (
 945   IN  HTTP_PROTOCOL        *HttpInstance
 946   )
 947 {
 948   EFI_STATUS                    Status;
 949
 950   //
 951   // Connect to Http server
 952   //
 953   if (!HttpInstance->LocalAddressIsIPv6) {
 954     HttpInstance->IsTcp4ConnDone = FALSE;
 955     HttpInstance->Tcp4ConnToken.CompletionToken.Status = EFI_NOT_READY;
 956     Status = HttpInstance->Tcp4->Connect (HttpInstance->Tcp4, &HttpInstance->Tcp4ConnToken);
 957     if (EFI_ERROR (Status)) {
 958       DEBUG ((EFI_D_ERROR, "HttpCreateConnection: Tcp4->Connect() = %r\n", Status));
 959       return Status;
 960     }
 961
 962     while (!HttpInstance->IsTcp4ConnDone) {
 963       HttpInstance->Tcp4->Poll (HttpInstance->Tcp4);
 964     }
 965
 966     Status = HttpInstance->Tcp4ConnToken.CompletionToken.Status;
 967
 968   } else {
 969     HttpInstance->IsTcp6ConnDone = FALSE;
 970     HttpInstance->Tcp6ConnToken.CompletionToken.Status = EFI_NOT_READY;
 971     Status = HttpInstance->Tcp6->Connect (HttpInstance->Tcp6, &HttpInstance->Tcp6ConnToken);
 972     if (EFI_ERROR (Status)) {
 973       DEBUG ((EFI_D_ERROR, "HttpCreateConnection: Tcp6->Connect() = %r\n", Status));
 974       return Status;
 975     }
 976
 977     while(!HttpInstance->IsTcp6ConnDone) {
 978       HttpInstance->Tcp6->Poll (HttpInstance->Tcp6);
 979     }
 980
 981     Status = HttpInstance->Tcp6ConnToken.CompletionToken.Status;
 982   }
 983
 984   if (!EFI_ERROR (Status)) {
 985     HttpInstance->State = HTTP_STATE_TCP_CONNECTED;
 986   }
 987
 988   return Status;
 989 }
 990
 991 /**
 992   Close existing TCP connection.
 993
 994   @param[in]  HttpInstance       The HTTP instance private data.
 995
 996   @retval EFI_SUCCESS            The TCP connection is closed.
 997   @retval Others                 Other error as indicated.
 998
 999 **/
1000 EFI_STATUS
1001 HttpCloseConnection (
1002   IN  HTTP_PROTOCOL        *HttpInstance
1003   )
1004 {
1005   EFI_STATUS                Status;
1006
1007   if (HttpInstance->State == HTTP_STATE_TCP_CONNECTED) {
1008
1009     if (HttpInstance->LocalAddressIsIPv6) {
1010       HttpInstance->Tcp6CloseToken.AbortOnClose = TRUE;
1011       HttpInstance->IsTcp6CloseDone             = FALSE;
1012       Status = HttpInstance->Tcp6->Close (HttpInstance->Tcp6, &HttpInstance->Tcp6CloseToken);
1013       if (EFI_ERROR (Status)) {
1014         return Status;
1015       }
1016
1017       while (!HttpInstance->IsTcp6CloseDone) {
1018         HttpInstance->Tcp6->Poll (HttpInstance->Tcp6);
1019       }
1020
1021     } else {
1022       HttpInstance->Tcp4CloseToken.AbortOnClose = TRUE;
1023       HttpInstance->IsTcp4CloseDone             = FALSE;
1024       Status = HttpInstance->Tcp4->Close (HttpInstance->Tcp4, &HttpInstance->Tcp4CloseToken);
1025       if (EFI_ERROR (Status)) {
1026         return Status;
1027       }
1028
1029       while (!HttpInstance->IsTcp4CloseDone) {
1030         HttpInstance->Tcp4->Poll (HttpInstance->Tcp4);
1031       }
1032     }
1033
1034   }
1035
1036   HttpInstance->State = HTTP_STATE_TCP_CLOSED;
1037   return EFI_SUCCESS;
1038 }
1039
1040 /**
1041   Configure TCP4 protocol child.
1042
1043   @param[in]  HttpInstance       The HTTP instance private data.
1044   @param[in]  Wrap               The HTTP token's wrap data.
1045
1046   @retval EFI_SUCCESS            The TCP4 protocol child is configured.
1047   @retval Others                 Other error as indicated.
1048
1049 **/
1050 EFI_STATUS
1051 HttpConfigureTcp4 (
1052   IN  HTTP_PROTOCOL        *HttpInstance,
1053   IN  HTTP_TOKEN_WRAP      *Wrap
1054   )
1055 {
1056   EFI_STATUS                 Status;
1057   EFI_TCP4_CONFIG_DATA       *Tcp4CfgData;
1058   EFI_TCP4_ACCESS_POINT      *Tcp4AP;
1059   EFI_TCP4_OPTION            *Tcp4Option;
1060
1061   ASSERT (HttpInstance != NULL);
1062
1063
1064   Tcp4CfgData = &HttpInstance->Tcp4CfgData;
1065   ZeroMem (Tcp4CfgData, sizeof (EFI_TCP4_CONFIG_DATA));
1066
1067   Tcp4CfgData->TypeOfService = HTTP_TOS_DEAULT;
1068   Tcp4CfgData->TimeToLive    = HTTP_TTL_DEAULT;
1069   Tcp4CfgData->ControlOption = &HttpInstance->Tcp4Option;
1070
1071   Tcp4AP = &Tcp4CfgData->AccessPoint;
1072   Tcp4AP->UseDefaultAddress = HttpInstance->IPv4Node.UseDefaultAddress;
1073   if (!Tcp4AP->UseDefaultAddress) {
1074     IP4_COPY_ADDRESS (&Tcp4AP->StationAddress, &HttpInstance->IPv4Node.LocalAddress);
1075     IP4_COPY_ADDRESS (&Tcp4AP->SubnetMask, &HttpInstance->IPv4Node.LocalSubnet);
1076   }
1077
1078   Tcp4AP->StationPort = HttpInstance->IPv4Node.LocalPort;
1079   Tcp4AP->RemotePort  = HttpInstance->RemotePort;
1080   Tcp4AP->ActiveFlag  = TRUE;
1081   IP4_COPY_ADDRESS (&Tcp4AP->RemoteAddress, &HttpInstance->RemoteAddr);
1082
1083   Tcp4Option = Tcp4CfgData->ControlOption;
1084   Tcp4Option->ReceiveBufferSize      = HTTP_BUFFER_SIZE_DEAULT;
1085   Tcp4Option->SendBufferSize         = HTTP_BUFFER_SIZE_DEAULT;
1086   Tcp4Option->MaxSynBackLog          = HTTP_MAX_SYN_BACK_LOG;
1087   Tcp4Option->ConnectionTimeout      = HTTP_CONNECTION_TIMEOUT;
1088   Tcp4Option->DataRetries            = HTTP_DATA_RETRIES;
1089   Tcp4Option->FinTimeout             = HTTP_FIN_TIMEOUT;
1090   Tcp4Option->KeepAliveProbes        = HTTP_KEEP_ALIVE_PROBES;
1091   Tcp4Option->KeepAliveTime          = HTTP_KEEP_ALIVE_TIME;
1092   Tcp4Option->KeepAliveInterval      = HTTP_KEEP_ALIVE_INTERVAL;
1093   Tcp4Option->EnableNagle            = TRUE;
1094   Tcp4CfgData->ControlOption         = Tcp4Option;
1095
1096   Status = HttpInstance->Tcp4->Configure (HttpInstance->Tcp4, Tcp4CfgData);
1097   if (EFI_ERROR (Status)) {
1098     DEBUG ((EFI_D_ERROR, "HttpConfigureTcp4 - %r\n", Status));
1099     return Status;
1100   }
1101
1102   Status = HttpCreateTcpConnCloseEvent (HttpInstance);
1103   if (EFI_ERROR (Status)) {
1104     return Status;
1105   }
1106
1107   Status = HttpCreateTcpTxEvent (Wrap);
1108   if (EFI_ERROR (Status)) {
1109     return Status;
1110   }
1111
1112   HttpInstance->State = HTTP_STATE_TCP_CONFIGED;
1113
1114   return EFI_SUCCESS;
1115 }
1116
1117 /**
1118   Configure TCP6 protocol child.
1119
1120   @param[in]  HttpInstance       The HTTP instance private data.
1121   @param[in]  Wrap               The HTTP token's wrap data.
1122
1123   @retval EFI_SUCCESS            The TCP6 protocol child is configured.
1124   @retval Others                 Other error as indicated.
1125
1126 **/
1127 EFI_STATUS
1128 HttpConfigureTcp6 (
1129   IN  HTTP_PROTOCOL        *HttpInstance,
1130   IN  HTTP_TOKEN_WRAP      *Wrap
1131   )
1132 {
1133   EFI_STATUS               Status;
1134   EFI_TCP6_CONFIG_DATA     *Tcp6CfgData;
1135   EFI_TCP6_ACCESS_POINT    *Tcp6Ap;
1136   EFI_TCP6_OPTION          *Tcp6Option;
1137
1138   ASSERT (HttpInstance != NULL);
1139
1140   Tcp6CfgData = &HttpInstance->Tcp6CfgData;
1141   ZeroMem (Tcp6CfgData, sizeof (EFI_TCP6_CONFIG_DATA));
1142
1143   Tcp6CfgData->TrafficClass  = 0;
1144   Tcp6CfgData->HopLimit      = 255;
1145   Tcp6CfgData->ControlOption = &HttpInstance->Tcp6Option;
1146
1147   Tcp6Ap  = &Tcp6CfgData->AccessPoint;
1148   Tcp6Ap->ActiveFlag  = TRUE;
1149   Tcp6Ap->StationPort = HttpInstance->Ipv6Node.LocalPort;
1150   Tcp6Ap->RemotePort  = HttpInstance->RemotePort;
1151   IP6_COPY_ADDRESS (&Tcp6Ap->StationAddress, &HttpInstance->Ipv6Node.LocalAddress);
1152   IP6_COPY_ADDRESS (&Tcp6Ap->RemoteAddress , &HttpInstance->RemoteIpv6Addr);
1153
1154   Tcp6Option = Tcp6CfgData->ControlOption;
1155   Tcp6Option->ReceiveBufferSize  = HTTP_BUFFER_SIZE_DEAULT;
1156   Tcp6Option->SendBufferSize     = HTTP_BUFFER_SIZE_DEAULT;
1157   Tcp6Option->MaxSynBackLog      = HTTP_MAX_SYN_BACK_LOG;
1158   Tcp6Option->ConnectionTimeout  = HTTP_CONNECTION_TIMEOUT;
1159   Tcp6Option->DataRetries        = HTTP_DATA_RETRIES;
1160   Tcp6Option->FinTimeout         = HTTP_FIN_TIMEOUT;
1161   Tcp6Option->KeepAliveProbes    = HTTP_KEEP_ALIVE_PROBES;
1162   Tcp6Option->KeepAliveTime      = HTTP_KEEP_ALIVE_TIME;
1163   Tcp6Option->KeepAliveInterval  = HTTP_KEEP_ALIVE_INTERVAL;
1164   Tcp6Option->EnableNagle        = TRUE;
1165
1166   Status = HttpInstance->Tcp6->Configure (HttpInstance->Tcp6, Tcp6CfgData);
1167   if (EFI_ERROR (Status)) {
1168     DEBUG ((EFI_D_ERROR, "HttpConfigureTcp6 - %r\n", Status));
1169     return Status;
1170   }
1171
1172   Status = HttpCreateTcpConnCloseEvent (HttpInstance);
1173   if (EFI_ERROR (Status)) {
1174     return Status;
1175   }
1176
1177   Status = HttpCreateTcpTxEvent (Wrap);
1178   if (EFI_ERROR (Status)) {
1179     return Status;
1180   }
1181
1182   HttpInstance->State = HTTP_STATE_TCP_CONFIGED;
1183
1184   return EFI_SUCCESS;
1185
1186 }
1187
1188 /**
1189   Check existing TCP connection, if in error state, recover TCP4 connection. Then,
1190   connect one TLS session if required.
1191
1192   @param[in]  HttpInstance       The HTTP instance private data.
1193
1194   @retval EFI_SUCCESS            The TCP connection is established.
1195   @retval EFI_NOT_READY          TCP4 protocol child is not created or configured.
1196   @retval Others                 Other error as indicated.
1197
1198 **/
1199 EFI_STATUS
1200 HttpConnectTcp4 (
1201   IN  HTTP_PROTOCOL        *HttpInstance
1202   )
1203 {
1204   EFI_STATUS                Status;
1205   EFI_TCP4_CONNECTION_STATE Tcp4State;
1206
1207
1208   if (HttpInstance->State < HTTP_STATE_TCP_CONFIGED || HttpInstance->Tcp4 == NULL) {
1209     return EFI_NOT_READY;
1210   }
1211
1212   Status = HttpInstance->Tcp4->GetModeData(
1213                                  HttpInstance->Tcp4,
1214                                  &Tcp4State,
1215                                  NULL,
1216                                  NULL,
1217                                  NULL,
1218                                  NULL
1219                                  );
1220   if (EFI_ERROR(Status)){
1221     DEBUG ((EFI_D_ERROR, "Tcp4 GetModeData fail - %x\n", Status));
1222     return Status;
1223   }
1224
1225   if (Tcp4State == Tcp4StateEstablished) {
1226     return EFI_SUCCESS;
1227   } else if (Tcp4State > Tcp4StateEstablished ) {
1228     HttpCloseConnection(HttpInstance);
1229   }
1230
1231   Status = HttpCreateConnection (HttpInstance);
1232   if (EFI_ERROR(Status)){
1233     DEBUG ((EFI_D_ERROR, "Tcp4 Connection fail - %x\n", Status));
1234     return Status;
1235   }
1236
1237   //
1238   // Tls session connection.
1239   //
1240   if (HttpInstance->UseHttps) {
1241     if (HttpInstance->TimeoutEvent == NULL) {
1242       //
1243       // Create TimeoutEvent for TLS connection.
1244       //
1245       Status = gBS->CreateEvent (
1246                       EVT_TIMER,
1247                       TPL_CALLBACK,
1248                       NULL,
1249                       NULL,
1250                       &HttpInstance->TimeoutEvent
1251                       );
1252       if (EFI_ERROR (Status)) {
1253         TlsCloseTxRxEvent (HttpInstance);
1254         return Status;
1255       }
1256     }
1257
1258     //
1259     // Start the timer, and wait Timeout seconds for connection.
1260     //
1261     Status = gBS->SetTimer (HttpInstance->TimeoutEvent, TimerRelative, HTTP_CONNECTION_TIMEOUT * TICKS_PER_SECOND);
1262     if (EFI_ERROR (Status)) {
1263       TlsCloseTxRxEvent (HttpInstance);
1264       return Status;
1265     }
1266
1267     Status = TlsConnectSession (HttpInstance, HttpInstance->TimeoutEvent);
1268
1269     gBS->SetTimer (HttpInstance->TimeoutEvent, TimerCancel, 0);
1270
1271     if (EFI_ERROR (Status)) {
1272       TlsCloseTxRxEvent (HttpInstance);
1273       return Status;
1274     }
1275   }
1276
1277   return Status;
1278 }
1279
1280 /**
1281   Check existing TCP connection, if in error state, recover TCP6 connection. Then,
1282   connect one TLS session if required.
1283
1284   @param[in]  HttpInstance       The HTTP instance private data.
1285
1286   @retval EFI_SUCCESS            The TCP connection is established.
1287   @retval EFI_NOT_READY          TCP6 protocol child is not created or configured.
1288   @retval Others                 Other error as indicated.
1289
1290 **/
1291 EFI_STATUS
1292 HttpConnectTcp6 (
1293   IN  HTTP_PROTOCOL        *HttpInstance
1294   )
1295 {
1296   EFI_STATUS                Status;
1297   EFI_TCP6_CONNECTION_STATE Tcp6State;
1298
1299   if (HttpInstance->State < HTTP_STATE_TCP_CONFIGED || HttpInstance->Tcp6 == NULL) {
1300     return EFI_NOT_READY;
1301   }
1302
1303   Status = HttpInstance->Tcp6->GetModeData (
1304                                  HttpInstance->Tcp6,
1305                                  &Tcp6State,
1306                                  NULL,
1307                                  NULL,
1308                                  NULL,
1309                                  NULL
1310                                  );
1311
1312   if (EFI_ERROR(Status)){
1313      DEBUG ((EFI_D_ERROR, "Tcp6 GetModeData fail - %x\n", Status));
1314      return Status;
1315   }
1316
1317   if (Tcp6State == Tcp6StateEstablished) {
1318     return EFI_SUCCESS;
1319   } else if (Tcp6State > Tcp6StateEstablished ) {
1320     HttpCloseConnection(HttpInstance);
1321   }
1322
1323   Status = HttpCreateConnection (HttpInstance);
1324   if (EFI_ERROR(Status)){
1325     DEBUG ((EFI_D_ERROR, "Tcp6 Connection fail - %x\n", Status));
1326     return Status;
1327   }
1328
1329   //
1330   // Tls session connection.
1331   //
1332   if (HttpInstance->UseHttps) {
1333     if (HttpInstance->TimeoutEvent == NULL) {
1334       //
1335       // Create TimeoutEvent for TLS connection.
1336       //
1337       Status = gBS->CreateEvent (
1338                       EVT_TIMER,
1339                       TPL_CALLBACK,
1340                       NULL,
1341                       NULL,
1342                       &HttpInstance->TimeoutEvent
1343                       );
1344       if (EFI_ERROR (Status)) {
1345         TlsCloseTxRxEvent (HttpInstance);
1346         return Status;
1347       }
1348     }
1349
1350     //
1351     // Start the timer, and wait Timeout seconds for connection.
1352     //
1353     Status = gBS->SetTimer (HttpInstance->TimeoutEvent, TimerRelative, HTTP_CONNECTION_TIMEOUT * TICKS_PER_SECOND);
1354     if (EFI_ERROR (Status)) {
1355       TlsCloseTxRxEvent (HttpInstance);
1356       return Status;
1357     }
1358
1359     Status = TlsConnectSession (HttpInstance, HttpInstance->TimeoutEvent);
1360
1361     gBS->SetTimer (HttpInstance->TimeoutEvent, TimerCancel, 0);
1362
1363     if (EFI_ERROR (Status)) {
1364       TlsCloseTxRxEvent (HttpInstance);
1365       return Status;
1366     }
1367   }
1368
1369   return Status;
1370 }
1371
1372 /**
1373   Initialize Http session.
1374
1375   @param[in]  HttpInstance       The HTTP instance private data.
1376   @param[in]  Wrap               The HTTP token's wrap data.
1377   @param[in]  Configure          The Flag indicates whether need to initialize session.
1378   @param[in]  TlsConfigure       The Flag indicates whether it's the new Tls session.
1379
1380   @retval EFI_SUCCESS            The initialization of session is done.
1381   @retval Others                 Other error as indicated.
1382
1383 **/
1384 EFI_STATUS
1385 HttpInitSession (
1386   IN  HTTP_PROTOCOL    *HttpInstance,
1387   IN  HTTP_TOKEN_WRAP  *Wrap,
1388   IN  BOOLEAN          Configure,
1389   IN  BOOLEAN          TlsConfigure
1390   )
1391 {
1392   EFI_STATUS           Status;
1393   ASSERT (HttpInstance != NULL);
1394
1395   //
1396   // Configure Tls session.
1397   //
1398   if (TlsConfigure) {
1399     Status = TlsConfigureSession (HttpInstance);
1400     if (EFI_ERROR (Status)) {
1401       return Status;
1402     }
1403   }
1404
1405   if (!HttpInstance->LocalAddressIsIPv6) {
1406     //
1407     // Configure TCP instance.
1408     //
1409     if (Configure) {
1410       Status = HttpConfigureTcp4 (HttpInstance, Wrap);
1411       if (EFI_ERROR (Status)) {
1412         return Status;
1413       }
1414     }
1415
1416     //
1417     // Connect TCP.
1418     //
1419     Status = HttpConnectTcp4 (HttpInstance);
1420     if (EFI_ERROR (Status)) {
1421       return Status;
1422     }
1423   } else {
1424     //
1425     // Configure TCP instance.
1426     //
1427     if (Configure) {
1428       Status = HttpConfigureTcp6 (HttpInstance, Wrap);
1429       if (EFI_ERROR (Status)) {
1430         return Status;
1431       }
1432     }
1433
1434     //
1435     // Connect TCP.
1436     //
1437     Status = HttpConnectTcp6 (HttpInstance);
1438     if (EFI_ERROR (Status)) {
1439       return Status;
1440     }
1441   }
1442
1443   return EFI_SUCCESS;
1444
1445 }
1446
1447 /**
1448   Send the HTTP or HTTPS message through TCP4 or TCP6.
1449
1450   @param[in]  HttpInstance       The HTTP instance private data.
1451   @param[in]  Wrap               The HTTP token's wrap data.
1452   @param[in]  TxString           Buffer containing the HTTP message string.
1453   @param[in]  TxStringLen        Length of the HTTP message string in bytes.
1454
1455   @retval EFI_SUCCESS            The HTTP message is queued into TCP transmit queue.
1456   @retval Others                 Other error as indicated.
1457
1458 **/
1459 EFI_STATUS
1460 HttpTransmitTcp (
1461   IN  HTTP_PROTOCOL    *HttpInstance,
1462   IN  HTTP_TOKEN_WRAP  *Wrap,
1463   IN  UINT8            *TxString,
1464   IN  UINTN            TxStringLen
1465   )
1466 {
1467   EFI_STATUS                    Status;
1468   EFI_TCP4_IO_TOKEN             *Tx4Token;
1469   EFI_TCP4_PROTOCOL             *Tcp4;
1470   EFI_TCP6_IO_TOKEN             *Tx6Token;
1471   EFI_TCP6_PROTOCOL             *Tcp6;
1472   UINT8                         *Buffer;
1473   UINTN                         BufferSize;
1474   NET_FRAGMENT                  TempFragment;
1475
1476   Status                = EFI_SUCCESS;
1477   Buffer                = NULL;
1478   TempFragment.Len      = 0;
1479   TempFragment.Bulk     = NULL;
1480
1481   //
1482   // Need to encrypt data.
1483   //
1484   if (HttpInstance->UseHttps) {
1485     //
1486     // Build BufferOut data
1487     //
1488     BufferSize = sizeof (TLS_RECORD_HEADER) + TxStringLen;
1489     Buffer     = AllocateZeroPool (BufferSize);
1490     if (Buffer == NULL) {
1491       Status = EFI_OUT_OF_RESOURCES;
1492       return Status;
1493     }
1494     ((TLS_RECORD_HEADER *) Buffer)->ContentType = TLS_CONTENT_TYPE_APPLICATION_DATA;
1495     ((TLS_RECORD_HEADER *) Buffer)->Version.Major = HttpInstance->TlsConfigData.Version.Major;
1496     ((TLS_RECORD_HEADER *) Buffer)->Version.Minor = HttpInstance->TlsConfigData.Version.Minor;
1497     ((TLS_RECORD_HEADER *) Buffer)->Length = (UINT16) (TxStringLen);
1498     CopyMem (Buffer + sizeof (TLS_RECORD_HEADER), TxString, TxStringLen);
1499
1500     //
1501     // Encrypt Packet.
1502     //
1503     Status = TlsProcessMessage (
1504                HttpInstance,
1505                Buffer,
1506                BufferSize,
1507                EfiTlsEncrypt,
1508                &TempFragment
1509                );
1510
1511     FreePool (Buffer);
1512
1513     if (EFI_ERROR (Status)) {
1514       return Status;
1515     }
1516   }
1517
1518   if (!HttpInstance->LocalAddressIsIPv6) {
1519     Tcp4 = HttpInstance->Tcp4;
1520     Tx4Token = &Wrap->TcpWrap.Tx4Token;
1521
1522     if (HttpInstance->UseHttps) {
1523       Tx4Token->Packet.TxData->DataLength = TempFragment.Len;
1524       Tx4Token->Packet.TxData->FragmentTable[0].FragmentLength = TempFragment.Len;
1525       Tx4Token->Packet.TxData->FragmentTable[0].FragmentBuffer = (VOID *) TempFragment.Bulk;
1526     } else {
1527       Tx4Token->Packet.TxData->DataLength = (UINT32) TxStringLen;
1528       Tx4Token->Packet.TxData->FragmentTable[0].FragmentLength = (UINT32) TxStringLen;
1529       Tx4Token->Packet.TxData->FragmentTable[0].FragmentBuffer = (VOID *) TxString;
1530     }
1531
1532     Tx4Token->CompletionToken.Status = EFI_NOT_READY;
1533
1534     Wrap->TcpWrap.IsTxDone = FALSE;
1535     Status  = Tcp4->Transmit (Tcp4, Tx4Token);
1536     if (EFI_ERROR (Status)) {
1537       DEBUG ((EFI_D_ERROR, "Transmit failed: %r\n", Status));
1538       return Status;
1539     }
1540
1541   } else {
1542     Tcp6 = HttpInstance->Tcp6;
1543     Tx6Token = &Wrap->TcpWrap.Tx6Token;
1544
1545     if (HttpInstance->UseHttps) {
1546       Tx6Token->Packet.TxData->DataLength = TempFragment.Len;
1547       Tx6Token->Packet.TxData->FragmentTable[0].FragmentLength = TempFragment.Len;
1548       Tx6Token->Packet.TxData->FragmentTable[0].FragmentBuffer = (VOID *) TempFragment.Bulk;
1549     } else {
1550       Tx6Token->Packet.TxData->DataLength = (UINT32) TxStringLen;
1551       Tx6Token->Packet.TxData->FragmentTable[0].FragmentLength = (UINT32) TxStringLen;
1552       Tx6Token->Packet.TxData->FragmentTable[0].FragmentBuffer = (VOID *) TxString;
1553     }
1554
1555     Tx6Token->CompletionToken.Status = EFI_NOT_READY;
1556
1557     Wrap->TcpWrap.IsTxDone = FALSE;
1558     Status = Tcp6->Transmit (Tcp6, Tx6Token);
1559     if (EFI_ERROR (Status)) {
1560       DEBUG ((EFI_D_ERROR, "Transmit failed: %r\n", Status));
1561       return Status;
1562     }
1563   }
1564
1565   return Status;
1566 }
1567
1568 /**
1569   Check whether the user's token or event has already
1570   been enqueue on HTTP Tx or Rx Token list.
1571
1572   @param[in]  Map                The container of either user's transmit or receive
1573                                  token.
1574   @param[in]  Item               Current item to check against.
1575   @param[in]  Context            The Token to check againist.
1576
1577   @retval EFI_ACCESS_DENIED      The token or event has already been enqueued in IP
1578   @retval EFI_SUCCESS            The current item isn't the same token/event as the
1579                                  context.
1580
1581 **/
1582 EFI_STATUS
1583 EFIAPI
1584 HttpTokenExist (
1585   IN NET_MAP                *Map,
1586   IN NET_MAP_ITEM           *Item,
1587   IN VOID                   *Context
1588   )
1589 {
1590   EFI_HTTP_TOKEN            *Token;
1591   EFI_HTTP_TOKEN            *TokenInItem;
1592
1593   Token       = (EFI_HTTP_TOKEN *) Context;
1594   TokenInItem = (EFI_HTTP_TOKEN *) Item->Key;
1595
1596   if (Token == TokenInItem || Token->Event == TokenInItem->Event) {
1597     return EFI_ACCESS_DENIED;
1598   }
1599
1600   return EFI_SUCCESS;
1601 }
1602
1603 /**
1604   Check whether the HTTP message associated with Tx4Token or Tx6Token is already sent out.
1605
1606   @param[in]  Map                The container of Tx4Token or Tx6Token.
1607   @param[in]  Item               Current item to check against.
1608   @param[in]  Context            The Token to check againist.
1609
1610   @retval EFI_NOT_READY          The HTTP message is still queued in the list.
1611   @retval EFI_SUCCESS            The HTTP message has been sent out.
1612
1613 **/
1614 EFI_STATUS
1615 EFIAPI
1616 HttpTcpNotReady (
1617   IN NET_MAP                *Map,
1618   IN NET_MAP_ITEM           *Item,
1619   IN VOID                   *Context
1620   )
1621 {
1622   HTTP_TOKEN_WRAP           *ValueInItem;
1623
1624   ValueInItem = (HTTP_TOKEN_WRAP *) Item->Value;
1625
1626   if (!ValueInItem->TcpWrap.IsTxDone) {
1627     return EFI_NOT_READY;
1628   }
1629
1630   return EFI_SUCCESS;
1631 }
1632
1633 /**
1634   Transmit the HTTP or HTTPS mssage by processing the associated HTTP token.
1635
1636   @param[in]  Map                The container of Tx4Token or Tx6Token.
1637   @param[in]  Item               Current item to check against.
1638   @param[in]  Context            The Token to check againist.
1639
1640   @retval EFI_OUT_OF_RESOURCES   Failed to allocate resources.
1641   @retval EFI_SUCCESS            The HTTP message is queued into TCP transmit
1642                                  queue.
1643
1644 **/
1645 EFI_STATUS
1646 EFIAPI
1647 HttpTcpTransmit (
1648   IN NET_MAP                *Map,
1649   IN NET_MAP_ITEM           *Item,
1650   IN VOID                   *Context
1651   )
1652 {
1653   HTTP_TOKEN_WRAP           *ValueInItem;
1654   EFI_STATUS                Status;
1655   CHAR8                     *RequestMsg;
1656   CHAR8                     *Url;
1657   UINTN                     UrlSize;
1658   UINTN                     RequestMsgSize;
1659
1660   RequestMsg = NULL;
1661
1662   ValueInItem = (HTTP_TOKEN_WRAP *) Item->Value;
1663   if (ValueInItem->TcpWrap.IsTxDone) {
1664     return EFI_SUCCESS;
1665   }
1666
1667   //
1668   // Parse the URI of the remote host.
1669   //
1670   UrlSize = StrLen (ValueInItem->HttpToken->Message->Data.Request->Url) + 1;
1671   Url = AllocatePool (UrlSize);
1672   if (Url == NULL) {
1673     return EFI_OUT_OF_RESOURCES;
1674   }
1675
1676   UnicodeStrToAsciiStrS (ValueInItem->HttpToken->Message->Data.Request->Url, Url, UrlSize);
1677
1678   //
1679   // Create request message.
1680   //
1681   Status = HttpGenRequestMessage (
1682                  ValueInItem->HttpToken->Message,
1683                  Url,
1684                  &RequestMsg,
1685                  &RequestMsgSize
1686                  );
1687   FreePool (Url);
1688
1689   if (EFI_ERROR (Status) || NULL == RequestMsg){
1690     return Status;
1691   }
1692
1693   ASSERT (RequestMsg != NULL);
1694
1695   //
1696   // Transmit the request message.
1697   //
1698   Status = HttpTransmitTcp (
1699              ValueInItem->HttpInstance,
1700              ValueInItem,
1701              (UINT8*) RequestMsg,
1702              RequestMsgSize
1703              );
1704   FreePool (RequestMsg);
1705   return Status;
1706 }
1707
1708 /**
1709   Receive the HTTP response by processing the associated HTTP token.
1710
1711   @param[in]  Map                The container of Rx4Token or Rx6Token.
1712   @param[in]  Item               Current item to check against.
1713   @param[in]  Context            The Token to check againist.
1714
1715   @retval EFI_SUCCESS            The HTTP response is queued into TCP receive
1716                                  queue.
1717   @retval Others                 Other error as indicated.
1718
1719 **/
1720 EFI_STATUS
1721 EFIAPI
1722 HttpTcpReceive (
1723   IN NET_MAP                *Map,
1724   IN NET_MAP_ITEM           *Item,
1725   IN VOID                   *Context
1726   )
1727 {
1728   //
1729   // Process the queued HTTP response.
1730   //
1731   return HttpResponseWorker ((HTTP_TOKEN_WRAP *) Item->Value);
1732 }
1733
1734 /**
1735   Receive the HTTP header by processing the associated HTTP token.
1736
1737   @param[in]       HttpInstance     The HTTP instance private data.
1738   @param[in, out]  SizeofHeaders    The HTTP header length.
1739   @param[in, out]  BufferSize       The size of buffer to cacahe the header message.
1740   @param[in]       Timeout          The time to wait for receiving the header packet.
1741
1742   @retval EFI_SUCCESS               The HTTP header is received.
1743   @retval Others                    Other errors as indicated.
1744
1745 **/
1746 EFI_STATUS
1747 HttpTcpReceiveHeader (
1748   IN  HTTP_PROTOCOL         *HttpInstance,
1749   IN  OUT UINTN             *SizeofHeaders,
1750   IN  OUT UINTN             *BufferSize,
1751   IN  EFI_EVENT             Timeout
1752   )
1753 {
1754   EFI_STATUS                    Status;
1755   EFI_TCP4_IO_TOKEN             *Rx4Token;
1756   EFI_TCP4_PROTOCOL             *Tcp4;
1757   EFI_TCP6_IO_TOKEN             *Rx6Token;
1758   EFI_TCP6_PROTOCOL             *Tcp6;
1759   CHAR8                         **EndofHeader;
1760   CHAR8                         **HttpHeaders;
1761   CHAR8                         *Buffer;
1762   NET_FRAGMENT                  Fragment;
1763
1764   ASSERT (HttpInstance != NULL);
1765
1766   EndofHeader = HttpInstance->EndofHeader;
1767   HttpHeaders = HttpInstance->HttpHeaders;
1768   Tcp4 = HttpInstance->Tcp4;
1769   Tcp6 = HttpInstance->Tcp6;
1770   Buffer      = NULL;
1771   Rx4Token    = NULL;
1772   Rx6Token    = NULL;
1773   Fragment.Len  = 0;
1774   Fragment.Bulk = NULL;
1775
1776   if (HttpInstance->LocalAddressIsIPv6) {
1777     ASSERT (Tcp6 != NULL);
1778   } else {
1779     ASSERT (Tcp4 != NULL);
1780   }
1781
1782   if (!HttpInstance->UseHttps) {
1783     Status = HttpCreateTcpRxEventForHeader (HttpInstance);
1784     if (EFI_ERROR (Status)) {
1785       return Status;
1786     }
1787   }
1788
1789   if (!HttpInstance->LocalAddressIsIPv6) {
1790     if (!HttpInstance->UseHttps) {
1791       Rx4Token = &HttpInstance->Rx4Token;
1792       Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer = AllocateZeroPool (DEF_BUF_LEN);
1793       if (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer == NULL) {
1794         Status = EFI_OUT_OF_RESOURCES;
1795         return Status;
1796       }
1797     }
1798
1799     //
1800     // Receive the HTTP headers only when EFI_HTTP_RESPONSE_DATA is not NULL.
1801     //
1802     while (*EndofHeader == NULL) {
1803       if (!HttpInstance->UseHttps) {
1804         HttpInstance->IsRxDone = FALSE;
1805         Rx4Token->Packet.RxData->DataLength = DEF_BUF_LEN;
1806         Rx4Token->Packet.RxData->FragmentTable[0].FragmentLength = DEF_BUF_LEN;
1807         Status = Tcp4->Receive (Tcp4, Rx4Token);
1808         if (EFI_ERROR (Status)) {
1809           DEBUG ((EFI_D_ERROR, "Tcp4 receive failed: %r\n", Status));
1810           return Status;
1811         }
1812
1813         while (!HttpInstance->IsRxDone && ((Timeout == NULL) || EFI_ERROR (gBS->CheckEvent (Timeout)))) {
1814           Tcp4->Poll (Tcp4);
1815         }
1816
1817         if (!HttpInstance->IsRxDone) {
1818           //
1819           // Cancle the Token before close its Event.
1820           //
1821           Tcp4->Cancel (HttpInstance->Tcp4, &Rx4Token->CompletionToken);
1822           gBS->CloseEvent (Rx4Token->CompletionToken.Event);
1823           Rx4Token->CompletionToken.Status = EFI_TIMEOUT;
1824         }
1825
1826         Status = Rx4Token->CompletionToken.Status;
1827         if (EFI_ERROR (Status)) {
1828           return Status;
1829         }
1830
1831         Fragment.Len  = Rx4Token->Packet.RxData->FragmentTable[0].FragmentLength;
1832         Fragment.Bulk = (UINT8 *) Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer;
1833       } else {
1834         if (Fragment.Bulk != NULL) {
1835           FreePool (Fragment.Bulk);
1836           Fragment.Bulk = NULL;
1837         }
1838
1839         Status = HttpsReceive (HttpInstance, &Fragment, Timeout);
1840         if (EFI_ERROR (Status)) {
1841           DEBUG ((EFI_D_ERROR, "Tcp4 receive failed: %r\n", Status));
1842           return Status;
1843         }
1844       }
1845
1846       //
1847       // Append the response string.
1848       //
1849       *BufferSize = *SizeofHeaders + Fragment.Len;
1850       Buffer      = AllocateZeroPool (*BufferSize);
1851       if (Buffer == NULL) {
1852         Status = EFI_OUT_OF_RESOURCES;
1853         return Status;
1854       }
1855
1856       if (*HttpHeaders != NULL) {
1857         CopyMem (Buffer, *HttpHeaders, *SizeofHeaders);
1858         FreePool (*HttpHeaders);
1859       }
1860
1861       CopyMem (
1862         Buffer + *SizeofHeaders,
1863         Fragment.Bulk,
1864         Fragment.Len
1865         );
1866       *HttpHeaders   = Buffer;
1867       *SizeofHeaders = *BufferSize;
1868
1869       //
1870       // Check whether we received end of HTTP headers.
1871       //
1872       *EndofHeader = AsciiStrStr (*HttpHeaders, HTTP_END_OF_HDR_STR);
1873     };
1874
1875     //
1876     // Free the buffer.
1877     //
1878     if (Rx4Token != NULL && Rx4Token->Packet.RxData != NULL && Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer != NULL) {
1879       FreePool (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer);
1880       Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;
1881       Fragment.Bulk = NULL;
1882     }
1883
1884     if (Fragment.Bulk != NULL) {
1885       FreePool (Fragment.Bulk);
1886       Fragment.Bulk = NULL;
1887     }
1888   } else {
1889     if (!HttpInstance->UseHttps) {
1890       Rx6Token = &HttpInstance->Rx6Token;
1891       Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer = AllocateZeroPool (DEF_BUF_LEN);
1892       if (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer == NULL) {
1893         Status = EFI_OUT_OF_RESOURCES;
1894         return Status;
1895       }
1896     }
1897
1898     //
1899     // Receive the HTTP headers only when EFI_HTTP_RESPONSE_DATA is not NULL.
1900     //
1901     while (*EndofHeader == NULL) {
1902       if (!HttpInstance->UseHttps) {
1903         HttpInstance->IsRxDone = FALSE;
1904         Rx6Token->Packet.RxData->DataLength = DEF_BUF_LEN;
1905         Rx6Token->Packet.RxData->FragmentTable[0].FragmentLength = DEF_BUF_LEN;
1906         Status = Tcp6->Receive (Tcp6, Rx6Token);
1907         if (EFI_ERROR (Status)) {
1908           DEBUG ((EFI_D_ERROR, "Tcp6 receive failed: %r\n", Status));
1909           return Status;
1910         }
1911
1912         while (!HttpInstance->IsRxDone && ((Timeout == NULL) || EFI_ERROR (gBS->CheckEvent (Timeout)))) {
1913           Tcp6->Poll (Tcp6);
1914         }
1915
1916         if (!HttpInstance->IsRxDone) {
1917           //
1918           // Cancle the Token before close its Event.
1919           //
1920           Tcp6->Cancel (HttpInstance->Tcp6, &Rx6Token->CompletionToken);
1921           gBS->CloseEvent (Rx6Token->CompletionToken.Event);
1922           Rx6Token->CompletionToken.Status = EFI_TIMEOUT;
1923         }
1924
1925         Status = Rx6Token->CompletionToken.Status;
1926         if (EFI_ERROR (Status)) {
1927           return Status;
1928         }
1929
1930         Fragment.Len  = Rx6Token->Packet.RxData->FragmentTable[0].FragmentLength;
1931         Fragment.Bulk = (UINT8 *) Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer;
1932       } else {
1933         if (Fragment.Bulk != NULL) {
1934           FreePool (Fragment.Bulk);
1935           Fragment.Bulk = NULL;
1936         }
1937
1938         Status = HttpsReceive (HttpInstance, &Fragment, Timeout);
1939         if (EFI_ERROR (Status)) {
1940           DEBUG ((EFI_D_ERROR, "Tcp6 receive failed: %r\n", Status));
1941           return Status;
1942         }
1943       }
1944
1945       //
1946       // Append the response string.
1947       //
1948       *BufferSize = *SizeofHeaders + Fragment.Len;
1949       Buffer      = AllocateZeroPool (*BufferSize);
1950       if (Buffer == NULL) {
1951         Status = EFI_OUT_OF_RESOURCES;
1952         return Status;
1953       }
1954
1955       if (*HttpHeaders != NULL) {
1956         CopyMem (Buffer, *HttpHeaders, *SizeofHeaders);
1957         FreePool (*HttpHeaders);
1958       }
1959
1960       CopyMem (
1961         Buffer + *SizeofHeaders,
1962         Fragment.Bulk,
1963         Fragment.Len
1964         );
1965       *HttpHeaders   = Buffer;
1966       *SizeofHeaders = *BufferSize;
1967
1968       //
1969       // Check whether we received end of HTTP headers.
1970       //
1971       *EndofHeader = AsciiStrStr (*HttpHeaders, HTTP_END_OF_HDR_STR);
1972     };
1973
1974     //
1975     // Free the buffer.
1976     //
1977     if (Rx6Token != NULL && Rx6Token->Packet.RxData != NULL && Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer != NULL) {
1978       FreePool (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer);
1979       Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;
1980       Fragment.Bulk = NULL;
1981     }
1982
1983     if (Fragment.Bulk != NULL) {
1984       FreePool (Fragment.Bulk);
1985       Fragment.Bulk = NULL;
1986     }
1987   }
1988
1989   //
1990   // Skip the CRLF after the HTTP headers.
1991   //
1992   *EndofHeader = *EndofHeader + AsciiStrLen (HTTP_END_OF_HDR_STR);
1993
1994   return EFI_SUCCESS;
1995 }
1996
1997 /**
1998   Receive the HTTP body by processing the associated HTTP token.
1999
2000   @param[in]  Wrap               The HTTP token's wrap data.
2001   @param[in]  HttpMsg            The HTTP message data.
2002
2003   @retval EFI_SUCCESS            The HTTP body is received.
2004   @retval Others                 Other error as indicated.
2005
2006 **/
2007 EFI_STATUS
2008 HttpTcpReceiveBody (
2009   IN  HTTP_TOKEN_WRAP       *Wrap,
2010   IN  EFI_HTTP_MESSAGE      *HttpMsg
2011   )
2012 {
2013   EFI_STATUS                Status;
2014   HTTP_PROTOCOL             *HttpInstance;
2015   EFI_TCP6_PROTOCOL         *Tcp6;
2016   EFI_TCP6_IO_TOKEN         *Rx6Token;
2017   EFI_TCP4_PROTOCOL         *Tcp4;
2018   EFI_TCP4_IO_TOKEN         *Rx4Token;
2019
2020   HttpInstance   = Wrap->HttpInstance;
2021   Tcp4 = HttpInstance->Tcp4;
2022   Tcp6 = HttpInstance->Tcp6;
2023   Rx4Token       = NULL;
2024   Rx6Token       = NULL;
2025
2026   if (HttpInstance->LocalAddressIsIPv6) {
2027     ASSERT (Tcp6 != NULL);
2028   } else {
2029     ASSERT (Tcp4 != NULL);
2030   }
2031
2032   if (HttpInstance->LocalAddressIsIPv6) {
2033     Rx6Token = &Wrap->TcpWrap.Rx6Token;
2034     Rx6Token ->Packet.RxData->DataLength = (UINT32) HttpMsg->BodyLength;
2035     Rx6Token ->Packet.RxData->FragmentTable[0].FragmentLength = (UINT32) HttpMsg->BodyLength;
2036     Rx6Token ->Packet.RxData->FragmentTable[0].FragmentBuffer = (VOID *) HttpMsg->Body;
2037     Rx6Token->CompletionToken.Status = EFI_NOT_READY;
2038
2039     Status = Tcp6->Receive (Tcp6, Rx6Token);
2040     if (EFI_ERROR (Status)) {
2041       DEBUG ((EFI_D_ERROR, "Tcp6 receive failed: %r\n", Status));
2042       return Status;
2043     }
2044   } else {
2045     Rx4Token = &Wrap->TcpWrap.Rx4Token;
2046     Rx4Token->Packet.RxData->DataLength = (UINT32) HttpMsg->BodyLength;
2047     Rx4Token->Packet.RxData->FragmentTable[0].FragmentLength = (UINT32) HttpMsg->BodyLength;
2048     Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer = (VOID *) HttpMsg->Body;
2049
2050     Rx4Token->CompletionToken.Status = EFI_NOT_READY;
2051     Status = Tcp4->Receive (Tcp4, Rx4Token);
2052     if (EFI_ERROR (Status)) {
2053       DEBUG ((EFI_D_ERROR, "Tcp4 receive failed: %r\n", Status));
2054       return Status;
2055     }
2056   }
2057
2058   return EFI_SUCCESS;
2059
2060 }
2061
2062 /**
2063   Clean up Tcp Tokens while the Tcp transmission error occurs.
2064
2065   @param[in]  Wrap               Pointer to HTTP token's wrap data.
2066
2067 **/
2068 VOID
2069 HttpTcpTokenCleanup (
2070   IN  HTTP_TOKEN_WRAP      *Wrap
2071   )
2072 {
2073   HTTP_PROTOCOL            *HttpInstance;
2074   EFI_TCP4_IO_TOKEN        *Rx4Token;
2075   EFI_TCP6_IO_TOKEN        *Rx6Token;
2076
2077   ASSERT (Wrap != NULL);
2078   HttpInstance   = Wrap->HttpInstance;
2079   Rx4Token       = NULL;
2080   Rx6Token       = NULL;
2081
2082   if (HttpInstance->LocalAddressIsIPv6) {
2083     Rx6Token = &Wrap->TcpWrap.Rx6Token;
2084
2085     if (Rx6Token->CompletionToken.Event != NULL) {
2086       gBS->CloseEvent (Rx6Token->CompletionToken.Event);
2087       Rx6Token->CompletionToken.Event = NULL;
2088     }
2089
2090     FreePool (Wrap);
2091
2092     Rx6Token = &HttpInstance->Rx6Token;
2093
2094     if (Rx6Token->CompletionToken.Event != NULL) {
2095       gBS->CloseEvent (Rx6Token->CompletionToken.Event);
2096       Rx6Token->CompletionToken.Event = NULL;
2097     }
2098
2099     if (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer != NULL) {
2100       FreePool (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer);
2101       Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;
2102     }
2103
2104   } else {
2105     Rx4Token = &Wrap->TcpWrap.Rx4Token;
2106
2107     if (Rx4Token->CompletionToken.Event != NULL) {
2108       gBS->CloseEvent (Rx4Token->CompletionToken.Event);
2109       Rx4Token->CompletionToken.Event = NULL;
2110     }
2111
2112     FreePool (Wrap);
2113
2114     Rx4Token = &HttpInstance->Rx4Token;
2115
2116     if (Rx4Token->CompletionToken.Event != NULL) {
2117       gBS->CloseEvent (Rx4Token->CompletionToken.Event);
2118       Rx4Token->CompletionToken.Event = NULL;
2119     }
2120
2121
2122     if (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer != NULL) {
2123       FreePool (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer);
2124       Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;
2125     }
2126   }
2127
2128 }