]> git.proxmox.com Git - mirror_edk2.git/blob - ShellPkg/Library/UefiShellDebug1CommandsLib/DmpStore.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ShellPkg: Refine type cast for pointer subtraction
[mirror_edk2.git] / ShellPkg / Library / UefiShellDebug1CommandsLib / DmpStore.c
1 /** @file
2 Main file for DmpStore shell Debug1 function.
3
4 (C) Copyright 2013-2015 Hewlett-Packard Development Company, L.P.<BR>
5 Copyright (c) 2005 - 2017, Intel Corporation. All rights reserved.<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 "UefiShellDebug1CommandsLib.h"
17
18 typedef enum {
19 DmpStoreDisplay,
20 DmpStoreDelete,
21 DmpStoreSave,
22 DmpStoreLoad
23 } DMP_STORE_TYPE;
24
25 typedef struct {
26 UINT32 Signature;
27 CHAR16 *Name;
28 EFI_GUID Guid;
29 UINT32 Attributes;
30 UINT32 DataSize;
31 UINT8 *Data;
32 LIST_ENTRY Link;
33 } DMP_STORE_VARIABLE;
34
35 #define DMP_STORE_VARIABLE_SIGNATURE SIGNATURE_32 ('_', 'd', 's', 's')
36
37 /**
38 Base on the input attribute value to return the attribute string.
39
40 @param[in] Atts The input attribute value
41
42 @retval The attribute string info.
43 **/
44 CHAR16 *
45 GetAttrType (
46 IN CONST UINT32 Atts
47 )
48 {
49 UINTN BufLen;
50 CHAR16 *RetString;
51
52 BufLen = 0;
53 RetString = NULL;
54
55 if ((Atts & EFI_VARIABLE_NON_VOLATILE) != 0) {
56 StrnCatGrow (&RetString, &BufLen, L"+NV", 0);
57 }
58 if ((Atts & EFI_VARIABLE_RUNTIME_ACCESS) != 0) {
59 StrnCatGrow (&RetString, &BufLen, L"+RT+BS", 0);
60 } else if ((Atts & EFI_VARIABLE_BOOTSERVICE_ACCESS) != 0) {
61 StrnCatGrow (&RetString, &BufLen, L"+BS", 0);
62 }
63 if ((Atts & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0) {
64 StrnCatGrow (&RetString, &BufLen, L"+HR", 0);
65 }
66 if ((Atts & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) {
67 StrnCatGrow (&RetString, &BufLen, L"+AW", 0);
68 }
69 if ((Atts & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) {
70 StrnCatGrow (&RetString, &BufLen, L"+AT", 0);
71 }
72
73 if (RetString == NULL) {
74 RetString = StrnCatGrow(&RetString, &BufLen, L"Invalid", 0);
75 }
76
77 if ((RetString != NULL) && (RetString[0] == L'+')) {
78 CopyMem(RetString, RetString + 1, StrSize(RetString + 1));
79 }
80
81 return RetString;
82 }
83
84 /**
85 Convert binary to hex format string.
86
87 @param[in] Buffer The binary data.
88 @param[in] BufferSize The size in bytes of the binary data.
89 @param[in, out] HexString Hex format string.
90 @param[in] HexStringSize The size in bytes of the string.
91
92 @return The hex format string.
93 **/
94 CHAR16*
95 BinaryToHexString (
96 IN VOID *Buffer,
97 IN UINTN BufferSize,
98 IN OUT CHAR16 *HexString,
99 IN UINTN HexStringSize
100 )
101 {
102 UINTN Index;
103 UINTN StringIndex;
104
105 ASSERT (Buffer != NULL);
106 ASSERT ((BufferSize * 2 + 1) * sizeof (CHAR16) <= HexStringSize);
107
108 for (Index = 0, StringIndex = 0; Index < BufferSize; Index += 1) {
109 StringIndex +=
110 UnicodeSPrint (
111 &HexString[StringIndex],
112 HexStringSize - StringIndex * sizeof (CHAR16),
113 L"%02x",
114 ((UINT8 *) Buffer)[Index]
115 );
116 }
117 return HexString;
118 }
119
120 /**
121 Load the variable data from file and set to variable data base.
122
123 @param[in] FileHandle The file to be read.
124 @param[in] Name The name of the variables to be loaded.
125 @param[in] Guid The guid of the variables to be loaded.
126 @param[out] Found TRUE when at least one variable was loaded and set.
127
128 @retval SHELL_DEVICE_ERROR Cannot access the file.
129 @retval SHELL_VOLUME_CORRUPTED The file is in bad format.
130 @retval SHELL_OUT_OF_RESOURCES There is not enough memory to perform the operation.
131 @retval SHELL_SUCCESS Successfully load and set the variables.
132 **/
133 SHELL_STATUS
134 LoadVariablesFromFile (
135 IN SHELL_FILE_HANDLE FileHandle,
136 IN CONST CHAR16 *Name,
137 IN CONST EFI_GUID *Guid,
138 OUT BOOLEAN *Found
139 )
140 {
141 EFI_STATUS Status;
142 SHELL_STATUS ShellStatus;
143 UINT32 NameSize;
144 UINT32 DataSize;
145 UINTN BufferSize;
146 UINTN RemainingSize;
147 UINT64 Position;
148 UINT64 FileSize;
149 LIST_ENTRY List;
150 DMP_STORE_VARIABLE *Variable;
151 LIST_ENTRY *Link;
152 CHAR16 *Attributes;
153 UINT8 *Buffer;
154 UINT32 Crc32;
155
156 Status = ShellGetFileSize (FileHandle, &FileSize);
157 if (EFI_ERROR (Status)) {
158 return SHELL_DEVICE_ERROR;
159 }
160
161 ShellStatus = SHELL_SUCCESS;
162
163 InitializeListHead (&List);
164
165 Position = 0;
166 while (Position < FileSize) {
167 //
168 // NameSize
169 //
170 BufferSize = sizeof (NameSize);
171 Status = ShellReadFile (FileHandle, &BufferSize, &NameSize);
172 if (EFI_ERROR (Status) || (BufferSize != sizeof (NameSize))) {
173 ShellStatus = SHELL_VOLUME_CORRUPTED;
174 break;
175 }
176
177 //
178 // DataSize
179 //
180 BufferSize = sizeof (DataSize);
181 Status = ShellReadFile (FileHandle, &BufferSize, &DataSize);
182 if (EFI_ERROR (Status) || (BufferSize != sizeof (DataSize))) {
183 ShellStatus = SHELL_VOLUME_CORRUPTED;
184 break;
185 }
186
187 //
188 // Name, Guid, Attributes, Data, Crc32
189 //
190 RemainingSize = NameSize + sizeof (EFI_GUID) + sizeof (UINT32) + DataSize + sizeof (Crc32);
191 BufferSize = sizeof (NameSize) + sizeof (DataSize) + RemainingSize;
192 Buffer = AllocatePool (BufferSize);
193 if (Buffer == NULL) {
194 ShellStatus = SHELL_OUT_OF_RESOURCES;
195 break;
196 }
197 BufferSize = RemainingSize;
198 Status = ShellReadFile (FileHandle, &BufferSize, (UINT32 *) Buffer + 2);
199 if (EFI_ERROR (Status) || (BufferSize != RemainingSize)) {
200 ShellStatus = SHELL_VOLUME_CORRUPTED;
201 FreePool (Buffer);
202 break;
203 }
204
205 //
206 // Check Crc32
207 //
208 * (UINT32 *) Buffer = NameSize;
209 * ((UINT32 *) Buffer + 1) = DataSize;
210 BufferSize = RemainingSize + sizeof (NameSize) + sizeof (DataSize) - sizeof (Crc32);
211 gBS->CalculateCrc32 (
212 Buffer,
213 BufferSize,
214 &Crc32
215 );
216 if (Crc32 != * (UINT32 *) (Buffer + BufferSize)) {
217 FreePool (Buffer);
218 ShellStatus = SHELL_VOLUME_CORRUPTED;
219 break;
220 }
221
222 Position += BufferSize + sizeof (Crc32);
223
224 Variable = AllocateZeroPool (sizeof (*Variable) + NameSize + DataSize);
225 if (Variable == NULL) {
226 FreePool (Buffer);
227 ShellStatus = SHELL_OUT_OF_RESOURCES;
228 break;
229 }
230 Variable->Signature = DMP_STORE_VARIABLE_SIGNATURE;
231 Variable->Name = (CHAR16 *) (Variable + 1);
232 Variable->DataSize = DataSize;
233 Variable->Data = (UINT8 *) Variable->Name + NameSize;
234 CopyMem (Variable->Name, Buffer + sizeof (NameSize) + sizeof (DataSize), NameSize);
235 CopyMem (&Variable->Guid, Buffer + sizeof (NameSize) + sizeof (DataSize) + NameSize, sizeof (EFI_GUID));
236 CopyMem (&Variable->Attributes, Buffer + sizeof (NameSize) + sizeof (DataSize) + NameSize + sizeof (EFI_GUID), sizeof (UINT32));
237 CopyMem (Variable->Data, Buffer + sizeof (NameSize) + sizeof (DataSize) + NameSize + sizeof (EFI_GUID) + sizeof (UINT32), DataSize);
238
239 InsertTailList (&List, &Variable->Link);
240 FreePool (Buffer);
241 }
242
243 if ((Position != FileSize) || (ShellStatus != SHELL_SUCCESS)) {
244 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_LOAD_BAD_FILE), gShellDebug1HiiHandle, L"dmpstore");
245 if (Position != FileSize) {
246 ShellStatus = SHELL_VOLUME_CORRUPTED;
247 }
248 }
249
250 for ( Link = GetFirstNode (&List)
251 ; !IsNull (&List, Link) && (ShellStatus == SHELL_SUCCESS)
252 ; Link = GetNextNode (&List, Link)
253 ) {
254 Variable = CR (Link, DMP_STORE_VARIABLE, Link, DMP_STORE_VARIABLE_SIGNATURE);
255
256 if (((Name == NULL) || gUnicodeCollation->MetaiMatch (gUnicodeCollation, Variable->Name, (CHAR16 *) Name)) &&
257 ((Guid == NULL) || CompareGuid (&Variable->Guid, Guid))
258 ) {
259 Attributes = GetAttrType (Variable->Attributes);
260 ShellPrintHiiEx (
261 -1, -1, NULL, STRING_TOKEN(STR_DMPSTORE_HEADER_LINE), gShellDebug1HiiHandle,
262 Attributes, &Variable->Guid, Variable->Name, Variable->DataSize
263 );
264 SHELL_FREE_NON_NULL(Attributes);
265
266 *Found = TRUE;
267 Status = gRT->SetVariable (
268 Variable->Name,
269 &Variable->Guid,
270 Variable->Attributes,
271 Variable->DataSize,
272 Variable->Data
273 );
274 if (EFI_ERROR (Status)) {
275 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_LOAD_GEN_FAIL), gShellDebug1HiiHandle, L"dmpstore", Variable->Name, Status);
276 }
277 }
278 }
279
280 for (Link = GetFirstNode (&List); !IsNull (&List, Link); ) {
281 Variable = CR (Link, DMP_STORE_VARIABLE, Link, DMP_STORE_VARIABLE_SIGNATURE);
282 Link = RemoveEntryList (&Variable->Link);
283 FreePool (Variable);
284 }
285
286 return ShellStatus;
287 }
288
289 /**
290 Append one variable to file.
291
292 @param[in] FileHandle The file to be appended.
293 @param[in] Name The variable name.
294 @param[in] Guid The variable GUID.
295 @param[in] Attributes The variable attributes.
296 @param[in] DataSize The variable data size.
297 @param[in] Data The variable data.
298
299 @retval EFI_OUT_OF_RESOURCES There is not enough memory to perform the operation.
300 @retval EFI_SUCCESS The variable is appended to file successfully.
301 @retval others Failed to append the variable to file.
302 **/
303 EFI_STATUS
304 AppendSingleVariableToFile (
305 IN SHELL_FILE_HANDLE FileHandle,
306 IN CONST CHAR16 *Name,
307 IN CONST EFI_GUID *Guid,
308 IN UINT32 Attributes,
309 IN UINT32 DataSize,
310 IN CONST UINT8 *Data
311 )
312 {
313 UINT32 NameSize;
314 UINT8 *Buffer;
315 UINT8 *Ptr;
316 UINTN BufferSize;
317 EFI_STATUS Status;
318
319 NameSize = (UINT32) StrSize (Name);
320 BufferSize = sizeof (NameSize) + sizeof (DataSize)
321 + sizeof (*Guid)
322 + sizeof (Attributes)
323 + NameSize + DataSize
324 + sizeof (UINT32);
325
326 Buffer = AllocatePool (BufferSize);
327 if (Buffer == NULL) {
328 return EFI_OUT_OF_RESOURCES;
329 }
330
331 Ptr = Buffer;
332 //
333 // NameSize and DataSize
334 //
335 * (UINT32 *) Ptr = NameSize;
336 Ptr += sizeof (NameSize);
337 *(UINT32 *) Ptr = DataSize;
338 Ptr += sizeof (DataSize);
339
340 //
341 // Name
342 //
343 CopyMem (Ptr, Name, NameSize);
344 Ptr += NameSize;
345
346 //
347 // Guid
348 //
349 CopyMem (Ptr, Guid, sizeof (*Guid));
350 Ptr += sizeof (*Guid);
351
352 //
353 // Attributes
354 //
355 * (UINT32 *) Ptr = Attributes;
356 Ptr += sizeof (Attributes);
357
358 //
359 // Data
360 //
361 CopyMem (Ptr, Data, DataSize);
362 Ptr += DataSize;
363
364 //
365 // Crc32
366 //
367 gBS->CalculateCrc32 (Buffer, (UINTN) Ptr - (UINTN) Buffer, (UINT32 *) Ptr);
368
369 Status = ShellWriteFile (FileHandle, &BufferSize, Buffer);
370 FreePool (Buffer);
371
372 if (!EFI_ERROR (Status) &&
373 (BufferSize != sizeof (NameSize) + sizeof (DataSize) + sizeof (*Guid) + sizeof (Attributes) + NameSize + DataSize + sizeof (UINT32))
374 ) {
375 Status = EFI_DEVICE_ERROR;
376 }
377
378 return Status;
379 }
380
381 /**
382 Recursive function to display or delete variables.
383
384 This function will call itself to create a stack-based list of allt he variables to process,
385 then fromt he last to the first, they will do either printing or deleting.
386
387 This is necessary since once a delete happens GetNextVariableName() will work.
388
389 @param[in] Name The variable name of the EFI variable (or NULL).
390 @param[in] Guid The GUID of the variable set (or NULL).
391 @param[in] Type The operation type.
392 @param[in] FileHandle The file to operate on (or NULL).
393 @param[in] PrevName The previous variable name from GetNextVariableName. L"" to start.
394 @param[in] FoundVarGuid The previous GUID from GetNextVariableName. ignored at start.
395 @param[in] FoundOne If a VariableName or Guid was specified and one was printed or
396 deleted, then set this to TRUE, otherwise ignored.
397 @param[in] StandardFormatOutput TRUE indicates Standard-Format Output.
398
399 @retval SHELL_SUCCESS The operation was successful.
400 @retval SHELL_OUT_OF_RESOURCES A memorty allocation failed.
401 @retval SHELL_ABORTED The abort message was received.
402 @retval SHELL_DEVICE_ERROR UEFI Variable Services returned an error.
403 @retval SHELL_NOT_FOUND the Name/Guid pair could not be found.
404 **/
405 SHELL_STATUS
406 CascadeProcessVariables (
407 IN CONST CHAR16 *Name OPTIONAL,
408 IN CONST EFI_GUID *Guid OPTIONAL,
409 IN DMP_STORE_TYPE Type,
410 IN EFI_FILE_PROTOCOL *FileHandle OPTIONAL,
411 IN CONST CHAR16 * CONST PrevName,
412 IN EFI_GUID FoundVarGuid,
413 IN BOOLEAN *FoundOne,
414 IN BOOLEAN StandardFormatOutput
415 )
416 {
417 EFI_STATUS Status;
418 CHAR16 *FoundVarName;
419 UINT8 *DataBuffer;
420 UINTN DataSize;
421 UINT32 Atts;
422 SHELL_STATUS ShellStatus;
423 UINTN NameSize;
424 CHAR16 *AttrString;
425 CHAR16 *HexString;
426 EFI_STATUS SetStatus;
427
428 if (ShellGetExecutionBreakFlag()) {
429 return (SHELL_ABORTED);
430 }
431
432 NameSize = 0;
433 FoundVarName = NULL;
434
435 if (PrevName!=NULL) {
436 StrnCatGrow(&FoundVarName, &NameSize, PrevName, 0);
437 } else {
438 FoundVarName = AllocateZeroPool(sizeof(CHAR16));
439 }
440
441 Status = gRT->GetNextVariableName (&NameSize, FoundVarName, &FoundVarGuid);
442 if (Status == EFI_BUFFER_TOO_SMALL) {
443 SHELL_FREE_NON_NULL(FoundVarName);
444 FoundVarName = AllocateZeroPool (NameSize);
445 if (FoundVarName != NULL) {
446 if (PrevName != NULL) {
447 StrnCpyS(FoundVarName, NameSize/sizeof(CHAR16), PrevName, NameSize/sizeof(CHAR16) - 1);
448 }
449
450 Status = gRT->GetNextVariableName (&NameSize, FoundVarName, &FoundVarGuid);
451 } else {
452 Status = EFI_OUT_OF_RESOURCES;
453 }
454 }
455
456 //
457 // No more is fine.
458 //
459 if (Status == EFI_NOT_FOUND) {
460 SHELL_FREE_NON_NULL(FoundVarName);
461 return (SHELL_SUCCESS);
462 } else if (EFI_ERROR(Status)) {
463 SHELL_FREE_NON_NULL(FoundVarName);
464 return (SHELL_DEVICE_ERROR);
465 }
466
467 //
468 // Recurse to the next iteration. We know "our" variable's name.
469 //
470 ShellStatus = CascadeProcessVariables (Name, Guid, Type, FileHandle, FoundVarName, FoundVarGuid, FoundOne, StandardFormatOutput);
471
472 if (ShellGetExecutionBreakFlag() || (ShellStatus == SHELL_ABORTED)) {
473 SHELL_FREE_NON_NULL(FoundVarName);
474 return (SHELL_ABORTED);
475 }
476
477 //
478 // No matter what happened we process our own variable
479 // Only continue if Guid and VariableName are each either NULL or a match
480 //
481 if ( ( Name == NULL
482 || gUnicodeCollation->MetaiMatch(gUnicodeCollation, FoundVarName, (CHAR16*) Name) )
483 && ( Guid == NULL
484 || CompareGuid(&FoundVarGuid, Guid) )
485 ) {
486 DataSize = 0;
487 DataBuffer = NULL;
488 //
489 // do the print or delete
490 //
491 *FoundOne = TRUE;
492 Status = gRT->GetVariable (FoundVarName, &FoundVarGuid, &Atts, &DataSize, DataBuffer);
493 if (Status == EFI_BUFFER_TOO_SMALL) {
494 SHELL_FREE_NON_NULL (DataBuffer);
495 DataBuffer = AllocatePool (DataSize);
496 if (DataBuffer == NULL) {
497 Status = EFI_OUT_OF_RESOURCES;
498 } else {
499 Status = gRT->GetVariable (FoundVarName, &FoundVarGuid, &Atts, &DataSize, DataBuffer);
500 }
501 }
502 //
503 // Last error check then print this variable out.
504 //
505 if (Type == DmpStoreDisplay) {
506 if (!EFI_ERROR(Status) && (DataBuffer != NULL) && (FoundVarName != NULL)) {
507 AttrString = GetAttrType(Atts);
508 if (StandardFormatOutput) {
509 HexString = AllocatePool ((DataSize * 2 + 1) * sizeof (CHAR16));
510 if (HexString != NULL) {
511 ShellPrintHiiEx (
512 -1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_VAR_SFO), gShellDebug1HiiHandle,
513 FoundVarName, &FoundVarGuid, Atts, DataSize,
514 BinaryToHexString (
515 DataBuffer, DataSize, HexString, (DataSize * 2 + 1) * sizeof (CHAR16)
516 )
517 );
518 FreePool (HexString);
519 } else {
520 Status = EFI_OUT_OF_RESOURCES;
521 }
522 } else {
523 ShellPrintHiiEx (
524 -1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_HEADER_LINE), gShellDebug1HiiHandle,
525 AttrString, &FoundVarGuid, FoundVarName, DataSize
526 );
527 DumpHex (2, 0, DataSize, DataBuffer);
528 }
529 SHELL_FREE_NON_NULL (AttrString);
530 }
531 } else if (Type == DmpStoreSave) {
532 if (!EFI_ERROR(Status) && (DataBuffer != NULL) && (FoundVarName != NULL)) {
533 AttrString = GetAttrType (Atts);
534 ShellPrintHiiEx (
535 -1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_HEADER_LINE), gShellDebug1HiiHandle,
536 AttrString, &FoundVarGuid, FoundVarName, DataSize
537 );
538 Status = AppendSingleVariableToFile (
539 FileHandle,
540 FoundVarName,
541 &FoundVarGuid,
542 Atts,
543 (UINT32) DataSize,
544 DataBuffer
545 );
546 SHELL_FREE_NON_NULL (AttrString);
547 }
548 } else if (Type == DmpStoreDelete) {
549 //
550 // We only need name to delete it...
551 //
552 SetStatus = gRT->SetVariable (FoundVarName, &FoundVarGuid, Atts, 0, NULL);
553 if (StandardFormatOutput) {
554 if (SetStatus == EFI_SUCCESS) {
555 ShellPrintHiiEx (
556 -1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_NG_SFO), gShellDebug1HiiHandle,
557 FoundVarName, &FoundVarGuid
558 );
559 }
560 } else {
561 ShellPrintHiiEx (
562 -1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_DELETE_LINE), gShellDebug1HiiHandle,
563 &FoundVarGuid, FoundVarName, SetStatus
564 );
565 }
566 }
567 SHELL_FREE_NON_NULL(DataBuffer);
568 }
569
570 SHELL_FREE_NON_NULL(FoundVarName);
571
572 if (Status == EFI_DEVICE_ERROR) {
573 ShellStatus = SHELL_DEVICE_ERROR;
574 } else if (Status == EFI_SECURITY_VIOLATION) {
575 ShellStatus = SHELL_SECURITY_VIOLATION;
576 } else if (EFI_ERROR(Status)) {
577 ShellStatus = SHELL_NOT_READY;
578 }
579
580 return (ShellStatus);
581 }
582
583 /**
584 Function to display or delete variables. This will set up and call into the recursive function.
585
586 @param[in] Name The variable name of the EFI variable (or NULL).
587 @param[in] Guid The GUID of the variable set (or NULL).
588 @param[in] Type The operation type.
589 @param[in] FileHandle The file to save or load variables.
590 @param[in] StandardFormatOutput TRUE indicates Standard-Format Output.
591
592 @retval SHELL_SUCCESS The operation was successful.
593 @retval SHELL_OUT_OF_RESOURCES A memorty allocation failed.
594 @retval SHELL_ABORTED The abort message was received.
595 @retval SHELL_DEVICE_ERROR UEFI Variable Services returned an error.
596 @retval SHELL_NOT_FOUND the Name/Guid pair could not be found.
597 **/
598 SHELL_STATUS
599 ProcessVariables (
600 IN CONST CHAR16 *Name OPTIONAL,
601 IN CONST EFI_GUID *Guid OPTIONAL,
602 IN DMP_STORE_TYPE Type,
603 IN SHELL_FILE_HANDLE FileHandle OPTIONAL,
604 IN BOOLEAN StandardFormatOutput
605 )
606 {
607 SHELL_STATUS ShellStatus;
608 BOOLEAN Found;
609 EFI_GUID FoundVarGuid;
610
611 Found = FALSE;
612 ShellStatus = SHELL_SUCCESS;
613 ZeroMem (&FoundVarGuid, sizeof(EFI_GUID));
614
615 if (StandardFormatOutput) {
616 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_GEN_SFO_HEADER), gShellDebug1HiiHandle, L"dmpstore");
617 }
618
619 if (Type == DmpStoreLoad) {
620 ShellStatus = LoadVariablesFromFile (FileHandle, Name, Guid, &Found);
621 } else {
622 ShellStatus = CascadeProcessVariables (Name, Guid, Type, FileHandle, NULL, FoundVarGuid, &Found, StandardFormatOutput);
623 }
624
625 if (!Found) {
626 if (ShellStatus == SHELL_OUT_OF_RESOURCES) {
627 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_OUT_MEM), gShellDebug1HiiHandle, L"dmpstore");
628 return (ShellStatus);
629 } else if (Name != NULL && Guid == NULL) {
630 if (StandardFormatOutput) {
631 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_N_SFO), gShellDebug1HiiHandle, Name);
632 } else {
633 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_N), gShellDebug1HiiHandle, L"dmpstore", Name);
634 }
635 } else if (Name != NULL && Guid != NULL) {
636 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_GN), gShellDebug1HiiHandle, L"dmpstore", Guid, Name);
637 } else if (Name == NULL && Guid == NULL) {
638 if (StandardFormatOutput) {
639 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_SFO), gShellDebug1HiiHandle);
640 } else {
641 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND), gShellDebug1HiiHandle, L"dmpstore");
642 }
643 } else if (Name == NULL && Guid != NULL) {
644 if (StandardFormatOutput) {
645 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_G_SFO), gShellDebug1HiiHandle, Guid);
646 } else {
647 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_G), gShellDebug1HiiHandle, L"dmpstore", Guid);
648 }
649 }
650 return (SHELL_NOT_FOUND);
651 }
652 return (ShellStatus);
653 }
654
655 STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
656 {L"-d", TypeFlag},
657 {L"-l", TypeValue},
658 {L"-s", TypeValue},
659 {L"-all", TypeFlag},
660 {L"-guid", TypeValue},
661 {L"-sfo", TypeFlag},
662 {NULL, TypeMax}
663 };
664
665 /**
666 Function for 'dmpstore' command.
667
668 @param[in] ImageHandle Handle to the Image (NULL if Internal).
669 @param[in] SystemTable Pointer to the System Table (NULL if Internal).
670 **/
671 SHELL_STATUS
672 EFIAPI
673 ShellCommandRunDmpStore (
674 IN EFI_HANDLE ImageHandle,
675 IN EFI_SYSTEM_TABLE *SystemTable
676 )
677 {
678 EFI_STATUS Status;
679 RETURN_STATUS RStatus;
680 LIST_ENTRY *Package;
681 CHAR16 *ProblemParam;
682 SHELL_STATUS ShellStatus;
683 CONST CHAR16 *GuidStr;
684 CONST CHAR16 *File;
685 EFI_GUID *Guid;
686 EFI_GUID GuidData;
687 CONST CHAR16 *Name;
688 DMP_STORE_TYPE Type;
689 SHELL_FILE_HANDLE FileHandle;
690 EFI_FILE_INFO *FileInfo;
691 BOOLEAN StandardFormatOutput;
692
693 ShellStatus = SHELL_SUCCESS;
694 Package = NULL;
695 FileHandle = NULL;
696 File = NULL;
697 Type = DmpStoreDisplay;
698 StandardFormatOutput = FALSE;
699
700 Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
701 if (EFI_ERROR(Status)) {
702 if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
703 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, L"dmpstore", ProblemParam);
704 FreePool(ProblemParam);
705 ShellStatus = SHELL_INVALID_PARAMETER;
706 } else {
707 ASSERT(FALSE);
708 }
709 } else {
710 if (ShellCommandLineGetCount(Package) > 2) {
711 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle, L"dmpstore");
712 ShellStatus = SHELL_INVALID_PARAMETER;
713 } else if (ShellCommandLineGetFlag(Package, L"-all") && ShellCommandLineGetFlag(Package, L"-guid")) {
714 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONFLICT), gShellDebug1HiiHandle, L"dmpstore", L"-all", L"-guid");
715 ShellStatus = SHELL_INVALID_PARAMETER;
716 } else if (ShellCommandLineGetFlag(Package, L"-s") && ShellCommandLineGetFlag(Package, L"-l")) {
717 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONFLICT), gShellDebug1HiiHandle, L"dmpstore", L"-l", L"-s");
718 ShellStatus = SHELL_INVALID_PARAMETER;
719 } else if ((ShellCommandLineGetFlag(Package, L"-s") || ShellCommandLineGetFlag(Package, L"-l")) && ShellCommandLineGetFlag(Package, L"-d")) {
720 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONFLICT), gShellDebug1HiiHandle, L"dmpstore", L"-l or -s", L"-d");
721 ShellStatus = SHELL_INVALID_PARAMETER;
722 } else if ((ShellCommandLineGetFlag(Package, L"-s") || ShellCommandLineGetFlag(Package, L"-l")) && ShellCommandLineGetFlag(Package, L"-sfo")) {
723 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONFLICT), gShellDebug1HiiHandle, L"dmpstore", L"-l or -s", L"-sfo");
724 ShellStatus = SHELL_INVALID_PARAMETER;
725 } else {
726 //
727 // Determine the GUID to search for based on -all and -guid parameters
728 //
729 if (!ShellCommandLineGetFlag(Package, L"-all")) {
730 GuidStr = ShellCommandLineGetValue(Package, L"-guid");
731 if (GuidStr != NULL) {
732 RStatus = StrToGuid (GuidStr, &GuidData);
733 if (RETURN_ERROR (RStatus) || (GuidStr[GUID_STRING_LENGTH] != L'\0')) {
734 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellDebug1HiiHandle, L"dmpstore", GuidStr);
735 ShellStatus = SHELL_INVALID_PARAMETER;
736 }
737 Guid = &GuidData;
738 } else {
739 Guid = &gEfiGlobalVariableGuid;
740 }
741 } else {
742 Guid = NULL;
743 }
744
745 //
746 // Get the Name of the variable to find
747 //
748 Name = ShellCommandLineGetRawValue(Package, 1);
749
750 if (ShellStatus == SHELL_SUCCESS) {
751 if (ShellCommandLineGetFlag(Package, L"-s")) {
752 Type = DmpStoreSave;
753 File = ShellCommandLineGetValue(Package, L"-s");
754 if (File == NULL) {
755 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDebug1HiiHandle, L"dmpstore", L"-s");
756 ShellStatus = SHELL_INVALID_PARAMETER;
757 } else {
758 Status = ShellOpenFileByName (File, &FileHandle, EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ, 0);
759 if (!EFI_ERROR (Status)) {
760 //
761 // Delete existing file, but do not delete existing directory
762 //
763 FileInfo = ShellGetFileInfo (FileHandle);
764 if (FileInfo == NULL) {
765 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, L"dmpstore", File);
766 Status = EFI_DEVICE_ERROR;
767 } else {
768 if ((FileInfo->Attribute & EFI_FILE_DIRECTORY) == EFI_FILE_DIRECTORY) {
769 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_IS_DIRECTORY), gShellDebug1HiiHandle, L"dmpstore", File);
770 Status = EFI_INVALID_PARAMETER;
771 } else {
772 Status = ShellDeleteFile (&FileHandle);
773 if (EFI_ERROR (Status)) {
774 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_DELETE_FAIL), gShellDebug1HiiHandle, L"dmpstore", File);
775 }
776 }
777 FreePool (FileInfo);
778 }
779 } else if (Status == EFI_NOT_FOUND) {
780 //
781 // Good when file doesn't exist
782 //
783 Status = EFI_SUCCESS;
784 } else {
785 //
786 // Otherwise it's bad.
787 //
788 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, L"dmpstore", File);
789 }
790
791 if (!EFI_ERROR (Status)) {
792 Status = ShellOpenFileByName (File, &FileHandle, EFI_FILE_MODE_CREATE | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ, 0);
793 if (EFI_ERROR (Status)) {
794 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, L"dmpstore", File);
795 }
796 }
797
798 if (EFI_ERROR (Status)) {
799 ShellStatus = SHELL_INVALID_PARAMETER;
800 }
801 }
802 } else if (ShellCommandLineGetFlag(Package, L"-l")) {
803 Type = DmpStoreLoad;
804 File = ShellCommandLineGetValue(Package, L"-l");
805 if (File == NULL) {
806 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDebug1HiiHandle, L"dmpstore", L"-l");
807 ShellStatus = SHELL_INVALID_PARAMETER;
808 } else {
809 Status = ShellOpenFileByName (File, &FileHandle, EFI_FILE_MODE_READ, 0);
810 if (EFI_ERROR (Status)) {
811 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, L"dmpstore", File);
812 ShellStatus = SHELL_INVALID_PARAMETER;
813 } else {
814 FileInfo = ShellGetFileInfo (FileHandle);
815 if (FileInfo == NULL) {
816 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, L"dmpstore", File);
817 ShellStatus = SHELL_DEVICE_ERROR;
818 } else {
819 if ((FileInfo->Attribute & EFI_FILE_DIRECTORY) == EFI_FILE_DIRECTORY) {
820 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_IS_DIRECTORY), gShellDebug1HiiHandle, L"dmpstore", File);
821 ShellStatus = SHELL_INVALID_PARAMETER;
822 }
823 FreePool (FileInfo);
824 }
825 }
826 }
827 } else if (ShellCommandLineGetFlag(Package, L"-d")) {
828 Type = DmpStoreDelete;
829 }
830
831 if (ShellCommandLineGetFlag (Package,L"-sfo")) {
832 StandardFormatOutput = TRUE;
833 }
834 }
835
836 if (ShellStatus == SHELL_SUCCESS) {
837 if (Type == DmpStoreSave) {
838 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_SAVE), gShellDebug1HiiHandle, File);
839 } else if (Type == DmpStoreLoad) {
840 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_LOAD), gShellDebug1HiiHandle, File);
841 }
842 ShellStatus = ProcessVariables (Name, Guid, Type, FileHandle, StandardFormatOutput);
843 if ((Type == DmpStoreLoad) || (Type == DmpStoreSave)) {
844 ShellCloseFile (&FileHandle);
845 }
846 }
847 }
848 }
849
850 if (Package != NULL) {
851 ShellCommandLineFreeVarList (Package);
852 }
853 return ShellStatus;
854 }
855
EFI Development Kit II mirror for PVE