VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/ShellPkg/Application/Shell/ShellEnvVar.c@ 99396

Last change on this file since 99396 was 85718, checked in by vboxsync, 5 years ago

Devices/EFI: Merge edk-stable202005 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 15.3 KB
Line 
1/** @file
2 function declarations for shell environment functions.
3
4 Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>
5 SPDX-License-Identifier: BSD-2-Clause-Patent
6
7**/
8
9#include "Shell.h"
10
11#define INIT_NAME_BUFFER_SIZE 128
12#define INIT_DATA_BUFFER_SIZE 1024
13
14//
15// The list is used to cache the environment variables.
16//
17ENV_VAR_LIST gShellEnvVarList;
18
19/**
20 Reports whether an environment variable is Volatile or Non-Volatile.
21
22 @param EnvVarName The name of the environment variable in question
23 @param Volatile Return TRUE if the environment variable is volatile
24
25 @retval EFI_SUCCESS The volatile attribute is returned successfully
26 @retval others Some errors happened.
27**/
28EFI_STATUS
29IsVolatileEnv (
30 IN CONST CHAR16 *EnvVarName,
31 OUT BOOLEAN *Volatile
32 )
33{
34 EFI_STATUS Status;
35 UINTN Size;
36 VOID *Buffer;
37 UINT32 Attribs;
38
39 ASSERT (Volatile != NULL);
40
41 Size = 0;
42 Buffer = NULL;
43
44 //
45 // get the variable
46 //
47 Status = gRT->GetVariable((CHAR16*)EnvVarName,
48 &gShellVariableGuid,
49 &Attribs,
50 &Size,
51 Buffer);
52 if (Status == EFI_BUFFER_TOO_SMALL) {
53 Buffer = AllocateZeroPool(Size);
54 if (Buffer == NULL) {
55 return EFI_OUT_OF_RESOURCES;
56 }
57 Status = gRT->GetVariable((CHAR16*)EnvVarName,
58 &gShellVariableGuid,
59 &Attribs,
60 &Size,
61 Buffer);
62 FreePool(Buffer);
63 }
64 //
65 // not found means volatile
66 //
67 if (Status == EFI_NOT_FOUND) {
68 *Volatile = TRUE;
69 return EFI_SUCCESS;
70 }
71 if (EFI_ERROR (Status)) {
72 return Status;
73 }
74
75 //
76 // check for the Non Volatile bit
77 //
78 *Volatile = !(BOOLEAN) ((Attribs & EFI_VARIABLE_NON_VOLATILE) == EFI_VARIABLE_NON_VOLATILE);
79 return EFI_SUCCESS;
80}
81
82/**
83 free function for ENV_VAR_LIST objects.
84
85 @param[in] List The pointer to pointer to list.
86**/
87VOID
88FreeEnvironmentVariableList(
89 IN LIST_ENTRY *List
90 )
91{
92 ENV_VAR_LIST *Node;
93
94 ASSERT (List != NULL);
95 if (List == NULL) {
96 return;
97 }
98
99 for ( Node = (ENV_VAR_LIST*)GetFirstNode(List)
100 ; !IsListEmpty(List)
101 ; Node = (ENV_VAR_LIST*)GetFirstNode(List)
102 ){
103 ASSERT(Node != NULL);
104 RemoveEntryList(&Node->Link);
105 if (Node->Key != NULL) {
106 FreePool(Node->Key);
107 }
108 if (Node->Val != NULL) {
109 FreePool(Node->Val);
110 }
111 FreePool(Node);
112 }
113}
114
115/**
116 Creates a list of all Shell-Guid-based environment variables.
117
118 @param[in, out] ListHead The pointer to pointer to LIST ENTRY object for
119 storing this list.
120
121 @retval EFI_SUCCESS the list was created successfully.
122**/
123EFI_STATUS
124GetEnvironmentVariableList(
125 IN OUT LIST_ENTRY *ListHead
126 )
127{
128 CHAR16 *VariableName;
129 UINTN NameSize;
130 UINTN NameBufferSize;
131 EFI_STATUS Status;
132 EFI_GUID Guid;
133 UINTN ValSize;
134 UINTN ValBufferSize;
135 ENV_VAR_LIST *VarList;
136
137 if (ListHead == NULL) {
138 return (EFI_INVALID_PARAMETER);
139 }
140
141 Status = EFI_SUCCESS;
142
143 ValBufferSize = INIT_DATA_BUFFER_SIZE;
144 NameBufferSize = INIT_NAME_BUFFER_SIZE;
145 VariableName = AllocateZeroPool(NameBufferSize);
146 if (VariableName == NULL) {
147 return (EFI_OUT_OF_RESOURCES);
148 }
149 *VariableName = CHAR_NULL;
150
151 while (!EFI_ERROR(Status)) {
152 NameSize = NameBufferSize;
153 Status = gRT->GetNextVariableName(&NameSize, VariableName, &Guid);
154 if (Status == EFI_NOT_FOUND){
155 Status = EFI_SUCCESS;
156 break;
157 } else if (Status == EFI_BUFFER_TOO_SMALL) {
158 NameBufferSize = NameSize > NameBufferSize * 2 ? NameSize : NameBufferSize * 2;
159 SHELL_FREE_NON_NULL(VariableName);
160 VariableName = AllocateZeroPool(NameBufferSize);
161 if (VariableName == NULL) {
162 Status = EFI_OUT_OF_RESOURCES;
163 break;
164 }
165 NameSize = NameBufferSize;
166 Status = gRT->GetNextVariableName(&NameSize, VariableName, &Guid);
167 }
168
169 if (!EFI_ERROR(Status) && CompareGuid(&Guid, &gShellVariableGuid)){
170 VarList = AllocateZeroPool(sizeof(ENV_VAR_LIST));
171 if (VarList == NULL) {
172 Status = EFI_OUT_OF_RESOURCES;
173 } else {
174 ValSize = ValBufferSize;
175 //
176 // We need another CHAR16 to save '\0' in VarList->Val.
177 //
178 VarList->Val = AllocateZeroPool (ValSize + sizeof (CHAR16));
179 if (VarList->Val == NULL) {
180 SHELL_FREE_NON_NULL(VarList);
181 Status = EFI_OUT_OF_RESOURCES;
182 break;
183 }
184 Status = SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(VariableName, &VarList->Atts, &ValSize, VarList->Val);
185 if (Status == EFI_BUFFER_TOO_SMALL){
186 ValBufferSize = ValSize > ValBufferSize * 2 ? ValSize : ValBufferSize * 2;
187 SHELL_FREE_NON_NULL (VarList->Val);
188 //
189 // We need another CHAR16 to save '\0' in VarList->Val.
190 //
191 VarList->Val = AllocateZeroPool (ValBufferSize + sizeof (CHAR16));
192 if (VarList->Val == NULL) {
193 SHELL_FREE_NON_NULL(VarList);
194 Status = EFI_OUT_OF_RESOURCES;
195 break;
196 }
197
198 ValSize = ValBufferSize;
199 Status = SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(VariableName, &VarList->Atts, &ValSize, VarList->Val);
200 }
201 if (!EFI_ERROR(Status)) {
202 VarList->Key = AllocateCopyPool(StrSize(VariableName), VariableName);
203 if (VarList->Key == NULL) {
204 SHELL_FREE_NON_NULL(VarList->Val);
205 SHELL_FREE_NON_NULL(VarList);
206 Status = EFI_OUT_OF_RESOURCES;
207 } else {
208 InsertTailList(ListHead, &VarList->Link);
209 }
210 } else {
211 SHELL_FREE_NON_NULL(VarList->Val);
212 SHELL_FREE_NON_NULL(VarList);
213 }
214 } // if (VarList == NULL) ... else ...
215 } // compare guid
216 } // while
217 SHELL_FREE_NON_NULL (VariableName);
218
219 if (EFI_ERROR(Status)) {
220 FreeEnvironmentVariableList(ListHead);
221 }
222
223 return (Status);
224}
225
226/**
227 Sets a list of all Shell-Guid-based environment variables. this will
228 also eliminate all existing shell environment variables (even if they
229 are not on the list).
230
231 This function will also deallocate the memory from List.
232
233 @param[in] ListHead The pointer to LIST_ENTRY from
234 GetShellEnvVarList().
235
236 @retval EFI_SUCCESS the list was Set successfully.
237**/
238EFI_STATUS
239SetEnvironmentVariableList(
240 IN LIST_ENTRY *ListHead
241 )
242{
243 ENV_VAR_LIST VarList;
244 ENV_VAR_LIST *Node;
245 EFI_STATUS Status;
246 UINTN Size;
247
248 InitializeListHead(&VarList.Link);
249
250 //
251 // Delete all the current environment variables
252 //
253 Status = GetEnvironmentVariableList(&VarList.Link);
254 ASSERT_EFI_ERROR(Status);
255
256 for ( Node = (ENV_VAR_LIST*)GetFirstNode(&VarList.Link)
257 ; !IsNull(&VarList.Link, &Node->Link)
258 ; Node = (ENV_VAR_LIST*)GetNextNode(&VarList.Link, &Node->Link)
259 ){
260 if (Node->Key != NULL) {
261 Status = SHELL_DELETE_ENVIRONMENT_VARIABLE(Node->Key);
262 }
263 ASSERT_EFI_ERROR(Status);
264 }
265
266 FreeEnvironmentVariableList(&VarList.Link);
267
268 //
269 // set all the variables from the list
270 //
271 for ( Node = (ENV_VAR_LIST*)GetFirstNode(ListHead)
272 ; !IsNull(ListHead, &Node->Link)
273 ; Node = (ENV_VAR_LIST*)GetNextNode(ListHead, &Node->Link)
274 ){
275 Size = StrSize (Node->Val) - sizeof (CHAR16);
276 if (Node->Atts & EFI_VARIABLE_NON_VOLATILE) {
277 Status = SHELL_SET_ENVIRONMENT_VARIABLE_NV(Node->Key, Size, Node->Val);
278 } else {
279 Status = SHELL_SET_ENVIRONMENT_VARIABLE_V (Node->Key, Size, Node->Val);
280 }
281 ASSERT_EFI_ERROR(Status);
282 }
283 FreeEnvironmentVariableList(ListHead);
284
285 return (Status);
286}
287
288/**
289 sets a list of all Shell-Guid-based environment variables.
290
291 @param Environment Points to a NULL-terminated array of environment
292 variables with the format 'x=y', where x is the
293 environment variable name and y is the value.
294
295 @retval EFI_SUCCESS The command executed successfully.
296 @retval EFI_INVALID_PARAMETER The parameter is invalid.
297 @retval EFI_OUT_OF_RESOURCES Out of resources.
298
299 @sa SetEnvironmentVariableList
300**/
301EFI_STATUS
302SetEnvironmentVariables(
303 IN CONST CHAR16 **Environment
304 )
305{
306 CONST CHAR16 *CurrentString;
307 UINTN CurrentCount;
308 ENV_VAR_LIST *VarList;
309 ENV_VAR_LIST *Node;
310
311 VarList = NULL;
312
313 if (Environment == NULL) {
314 return (EFI_INVALID_PARAMETER);
315 }
316
317 //
318 // Build a list identical to the ones used for get/set list functions above
319 //
320 for ( CurrentCount = 0
321 ;
322 ; CurrentCount++
323 ){
324 CurrentString = Environment[CurrentCount];
325 if (CurrentString == NULL) {
326 break;
327 }
328 ASSERT(StrStr(CurrentString, L"=") != NULL);
329 Node = AllocateZeroPool(sizeof(ENV_VAR_LIST));
330 if (Node == NULL) {
331 SetEnvironmentVariableList(&VarList->Link);
332 return (EFI_OUT_OF_RESOURCES);
333 }
334
335 Node->Key = AllocateZeroPool((StrStr(CurrentString, L"=") - CurrentString + 1) * sizeof(CHAR16));
336 if (Node->Key == NULL) {
337 SHELL_FREE_NON_NULL(Node);
338 SetEnvironmentVariableList(&VarList->Link);
339 return (EFI_OUT_OF_RESOURCES);
340 }
341
342 //
343 // Copy the string into the Key, leaving the last character allocated as NULL to terminate
344 //
345 StrnCpyS( Node->Key,
346 StrStr(CurrentString, L"=") - CurrentString + 1,
347 CurrentString,
348 StrStr(CurrentString, L"=") - CurrentString
349 );
350
351 //
352 // ValueSize = TotalSize - already removed size - size for '=' + size for terminator (the last 2 items cancel each other)
353 //
354 Node->Val = AllocateCopyPool(StrSize(CurrentString) - StrSize(Node->Key), CurrentString + StrLen(Node->Key) + 1);
355 if (Node->Val == NULL) {
356 SHELL_FREE_NON_NULL(Node->Key);
357 SHELL_FREE_NON_NULL(Node);
358 SetEnvironmentVariableList(&VarList->Link);
359 return (EFI_OUT_OF_RESOURCES);
360 }
361
362 Node->Atts = EFI_VARIABLE_BOOTSERVICE_ACCESS;
363
364 if (VarList == NULL) {
365 VarList = AllocateZeroPool(sizeof(ENV_VAR_LIST));
366 if (VarList == NULL) {
367 SHELL_FREE_NON_NULL(Node->Key);
368 SHELL_FREE_NON_NULL(Node->Val);
369 SHELL_FREE_NON_NULL(Node);
370 return (EFI_OUT_OF_RESOURCES);
371 }
372 InitializeListHead(&VarList->Link);
373 }
374 InsertTailList(&VarList->Link, &Node->Link);
375
376 } // for loop
377
378 //
379 // set this new list as the set of all environment variables.
380 // this function also frees the memory and deletes all pre-existing
381 // shell-guid based environment variables.
382 //
383 return (SetEnvironmentVariableList(&VarList->Link));
384}
385
386/**
387 Find an environment variable in the gShellEnvVarList.
388
389 @param Key The name of the environment variable.
390 @param Value The value of the environment variable, the buffer
391 shoule be freed by the caller.
392 @param ValueSize The size in bytes of the environment variable
393 including the tailing CHAR_NELL.
394 @param Atts The attributes of the variable.
395
396 @retval EFI_SUCCESS The command executed successfully.
397 @retval EFI_NOT_FOUND The environment variable is not found in
398 gShellEnvVarList.
399
400**/
401EFI_STATUS
402ShellFindEnvVarInList (
403 IN CONST CHAR16 *Key,
404 OUT CHAR16 **Value,
405 OUT UINTN *ValueSize,
406 OUT UINT32 *Atts OPTIONAL
407 )
408{
409 ENV_VAR_LIST *Node;
410
411 if (Key == NULL || Value == NULL || ValueSize == NULL) {
412 return SHELL_INVALID_PARAMETER;
413 }
414
415 for ( Node = (ENV_VAR_LIST*)GetFirstNode(&gShellEnvVarList.Link)
416 ; !IsNull(&gShellEnvVarList.Link, &Node->Link)
417 ; Node = (ENV_VAR_LIST*)GetNextNode(&gShellEnvVarList.Link, &Node->Link)
418 ){
419 if (Node->Key != NULL && StrCmp(Key, Node->Key) == 0) {
420 *Value = AllocateCopyPool(StrSize(Node->Val), Node->Val);
421 *ValueSize = StrSize(Node->Val);
422 if (Atts != NULL) {
423 *Atts = Node->Atts;
424 }
425 return EFI_SUCCESS;
426 }
427 }
428
429 return EFI_NOT_FOUND;
430}
431
432/**
433 Add an environment variable into gShellEnvVarList.
434
435 @param Key The name of the environment variable.
436 @param Value The value of environment variable.
437 @param ValueSize The size in bytes of the environment variable
438 including the tailing CHAR_NULL
439 @param Atts The attributes of the variable.
440
441 @retval EFI_SUCCESS The environment variable was added to list successfully.
442 @retval others Some errors happened.
443
444**/
445EFI_STATUS
446ShellAddEnvVarToList (
447 IN CONST CHAR16 *Key,
448 IN CONST CHAR16 *Value,
449 IN UINTN ValueSize,
450 IN UINT32 Atts
451 )
452{
453 ENV_VAR_LIST *Node;
454 CHAR16 *LocalKey;
455 CHAR16 *LocalValue;
456
457 if (Key == NULL || Value == NULL || ValueSize == 0) {
458 return EFI_INVALID_PARAMETER;
459 }
460
461 LocalValue = AllocateCopyPool (ValueSize, Value);
462 if (LocalValue == NULL) {
463 return EFI_OUT_OF_RESOURCES;
464 }
465
466 //
467 // Update the variable value if it exists in gShellEnvVarList.
468 //
469 for ( Node = (ENV_VAR_LIST*)GetFirstNode(&gShellEnvVarList.Link)
470 ; !IsNull(&gShellEnvVarList.Link, &Node->Link)
471 ; Node = (ENV_VAR_LIST*)GetNextNode(&gShellEnvVarList.Link, &Node->Link)
472 ){
473 if (Node->Key != NULL && StrCmp(Key, Node->Key) == 0) {
474 Node->Atts = Atts;
475 SHELL_FREE_NON_NULL(Node->Val);
476 Node->Val = LocalValue;
477 return EFI_SUCCESS;
478 }
479 }
480
481 //
482 // If the environment variable key doesn't exist in list just insert
483 // a new node.
484 //
485 LocalKey = AllocateCopyPool (StrSize(Key), Key);
486 if (LocalKey == NULL) {
487 FreePool (LocalValue);
488 return EFI_OUT_OF_RESOURCES;
489 }
490 Node = (ENV_VAR_LIST*)AllocateZeroPool (sizeof(ENV_VAR_LIST));
491 if (Node == NULL) {
492 FreePool (LocalKey);
493 FreePool (LocalValue);
494 return EFI_OUT_OF_RESOURCES;
495 }
496 Node->Key = LocalKey;
497 Node->Val = LocalValue;
498 Node->Atts = Atts;
499 InsertTailList(&gShellEnvVarList.Link, &Node->Link);
500
501 return EFI_SUCCESS;
502}
503
504/**
505 Remove a specified environment variable in gShellEnvVarList.
506
507 @param Key The name of the environment variable.
508
509 @retval EFI_SUCCESS The command executed successfully.
510 @retval EFI_NOT_FOUND The environment variable is not found in
511 gShellEnvVarList.
512**/
513EFI_STATUS
514ShellRemvoeEnvVarFromList (
515 IN CONST CHAR16 *Key
516 )
517{
518 ENV_VAR_LIST *Node;
519
520 if (Key == NULL) {
521 return EFI_INVALID_PARAMETER;
522 }
523
524 for ( Node = (ENV_VAR_LIST*)GetFirstNode(&gShellEnvVarList.Link)
525 ; !IsNull(&gShellEnvVarList.Link, &Node->Link)
526 ; Node = (ENV_VAR_LIST*)GetNextNode(&gShellEnvVarList.Link, &Node->Link)
527 ){
528 if (Node->Key != NULL && StrCmp(Key, Node->Key) == 0) {
529 SHELL_FREE_NON_NULL(Node->Key);
530 SHELL_FREE_NON_NULL(Node->Val);
531 RemoveEntryList(&Node->Link);
532 SHELL_FREE_NON_NULL(Node);
533 return EFI_SUCCESS;
534 }
535 }
536
537 return EFI_NOT_FOUND;
538}
539
540/**
541 Initialize the gShellEnvVarList and cache all Shell-Guid-based environment
542 variables.
543
544**/
545EFI_STATUS
546ShellInitEnvVarList (
547 VOID
548 )
549{
550 EFI_STATUS Status;
551
552 InitializeListHead(&gShellEnvVarList.Link);
553 Status = GetEnvironmentVariableList (&gShellEnvVarList.Link);
554
555 return Status;
556}
557
558/**
559 Destructe the gShellEnvVarList.
560
561**/
562VOID
563ShellFreeEnvVarList (
564 VOID
565 )
566{
567 FreeEnvironmentVariableList (&gShellEnvVarList.Link);
568 InitializeListHead(&gShellEnvVarList.Link);
569
570 return;
571}
572
Note: See TracBrowser for help on using the repository browser.

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