NetworkPkg/HttpDxe/HttpProto.c

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