Added support for "%v" as a variable for the kernel version number in
[refind] / refind / mystrings.c
1 /*
2 * refind/mystrings.c
3 * String-manipulation functions
4 *
5 * Copyright (c) 2012-2015 Roderick W. Smith
6 *
7 * Distributed under the terms of the GNU General Public License (GPL)
8 * version 3 (GPLv3), or (at your option) any later version.
9 *
10 */
11 /*
12 * This program is free software: you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation, either version 3 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program. If not, see <http://www.gnu.org/licenses/>.
24 */
25
26
27 #include "mystrings.h"
28 #include "lib.h"
29
30 BOOLEAN StriSubCmp(IN CHAR16 *SmallStr, IN CHAR16 *BigStr) {
31 BOOLEAN Found = 0, Terminate = 0;
32 UINTN BigIndex = 0, SmallIndex = 0, BigStart = 0;
33
34 if (SmallStr && BigStr) {
35 while (!Terminate) {
36 if (BigStr[BigIndex] == '\0') {
37 Terminate = 1;
38 }
39 if (SmallStr[SmallIndex] == '\0') {
40 Found = 1;
41 Terminate = 1;
42 }
43 if ((SmallStr[SmallIndex] & ~0x20) == (BigStr[BigIndex] & ~0x20)) {
44 SmallIndex++;
45 BigIndex++;
46 } else {
47 SmallIndex = 0;
48 BigStart++;
49 BigIndex = BigStart;
50 }
51 } // while
52 } // if
53 return Found;
54 } // BOOLEAN StriSubCmp()
55
56 // Performs a case-insensitive string comparison. This function is necesary
57 // because some EFIs have buggy StriCmp() functions that actually perform
58 // case-sensitive comparisons.
59 // Returns TRUE if strings are identical, FALSE otherwise.
60 BOOLEAN MyStriCmp(IN CONST CHAR16 *FirstString, IN CONST CHAR16 *SecondString) {
61 if (FirstString && SecondString) {
62 while ((*FirstString != L'\0') && ((*FirstString & ~0x20) == (*SecondString & ~0x20))) {
63 FirstString++;
64 SecondString++;
65 }
66 return (*FirstString == *SecondString);
67 } else {
68 return FALSE;
69 }
70 } // BOOLEAN MyStriCmp()
71
72 /*++
73 *
74 * Routine Description:
75 *
76 * Find a substring.
77 *
78 * Arguments:
79 *
80 * String - Null-terminated string to search.
81 * StrCharSet - Null-terminated string to search for.
82 *
83 * Returns:
84 * The address of the first occurrence of the matching substring if successful, or NULL otherwise.
85 * --*/
86 CHAR16* MyStrStr (IN CHAR16 *String, IN CHAR16 *StrCharSet)
87 {
88 CHAR16 *Src;
89 CHAR16 *Sub;
90
91 if ((String == NULL) || (StrCharSet == NULL))
92 return NULL;
93
94 Src = String;
95 Sub = StrCharSet;
96
97 while ((*String != L'\0') && (*StrCharSet != L'\0')) {
98 if (*String++ != *StrCharSet) {
99 String = ++Src;
100 StrCharSet = Sub;
101 } else {
102 StrCharSet++;
103 }
104 }
105 if (*StrCharSet == L'\0') {
106 return Src;
107 } else {
108 return NULL;
109 }
110 } // CHAR16 *MyStrStr()
111
112 // Convert input string to all-lowercase.
113 // DO NOT USE the standard StrLwr() function, since it's broken on some EFIs!
114 VOID ToLower(CHAR16 * MyString) {
115 UINTN i = 0;
116
117 if (MyString) {
118 while (MyString[i] != L'\0') {
119 if ((MyString[i] >= L'A') && (MyString[i] <= L'Z'))
120 MyString[i] = MyString[i] - L'A' + L'a';
121 i++;
122 } // while
123 } // if
124 } // VOID ToLower()
125
126 // Merges two strings, creating a new one and returning a pointer to it.
127 // If AddChar != 0, the specified character is placed between the two original
128 // strings (unless the first string is NULL or empty). The original input
129 // string *First is de-allocated and replaced by the new merged string.
130 // This is similar to StrCat, but safer and more flexible because
131 // MergeStrings allocates memory that's the correct size for the
132 // new merged string, so it can take a NULL *First and it cleans
133 // up the old memory. It should *NOT* be used with a constant
134 // *First, though....
135 VOID MergeStrings(IN OUT CHAR16 **First, IN CHAR16 *Second, CHAR16 AddChar) {
136 UINTN Length1 = 0, Length2 = 0;
137 CHAR16* NewString;
138
139 if (*First != NULL)
140 Length1 = StrLen(*First);
141 if (Second != NULL)
142 Length2 = StrLen(Second);
143 NewString = AllocatePool(sizeof(CHAR16) * (Length1 + Length2 + 2));
144 if (NewString != NULL) {
145 if ((*First != NULL) && (Length1 == 0)) {
146 MyFreePool(*First);
147 *First = NULL;
148 }
149 NewString[0] = L'\0';
150 if (*First != NULL) {
151 StrCat(NewString, *First);
152 if (AddChar) {
153 NewString[Length1] = AddChar;
154 NewString[Length1 + 1] = '\0';
155 } // if (AddChar)
156 } // if (*First != NULL)
157 if (Second != NULL)
158 StrCat(NewString, Second);
159 MyFreePool(*First);
160 *First = NewString;
161 } else {
162 Print(L"Error! Unable to allocate memory in MergeStrings()!\n");
163 } // if/else
164 } // VOID MergeStrings()
165
166 // Similar to MergeStrings, but breaks the input string into word chunks and
167 // merges each word separately. Words are defined as string fragments separated
168 // by ' ', '_', or '-'.
169 VOID MergeWords(CHAR16 **MergeTo, CHAR16 *SourceString, CHAR16 AddChar) {
170 CHAR16 *Temp, *Word, *p;
171 BOOLEAN LineFinished = FALSE;
172
173 if (SourceString) {
174 Temp = Word = p = StrDuplicate(SourceString);
175 if (Temp) {
176 while (!LineFinished) {
177 if ((*p == L' ') || (*p == L'_') || (*p == L'-') || (*p == L'\0')) {
178 if (*p == L'\0')
179 LineFinished = TRUE;
180 *p = L'\0';
181 if (*Word != L'\0')
182 MergeStrings(MergeTo, Word, AddChar);
183 Word = p + 1;
184 } // if
185 p++;
186 } // while
187 MyFreePool(Temp);
188 } else {
189 Print(L"Error! Unable to allocate memory in MergeWords()!\n");
190 } // if/else
191 } // if
192 } // VOID MergeWords()
193
194 // Restrict TheString to at most Limit characters.
195 // Does this in two ways:
196 // - Locates stretches of two or more spaces and compresses
197 // them down to one space.
198 // - Truncates TheString
199 // Returns TRUE if changes were made, FALSE otherwise
200 BOOLEAN LimitStringLength(CHAR16 *TheString, UINTN Limit) {
201 CHAR16 *SubString, *TempString;
202 UINTN i;
203 BOOLEAN HasChanged = FALSE;
204
205 // SubString will be NULL or point WITHIN TheString
206 SubString = MyStrStr(TheString, L" ");
207 while (SubString != NULL) {
208 i = 0;
209 while (SubString[i] == L' ')
210 i++;
211 if (i >= StrLen(SubString)) {
212 SubString[0] = '\0';
213 HasChanged = TRUE;
214 } else {
215 TempString = StrDuplicate(&SubString[i]);
216 if (TempString != NULL) {
217 StrCpy(&SubString[1], TempString);
218 MyFreePool(TempString);
219 HasChanged = TRUE;
220 } else {
221 // memory allocation problem; abort to avoid potentially infinite loop!
222 break;
223 } // if/else
224 } // if/else
225 SubString = MyStrStr(TheString, L" ");
226 } // while
227
228 // If the string is still too long, truncate it....
229 if (StrLen(TheString) > Limit) {
230 TheString[Limit] = '\0';
231 HasChanged = TRUE;
232 } // if
233
234 return HasChanged;
235 } // BOOLEAN LimitStringLength()
236
237 // Returns all the digits in the input string, including intervening
238 // non-digit characters. For instance, if InString is "foo-3.3.4-7.img",
239 // this function returns "3.3.4-7". If InString contains no digits,
240 // the return value is NULL.
241 CHAR16 *FindNumbers(IN CHAR16 *InString) {
242 UINTN i, StartOfElement, EndOfElement = 0, CopyLength;
243 CHAR16 *Found = NULL;
244
245 if (InString == NULL)
246 return NULL;
247
248 StartOfElement = StrLen(InString);
249 // Find start & end of target element
250 for (i = 0; InString[i] != L'\0'; i++) {
251 if ((InString[i] >= L'0') && (InString[i] <= L'9')) {
252 if (StartOfElement > i)
253 StartOfElement = i;
254 if (EndOfElement < i)
255 EndOfElement = i;
256 } // if
257 } // for
258 // Extract the target element
259 if (EndOfElement > 0) {
260 if (EndOfElement >= StartOfElement) {
261 CopyLength = EndOfElement - StartOfElement + 1;
262 Found = StrDuplicate(&InString[StartOfElement]);
263 if (Found != NULL)
264 Found[CopyLength] = 0;
265 } // if (EndOfElement >= StartOfElement)
266 } // if (EndOfElement > 0)
267 return (Found);
268 } // CHAR16 *FindNumbers()
269
270 // Returns the number of characters that are in common between
271 // String1 and String2 before they diverge. For instance, if
272 // String1 is "FooBar" and String2 is "FoodiesBar", this function
273 // will return "3", since they both start with "Foo".
274 UINTN NumCharsInCommon(IN CHAR16* String1, IN CHAR16* String2) {
275 UINTN Count = 0;
276 if ((String1 == NULL) || (String2 == NULL))
277 return 0;
278 while ((String1[Count] != L'\0') && (String2[Count] != L'\0') && (String1[Count] == String2[Count]))
279 Count++;
280 return Count;
281 } // UINTN NumCharsInCommon()
282
283 // Find the #Index element (numbered from 0) in a comma-delimited string
284 // of elements.
285 // Returns the found element, or NULL if Index is out of range or InString
286 // is NULL. Note that the calling function is responsible for freeing the
287 // memory associated with the returned string pointer.
288 CHAR16 *FindCommaDelimited(IN CHAR16 *InString, IN UINTN Index) {
289 UINTN StartPos = 0, CurPos = 0, InLength;
290 BOOLEAN Found = FALSE;
291 CHAR16 *FoundString = NULL;
292
293 if (InString != NULL) {
294 InLength = StrLen(InString);
295 // After while() loop, StartPos marks start of item #Index
296 while ((Index > 0) && (CurPos < InLength)) {
297 if (InString[CurPos] == L',') {
298 Index--;
299 StartPos = CurPos + 1;
300 } // if
301 CurPos++;
302 } // while
303 // After while() loop, CurPos is one past the end of the element
304 while ((CurPos < InLength) && (!Found)) {
305 if (InString[CurPos] == L',')
306 Found = TRUE;
307 else
308 CurPos++;
309 } // while
310 if (Index == 0)
311 FoundString = StrDuplicate(&InString[StartPos]);
312 if (FoundString != NULL)
313 FoundString[CurPos - StartPos] = 0;
314 } // if
315 return (FoundString);
316 } // CHAR16 *FindCommaDelimited()
317
318 // Returns TRUE if SmallString is an element in the comma-delimited List,
319 // FALSE otherwise. Performs comparison case-insensitively.
320 BOOLEAN IsIn(IN CHAR16 *SmallString, IN CHAR16 *List) {
321 UINTN i = 0;
322 BOOLEAN Found = FALSE;
323 CHAR16 *OneElement;
324
325 if (SmallString && List) {
326 while (!Found && (OneElement = FindCommaDelimited(List, i++))) {
327 if (MyStriCmp(OneElement, SmallString))
328 Found = TRUE;
329 } // while
330 } // if
331 return Found;
332 } // BOOLEAN IsIn()
333
334 // Returns TRUE if any element of List can be found as a substring of
335 // BigString, FALSE otherwise. Performs comparisons case-insensitively.
336 BOOLEAN IsInSubstring(IN CHAR16 *BigString, IN CHAR16 *List) {
337 UINTN i = 0, ElementLength;
338 BOOLEAN Found = FALSE;
339 CHAR16 *OneElement;
340
341 if (BigString && List) {
342 while (!Found && (OneElement = FindCommaDelimited(List, i++))) {
343 ElementLength = StrLen(OneElement);
344 if ((ElementLength <= StrLen(BigString)) && (StriSubCmp(OneElement, BigString)))
345 Found = TRUE;
346 } // while
347 } // if
348 return Found;
349 } // BOOLEAN IsSubstringIn()
350
351 // Replace *SearchString in **MainString with *ReplString.
352 // Returns TRUE if replacement was done, FALSE otherwise.
353 BOOLEAN ReplaceSubstring(IN OUT CHAR16 **MainString, IN CHAR16 *SearchString, IN CHAR16 *ReplString) {
354 BOOLEAN WasReplaced = FALSE;
355 CHAR16 *FoundSearchString, *NewString, *EndString;
356
357 FoundSearchString = MyStrStr(*MainString, SearchString);
358 if (FoundSearchString) {
359 NewString = AllocateZeroPool(sizeof(CHAR16) * StrLen(*MainString));
360 if (NewString) {
361 EndString = &(FoundSearchString[StrLen(SearchString)]);
362 FoundSearchString[0] = L'\0';
363 StrCpy(NewString, *MainString);
364 MergeStrings(&NewString, ReplString, L'\0');
365 MergeStrings(&NewString, EndString, L'\0');
366 MyFreePool(MainString);
367 *MainString = NewString;
368 WasReplaced = TRUE;
369 } // if
370 } // if
371 return WasReplaced;
372 } // BOOLEAN ReplaceSubstring()
373
374 // Returns TRUE if *Input contains nothing but valid hexadecimal characters,
375 // FALSE otherwise. Note that a leading "0x" is NOT acceptable in the input!
376 BOOLEAN IsValidHex(CHAR16 *Input) {
377 BOOLEAN IsHex = TRUE;
378 UINTN i = 0;
379
380 while ((Input[i] != L'\0') && IsHex) {
381 if (!(((Input[i] >= L'0') && (Input[i] <= L'9')) ||
382 ((Input[i] >= L'A') && (Input[i] <= L'F')) ||
383 ((Input[i] >= L'a') && (Input[i] <= L'f')))) {
384 IsHex = FALSE;
385 }
386 i++;
387 } // while
388 return IsHex;
389 } // BOOLEAN IsValidHex()
390
391 // Converts consecutive characters in the input string into a
392 // number, interpreting the string as a hexadecimal number, starting
393 // at the specified position and continuing for the specified number
394 // of characters or until the end of the string, whichever is first.
395 // NumChars must be between 1 and 16. Ignores invalid characters.
396 UINT64 StrToHex(CHAR16 *Input, UINTN Pos, UINTN NumChars) {
397 UINT64 retval = 0x00;
398 UINTN NumDone = 0, InputLength;
399 CHAR16 a;
400
401 if ((Input == NULL) || (NumChars == 0) || (NumChars > 16)) {
402 return 0;
403 }
404
405 InputLength = StrLen(Input);
406 while ((Pos <= InputLength) && (NumDone < NumChars)) {
407 a = Input[Pos];
408 if ((a >= '0') && (a <= '9')) {
409 retval *= 0x10;
410 retval += (a - '0');
411 NumDone++;
412 }
413 if ((a >= 'a') && (a <= 'f')) {
414 retval *= 0x10;
415 retval += (a - 'a' + 0x0a);
416 NumDone++;
417 }
418 if ((a >= 'A') && (a <= 'F')) {
419 retval *= 0x10;
420 retval += (a - 'A' + 0x0a);
421 NumDone++;
422 }
423 Pos++;
424 } // while()
425 return retval;
426 } // StrToHex()
427
428 // Returns TRUE if UnknownString can be interpreted as a GUID, FALSE otherwise.
429 // Note that the input string must have no extraneous spaces and must be
430 // conventionally formatted as a 36-character GUID, complete with dashes in
431 // appropriate places.
432 BOOLEAN IsGuid(CHAR16 *UnknownString) {
433 UINTN Length, i;
434 BOOLEAN retval = TRUE;
435 CHAR16 a;
436
437 if (UnknownString == NULL)
438 return FALSE;
439
440 Length = StrLen(UnknownString);
441 if (Length != 36)
442 return FALSE;
443
444 for (i = 0; i < Length; i++) {
445 a = UnknownString[i];
446 if ((i == 8) || (i == 13) || (i == 18) || (i == 23)) {
447 if (a != L'-')
448 retval = FALSE;
449 } else if (((a < L'a') || (a > L'f')) &&
450 ((a < L'A') || (a > L'F')) &&
451 ((a < L'0') && (a > L'9'))) {
452 retval = FALSE;
453 } // if/else if
454 } // for
455 return retval;
456 } // BOOLEAN IsGuid()
457
458 // Return the GUID as a string, suitable for display to the user. Note that the calling
459 // function is responsible for freeing the allocated memory.
460 CHAR16 * GuidAsString(EFI_GUID *GuidData) {
461 CHAR16 *TheString;
462
463 TheString = AllocateZeroPool(42 * sizeof(CHAR16));
464 if (TheString != 0) {
465 SPrint (TheString, 82, L"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
466 (UINTN)GuidData->Data1, (UINTN)GuidData->Data2, (UINTN)GuidData->Data3,
467 (UINTN)GuidData->Data4[0], (UINTN)GuidData->Data4[1], (UINTN)GuidData->Data4[2],
468 (UINTN)GuidData->Data4[3], (UINTN)GuidData->Data4[4], (UINTN)GuidData->Data4[5],
469 (UINTN)GuidData->Data4[6], (UINTN)GuidData->Data4[7]);
470 }
471 return TheString;
472 } // GuidAsString(EFI_GUID *GuidData)
473
474 EFI_GUID StringAsGuid(CHAR16 * InString) {
475 EFI_GUID Guid = NULL_GUID_VALUE;
476
477 if (!IsGuid(InString)) {
478 return Guid;
479 }
480
481 Guid.Data1 = (UINT32) StrToHex(InString, 0, 8);
482 Guid.Data2 = (UINT16) StrToHex(InString, 9, 4);
483 Guid.Data3 = (UINT16) StrToHex(InString, 14, 4);
484 Guid.Data4[0] = (UINT8) StrToHex(InString, 19, 2);
485 Guid.Data4[1] = (UINT8) StrToHex(InString, 21, 2);
486 Guid.Data4[2] = (UINT8) StrToHex(InString, 23, 2);
487 Guid.Data4[3] = (UINT8) StrToHex(InString, 26, 2);
488 Guid.Data4[4] = (UINT8) StrToHex(InString, 28, 2);
489 Guid.Data4[5] = (UINT8) StrToHex(InString, 30, 2);
490 Guid.Data4[6] = (UINT8) StrToHex(InString, 32, 2);
491 Guid.Data4[7] = (UINT8) StrToHex(InString, 34, 2);
492
493 return Guid;
494 } // EFI_GUID StringAsGuid()
495
496 // Delete the STRING_LIST pointed to by *StringList.
497 VOID DeleteStringList(STRING_LIST *StringList) {
498 STRING_LIST *Current = StringList, *Previous;
499
500 while (Current != NULL) {
501 MyFreePool(Current->Value);
502 Previous = Current;
503 Current = Current->Next;
504 MyFreePool(Previous);
505 }
506 } // VOID DeleteStringList()