code.delx.au - refind/blob - 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 // As a special case for Arch Linux the strings "linux" and "linux-lts"
 242 // are considered to be digits.
 243 CHAR16 *FindNumbers(IN CHAR16 *InString) {
 244     UINTN i, StartOfElement = 0, EndOfElement = 0, CopyLength;
 245     CHAR16 *Found = NULL;
 246
 247     if (InString == NULL)
 248         return NULL;
 249
 250     // Find "linux-lts" or "linux"
 251     Found = MyStrStr(InString, L"linux-lts");
 252     if (Found != NULL) {
 253         StartOfElement = Found - InString;
 254         EndOfElement = StartOfElement + StrLen(L"linux-lts") - 1;
 255     } else {
 256         Found = MyStrStr(InString, L"linux");
 257         if (Found != NULL) {
 258             StartOfElement = Found - InString;
 259             EndOfElement = StartOfElement + StrLen(L"linux") - 1;
 260         } // if
 261     } // if/else
 262     Found = NULL;
 263
 264     // Find start & end of target element
 265     for (i = 0; InString[i] != L'\0'; i++) {
 266         if ((InString[i] >= L'0') && (InString[i] <= L'9')) {
 267             if (StartOfElement > i)
 268                 StartOfElement = i;
 269             if (EndOfElement < i)
 270                 EndOfElement = i;
 271         } // if
 272     } // for
 273
 274     // Extract the target element
 275     if (EndOfElement > 0) {
 276         if (EndOfElement >= StartOfElement) {
 277             CopyLength = EndOfElement - StartOfElement + 1;
 278             Found = StrDuplicate(&InString[StartOfElement]);
 279             if (Found != NULL)
 280                 Found[CopyLength] = 0;
 281         } // if (EndOfElement >= StartOfElement)
 282     } // if (EndOfElement > 0)
 283     return (Found);
 284 } // CHAR16 *FindNumbers()
 285
 286 // Returns the number of characters that are in common between
 287 // String1 and String2 before they diverge. For instance, if
 288 // String1 is "FooBar" and String2 is "FoodiesBar", this function
 289 // will return "3", since they both start with "Foo".
 290 UINTN NumCharsInCommon(IN CHAR16* String1, IN CHAR16* String2) {
 291     UINTN Count = 0;
 292     if ((String1 == NULL) || (String2 == NULL))
 293         return 0;
 294     while ((String1[Count] != L'\0') && (String2[Count] != L'\0') && (String1[Count] == String2[Count]))
 295         Count++;
 296     return Count;
 297 } // UINTN NumCharsInCommon()
 298
 299 // Find the #Index element (numbered from 0) in a comma-delimited string
 300 // of elements.
 301 // Returns the found element, or NULL if Index is out of range or InString
 302 // is NULL. Note that the calling function is responsible for freeing the
 303 // memory associated with the returned string pointer.
 304 CHAR16 *FindCommaDelimited(IN CHAR16 *InString, IN UINTN Index) {
 305     UINTN    StartPos = 0, CurPos = 0, InLength;
 306     BOOLEAN  Found = FALSE;
 307     CHAR16   *FoundString = NULL;
 308
 309     if (InString != NULL) {
 310         InLength = StrLen(InString);
 311         // After while() loop, StartPos marks start of item #Index
 312         while ((Index > 0) && (CurPos < InLength)) {
 313             if (InString[CurPos] == L',') {
 314                 Index--;
 315                 StartPos = CurPos + 1;
 316             } // if
 317             CurPos++;
 318         } // while
 319         // After while() loop, CurPos is one past the end of the element
 320         while ((CurPos < InLength) && (!Found)) {
 321             if (InString[CurPos] == L',')
 322                 Found = TRUE;
 323             else
 324                 CurPos++;
 325         } // while
 326         if (Index == 0)
 327             FoundString = StrDuplicate(&InString[StartPos]);
 328         if (FoundString != NULL)
 329             FoundString[CurPos - StartPos] = 0;
 330     } // if
 331     return (FoundString);
 332 } // CHAR16 *FindCommaDelimited()
 333
 334 // Returns TRUE if SmallString is an element in the comma-delimited List,
 335 // FALSE otherwise. Performs comparison case-insensitively.
 336 BOOLEAN IsIn(IN CHAR16 *SmallString, IN CHAR16 *List) {
 337    UINTN     i = 0;
 338    BOOLEAN   Found = FALSE;
 339    CHAR16    *OneElement;
 340
 341    if (SmallString && List) {
 342       while (!Found && (OneElement = FindCommaDelimited(List, i++))) {
 343          if (MyStriCmp(OneElement, SmallString))
 344             Found = TRUE;
 345       } // while
 346    } // if
 347    return Found;
 348 } // BOOLEAN IsIn()
 349
 350 // Returns TRUE if any element of List can be found as a substring of
 351 // BigString, FALSE otherwise. Performs comparisons case-insensitively.
 352 BOOLEAN IsInSubstring(IN CHAR16 *BigString, IN CHAR16 *List) {
 353    UINTN   i = 0, ElementLength;
 354    BOOLEAN Found = FALSE;
 355    CHAR16  *OneElement;
 356
 357    if (BigString && List) {
 358       while (!Found && (OneElement = FindCommaDelimited(List, i++))) {
 359          ElementLength = StrLen(OneElement);
 360          if ((ElementLength <= StrLen(BigString)) && (StriSubCmp(OneElement, BigString)))
 361             Found = TRUE;
 362       } // while
 363    } // if
 364    return Found;
 365 } // BOOLEAN IsSubstringIn()
 366
 367 // Replace *SearchString in **MainString with *ReplString -- but if *SearchString
 368 // is preceded by "%", instead remove that character.
 369 // Returns TRUE if replacement was done, FALSE otherwise.
 370 BOOLEAN ReplaceSubstring(IN OUT CHAR16 **MainString, IN CHAR16 *SearchString, IN CHAR16 *ReplString) {
 371     BOOLEAN WasReplaced = FALSE;
 372     CHAR16 *FoundSearchString, *NewString, *EndString;
 373
 374     FoundSearchString = MyStrStr(*MainString, SearchString);
 375     if (FoundSearchString) {
 376         NewString = AllocateZeroPool(sizeof(CHAR16) * StrLen(*MainString));
 377         if (NewString) {
 378             EndString = &(FoundSearchString[StrLen(SearchString)]);
 379             FoundSearchString[0] = L'\0';
 380             if ((FoundSearchString > *MainString) && (FoundSearchString[-1] == L'%')) {
 381                 FoundSearchString[-1] = L'\0';
 382                 ReplString = SearchString;
 383             } // if
 384             StrCpy(NewString, *MainString);
 385             MergeStrings(&NewString, ReplString, L'\0');
 386             MergeStrings(&NewString, EndString, L'\0');
 387             MyFreePool(MainString);
 388             *MainString = NewString;
 389             WasReplaced = TRUE;
 390         } // if
 391     } // if
 392     return WasReplaced;
 393 } // BOOLEAN ReplaceSubstring()
 394
 395 // Returns TRUE if *Input contains nothing but valid hexadecimal characters,
 396 // FALSE otherwise. Note that a leading "0x" is NOT acceptable in the input!
 397 BOOLEAN IsValidHex(CHAR16 *Input) {
 398     BOOLEAN IsHex = TRUE;
 399     UINTN i = 0;
 400
 401     while ((Input[i] != L'\0') && IsHex) {
 402         if (!(((Input[i] >= L'0') && (Input[i] <= L'9')) ||
 403               ((Input[i] >= L'A') && (Input[i] <= L'F')) ||
 404               ((Input[i] >= L'a') && (Input[i] <= L'f')))) {
 405                 IsHex = FALSE;
 406         }
 407         i++;
 408     } // while
 409     return IsHex;
 410 } // BOOLEAN IsValidHex()
 411
 412 // Converts consecutive characters in the input string into a
 413 // number, interpreting the string as a hexadecimal number, starting
 414 // at the specified position and continuing for the specified number
 415 // of characters or until the end of the string, whichever is first.
 416 // NumChars must be between 1 and 16. Ignores invalid characters.
 417 UINT64 StrToHex(CHAR16 *Input, UINTN Pos, UINTN NumChars) {
 418     UINT64 retval = 0x00;
 419     UINTN  NumDone = 0, InputLength;
 420     CHAR16 a;
 421
 422     if ((Input == NULL) || (NumChars == 0) || (NumChars > 16)) {
 423         return 0;
 424     }
 425
 426     InputLength = StrLen(Input);
 427     while ((Pos <= InputLength) && (NumDone < NumChars)) {
 428         a = Input[Pos];
 429         if ((a >= '0') && (a <= '9')) {
 430             retval *= 0x10;
 431             retval += (a - '0');
 432             NumDone++;
 433         }
 434         if ((a >= 'a') && (a <= 'f')) {
 435             retval *= 0x10;
 436             retval += (a - 'a' + 0x0a);
 437             NumDone++;
 438         }
 439         if ((a >= 'A') && (a <= 'F')) {
 440             retval *= 0x10;
 441             retval += (a - 'A' + 0x0a);
 442             NumDone++;
 443         }
 444         Pos++;
 445     } // while()
 446     return retval;
 447 } // StrToHex()
 448
 449 // Returns TRUE if UnknownString can be interpreted as a GUID, FALSE otherwise.
 450 // Note that the input string must have no extraneous spaces and must be
 451 // conventionally formatted as a 36-character GUID, complete with dashes in
 452 // appropriate places.
 453 BOOLEAN IsGuid(CHAR16 *UnknownString) {
 454     UINTN   Length, i;
 455     BOOLEAN retval = TRUE;
 456     CHAR16  a;
 457
 458     if (UnknownString == NULL)
 459         return FALSE;
 460
 461     Length = StrLen(UnknownString);
 462     if (Length != 36)
 463         return FALSE;
 464
 465     for (i = 0; i < Length; i++) {
 466         a = UnknownString[i];
 467         if ((i == 8) || (i == 13) || (i == 18) || (i == 23)) {
 468             if (a != L'-')
 469                 retval = FALSE;
 470         } else if (((a < L'a') || (a > L'f')) &&
 471                    ((a < L'A') || (a > L'F')) &&
 472                    ((a < L'0') && (a > L'9'))) {
 473             retval = FALSE;
 474         } // if/else if
 475     } // for
 476     return retval;
 477 } // BOOLEAN IsGuid()
 478
 479 // Return the GUID as a string, suitable for display to the user. Note that the calling
 480 // function is responsible for freeing the allocated memory.
 481 CHAR16 * GuidAsString(EFI_GUID *GuidData) {
 482    CHAR16 *TheString;
 483
 484    TheString = AllocateZeroPool(42 * sizeof(CHAR16));
 485    if (TheString != 0) {
 486       SPrint (TheString, 82, L"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 487               (UINTN)GuidData->Data1, (UINTN)GuidData->Data2, (UINTN)GuidData->Data3,
 488               (UINTN)GuidData->Data4[0], (UINTN)GuidData->Data4[1], (UINTN)GuidData->Data4[2],
 489               (UINTN)GuidData->Data4[3], (UINTN)GuidData->Data4[4], (UINTN)GuidData->Data4[5],
 490               (UINTN)GuidData->Data4[6], (UINTN)GuidData->Data4[7]);
 491    }
 492    return TheString;
 493 } // GuidAsString(EFI_GUID *GuidData)
 494
 495 EFI_GUID StringAsGuid(CHAR16 * InString) {
 496     EFI_GUID  Guid = NULL_GUID_VALUE;
 497
 498     if (!IsGuid(InString)) {
 499         return Guid;
 500     }
 501
 502     Guid.Data1 = (UINT32) StrToHex(InString, 0, 8);
 503     Guid.Data2 = (UINT16) StrToHex(InString, 9, 4);
 504     Guid.Data3 = (UINT16) StrToHex(InString, 14, 4);
 505     Guid.Data4[0] = (UINT8) StrToHex(InString, 19, 2);
 506     Guid.Data4[1] = (UINT8) StrToHex(InString, 21, 2);
 507     Guid.Data4[2] = (UINT8) StrToHex(InString, 23, 2);
 508     Guid.Data4[3] = (UINT8) StrToHex(InString, 26, 2);
 509     Guid.Data4[4] = (UINT8) StrToHex(InString, 28, 2);
 510     Guid.Data4[5] = (UINT8) StrToHex(InString, 30, 2);
 511     Guid.Data4[6] = (UINT8) StrToHex(InString, 32, 2);
 512     Guid.Data4[7] = (UINT8) StrToHex(InString, 34, 2);
 513
 514     return Guid;
 515 } // EFI_GUID StringAsGuid()
 516
 517 // Delete the STRING_LIST pointed to by *StringList.
 518 VOID DeleteStringList(STRING_LIST *StringList) {
 519     STRING_LIST *Current = StringList, *Previous;
 520
 521     while (Current != NULL) {
 522         MyFreePool(Current->Value);
 523         Previous = Current;
 524         Current = Current->Next;
 525         MyFreePool(Previous);
 526     }
 527 } // VOID DeleteStringList()