VirtualBox

Ignore:
Timestamp:
Apr 14, 2023 3:17:44 PM (22 months ago)
Author:
vboxsync
Message:

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643

Location:
trunk/src/VBox/Devices/EFI/FirmwareNew
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/EFI/FirmwareNew

  • trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/Library/DxeHttpIoLib/DxeHttpIoLib.c

    r89983 r99404  
    2727EFIAPI
    2828HttpIoNotifyDpc (
    29   IN VOID                *Context
     29  IN VOID  *Context
    3030  )
    3131{
    32   *((BOOLEAN *) Context) = TRUE;
     32  *((BOOLEAN *)Context) = TRUE;
    3333}
    3434
    … …  
    4343EFIAPI
    4444HttpIoNotify (
    45   IN EFI_EVENT              Event,
    46   IN VOID                   *Context
     45  IN EFI_EVENT  Event,
     46  IN VOID       *Context
    4747  )
    4848{
    … …  
    6161VOID
    6262HttpIoDestroyIo (
    63   IN HTTP_IO                *HttpIo
     63  IN HTTP_IO  *HttpIo
    6464  )
    6565{
    66   EFI_HTTP_PROTOCOL         *Http;
    67   EFI_EVENT                 Event;
     66  EFI_HTTP_PROTOCOL  *Http;
     67  EFI_EVENT          Event;
    6868
    6969  if (HttpIo == NULL) {
    … …  
    129129EFI_STATUS
    130130HttpIoCreateIo (
    131   IN EFI_HANDLE             Image,
    132   IN EFI_HANDLE             Controller,
    133   IN UINT8                  IpVersion,
    134   IN HTTP_IO_CONFIG_DATA    *ConfigData, OPTIONAL
    135   IN HTTP_IO_CALLBACK       Callback,
    136   IN VOID                   *Context,
    137   OUT HTTP_IO               *HttpIo
     131  IN EFI_HANDLE           Image,
     132  IN EFI_HANDLE           Controller,
     133  IN UINT8                IpVersion,
     134  IN HTTP_IO_CONFIG_DATA  *ConfigData  OPTIONAL,
     135  IN HTTP_IO_CALLBACK     Callback,
     136  IN VOID                 *Context,
     137  OUT HTTP_IO             *HttpIo
    138138  )
    139139{
    140   EFI_STATUS                Status;
    141   EFI_HTTP_CONFIG_DATA      HttpConfigData;
    142   EFI_HTTPv4_ACCESS_POINT   Http4AccessPoint;
    143   EFI_HTTPv6_ACCESS_POINT   Http6AccessPoint;
    144   EFI_HTTP_PROTOCOL         *Http;
    145   EFI_EVENT                 Event;
     140  EFI_STATUS               Status;
     141  EFI_HTTP_CONFIG_DATA     HttpConfigData;
     142  EFI_HTTPv4_ACCESS_POINT  Http4AccessPoint;
     143  EFI_HTTPv6_ACCESS_POINT  Http6AccessPoint;
     144  EFI_HTTP_PROTOCOL        *Http;
     145  EFI_EVENT                Event;
    146146
    147147  if ((Image == NULL) || (Controller == NULL) || (HttpIo == NULL)) {
    … …  
    149149  }
    150150
    151   if (IpVersion != IP_VERSION_4 && IpVersion != IP_VERSION_6) {
     151  if ((IpVersion != IP_VERSION_4) && (IpVersion != IP_VERSION_6)) {
    152152    return EFI_UNSUPPORTED;
    153153  }
    … …  
    172172                  HttpIo->Handle,
    173173                  &gEfiHttpProtocolGuid,
    174                   (VOID **) &Http,
     174                  (VOID **)&Http,
    175175                  Image,
    176176                  Controller,
    … …  
    184184  // Init the configuration data and configure the HTTP child.
    185185  //
    186   HttpIo->Image       = Image;
    187   HttpIo->Controller  = Controller;
    188   HttpIo->IpVersion   = IpVersion;
    189   HttpIo->Http        = Http;
    190   HttpIo->Callback    = Callback;
    191   HttpIo->Context     = Context;
    192   HttpIo->Timeout     = PcdGet32 (PcdHttpIoTimeout);
     186  HttpIo->Image      = Image;
     187  HttpIo->Controller = Controller;
     188  HttpIo->IpVersion  = IpVersion;
     189  HttpIo->Http       = Http;
     190  HttpIo->Callback   = Callback;
     191  HttpIo->Context    = Context;
     192  HttpIo->Timeout    = PcdGet32 (PcdHttpIoTimeout);
    193193
    194194  if (ConfigData != NULL) {
    195195    if (HttpIo->IpVersion == IP_VERSION_4) {
    196       HttpConfigData.LocalAddressIsIPv6  = FALSE;
    197       HttpConfigData.HttpVersion         = ConfigData->Config4.HttpVersion;
    198       HttpConfigData.TimeOutMillisec     = ConfigData->Config4.RequestTimeOut;
     196      HttpConfigData.LocalAddressIsIPv6 = FALSE;
     197      HttpConfigData.HttpVersion        = ConfigData->Config4.HttpVersion;
     198      HttpConfigData.TimeOutMillisec    = ConfigData->Config4.RequestTimeOut;
    199199
    200200      Http4AccessPoint.UseDefaultAddress = ConfigData->Config4.UseDefaultAddress;
    … …  
    205205    } else {
    206206      HttpConfigData.LocalAddressIsIPv6 = TRUE;
    207       HttpConfigData.HttpVersion         = ConfigData->Config6.HttpVersion;
    208       HttpConfigData.TimeOutMillisec     = ConfigData->Config6.RequestTimeOut;
    209 
    210       Http6AccessPoint.LocalPort         = ConfigData->Config6.LocalPort;
     207      HttpConfigData.HttpVersion        = ConfigData->Config6.HttpVersion;
     208      HttpConfigData.TimeOutMillisec    = ConfigData->Config6.RequestTimeOut;
     209
     210      Http6AccessPoint.LocalPort = ConfigData->Config6.LocalPort;
    211211      IP6_COPY_ADDRESS (&Http6AccessPoint.LocalAddress, &ConfigData->Config6.LocalIp);
    212212      HttpConfigData.AccessPoint.IPv6Node = &Http6AccessPoint;
    … …  
    232232    goto ON_ERROR;
    233233  }
    234   HttpIo->ReqToken.Event = Event;
     234
     235  HttpIo->ReqToken.Event   = Event;
    235236  HttpIo->ReqToken.Message = &HttpIo->ReqMessage;
    236237
    … …  
    245246    goto ON_ERROR;
    246247  }
    247   HttpIo->RspToken.Event = Event;
     248
     249  HttpIo->RspToken.Event   = Event;
    248250  HttpIo->RspToken.Message = &HttpIo->RspMessage;
    249251
    … …  
    261263    goto ON_ERROR;
    262264  }
     265
    263266  HttpIo->TimeoutEvent = Event;
    264267  return EFI_SUCCESS;
    … …  
    297300  )
    298301{
    299   EFI_STATUS                 Status;
    300   EFI_HTTP_PROTOCOL          *Http;
    301 
    302   if (HttpIo == NULL || HttpIo->Http == NULL) {
     302  EFI_STATUS         Status;
     303  EFI_HTTP_PROTOCOL  *Http;
     304
     305  if ((HttpIo == NULL) || (HttpIo->Http == NULL)) {
    303306    return EFI_INVALID_PARAMETER;
    304307  }
    305308
    306   HttpIo->ReqToken.Status  = EFI_NOT_READY;
     309  HttpIo->ReqToken.Status                = EFI_NOT_READY;
    307310  HttpIo->ReqToken.Message->Data.Request = Request;
    308311  HttpIo->ReqToken.Message->HeaderCount  = HeaderCount;
    … …  
    313316  if (HttpIo->Callback != NULL) {
    314317    Status = HttpIo->Callback (
    315                HttpIoRequest,
    316                HttpIo->ReqToken.Message,
    317                HttpIo->Context
    318                );
     318                       HttpIoRequest,
     319                       HttpIo->ReqToken.Message,
     320                       HttpIo->Context
     321                       );
    319322    if (EFI_ERROR (Status)) {
    320323      return Status;
    … …  
    325328  // Queue the request token to HTTP instances.
    326329  //
    327   Http = HttpIo->Http;
     330  Http             = HttpIo->Http;
    328331  HttpIo->IsTxDone = FALSE;
    329   Status = Http->Request (
    330                    Http,
    331                    &HttpIo->ReqToken
    332                    );
     332  Status           = Http->Request (
     333                             Http,
     334                             &HttpIo->ReqToken
     335                             );
    333336  if (EFI_ERROR (Status)) {
    334337    return Status;
    … …  
    362365EFI_STATUS
    363366HttpIoRecvResponse (
    364   IN      HTTP_IO                  *HttpIo,
    365   IN      BOOLEAN                  RecvMsgHeader,
    366   OUT     HTTP_IO_RESPONSE_DATA    *ResponseData
     367  IN      HTTP_IO                *HttpIo,
     368  IN      BOOLEAN                RecvMsgHeader,
     369  OUT     HTTP_IO_RESPONSE_DATA  *ResponseData
    367370  )
    368371{
    369   EFI_STATUS                 Status;
    370   EFI_HTTP_PROTOCOL          *Http;
    371 
    372   if (HttpIo == NULL || HttpIo->Http == NULL || ResponseData == NULL) {
     372  EFI_STATUS         Status;
     373  EFI_HTTP_PROTOCOL  *Http;
     374
     375  if ((HttpIo == NULL) || (HttpIo->Http == NULL) || (ResponseData == NULL)) {
    373376    return EFI_INVALID_PARAMETER;
    374377  }
    … …  
    377380  // Queue the response token to HTTP instances.
    378381  //
    379   HttpIo->RspToken.Status  = EFI_NOT_READY;
     382  HttpIo->RspToken.Status = EFI_NOT_READY;
    380383  if (RecvMsgHeader) {
    381384    HttpIo->RspToken.Message->Data.Response = &ResponseData->Response;
    … …  
    383386    HttpIo->RspToken.Message->Data.Response = NULL;
    384387  }
    385   HttpIo->RspToken.Message->HeaderCount   = 0;
    386   HttpIo->RspToken.Message->Headers       = NULL;
    387   HttpIo->RspToken.Message->BodyLength    = ResponseData->BodyLength;
    388   HttpIo->RspToken.Message->Body          = ResponseData->Body;
    389 
    390   Http = HttpIo->Http;
     388
     389  HttpIo->RspToken.Message->HeaderCount = 0;
     390  HttpIo->RspToken.Message->Headers     = NULL;
     391  HttpIo->RspToken.Message->BodyLength  = ResponseData->BodyLength;
     392  HttpIo->RspToken.Message->Body        = ResponseData->Body;
     393
     394  Http             = HttpIo->Http;
    391395  HttpIo->IsRxDone = FALSE;
    392396
    … …  
    438442
    439443  if ((HttpIo->Callback != NULL) &&
    440       (HttpIo->RspToken.Status == EFI_SUCCESS || HttpIo->RspToken.Status == EFI_HTTP_ERROR)) {
     444      ((HttpIo->RspToken.Status == EFI_SUCCESS) || (HttpIo->RspToken.Status == EFI_HTTP_ERROR)))
     445  {
    441446    Status = HttpIo->Callback (
    442                HttpIoResponse,
    443                HttpIo->RspToken.Message,
    444                HttpIo->Context
    445                );
     447                       HttpIoResponse,
     448                       HttpIo->RspToken.Message,
     449                       HttpIo->Context
     450                       );
    446451    if (EFI_ERROR (Status)) {
    447452      return Status;
    … …  
    452457  // Store the received data into the wrapper.
    453458  //
    454   ResponseData->Status = HttpIo->RspToken.Status;
     459  ResponseData->Status      = HttpIo->RspToken.Status;
    455460  ResponseData->HeaderCount = HttpIo->RspToken.Message->HeaderCount;
    456461  ResponseData->Headers     = HttpIo->RspToken.Message->Headers;
    … …  
    473478EFI_STATUS
    474479HttpIoGetContentLength (
    475   IN     UINTN                HeaderCount,
    476   IN     EFI_HTTP_HEADER      *Headers,
    477   OUT    UINTN                *ContentLength
     480  IN     UINTN            HeaderCount,
     481  IN     EFI_HTTP_HEADER  *Headers,
     482  OUT    UINTN            *ContentLength
    478483  )
    479484{
    480   EFI_HTTP_HEADER       *Header;
     485  EFI_HTTP_HEADER  *Header;
    481486
    482487  Header = HttpFindHeader (HeaderCount, Headers, HTTP_HEADER_CONTENT_LENGTH);
    … …  
    485490  }
    486491
    487   return AsciiStrDecimalToUintnS (Header->FieldValue, (CHAR8 **) NULL, ContentLength);
     492  return AsciiStrDecimalToUintnS (Header->FieldValue, (CHAR8 **)NULL, ContentLength);
    488493}
     494
    489495/**
    490496  Send HTTP request in chunks.
    … …  
    500506EFI_STATUS
    501507HttpIoSendChunkedTransfer (
    502   IN  HTTP_IO                    *HttpIo,
    503   IN  HTTP_IO_SEND_CHUNK_PROCESS *SendChunkProcess,
    504   IN  EFI_HTTP_MESSAGE           *RequestMessage
    505 )
     508  IN  HTTP_IO                     *HttpIo,
     509  IN  HTTP_IO_SEND_CHUNK_PROCESS  *SendChunkProcess,
     510  IN  EFI_HTTP_MESSAGE            *RequestMessage
     511  )
    506512{
    507   EFI_STATUS            Status;
    508   EFI_HTTP_HEADER       *NewHeaders;
    509   EFI_HTTP_HEADER       *ContentLengthHeader;
    510   UINTN                 AddNewHeader;
    511   UINTN                 HeaderCount;
    512   CHAR8                 *MessageBody;
    513   UINTN                 MessageBodyLength;
    514   UINTN                 ChunkLength;
    515   CHAR8                 ChunkLengthStr [HTTP_IO_CHUNK_SIZE_STRING_LEN];
    516   EFI_HTTP_REQUEST_DATA *SentRequestData;
     513  EFI_STATUS             Status;
     514  EFI_HTTP_HEADER        *NewHeaders;
     515  EFI_HTTP_HEADER        *ContentLengthHeader;
     516  UINTN                  AddNewHeader;
     517  UINTN                  HeaderCount;
     518  CHAR8                  *MessageBody;
     519  UINTN                  MessageBodyLength;
     520  UINTN                  ChunkLength;
     521  CHAR8                  ChunkLengthStr[HTTP_IO_CHUNK_SIZE_STRING_LEN];
     522  EFI_HTTP_REQUEST_DATA  *SentRequestData;
    517523
    518524  AddNewHeader        = 0;
    … …  
    523529
    524530  switch (*SendChunkProcess) {
    525   case HttpIoSendChunkHeaderZeroContent:
     531    case HttpIoSendChunkHeaderZeroContent:
    526532      ContentLengthHeader = HttpFindHeader (RequestMessage->HeaderCount, RequestMessage->Headers, HTTP_HEADER_CONTENT_LENGTH);
    527533      if (ContentLengthHeader == NULL) {
    … …  
    529535      }
    530536
    531       NewHeaders = AllocateZeroPool ((RequestMessage->HeaderCount + AddNewHeader) * sizeof(EFI_HTTP_HEADER));
    532       CopyMem ((VOID*)NewHeaders, (VOID *)RequestMessage->Headers, RequestMessage->HeaderCount * sizeof (EFI_HTTP_HEADER));
     537      NewHeaders = AllocateZeroPool ((RequestMessage->HeaderCount + AddNewHeader) * sizeof (EFI_HTTP_HEADER));
     538      CopyMem ((VOID *)NewHeaders, (VOID *)RequestMessage->Headers, RequestMessage->HeaderCount * sizeof (EFI_HTTP_HEADER));
    533539      if (AddNewHeader == 0) {
    534540        //
    535541        // Override content-length to Transfer-Encoding.
    536542        //
    537         ContentLengthHeader = HttpFindHeader (RequestMessage->HeaderCount, NewHeaders, HTTP_HEADER_CONTENT_LENGTH);
    538         ContentLengthHeader->FieldName = NULL;
     543        ContentLengthHeader             = HttpFindHeader (RequestMessage->HeaderCount, NewHeaders, HTTP_HEADER_CONTENT_LENGTH);
     544        ContentLengthHeader->FieldName  = NULL;
    539545        ContentLengthHeader->FieldValue = NULL;
    540546      } else {
    541547        ContentLengthHeader = NewHeaders + RequestMessage->HeaderCount;
    542548      }
     549
    543550      HttpSetFieldNameAndValue (ContentLengthHeader, HTTP_HEADER_TRANSFER_ENCODING, HTTP_HEADER_TRANSFER_ENCODING_CHUNKED);
    544       HeaderCount = RequestMessage->HeaderCount + AddNewHeader;
     551      HeaderCount       = RequestMessage->HeaderCount + AddNewHeader;
    545552      MessageBodyLength = 0;
    546       MessageBody = NULL;
    547       SentRequestData = RequestMessage->Data.Request;
     553      MessageBody       = NULL;
     554      SentRequestData   = RequestMessage->Data.Request;
    548555      break;
    549556
    550   case HttpIoSendChunkContent:
    551       HeaderCount = 0;
    552       NewHeaders = NULL;
     557    case HttpIoSendChunkContent:
     558      HeaderCount     = 0;
     559      NewHeaders      = NULL;
    553560      SentRequestData = NULL;
    554561      if (RequestMessage->BodyLength > HTTP_IO_MAX_SEND_PAYLOAD) {
    … …  
    557564        MessageBodyLength = RequestMessage->BodyLength;
    558565      }
     566
    559567      AsciiSPrint (
    560           ChunkLengthStr,
    561           HTTP_IO_CHUNK_SIZE_STRING_LEN,
    562           "%x%c%c",
    563           MessageBodyLength,
    564           CHUNKED_TRANSFER_CODING_CR,
    565           CHUNKED_TRANSFER_CODING_LF
    566           );
     568        ChunkLengthStr,
     569        HTTP_IO_CHUNK_SIZE_STRING_LEN,
     570        "%x%c%c",
     571        MessageBodyLength,
     572        CHUNKED_TRANSFER_CODING_CR,
     573        CHUNKED_TRANSFER_CODING_LF
     574        );
    567575      ChunkLength = AsciiStrLen (ChunkLengthStr);
    568576      MessageBody = AllocatePool (ChunkLength + MessageBodyLength + 2);
    569577      if (MessageBody == NULL) {
    570         DEBUG((DEBUG_ERROR, "Not enough memory for chunk transfer\n"));
     578        DEBUG ((DEBUG_ERROR, "Not enough memory for chunk transfer\n"));
    571579        return EFI_OUT_OF_RESOURCES;
    572580      }
     581
    573582      //
    574583      // Build up the chunk transfer paylaod.
    … …  
    576585      CopyMem (MessageBody, ChunkLengthStr, ChunkLength);
    577586      CopyMem (MessageBody + ChunkLength, RequestMessage->Body, MessageBodyLength);
    578       *(MessageBody + ChunkLength + MessageBodyLength) = CHUNKED_TRANSFER_CODING_CR;
     587      *(MessageBody + ChunkLength + MessageBodyLength)     = CHUNKED_TRANSFER_CODING_CR;
    579588      *(MessageBody + ChunkLength + MessageBodyLength + 1) = CHUNKED_TRANSFER_CODING_LF;
    580589      //
    … …  
    582591      //
    583592      RequestMessage->BodyLength -= MessageBodyLength;
    584       RequestMessage->Body = (VOID *)((CHAR8 *)RequestMessage->Body + MessageBodyLength);
    585       MessageBodyLength += (ChunkLength + 2);
     593      RequestMessage->Body        = (VOID *)((CHAR8 *)RequestMessage->Body + MessageBodyLength);
     594      MessageBodyLength          += (ChunkLength + 2);
    586595      if (RequestMessage->BodyLength == 0) {
    587596        *SendChunkProcess = HttpIoSendChunkEndChunk;
    588597      }
     598
    589599      break;
    590600
    591   case HttpIoSendChunkEndChunk:
    592       HeaderCount = 0;
    593       NewHeaders = NULL;
     601    case HttpIoSendChunkEndChunk:
     602      HeaderCount     = 0;
     603      NewHeaders      = NULL;
    594604      SentRequestData = NULL;
    595605      AsciiSPrint (
    … …  
    602612        CHUNKED_TRANSFER_CODING_LF
    603613        );
    604       MessageBody = AllocatePool (AsciiStrLen(ChunkLengthStr));
     614      MessageBody = AllocatePool (AsciiStrLen (ChunkLengthStr));
    605615      if (MessageBody == NULL) {
    606         DEBUG((DEBUG_ERROR, "Not enough memory for the end chunk transfer\n"));
     616        DEBUG ((DEBUG_ERROR, "Not enough memory for the end chunk transfer\n"));
    607617        return EFI_OUT_OF_RESOURCES;
    608618      }
     619
    609620      CopyMem (MessageBody, ChunkLengthStr, AsciiStrLen (ChunkLengthStr));
    610621      MessageBodyLength = AsciiStrLen (ChunkLengthStr);
    … …  
    612623      break;
    613624
    614   default:
     625    default:
    615626      return EFI_INVALID_PARAMETER;
    616627  }
    … …  
    628639      FreePool (ContentLengthHeader->FieldName);
    629640    }
     641
    630642    if (ContentLengthHeader->FieldValue != NULL) {
    631643      FreePool (ContentLengthHeader->FieldValue);
    632644    }
    633645  }
     646
    634647  if (NewHeaders != NULL) {
    635648    FreePool (NewHeaders);
    636649  }
     650
    637651  if (MessageBody != NULL) {
    638652    FreePool (MessageBody);
    639653  }
     654
    640655  return Status;
    641656}
    … …  
    662677EFI_STATUS
    663678HttpIoGetChunkedTransferContent (
    664   IN     HTTP_IO              *HttpIo,
    665   IN     UINTN                HeaderCount,
    666   IN     EFI_HTTP_HEADER      *Headers,
    667   OUT    LIST_ENTRY           **ChunkListHead,
    668   OUT    UINTN                *ContentLength
     679  IN     HTTP_IO          *HttpIo,
     680  IN     UINTN            HeaderCount,
     681  IN     EFI_HTTP_HEADER  *Headers,
     682  OUT    LIST_ENTRY       **ChunkListHead,
     683  OUT    UINTN            *ContentLength
    669684  )
    670685{
    671   EFI_HTTP_HEADER       *Header;
    672   CHAR8                 ChunkSizeAscii [256];
    673   EFI_STATUS            Status;
    674   UINTN                 Index;
    675   HTTP_IO_RESPONSE_DATA ResponseData;
    676   UINTN                 TotalLength;
    677   UINTN                 MaxTotalLength;
    678   LIST_ENTRY            *HttpChunks;
    679   HTTP_IO_CHUNKS        *ThisChunk;
    680   LIST_ENTRY            *ThisListEntry;
    681 
    682   if (ChunkListHead == NULL || ContentLength == NULL) {
     686  EFI_HTTP_HEADER        *Header;
     687  CHAR8                  ChunkSizeAscii[256];
     688  EFI_STATUS             Status;
     689  UINTN                  Index;
     690  HTTP_IO_RESPONSE_DATA  ResponseData;
     691  UINTN                  TotalLength;
     692  UINTN                  MaxTotalLength;
     693  LIST_ENTRY             *HttpChunks;
     694  HTTP_IO_CHUNKS         *ThisChunk;
     695  LIST_ENTRY             *ThisListEntry;
     696
     697  if ((ChunkListHead == NULL) || (ContentLength == NULL)) {
    683698    return EFI_INVALID_PARAMETER;
    684699  }
    685700
    686701  *ContentLength = 0;
    687   Header = HttpFindHeader (HeaderCount, Headers, HTTP_HEADER_TRANSFER_ENCODING);
     702  Header         = HttpFindHeader (HeaderCount, Headers, HTTP_HEADER_TRANSFER_ENCODING);
    688703  if (Header == NULL) {
    689704    return EFI_NOT_FOUND;
    … …  
    693708    return EFI_NOT_FOUND;
    694709  }
     710
    695711  //
    696712  // Loop to get all chunks.
    697713  //
    698   TotalLength = 0;
     714  TotalLength    = 0;
    699715  MaxTotalLength = PcdGet32 (PcdMaxHttpChunkTransfer);
    700   HttpChunks = (LIST_ENTRY *)AllocateZeroPool (sizeof (LIST_ENTRY));
     716  HttpChunks     = (LIST_ENTRY *)AllocateZeroPool (sizeof (LIST_ENTRY));
    701717  if (HttpChunks == NULL) {
    702718    Status = EFI_OUT_OF_RESOURCES;
    703719    goto ExitDeleteChunks;
    704720  }
     721
    705722  InitializeListHead (HttpChunks);
    706723  DEBUG ((DEBUG_INFO, "     Chunked transfer\n"));
    707724  while (TRUE) {
    708     ZeroMem((VOID *)&ResponseData, sizeof(HTTP_IO_RESPONSE_DATA));
     725    ZeroMem ((VOID *)&ResponseData, sizeof (HTTP_IO_RESPONSE_DATA));
    709726    ResponseData.BodyLength = HTTP_IO_CHUNKED_TRANSFER_CODING_DATA_LENGTH;
    710     ResponseData.Body = ChunkSizeAscii;
    711     Status = HttpIoRecvResponse (
    712                HttpIo,
    713                FALSE,
    714                &ResponseData
    715                );
     727    ResponseData.Body       = ChunkSizeAscii;
     728    Status                  = HttpIoRecvResponse (
     729                                HttpIo,
     730                                FALSE,
     731                                &ResponseData
     732                                );
    716733    if (EFI_ERROR (Status)) {
    717734      goto ExitDeleteChunks;
    718735    }
     736
    719737    //
    720738    // Decoding Chunked Transfer Coding.
    … …  
    725743    // Break if this is last chunk.
    726744    //
    727     if (ChunkSizeAscii [0] == CHUNKED_TRANSFER_CODING_LAST_CHUNK) {
     745    if (ChunkSizeAscii[0] == CHUNKED_TRANSFER_CODING_LAST_CHUNK) {
    728746      //
    729747      // Check if this is a valid Last-Chunk.
    730748      //
    731       if ((ChunkSizeAscii [1] != CHUNKED_TRANSFER_CODING_CR) ||
    732           (ChunkSizeAscii [2] != CHUNKED_TRANSFER_CODING_LF)
    733           ) {
     749      if ((ChunkSizeAscii[1] != CHUNKED_TRANSFER_CODING_CR) ||
     750          (ChunkSizeAscii[2] != CHUNKED_TRANSFER_CODING_LF)
     751          )
     752      {
    734753        DEBUG ((DEBUG_ERROR, "     This is an invalid Last-chunk\n"));
    735754        Status = EFI_INVALID_PARAMETER;
    … …  
    747766      InitializeListHead (&ThisChunk->NextChunk);
    748767      ThisChunk->Length = ResponseData.BodyLength - 1 - 2; // Minus sizeof '0' and CRLF.
    749       ThisChunk->Data = (CHAR8 *)AllocatePool (ThisChunk->Length);
     768      ThisChunk->Data   = (CHAR8 *)AllocatePool (ThisChunk->Length);
    750769      if (ThisChunk->Data == NULL) {
    751770        FreePool ((UINT8 *)ThisChunk);
    … …  
    753772        goto ExitDeleteChunks;
    754773      }
     774
    755775      CopyMem ((UINT8 *)ThisChunk->Data, (UINT8 *)ResponseData.Body + 1, ThisChunk->Length);
    756776      TotalLength += ThisChunk->Length;
    … …  
    763783    //
    764784    Index = 0;
    765     while ((ChunkSizeAscii [Index] != CHUNKED_TRANSFER_CODING_EXTENSION_SEPARATOR) &&
    766            (ChunkSizeAscii [Index] != (CHAR8)CHUNKED_TRANSFER_CODING_CR) &&
    767            (Index != HTTP_IO_CHUNKED_TRANSFER_CODING_DATA_LENGTH)) {
    768       Index ++;
     785    while ((ChunkSizeAscii[Index] != CHUNKED_TRANSFER_CODING_EXTENSION_SEPARATOR) &&
     786           (ChunkSizeAscii[Index] != (CHAR8)CHUNKED_TRANSFER_CODING_CR) &&
     787           (Index != HTTP_IO_CHUNKED_TRANSFER_CODING_DATA_LENGTH))
     788    {
     789      Index++;
    769790    }
    770791
    … …  
    773794      goto ExitDeleteChunks;
    774795    }
     796
    775797    ChunkSizeAscii[Index] = 0;
    776798    AsciiStrHexToUintnS (ChunkSizeAscii, NULL, ContentLength);
    … …  
    784806      goto ExitDeleteChunks;
    785807    }
     808
    786809    ResponseData.BodyLength = *ContentLength;
    787     ResponseData.Body = (CHAR8 *)AllocatePool (*ContentLength);
     810    ResponseData.Body       = (CHAR8 *)AllocatePool (*ContentLength);
    788811    if (ResponseData.Body == NULL) {
    789812      FreePool (ThisChunk);
    … …  
    791814      goto ExitDeleteChunks;
    792815    }
     816
    793817    InitializeListHead (&ThisChunk->NextChunk);
    794818    ThisChunk->Length = *ContentLength;
    795     ThisChunk->Data = ResponseData.Body;
     819    ThisChunk->Data   = ResponseData.Body;
    796820    InsertTailList (HttpChunks, &ThisChunk->NextChunk);
    797821    Status = HttpIoRecvResponse (
    … …  
    803827      goto ExitDeleteChunks;
    804828    }
     829
    805830    //
    806831    // Read CRLF
    807832    //
    808     ZeroMem((VOID *)&ResponseData, sizeof(HTTP_IO_RESPONSE_DATA));
     833    ZeroMem ((VOID *)&ResponseData, sizeof (HTTP_IO_RESPONSE_DATA));
    809834    ResponseData.BodyLength = 2;
    810     ResponseData.Body = ChunkSizeAscii;
    811     Status = HttpIoRecvResponse (
    812                HttpIo,
    813                FALSE,
    814                &ResponseData
    815                );
     835    ResponseData.Body       = ChunkSizeAscii;
     836    Status                  = HttpIoRecvResponse (
     837                                HttpIo,
     838                                FALSE,
     839                                &ResponseData
     840                                );
    816841    if (EFI_ERROR (Status)) {
    817842      goto ExitDeleteChunks;
    818843    }
     844
    819845    //
    820846    // Verify the end of chunk payload.
    821847    //
    822     if ((ChunkSizeAscii [0] != CHUNKED_TRANSFER_CODING_CR) ||
    823         (ChunkSizeAscii [1] != CHUNKED_TRANSFER_CODING_LF)
    824        ) {
    825        DEBUG ((DEBUG_ERROR, "     This is an invalid End-of-chunk notation.\n"));
    826        goto ExitDeleteChunks;
    827     }
     848    if ((ChunkSizeAscii[0] != CHUNKED_TRANSFER_CODING_CR) ||
     849        (ChunkSizeAscii[1] != CHUNKED_TRANSFER_CODING_LF)
     850        )
     851    {
     852      DEBUG ((DEBUG_ERROR, "     This is an invalid End-of-chunk notation.\n"));
     853      goto ExitDeleteChunks;
     854    }
     855
    828856    TotalLength += *ContentLength;
    829857    if (TotalLength > MaxTotalLength) {
    830        DEBUG ((DEBUG_ERROR, "     Total chunk transfer payload exceeds the size defined by PcdMaxHttpChunkTransfer.\n"));
    831        goto ExitDeleteChunks;
     858      DEBUG ((DEBUG_ERROR, "     Total chunk transfer payload exceeds the size defined by PcdMaxHttpChunkTransfer.\n"));
     859      goto ExitDeleteChunks;
    832860    }
    833861  }
    … …  
    840868ExitDeleteChunks:
    841869  if (HttpChunks != NULL) {
    842     while (!IsListEmpty(HttpChunks)) {
     870    while (!IsListEmpty (HttpChunks)) {
    843871      ThisListEntry = GetFirstNode (HttpChunks);
    844872      RemoveEntryList (ThisListEntry);
    … …  
    847875        FreePool (ThisChunk->Data);
    848876      }
    849       FreePool(ThisListEntry);
    850     }
     877
     878      FreePool (ThisListEntry);
     879    }
     880
    851881    FreePool (HttpChunks);
    852882  }
     883
    853884  return Status;
    854885}
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette