code.delx.au - refind/blob - refind/config.c

   1 /*
   2  * refit/config.c
   3  * Configuration file functions
   4  *
   5  * Copyright (c) 2006 Christoph Pfisterer
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are
  10  * met:
  11  *
  12  *  * Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  *  * Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  *  * Neither the name of Christoph Pfisterer nor the names of the
  21  *    contributors may be used to endorse or promote products derived
  22  *    from this software without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  25  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  26  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  27  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  28  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  29  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  30  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  31  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  32  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  33  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  34  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  */
  36
  37 /*
  38  * Modifications copyright (c) 2012-2013 Roderick W. Smith
  39  *
  40  * Modifications distributed under the terms of the GNU General Public
  41  * License (GPL) version 3 (GPLv3), a copy of which must be distributed
  42  * with this source code or binaries made from it.
  43  *
  44  */
  45
  46 #include "global.h"
  47 #include "lib.h"
  48 #include "icns.h"
  49 #include "menu.h"
  50 #include "config.h"
  51 #include "screen.h"
  52 #include "../include/refit_call_wrapper.h"
  53
  54 // constants
  55
  56 #define LINUX_OPTIONS_FILENAMES  L"refind_linux.conf,refind-linux.conf"
  57 #define MAXCONFIGFILESIZE        (128*1024)
  58
  59 #define ENCODING_ISO8859_1  (0)
  60 #define ENCODING_UTF8       (1)
  61 #define ENCODING_UTF16_LE   (2)
  62
  63 static REFIT_MENU_ENTRY MenuEntryReturn   = { L"Return to Main Menu", TAG_RETURN, 0, 0, 0, NULL, NULL, NULL };
  64
  65 //
  66 // read a file into a buffer
  67 //
  68
  69 EFI_STATUS ReadFile(IN EFI_FILE_HANDLE BaseDir, IN CHAR16 *FileName, IN OUT REFIT_FILE *File, OUT UINTN *size)
  70 {
  71     EFI_STATUS      Status;
  72     EFI_FILE_HANDLE FileHandle;
  73     EFI_FILE_INFO   *FileInfo;
  74     UINT64          ReadSize;
  75     CHAR16          Message[256];
  76
  77     File->Buffer = NULL;
  78     File->BufferSize = 0;
  79
  80     // read the file, allocating a buffer on the way
  81     Status = refit_call5_wrapper(BaseDir->Open, BaseDir, &FileHandle, FileName, EFI_FILE_MODE_READ, 0);
  82     SPrint(Message, 255, L"while loading the file '%s'", FileName);
  83     if (CheckError(Status, Message))
  84         return Status;
  85
  86     FileInfo = LibFileInfo(FileHandle);
  87     if (FileInfo == NULL) {
  88         // TODO: print and register the error
  89         refit_call1_wrapper(FileHandle->Close, FileHandle);
  90         return EFI_LOAD_ERROR;
  91     }
  92     ReadSize = FileInfo->FileSize;
  93     FreePool(FileInfo);
  94
  95     File->BufferSize = (UINTN)ReadSize;
  96     File->Buffer = AllocatePool(File->BufferSize);
  97     if (File->Buffer == NULL) {
  98        size = 0;
  99        return EFI_OUT_OF_RESOURCES;
 100     } else {
 101        *size = File->BufferSize;
 102     } // if/else
 103     Status = refit_call3_wrapper(FileHandle->Read, FileHandle, &File->BufferSize, File->Buffer);
 104     if (CheckError(Status, Message)) {
 105         MyFreePool(File->Buffer);
 106         File->Buffer = NULL;
 107         refit_call1_wrapper(FileHandle->Close, FileHandle);
 108         return Status;
 109     }
 110     Status = refit_call1_wrapper(FileHandle->Close, FileHandle);
 111
 112     // setup for reading
 113     File->Current8Ptr  = (CHAR8 *)File->Buffer;
 114     File->End8Ptr      = File->Current8Ptr + File->BufferSize;
 115     File->Current16Ptr = (CHAR16 *)File->Buffer;
 116     File->End16Ptr     = File->Current16Ptr + (File->BufferSize >> 1);
 117
 118     // detect encoding
 119     File->Encoding = ENCODING_ISO8859_1;   // default: 1:1 translation of CHAR8 to CHAR16
 120     if (File->BufferSize >= 4) {
 121         if (File->Buffer[0] == 0xFF && File->Buffer[1] == 0xFE) {
 122             // BOM in UTF-16 little endian (or UTF-32 little endian)
 123             File->Encoding = ENCODING_UTF16_LE;   // use CHAR16 as is
 124             File->Current16Ptr++;
 125         } else if (File->Buffer[0] == 0xEF && File->Buffer[1] == 0xBB && File->Buffer[2] == 0xBF) {
 126             // BOM in UTF-8
 127             File->Encoding = ENCODING_UTF8;       // translate from UTF-8 to UTF-16
 128             File->Current8Ptr += 3;
 129         } else if (File->Buffer[1] == 0 && File->Buffer[3] == 0) {
 130             File->Encoding = ENCODING_UTF16_LE;   // use CHAR16 as is
 131         }
 132         // TODO: detect other encodings as they are implemented
 133     }
 134
 135     return EFI_SUCCESS;
 136 }
 137
 138 //
 139 // get a single line of text from a file
 140 //
 141
 142 static CHAR16 *ReadLine(REFIT_FILE *File)
 143 {
 144     CHAR16  *Line, *q;
 145     UINTN   LineLength;
 146
 147     if (File->Buffer == NULL)
 148         return NULL;
 149
 150     if (File->Encoding == ENCODING_ISO8859_1 || File->Encoding == ENCODING_UTF8) {
 151
 152         CHAR8 *p, *LineStart, *LineEnd;
 153
 154         p = File->Current8Ptr;
 155         if (p >= File->End8Ptr)
 156             return NULL;
 157
 158         LineStart = p;
 159         for (; p < File->End8Ptr; p++)
 160             if (*p == 13 || *p == 10)
 161                 break;
 162         LineEnd = p;
 163         for (; p < File->End8Ptr; p++)
 164             if (*p != 13 && *p != 10)
 165                 break;
 166         File->Current8Ptr = p;
 167
 168         LineLength = (UINTN)(LineEnd - LineStart) + 1;
 169         Line = AllocatePool(LineLength * sizeof(CHAR16));
 170         if (Line == NULL)
 171             return NULL;
 172
 173         q = Line;
 174         if (File->Encoding == ENCODING_ISO8859_1) {
 175             for (p = LineStart; p < LineEnd; )
 176                 *q++ = *p++;
 177         } else if (File->Encoding == ENCODING_UTF8) {
 178             // TODO: actually handle UTF-8
 179             for (p = LineStart; p < LineEnd; )
 180                 *q++ = *p++;
 181         }
 182         *q = 0;
 183
 184     } else if (File->Encoding == ENCODING_UTF16_LE) {
 185
 186         CHAR16 *p, *LineStart, *LineEnd;
 187
 188         p = File->Current16Ptr;
 189         if (p >= File->End16Ptr)
 190             return NULL;
 191
 192         LineStart = p;
 193         for (; p < File->End16Ptr; p++)
 194             if (*p == 13 || *p == 10)
 195                 break;
 196         LineEnd = p;
 197         for (; p < File->End16Ptr; p++)
 198             if (*p != 13 && *p != 10)
 199                 break;
 200         File->Current16Ptr = p;
 201
 202         LineLength = (UINTN)(LineEnd - LineStart) + 1;
 203         Line = AllocatePool(LineLength * sizeof(CHAR16));
 204         if (Line == NULL)
 205             return NULL;
 206
 207         for (p = LineStart, q = Line; p < LineEnd; )
 208             *q++ = *p++;
 209         *q = 0;
 210
 211     } else
 212         return NULL;   // unsupported encoding
 213
 214     return Line;
 215 }
 216
 217 // Returns FALSE if *p points to the end of a token, TRUE otherwise.
 218 // Also modifies *p **IF** the first and second characters are both
 219 // quotes ('"'); it deletes one of them.
 220 static BOOLEAN KeepReading(IN OUT CHAR16 *p, IN OUT BOOLEAN *IsQuoted) {
 221    BOOLEAN MoreToRead = FALSE;
 222    CHAR16  *Temp = NULL;
 223
 224    if ((p == NULL) || (IsQuoted == NULL))
 225       return FALSE;
 226
 227    if (*p == L'\0')
 228       return FALSE;
 229
 230    if ((*p != ' ' && *p != '\t' && *p != '=' && *p != '#' && *p != ',') || *IsQuoted) {
 231       MoreToRead = TRUE;
 232    }
 233    if (*p == L'"') {
 234       if (p[1] == L'"') {
 235          Temp = StrDuplicate(&p[1]);
 236          if (Temp != NULL) {
 237             StrCpy(p, Temp);
 238             FreePool(Temp);
 239          }
 240          MoreToRead = TRUE;
 241       } else {
 242          *IsQuoted = !(*IsQuoted);
 243          MoreToRead = FALSE;
 244       } // if/else second character is a quote
 245    } // if first character is a quote
 246
 247    return MoreToRead;
 248 } // BOOLEAN KeepReading()
 249
 250 //
 251 // get a line of tokens from a file
 252 //
 253 UINTN ReadTokenLine(IN REFIT_FILE *File, OUT CHAR16 ***TokenList)
 254 {
 255     BOOLEAN         LineFinished, IsQuoted = FALSE;
 256     CHAR16          *Line, *Token, *p;
 257     UINTN           TokenCount = 0;
 258
 259     *TokenList = NULL;
 260
 261     while (TokenCount == 0) {
 262         Line = ReadLine(File);
 263         if (Line == NULL)
 264             return(0);
 265
 266         p = Line;
 267         LineFinished = FALSE;
 268         while (!LineFinished) {
 269             // skip whitespace & find start of token
 270             while ((*p == ' ' || *p == '\t' || *p == '=' || *p == ',') && !IsQuoted)
 271                 p++;
 272             if (*p == 0 || *p == '#')
 273                 break;
 274
 275             if (*p == '"') {
 276                IsQuoted = !IsQuoted;
 277                p++;
 278             } // if
 279             Token = p;
 280
 281             // find end of token
 282             while (KeepReading(p, &IsQuoted)) {
 283                if ((*p == L'/') && !IsQuoted) // Switch Unix-style to DOS-style directory separators
 284                   *p = L'\\';
 285                p++;
 286             } // while
 287             if (*p == L'\0' || *p == L'#')
 288                 LineFinished = TRUE;
 289             *p++ = 0;
 290
 291             AddListElement((VOID ***)TokenList, &TokenCount, (VOID *)StrDuplicate(Token));
 292         }
 293
 294         FreePool(Line);
 295     }
 296     return (TokenCount);
 297 } /* ReadTokenLine() */
 298
 299 VOID FreeTokenLine(IN OUT CHAR16 ***TokenList, IN OUT UINTN *TokenCount)
 300 {
 301     // TODO: also free the items
 302     FreeList((VOID ***)TokenList, TokenCount);
 303 }
 304
 305 // handle a parameter with a single integer argument
 306 static VOID HandleInt(IN CHAR16 **TokenList, IN UINTN TokenCount, OUT UINTN *Value)
 307 {
 308     if (TokenCount == 2)
 309        *Value = Atoi(TokenList[1]);
 310 }
 311
 312 // handle a parameter with a single string argument
 313 static VOID HandleString(IN CHAR16 **TokenList, IN UINTN TokenCount, OUT CHAR16 **Target) {
 314    if (TokenCount == 2) {
 315       MyFreePool(*Target);
 316       *Target = StrDuplicate(TokenList[1]);
 317    } // if
 318 } // static VOID HandleString()
 319
 320 // Handle a parameter with a series of string arguments, to be added to a comma-delimited
 321 // list. Passes each token through the CleanUpPathNameSlashes() function to ensure
 322 // consistency in subsequent comparisons of filenames.
 323 static VOID HandleStrings(IN CHAR16 **TokenList, IN UINTN TokenCount, OUT CHAR16 **Target) {
 324    UINTN i;
 325
 326    if (*Target != NULL) {
 327       FreePool(*Target);
 328       *Target = NULL;
 329    } // if
 330    for (i = 1; i < TokenCount; i++) {
 331       CleanUpPathNameSlashes(TokenList[i]);
 332       MergeStrings(Target, TokenList[i], L',');
 333    }
 334 } // static VOID HandleStrings()
 335
 336 // read config file
 337 VOID ReadConfig(CHAR16 *FileName)
 338 {
 339     EFI_STATUS      Status;
 340     REFIT_FILE      File;
 341     CHAR16          **TokenList;
 342     CHAR16          *FlagName;
 343     CHAR16          *SelfPath = NULL;
 344     UINTN           TokenCount, i;
 345
 346     // Set a few defaults only if we're loading the default file.
 347     if (StriCmp(FileName, CONFIG_FILE_NAME) == 0) {
 348        MyFreePool(GlobalConfig.AlsoScan);
 349        GlobalConfig.AlsoScan = StrDuplicate(ALSO_SCAN_DIRS);
 350        MyFreePool(GlobalConfig.DontScanDirs);
 351        if (SelfVolume) {
 352           if (SelfVolume->VolName) {
 353              SelfPath = SelfVolume->VolName ? StrDuplicate(SelfVolume->VolName) : NULL;
 354           } else {
 355              SelfPath = AllocateZeroPool(256 * sizeof(CHAR16));
 356              if (SelfPath != NULL)
 357                 SPrint(SelfPath, 255, L"fs%d", SelfVolume->VolNumber);
 358           } // if/else
 359        }
 360        MergeStrings(&SelfPath, SelfDirPath, L':');
 361        GlobalConfig.DontScanDirs = SelfPath;
 362        MyFreePool(GlobalConfig.DontScanFiles);
 363        GlobalConfig.DontScanFiles = StrDuplicate(DONT_SCAN_FILES);
 364        MergeStrings(&(GlobalConfig.DontScanFiles), MOK_NAMES, L',');
 365        MyFreePool(GlobalConfig.DontScanVolumes);
 366        GlobalConfig.DontScanVolumes = StrDuplicate(DONT_SCAN_VOLUMES);
 367     } // if
 368
 369     if (!FileExists(SelfDir, FileName)) {
 370         Print(L"Configuration file '%s' missing!\n", FileName);
 371         return;
 372     }
 373
 374     Status = ReadFile(SelfDir, FileName, &File, &i);
 375     if (EFI_ERROR(Status))
 376         return;
 377
 378     for (;;) {
 379         TokenCount = ReadTokenLine(&File, &TokenList);
 380         if (TokenCount == 0)
 381             break;
 382
 383         if (StriCmp(TokenList[0], L"timeout") == 0) {
 384             HandleInt(TokenList, TokenCount, &(GlobalConfig.Timeout));
 385
 386         } else if (StriCmp(TokenList[0], L"hideui") == 0) {
 387             for (i = 1; i < TokenCount; i++) {
 388                 FlagName = TokenList[i];
 389                 if (StriCmp(FlagName, L"banner") == 0) {
 390                    GlobalConfig.HideUIFlags |= HIDEUI_FLAG_BANNER;
 391                 } else if (StriCmp(FlagName, L"label") == 0) {
 392                    GlobalConfig.HideUIFlags |= HIDEUI_FLAG_LABEL;
 393                 } else if (StriCmp(FlagName, L"singleuser") == 0) {
 394                    GlobalConfig.HideUIFlags |= HIDEUI_FLAG_SINGLEUSER;
 395                 } else if (StriCmp(FlagName, L"hwtest") == 0) {
 396                    GlobalConfig.HideUIFlags |= HIDEUI_FLAG_HWTEST;
 397                 } else if (StriCmp(FlagName, L"arrows") == 0) {
 398                    GlobalConfig.HideUIFlags |= HIDEUI_FLAG_ARROWS;
 399                 } else if (StriCmp(FlagName, L"hints") == 0) {
 400                    GlobalConfig.HideUIFlags |= HIDEUI_FLAG_HINTS;
 401                 } else if (StriCmp(FlagName, L"editor") == 0) {
 402                    GlobalConfig.HideUIFlags |= HIDEUI_FLAG_EDITOR;
 403                 } else if (StriCmp(FlagName, L"safemode") == 0) {
 404                    GlobalConfig.HideUIFlags |= HIDEUI_FLAG_SAFEMODE;
 405                 } else if (StriCmp(FlagName, L"all") == 0) {
 406                    GlobalConfig.HideUIFlags = HIDEUI_FLAG_ALL;
 407                 } else {
 408                     Print(L" unknown hideui flag: '%s'\n", FlagName);
 409                 }
 410             }
 411
 412         } else if (StriCmp(TokenList[0], L"icons_dir") == 0) {
 413            HandleString(TokenList, TokenCount, &(GlobalConfig.IconsDir));
 414
 415         } else if (StriCmp(TokenList[0], L"scanfor") == 0) {
 416            for (i = 0; i < NUM_SCAN_OPTIONS; i++) {
 417               if (i < TokenCount)
 418                  GlobalConfig.ScanFor[i] = TokenList[i][0];
 419               else
 420                  GlobalConfig.ScanFor[i] = ' ';
 421            }
 422
 423         } else if ((StriCmp(TokenList[0], L"scan_delay") == 0) && (TokenCount == 2)) {
 424            HandleInt(TokenList, TokenCount, &(GlobalConfig.ScanDelay));
 425
 426         } else if (StriCmp(TokenList[0], L"also_scan_dirs") == 0) {
 427             HandleStrings(TokenList, TokenCount, &(GlobalConfig.AlsoScan));
 428
 429         } else if ((StriCmp(TokenList[0], L"don't_scan_volumes") == 0) || (StriCmp(TokenList[0], L"dont_scan_volumes") == 0)) {
 430            // Note: Don't use HandleStrings() because it modifies slashes, which might be present in volume name
 431            MyFreePool(GlobalConfig.DontScanVolumes);
 432            GlobalConfig.DontScanVolumes = NULL;
 433            for (i = 1; i < TokenCount; i++) {
 434               MergeStrings(&GlobalConfig.DontScanVolumes, TokenList[i], L',');
 435            }
 436
 437         } else if ((StriCmp(TokenList[0], L"don't_scan_dirs") == 0) || (StriCmp(TokenList[0], L"dont_scan_dirs") == 0)) {
 438             HandleStrings(TokenList, TokenCount, &(GlobalConfig.DontScanDirs));
 439
 440         } else if ((StriCmp(TokenList[0], L"don't_scan_files") == 0) || (StriCmp(TokenList[0], L"dont_scan_files") == 0)) {
 441            HandleStrings(TokenList, TokenCount, &(GlobalConfig.DontScanFiles));
 442
 443         } else if (StriCmp(TokenList[0], L"scan_driver_dirs") == 0) {
 444             HandleStrings(TokenList, TokenCount, &(GlobalConfig.DriverDirs));
 445
 446         } else if (StriCmp(TokenList[0], L"showtools") == 0) {
 447             SetMem(GlobalConfig.ShowTools, NUM_TOOLS * sizeof(UINTN), 0);
 448             for (i = 1; (i < TokenCount) && (i < NUM_TOOLS); i++) {
 449                 FlagName = TokenList[i];
 450                 if (StriCmp(FlagName, L"shell") == 0) {
 451                     GlobalConfig.ShowTools[i - 1] = TAG_SHELL;
 452                 } else if (StriCmp(FlagName, L"gptsync") == 0) {
 453                     GlobalConfig.ShowTools[i - 1] = TAG_GPTSYNC;
 454                 } else if (StriCmp(FlagName, L"about") == 0) {
 455                    GlobalConfig.ShowTools[i - 1] = TAG_ABOUT;
 456                 } else if (StriCmp(FlagName, L"exit") == 0) {
 457                    GlobalConfig.ShowTools[i - 1] = TAG_EXIT;
 458                 } else if (StriCmp(FlagName, L"reboot") == 0) {
 459                    GlobalConfig.ShowTools[i - 1] = TAG_REBOOT;
 460                 } else if (StriCmp(FlagName, L"shutdown") == 0) {
 461                    GlobalConfig.ShowTools[i - 1] = TAG_SHUTDOWN;
 462                 } else if (StriCmp(FlagName, L"apple_recovery") == 0) {
 463                    GlobalConfig.ShowTools[i - 1] = TAG_APPLE_RECOVERY;
 464                 } else if (StriCmp(FlagName, L"mok_tool") == 0) {
 465                    GlobalConfig.ShowTools[i - 1] = TAG_MOK_TOOL;
 466                 } else if (StriCmp(FlagName, L"firmware") == 0) {
 467                    GlobalConfig.ShowTools[i - 1] = TAG_FIRMWARE;
 468                 } else {
 469                    Print(L" unknown showtools flag: '%s'\n", FlagName);
 470                 }
 471             } // showtools options
 472
 473         } else if (StriCmp(TokenList[0], L"banner") == 0) {
 474            HandleString(TokenList, TokenCount, &(GlobalConfig.BannerFileName));
 475
 476         } else if (StriCmp(TokenList[0], L"selection_small") == 0) {
 477            HandleString(TokenList, TokenCount, &(GlobalConfig.SelectionSmallFileName));
 478
 479         } else if (StriCmp(TokenList[0], L"selection_big") == 0) {
 480            HandleString(TokenList, TokenCount, &(GlobalConfig.SelectionBigFileName));
 481
 482         } else if (StriCmp(TokenList[0], L"default_selection") == 0) {
 483            HandleString(TokenList, TokenCount, &(GlobalConfig.DefaultSelection));
 484
 485         } else if (StriCmp(TokenList[0], L"textonly") == 0) {
 486            if ((TokenCount >= 2) && (StriCmp(TokenList[1], L"0") == 0)) {
 487               GlobalConfig.TextOnly = FALSE;
 488            } else {
 489               GlobalConfig.TextOnly = TRUE;
 490            }
 491
 492         } else if (StriCmp(TokenList[0], L"textmode") == 0) {
 493            HandleInt(TokenList, TokenCount, &(GlobalConfig.RequestedTextMode));
 494
 495         } else if ((StriCmp(TokenList[0], L"resolution") == 0) && ((TokenCount == 2) || (TokenCount == 3))) {
 496            GlobalConfig.RequestedScreenWidth = Atoi(TokenList[1]);
 497            if (TokenCount == 3)
 498               GlobalConfig.RequestedScreenHeight = Atoi(TokenList[2]);
 499            else
 500               GlobalConfig.RequestedScreenHeight = 0;
 501
 502         } else if (StriCmp(TokenList[0], L"screensaver") == 0) {
 503            HandleInt(TokenList, TokenCount, &(GlobalConfig.ScreensaverTime));
 504
 505         } else if (StriCmp(TokenList[0], L"use_graphics_for") == 0) {
 506            GlobalConfig.GraphicsFor = 0;
 507            for (i = 1; i < TokenCount; i++) {
 508               if (StriCmp(TokenList[i], L"osx") == 0) {
 509                  GlobalConfig.GraphicsFor |= GRAPHICS_FOR_OSX;
 510               } else if (StriCmp(TokenList[i], L"linux") == 0) {
 511                  GlobalConfig.GraphicsFor |= GRAPHICS_FOR_LINUX;
 512               } else if (StriCmp(TokenList[i], L"elilo") == 0) {
 513                  GlobalConfig.GraphicsFor |= GRAPHICS_FOR_ELILO;
 514               } else if (StriCmp(TokenList[i], L"grub") == 0) {
 515                  GlobalConfig.GraphicsFor |= GRAPHICS_FOR_GRUB;
 516               } else if (StriCmp(TokenList[i], L"windows") == 0) {
 517                  GlobalConfig.GraphicsFor |= GRAPHICS_FOR_WINDOWS;
 518               }
 519            } // for (graphics_on tokens)
 520
 521         } else if ((StriCmp(TokenList[0], L"font") == 0) && (TokenCount == 2)) {
 522            egLoadFont(TokenList[1]);
 523
 524         } else if (StriCmp(TokenList[0], L"scan_all_linux_kernels") == 0) {
 525            if ((TokenCount >= 2) && (StriCmp(TokenList[1], L"0") == 0)) {
 526               GlobalConfig.ScanAllLinux = FALSE;
 527            } else {
 528               GlobalConfig.ScanAllLinux = TRUE;
 529            }
 530
 531         } else if (StriCmp(TokenList[0], L"max_tags") == 0) {
 532            HandleInt(TokenList, TokenCount, &(GlobalConfig.MaxTags));
 533
 534         } else if ((StriCmp(TokenList[0], L"include") == 0) && (TokenCount == 2) && (StriCmp(FileName, CONFIG_FILE_NAME) == 0)) {
 535            if (StriCmp(TokenList[1], FileName) != 0) {
 536               ReadConfig(TokenList[1]);
 537            }
 538
 539         }
 540
 541         FreeTokenLine(&TokenList, &TokenCount);
 542     }
 543     MyFreePool(File.Buffer);
 544 } /* VOID ReadConfig() */
 545
 546 // Finds a volume with the specified Identifier (a volume label or a number
 547 // followed by a colon, for the moment). If found, sets *Volume to point to
 548 // that volume. If not, leaves it unchanged.
 549 // Returns TRUE if a match was found, FALSE if not.
 550 static BOOLEAN FindVolume(REFIT_VOLUME **Volume, CHAR16 *Identifier) {
 551    UINTN     i = 0, CountedVolumes = 0;
 552    INTN      Number = -1;
 553    BOOLEAN   Found = FALSE;
 554
 555    if ((StrLen(Identifier) >= 2) && (Identifier[StrLen(Identifier) - 1] == L':') &&
 556        (Identifier[0] >= L'0') && (Identifier[0] <= L'9')) {
 557       Number = (INTN) Atoi(Identifier);
 558    }
 559    while ((i < VolumesCount) && (!Found)) {
 560       if (Number >= 0) { // User specified a volume by number
 561          if (Volumes[i]->IsReadable) {
 562             if (CountedVolumes == Number) {
 563                *Volume = Volumes[i];
 564                Found = TRUE;
 565             }
 566             CountedVolumes++;
 567          } // if
 568       } else { // User specified a volume by label
 569          if (StriCmp(Identifier, Volumes[i]->VolName) == 0) {
 570             *Volume = Volumes[i];
 571             Found = TRUE;
 572          } // if
 573       } // if/else
 574       i++;
 575    } // while()
 576    return (Found);
 577 } // static VOID FindVolume()
 578
 579 static VOID AddSubmenu(LOADER_ENTRY *Entry, REFIT_FILE *File, REFIT_VOLUME *Volume, CHAR16 *Title) {
 580    REFIT_MENU_SCREEN  *SubScreen;
 581    LOADER_ENTRY       *SubEntry;
 582    UINTN              TokenCount;
 583    CHAR16             **TokenList;
 584
 585    SubScreen = InitializeSubScreen(Entry);
 586
 587    // Set defaults for the new entry; will be modified based on lines read from the config. file....
 588    SubEntry = InitializeLoaderEntry(Entry);
 589
 590    if ((SubEntry == NULL) || (SubScreen == NULL))
 591       return;
 592    SubEntry->me.Title        = StrDuplicate(Title);
 593
 594    while (((TokenCount = ReadTokenLine(File, &TokenList)) > 0) && (StriCmp(TokenList[0], L"}") != 0)) {
 595
 596       if ((StriCmp(TokenList[0], L"loader") == 0) && (TokenCount > 1)) { // set the boot loader filename
 597          MyFreePool(SubEntry->LoaderPath);
 598          SubEntry->LoaderPath = StrDuplicate(TokenList[1]);
 599          SubEntry->DevicePath = FileDevicePath(Volume->DeviceHandle, SubEntry->LoaderPath);
 600
 601       } else if ((StriCmp(TokenList[0], L"volume") == 0) && (TokenCount > 1)) {
 602          if (FindVolume(&Volume, TokenList[1])) {
 603             MyFreePool(SubEntry->me.Title);
 604             SubEntry->me.Title        = AllocateZeroPool(256 * sizeof(CHAR16));
 605             SPrint(SubEntry->me.Title, 255, L"Boot %s from %s", (Title != NULL) ? Title : L"Unknown", Volume->VolName);
 606             SubEntry->me.BadgeImage   = Volume->VolBadgeImage;
 607             SubEntry->VolName         = Volume->VolName;
 608          } // if match found
 609
 610       } else if (StriCmp(TokenList[0], L"initrd") == 0) {
 611          MyFreePool(SubEntry->InitrdPath);
 612          SubEntry->InitrdPath = NULL;
 613          if (TokenCount > 1) {
 614             SubEntry->InitrdPath = StrDuplicate(TokenList[1]);
 615          }
 616
 617       } else if (StriCmp(TokenList[0], L"options") == 0) {
 618          MyFreePool(SubEntry->LoadOptions);
 619          SubEntry->LoadOptions = NULL;
 620          if (TokenCount > 1) {
 621             SubEntry->LoadOptions = StrDuplicate(TokenList[1]);
 622          } // if/else
 623
 624       } else if ((StriCmp(TokenList[0], L"add_options") == 0) && (TokenCount > 1)) {
 625          MergeStrings(&SubEntry->LoadOptions, TokenList[1], L' ');
 626
 627       } else if ((StriCmp(TokenList[0], L"graphics") == 0) && (TokenCount > 1)) {
 628          SubEntry->UseGraphicsMode = (StriCmp(TokenList[1], L"on") == 0);
 629
 630       } else if (StriCmp(TokenList[0], L"disabled") == 0) {
 631          SubEntry->Enabled = FALSE;
 632       } // ief/elseif
 633
 634       FreeTokenLine(&TokenList, &TokenCount);
 635    } // while()
 636
 637    if (SubEntry->InitrdPath != NULL) {
 638       MergeStrings(&SubEntry->LoadOptions, L"initrd=", L' ');
 639       MergeStrings(&SubEntry->LoadOptions, SubEntry->InitrdPath, 0);
 640       MyFreePool(SubEntry->InitrdPath);
 641       SubEntry->InitrdPath = NULL;
 642    } // if
 643    if (SubEntry->Enabled == TRUE) {
 644       AddMenuEntry(SubScreen, (REFIT_MENU_ENTRY *)SubEntry);
 645    }
 646    Entry->me.SubScreen = SubScreen;
 647 } // VOID AddSubmenu()
 648
 649 // Adds the options from a SINGLE refind.conf stanza to a new loader entry and returns
 650 // that entry. The calling function is then responsible for adding the entry to the
 651 // list of entries.
 652 static LOADER_ENTRY * AddStanzaEntries(REFIT_FILE *File, REFIT_VOLUME *Volume, CHAR16 *Title) {
 653    CHAR16       **TokenList;
 654    UINTN        TokenCount;
 655    LOADER_ENTRY *Entry;
 656    BOOLEAN      DefaultsSet = FALSE, AddedSubmenu = FALSE;
 657    REFIT_VOLUME *CurrentVolume = Volume;
 658
 659    // prepare the menu entry
 660    Entry = InitializeLoaderEntry(NULL);
 661    if (Entry == NULL)
 662       return NULL;
 663
 664    Entry->Title           = StrDuplicate(Title);
 665    Entry->me.Title        = AllocateZeroPool(256 * sizeof(CHAR16));
 666    SPrint(Entry->me.Title, 255, L"Boot %s from %s", (Title != NULL) ? Title : L"Unknown", CurrentVolume->VolName);
 667    Entry->me.Row          = 0;
 668    Entry->me.BadgeImage   = CurrentVolume->VolBadgeImage;
 669    Entry->VolName         = CurrentVolume->VolName;
 670
 671    // Parse the config file to add options for a single stanza, terminating when the token
 672    // is "}" or when the end of file is reached.
 673    while (((TokenCount = ReadTokenLine(File, &TokenList)) > 0) && (StriCmp(TokenList[0], L"}") != 0)) {
 674       if ((StriCmp(TokenList[0], L"loader") == 0) && (TokenCount > 1)) { // set the boot loader filename
 675          Entry->LoaderPath = StrDuplicate(TokenList[1]);
 676          Entry->DevicePath = FileDevicePath(CurrentVolume->DeviceHandle, Entry->LoaderPath);
 677          SetLoaderDefaults(Entry, TokenList[1], CurrentVolume);
 678          MyFreePool(Entry->LoadOptions);
 679          Entry->LoadOptions = NULL; // Discard default options, if any
 680          DefaultsSet = TRUE;
 681
 682       } else if ((StriCmp(TokenList[0], L"volume") == 0) && (TokenCount > 1)) {
 683          if (FindVolume(&CurrentVolume, TokenList[1])) {
 684             MyFreePool(Entry->me.Title);
 685             Entry->me.Title        = AllocateZeroPool(256 * sizeof(CHAR16));
 686             SPrint(Entry->me.Title, 255, L"Boot %s from %s", (Title != NULL) ? Title : L"Unknown", CurrentVolume->VolName);
 687             Entry->me.BadgeImage   = CurrentVolume->VolBadgeImage;
 688             Entry->VolName         = CurrentVolume->VolName;
 689          } // if match found
 690
 691       } else if ((StriCmp(TokenList[0], L"icon") == 0) && (TokenCount > 1)) {
 692          MyFreePool(Entry->me.Image);
 693          Entry->me.Image = egLoadIcon(CurrentVolume->RootDir, TokenList[1], 128);
 694          if (Entry->me.Image == NULL) {
 695             Entry->me.Image = DummyImage(128);
 696          }
 697
 698       } else if ((StriCmp(TokenList[0], L"initrd") == 0) && (TokenCount > 1)) {
 699          MyFreePool(Entry->InitrdPath);
 700          Entry->InitrdPath = StrDuplicate(TokenList[1]);
 701
 702       } else if ((StriCmp(TokenList[0], L"options") == 0) && (TokenCount > 1)) {
 703          MyFreePool(Entry->LoadOptions);
 704          Entry->LoadOptions = StrDuplicate(TokenList[1]);
 705
 706       } else if ((StriCmp(TokenList[0], L"ostype") == 0) && (TokenCount > 1)) {
 707          if (TokenCount > 1) {
 708             Entry->OSType = TokenList[1][0];
 709          }
 710
 711       } else if ((StriCmp(TokenList[0], L"graphics") == 0) && (TokenCount > 1)) {
 712          Entry->UseGraphicsMode = (StriCmp(TokenList[1], L"on") == 0);
 713
 714       } else if (StriCmp(TokenList[0], L"disabled") == 0) {
 715          Entry->Enabled = FALSE;
 716
 717       } else if ((StriCmp(TokenList[0], L"submenuentry") == 0) && (TokenCount > 1)) {
 718          AddSubmenu(Entry, File, CurrentVolume, TokenList[1]);
 719          AddedSubmenu = TRUE;
 720
 721       } // set options to pass to the loader program
 722       FreeTokenLine(&TokenList, &TokenCount);
 723    } // while()
 724
 725    if (AddedSubmenu)
 726        AddMenuEntry(Entry->me.SubScreen, &MenuEntryReturn);
 727
 728    if (Entry->InitrdPath) {
 729       MergeStrings(&Entry->LoadOptions, L"initrd=", L' ');
 730       MergeStrings(&Entry->LoadOptions, Entry->InitrdPath, 0);
 731       MyFreePool(Entry->InitrdPath);
 732       Entry->InitrdPath = NULL;
 733    } // if
 734
 735    if (!DefaultsSet)
 736       SetLoaderDefaults(Entry, L"\\EFI\\BOOT\\nemo.efi", CurrentVolume); // user included no "loader" line; use bogus one
 737
 738    return(Entry);
 739 } // static VOID AddStanzaEntries()
 740
 741 // Read the user-configured menu entries from refind.conf and add or delete
 742 // entries based on the contents of that file....
 743 VOID ScanUserConfigured(CHAR16 *FileName)
 744 {
 745    EFI_STATUS        Status;
 746    REFIT_FILE        File;
 747    REFIT_VOLUME      *Volume;
 748    CHAR16            **TokenList;
 749    CHAR16            *Title = NULL;
 750    UINTN             TokenCount, size;
 751    LOADER_ENTRY      *Entry;
 752
 753    if (FileExists(SelfDir, FileName)) {
 754       Status = ReadFile(SelfDir, FileName, &File, &size);
 755       if (EFI_ERROR(Status))
 756          return;
 757
 758       Volume = SelfVolume;
 759
 760       while ((TokenCount = ReadTokenLine(&File, &TokenList)) > 0) {
 761          if ((StriCmp(TokenList[0], L"menuentry") == 0) && (TokenCount > 1)) {
 762             Title = StrDuplicate(TokenList[1]);
 763             Entry = AddStanzaEntries(&File, Volume, TokenList[1]);
 764             if (Entry->Enabled) {
 765                if (Entry->me.SubScreen == NULL)
 766                   GenerateSubScreen(Entry, Volume);
 767                AddPreparedLoaderEntry(Entry);
 768             } else {
 769                MyFreePool(Entry);
 770             } // if/else
 771             MyFreePool(Title);
 772
 773          } else if ((StriCmp(TokenList[0], L"include") == 0) && (TokenCount == 2) && (StriCmp(FileName, CONFIG_FILE_NAME) == 0)) {
 774             if (StriCmp(TokenList[1], FileName) != 0) {
 775                ScanUserConfigured(TokenList[1]);
 776             }
 777
 778          } // if/else if...
 779          FreeTokenLine(&TokenList, &TokenCount);
 780       } // while()
 781    } // if()
 782 } // VOID ScanUserConfigured()
 783
 784 // Create an options file based on /etc/fstab. The resulting file has two options
 785 // lines, one of which boots the system with "ro root={rootfs}" and the other of
 786 // which boots the system with "ro root={rootfs} single", where "{rootfs}" is the
 787 // filesystem identifier associated with the "/" line in /etc/fstab.
 788 static REFIT_FILE * GenerateOptionsFromEtcFstab(REFIT_VOLUME *Volume) {
 789    UINTN        TokenCount, i;
 790    REFIT_FILE   *Options = NULL, *Fstab = NULL;
 791    EFI_STATUS   Status;
 792    CHAR16       **TokenList, Line[513], Root[100];
 793
 794    if (FileExists(Volume->RootDir, L"\\etc\\fstab")) {
 795       Options = AllocateZeroPool(sizeof(REFIT_FILE));
 796       Fstab = AllocateZeroPool(sizeof(REFIT_FILE));
 797       Status = ReadFile(Volume->RootDir, L"\\etc\\fstab", Fstab, &i);
 798       if (CheckError(Status, L"while reading /etc/fstab")) {
 799          if (Options != NULL)
 800             FreePool(Options);
 801          if (Fstab != NULL)
 802             FreePool(Fstab);
 803          Options = NULL;
 804          Fstab = NULL;
 805       } else { // File read; locate root fs and create entries
 806          Options->Encoding = ENCODING_UTF16_LE;
 807          Line[0] = '\0';
 808          while ((TokenCount = ReadTokenLine(Fstab, &TokenList)) > 0) {
 809             if (TokenCount > 2) {
 810                Root[0] = '\0';
 811                if (StriCmp(TokenList[1], L"\\") == 0) {
 812                   SPrint(Root, 99, L"%s", TokenList[0]);
 813                } else if (StriCmp(TokenList[2], L"\\") == 0) {
 814                   SPrint(Root, 99, L"%s=%s", TokenList[0], TokenList[1]);
 815                } // if/elseif/elseif
 816                if (Root[0] != L'\0') {
 817                   for (i = 0; i < StrLen(Root); i++)
 818                      if (Root[i] == '\\')
 819                         Root[i] = '/';
 820                   SPrint(Line, 512, L"\"Boot with normal options\"    \"ro root=%s\"\n", Root);
 821                   MergeStrings((CHAR16 **) &(Options->Buffer), Line, 0);
 822                   SPrint(Line, 512, L"\"Boot into single-user mode\"  \"ro root=%s single\"\n", Root);
 823                   MergeStrings((CHAR16**) &(Options->Buffer), Line, 0);
 824                   Options->BufferSize = StrLen((CHAR16*) Options->Buffer) * sizeof(CHAR16);
 825                } // if
 826             } // if
 827             FreeTokenLine(&TokenList, &TokenCount);
 828          } // while
 829
 830          Options->Current8Ptr  = (CHAR8 *)Options->Buffer;
 831          Options->End8Ptr      = Options->Current8Ptr + Options->BufferSize;
 832          Options->Current16Ptr = (CHAR16 *)Options->Buffer;
 833          Options->End16Ptr     = Options->Current16Ptr + (Options->BufferSize >> 1);
 834
 835          MyFreePool(Fstab->Buffer);
 836          MyFreePool(Fstab);
 837       } // if/else file read error
 838    } // if /etc/fstab exists
 839    return Options;
 840 } // GenerateOptionsFromEtcFstab()
 841
 842
 843 // Read a Linux kernel options file for a Linux boot loader into memory. The LoaderPath
 844 // and Volume variables identify the location of the options file, but not its name --
 845 // you pass this function the filename of the Linux kernel, initial RAM disk, or other
 846 // file in the target directory, and this function finds the file with a name in the
 847 // comma-delimited list of names specified by LINUX_OPTIONS_FILENAMES within that
 848 // directory and loads it. This function tries multiple files because I originally
 849 // used the filename linux.conf, but close on the heels of that decision, the Linux
 850 // kernel developers decided to use that name for a similar purpose, but with a
 851 // different file format. Thus, I'm migrating rEFInd to use the name refind_linux.conf,
 852 // but I want a migration period in which both names are used.
 853 // If a rEFInd options file can't be found, try to generate minimal options from
 854 // /etc/fstab on the same volume as the kernel. This typically works only if the
 855 // kernel is being read from the Linux root filesystem.
 856 //
 857 // The return value is a pointer to the REFIT_FILE handle for the file, or NULL if
 858 // it wasn't found.
 859 REFIT_FILE * ReadLinuxOptionsFile(IN CHAR16 *LoaderPath, IN REFIT_VOLUME *Volume) {
 860    CHAR16       *OptionsFilename, *FullFilename;
 861    BOOLEAN      GoOn = TRUE, FileFound = FALSE;
 862    UINTN        i = 0, size;
 863    REFIT_FILE   *File = NULL;
 864    EFI_STATUS   Status;
 865
 866    do {
 867       OptionsFilename = FindCommaDelimited(LINUX_OPTIONS_FILENAMES, i++);
 868       FullFilename = FindPath(LoaderPath);
 869       if ((OptionsFilename != NULL) && (FullFilename != NULL)) {
 870          MergeStrings(&FullFilename, OptionsFilename, '\\');
 871          if (FileExists(Volume->RootDir, FullFilename)) {
 872             File = AllocateZeroPool(sizeof(REFIT_FILE));
 873             Status = ReadFile(Volume->RootDir, FullFilename, File, &size);
 874             if (CheckError(Status, L"while loading the Linux options file")) {
 875                if (File != NULL)
 876                   FreePool(File);
 877                File = NULL;
 878             } else {
 879                GoOn = FALSE;
 880                FileFound = TRUE;
 881             } // if/else error
 882          } // if file exists
 883       } else { // a filename string is NULL
 884          GoOn = FALSE;
 885       } // if/else
 886       if (!FileFound)
 887          File = GenerateOptionsFromEtcFstab(Volume);
 888       MyFreePool(OptionsFilename);
 889       MyFreePool(FullFilename);
 890       OptionsFilename = FullFilename = NULL;
 891    } while (GoOn);
 892    return (File);
 893 } // static REFIT_FILE * ReadLinuxOptionsFile()
 894
 895 // Retrieve a single line of options from a Linux kernel options file
 896 CHAR16 * GetFirstOptionsFromFile(IN CHAR16 *LoaderPath, IN REFIT_VOLUME *Volume) {
 897    UINTN        TokenCount;
 898    CHAR16       *Options = NULL;
 899    CHAR16       **TokenList;
 900    REFIT_FILE   *File;
 901
 902    File = ReadLinuxOptionsFile(LoaderPath, Volume);
 903    if (File != NULL) {
 904       TokenCount = ReadTokenLine(File, &TokenList);
 905       if (TokenCount > 1)
 906          Options = StrDuplicate(TokenList[1]);
 907       FreeTokenLine(&TokenList, &TokenCount);
 908       FreePool(File);
 909    } // if
 910    return Options;
 911 } // static CHAR16 * GetOptionsFile()
 912