NetworkPkg/HttpDxe/HttpProto.c

   1 /** @file
   2   Miscellaneous routines for HttpDxe driver.
   3
   4 Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "HttpDriver.h"
  16
  17 /**
  18   The common notify function used in HTTP driver.
  19
  20   @param[in]  Event   The event signaled.
  21   @param[in]  Context The context.
  22
  23 **/
  24 VOID
  25 EFIAPI
  26 HttpCommonNotify (
  27   IN EFI_EVENT  Event,
  28   IN VOID       *Context
  29   )
  30 {
  31   if ((Event == NULL) || (Context == NULL)) {
  32     return ;
  33   }
  34
  35   *((BOOLEAN *) Context) = TRUE;
  36 }
  37
  38 /**
  39   The notify function associated with TxToken for Tcp4->Transmit().
  40
  41   @param[in]  Event   The event signaled.
  42   @param[in]  Context The context.
  43
  44 **/
  45 VOID
  46 EFIAPI
  47 HttpTcpTransmitNotify (
  48   IN EFI_EVENT  Event,
  49   IN VOID       *Context
  50   )
  51 {
  52   HTTP_TOKEN_WRAP          *Wrap;
  53
  54   if ((Event == NULL) || (Context == NULL)) {
  55     return ;
  56   }
  57
  58   Wrap = (HTTP_TOKEN_WRAP *) Context;
  59   Wrap->HttpToken->Status = Wrap->TcpWrap.TxToken.CompletionToken.Status;
  60   gBS->SignalEvent (Wrap->HttpToken->Event);
  61
  62   //
  63   // Free resources.
  64   //
  65   if (Wrap->TcpWrap.TxToken.Packet.TxData->FragmentTable[0].FragmentBuffer != NULL) {
  66     FreePool (Wrap->TcpWrap.TxToken.Packet.TxData->FragmentTable[0].FragmentBuffer);
  67   }
  68
  69   if (Wrap->TcpWrap.TxToken.CompletionToken.Event != NULL) {
  70     gBS->CloseEvent (Wrap->TcpWrap.TxToken.CompletionToken.Event);
  71   }
  72
  73   Wrap->TcpWrap.IsTxDone = TRUE;
  74
  75   //
  76   // Check pending TxTokens and sent out.
  77   //
  78   NetMapIterate (&Wrap->HttpInstance->TxTokens, HttpTcpTransmit, NULL);
  79
  80 }
  81
  82 /**
  83   The notify function associated with RxToken for Tcp4->Receive ().
  84
  85   @param[in]  Event   The event signaled.
  86   @param[in]  Context The context.
  87
  88 **/
  89 VOID
  90 EFIAPI
  91 HttpTcpReceiveNotify (
  92   IN EFI_EVENT  Event,
  93   IN VOID       *Context
  94   )
  95 {
  96   HTTP_TOKEN_WRAP          *Wrap;
  97   NET_MAP_ITEM             *Item;
  98   UINTN                    Length;
  99   EFI_STATUS               Status;
 100   HTTP_PROTOCOL            *HttpInstance;
 101
 102   if ((Event == NULL) || (Context == NULL)) {
 103     return ;
 104   }
 105
 106   Wrap = (HTTP_TOKEN_WRAP *) Context;
 107   if (EFI_ERROR (Wrap->TcpWrap.RxToken.CompletionToken.Status)) {
 108     return ;
 109   }
 110
 111   HttpInstance = Wrap->HttpInstance;
 112
 113   //
 114   // Check whether we receive a complete HTTP message.
 115   //
 116   ASSERT (HttpInstance->MsgParser != NULL);
 117
 118   Length = (UINTN) Wrap->TcpWrap.RxData.FragmentTable[0].FragmentLength;
 119   Status = HttpParseMessageBody (
 120              HttpInstance->MsgParser,
 121              Length,
 122              Wrap->HttpToken->Message->Body
 123              );
 124   if (EFI_ERROR (Status)) {
 125     return ;
 126   }
 127
 128   if (HttpIsMessageComplete (HttpInstance->MsgParser)) {
 129     //
 130     // Free the MsgParse since we already have a full HTTP message.
 131     //
 132     HttpFreeMsgParser (HttpInstance->MsgParser);
 133     HttpInstance->MsgParser = NULL;
 134   }
 135
 136   Wrap->HttpToken->Message->BodyLength = Length;
 137   ASSERT (HttpInstance->CacheBody == NULL);
 138   //
 139   // We receive part of header of next HTTP msg.
 140   //
 141   if (HttpInstance->NextMsg != NULL) {
 142     Wrap->HttpToken->Message->BodyLength = HttpInstance->NextMsg -
 143                                            (CHAR8 *) Wrap->HttpToken->Message->Body;
 144     HttpInstance->CacheLen = Length - Wrap->HttpToken->Message->BodyLength;
 145     if (HttpInstance->CacheLen != 0) {
 146       HttpInstance->CacheBody = AllocateZeroPool (HttpInstance->CacheLen);
 147       if (HttpInstance->CacheBody == NULL) {
 148         return ;
 149       }
 150       CopyMem (HttpInstance->CacheBody, HttpInstance->NextMsg, HttpInstance->CacheLen);
 151       HttpInstance->NextMsg = HttpInstance->CacheBody;
 152       HttpInstance->CacheOffset = 0;
 153     }
 154   }
 155
 156   Item = NetMapFindKey (&Wrap->HttpInstance->RxTokens, Wrap->HttpToken);
 157   if (Item != NULL) {
 158     NetMapRemoveItem (&Wrap->HttpInstance->RxTokens, Item, NULL);
 159   }
 160
 161
 162   Wrap->TcpWrap.IsRxDone = TRUE;
 163   Wrap->HttpToken->Status = Wrap->TcpWrap.RxToken.CompletionToken.Status;
 164
 165   gBS->SignalEvent (Wrap->HttpToken->Event);
 166
 167   //
 168   // Check pending RxTokens and receive the HTTP message.
 169   //
 170   NetMapIterate (&Wrap->HttpInstance->RxTokens, HttpTcpReceive, NULL);
 171
 172   FreePool (Wrap);
 173 }
 174
 175 /**
 176   Create events for the TCP4 connection token and TCP4 close token.
 177
 178   @param[in]  HttpInstance       Pointer to HTTP_PROTOCOL structure.
 179
 180   @retval EFI_SUCCESS            The events are created successfully.
 181   @retval others                 Other error as indicated.
 182
 183 **/
 184 EFI_STATUS
 185 HttpCreateTcp4ConnCloseEvent (
 186   IN  HTTP_PROTOCOL        *HttpInstance
 187   )
 188 {
 189   EFI_STATUS               Status;
 190     //
 191     // Create events for variuos asynchronous operations.
 192     //
 193     Status = gBS->CreateEvent (
 194                     EVT_NOTIFY_SIGNAL,
 195                     TPL_NOTIFY,
 196                     HttpCommonNotify,
 197                     &HttpInstance->IsConnDone,
 198                     &HttpInstance->ConnToken.CompletionToken.Event
 199                     );
 200     if (EFI_ERROR (Status)) {
 201       goto ERROR;
 202     }
 203
 204     //
 205     // Initialize CloseToken
 206     //
 207     Status = gBS->CreateEvent (
 208                     EVT_NOTIFY_SIGNAL,
 209                     TPL_NOTIFY,
 210                     HttpCommonNotify,
 211                     &HttpInstance->IsCloseDone,
 212                     &HttpInstance->CloseToken.CompletionToken.Event
 213                     );
 214     if (EFI_ERROR (Status)) {
 215       goto ERROR;
 216     }
 217
 218
 219   return EFI_SUCCESS;
 220
 221 ERROR:
 222   //
 223   // Error handling
 224   //
 225   HttpCloseTcp4ConnCloseEvent (HttpInstance);
 226
 227   return Status;
 228 }
 229
 230
 231 /**
 232   Close events in the TCP4 connection token and TCP4 close token.
 233
 234   @param[in]  HttpInstance   Pointer to HTTP_PROTOCOL structure.
 235
 236 **/
 237 VOID
 238 HttpCloseTcp4ConnCloseEvent (
 239   IN  HTTP_PROTOCOL        *HttpInstance
 240   )
 241 {
 242   ASSERT (HttpInstance != NULL);
 243
 244   if (NULL != HttpInstance->ConnToken.CompletionToken.Event) {
 245     gBS->CloseEvent (HttpInstance->ConnToken.CompletionToken.Event);
 246     HttpInstance->ConnToken.CompletionToken.Event = NULL;
 247   }
 248
 249   if (NULL != HttpInstance->CloseToken.CompletionToken.Event) {
 250     gBS->CloseEvent(HttpInstance->CloseToken.CompletionToken.Event);
 251     HttpInstance->CloseToken.CompletionToken.Event = NULL;
 252   }
 253 }
 254
 255 /**
 256   Create event for the TCP4 transmit token.
 257
 258   @param[in]  Wrap               Point to HTTP token's wrap data.
 259
 260   @retval EFI_SUCCESS            The events is created successfully.
 261   @retval others                 Other error as indicated.
 262
 263 **/
 264 EFI_STATUS
 265 HttpCreateTcp4TxEvent (
 266   IN  HTTP_TOKEN_WRAP      *Wrap
 267   )
 268 {
 269   EFI_STATUS               Status;
 270   HTTP_PROTOCOL            *HttpInstance;
 271   HTTP_TCP_TOKEN_WRAP      *TcpWrap;
 272
 273   HttpInstance = Wrap->HttpInstance;
 274   TcpWrap      = &Wrap->TcpWrap;
 275
 276   Status = gBS->CreateEvent (
 277                   EVT_NOTIFY_SIGNAL,
 278                   TPL_NOTIFY,
 279                   HttpTcpTransmitNotify,
 280                   Wrap,
 281                   &TcpWrap->TxToken.CompletionToken.Event
 282                   );
 283   if (EFI_ERROR (Status)) {
 284     return Status;
 285   }
 286
 287   TcpWrap->TxData.Push = TRUE;
 288   TcpWrap->TxData.Urgent = FALSE;
 289   TcpWrap->TxData.FragmentCount = 1;
 290   TcpWrap->TxToken.Packet.TxData = &Wrap->TcpWrap.TxData;
 291   TcpWrap->TxToken.CompletionToken.Status = EFI_NOT_READY;
 292
 293   return EFI_SUCCESS;
 294 }
 295
 296 /**
 297   Create event for the TCP4 receive token which is used to receive HTTP header.
 298
 299   @param[in]  HttpInstance       Pointer to HTTP_PROTOCOL structure.
 300
 301   @retval EFI_SUCCESS            The events is created successfully.
 302   @retval others                 Other error as indicated.
 303
 304 **/
 305 EFI_STATUS
 306 HttpCreateTcp4RxEventForHeader (
 307   IN  HTTP_PROTOCOL        *HttpInstance
 308   )
 309 {
 310   EFI_STATUS               Status;
 311
 312
 313   Status = gBS->CreateEvent (
 314                   EVT_NOTIFY_SIGNAL,
 315                   TPL_NOTIFY,
 316                   HttpCommonNotify,
 317                   &HttpInstance->IsRxDone,
 318                   &HttpInstance->RxToken.CompletionToken.Event
 319                   );
 320   if (EFI_ERROR (Status)) {
 321     return Status;
 322   }
 323
 324   HttpInstance->RxData.FragmentCount = 1;
 325   HttpInstance->RxToken.Packet.RxData = &HttpInstance->RxData;
 326   HttpInstance->RxToken.CompletionToken.Status = EFI_NOT_READY;
 327
 328   return EFI_SUCCESS;
 329 }
 330
 331 /**
 332   Create event for the TCP4 receive token which is used to receive HTTP body.
 333
 334   @param[in]  Wrap               Point to HTTP token's wrap data.
 335
 336   @retval EFI_SUCCESS            The events is created successfully.
 337   @retval others                 Other error as indicated.
 338
 339 **/
 340 EFI_STATUS
 341 HttpCreateTcp4RxEvent (
 342   IN  HTTP_TOKEN_WRAP      *Wrap
 343   )
 344 {
 345   EFI_STATUS               Status;
 346   HTTP_PROTOCOL            *HttpInstance;
 347   HTTP_TCP_TOKEN_WRAP      *TcpWrap;
 348
 349   HttpInstance = Wrap->HttpInstance;
 350   TcpWrap      = &Wrap->TcpWrap;
 351
 352   Status = gBS->CreateEvent (
 353                   EVT_NOTIFY_SIGNAL,
 354                   TPL_NOTIFY,
 355                   HttpTcpReceiveNotify,
 356                   Wrap,
 357                   &TcpWrap->RxToken.CompletionToken.Event
 358                   );
 359   if (EFI_ERROR (Status)) {
 360     return Status;
 361   }
 362
 363   TcpWrap->RxData.FragmentCount = 1;
 364   TcpWrap->RxToken.Packet.RxData = &Wrap->TcpWrap.RxData;
 365   TcpWrap->RxToken.CompletionToken.Status = EFI_NOT_READY;
 366
 367   return EFI_SUCCESS;
 368 }
 369
 370 /**
 371   Intiialize the HTTP_PROTOCOL structure to the unconfigured state.
 372
 373   @param[in]       HttpSb               The HTTP service private instance.
 374   @param[in, out]  HttpInstance         Pointer to HTTP_PROTOCOL structure.
 375
 376   @retval EFI_SUCCESS       HTTP_PROTOCOL structure is initialized successfully.
 377   @retval Others            Other error as indicated.
 378
 379 **/
 380 EFI_STATUS
 381 HttpInitProtocol (
 382   IN     HTTP_SERVICE            *HttpSb,
 383   IN OUT HTTP_PROTOCOL           *HttpInstance
 384   )
 385 {
 386   EFI_STATUS                     Status;
 387   VOID                           *Interface;
 388
 389   ASSERT ((HttpSb != NULL) && (HttpInstance != NULL));
 390
 391   HttpInstance->Signature = HTTP_PROTOCOL_SIGNATURE;
 392   CopyMem (&HttpInstance->Http, &mEfiHttpTemplate, sizeof (HttpInstance->Http));
 393   HttpInstance->Service = HttpSb;
 394
 395   //
 396   // Create TCP child.
 397   //
 398   Status = NetLibCreateServiceChild (
 399              HttpInstance->Service->ControllerHandle,
 400              HttpInstance->Service->ImageHandle,
 401              &gEfiTcp4ServiceBindingProtocolGuid,
 402              &HttpInstance->TcpChildHandle
 403              );
 404
 405   if (EFI_ERROR (Status)) {
 406     goto ON_ERROR;
 407   }
 408
 409   Status = gBS->OpenProtocol (
 410                   HttpInstance->TcpChildHandle,
 411                   &gEfiTcp4ProtocolGuid,
 412                   (VOID **) &Interface,
 413                   HttpInstance->Service->ImageHandle,
 414                   HttpInstance->Service->ControllerHandle,
 415                   EFI_OPEN_PROTOCOL_BY_DRIVER
 416                   );
 417
 418   if (EFI_ERROR (Status)) {
 419     goto ON_ERROR;
 420   }
 421
 422   Status = gBS->OpenProtocol (
 423                   HttpInstance->TcpChildHandle,
 424                   &gEfiTcp4ProtocolGuid,
 425                   (VOID **) &HttpInstance->Tcp4,
 426                   HttpInstance->Service->ImageHandle,
 427                   HttpInstance->Handle,
 428                   EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 429                   );
 430   if (EFI_ERROR(Status)) {
 431     goto ON_ERROR;
 432   }
 433
 434   NetMapInit (&HttpInstance->TxTokens);
 435   NetMapInit (&HttpInstance->RxTokens);
 436
 437   return EFI_SUCCESS;
 438
 439 ON_ERROR:
 440
 441   if (HttpInstance->TcpChildHandle != NULL) {
 442     gBS->CloseProtocol (
 443            HttpInstance->TcpChildHandle,
 444            &gEfiTcp4ProtocolGuid,
 445            HttpInstance->Service->ImageHandle,
 446            HttpInstance->Service->ControllerHandle
 447            );
 448
 449     gBS->CloseProtocol (
 450            HttpInstance->TcpChildHandle,
 451            &gEfiTcp4ProtocolGuid,
 452            HttpInstance->Service->ImageHandle,
 453            HttpInstance->Handle
 454            );
 455
 456     NetLibDestroyServiceChild (
 457       HttpInstance->Service->ControllerHandle,
 458       HttpInstance->Service->ImageHandle,
 459       &gEfiTcp4ServiceBindingProtocolGuid,
 460       HttpInstance->TcpChildHandle
 461       );
 462   }
 463
 464   return Status;
 465
 466 }
 467
 468 /**
 469   Clean up the HTTP child, release all the resources used by it.
 470
 471   @param[in]  HttpInstance       The HTTP child to clean up.
 472
 473 **/
 474 VOID
 475 HttpCleanProtocol (
 476   IN  HTTP_PROTOCOL          *HttpInstance
 477   )
 478 {
 479   HttpCloseConnection (HttpInstance);
 480
 481   HttpCloseTcp4ConnCloseEvent (HttpInstance);
 482
 483   if (HttpInstance->CacheBody != NULL) {
 484     FreePool (HttpInstance->CacheBody);
 485     HttpInstance->CacheBody = NULL;
 486     HttpInstance->NextMsg   = NULL;
 487   }
 488
 489   if (HttpInstance->RemoteHost != NULL) {
 490     FreePool (HttpInstance->RemoteHost);
 491     HttpInstance->RemoteHost = NULL;
 492   }
 493
 494   if (HttpInstance->MsgParser != NULL) {
 495     HttpFreeMsgParser (HttpInstance->MsgParser);
 496     HttpInstance->MsgParser = NULL;
 497   }
 498
 499   NetMapClean (&HttpInstance->TxTokens);
 500   NetMapClean (&HttpInstance->RxTokens);
 501
 502   if (HttpInstance->TcpChildHandle != NULL) {
 503     gBS->CloseProtocol (
 504            HttpInstance->TcpChildHandle,
 505            &gEfiTcp4ProtocolGuid,
 506            HttpInstance->Service->ImageHandle,
 507            HttpInstance->Service->ControllerHandle
 508            );
 509
 510     gBS->CloseProtocol (
 511            HttpInstance->TcpChildHandle,
 512            &gEfiTcp4ProtocolGuid,
 513            HttpInstance->Service->ImageHandle,
 514            HttpInstance->Handle
 515            );
 516
 517     NetLibDestroyServiceChild (
 518       HttpInstance->Service->ControllerHandle,
 519       HttpInstance->Service->ImageHandle,
 520       &gEfiTcp4ServiceBindingProtocolGuid,
 521       HttpInstance->TcpChildHandle
 522       );
 523   }
 524 }
 525
 526 /**
 527   Establish TCP connection with HTTP server.
 528
 529   @param[in]  HttpInstance       The HTTP instance private data.
 530
 531   @retval EFI_SUCCESS            The TCP connection is established.
 532   @retval Others                 Other error as indicated.
 533
 534 **/
 535 EFI_STATUS
 536 HttpCreateConnection (
 537   IN  HTTP_PROTOCOL        *HttpInstance
 538   )
 539 {
 540   EFI_STATUS                    Status;
 541
 542   //
 543   // Create events for variuos asynchronous operations.
 544   //
 545   HttpInstance->IsConnDone = FALSE;
 546
 547   //
 548   // Connect to Http server
 549   //
 550   HttpInstance->ConnToken.CompletionToken.Status = EFI_NOT_READY;
 551   Status = HttpInstance->Tcp4->Connect (HttpInstance->Tcp4, &HttpInstance->ConnToken);
 552   if (EFI_ERROR (Status)) {
 553     DEBUG ((EFI_D_ERROR, "HttpCreateConnection: Tcp4->Connect() = %r\n", Status));
 554     return Status;
 555   }
 556
 557   while (!HttpInstance->IsConnDone) {
 558     HttpInstance->Tcp4->Poll (HttpInstance->Tcp4);
 559   }
 560
 561   Status = HttpInstance->ConnToken.CompletionToken.Status;
 562
 563   if (!EFI_ERROR (Status)) {
 564     HttpInstance->State = HTTP_STATE_TCP_CONNECTED;
 565   }
 566
 567   return Status;
 568 }
 569
 570 /**
 571   Close existing TCP connection.
 572
 573   @param[in]  HttpInstance       The HTTP instance private data.
 574
 575   @retval EFI_SUCCESS            The TCP connection is closed.
 576   @retval Others                 Other error as indicated.
 577
 578 **/
 579 EFI_STATUS
 580 HttpCloseConnection (
 581   IN  HTTP_PROTOCOL        *HttpInstance
 582   )
 583 {
 584   EFI_STATUS                Status;
 585
 586   if (HttpInstance->State == HTTP_STATE_TCP_CONNECTED) {
 587     HttpInstance->CloseToken.AbortOnClose = TRUE;
 588     HttpInstance->IsCloseDone             = FALSE;
 589
 590     Status = HttpInstance->Tcp4->Close (HttpInstance->Tcp4, &HttpInstance->CloseToken);
 591     if (EFI_ERROR (Status)) {
 592       return Status;
 593     }
 594
 595     while (!HttpInstance->IsCloseDone) {
 596       HttpInstance->Tcp4->Poll (HttpInstance->Tcp4);
 597     }
 598   }
 599
 600   HttpInstance->State = HTTP_STATE_TCP_CLOSED;
 601   return EFI_SUCCESS;
 602 }
 603
 604 /**
 605   Configure TCP4 protocol child.
 606
 607   @param[in]  HttpInstance       The HTTP instance private data.
 608   @param[in]  Wrap               The HTTP token's wrap data.
 609
 610   @retval EFI_SUCCESS            The TCP4 protocol child is configured.
 611   @retval Others                 Other error as indicated.
 612
 613 **/
 614 EFI_STATUS
 615 HttpConfigureTcp4 (
 616   IN  HTTP_PROTOCOL        *HttpInstance,
 617   IN  HTTP_TOKEN_WRAP      *Wrap
 618   )
 619 {
 620   EFI_STATUS                 Status;
 621   EFI_TCP4_CONFIG_DATA       *Tcp4CfgData;
 622   EFI_TCP4_ACCESS_POINT      *Tcp4AP;
 623   EFI_TCP4_OPTION            *Tcp4Option;
 624   HTTP_TCP_TOKEN_WRAP        *TcpWrap;
 625
 626   ASSERT (HttpInstance != NULL);
 627   TcpWrap = &Wrap->TcpWrap;
 628
 629
 630   Tcp4CfgData = &HttpInstance->Tcp4CfgData;
 631   ZeroMem (Tcp4CfgData, sizeof (EFI_TCP4_CONFIG_DATA));
 632
 633   Tcp4CfgData->TypeOfService = HTTP_TOS_DEAULT;
 634   Tcp4CfgData->TimeToLive    = HTTP_TTL_DEAULT;
 635   Tcp4CfgData->ControlOption = &HttpInstance->Tcp4Option;
 636
 637   Tcp4AP = &Tcp4CfgData->AccessPoint;
 638   Tcp4AP->UseDefaultAddress = HttpInstance->IPv4Node.UseDefaultAddress;
 639   if (!Tcp4AP->UseDefaultAddress) {
 640     IP4_COPY_ADDRESS (&Tcp4AP->StationAddress, &HttpInstance->IPv4Node.LocalAddress);
 641     IP4_COPY_ADDRESS (&Tcp4AP->SubnetMask, &HttpInstance->IPv4Node.LocalSubnet);
 642   }
 643
 644   Tcp4AP->StationPort = HttpInstance->IPv4Node.LocalPort;
 645   Tcp4AP->RemotePort  = HttpInstance->RemotePort;
 646   Tcp4AP->ActiveFlag  = TRUE;
 647   IP4_COPY_ADDRESS (&Tcp4AP->RemoteAddress, &HttpInstance->RemoteAddr);
 648
 649   Tcp4Option = Tcp4CfgData->ControlOption;
 650   Tcp4Option->ReceiveBufferSize      = HTTP_BUFFER_SIZE_DEAULT;
 651   Tcp4Option->SendBufferSize         = HTTP_BUFFER_SIZE_DEAULT;
 652   Tcp4Option->MaxSynBackLog          = HTTP_MAX_SYN_BACK_LOG;
 653   Tcp4Option->ConnectionTimeout      = HTTP_CONNECTION_TIMEOUT;
 654   Tcp4Option->DataRetries            = HTTP_DATA_RETRIES;
 655   Tcp4Option->FinTimeout             = HTTP_FIN_TIMEOUT;
 656   Tcp4Option->KeepAliveProbes        = HTTP_KEEP_ALIVE_PROBES;
 657   Tcp4Option->KeepAliveTime          = HTTP_KEEP_ALIVE_TIME;
 658   Tcp4Option->KeepAliveInterval      = HTTP_KEEP_ALIVE_INTERVAL;
 659   Tcp4Option->EnableNagle            = TRUE;
 660   Tcp4CfgData->ControlOption         = Tcp4Option;
 661
 662   Status = HttpInstance->Tcp4->Configure (HttpInstance->Tcp4, Tcp4CfgData);
 663   if (EFI_ERROR (Status)) {
 664     DEBUG ((EFI_D_ERROR, "HttpConfigureTcp4 - %r\n", Status));
 665     return Status;
 666   }
 667
 668   Status = HttpCreateTcp4ConnCloseEvent (HttpInstance);
 669   if (EFI_ERROR (Status)) {
 670     return Status;
 671   }
 672
 673   Status = HttpCreateTcp4TxEvent (Wrap);
 674   if (EFI_ERROR (Status)) {
 675     return Status;
 676   }
 677
 678   HttpInstance->State = HTTP_STATE_TCP_CONFIGED;
 679
 680   return EFI_SUCCESS;
 681 }
 682
 683 /**
 684   Check existing TCP connection, if in error state, receover TCP4 connection.
 685
 686   @param[in]  HttpInstance       The HTTP instance private data.
 687
 688   @retval EFI_SUCCESS            The TCP connection is established.
 689   @retval EFI_NOT_READY          TCP4 protocol child is not created or configured.
 690   @retval Others                 Other error as indicated.
 691
 692 **/
 693 EFI_STATUS
 694 HttpConnectTcp4 (
 695   IN  HTTP_PROTOCOL        *HttpInstance
 696   )
 697 {
 698   EFI_STATUS                Status;
 699   EFI_TCP4_CONNECTION_STATE Tcp4State;
 700
 701
 702   if (HttpInstance->State != HTTP_STATE_TCP_CONFIGED || HttpInstance->Tcp4 == NULL) {
 703     return EFI_NOT_READY;
 704   }
 705
 706   Status = HttpInstance->Tcp4->GetModeData(
 707                                  HttpInstance->Tcp4,
 708                                  &Tcp4State,
 709                                  NULL,
 710                                  NULL,
 711                                  NULL,
 712                                  NULL
 713                                  );
 714   if (EFI_ERROR(Status)){
 715     DEBUG ((EFI_D_ERROR, "Tcp4 GetModeData fail - %x\n", Status));
 716     return Status;
 717   }
 718
 719   if (Tcp4State > Tcp4StateEstablished) {
 720     HttpCloseConnection(HttpInstance);
 721   }
 722
 723   return HttpCreateConnection (HttpInstance);
 724 }
 725
 726 /**
 727   Send the HTTP message through TCP4.
 728
 729   @param[in]  HttpInstance       The HTTP instance private data.
 730   @param[in]  Wrap               The HTTP token's wrap data.
 731   @param[in]  TxString           Buffer containing the HTTP message string.
 732   @param[in]  TxStringLen        Length of the HTTP message string in bytes.
 733
 734   @retval EFI_SUCCESS            The HTTP message is queued into TCP transmit queue.
 735   @retval Others                 Other error as indicated.
 736
 737 **/
 738 EFI_STATUS
 739 HttpTransmitTcp4 (
 740   IN  HTTP_PROTOCOL    *HttpInstance,
 741   IN  HTTP_TOKEN_WRAP  *Wrap,
 742   IN  UINT8            *TxString,
 743   IN  UINTN            TxStringLen
 744   )
 745 {
 746   EFI_STATUS                    Status;
 747   EFI_TCP4_IO_TOKEN             *TxToken;
 748   EFI_TCP4_PROTOCOL             *Tcp4;
 749
 750   Tcp4 = HttpInstance->Tcp4;
 751   TxToken = &Wrap->TcpWrap.TxToken;
 752
 753   TxToken->Packet.TxData->DataLength = (UINT32) TxStringLen;
 754   TxToken->Packet.TxData->FragmentTable[0].FragmentLength = (UINT32) TxStringLen;
 755   TxToken->Packet.TxData->FragmentTable[0].FragmentBuffer = (VOID *) TxString;
 756   TxToken->CompletionToken.Status = EFI_NOT_READY;
 757
 758   Wrap->TcpWrap.IsTxDone = FALSE;
 759   Status  = Tcp4->Transmit (Tcp4, TxToken);
 760   if (EFI_ERROR (Status)) {
 761     DEBUG ((EFI_D_ERROR, "Transmit failed: %r\n", Status));
 762     return Status;
 763   }
 764
 765   return Status;
 766 }
 767
 768 /**
 769   Translate the status code in HTTP message to EFI_HTTP_STATUS_CODE defined
 770   in UEFI 2.5 specification.
 771
 772   @param[in]  StatusCode         The status code value in HTTP message.
 773
 774   @return                        Value defined in EFI_HTTP_STATUS_CODE .
 775
 776 **/
 777 EFI_HTTP_STATUS_CODE
 778 HttpMappingToStatusCode (
 779   IN UINTN                  StatusCode
 780   )
 781 {
 782   switch (StatusCode) {
 783   case 100:
 784     return HTTP_STATUS_100_CONTINUE;
 785   case 101:
 786     return HTTP_STATUS_101_SWITCHING_PROTOCOLS;
 787   case 200:
 788     return HTTP_STATUS_200_OK;
 789   case 201:
 790     return HTTP_STATUS_201_CREATED;
 791   case 202:
 792     return HTTP_STATUS_202_ACCEPTED;
 793   case 203:
 794     return HTTP_STATUS_203_NON_AUTHORITATIVE_INFORMATION;
 795   case 204:
 796     return HTTP_STATUS_204_NO_CONTENT;
 797   case 205:
 798     return HTTP_STATUS_205_RESET_CONTENT;
 799   case 206:
 800     return HTTP_STATUS_206_PARTIAL_CONTENT;
 801   case 300:
 802     return HTTP_STATUS_300_MULTIPLE_CHIOCES;
 803   case 301:
 804     return HTTP_STATUS_301_MOVED_PERMANENTLY;
 805   case 302:
 806     return HTTP_STATUS_302_FOUND;
 807   case 303:
 808     return HTTP_STATUS_303_SEE_OTHER;
 809   case 304:
 810     return HTTP_STATUS_304_NOT_MODIFIED;
 811   case 305:
 812     return HTTP_STATUS_305_USE_PROXY;
 813   case 307:
 814     return HTTP_STATUS_307_TEMPORARY_REDIRECT;
 815   case 400:
 816     return HTTP_STATUS_400_BAD_REQUEST;
 817   case 401:
 818     return HTTP_STATUS_401_UNAUTHORIZED;
 819   case 402:
 820     return HTTP_STATUS_402_PAYMENT_REQUIRED;
 821   case 403:
 822     return HTTP_STATUS_403_FORBIDDEN;
 823   case 404:
 824     return HTTP_STATUS_404_NOT_FOUND;
 825   case 405:
 826     return HTTP_STATUS_405_METHOD_NOT_ALLOWED;
 827   case 406:
 828     return HTTP_STATUS_406_NOT_ACCEPTABLE;
 829   case 407:
 830     return HTTP_STATUS_407_PROXY_AUTHENTICATION_REQUIRED;
 831   case 408:
 832     return HTTP_STATUS_408_REQUEST_TIME_OUT;
 833   case 409:
 834     return HTTP_STATUS_409_CONFLICT;
 835   case 410:
 836     return HTTP_STATUS_410_GONE;
 837   case 411:
 838     return HTTP_STATUS_411_LENGTH_REQUIRED;
 839   case 412:
 840     return HTTP_STATUS_412_PRECONDITION_FAILED;
 841   case 413:
 842     return HTTP_STATUS_413_REQUEST_ENTITY_TOO_LARGE;
 843   case 414:
 844     return HTTP_STATUS_414_REQUEST_URI_TOO_LARGE;
 845   case 415:
 846     return HTTP_STATUS_415_UNSUPPORETD_MEDIA_TYPE;
 847   case 416:
 848     return HTTP_STATUS_416_REQUESTED_RANGE_NOT_SATISFIED;
 849   case 417:
 850     return HTTP_STATUS_417_EXPECTATION_FAILED;
 851   case 500:
 852     return HTTP_STATUS_500_INTERNAL_SERVER_ERROR;
 853   case 501:
 854     return HTTP_STATUS_501_NOT_IMIPLEMENTED;
 855   case 502:
 856     return HTTP_STATUS_502_BAD_GATEWAY;
 857   case 503:
 858     return HTTP_STATUS_503_SERVICE_UNAVAILABLE;
 859   case 504:
 860     return HTTP_STATUS_504_GATEWAY_TIME_OUT;
 861   case 505:
 862     return HTTP_STATUS_505_HTTP_VERSION_NOT_SUPPORTED;
 863
 864   default:
 865     return HTTP_STATUS_UNSUPPORTED_STATUS;
 866   }
 867 }
 868
 869 /**
 870   Check whether the user's token or event has already
 871   been enqueue on HTTP TxToken or RxToken list.
 872
 873   @param[in]  Map                The container of either user's transmit or receive
 874                                  token.
 875   @param[in]  Item               Current item to check against.
 876   @param[in]  Context            The Token to check againist.
 877
 878   @retval EFI_ACCESS_DENIED      The token or event has already been enqueued in IP
 879   @retval EFI_SUCCESS            The current item isn't the same token/event as the
 880                                  context.
 881
 882 **/
 883 EFI_STATUS
 884 EFIAPI
 885 HttpTokenExist (
 886   IN NET_MAP                *Map,
 887   IN NET_MAP_ITEM           *Item,
 888   IN VOID                   *Context
 889   )
 890 {
 891   EFI_HTTP_TOKEN            *Token;
 892   EFI_HTTP_TOKEN            *TokenInItem;
 893
 894   Token       = (EFI_HTTP_TOKEN *) Context;
 895   TokenInItem = (EFI_HTTP_TOKEN *) Item->Key;
 896
 897   if (Token == TokenInItem || Token->Event == TokenInItem->Event) {
 898     return EFI_ACCESS_DENIED;
 899   }
 900
 901   return EFI_SUCCESS;
 902 }
 903
 904 /**
 905   Check whether the HTTP message associated with TxToken is already sent out.
 906
 907   @param[in]  Map                The container of TxToken.
 908   @param[in]  Item               Current item to check against.
 909   @param[in]  Context            The Token to check againist.
 910
 911   @retval EFI_NOT_READY          The HTTP message is still queued in the list.
 912   @retval EFI_SUCCESS            The HTTP message has been sent out.
 913
 914 **/
 915 EFI_STATUS
 916 EFIAPI
 917 HttpTcpNotReady (
 918   IN NET_MAP                *Map,
 919   IN NET_MAP_ITEM           *Item,
 920   IN VOID                   *Context
 921   )
 922 {
 923   HTTP_TOKEN_WRAP           *ValueInItem;
 924
 925   ValueInItem = (HTTP_TOKEN_WRAP *) Item->Value;
 926
 927   if (!ValueInItem->TcpWrap.IsTxDone) {
 928     return EFI_NOT_READY;
 929   }
 930
 931   return EFI_SUCCESS;
 932 }
 933
 934 /**
 935   Transmit the HTTP mssage by processing the associated HTTP token.
 936
 937   @param[in]  Map                The container of TxToken.
 938   @param[in]  Item               Current item to check against.
 939   @param[in]  Context            The Token to check againist.
 940
 941   @retval EFI_OUT_OF_RESOURCES   Failed to allocate resources.
 942   @retval EFI_SUCCESS            The HTTP message is queued into TCP transmit
 943                                  queue.
 944
 945 **/
 946 EFI_STATUS
 947 EFIAPI
 948 HttpTcpTransmit (
 949   IN NET_MAP                *Map,
 950   IN NET_MAP_ITEM           *Item,
 951   IN VOID                   *Context
 952   )
 953 {
 954   HTTP_TOKEN_WRAP           *ValueInItem;
 955   EFI_STATUS                Status;
 956   CHAR8                     *RequestStr;
 957   CHAR8                     *Url;
 958
 959   ValueInItem = (HTTP_TOKEN_WRAP *) Item->Value;
 960   if (ValueInItem->TcpWrap.IsTxDone) {
 961     return EFI_SUCCESS;
 962   }
 963
 964   //
 965   // Parse the URI of the remote host.
 966   //
 967   Url = AllocatePool (StrLen (ValueInItem->HttpToken->Message->Data.Request->Url) + 1);
 968   if (Url == NULL) {
 969     return EFI_OUT_OF_RESOURCES;
 970   }
 971
 972   UnicodeStrToAsciiStr (ValueInItem->HttpToken->Message->Data.Request->Url, Url);
 973
 974   //
 975   // Create request message.
 976   //
 977   RequestStr = HttpGenRequestString (
 978                  ValueInItem->HttpInstance,
 979                  ValueInItem->HttpToken->Message,
 980                  Url
 981                  );
 982   FreePool (Url);
 983   if (RequestStr == NULL) {
 984     return EFI_OUT_OF_RESOURCES;
 985   }
 986
 987   //
 988   // Transmit the request message.
 989   //
 990   Status = HttpTransmitTcp4 (
 991              ValueInItem->HttpInstance,
 992              ValueInItem,
 993              (UINT8*) RequestStr,
 994              AsciiStrLen (RequestStr)
 995              );
 996   FreePool (RequestStr);
 997   return Status;
 998 }
 999
