NetworkPkg/HttpUtilitiesDxe/HttpUtilitiesProtocol.c

   1 /** @file
   2   Implementation of EFI_HTTP_PROTOCOL protocol interfaces.
   3
   4   Copyright (c) 2015 - 2018, 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 "HttpUtilitiesDxe.h"
  17
  18 EFI_HTTP_UTILITIES_PROTOCOL mHttpUtilitiesProtocol = {
  19   HttpUtilitiesBuild,
  20   HttpUtilitiesParse
  21 };
  22
  23
  24 /**
  25   Create HTTP header based on a combination of seed header, fields
  26   to delete, and fields to append.
  27
  28   The Build() function is used to manage the headers portion of an
  29   HTTP message by providing the ability to add, remove, or replace
  30   HTTP headers.
  31
  32   @param[in]  This                Pointer to EFI_HTTP_UTILITIES_PROTOCOL instance.
  33   @param[in]  SeedMessageSize     Size of the initial HTTP header. This can be zero.
  34   @param[in]  SeedMessage         Initial HTTP header to be used as a base for
  35                                   building a new HTTP header. If NULL,
  36                                   SeedMessageSize is ignored.
  37   @param[in]  DeleteCount         Number of null-terminated HTTP header field names
  38                                   in DeleteList.
  39   @param[in]  DeleteList          List of null-terminated HTTP header field names to
  40                                   remove from SeedMessage. Only the field names are
  41                                   in this list because the field values are irrelevant
  42                                   to this operation.
  43   @param[in]  AppendCount         Number of header fields in AppendList.
  44   @param[in]  AppendList          List of HTTP headers to populate NewMessage with.
  45                                   If SeedMessage is not NULL, AppendList will be
  46                                   appended to the existing list from SeedMessage in
  47                                   NewMessage.
  48   @param[out] NewMessageSize      Pointer to number of header fields in NewMessage.
  49   @param[out] NewMessage          Pointer to a new list of HTTP headers based on.
  50
  51   @retval EFI_SUCCESS             Add, remove, and replace operations succeeded.
  52   @retval EFI_OUT_OF_RESOURCES    Could not allocate memory for NewMessage.
  53   @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
  54                                   This is NULL.
  55 **/
  56 EFI_STATUS
  57 EFIAPI
  58 HttpUtilitiesBuild (
  59   IN     EFI_HTTP_UTILITIES_PROTOCOL *This,
  60   IN     UINTN                       SeedMessageSize,
  61   IN     VOID                        *SeedMessage, OPTIONAL
  62   IN     UINTN                       DeleteCount,
  63   IN     CHAR8                       *DeleteList[], OPTIONAL
  64   IN     UINTN                       AppendCount,
  65   IN     EFI_HTTP_HEADER             *AppendList[], OPTIONAL
  66      OUT UINTN                       *NewMessageSize,
  67      OUT VOID                        **NewMessage
  68   )
  69 {
  70   EFI_STATUS                Status;
  71   EFI_HTTP_HEADER           *SeedHeaderFields;
  72   UINTN                     SeedFieldCount;
  73   UINTN                     Index;
  74   EFI_HTTP_HEADER           *TempHeaderFields;
  75   UINTN                     TempFieldCount;
  76   EFI_HTTP_HEADER           *NewHeaderFields;
  77   UINTN                     NewFieldCount;
  78   EFI_HTTP_HEADER           *HttpHeader;
  79   UINTN                     StrLength;
  80   UINT8                     *NewMessagePtr;
  81
  82   SeedHeaderFields = NULL;
  83   SeedFieldCount   = 0;
  84   TempHeaderFields = NULL;
  85   TempFieldCount   = 0;
  86   NewHeaderFields  = NULL;
  87   NewFieldCount    = 0;
  88
  89   HttpHeader       = NULL;
  90   StrLength        = 0;
  91   NewMessagePtr    = NULL;
  92   *NewMessageSize  = 0;
  93   Status           = EFI_SUCCESS;
  94
  95   if (This == NULL) {
  96     return EFI_INVALID_PARAMETER;
  97   }
  98
  99   if (SeedMessage != NULL) {
 100     Status = This->Parse (
 101                      This,
 102                      SeedMessage,
 103                      SeedMessageSize,
 104                      &SeedHeaderFields,
 105                      &SeedFieldCount
 106                      );
 107     if (EFI_ERROR (Status)) {
 108       goto ON_EXIT;
 109     }
 110   }
 111
 112   //
 113   // Handle DeleteList
 114   //
 115   if (SeedFieldCount != 0 && DeleteCount != 0) {
 116     TempHeaderFields = AllocateZeroPool (SeedFieldCount * sizeof(EFI_HTTP_HEADER));
 117     if (TempHeaderFields == NULL) {
 118       Status = EFI_OUT_OF_RESOURCES;
 119       goto ON_EXIT;
 120     }
 121
 122     for (Index = 0, TempFieldCount = 0; Index < SeedFieldCount; Index++) {
 123       //
 124       // Check whether each SeedHeaderFields member is in DeleteList
 125       //
 126       if (HttpIsValidHttpHeader( DeleteList, DeleteCount, SeedHeaderFields[Index].FieldName)) {
 127         Status = HttpSetFieldNameAndValue (
 128                    &TempHeaderFields[TempFieldCount],
 129                    SeedHeaderFields[Index].FieldName,
 130                    SeedHeaderFields[Index].FieldValue
 131                    );
 132         if (EFI_ERROR (Status)) {
 133           goto ON_EXIT;
 134         }
 135         TempFieldCount++;
 136       }
 137     }
 138   } else {
 139     TempHeaderFields = SeedHeaderFields;
 140     TempFieldCount = SeedFieldCount;
 141   }
 142
 143   //
 144   // Handle AppendList
 145   //
 146   NewHeaderFields = AllocateZeroPool ((TempFieldCount + AppendCount) * sizeof (EFI_HTTP_HEADER));
 147   if (NewHeaderFields == NULL) {
 148     Status = EFI_OUT_OF_RESOURCES;
 149     goto ON_EXIT;
 150   }
 151
 152   for (Index = 0; Index < TempFieldCount; Index++) {
 153     Status = HttpSetFieldNameAndValue (
 154                &NewHeaderFields[Index],
 155                TempHeaderFields[Index].FieldName,
 156                TempHeaderFields[Index].FieldValue
 157                );
 158     if (EFI_ERROR (Status)) {
 159       goto ON_EXIT;
 160     }
 161   }
 162
 163   NewFieldCount = TempFieldCount;
 164
 165   for (Index = 0; Index < AppendCount; Index++) {
 166     HttpHeader = HttpFindHeader (NewFieldCount, NewHeaderFields, AppendList[Index]->FieldName);
 167     if (HttpHeader != NULL) {
 168       Status = HttpSetFieldNameAndValue (
 169                  HttpHeader,
 170                  AppendList[Index]->FieldName,
 171                  AppendList[Index]->FieldValue
 172                  );
 173       if (EFI_ERROR (Status)) {
 174         goto ON_EXIT;
 175       }
 176     } else {
 177       Status = HttpSetFieldNameAndValue (
 178                  &NewHeaderFields[NewFieldCount],
 179                  AppendList[Index]->FieldName,
 180                  AppendList[Index]->FieldValue
 181                  );
 182       if (EFI_ERROR (Status)) {
 183         goto ON_EXIT;
 184       }
 185       NewFieldCount++;
 186     }
 187   }
 188
 189   //
 190   // Calculate NewMessageSize, then build NewMessage
 191   //
 192   for (Index = 0; Index < NewFieldCount; Index++) {
 193     HttpHeader = &NewHeaderFields[Index];
 194
 195     StrLength = AsciiStrLen (HttpHeader->FieldName);
 196     *NewMessageSize += StrLength;
 197
 198     StrLength = sizeof(": ") - 1;
 199     *NewMessageSize += StrLength;
 200
 201     StrLength = AsciiStrLen (HttpHeader->FieldValue);
 202     *NewMessageSize += StrLength;
 203
 204     StrLength = sizeof("\r\n") - 1;
 205     *NewMessageSize += StrLength;
 206   }
 207   StrLength = sizeof("\r\n") - 1;
 208   *NewMessageSize += StrLength;
 209
 210   *NewMessage = AllocateZeroPool (*NewMessageSize);
 211   if (*NewMessage == NULL) {
 212     Status = EFI_OUT_OF_RESOURCES;
 213     goto ON_EXIT;
 214   }
 215
 216   NewMessagePtr = (UINT8 *)(*NewMessage);
 217
 218   for (Index = 0; Index < NewFieldCount; Index++) {
 219     HttpHeader = &NewHeaderFields[Index];
 220
 221     StrLength = AsciiStrLen (HttpHeader->FieldName);
 222     CopyMem (NewMessagePtr, HttpHeader->FieldName, StrLength);
 223     NewMessagePtr += StrLength;
 224
 225     StrLength = sizeof(": ") - 1;
 226     CopyMem (NewMessagePtr, ": ", StrLength);
 227     NewMessagePtr += StrLength;
 228
 229     StrLength = AsciiStrLen (HttpHeader->FieldValue);
 230     CopyMem (NewMessagePtr, HttpHeader->FieldValue, StrLength);
 231     NewMessagePtr += StrLength;
 232
 233     StrLength = sizeof("\r\n") - 1;
 234     CopyMem (NewMessagePtr, "\r\n", StrLength);
 235     NewMessagePtr += StrLength;
 236   }
 237   StrLength = sizeof("\r\n") - 1;
 238   CopyMem (NewMessagePtr, "\r\n", StrLength);
 239   NewMessagePtr += StrLength;
 240
 241   ASSERT (*NewMessageSize == (UINTN)NewMessagePtr - (UINTN)(*NewMessage));
 242
 243   //
 244   // Free allocated buffer
 245   //
 246 ON_EXIT:
 247   if (SeedHeaderFields != NULL) {
 248     HttpFreeHeaderFields(SeedHeaderFields, SeedFieldCount);
 249   }
 250
 251   if (TempHeaderFields != NULL) {
 252     HttpFreeHeaderFields(TempHeaderFields, TempFieldCount);
 253   }
 254
 255   if (NewHeaderFields != NULL) {
 256     HttpFreeHeaderFields(NewHeaderFields, NewFieldCount);
 257   }
 258
 259   return Status;
 260 }
 261
 262
 263 /**
 264   Parses HTTP header and produces an array of key/value pairs.
 265
 266   The Parse() function is used to transform data stored in HttpHeader
 267   into a list of fields paired with their corresponding values.
 268
 269   @param[in]  This                Pointer to EFI_HTTP_UTILITIES_PROTOCOL instance.
 270   @param[in]  HttpMessage         Contains raw unformatted HTTP header string.
 271   @param[in]  HttpMessageSize     Size of HTTP header.
 272   @param[out] HeaderFields        Array of key/value header pairs.
 273   @param[out] FieldCount          Number of headers in HeaderFields.
 274
 275   @retval EFI_SUCCESS             Allocation succeeded.
 276   @retval EFI_NOT_STARTED         This EFI HTTP Protocol instance has not been
 277                                   initialized.
 278   @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
 279                                   This is NULL.
 280                                   HttpMessage is NULL.
 281                                   HeaderFields is NULL.
 282                                   FieldCount is NULL.
 283 **/
 284 EFI_STATUS
 285 EFIAPI
 286 HttpUtilitiesParse (
 287   IN  EFI_HTTP_UTILITIES_PROTOCOL  *This,
 288   IN  CHAR8                        *HttpMessage,
 289   IN  UINTN                        HttpMessageSize,
 290   OUT EFI_HTTP_HEADER              **HeaderFields,
 291   OUT UINTN                        *FieldCount
 292   )
 293 {
 294   EFI_STATUS                Status;
 295   CHAR8                     *TempHttpMessage;
 296   CHAR8                     *Token;
 297   CHAR8                     *NextToken;
 298   CHAR8                     *FieldName;
 299   CHAR8                     *FieldValue;
 300   UINTN                     Index;
 301   UINTN                     HttpBufferSize;
 302
 303   Status          = EFI_SUCCESS;
 304   TempHttpMessage = NULL;
 305   Token           = NULL;
 306   NextToken       = NULL;
 307   FieldName       = NULL;
 308   FieldValue      = NULL;
 309   Index           = 0;
 310
 311   if (This == NULL || HttpMessage == NULL || HeaderFields == NULL || FieldCount == NULL) {
 312     return EFI_INVALID_PARAMETER;
 313   }
 314
 315   //
 316   // Append the http response string along with a Null-terminator.
 317   //
 318   HttpBufferSize = HttpMessageSize + 1;
 319   TempHttpMessage = AllocatePool (HttpBufferSize);
 320   if (TempHttpMessage == NULL) {
 321     return EFI_OUT_OF_RESOURCES;
 322   }
 323
 324   CopyMem (TempHttpMessage, HttpMessage, HttpMessageSize);
 325   *(TempHttpMessage + HttpMessageSize) = '\0';
 326
 327   //
 328   // Get header number
 329   //
 330   *FieldCount = 0;
 331   Token = TempHttpMessage;
 332   while (TRUE) {
 333     FieldName     = NULL;
 334     FieldValue    = NULL;
 335     NextToken = HttpGetFieldNameAndValue (Token, &FieldName, &FieldValue);
 336     Token     = NextToken;
 337     if (FieldName == NULL || FieldValue == NULL) {
 338       break;
 339     }
 340
 341     (*FieldCount)++;
 342   }
 343
 344   if (*FieldCount == 0) {
 345     Status =  EFI_INVALID_PARAMETER;
 346     goto ON_EXIT;
 347   }
 348
 349   //
 350   // Allocate buffer for header
 351   //
 352   *HeaderFields = AllocateZeroPool ((*FieldCount) * sizeof(EFI_HTTP_HEADER));
 353   if (*HeaderFields == NULL) {
 354     *FieldCount = 0;
 355     Status = EFI_OUT_OF_RESOURCES;
 356     goto ON_EXIT;
 357   }
 358
 359   CopyMem (TempHttpMessage, HttpMessage, HttpMessageSize);
 360
 361   //
 362   // Set Field and Value to each header
 363   //
 364   Token = TempHttpMessage;
 365   while (Index < *FieldCount) {
 366     FieldName     = NULL;
 367     FieldValue    = NULL;
 368     NextToken = HttpGetFieldNameAndValue (Token, &FieldName, &FieldValue);
 369     Token     = NextToken;
 370     if (FieldName == NULL || FieldValue == NULL) {
 371       break;
 372     }
 373
 374     Status = HttpSetFieldNameAndValue (&(*HeaderFields)[Index], FieldName, FieldValue);
 375     if (EFI_ERROR (Status)) {
 376       *FieldCount = 0;
 377       HttpFreeHeaderFields (*HeaderFields, Index);
 378       goto ON_EXIT;
 379     }
 380
 381     Index++;
 382   }
 383
 384   //
 385   // Free allocated buffer
 386   //
 387 ON_EXIT:
 388   if (TempHttpMessage != NULL) {
 389     FreePool (TempHttpMessage);
 390   }
 391
 392   return Status;
 393 }