NetworkPkg/HttpDxe/HttpProto.c

   1 /** @file
   2   Miscellaneous routines for HttpDxe driver.
   3
   4 Copyright (c) 2015, 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
 152     if (EFI_ERROR (Wrap->TcpWrap.Rx6Token.CompletionToken.Status)) {
 153       Wrap->HttpToken->Status = Wrap->TcpWrap.Rx6Token.CompletionToken.Status;
 154       gBS->SignalEvent (Wrap->HttpToken->Event);
 155       FreePool (Wrap);
 156       return ;
 157     }
 158
 159   } else {
 160     gBS->CloseEvent (Wrap->TcpWrap.Rx4Token.CompletionToken.Event);
 161
 162     if (EFI_ERROR (Wrap->TcpWrap.Rx4Token.CompletionToken.Status)) {
 163       Wrap->HttpToken->Status = Wrap->TcpWrap.Rx4Token.CompletionToken.Status;
 164       gBS->SignalEvent (Wrap->HttpToken->Event);
 165       FreePool (Wrap);
 166       return ;
 167     }
 168   }
 169
 170   //
 171   // Check whether we receive a complete HTTP message.
 172   //
 173   ASSERT (HttpInstance->MsgParser != NULL);
 174   if (UsingIpv6) {
 175     Length = (UINTN) Wrap->TcpWrap.Rx6Data.FragmentTable[0].FragmentLength;
 176   } else {
 177     Length = (UINTN) Wrap->TcpWrap.Rx4Data.FragmentTable[0].FragmentLength;
 178   }
 179
 180   Status = HttpParseMessageBody (
 181              HttpInstance->MsgParser,
 182              Length,
 183              Wrap->HttpToken->Message->Body
 184              );
 185   if (EFI_ERROR (Status)) {
 186     return ;
 187   }
 188
 189   if (HttpIsMessageComplete (HttpInstance->MsgParser)) {
 190     //
 191     // Free the MsgParse since we already have a full HTTP message.
 192     //
 193     HttpFreeMsgParser (HttpInstance->MsgParser);
 194     HttpInstance->MsgParser = NULL;
 195   }
 196
 197   Wrap->HttpToken->Message->BodyLength = Length;
 198   ASSERT (HttpInstance->CacheBody == NULL);
 199   //
 200   // We receive part of header of next HTTP msg.
 201   //
 202   if (HttpInstance->NextMsg != NULL) {
 203     Wrap->HttpToken->Message->BodyLength = HttpInstance->NextMsg -
 204                                            (CHAR8 *) Wrap->HttpToken->Message->Body;
 205     HttpInstance->CacheLen = Length - Wrap->HttpToken->Message->BodyLength;
 206     if (HttpInstance->CacheLen != 0) {
 207       HttpInstance->CacheBody = AllocateZeroPool (HttpInstance->CacheLen);
 208       if (HttpInstance->CacheBody == NULL) {
 209         return ;
 210       }
 211       CopyMem (HttpInstance->CacheBody, HttpInstance->NextMsg, HttpInstance->CacheLen);
 212       HttpInstance->NextMsg = HttpInstance->CacheBody;
 213       HttpInstance->CacheOffset = 0;
 214     }
 215   }
 216
 217   Item = NetMapFindKey (&Wrap->HttpInstance->RxTokens, Wrap->HttpToken);
 218   if (Item != NULL) {
 219     NetMapRemoveItem (&Wrap->HttpInstance->RxTokens, Item, NULL);
 220   }
 221
 222
 223   Wrap->TcpWrap.IsRxDone = TRUE;
 224   if (UsingIpv6) {
 225     Wrap->HttpToken->Status = Wrap->TcpWrap.Rx6Token.CompletionToken.Status;
 226   } else {
 227     Wrap->HttpToken->Status = Wrap->TcpWrap.Rx4Token.CompletionToken.Status;
 228   }
 229
 230
 231   gBS->SignalEvent (Wrap->HttpToken->Event);
 232
 233   //
 234   // Check pending RxTokens and receive the HTTP message.
 235   //
 236   NetMapIterate (&Wrap->HttpInstance->RxTokens, HttpTcpReceive, NULL);
 237
 238   FreePool (Wrap);
 239 }
 240
 241 /**
 242   Request HttpTcpReceiveNotifyDpc as a DPC at TPL_CALLBACK.
 243
 244   @param  Event                 The receive event delivered to TCP for receive.
 245   @param  Context               Context for the callback.
 246
 247 **/
 248 VOID
 249 EFIAPI
 250 HttpTcpReceiveNotify (
 251   IN EFI_EVENT                Event,
 252   IN VOID                     *Context
 253   )
 254 {
 255   //
 256   // Request HttpTcpTransmitNotifyDpc as a DPC at TPL_CALLBACK
 257   //
 258   QueueDpc (TPL_CALLBACK, HttpTcpReceiveNotifyDpc, Context);
 259 }
 260
 261 /**
 262   Create events for the TCP connection token and TCP close token.
 263
 264   @param[in]  HttpInstance       Pointer to HTTP_PROTOCOL structure.
 265
 266   @retval EFI_SUCCESS            The events are created successfully.
 267   @retval others                 Other error as indicated.
 268
 269 **/
 270 EFI_STATUS
 271 HttpCreateTcpConnCloseEvent (
 272   IN  HTTP_PROTOCOL        *HttpInstance
 273   )
 274 {
 275   EFI_STATUS               Status;
 276
 277   if (!HttpInstance->LocalAddressIsIPv6) {
 278     //
 279     // Create events for variuos asynchronous operations.
 280     //
 281     Status = gBS->CreateEvent (
 282                     EVT_NOTIFY_SIGNAL,
 283                     TPL_NOTIFY,
 284                     HttpCommonNotify,
 285                     &HttpInstance->IsTcp4ConnDone,
 286                     &HttpInstance->Tcp4ConnToken.CompletionToken.Event
 287                     );
 288     if (EFI_ERROR (Status)) {
 289       goto ERROR;
 290     }
 291
 292     //
 293     // Initialize Tcp4CloseToken
 294     //
 295     Status = gBS->CreateEvent (
 296                     EVT_NOTIFY_SIGNAL,
 297                     TPL_NOTIFY,
 298                     HttpCommonNotify,
 299                     &HttpInstance->IsTcp4CloseDone,
 300                     &HttpInstance->Tcp4CloseToken.CompletionToken.Event
 301                     );
 302     if (EFI_ERROR (Status)) {
 303       goto ERROR;
 304     }
 305
 306   } else {
 307     //
 308     // Create events for variuos asynchronous operations.
 309     //
 310     Status = gBS->CreateEvent (
 311                     EVT_NOTIFY_SIGNAL,
 312                     TPL_NOTIFY,
 313                     HttpCommonNotify,
 314                     &HttpInstance->IsTcp6ConnDone,
 315                     &HttpInstance->Tcp6ConnToken.CompletionToken.Event
 316                     );
 317     if (EFI_ERROR (Status)) {
 318       goto ERROR;
 319     }
 320
 321     //
 322     // Initialize Tcp6CloseToken
 323     //
 324     Status = gBS->CreateEvent (
 325                     EVT_NOTIFY_SIGNAL,
 326                     TPL_NOTIFY,
 327                     HttpCommonNotify,
 328                     &HttpInstance->IsTcp6CloseDone,
 329                     &HttpInstance->Tcp6CloseToken.CompletionToken.Event
 330                     );
 331     if (EFI_ERROR (Status)) {
 332       goto ERROR;
 333     }
 334   }
 335
 336   return EFI_SUCCESS;
 337
 338 ERROR:
 339   //
 340   // Error handling
 341   //
 342   HttpCloseTcpConnCloseEvent (HttpInstance);
 343
 344   return Status;
 345 }
 346
 347
 348 /**
 349   Close events in the TCP connection token and TCP close token.
 350
 351   @param[in]  HttpInstance   Pointer to HTTP_PROTOCOL structure.
 352
 353 **/
 354 VOID
 355 HttpCloseTcpConnCloseEvent (
 356   IN  HTTP_PROTOCOL        *HttpInstance
 357   )
 358 {
 359   ASSERT (HttpInstance != NULL);
 360
 361   if (HttpInstance->LocalAddressIsIPv6) {
 362     if (NULL != HttpInstance->Tcp6ConnToken.CompletionToken.Event) {
 363       gBS->CloseEvent (HttpInstance->Tcp6ConnToken.CompletionToken.Event);
 364       HttpInstance->Tcp6ConnToken.CompletionToken.Event = NULL;
 365     }
 366
 367     if (NULL != HttpInstance->Tcp6CloseToken.CompletionToken.Event) {
 368       gBS->CloseEvent(HttpInstance->Tcp6CloseToken.CompletionToken.Event);
 369       HttpInstance->Tcp6CloseToken.CompletionToken.Event = NULL;
 370     }
 371
 372   } else {
 373     if (NULL != HttpInstance->Tcp4ConnToken.CompletionToken.Event) {
 374       gBS->CloseEvent (HttpInstance->Tcp4ConnToken.CompletionToken.Event);
 375       HttpInstance->Tcp4ConnToken.CompletionToken.Event = NULL;
 376     }
 377
 378     if (NULL != HttpInstance->Tcp4CloseToken.CompletionToken.Event) {
 379       gBS->CloseEvent(HttpInstance->Tcp4CloseToken.CompletionToken.Event);
 380       HttpInstance->Tcp4CloseToken.CompletionToken.Event = NULL;
 381     }
 382   }
 383
 384 }
 385
 386 /**
 387   Create event for the TCP transmit token.
 388
 389   @param[in]  Wrap               Point to HTTP token's wrap data.
 390
 391   @retval EFI_SUCCESS            The events is created successfully.
 392   @retval others                 Other error as indicated.
 393
 394 **/
 395 EFI_STATUS
 396 HttpCreateTcpTxEvent (
 397   IN  HTTP_TOKEN_WRAP      *Wrap
 398   )
 399 {
 400   EFI_STATUS               Status;
 401   HTTP_PROTOCOL            *HttpInstance;
 402   HTTP_TCP_TOKEN_WRAP      *TcpWrap;
 403
 404   HttpInstance = Wrap->HttpInstance;
 405   TcpWrap      = &Wrap->TcpWrap;
 406
 407   if (!HttpInstance->LocalAddressIsIPv6) {
 408     Status = gBS->CreateEvent (
 409                     EVT_NOTIFY_SIGNAL,
 410                     TPL_NOTIFY,
 411                     HttpTcpTransmitNotify,
 412                     Wrap,
 413                     &TcpWrap->Tx4Token.CompletionToken.Event
 414                     );
 415       if (EFI_ERROR (Status)) {
 416         return Status;
 417       }
 418
 419       TcpWrap->Tx4Data.Push = TRUE;
 420       TcpWrap->Tx4Data.Urgent = FALSE;
 421       TcpWrap->Tx4Data.FragmentCount = 1;
 422       TcpWrap->Tx4Token.Packet.TxData = &Wrap->TcpWrap.Tx4Data;
 423       TcpWrap->Tx4Token.CompletionToken.Status = EFI_NOT_READY;
 424
 425   } else {
 426     Status = gBS->CreateEvent (
 427                     EVT_NOTIFY_SIGNAL,
 428                     TPL_NOTIFY,
 429                     HttpTcpTransmitNotify,
 430                     Wrap,
 431                     &TcpWrap->Tx6Token.CompletionToken.Event
 432                     );
 433     if (EFI_ERROR (Status)) {
 434       return Status;
 435     }
 436
 437     TcpWrap->Tx6Data.Push   = TRUE;
 438     TcpWrap->Tx6Data.Urgent = FALSE;
 439     TcpWrap->Tx6Data.FragmentCount  = 1;
 440     TcpWrap->Tx6Token.Packet.TxData = &Wrap->TcpWrap.Tx6Data;
 441     TcpWrap->Tx6Token.CompletionToken.Status =EFI_NOT_READY;
 442
 443
 444   }
 445
 446   return EFI_SUCCESS;
 447 }
 448
 449 /**
 450   Create event for the TCP receive token which is used to receive HTTP header.
 451
 452   @param[in]  HttpInstance       Pointer to HTTP_PROTOCOL structure.
 453
 454   @retval EFI_SUCCESS            The events is created successfully.
 455   @retval others                 Other error as indicated.
 456
 457 **/
 458 EFI_STATUS
 459 HttpCreateTcpRxEventForHeader (
 460   IN  HTTP_PROTOCOL        *HttpInstance
 461   )
 462 {
 463   EFI_STATUS               Status;
 464
 465   if (!HttpInstance->LocalAddressIsIPv6) {
 466     Status = gBS->CreateEvent (
 467                     EVT_NOTIFY_SIGNAL,
 468                     TPL_NOTIFY,
 469                     HttpCommonNotify,
 470                     &HttpInstance->IsRxDone,
 471                     &HttpInstance->Rx4Token.CompletionToken.Event
 472                     );
 473     if (EFI_ERROR (Status)) {
 474       return Status;
 475     }
 476
 477     HttpInstance->Rx4Data.FragmentCount = 1;
 478     HttpInstance->Rx4Token.Packet.RxData = &HttpInstance->Rx4Data;
 479     HttpInstance->Rx4Token.CompletionToken.Status = EFI_NOT_READY;
 480
 481   } else {
 482     Status = gBS->CreateEvent (
 483                     EVT_NOTIFY_SIGNAL,
 484                     TPL_NOTIFY,
 485                     HttpCommonNotify,
 486                     &HttpInstance->IsRxDone,
 487                     &HttpInstance->Rx6Token.CompletionToken.Event
 488                     );
 489     if (EFI_ERROR (Status)) {
 490       return Status;
 491     }
 492
 493     HttpInstance->Rx6Data.FragmentCount  =1;
 494     HttpInstance->Rx6Token.Packet.RxData = &HttpInstance->Rx6Data;
 495     HttpInstance->Rx6Token.CompletionToken.Status = EFI_NOT_READY;
 496
 497   }
 498
 499
 500   return EFI_SUCCESS;
 501 }
 502
 503 /**
 504   Create event for the TCP receive token which is used to receive HTTP body.
 505
 506   @param[in]  Wrap               Point to HTTP token's wrap data.
 507
 508   @retval EFI_SUCCESS            The events is created successfully.
 509   @retval others                 Other error as indicated.
 510
 511 **/
 512 EFI_STATUS
 513 HttpCreateTcpRxEvent (
 514   IN  HTTP_TOKEN_WRAP      *Wrap
 515   )
 516 {
 517   EFI_STATUS               Status;
 518   HTTP_PROTOCOL            *HttpInstance;
 519   HTTP_TCP_TOKEN_WRAP      *TcpWrap;
 520
 521   HttpInstance = Wrap->HttpInstance;
 522   TcpWrap      = &Wrap->TcpWrap;
 523   if (!HttpInstance->LocalAddressIsIPv6) {
 524     Status = gBS->CreateEvent (
 525                     EVT_NOTIFY_SIGNAL,
 526                     TPL_NOTIFY,
 527                     HttpTcpReceiveNotify,
 528                     Wrap,
 529                     &TcpWrap->Rx4Token.CompletionToken.Event
 530                     );
 531     if (EFI_ERROR (Status)) {
 532       return Status;
 533     }
 534
 535     TcpWrap->Rx4Data.FragmentCount = 1;
 536     TcpWrap->Rx4Token.Packet.RxData = &Wrap->TcpWrap.Rx4Data;
 537     TcpWrap->Rx4Token.CompletionToken.Status = EFI_NOT_READY;
 538
 539   } else {
 540     Status = gBS->CreateEvent (
 541                     EVT_NOTIFY_SIGNAL,
 542                     TPL_NOTIFY,
 543                     HttpTcpReceiveNotify,
 544                     Wrap,
 545                     &TcpWrap->Rx6Token.CompletionToken.Event
 546                     );
 547     if (EFI_ERROR (Status)) {
 548       return Status;
 549     }
 550
 551     TcpWrap->Rx6Data.FragmentCount = 1;
 552     TcpWrap->Rx6Token.Packet.RxData = &Wrap->TcpWrap.Rx6Data;
 553     TcpWrap->Rx6Token.CompletionToken.Status = EFI_NOT_READY;
 554   }
 555
 556   return EFI_SUCCESS;
 557 }
 558
 559 /**
 560   Close Events for Tcp Receive Tokens for HTTP body and HTTP header.
 561
 562   @param[in]  Wrap               Pointer to HTTP token's wrap data.
 563
 564 **/
 565 VOID
 566 HttpCloseTcpRxEvent (
 567   IN  HTTP_TOKEN_WRAP      *Wrap
 568   )
 569 {
 570   HTTP_PROTOCOL            *HttpInstance;
 571
 572   ASSERT (Wrap != NULL);
 573   HttpInstance   = Wrap->HttpInstance;
 574
 575   if (HttpInstance->LocalAddressIsIPv6) {
 576     if (Wrap->TcpWrap.Rx6Token.CompletionToken.Event != NULL) {
 577       gBS->CloseEvent (Wrap->TcpWrap.Rx6Token.CompletionToken.Event);
 578     }
 579
 580     if (HttpInstance->Rx6Token.CompletionToken.Event != NULL) {
 581       gBS->CloseEvent (HttpInstance->Rx6Token.CompletionToken.Event);
 582       HttpInstance->Rx6Token.CompletionToken.Event = NULL;
 583     }
 584   } else {
 585     if (Wrap->TcpWrap.Rx4Token.CompletionToken.Event != NULL) {
 586       gBS->CloseEvent (Wrap->TcpWrap.Rx4Token.CompletionToken.Event);
 587     }
 588
 589     if (HttpInstance->Rx4Token.CompletionToken.Event != NULL) {
 590       gBS->CloseEvent (HttpInstance->Rx4Token.CompletionToken.Event);
 591       HttpInstance->Rx4Token.CompletionToken.Event = NULL;
 592     }
 593   }
 594 }
 595
 596 /**
 597   Intiialize the HTTP_PROTOCOL structure to the unconfigured state.
 598
 599   @param[in, out]  HttpInstance         Pointer to HTTP_PROTOCOL structure.
 600   @param[in]       IpVersion            Indicate us TCP4 protocol or TCP6 protocol.
 601
 602   @retval EFI_SUCCESS       HTTP_PROTOCOL structure is initialized successfully.
 603   @retval Others            Other error as indicated.
 604
 605 **/
 606 EFI_STATUS
 607 HttpInitProtocol (
 608   IN OUT HTTP_PROTOCOL           *HttpInstance,
 609   IN     BOOLEAN                 IpVersion
 610   )
 611 {
 612   EFI_STATUS                     Status;
 613   VOID                           *Interface;
 614   BOOLEAN                        UsingIpv6;
 615
 616   ASSERT (HttpInstance != NULL);
 617   UsingIpv6 = IpVersion;
 618
 619   if (!UsingIpv6) {
 620     //
 621     // Create TCP4 child.
 622     //
 623     Status = NetLibCreateServiceChild (
 624                HttpInstance->Service->ControllerHandle,
 625                HttpInstance->Service->ImageHandle,
 626                &gEfiTcp4ServiceBindingProtocolGuid,
 627                &HttpInstance->Tcp4ChildHandle
 628                );
 629
 630     if (EFI_ERROR (Status)) {
 631       goto ON_ERROR;
 632     }
 633
 634     Status = gBS->OpenProtocol (
 635                     HttpInstance->Tcp4ChildHandle,
 636                     &gEfiTcp4ProtocolGuid,
 637                     (VOID **) &Interface,
 638                     HttpInstance->Service->ImageHandle,
 639                     HttpInstance->Service->ControllerHandle,
 640                     EFI_OPEN_PROTOCOL_BY_DRIVER
 641                     );
 642
 643     if (EFI_ERROR (Status)) {
 644       goto ON_ERROR;
 645     }
 646
 647     Status = gBS->OpenProtocol (
 648                     HttpInstance->Tcp4ChildHandle,
 649                     &gEfiTcp4ProtocolGuid,
 650                     (VOID **) &HttpInstance->Tcp4,
 651                     HttpInstance->Service->ImageHandle,
 652                     HttpInstance->Handle,
 653                     EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 654                     );
 655     if (EFI_ERROR(Status)) {
 656       goto ON_ERROR;
 657     }
 658
 659     Status = gBS->OpenProtocol (
 660                     HttpInstance->Service->Tcp4ChildHandle,
 661                     &gEfiTcp4ProtocolGuid,
 662                     (VOID **) &Interface,
 663                     HttpInstance->Service->ImageHandle,
 664                     HttpInstance->Handle,
 665                     EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 666                     );
 667     if (EFI_ERROR(Status)) {
 668       goto ON_ERROR;
 669     }
 670   } else {
 671     //
 672     // Create TCP6 Child.
 673     //
 674     Status = NetLibCreateServiceChild (
 675                HttpInstance->Service->ControllerHandle,
 676                HttpInstance->Service->ImageHandle,
 677                &gEfiTcp6ServiceBindingProtocolGuid,
 678                &HttpInstance->Tcp6ChildHandle
 679                );
 680
 681     if (EFI_ERROR (Status)) {
 682       goto ON_ERROR;
 683     }
 684
 685     Status = gBS->OpenProtocol (
 686                     HttpInstance->Tcp6ChildHandle,
 687                     &gEfiTcp6ProtocolGuid,
 688                     (VOID **) &Interface,
 689                     HttpInstance->Service->ImageHandle,
 690                     HttpInstance->Service->ControllerHandle,
 691                     EFI_OPEN_PROTOCOL_BY_DRIVER
 692                     );
 693
 694     if (EFI_ERROR (Status)) {
 695       goto ON_ERROR;
 696     }
 697
 698     Status = gBS->OpenProtocol (
 699                     HttpInstance->Tcp6ChildHandle,
 700                     &gEfiTcp6ProtocolGuid,
 701                     (VOID **) &HttpInstance->Tcp6,
 702                     HttpInstance->Service->ImageHandle,
 703                     HttpInstance->Handle,
 704                     EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 705                     );
 706
 707     if (EFI_ERROR(Status)) {
 708       goto ON_ERROR;
 709     }
 710
 711     Status = gBS->OpenProtocol (
 712                     HttpInstance->Service->Tcp6ChildHandle,
 713                     &gEfiTcp6ProtocolGuid,
 714                     (VOID **) &Interface,
 715                     HttpInstance->Service->ImageHandle,
 716                     HttpInstance->Handle,
 717                     EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 718                     );
 719
 720     if (EFI_ERROR(Status)) {
 721       goto ON_ERROR;
 722     }
 723   }
 724
 725   HttpInstance->Url = AllocateZeroPool (HTTP_URL_BUFFER_LEN);
 726   if (HttpInstance->Url == NULL) {
 727     Status = EFI_OUT_OF_RESOURCES;
 728     goto ON_ERROR;
 729   }
 730
 731   return EFI_SUCCESS;
 732
 733 ON_ERROR:
 734
 735   if (HttpInstance->Tcp4ChildHandle != NULL) {
 736     gBS->CloseProtocol (
 737            HttpInstance->Tcp4ChildHandle,
 738            &gEfiTcp4ProtocolGuid,
 739            HttpInstance->Service->ImageHandle,
 740            HttpInstance->Service->ControllerHandle
 741            );
 742
 743     gBS->CloseProtocol (
 744            HttpInstance->Tcp4ChildHandle,
 745            &gEfiTcp4ProtocolGuid,
 746            HttpInstance->Service->ImageHandle,
 747            HttpInstance->Handle
 748            );
 749
 750     NetLibDestroyServiceChild (
 751       HttpInstance->Service->ControllerHandle,
 752       HttpInstance->Service->ImageHandle,
 753       &gEfiTcp4ServiceBindingProtocolGuid,
 754       HttpInstance->Tcp4ChildHandle
 755       );
 756   }
 757
 758   if (HttpInstance->Service->Tcp4ChildHandle != NULL) {
 759     gBS->CloseProtocol (
 760            HttpInstance->Service->Tcp4ChildHandle,
 761            &gEfiTcp4ProtocolGuid,
 762            HttpInstance->Service->ImageHandle,
 763            HttpInstance->Handle
 764            );
 765   }
 766
 767   if (HttpInstance->Tcp6ChildHandle != NULL) {
 768     gBS->CloseProtocol (
 769            HttpInstance->Tcp6ChildHandle,
 770            &gEfiTcp6ProtocolGuid,
 771            HttpInstance->Service->ImageHandle,
 772            HttpInstance->Service->ControllerHandle
 773            );
 774
 775     gBS->CloseProtocol (
 776            HttpInstance->Tcp6ChildHandle,
 777            &gEfiTcp6ProtocolGuid,
 778            HttpInstance->Service->ImageHandle,
 779            HttpInstance->Handle
 780            );
 781
 782     NetLibDestroyServiceChild (
 783       HttpInstance->Service->ControllerHandle,
 784       HttpInstance->Service->ImageHandle,
 785       &gEfiTcp6ServiceBindingProtocolGuid,
 786       HttpInstance->Tcp6ChildHandle
 787       );
 788   }
 789
 790   if (HttpInstance->Service->Tcp6ChildHandle != NULL) {
 791     gBS->CloseProtocol (
 792            HttpInstance->Service->Tcp6ChildHandle,
 793            &gEfiTcp6ProtocolGuid,
 794            HttpInstance->Service->ImageHandle,
 795            HttpInstance->Handle
 796            );
 797   }
 798
 799   return EFI_UNSUPPORTED;
 800
 801 }
 802
 803 /**
 804   Clean up the HTTP child, release all the resources used by it.
 805
 806   @param[in]  HttpInstance       The HTTP child to clean up.
 807
 808 **/
 809 VOID
 810 HttpCleanProtocol (
 811   IN  HTTP_PROTOCOL          *HttpInstance
 812   )
 813 {
 814   HttpCloseConnection (HttpInstance);
 815
 816   HttpCloseTcpConnCloseEvent (HttpInstance);
 817
 818   if (HttpInstance->CacheBody != NULL) {
 819     FreePool (HttpInstance->CacheBody);
 820     HttpInstance->CacheBody = NULL;
 821     HttpInstance->NextMsg   = NULL;
 822   }
 823
 824   if (HttpInstance->RemoteHost != NULL) {
 825     FreePool (HttpInstance->RemoteHost);
 826     HttpInstance->RemoteHost = NULL;
 827   }
 828
 829   if (HttpInstance->MsgParser != NULL) {
 830     HttpFreeMsgParser (HttpInstance->MsgParser);
 831     HttpInstance->MsgParser = NULL;
 832   }
 833
 834   if (HttpInstance->Url != NULL) {
 835     FreePool (HttpInstance->Url);
 836     HttpInstance->Url = NULL;
 837   }
 838
 839   NetMapClean (&HttpInstance->TxTokens);
 840   NetMapClean (&HttpInstance->RxTokens);
 841
 842   if (HttpInstance->Tcp4ChildHandle != NULL) {
 843     gBS->CloseProtocol (
 844            HttpInstance->Tcp4ChildHandle,
 845            &gEfiTcp4ProtocolGuid,
 846            HttpInstance->Service->ImageHandle,
 847            HttpInstance->Service->ControllerHandle
 848            );
 849
 850     gBS->CloseProtocol (
 851            HttpInstance->Tcp4ChildHandle,
 852            &gEfiTcp4ProtocolGuid,
 853            HttpInstance->Service->ImageHandle,
 854            HttpInstance->Handle
 855            );
 856
 857     NetLibDestroyServiceChild (
 858       HttpInstance->Service->ControllerHandle,
 859       HttpInstance->Service->ImageHandle,
 860       &gEfiTcp4ServiceBindingProtocolGuid,
 861       HttpInstance->Tcp4ChildHandle
 862       );
 863   }
 864
 865   if (HttpInstance->Service->Tcp4ChildHandle != NULL) {
 866     gBS->CloseProtocol (
 867            HttpInstance->Service->Tcp4ChildHandle,
 868            &gEfiTcp4ProtocolGuid,
 869            HttpInstance->Service->ImageHandle,
 870            HttpInstance->Handle
 871            );
 872   }
 873
 874   if (HttpInstance->Tcp6ChildHandle != NULL) {
 875     gBS->CloseProtocol (
 876            HttpInstance->Tcp6ChildHandle,
 877            &gEfiTcp6ProtocolGuid,
 878            HttpInstance->Service->ImageHandle,
 879            HttpInstance->Service->ControllerHandle
 880            );
 881
 882     gBS->CloseProtocol (
 883            HttpInstance->Tcp6ChildHandle,
 884            &gEfiTcp6ProtocolGuid,
 885            HttpInstance->Service->ImageHandle,
 886            HttpInstance->Handle
 887            );
 888
 889     NetLibDestroyServiceChild (
 890       HttpInstance->Service->ControllerHandle,
 891       HttpInstance->Service->ImageHandle,
 892       &gEfiTcp6ServiceBindingProtocolGuid,
 893       HttpInstance->Tcp6ChildHandle
 894       );
 895   }
 896
 897   if (HttpInstance->Service->Tcp6ChildHandle != NULL) {
 898     gBS->CloseProtocol (
 899            HttpInstance->Service->Tcp6ChildHandle,
 900            &gEfiTcp6ProtocolGuid,
 901            HttpInstance->Service->ImageHandle,
 902            HttpInstance->Handle
 903            );
 904   }
 905
 906 }
 907
 908 /**
 909   Establish TCP connection with HTTP server.
 910
 911   @param[in]  HttpInstance       The HTTP instance private data.
 912
 913   @retval EFI_SUCCESS            The TCP connection is established.
 914   @retval Others                 Other error as indicated.
 915
 916 **/
 917 EFI_STATUS
 918 HttpCreateConnection (
 919   IN  HTTP_PROTOCOL        *HttpInstance
 920   )
 921 {
 922   EFI_STATUS                    Status;
 923
 924   //
 925   // Connect to Http server
 926   //
 927   if (!HttpInstance->LocalAddressIsIPv6) {
 928     HttpInstance->IsTcp4ConnDone = FALSE;
 929     HttpInstance->Tcp4ConnToken.CompletionToken.Status = EFI_NOT_READY;
 930     Status = HttpInstance->Tcp4->Connect (HttpInstance->Tcp4, &HttpInstance->Tcp4ConnToken);
 931     if (EFI_ERROR (Status)) {
 932       DEBUG ((EFI_D_ERROR, "HttpCreateConnection: Tcp4->Connect() = %r\n", Status));
 933       return Status;
 934     }
 935
 936     while (!HttpInstance->IsTcp4ConnDone) {
 937       HttpInstance->Tcp4->Poll (HttpInstance->Tcp4);
 938     }
 939
 940     Status = HttpInstance->Tcp4ConnToken.CompletionToken.Status;
 941
 942   } else {
 943     HttpInstance->IsTcp6ConnDone = FALSE;
 944     HttpInstance->Tcp6ConnToken.CompletionToken.Status = EFI_NOT_READY;
 945     Status = HttpInstance->Tcp6->Connect (HttpInstance->Tcp6, &HttpInstance->Tcp6ConnToken);
 946     if (EFI_ERROR (Status)) {
 947       DEBUG ((EFI_D_ERROR, "HttpCreateConnection: Tcp6->Connect() = %r\n", Status));
 948       return Status;
 949     }
 950
 951     while(!HttpInstance->IsTcp6ConnDone) {
 952       HttpInstance->Tcp6->Poll (HttpInstance->Tcp6);
 953     }
 954
 955     Status = HttpInstance->Tcp6ConnToken.CompletionToken.Status;
 956   }
 957
 958   if (!EFI_ERROR (Status)) {
 959     HttpInstance->State = HTTP_STATE_TCP_CONNECTED;
 960   }
 961
 962   return Status;
 963 }
 964
 965 /**
 966   Close existing TCP connection.
 967
 968   @param[in]  HttpInstance       The HTTP instance private data.
 969
 970   @retval EFI_SUCCESS            The TCP connection is closed.
 971   @retval Others                 Other error as indicated.
 972
 973 **/
 974 EFI_STATUS
 975 HttpCloseConnection (
 976   IN  HTTP_PROTOCOL        *HttpInstance
 977   )
 978 {
 979   EFI_STATUS                Status;
 980
 981   if (HttpInstance->State == HTTP_STATE_TCP_CONNECTED) {
 982
 983     if (HttpInstance->LocalAddressIsIPv6) {
 984       HttpInstance->Tcp6CloseToken.AbortOnClose = TRUE;
 985       HttpInstance->IsTcp6CloseDone             = FALSE;
 986       Status = HttpInstance->Tcp6->Close (HttpInstance->Tcp6, &HttpInstance->Tcp6CloseToken);
 987       if (EFI_ERROR (Status)) {
 988         return Status;
 989       }
 990
 991       while (!HttpInstance->IsTcp6CloseDone) {
 992         HttpInstance->Tcp6->Poll (HttpInstance->Tcp6);
 993       }
 994
 995     } else {
 996       HttpInstance->Tcp4CloseToken.AbortOnClose = TRUE;
 997       HttpInstance->IsTcp4CloseDone             = FALSE;
 998       Status = HttpInstance->Tcp4->Close (HttpInstance->Tcp4, &HttpInstance->Tcp4CloseToken);
 999       if (EFI_ERROR (Status)) {
1000         return Status;
1001       }
1002
1003       while (!HttpInstance->IsTcp4CloseDone) {
1004         HttpInstance->Tcp4->Poll (HttpInstance->Tcp4);
1005       }
1006     }
1007
1008   }
1009
1010   HttpInstance->State = HTTP_STATE_TCP_CLOSED;
1011   return EFI_SUCCESS;
1012 }
1013
1014 /**
1015   Configure TCP4 protocol child.
1016
1017   @param[in]  HttpInstance       The HTTP instance private data.
1018   @param[in]  Wrap               The HTTP token's wrap data.
1019
1020   @retval EFI_SUCCESS            The TCP4 protocol child is configured.
1021   @retval Others                 Other error as indicated.
1022
1023 **/
1024 EFI_STATUS
1025 HttpConfigureTcp4 (
1026   IN  HTTP_PROTOCOL        *HttpInstance,
1027   IN  HTTP_TOKEN_WRAP      *Wrap
1028   )
1029 {
1030   EFI_STATUS                 Status;
1031   EFI_TCP4_CONFIG_DATA       *Tcp4CfgData;
1032   EFI_TCP4_ACCESS_POINT      *Tcp4AP;
1033   EFI_TCP4_OPTION            *Tcp4Option;
1034
1035   ASSERT (HttpInstance != NULL);
1036
1037
1038   Tcp4CfgData = &HttpInstance->Tcp4CfgData;
1039   ZeroMem (Tcp4CfgData, sizeof (EFI_TCP4_CONFIG_DATA));
1040
1041   Tcp4CfgData->TypeOfService = HTTP_TOS_DEAULT;
1042   Tcp4CfgData->TimeToLive    = HTTP_TTL_DEAULT;
1043   Tcp4CfgData->ControlOption = &HttpInstance->Tcp4Option;
1044
1045   Tcp4AP = &Tcp4CfgData->AccessPoint;
1046   Tcp4AP->UseDefaultAddress = HttpInstance->IPv4Node.UseDefaultAddress;
1047   if (!Tcp4AP->UseDefaultAddress) {
1048     IP4_COPY_ADDRESS (&Tcp4AP->StationAddress, &HttpInstance->IPv4Node.LocalAddress);
1049     IP4_COPY_ADDRESS (&Tcp4AP->SubnetMask, &HttpInstance->IPv4Node.LocalSubnet);
1050   }
1051
1052   Tcp4AP->StationPort = HttpInstance->IPv4Node.LocalPort;
1053   Tcp4AP->RemotePort  = HttpInstance->RemotePort;
1054   Tcp4AP->ActiveFlag  = TRUE;
1055   IP4_COPY_ADDRESS (&Tcp4AP->RemoteAddress, &HttpInstance->RemoteAddr);
1056
1057   Tcp4Option = Tcp4CfgData->ControlOption;
1058   Tcp4Option->ReceiveBufferSize      = HTTP_BUFFER_SIZE_DEAULT;
1059   Tcp4Option->SendBufferSize         = HTTP_BUFFER_SIZE_DEAULT;
1060   Tcp4Option->MaxSynBackLog          = HTTP_MAX_SYN_BACK_LOG;
1061   Tcp4Option->ConnectionTimeout      = HTTP_CONNECTION_TIMEOUT;
1062   Tcp4Option->DataRetries            = HTTP_DATA_RETRIES;
1063   Tcp4Option->FinTimeout             = HTTP_FIN_TIMEOUT;
1064   Tcp4Option->KeepAliveProbes        = HTTP_KEEP_ALIVE_PROBES;
1065   Tcp4Option->KeepAliveTime          = HTTP_KEEP_ALIVE_TIME;
1066   Tcp4Option->KeepAliveInterval      = HTTP_KEEP_ALIVE_INTERVAL;
1067   Tcp4Option->EnableNagle            = TRUE;
1068   Tcp4CfgData->ControlOption         = Tcp4Option;
1069
1070   Status = HttpInstance->Tcp4->Configure (HttpInstance->Tcp4, Tcp4CfgData);
1071   if (EFI_ERROR (Status)) {
1072     DEBUG ((EFI_D_ERROR, "HttpConfigureTcp4 - %r\n", Status));
1073     return Status;
1074   }
1075
1076   Status = HttpCreateTcpConnCloseEvent (HttpInstance);
1077   if (EFI_ERROR (Status)) {
1078     return Status;
1079   }
1080
1081   Status = HttpCreateTcpTxEvent (Wrap);
1082   if (EFI_ERROR (Status)) {
1083     return Status;
1084   }
1085
1086   HttpInstance->State = HTTP_STATE_TCP_CONFIGED;
1087
1088   return EFI_SUCCESS;
1089 }
1090
1091 /**
1092   Configure TCP6 protocol child.
1093
1094   @param[in]  HttpInstance       The HTTP instance private data.
1095   @param[in]  Wrap               The HTTP token's wrap data.
1096
1097   @retval EFI_SUCCESS            The TCP6 protocol child is configured.
1098   @retval Others                 Other error as indicated.
1099
1100 **/
1101 EFI_STATUS
1102 HttpConfigureTcp6 (
1103   IN  HTTP_PROTOCOL        *HttpInstance,
1104   IN  HTTP_TOKEN_WRAP      *Wrap
1105   )
1106 {
1107   EFI_STATUS               Status;
1108   EFI_TCP6_CONFIG_DATA     *Tcp6CfgData;
1109   EFI_TCP6_ACCESS_POINT    *Tcp6Ap;
1110   EFI_TCP6_OPTION          *Tcp6Option;
1111
1112   ASSERT (HttpInstance != NULL);
1113
1114   Tcp6CfgData = &HttpInstance->Tcp6CfgData;
1115   ZeroMem (Tcp6CfgData, sizeof (EFI_TCP6_CONFIG_DATA));
1116
1117   Tcp6CfgData->TrafficClass  = 0;
1118   Tcp6CfgData->HopLimit      = 255;
1119   Tcp6CfgData->ControlOption = &HttpInstance->Tcp6Option;
1120
1121   Tcp6Ap  = &Tcp6CfgData->AccessPoint;
1122   Tcp6Ap->ActiveFlag  = TRUE;
1123   Tcp6Ap->StationPort = HttpInstance->Ipv6Node.LocalPort;
1124   Tcp6Ap->RemotePort  = HttpInstance->RemotePort;
1125   IP6_COPY_ADDRESS (&Tcp6Ap->StationAddress, &HttpInstance->Ipv6Node.LocalAddress);
1126   IP6_COPY_ADDRESS (&Tcp6Ap->RemoteAddress , &HttpInstance->RemoteIpv6Addr);
1127
1128   Tcp6Option = Tcp6CfgData->ControlOption;
1129   Tcp6Option->ReceiveBufferSize  = HTTP_BUFFER_SIZE_DEAULT;
1130   Tcp6Option->SendBufferSize     = HTTP_BUFFER_SIZE_DEAULT;
1131   Tcp6Option->MaxSynBackLog      = HTTP_MAX_SYN_BACK_LOG;
1132   Tcp6Option->ConnectionTimeout  = HTTP_CONNECTION_TIMEOUT;
1133   Tcp6Option->DataRetries        = HTTP_DATA_RETRIES;
1134   Tcp6Option->FinTimeout         = HTTP_FIN_TIMEOUT;
1135   Tcp6Option->KeepAliveProbes    = HTTP_KEEP_ALIVE_PROBES;
1136   Tcp6Option->KeepAliveTime      = HTTP_KEEP_ALIVE_TIME;
1137   Tcp6Option->KeepAliveInterval  = HTTP_KEEP_ALIVE_INTERVAL;
1138   Tcp6Option->EnableNagle        = TRUE;
1139
1140   Status = HttpInstance->Tcp6->Configure (HttpInstance->Tcp6, Tcp6CfgData);
1141   if (EFI_ERROR (Status)) {
1142     DEBUG ((EFI_D_ERROR, "HttpConfigureTcp6 - %r\n", Status));
1143     return Status;
1144   }
1145
1146   Status = HttpCreateTcpConnCloseEvent (HttpInstance);
1147   if (EFI_ERROR (Status)) {
1148     return Status;
1149   }
1150
1151   Status = HttpCreateTcpTxEvent (Wrap);
1152   if (EFI_ERROR (Status)) {
1153     return Status;
1154   }
1155
1156   HttpInstance->State = HTTP_STATE_TCP_CONFIGED;
1157
1158   return EFI_SUCCESS;
1159
1160 }
1161
1162 /**
1163   Check existing TCP connection, if in error state, recover TCP4 connection.
1164
1165   @param[in]  HttpInstance       The HTTP instance private data.
1166
1167   @retval EFI_SUCCESS            The TCP connection is established.
1168   @retval EFI_NOT_READY          TCP4 protocol child is not created or configured.
1169   @retval Others                 Other error as indicated.
1170
1171 **/
1172 EFI_STATUS
1173 HttpConnectTcp4 (
1174   IN  HTTP_PROTOCOL        *HttpInstance
1175   )
1176 {
1177   EFI_STATUS                Status;
1178   EFI_TCP4_CONNECTION_STATE Tcp4State;
1179
1180
1181   if (HttpInstance->State < HTTP_STATE_TCP_CONFIGED || HttpInstance->Tcp4 == NULL) {
1182     return EFI_NOT_READY;
1183   }
1184
1185   Status = HttpInstance->Tcp4->GetModeData(
1186                                  HttpInstance->Tcp4,
1187                                  &Tcp4State,
1188                                  NULL,
1189                                  NULL,
1190                                  NULL,
1191                                  NULL
1192                                  );
1193   if (EFI_ERROR(Status)){
1194     DEBUG ((EFI_D_ERROR, "Tcp4 GetModeData fail - %x\n", Status));
1195     return Status;
1196   }
1197
1198   if (Tcp4State == Tcp4StateEstablished) {
1199     return EFI_SUCCESS;
1200   } else if (Tcp4State > Tcp4StateEstablished ) {
1201     HttpCloseConnection(HttpInstance);
1202   }
1203
1204   return HttpCreateConnection (HttpInstance);
1205 }
1206
1207 /**
1208   Check existing TCP connection, if in error state, recover TCP6 connection.
1209
1210   @param[in]  HttpInstance       The HTTP instance private data.
1211
1212   @retval EFI_SUCCESS            The TCP connection is established.
1213   @retval EFI_NOT_READY          TCP6 protocol child is not created or configured.
1214   @retval Others                 Other error as indicated.
1215
1216 **/
1217 EFI_STATUS
1218 HttpConnectTcp6 (
1219   IN  HTTP_PROTOCOL        *HttpInstance
1220   )
1221 {
1222   EFI_STATUS                Status;
1223   EFI_TCP6_CONNECTION_STATE Tcp6State;
1224
1225   if (HttpInstance->State < HTTP_STATE_TCP_CONFIGED || HttpInstance->Tcp6 == NULL) {
1226     return EFI_NOT_READY;
1227   }
1228
1229   Status = HttpInstance->Tcp6->GetModeData (
1230                                  HttpInstance->Tcp6,
1231                                  &Tcp6State,
1232                                  NULL,
1233                                  NULL,
1234                                  NULL,
1235                                  NULL
1236                                  );
1237
1238   if (EFI_ERROR(Status)){
1239      DEBUG ((EFI_D_ERROR, "Tcp6 GetModeData fail - %x\n", Status));
1240      return Status;
1241   }
1242
1243   if (Tcp6State == Tcp6StateEstablished) {
1244     return EFI_SUCCESS;
1245   } else if (Tcp6State > Tcp6StateEstablished ) {
1246     HttpCloseConnection(HttpInstance);
1247   }
1248
1249   return HttpCreateConnection (HttpInstance);
1250 }
1251
1252 /**
1253   Initialize TCP related data.
1254
1255   @param[in]  HttpInstance       The HTTP instance private data.
1256   @param[in]  Wrap               The HTTP token's wrap data.
1257   @param[in]  Configure          The Flag indicates whether the first time to initialize Tcp.
1258
1259   @retval EFI_SUCCESS            The initialization of TCP instance is done.
1260   @retval Others                 Other error as indicated.
1261
1262 **/
1263 EFI_STATUS
1264 HttpInitTcp (
1265   IN  HTTP_PROTOCOL    *HttpInstance,
1266   IN  HTTP_TOKEN_WRAP  *Wrap,
1267   IN  BOOLEAN          Configure
1268   )
1269 {
1270   EFI_STATUS           Status;
1271   ASSERT (HttpInstance != NULL);
1272
1273   if (!HttpInstance->LocalAddressIsIPv6) {
1274     //
1275     // Configure TCP instance.
1276     //
1277     if (Configure) {
1278       Status = HttpConfigureTcp4 (HttpInstance, Wrap);
1279       if (EFI_ERROR (Status)) {
1280         return Status;
1281       }
1282     }
1283
1284     //
1285     // Connect TCP.
1286     //
1287     Status = HttpConnectTcp4 (HttpInstance);
1288     if (EFI_ERROR (Status)) {
1289       return Status;
1290     }
1291   } else {
1292     //
1293     // Configure TCP instance.
1294     //
1295     if (Configure) {
1296       Status = HttpConfigureTcp6 (HttpInstance, Wrap);
1297       if (EFI_ERROR (Status)) {
1298         return Status;
1299       }
1300     }
1301
1302     //
1303     // Connect TCP.
1304     //
1305     Status = HttpConnectTcp6 (HttpInstance);
1306     if (EFI_ERROR (Status)) {
1307       return Status;
1308     }
1309   }
1310
1311   return EFI_SUCCESS;
1312
1313 }
1314
1315 /**
1316   Send the HTTP message through TCP4 or TCP6.
1317
1318   @param[in]  HttpInstance       The HTTP instance private data.
1319   @param[in]  Wrap               The HTTP token's wrap data.
1320   @param[in]  TxString           Buffer containing the HTTP message string.
1321   @param[in]  TxStringLen        Length of the HTTP message string in bytes.
1322
1323   @retval EFI_SUCCESS            The HTTP message is queued into TCP transmit queue.
1324   @retval Others                 Other error as indicated.
1325
1326 **/
1327 EFI_STATUS
1328 HttpTransmitTcp (
1329   IN  HTTP_PROTOCOL    *HttpInstance,
1330   IN  HTTP_TOKEN_WRAP  *Wrap,
1331   IN  UINT8            *TxString,
1332   IN  UINTN            TxStringLen
1333   )
1334 {
1335   EFI_STATUS                    Status;
1336   EFI_TCP4_IO_TOKEN             *Tx4Token;
1337   EFI_TCP4_PROTOCOL             *Tcp4;
1338   EFI_TCP6_IO_TOKEN             *Tx6Token;
1339   EFI_TCP6_PROTOCOL             *Tcp6;
1340
1341   if (!HttpInstance->LocalAddressIsIPv6) {
1342     Tcp4 = HttpInstance->Tcp4;
1343     Tx4Token = &Wrap->TcpWrap.Tx4Token;
1344
1345     Tx4Token->Packet.TxData->DataLength = (UINT32) TxStringLen;
1346     Tx4Token->Packet.TxData->FragmentTable[0].FragmentLength = (UINT32) TxStringLen;
1347     Tx4Token->Packet.TxData->FragmentTable[0].FragmentBuffer = (VOID *) TxString;
1348     Tx4Token->CompletionToken.Status = EFI_NOT_READY;
1349
1350     Wrap->TcpWrap.IsTxDone = FALSE;
1351     Status  = Tcp4->Transmit (Tcp4, Tx4Token);
1352     if (EFI_ERROR (Status)) {
1353       DEBUG ((EFI_D_ERROR, "Transmit failed: %r\n", Status));
1354       return Status;
1355     }
1356
1357   } else {
1358     Tcp6 = HttpInstance->Tcp6;
1359     Tx6Token = &Wrap->TcpWrap.Tx6Token;
1360
1361     Tx6Token->Packet.TxData->DataLength = (UINT32) TxStringLen;
1362     Tx6Token->Packet.TxData->FragmentTable[0].FragmentLength = (UINT32) TxStringLen;
1363     Tx6Token->Packet.TxData->FragmentTable[0].FragmentBuffer = (VOID *) TxString;
1364     Tx6Token->CompletionToken.Status = EFI_NOT_READY;
1365
1366     Wrap->TcpWrap.IsTxDone = FALSE;
1367     Status = Tcp6->Transmit (Tcp6, Tx6Token);
1368     if (EFI_ERROR (Status)) {
1369       DEBUG ((EFI_D_ERROR, "Transmit failed: %r\n", Status));
1370       return Status;
1371     }
1372   }
1373
1374
1375   return Status;
1376 }
1377
1378 /**
1379   Check whether the user's token or event has already
1380   been enqueue on HTTP Tx or Rx Token list.
1381
1382   @param[in]  Map                The container of either user's transmit or receive
1383                                  token.
1384   @param[in]  Item               Current item to check against.
1385   @param[in]  Context            The Token to check againist.
1386
1387   @retval EFI_ACCESS_DENIED      The token or event has already been enqueued in IP
1388   @retval EFI_SUCCESS            The current item isn't the same token/event as the
1389                                  context.
1390
1391 **/
1392 EFI_STATUS
1393 EFIAPI
1394 HttpTokenExist (
1395   IN NET_MAP                *Map,
1396   IN NET_MAP_ITEM           *Item,
1397   IN VOID                   *Context
1398   )
1399 {
1400   EFI_HTTP_TOKEN            *Token;
1401   EFI_HTTP_TOKEN            *TokenInItem;
1402
1403   Token       = (EFI_HTTP_TOKEN *) Context;
1404   TokenInItem = (EFI_HTTP_TOKEN *) Item->Key;
1405
1406   if (Token == TokenInItem || Token->Event == TokenInItem->Event) {
1407     return EFI_ACCESS_DENIED;
1408   }
1409
1410   return EFI_SUCCESS;
1411 }
1412
1413 /**
1414   Check whether the HTTP message associated with Tx4Token or Tx6Token is already sent out.
1415
1416   @param[in]  Map                The container of Tx4Token or Tx6Token.
1417   @param[in]  Item               Current item to check against.
1418   @param[in]  Context            The Token to check againist.
1419
1420   @retval EFI_NOT_READY          The HTTP message is still queued in the list.
1421   @retval EFI_SUCCESS            The HTTP message has been sent out.
1422
1423 **/
1424 EFI_STATUS
1425 EFIAPI
1426 HttpTcpNotReady (
1427   IN NET_MAP                *Map,
1428   IN NET_MAP_ITEM           *Item,
1429   IN VOID                   *Context
1430   )
1431 {
1432   HTTP_TOKEN_WRAP           *ValueInItem;
1433
1434   ValueInItem = (HTTP_TOKEN_WRAP *) Item->Value;
1435
1436   if (!ValueInItem->TcpWrap.IsTxDone) {
1437     return EFI_NOT_READY;
1438   }
1439
1440   return EFI_SUCCESS;
1441 }
1442
1443 /**
1444   Transmit the HTTP mssage by processing the associated HTTP token.
1445
1446   @param[in]  Map                The container of Tx4Token or Tx6Token.
1447   @param[in]  Item               Current item to check against.
1448   @param[in]  Context            The Token to check againist.
1449
1450   @retval EFI_OUT_OF_RESOURCES   Failed to allocate resources.
1451   @retval EFI_SUCCESS            The HTTP message is queued into TCP transmit
1452                                  queue.
1453
1454 **/
1455 EFI_STATUS
1456 EFIAPI
1457 HttpTcpTransmit (
1458   IN NET_MAP                *Map,
1459   IN NET_MAP_ITEM           *Item,
1460   IN VOID                   *Context
1461   )
1462 {
1463   HTTP_TOKEN_WRAP           *ValueInItem;
1464   EFI_STATUS                Status;
1465   CHAR8                     *RequestMsg;
1466   CHAR8                     *Url;
1467   UINTN                     RequestMsgSize;
1468
1469   ValueInItem = (HTTP_TOKEN_WRAP *) Item->Value;
1470   if (ValueInItem->TcpWrap.IsTxDone) {
1471     return EFI_SUCCESS;
1472   }
1473
1474   //
1475   // Parse the URI of the remote host.
1476   //
1477   Url = AllocatePool (StrLen (ValueInItem->HttpToken->Message->Data.Request->Url) + 1);
1478   if (Url == NULL) {
1479     return EFI_OUT_OF_RESOURCES;
1480   }
1481
1482   UnicodeStrToAsciiStr (ValueInItem->HttpToken->Message->Data.Request->Url, Url);
1483
1484   //
1485   // Create request message.
1486   //
1487   Status = HttpGenRequestMessage (
1488                  ValueInItem->HttpToken->Message,
1489                  Url,
1490                  &RequestMsg,
1491                  &RequestMsgSize
1492                  );
1493   FreePool (Url);
1494
1495   if (EFI_ERROR (Status)){
1496     return Status;
1497   }
1498
1499   //
1500   // Transmit the request message.
1501   //
1502   Status = HttpTransmitTcp (
1503              ValueInItem->HttpInstance,
1504              ValueInItem,
1505              (UINT8*) RequestMsg,
1506              RequestMsgSize
1507              );
1508   FreePool (RequestMsg);
1509   return Status;
1510 }
1511
1512 /**
1513   Receive the HTTP response by processing the associated HTTP token.
1514
1515   @param[in]  Map                The container of Rx4Token or Rx6Token.
1516   @param[in]  Item               Current item to check against.
1517   @param[in]  Context            The Token to check againist.
1518
1519   @retval EFI_SUCCESS            The HTTP response is queued into TCP receive
1520                                  queue.
1521   @retval Others                 Other error as indicated.
1522
1523 **/
1524 EFI_STATUS
1525 EFIAPI
1526 HttpTcpReceive (
1527   IN NET_MAP                *Map,
1528   IN NET_MAP_ITEM           *Item,
1529   IN VOID                   *Context
1530   )
1531 {
1532   //
1533   // Process the queued HTTP response.
1534   //
1535   return HttpResponseWorker ((HTTP_TOKEN_WRAP *) Item->Value);
1536 }
1537
1538 /**
1539   Receive the HTTP header by processing the associated HTTP token.
1540
1541   @param[in]       HttpInstance     The HTTP instance private data.
1542   @param[in, out]  SizeofHeaders    The HTTP header length.
1543   @param[in, out]  BufferSize       The size of buffer to cacahe the header message.
1544
1545   @retval EFI_SUCCESS               The HTTP header is received.
1546   @retval Others                    Other errors as indicated.
1547
1548 **/
1549 EFI_STATUS
1550 HttpTcpReceiveHeader (
1551   IN  HTTP_PROTOCOL         *HttpInstance,
1552   IN  OUT UINTN             *SizeofHeaders,
1553   IN  OUT UINTN             *BufferSize
1554   )
1555 {
1556   EFI_STATUS                    Status;
1557   EFI_TCP4_IO_TOKEN             *Rx4Token;
1558   EFI_TCP4_PROTOCOL             *Tcp4;
1559   EFI_TCP6_IO_TOKEN             *Rx6Token;
1560   EFI_TCP6_PROTOCOL             *Tcp6;
1561   CHAR8                         **EndofHeader;
1562   CHAR8                         **HttpHeaders;
1563   CHAR8                         *Buffer;
1564
1565   ASSERT (HttpInstance != NULL);
1566
1567   EndofHeader = HttpInstance->EndofHeader;
1568   HttpHeaders = HttpInstance->HttpHeaders;
1569   Tcp4 = HttpInstance->Tcp4;
1570   Tcp6 = HttpInstance->Tcp6;
1571   Buffer      = NULL;
1572   Rx4Token    = NULL;
1573   Rx6Token    = NULL;
1574
1575   if (HttpInstance->LocalAddressIsIPv6) {
1576     ASSERT (Tcp6 != NULL);
1577   } else {
1578     ASSERT (Tcp4 != NULL);
1579   }
1580
1581   if (!HttpInstance->LocalAddressIsIPv6) {
1582     Rx4Token = &HttpInstance->Rx4Token;
1583     Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer = AllocateZeroPool (DEF_BUF_LEN);
1584     if (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer == NULL) {
1585       Status = EFI_OUT_OF_RESOURCES;
1586       return Status;
1587     }
1588
1589     //
1590     // Receive the HTTP headers only when EFI_HTTP_RESPONSE_DATA is not NULL.
1591     //
1592     while (*EndofHeader == NULL) {
1593       HttpInstance->IsRxDone = FALSE;
1594       Rx4Token->Packet.RxData->DataLength = DEF_BUF_LEN;
1595       Rx4Token->Packet.RxData->FragmentTable[0].FragmentLength = DEF_BUF_LEN;
1596       Status = Tcp4->Receive (Tcp4, Rx4Token);
1597       if (EFI_ERROR (Status)) {
1598         DEBUG ((EFI_D_ERROR, "Tcp4 receive failed: %r\n", Status));
1599         return Status;
1600       }
1601
1602       while (!HttpInstance->IsRxDone) {
1603        Tcp4->Poll (Tcp4);
1604       }
1605
1606       Status = Rx4Token->CompletionToken.Status;
1607       if (EFI_ERROR (Status)) {
1608         return Status;
1609       }
1610
1611       //
1612       // Append the response string.
1613       //
1614       *BufferSize = (*SizeofHeaders) + Rx4Token->Packet.RxData->FragmentTable[0].FragmentLength;
1615       Buffer      = AllocateZeroPool (*BufferSize);
1616       if (Buffer == NULL) {
1617         Status = EFI_OUT_OF_RESOURCES;
1618         return Status;
1619       }
1620
1621       if (*HttpHeaders != NULL) {
1622         CopyMem (Buffer, *HttpHeaders, (*SizeofHeaders));
1623         FreePool (*HttpHeaders);
1624       }
1625
1626       CopyMem (
1627         Buffer + (*SizeofHeaders),
1628         Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer,
1629         Rx4Token->Packet.RxData->FragmentTable[0].FragmentLength
1630         );
1631       *HttpHeaders    = Buffer;
1632       *SizeofHeaders  = *BufferSize;
1633
1634       //
1635       // Check whether we received end of HTTP headers.
1636       //
1637       *EndofHeader = AsciiStrStr (*HttpHeaders, HTTP_END_OF_HDR_STR);
1638     }
1639     FreePool (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer);
1640     Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;
1641
1642   } else {
1643     Rx6Token = &HttpInstance->Rx6Token;
1644     Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer = AllocateZeroPool (DEF_BUF_LEN);
1645     if (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer == NULL) {
1646       Status = EFI_OUT_OF_RESOURCES;
1647       return Status;
1648     }
1649
1650     //
1651     // Receive the HTTP headers only when EFI_HTTP_RESPONSE_DATA is not NULL.
1652     //
1653     while (*EndofHeader == NULL) {
1654       HttpInstance->IsRxDone = FALSE;
1655       Rx6Token->Packet.RxData->DataLength = DEF_BUF_LEN;
1656       Rx6Token->Packet.RxData->FragmentTable[0].FragmentLength = DEF_BUF_LEN;
1657       Status = Tcp6->Receive (Tcp6, Rx6Token);
1658       if (EFI_ERROR (Status)) {
1659         DEBUG ((EFI_D_ERROR, "Tcp6 receive failed: %r\n", Status));
1660         return Status;
1661       }
1662
1663       while (!HttpInstance->IsRxDone) {
1664        Tcp6->Poll (Tcp6);
1665       }
1666
1667       Status = Rx6Token->CompletionToken.Status;
1668       if (EFI_ERROR (Status)) {
1669         return Status;
1670       }
1671
1672       //
1673       // Append the response string.
1674       //
1675       *BufferSize = (*SizeofHeaders) + Rx6Token->Packet.RxData->FragmentTable[0].FragmentLength;
1676       Buffer      = AllocateZeroPool (*BufferSize);
1677       if (Buffer == NULL) {
1678         Status = EFI_OUT_OF_RESOURCES;
1679         return Status;
1680       }
1681
1682       if (*HttpHeaders != NULL) {
1683         CopyMem (Buffer, *HttpHeaders, (*SizeofHeaders));
1684         FreePool (*HttpHeaders);
1685       }
1686
1687       CopyMem (
1688         Buffer + (*SizeofHeaders),
1689         Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer,
1690         Rx6Token->Packet.RxData->FragmentTable[0].FragmentLength
1691         );
1692       *HttpHeaders     = Buffer;
1693       *SizeofHeaders  = *BufferSize;
1694
1695       //
1696       // Check whether we received end of HTTP headers.
1697       //
1698       *EndofHeader = AsciiStrStr (*HttpHeaders, HTTP_END_OF_HDR_STR);
1699
1700     }
1701     FreePool (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer);
1702     Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;
1703   }
1704
1705   //
1706   // Skip the CRLF after the HTTP headers.
1707   //
1708   *EndofHeader = *EndofHeader + AsciiStrLen (HTTP_END_OF_HDR_STR);
1709
1710   return EFI_SUCCESS;
1711 }
1712
1713 /**
1714   Receive the HTTP body by processing the associated HTTP token.
1715
1716   @param[in]  Wrap               The HTTP token's wrap data.
1717   @param[in]  HttpMsg            The HTTP message data.
1718
1719   @retval EFI_SUCCESS            The HTTP body is received.
1720   @retval Others                 Other error as indicated.
1721
1722 **/
1723 EFI_STATUS
1724 HttpTcpReceiveBody (
1725   IN  HTTP_TOKEN_WRAP       *Wrap,
1726   IN  EFI_HTTP_MESSAGE      *HttpMsg
1727   )
1728 {
1729   EFI_STATUS                Status;
1730   HTTP_PROTOCOL             *HttpInstance;
1731   EFI_TCP6_PROTOCOL         *Tcp6;
1732   EFI_TCP6_IO_TOKEN         *Rx6Token;
1733   EFI_TCP4_PROTOCOL         *Tcp4;
1734   EFI_TCP4_IO_TOKEN         *Rx4Token;
1735
1736   HttpInstance   = Wrap->HttpInstance;
1737   Tcp4 = HttpInstance->Tcp4;
1738   Tcp6 = HttpInstance->Tcp6;
1739   Rx4Token       = NULL;
1740   Rx6Token       = NULL;
1741
1742
1743   if (HttpInstance->LocalAddressIsIPv6) {
1744     ASSERT (Tcp6 != NULL);
1745   } else {
1746     ASSERT (Tcp4 != NULL);
1747   }
1748
1749   if (HttpInstance->LocalAddressIsIPv6) {
1750     Rx6Token = &Wrap->TcpWrap.Rx6Token;
1751     Rx6Token ->Packet.RxData->DataLength = (UINT32) HttpMsg->BodyLength;
1752     Rx6Token ->Packet.RxData->FragmentTable[0].FragmentLength = (UINT32) HttpMsg->BodyLength;
1753     Rx6Token ->Packet.RxData->FragmentTable[0].FragmentBuffer = (VOID *) HttpMsg->Body;
1754     Rx6Token->CompletionToken.Status = EFI_NOT_READY;
1755
1756     Status = Tcp6->Receive (Tcp6, Rx6Token);
1757     if (EFI_ERROR (Status)) {
1758       DEBUG ((EFI_D_ERROR, "Tcp6 receive failed: %r\n", Status));
1759       return Status;
1760     }
1761
1762   } else {
1763     Rx4Token = &Wrap->TcpWrap.Rx4Token;
1764     Rx4Token->Packet.RxData->DataLength = (UINT32) HttpMsg->BodyLength;
1765     Rx4Token->Packet.RxData->FragmentTable[0].FragmentLength = (UINT32) HttpMsg->BodyLength;
1766     Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer = (VOID *) HttpMsg->Body;
1767
1768     Rx4Token->CompletionToken.Status = EFI_NOT_READY;
1769     Status = Tcp4->Receive (Tcp4, Rx4Token);
1770     if (EFI_ERROR (Status)) {
1771       DEBUG ((EFI_D_ERROR, "Tcp4 receive failed: %r\n", Status));
1772       return Status;
1773     }
1774   }
1775
1776   return EFI_SUCCESS;
1777
1778 }
1779
1780 /**
1781   Clean up Tcp Tokens while the Tcp transmission error occurs.
1782
1783   @param[in]  Wrap               Pointer to HTTP token's wrap data.
1784
1785 **/
1786 VOID
1787 HttpTcpTokenCleanup (
1788   IN  HTTP_TOKEN_WRAP      *Wrap
1789   )
1790 {
1791   HTTP_PROTOCOL            *HttpInstance;
1792   EFI_TCP4_IO_TOKEN        *Rx4Token;
1793   EFI_TCP6_IO_TOKEN        *Rx6Token;
1794
1795   ASSERT (Wrap != NULL);
1796   HttpInstance   = Wrap->HttpInstance;
1797   Rx4Token       = NULL;
1798   Rx6Token       = NULL;
1799
1800   if (HttpInstance->LocalAddressIsIPv6) {
1801     if (Wrap->TcpWrap.Rx6Token.CompletionToken.Event != NULL) {
1802       gBS->CloseEvent (Wrap->TcpWrap.Rx6Token.CompletionToken.Event);
1803     }
1804
1805     Rx6Token = &Wrap->TcpWrap.Rx6Token;
1806     if (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer != NULL) {
1807       FreePool (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer);
1808       Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;
1809     }
1810     FreePool (Wrap);
1811
1812     if (HttpInstance->Rx6Token.CompletionToken.Event != NULL) {
1813       gBS->CloseEvent (HttpInstance->Rx6Token.CompletionToken.Event);
1814       HttpInstance->Rx6Token.CompletionToken.Event = NULL;
1815     }
1816
1817     Rx6Token = &HttpInstance->Rx6Token;
1818     if (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer != NULL) {
1819       FreePool (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer);
1820       Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;
1821     }
1822
1823   } else {
1824     if (Wrap->TcpWrap.Rx4Token.CompletionToken.Event != NULL) {
1825       gBS->CloseEvent (Wrap->TcpWrap.Rx4Token.CompletionToken.Event);
1826     }
1827     Rx4Token = &Wrap->TcpWrap.Rx4Token;
1828     if (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer != NULL) {
1829       FreePool (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer);
1830       Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;
1831     }
1832     FreePool (Wrap);
1833
1834     if (HttpInstance->Rx4Token.CompletionToken.Event != NULL) {
1835       gBS->CloseEvent (HttpInstance->Rx4Token.CompletionToken.Event);
1836       HttpInstance->Rx4Token.CompletionToken.Event = NULL;
1837     }
1838
1839     Rx4Token = &HttpInstance->Rx4Token;
1840     if (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer != NULL) {
1841       FreePool (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer);
1842       Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;
1843     }
1844   }
1845
1846 }