1000 /**
1001   Receive the HTTP response by processing the associated HTTP token.
1002
1003   @param[in]  Map                The container of RxToken.
1004   @param[in]  Item               Current item to check against.
1005   @param[in]  Context            The Token to check againist.
1006
1007   @retval EFI_SUCCESS            The HTTP response is queued into TCP receive
1008                                  queue.
1009   @retval Others                 Other error as indicated.
1010
1011 **/
1012 EFI_STATUS
1013 EFIAPI
1014 HttpTcpReceive (
1015   IN NET_MAP                *Map,
1016   IN NET_MAP_ITEM           *Item,
1017   IN VOID                   *Context
1018   )
1019 {
1020   //
1021   // Process the queued HTTP response.
1022   //
1023   return HttpResponseWorker ((HTTP_TOKEN_WRAP *) Item->Value);
1024 }
1025
1026 /**
1027   Generate HTTP request string.
1028
1029   @param[in]  HttpInstance       Pointer to HTTP_PROTOCOL structure.
1030   @param[in]  Message            Pointer to storage containing HTTP message data.
1031   @param[in]  Url                The URL of a remote host.
1032
1033   @return     Pointer to the created HTTP request string.
1034   @return     NULL if any error occured.
1035
1036 **/
1037 CHAR8 *
1038 HttpGenRequestString (
1039   IN  HTTP_PROTOCOL        *HttpInstance,
1040   IN  EFI_HTTP_MESSAGE     *Message,
1041   IN  CHAR8                *Url
1042   )
1043 {
1044   EFI_STATUS                  Status;
1045   UINTN                       StrLength;
1046   UINT8                       *Request;
1047   UINT8                       *RequestPtr;
1048   UINTN                       HttpHdrSize;
1049   UINTN                       MsgSize;
1050   BOOLEAN                     Success;
1051   VOID                        *HttpHdr;
1052   EFI_HTTP_HEADER             **AppendList;
1053   UINTN                       Index;
1054
1055   ASSERT (HttpInstance != NULL);
1056   ASSERT (Message != NULL);
1057
1058   DEBUG ((EFI_D_ERROR, "HttpMethod - %x\n", Message->Data.Request->Method));
1059
1060   Request = NULL;
1061   Success = FALSE;
1062   HttpHdr = NULL;
1063   AppendList = NULL;
1064
1065   //
1066   // Build AppendList
1067   //
1068   AppendList = AllocateZeroPool (sizeof (EFI_HTTP_HEADER *) * (Message->HeaderCount));
1069   if (AppendList == NULL) {
1070     return NULL;
1071   }
1072
1073   for(Index = 0; Index < Message->HeaderCount; Index++){
1074     AppendList[Index] = &Message->Headers[Index];
1075   }
1076
1077   //
1078   // Check whether the EFI_HTTP_UTILITIES_PROTOCOL is available.
1079   //
1080   if (mHttpUtilities == NULL) {
1081     return NULL;
1082   }
1083
1084   //
1085   // Build raw unformatted HTTP headers.
1086   //
1087   Status = mHttpUtilities->Build (
1088                              mHttpUtilities,
1089                              0,
1090                              NULL,
1091                              0,
1092                              NULL,
1093                              Message->HeaderCount,
1094                              AppendList,
1095                              &HttpHdrSize,
1096                              &HttpHdr
1097                              );
1098   FreePool (AppendList);
1099   if (EFI_ERROR (Status) || HttpHdr == NULL) {
1100     return NULL;
1101   }
1102
1103   //
1104   // Calculate HTTP message length.
1105   //
1106   MsgSize = Message->BodyLength + HTTP_MAXIMUM_METHOD_LEN + AsciiStrLen (Url) +
1107             AsciiStrLen (HTTP_VERSION_CRLF_STR) + HttpHdrSize;
1108   Request = AllocateZeroPool (MsgSize);
1109   if (Request == NULL) {
1110     goto Exit;
1111   }
1112
1113   RequestPtr = Request;
1114   //
1115   // Construct header request
1116   //
1117   switch (Message->Data.Request->Method) {
1118   case HttpMethodGet:
1119     StrLength = sizeof (HTTP_GET_STR) - 1;
1120     CopyMem (RequestPtr, HTTP_GET_STR, StrLength);
1121     RequestPtr += StrLength;
1122     break;
1123   case HttpMethodHead:
1124     StrLength = sizeof (HTTP_HEAD_STR) - 1;
1125     CopyMem (RequestPtr, HTTP_HEAD_STR, StrLength);
1126     RequestPtr += StrLength;
1127     break;
1128   default:
1129     ASSERT (FALSE);
1130     goto Exit;
1131   }
1132
1133   StrLength = AsciiStrLen (Url);
1134   CopyMem (RequestPtr, Url, StrLength);
1135   RequestPtr += StrLength;
1136
1137   StrLength = sizeof (HTTP_VERSION_CRLF_STR) - 1;
1138   CopyMem (RequestPtr, HTTP_VERSION_CRLF_STR, StrLength);
1139   RequestPtr += StrLength;
1140
1141   //
1142   // Construct header
1143   //
1144   CopyMem (RequestPtr, HttpHdr, HttpHdrSize);
1145   RequestPtr += HttpHdrSize;
1146
1147   //
1148   // Construct body
1149   //
1150   if (Message->Body != NULL) {
1151     CopyMem (RequestPtr, Message->Body, Message->BodyLength);
1152     RequestPtr += Message->BodyLength;
1153   }
1154
1155   //
1156   // Done
1157   //
1158   *RequestPtr = 0;
1159   Success     = TRUE;
1160
1161 Exit:
1162
1163   if (!Success) {
1164     if (Request != NULL) {
1165       FreePool (Request);
1166     }
1167
1168     Request = NULL;
1169   }
1170
1171   if (HttpHdr != NULL) {
1172     FreePool (HttpHdr);
1173   }
1174
1175   return (CHAR8*) Request;
1176 }