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 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()