ArmPlatformPkg/Bds: Change the GetHIInput/EditHIInput to always return a valid IP...
[mirror_edk2.git] / ArmPlatformPkg / Bds / BdsHelper.c
1 /** @file
2 *
3 * Copyright (c) 2011 - 2014, ARM Limited. All rights reserved.
4 *
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 <Library/NetLib.h>
16 #include "BdsInternal.h"
17
18 EFI_STATUS
19 EditHIInputStr (
20 IN OUT CHAR16 *CmdLine,
21 IN UINTN MaxCmdLine
22 )
23 {
24 UINTN CmdLineIndex;
25 UINTN WaitIndex;
26 CHAR8 Char;
27 EFI_INPUT_KEY Key;
28 EFI_STATUS Status;
29
30 // The command line must be at least one character long
31 ASSERT (MaxCmdLine > 0);
32
33 // Ensure the last character of the buffer is the NULL character
34 CmdLine[MaxCmdLine - 1] = '\0';
35
36 Print (CmdLine);
37
38 // To prevent a buffer overflow, we only allow to enter (MaxCmdLine-1) characters
39 for (CmdLineIndex = StrLen (CmdLine); CmdLineIndex < MaxCmdLine; ) {
40 Status = gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &WaitIndex);
41 ASSERT_EFI_ERROR (Status);
42
43 Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
44 ASSERT_EFI_ERROR (Status);
45
46 // Unicode character is valid when Scancode is NUll
47 if (Key.ScanCode == SCAN_NULL) {
48 // Scan code is NUll, hence read Unicode character
49 Char = (CHAR8)Key.UnicodeChar;
50 } else {
51 Char = CHAR_NULL;
52 }
53
54 if ((Char == CHAR_LINEFEED) || (Char == CHAR_CARRIAGE_RETURN) || (Char == 0x7f)) {
55 CmdLine[CmdLineIndex] = '\0';
56 Print (L"\r\n");
57
58 return EFI_SUCCESS;
59 } else if ((Key.UnicodeChar == L'\b') || (Key.ScanCode == SCAN_LEFT) || (Key.ScanCode == SCAN_DELETE)){
60 if (CmdLineIndex != 0) {
61 CmdLineIndex--;
62 Print (L"\b \b");
63 }
64 } else if ((Key.ScanCode == SCAN_ESC) || (Char == 0x1B) || (Char == 0x0)) {
65 return EFI_INVALID_PARAMETER;
66 } else if (CmdLineIndex < (MaxCmdLine-1)) {
67 CmdLine[CmdLineIndex++] = Key.UnicodeChar;
68 Print (L"%c", Key.UnicodeChar);
69 }
70 }
71
72 return EFI_SUCCESS;
73 }
74
75 EFI_STATUS
76 GetHIInputStr (
77 IN OUT CHAR16 *CmdLine,
78 IN UINTN MaxCmdLine
79 )
80 {
81 EFI_STATUS Status;
82
83 // For a new input just passed an empty string
84 CmdLine[0] = L'\0';
85
86 Status = EditHIInputStr (CmdLine, MaxCmdLine);
87
88 return Status;
89 }
90
91 EFI_STATUS
92 EditHIInputAscii (
93 IN OUT CHAR8 *CmdLine,
94 IN UINTN MaxCmdLine
95 )
96 {
97 CHAR16* Str;
98 EFI_STATUS Status;
99
100 Str = (CHAR16*)AllocatePool (MaxCmdLine * sizeof(CHAR16));
101 AsciiStrToUnicodeStr (CmdLine, Str);
102
103 Status = EditHIInputStr (Str, MaxCmdLine);
104 if (!EFI_ERROR(Status)) {
105 UnicodeStrToAsciiStr (Str, CmdLine);
106 }
107 FreePool (Str);
108
109 return Status;
110 }
111
112 EFI_STATUS
113 GetHIInputAscii (
114 IN OUT CHAR8 *CmdLine,
115 IN UINTN MaxCmdLine
116 )
117 {
118 // For a new input just passed an empty string
119 CmdLine[0] = '\0';
120
121 return EditHIInputAscii (CmdLine,MaxCmdLine);
122 }
123
124 EFI_STATUS
125 GetHIInputInteger (
126 OUT UINTN *Integer
127 )
128 {
129 CHAR16 CmdLine[255];
130 EFI_STATUS Status;
131
132 CmdLine[0] = '\0';
133 Status = EditHIInputStr (CmdLine, 255);
134 if (!EFI_ERROR(Status)) {
135 *Integer = StrDecimalToUintn (CmdLine);
136 }
137
138 return Status;
139 }
140
141 /**
142 Get an IPv4 address
143
144 The function asks the user for an IPv4 address. If the input
145 string defines a valid IPv4 address, the four bytes of the
146 corresponding IPv4 address are extracted from the string and returned by
147 the function. As long as the user does not define a valid IP
148 address, he is asked for one. He can always escape by
149 pressing ESC.
150
151 @param[out] EFI_IP_ADDRESS OutIpAddr Returned IPv4 address. Valid if
152 and only if the returned value
153 is equal to EFI_SUCCESS
154
155 @retval EFI_SUCCESS Input completed
156 @retval EFI_ABORTED Editing aborted by the user
157 @retval EFI_OUT_OF_RESOURCES Fail to perform the operation due to
158 lack of resource
159 **/
160 EFI_STATUS
161 GetHIInputIP (
162 OUT EFI_IP_ADDRESS *OutIpAddr
163 )
164 {
165 EFI_STATUS Status;
166 CHAR16 CmdLine[48];
167
168 while (TRUE) {
169 CmdLine[0] = '\0';
170 Status = EditHIInputStr (CmdLine, 48);
171 if (EFI_ERROR (Status)) {
172 return EFI_ABORTED;
173 }
174
175 Status = NetLibStrToIp4 (CmdLine, &OutIpAddr->v4);
176 if (Status == EFI_INVALID_PARAMETER) {
177 Print (L"Invalid address\n");
178 } else {
179 return Status;
180 }
181 }
182 }
183
184 /**
185 Edit an IPv4 address
186
187 The function displays as a string following the "%d.%d.%d.%d" format the
188 IPv4 address that is passed in and asks the user to modify it. If the
189 resulting string defines a valid IPv4 address, the four bytes of the
190 corresponding IPv4 address are extracted from the string and returned by
191 the function. As long as the user does not define a valid IP
192 address, he is asked for one. He can always escape by
193 pressing ESC.
194
195 @param[in ] EFI_IP_ADDRESS InIpAddr Input IPv4 address
196 @param[out] EFI_IP_ADDRESS OutIpAddr Returned IPv4 address. Valid if
197 and only if the returned value
198 is equal to EFI_SUCCESS
199
200 @retval EFI_SUCCESS Update completed
201 @retval EFI_ABORTED Editing aborted by the user
202 @retval EFI_INVALID_PARAMETER The string returned by the user is
203 mal-formated
204 @retval EFI_OUT_OF_RESOURCES Fail to perform the operation due to
205 lack of resource
206 **/
207 EFI_STATUS
208 EditHIInputIP (
209 IN EFI_IP_ADDRESS *InIpAddr,
210 OUT EFI_IP_ADDRESS *OutIpAddr
211 )
212 {
213 EFI_STATUS Status;
214 CHAR16 CmdLine[48];
215
216 while (TRUE) {
217 UnicodeSPrint (
218 CmdLine, 48, L"%d.%d.%d.%d",
219 InIpAddr->v4.Addr[0], InIpAddr->v4.Addr[1],
220 InIpAddr->v4.Addr[2], InIpAddr->v4.Addr[3]
221 );
222
223 Status = EditHIInputStr (CmdLine, 48);
224 if (EFI_ERROR (Status)) {
225 return EFI_ABORTED;
226 }
227 Status = NetLibStrToIp4 (CmdLine, &OutIpAddr->v4);
228 if (Status == EFI_INVALID_PARAMETER) {
229 Print (L"Invalid address\n");
230 } else {
231 return Status;
232 }
233 }
234 }
235
236 EFI_STATUS
237 GetHIInputBoolean (
238 OUT BOOLEAN *Value
239 )
240 {
241 CHAR16 CmdBoolean[2];
242 EFI_STATUS Status;
243
244 while(1) {
245 Print (L"[y/n] ");
246 Status = GetHIInputStr (CmdBoolean, 2);
247 if (EFI_ERROR(Status)) {
248 return Status;
249 } else if ((CmdBoolean[0] == L'y') || (CmdBoolean[0] == L'Y')) {
250 if (Value) *Value = TRUE;
251 return EFI_SUCCESS;
252 } else if ((CmdBoolean[0] == L'n') || (CmdBoolean[0] == L'N')) {
253 if (Value) *Value = FALSE;
254 return EFI_SUCCESS;
255 }
256 }
257 }
258
259 BOOLEAN
260 HasFilePathEfiExtension (
261 IN CHAR16* FilePath
262 )
263 {
264 return (StrCmp (FilePath + (StrSize (FilePath) / sizeof (CHAR16)) - 5, L".EFI") == 0) ||
265 (StrCmp (FilePath + (StrSize (FilePath) / sizeof (CHAR16)) - 5, L".efi") == 0);
266 }
267
268 // Return the last non end-type Device Path Node from a Device Path
269 EFI_DEVICE_PATH*
270 GetLastDevicePathNode (
271 IN EFI_DEVICE_PATH* DevicePath
272 )
273 {
274 EFI_DEVICE_PATH* PrevDevicePathNode;
275
276 PrevDevicePathNode = DevicePath;
277 while (!IsDevicePathEndType (DevicePath)) {
278 PrevDevicePathNode = DevicePath;
279 DevicePath = NextDevicePathNode (DevicePath);
280 }
281
282 return PrevDevicePathNode;
283 }
284
285 EFI_STATUS
286 GenerateDeviceDescriptionName (
287 IN EFI_HANDLE Handle,
288 IN OUT CHAR16* Description
289 )
290 {
291 EFI_STATUS Status;
292 EFI_COMPONENT_NAME_PROTOCOL* ComponentName2Protocol;
293 EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;
294 EFI_DEVICE_PATH_PROTOCOL* DevicePathProtocol;
295 CHAR16* DriverName;
296 CHAR16* DevicePathTxt;
297 EFI_DEVICE_PATH* DevicePathNode;
298
299 ComponentName2Protocol = NULL;
300 Status = gBS->HandleProtocol (Handle, &gEfiComponentName2ProtocolGuid, (VOID **)&ComponentName2Protocol);
301 if (!EFI_ERROR(Status)) {
302 //TODO: Fixme. we must find the best langague
303 Status = ComponentName2Protocol->GetDriverName (ComponentName2Protocol,"en",&DriverName);
304 if (!EFI_ERROR(Status)) {
305 StrnCpy (Description, DriverName, BOOT_DEVICE_DESCRIPTION_MAX);
306 }
307 }
308
309 if (EFI_ERROR(Status)) {
310 // Use the lastest non null entry of the Device path as a description
311 Status = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID **)&DevicePathProtocol);
312 if (EFI_ERROR(Status)) {
313 return Status;
314 }
315
316 // Convert the last non end-type Device Path Node in text for the description
317 DevicePathNode = GetLastDevicePathNode (DevicePathProtocol);
318 Status = gBS->LocateProtocol (&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);
319 ASSERT_EFI_ERROR(Status);
320 DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (DevicePathNode, TRUE, TRUE);
321 StrnCpy (Description, DevicePathTxt, BOOT_DEVICE_DESCRIPTION_MAX);
322 FreePool (DevicePathTxt);
323 }
324
325 return EFI_SUCCESS;
326 }
327
328 EFI_STATUS
329 BdsStartBootOption (
330 IN CHAR16* BootOption
331 )
332 {
333 EFI_STATUS Status;
334 BDS_LOAD_OPTION *BdsLoadOption;
335
336 Status = BootOptionFromLoadOptionVariable (BootOption, &BdsLoadOption);
337 if (!EFI_ERROR(Status)) {
338 Status = BootOptionStart (BdsLoadOption);
339 FreePool (BdsLoadOption);
340
341 if (!EFI_ERROR(Status)) {
342 Status = EFI_SUCCESS;
343 } else {
344 Status = EFI_NOT_STARTED;
345 }
346 } else {
347 Status = EFI_NOT_FOUND;
348 }
349 return Status;
350 }
351
352 UINTN
353 GetUnalignedDevicePathSize (
354 IN EFI_DEVICE_PATH* DevicePath
355 )
356 {
357 UINTN Size;
358 EFI_DEVICE_PATH* AlignedDevicePath;
359
360 if ((UINTN)DevicePath & 0x1) {
361 AlignedDevicePath = DuplicateDevicePath (DevicePath);
362 Size = GetDevicePathSize (AlignedDevicePath);
363 FreePool (AlignedDevicePath);
364 } else {
365 Size = GetDevicePathSize (DevicePath);
366 }
367 return Size;
368 }
369
370 EFI_DEVICE_PATH*
371 GetAlignedDevicePath (
372 IN EFI_DEVICE_PATH* DevicePath
373 )
374 {
375 if ((UINTN)DevicePath & 0x1) {
376 return DuplicateDevicePath (DevicePath);
377 } else {
378 return DevicePath;
379 }
380 }
381
382 BOOLEAN
383 IsUnicodeString (
384 IN VOID* String
385 )
386 {
387 // We do not support NULL pointer
388 ASSERT (String != NULL);
389
390 if (*(CHAR16*)String < 0x100) {
391 //Note: We could get issue if the string is an empty Ascii string...
392 return TRUE;
393 } else {
394 return FALSE;
395 }
396 }
397
398 /*
399 * Try to detect if the given string is an ASCII or Unicode string
400 *
401 * There are actually few limitation to this function but it is mainly to give
402 * a user friendly output.
403 *
404 * Some limitations:
405 * - it only supports unicode string that use ASCII character (< 0x100)
406 * - single character ASCII strings are interpreted as Unicode string
407 * - string cannot be longer than 2 x BOOT_DEVICE_OPTION_MAX (600 bytes)
408 *
409 * @param String Buffer that might contain a Unicode or Ascii string
410 * @param IsUnicode If not NULL this boolean value returns if the string is an
411 * ASCII or Unicode string.
412 */
413 BOOLEAN
414 IsPrintableString (
415 IN VOID* String,
416 OUT BOOLEAN *IsUnicode
417 )
418 {
419 BOOLEAN UnicodeDetected;
420 BOOLEAN IsPrintable;
421 UINTN Index;
422 CHAR16 Character;
423
424 // We do not support NULL pointer
425 ASSERT (String != NULL);
426
427 // Test empty string
428 if (*(CHAR16*)String == L'\0') {
429 if (IsUnicode) {
430 *IsUnicode = TRUE;
431 }
432 return TRUE;
433 } else if (*(CHAR16*)String == '\0') {
434 if (IsUnicode) {
435 *IsUnicode = FALSE;
436 }
437 return TRUE;
438 }
439
440 // Limitation: if the string is an ASCII single character string. This comparison
441 // will assume it is a Unicode string.
442 if (*(CHAR16*)String < 0x100) {
443 UnicodeDetected = TRUE;
444 } else {
445 UnicodeDetected = FALSE;
446 }
447
448 IsPrintable = FALSE;
449 for (Index = 0; Index < BOOT_DEVICE_OPTION_MAX * 2; Index++) {
450 if (UnicodeDetected) {
451 Character = ((CHAR16*)String)[Index];
452 } else {
453 Character = ((CHAR8*)String)[Index];
454 }
455
456 if (Character == '\0') {
457 // End of the string
458 IsPrintable = TRUE;
459 break;
460 } else if ((Character < 0x20) || (Character > 0x7f)) {
461 // We only support the range of printable ASCII character
462 IsPrintable = FALSE;
463 break;
464 }
465 }
466
467 if (IsPrintable && IsUnicode) {
468 *IsUnicode = UnicodeDetected;
469 }
470
471 return IsPrintable;
472 }