ShellPkg/Application/Shell/ShellEnvVar.c

   1 /** @file
   2   function declarations for shell environment functions.
   3
   4   Copyright (c) 2009 - 2010, 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 <Uefi.h>
  16
  17 #include <Guid/ShellVariableGuid.h>
  18
  19 #include <Library/BaseLib.h>
  20 #include <Library/UefiRuntimeServicesTableLib.h>
  21 #include <Library/MemoryAllocationLib.h>
  22 #include <Library/DebugLib.h>
  23 #include <Library/BaseMemoryLib.h>
  24
  25 #include "ShellEnvVar.h"
  26
  27
  28 /**
  29   Reports whether an environment variable is Volatile or Non-Volatile.
  30
  31   @param EnvVarName             The name of the environment variable in question
  32
  33   @retval TRUE                  This environment variable is Volatile
  34   @retval FALSE                 This environment variable is NON-Volatile
  35 **/
  36 BOOLEAN
  37 EFIAPI
  38 IsVolatileEnv (
  39   IN CONST CHAR16 *EnvVarName
  40   )
  41 {
  42   EFI_STATUS  Status;
  43   UINTN       Size;
  44   VOID        *Buffer;
  45   UINT32      Attribs;
  46
  47   Size = 0;
  48   Buffer = NULL;
  49
  50   //
  51   // get the variable
  52   //
  53   Status = gRT->GetVariable((CHAR16*)EnvVarName,
  54                             &gShellVariableGuid,
  55                             &Attribs,
  56                             &Size,
  57                             Buffer);
  58   if (Status == EFI_BUFFER_TOO_SMALL) {
  59     Buffer = AllocatePool(Size);
  60     ASSERT(Buffer != NULL);
  61     Status = gRT->GetVariable((CHAR16*)EnvVarName,
  62                               &gShellVariableGuid,
  63                               &Attribs,
  64                               &Size,
  65                               Buffer);
  66     FreePool(Buffer);
  67   }
  68   //
  69   // not found means volatile
  70   //
  71   if (Status == EFI_NOT_FOUND) {
  72     return (TRUE);
  73   }
  74   ASSERT_EFI_ERROR(Status);
  75
  76   //
  77   // check for the Non Volatile bit
  78   //
  79   if ((Attribs & EFI_VARIABLE_NON_VOLATILE) == EFI_VARIABLE_NON_VOLATILE) {
  80     return (FALSE);
  81   }
  82
  83   //
  84   // everything else is volatile
  85   //
  86   return (TRUE);
  87 }
  88
  89 /**
  90   free function for ENV_VAR_LIST objects.
  91
  92   @param[in] List               The pointer to pointer to list.
  93 **/
  94 VOID
  95 EFIAPI
  96 FreeEnvironmentVariableList(
  97   IN LIST_ENTRY *List
  98   )
  99 {
 100   ENV_VAR_LIST *Node;
 101
 102   ASSERT (List != NULL);
 103   if (List == NULL) {
 104     return;
 105   }
 106
 107   for ( Node = (ENV_VAR_LIST*)GetFirstNode(List)
 108       ; IsListEmpty(List)
 109       ; Node = (ENV_VAR_LIST*)GetFirstNode(List)
 110      ){
 111     ASSERT(Node != NULL);
 112     RemoveEntryList(&Node->Link);
 113     if (Node->Key != NULL) {
 114       FreePool(Node->Key);
 115     }
 116     if (Node->Val != NULL) {
 117       FreePool(Node->Val);
 118     }
 119     FreePool(Node);
 120   }
 121 }
 122
 123 /**
 124   Creates a list of all Shell-Guid-based environment variables.
 125
 126   @param[in,out] ListHead       The pointer to pointer to LIST ENTRY object for
 127                                 storing this list.
 128
 129   @retval EFI_SUCCESS           the list was created sucessfully.
 130 **/
 131 EFI_STATUS
 132 EFIAPI
 133 GetEnvironmentVariableList(
 134   IN OUT LIST_ENTRY *ListHead
 135   )
 136 {
 137   CHAR16            *VariableName;
 138   UINTN             NameSize;
 139   UINT64            MaxStorSize;
 140   UINT64            RemStorSize;
 141   UINT64            MaxVarSize;
 142   EFI_STATUS        Status;
 143   EFI_GUID          Guid;
 144   UINTN             ValSize;
 145   ENV_VAR_LIST      *VarList;
 146
 147   if (ListHead == NULL) {
 148     return (EFI_INVALID_PARAMETER);
 149   }
 150
 151   Status = gRT->QueryVariableInfo(EFI_VARIABLE_NON_VOLATILE|EFI_VARIABLE_BOOTSERVICE_ACCESS, &MaxStorSize, &RemStorSize, &MaxVarSize);
 152   if (EFI_ERROR(Status)) {
 153     return (Status);
 154   }
 155
 156   NameSize = (UINTN)MaxVarSize;
 157   VariableName = AllocatePool(NameSize);
 158   if (VariableName == NULL) {
 159     return (EFI_OUT_OF_RESOURCES);
 160   }
 161   StrCpy(VariableName, L"");
 162
 163   while (!EFI_ERROR(Status)) {
 164     NameSize = (UINTN)MaxVarSize;
 165     Status = gRT->GetNextVariableName(&NameSize, VariableName, &Guid);
 166     if (Status == EFI_NOT_FOUND){
 167       Status = EFI_SUCCESS;
 168       break;
 169     }
 170     if (!EFI_ERROR(Status) && CompareGuid(&Guid, &gShellVariableGuid)){
 171       VarList = AllocateZeroPool(sizeof(ENV_VAR_LIST));
 172       ValSize = 0;
 173       Status = SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(VariableName, &VarList->Atts, &ValSize, VarList->Val);
 174       if (Status == EFI_BUFFER_TOO_SMALL){
 175         VarList->Val = AllocatePool(ValSize);
 176         ASSERT(VarList->Val != NULL);
 177         Status = SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(VariableName, &VarList->Atts, &ValSize, VarList->Val);
 178       }
 179       if (!EFI_ERROR(Status)) {
 180         VarList->Key = AllocatePool(StrSize(VariableName));
 181         ASSERT(VarList->Key != NULL);
 182         StrCpy(VarList->Key, VariableName);
 183         InsertTailList(ListHead, &VarList->Link);
 184       }
 185     } // compare guid
 186   } // while
 187   FreePool(VariableName);
 188
 189   if (EFI_ERROR(Status)) {
 190     FreeEnvironmentVariableList(ListHead);
 191   }
 192
 193   return (Status);
 194 }
 195
 196 /**
 197   Sets a list of all Shell-Guid-based environment variables.  this will
 198   also eliminate all existing shell environment variables (even if they
 199   are not on the list).
 200
 201   This function will also deallocate the memory from List.
 202
 203   @param[in] ListHead           The pointer to LIST_ENTRY from
 204                                 GetShellEnvVarList().
 205
 206   @retval EFI_SUCCESS           the list was Set sucessfully.
 207 **/
 208 EFI_STATUS
 209 EFIAPI
 210 SetEnvironmentVariableList(
 211   IN LIST_ENTRY *ListHead
 212   )
 213 {
 214   ENV_VAR_LIST      VarList;
 215   ENV_VAR_LIST      *Node;
 216   EFI_STATUS        Status;
 217   UINTN             Size;
 218
 219   InitializeListHead(&VarList.Link);
 220
 221   //
 222   // Delete all the current environment variables
 223   //
 224   Status = GetEnvironmentVariableList(&VarList.Link);
 225   ASSERT_EFI_ERROR(Status);
 226
 227   for ( Node = (ENV_VAR_LIST*)GetFirstNode(&VarList.Link)
 228       ; !IsNull(&VarList.Link, &Node->Link)
 229       ; Node = (ENV_VAR_LIST*)GetNextNode(&VarList.Link, &Node->Link)
 230      ){
 231     if (Node->Key != NULL) {
 232       Status = SHELL_DELETE_ENVIRONMENT_VARIABLE(Node->Key);
 233     }
 234     ASSERT_EFI_ERROR(Status);
 235   }
 236
 237   FreeEnvironmentVariableList(&VarList.Link);
 238
 239   //
 240   // set all the variables fron the list
 241   //
 242   for ( Node = (ENV_VAR_LIST*)GetFirstNode(ListHead)
 243       ; !IsNull(ListHead, &Node->Link)
 244       ; Node = (ENV_VAR_LIST*)GetNextNode(ListHead, &Node->Link)
 245      ){
 246     Size = StrSize(Node->Val);
 247     if (Node->Atts & EFI_VARIABLE_NON_VOLATILE) {
 248       Status = SHELL_SET_ENVIRONMENT_VARIABLE_NV(Node->Key, Size, Node->Val);
 249     } else {
 250       Status = SHELL_SET_ENVIRONMENT_VARIABLE_V (Node->Key, Size, Node->Val);
 251     }
 252     ASSERT_EFI_ERROR(Status);
 253   }
 254   FreeEnvironmentVariableList(ListHead);
 255
 256   return (Status);
 257 }
 258
 259 /**
 260   sets a list of all Shell-Guid-based environment variables.
 261
 262   @param Environment        Points to a NULL-terminated array of environment
 263                             variables with the format 'x=y', where x is the
 264                             environment variable name and y is the value.
 265
 266   @retval EFI_SUCCESS       The command executed successfully.
 267   @retval EFI_INVALID_PARAMETER The parameter is invalid.
 268   @retval EFI_OUT_OF_RESOURCES Out of resources.
 269
 270   @sa SetEnvironmentVariableList
 271 **/
 272 EFI_STATUS
 273 EFIAPI
 274 SetEnvironmentVariables(
 275   IN CONST CHAR16 **Environment
 276   )
 277 {
 278   CONST CHAR16  *CurrentString;
 279   UINTN         CurrentCount;
 280   ENV_VAR_LIST  *VarList;
 281   ENV_VAR_LIST  *Node;
 282   UINTN         NewSize;
 283
 284   VarList = NULL;
 285
 286   if (Environment == NULL) {
 287     return (EFI_INVALID_PARAMETER);
 288   }
 289
 290   //
 291   // Build a list identical to the ones used for get/set list functions above
 292   //
 293   for ( CurrentCount = 0
 294       ;
 295       ; CurrentCount++
 296      ){
 297     CurrentString = Environment[CurrentCount];
 298     if (CurrentString == NULL) {
 299       break;
 300     }
 301     ASSERT(StrStr(CurrentString, L"=") != NULL);
 302     Node = AllocatePool(sizeof(ENV_VAR_LIST));
 303     ASSERT(Node != NULL);
 304     Node->Key = AllocateZeroPool((StrStr(CurrentString, L"=") - CurrentString + 1) * sizeof(CHAR16));
 305     ASSERT(Node->Key != NULL);
 306     StrnCpy(Node->Key, CurrentString, StrStr(CurrentString, L"=") - CurrentString);
 307     NewSize = StrSize(CurrentString);
 308     NewSize -= StrLen(Node->Key) - 1;
 309     Node->Val = AllocateZeroPool(NewSize);
 310     ASSERT(Node->Val != NULL);
 311     StrCpy(Node->Val, CurrentString + StrLen(Node->Key) + 1);
 312     Node->Atts = EFI_VARIABLE_BOOTSERVICE_ACCESS;
 313
 314     if (VarList == NULL) {
 315       VarList = AllocateZeroPool(sizeof(ENV_VAR_LIST));
 316       ASSERT(VarList != NULL);
 317       InitializeListHead(&VarList->Link);
 318     }
 319     InsertTailList(&VarList->Link, &Node->Link);
 320
 321   } // for loop
 322
 323   //
 324   // set this new list as the set of all environment variables.
 325   // this function also frees the memory and deletes all pre-existing
 326   // shell-guid based environment variables.
 327   //
 328   return (SetEnvironmentVariableList(&VarList->Link));
 329 }