windows-xp/Source/XPSP1/NT/base/efiutil/efintldr/efintldr.c

/*++

Copyright (c) 2000 Microsoft Corporation

Module Name:

    efintldr.c

Abstract:

    

Revision History:

    Jeff Sigman             05/01/00  Created
    Jeff Sigman             05/10/00  Version 1.5 released
    Jeff Sigman             10/18/00  Fix for Soft81 bug(s)

--*/

#include "precomp.h"

//
// Open the IA64LDR.EFI image and load the OS
//
BOOLEAN
LaunchOS(
    IN char*             String,
    IN EFI_HANDLE        ImageHandle,
    IN EFI_FILE_HANDLE*  CurDir,
    IN EFI_LOADED_IMAGE* LoadedImage
    )
{
    CHAR16*          uniBuf     = NULL;
    BOOLEAN          bError     = TRUE;
    EFI_STATUS       Status;
    EFI_HANDLE       exeHdl     = NULL;
    EFI_INPUT_KEY    Key;
    EFI_FILE_HANDLE  FileHandle = NULL;
    EFI_DEVICE_PATH* ldrDevPath = NULL;

    do
    {
        //
        // Convert OS path to unicode from ACSII
        //
        uniBuf = RutlUniStrDup(String);
        if (!uniBuf)
        {
            break;
        }
        //
        // Open the ia64ldr.efi
        //
        Status = (*CurDir)->Open(
                            *CurDir,
                            &FileHandle,
                            uniBuf,
                            EFI_FILE_MODE_READ,
                            0);
        if (EFI_ERROR(Status))
        {
            break;
        }

        ldrDevPath = FileDevicePath(LoadedImage->DeviceHandle, uniBuf);
        if (!ldrDevPath)
        {
            break;
        }

        Status = BS->LoadImage(
                    FALSE,
                    ImageHandle,
                    ldrDevPath,
                    NULL,
                    0,
                    &exeHdl);
        if (EFI_ERROR(Status))
        {
            break;
        }

        Print (L"\nAttempting to launch... %s\n", uniBuf);
        WaitForSingleEvent(ST->ConIn->WaitForKey, 5000000);
        ST->ConIn->ReadKeyStroke(ST->ConIn, &Key);
        //
        // Clean up
        //
        ldrDevPath = RutlFree(ldrDevPath);
        uniBuf = RutlFree(uniBuf);
        String = RutlFree(String);
        //
        // Disable the cursor
        //
        ST->ConOut->EnableCursor(ST->ConOut, FALSE);
        bError = FALSE;
        //
        // Start the OS baby!!
        //
        BS->StartImage(exeHdl, 0, NULL);
        //
        // If we get here the OS failed to load
        //
        bError = TRUE;
        //
        // Re-enable the cursor
        //
        ST->ConOut->EnableCursor(ST->ConOut, TRUE);

    } while (FALSE);
    //
    // Clean up
    //
    if (ldrDevPath)
    {
        ldrDevPath = RutlFree(ldrDevPath);
    }
    if (uniBuf)
    {
        uniBuf = RutlFree(uniBuf);
    }
    if (FileHandle)
    {
        FileHandle->Close(FileHandle);
    }
    if (String)
    {
        String = RutlFree(String);
    }
//
// Where the heck is the lib for this?
//
//    if (exeHdl)
//        UnloadImage(&exeHdl);

    return bError;
}

//
// Struct Cleanup
//
BOOLEAN
FreeBootData(
    IN VOID* hBootData
    )
{
    UINTN      i;
    BOOT_DATA* pBootData = (BOOT_DATA*) hBootData;

    if (!pBootData)
    {
        return TRUE;
    }

    for (i = 0; i < pBootData->dwIndex; i++)
    {
        pBootData->pszSPart[i] = RutlFree(pBootData->pszSPart[i]);
        pBootData->pszOSLdr[i] = RutlFree(pBootData->pszOSLdr[i]);
        pBootData->pszLPart[i] = RutlFree(pBootData->pszLPart[i]);
        pBootData->pszFileN[i] = RutlFree(pBootData->pszFileN[i]);
        pBootData->pszIdent[i] = RutlFree(pBootData->pszIdent[i]);
        pBootData->pszShort[i] = RutlFree(pBootData->pszShort[i]);
    }

    pBootData->pszShort[pBootData->dwIndex] =
        RutlFree(pBootData->pszShort[pBootData->dwIndex]);

    pBootData->pszIdent[pBootData->dwIndex] =
        RutlFree(pBootData->pszIdent[pBootData->dwIndex]);

    if (pBootData->pszLoadOpt)
    {
        pBootData->pszLoadOpt = RutlFree(pBootData->pszLoadOpt);
    }

    pBootData->dwLastKnown = 0;
    pBootData->dwIndex = 0;
    pBootData->dwCount = 0;

    return FALSE;
}

//
// Sort the load options based placing the passed option first
//
BOOLEAN
SortLoadOptions(
    IN VOID*            hBootData,
    IN char*            Buffer,
    IN UINTN*           dwSize,
    IN UINTN*           dwOption,
    IN UINTN*           dwMax,
    IN EFI_FILE_HANDLE* FileHandle
    )
{
    char       *FndTok[BOOT_MAX],
               *Start    = NULL,
               *End      = NULL,
               *NewOpt   = NULL,
               *Sortme   = NULL,
               *Token    = NULL,
               *Last     = NULL,
               *Find     = NULL;
    UINTN      i         = 0,
               j         = 0,
               dwIndex   = 0,
               dwStLen   = 0,
               dwOrigLen = 0,
               dwLen     = 0;
    BOOLEAN    bError    = FALSE;
    BOOT_DATA* pBootData = (BOOT_DATA*) hBootData;

    do
    {
        //
        // Find the BOOT_LDOPT option
        //
        Start = strstr(Buffer, BOOT_LDOPT);
        if (!Start)
        {
            bError = TRUE;
            break;
        }
        //
        // Find the end of the option
        //
        End = (Start += strlena(BOOT_LDOPT));
        while (*(End++) != '\r')
            ;
        dwOrigLen = (End - Start) - 1;
        //
        // Create buffer to use for temp sort storage
        //
        NewOpt = AllocateZeroPool(dwOrigLen + 1);
        if (!NewOpt)
        {
            bError = TRUE;
            break;
        }
        //
        // Copy only that option to a new buffer
        //
        CopyMem(NewOpt, Start, dwOrigLen);
        //
        // Replace any leading ';' with a nodebug
        //
        while ((NewOpt[i] == ';') && (i < *dwMax))
        {
            FndTok[i] = RutlStrDup(BL_DEBUG_NONE);
            if (!FndTok[i])
            {
                bError = TRUE;
                break;
            }

            dwIndex += strlena(FndTok[i++]);
        }
        //
        // Remove tokens
        //
        Token = strtok(NewOpt, BOOT_TOKEN);

        while ((Token != NULL) &&
               (Token < (NewOpt + dwOrigLen)) &&
               (i < *dwMax)
              )
        {
            if (Find = FindAdvLoadOptions(Token))
            {
                //
                // User has booted using adv options, clearing them out
                //
                // Add a NULL at the location of the adv opt
                //
                *Find = '\0';

                FndTok[i] = RutlStrDup(Token);
            }
            else
            {
                FndTok[i] = RutlStrDup(Token);
                if (!FndTok[i])
                {
                    bError = TRUE;
                    break;
                }
            }

            dwIndex += strlena(FndTok[i++]);
            Token = strtok(NULL, BOOT_TOKEN);
        }

        while (i < *dwMax)
        {
            FndTok[i] = RutlStrDup(BL_DEBUG_NONE);
            if (!FndTok[i])
            {
                bError = TRUE;
                break;
            }

            dwIndex += strlena(FndTok[i++]);
        }
        //
        // Create buffer to store sorted data
        //
        Sortme = AllocateZeroPool(dwLen = dwIndex + *dwMax + 1);
        if (!Sortme)
        {
            bError = TRUE;
            break;
        }

        //
        // Copy selected option as the first option
        //
        if (pBootData->pszLoadOpt)
        {
            //
            // if user has selected an adv boot option, it is plum'd here
            //
            dwStLen = strlena(pBootData->pszLoadOpt) + dwLen + strlena(SPACES);

            Sortme = ReallocatePool(Sortme, dwLen, dwStLen);
            if (!Sortme)
            {
                bError = TRUE;
                break;
            }
            //
            // they will need to match up later
            //
            dwLen = dwStLen;

            dwIndex = strlena(FndTok[*dwOption]);
            CopyMem(Sortme, FndTok[*dwOption], dwIndex);
            dwStLen = dwIndex;

            dwIndex = strlena(SPACES);
            CopyMem(Sortme + dwStLen, SPACES, dwIndex);
            dwStLen += dwIndex;

            dwIndex = strlena(pBootData->pszLoadOpt);
            CopyMem(Sortme + dwStLen, pBootData->pszLoadOpt, dwIndex);
            dwStLen += dwIndex;
        }
        else
        {
            CopyMem(Sortme, FndTok[*dwOption], strlena(FndTok[*dwOption]));
            dwStLen = strlena(FndTok[*dwOption]);
        }
        //
        // Append a seperator
        //
        *(Sortme + (dwStLen++)) = ';';
        //
        // Smash the rest of the options back in
        //
        for (j = 0; j < i; j++)
        {
            //
            // Skip the option that was moved to the front
            //
            if (j == *dwOption)
            {
                continue;
            }

            CopyMem(Sortme + dwStLen, FndTok[j], strlena(FndTok[j]));
            dwStLen += strlena(FndTok[j]);
            //
            // Append a seperator
            //
            *(Sortme + (dwStLen++)) = ';';
        }

        dwStLen--;
        *(Sortme + dwStLen++) = '\r';
        *(Sortme + dwStLen++) = '\n';

        if (dwLen != dwStLen)
        {
            bError = TRUE;
            break;
        }
        //
        // Write new sorted load options to file
        //
        (*FileHandle)->SetPosition(*FileHandle, (Start - Buffer));
        (*FileHandle)->Write(*FileHandle, &dwStLen, Sortme);
        //
        // Write options that following load options back to file
        //
        (*FileHandle)->SetPosition(*FileHandle, (Start - Buffer) + dwStLen - 1);
        dwStLen = *dwSize - (End - Buffer);
        (*FileHandle)->Write(*FileHandle, &dwStLen, End);
        //
        // Set last known good
        //
        if (Last = strstr(End, BOOT_LASTK))
        {
            (*FileHandle)->SetPosition(
                                *FileHandle,
                                (Start - Buffer) + dwLen + (Last - End) - 1);

            if (pBootData->dwLastKnown)
            {
                dwIndex = strlena(LAST_TRUE);
                (*FileHandle)->Write(*FileHandle, &dwIndex, LAST_TRUE);
            }
            else
            {
                dwIndex = strlena(LAST_FALSE);
                (*FileHandle)->Write(*FileHandle, &dwIndex, LAST_FALSE);
            }
        }
        //
        // Subtract the terminators
        //
        dwLen -= 2;

        if (dwOrigLen <= dwLen)
        {
            break;
        }
        //
        // append semi-colon's at the end of the file if we have left over room
        //
        // don't reuse 'i', need it below to free
        //
        for (j = 0; j < (dwOrigLen - dwLen); j++)
        {
            dwStLen = 1;
            (*FileHandle)->Write(*FileHandle, &dwStLen, ";");
        }

    } while (FALSE);

    if (Sortme)
    {
        Sortme = RutlFree(Sortme);
    }

    for (j = 0; j < i; j++)
    {
        FndTok[j] = RutlFree(FndTok[j]);
    }

    if (NewOpt)
    {
        NewOpt = RutlFree(NewOpt);
    }

    return bError;
}

//
// Sort the boot options based placing the passed option first
//
BOOLEAN
SortBootData(
    IN char*  Option,
    IN char*  StrArr[],
    IN UINTN* dwOption,
    IN UINTN* dwMax,
    IN char*  Buffer
    )
{
    char    *Start  = NULL,
            *End    = NULL,
            *NewOpt = NULL;
    UINTN   i,
            dwIndex = 0,
            dwLen   = 0;
    BOOLEAN bError = TRUE;

    do
    {
        //
        // Find the option header
        //
        Start = strstr(Buffer, Option);
        if (!Start)
        {
            break;
        }
        //
        // Find the end of the option
        //
        End = (Start += strlena(Option));
        while (*(End++) != '\n')
            ;
        dwLen = End - Start;
        //
        // Create buffer to use for temp sort storage
        //
        NewOpt = AllocateZeroPool(dwLen);
        if (!NewOpt)
        {
            break;
        }
        //
        // Copy only that option to a new buffer
        //
        CopyMem(NewOpt, StrArr[*dwOption], strlena(StrArr[*dwOption]));
        dwIndex += strlena(StrArr[*dwOption]);
        //
        // Append a seperator
        //
        *(NewOpt+(dwIndex++)) = ';';

        for (i = 0; i < *dwMax; i++)
        {
            if (i == *dwOption)
            {
                continue;
            }

            CopyMem(NewOpt + dwIndex, StrArr[i], strlena(StrArr[i]));
            dwIndex += strlena(StrArr[i]);
            *(NewOpt+(dwIndex++)) = ';';
        }

        while (dwIndex++ < (dwLen - 1))
        {
            *(NewOpt + (dwIndex - 1)) = ';';
        }

        *(NewOpt + (dwLen - 2)) = '\r';
        *(NewOpt + dwLen - 1) = '\n';

        if (dwIndex != dwLen)
        {
            break;
        }
        //
        // Copy new sorted data in the buffer
        //
        CopyMem(Start, NewOpt, dwIndex);

        bError = FALSE;

    } while (FALSE);

    if (NewOpt)
    {
        NewOpt = RutlFree(NewOpt);
    }

    return bError;
}

//
// Parse options from file data
//
BOOLEAN
OrderBootFile(
    IN UINTN dwOption,
    IN char* Buffer,
    IN VOID* hBootData
    )
{
    BOOLEAN    bError    = TRUE;
    BOOT_DATA* pBootData = (BOOT_DATA*) hBootData;

    do
    {
        //
        // Find/sort the BOOT_SPART option
        //
        if (SortBootData(
                    BOOT_SPART,
                    pBootData->pszSPart,
                    &dwOption,
                    &(pBootData->dwIndex),
                    Buffer))
        {
            Print(L"OrderBootFile() failed for BOOT_SPART option!\n");
            break;
        }
        //
        // Find/sort the BOOT_OSLDR option
        //
        if (SortBootData(
                    BOOT_OSLDR,
                    pBootData->pszOSLdr,
                    &dwOption,
                    &(pBootData->dwIndex),
                    Buffer))
        {
            Print(L"OrderBootFile() failed for BOOT_OSLDR option!\n");
            break;
        }
        //
        // Find/sort the BOOT_LPART option
        //
        if (SortBootData(
                    BOOT_LPART,
                    pBootData->pszLPart,
                    &dwOption,
                    &(pBootData->dwIndex),
                    Buffer))
        {
            Print(L"OrderBootFile() failed for BOOT_LPART option!\n");
            break;
        }
        //
        // Find/sort the BOOT_FILEN option
        //
        if (SortBootData(
                    BOOT_FILEN,
                    pBootData->pszFileN,
                    &dwOption,
                    &(pBootData->dwIndex),
                    Buffer))
        {
            Print(L"OrderBootFile() failed for BOOT_FILEN option!\n");
            break;
        }
        //
        // Find/sort the BOOT_IDENT option
        //
        if (SortBootData(
                    BOOT_IDENT,
                    pBootData->pszIdent,
                    &dwOption,
                    &(pBootData->dwIndex),
                    Buffer))
        {
            Print(L"OrderBootFile() failed for BOOT_IDENT option!\n");
            break;
        }

        bError = FALSE;

    } while (FALSE);

    return bError;
}

//
// Chop-up name to be short to 'pretty up' the menu
//
BOOLEAN
CreateShortNames(
    IN VOID* hBootData
    )
{
    char       *start    = NULL,
               *end      = NULL;
    UINTN      i,
               Len       = 0;
    BOOLEAN    bError    = FALSE;
    BOOT_DATA* pBootData = (BOOT_DATA*) hBootData;

    do
    {
        for (i = 0; i < pBootData->dwIndex; i++)
        {
            start = strstr(pBootData->pszOSLdr[i], wacks);
            end = strstr(pBootData->pszOSLdr[i], EFIEXT);
            //
            // check for foo case (thx jhavens)
            //
            if ((end == NULL) ||
                (start == NULL)
               )
            {
                start = pBootData->pszOSLdr[i];
                end = start;
                while (*(end++) != '\0')
                    ;
                Len = end - start;
            }
            //
            // Non-foo case, person has atleast one '\' && '.efi'
            //
            if (!Len)
            {
                start += 1;

                while (*end != wackc)
                {
                    if (end <= start)
                    {
                        start = pBootData->pszOSLdr[i];
                        end = strstr(pBootData->pszOSLdr[i], wacks);
                        break;
                    }

                        end--;
                }

                Len = end - start;
            }

            if ((end == NULL)   ||
                (start == NULL) ||
                (Len < 1)
               )
            {
                bError = TRUE;
                break;
            }

            pBootData->pszShort[i] = AllocateZeroPool(Len + 1);
            if (!pBootData->pszShort[i])
            {
                bError = TRUE;
                break;
            }

            CopyMem(pBootData->pszShort[i], start, end - start);

            Len = 0;
            start = NULL;
            end = NULL;
        }

    } while (FALSE);

    return bError;
}

//
// Find the passed option from the file data
//
BOOLEAN
FindOpt(
    IN  char*  pszOption,
    IN  char*  Buffer,
    OUT char*  pszArray[],
    OUT UINTN* dwCount
    )
{
    char    *Start  = NULL,
            *End    = NULL,
            *Option = NULL,
            *Token  = NULL;
    UINTN   dwIndex = 0;
    BOOLEAN bError  = TRUE;

    do
    {
        //
        // Find the option
        //
        Start = strstr(Buffer, pszOption);
        if (!Start)
        {
            break;
        }
        //
        // Find the end of the option
        //
        Start += strlena(pszOption);
        End = Start;
        while (*(End++) != '\r')
            ;

        Option = AllocateZeroPool((End-Start));
        if (!Option)
        {
            break;
        }
        //
        // Copy only that option to a new buffer
        //
        CopyMem(Option, Start, (End-Start)-1);
        *(Option+((End-Start)-1)) = 0x00;
        //
        // Remove tokens
        //
        Token = strtok(Option, BOOT_TOKEN);
        if (!Token)
        {
            break;
        }

        if (!(*dwCount))
        {
            while ((Token != NULL) &&
                   (dwIndex < BOOT_MAX)
                  )
            {
                pszArray[(dwIndex)++] = RutlStrDup(Token);
                Token = strtok(NULL, BOOT_TOKEN);
            }

            *dwCount = dwIndex;
        }
        else
        {
            while ((Token != NULL) &&
                   (dwIndex < *dwCount)
                  )
            {
                pszArray[(dwIndex)++] = RutlStrDup(Token);
                Token = strtok(NULL, BOOT_TOKEN);
            }
        }

        if (dwIndex == 0)
        {
            break;
        }

        bError = FALSE;

    } while (FALSE);

    if (Option)
    {
        Option = RutlFree(Option);
    }

    return bError;
}

//
// Get the options in their entirety from the file data
//
BOOLEAN
GetBootData(
    IN VOID* hBootData,
    IN char* Buffer
    )
{
    UINTN      i;
    char*      TempStr   = NULL;
    CHAR16*    UniStr    = NULL;
    BOOLEAN    bError    = TRUE;
    BOOT_DATA* pBootData = (BOOT_DATA*) hBootData;

    do
    {
        //
        // Find the BOOT_IDENT option
        //
        if (FindOpt(
                BOOT_IDENT,
                Buffer,
                pBootData->pszIdent,
                &pBootData->dwIndex))
        {
            break;
        }

        pBootData->pszIdent[pBootData->dwIndex] = RutlStrDup(BL_EXIT_EFI1);
        if (!pBootData->pszIdent[pBootData->dwIndex])
        {
            break;
        }
        //
        // Find the BOOT_SPART option
        //
        if (FindOpt(
                BOOT_SPART,
                Buffer,
                pBootData->pszSPart,
                &pBootData->dwIndex))
        {
            break;
        }
        //
        // Find the BOOT_OSLDR option
        //
        if (FindOpt(
                BOOT_OSLDR,
                Buffer,
                pBootData->pszOSLdr,
                &pBootData->dwIndex))
        {
            break;
        }

        if (CreateShortNames(pBootData))
        {
            break;
        }
        //
        // Append 'exit' to the end of the menu
        //
        pBootData->pszShort[pBootData->dwIndex] = RutlStrDup(BL_EXIT_EFI2);
        if (!pBootData->pszShort[pBootData->dwIndex])
        {
            break;
        }
        //
        // Find the BOOT_LPART option
        //
        if (FindOpt(
                BOOT_LPART,
                Buffer,
                pBootData->pszLPart,
                &pBootData->dwIndex))
        {
            break;
        }
        //
        // Find the BOOT_FILEN option
        //
        if (FindOpt(
                BOOT_FILEN,
                Buffer,
                pBootData->pszFileN,
                &pBootData->dwIndex))
        {
            break;
        }
        //
        // Find the BOOT_CNTDW option
        //
        if (TempStr = strstr(Buffer, BOOT_CNTDW))
        {
            UniStr = RutlUniStrDup(TempStr + strlena(BOOT_CNTDW));

            if ((UniStr != NULL)   &&
                (Atoi(UniStr) > 0) &&
                (Atoi(UniStr) < BOOT_COUNT)
               )
            {
                pBootData->dwCount = Atoi(UniStr);
                bError = FALSE;
                break;
            }
        }
        //
        // Set the count to the default if setting it failed
        //
        if (!pBootData->dwCount)
        {
            pBootData->dwCount = BOOT_COUNT;
        }

        bError = FALSE;

    } while (FALSE);

    if (UniStr)
    {
        UniStr = RutlFree(UniStr);
    }

    return bError;
}

//
// fill out startup.nsh with the name of this program
//
void
PopulateStartFile(
    IN EFI_FILE_HANDLE* StartFile
    )
{
    UINTN  size;
    CHAR16 UnicodeMarker = UNICODE_BYTE_ORDER_MARK;

    size = sizeof(UnicodeMarker);
    (*StartFile)->Write(*StartFile, &size, &UnicodeMarker);

    size = (StrLen(THISFILE)) * sizeof(CHAR16);
    (*StartFile)->Write(*StartFile, &size, THISFILE);

    return;
}

//
// Parse cmdline params
//
void
ParseArgs(
    IN EFI_FILE_HANDLE*  CurDir,
    IN EFI_LOADED_IMAGE* LoadedImage
    )
{
    EFI_STATUS      Status;
    EFI_FILE_HANDLE StartFile = NULL;

    do
    {
        if (MetaiMatch(LoadedImage->LoadOptions, REGISTER1) ||
            MetaiMatch(LoadedImage->LoadOptions, REGISTER2)
           )
        {
            Status = (*CurDir)->Open(
                                *CurDir,
                                &StartFile,
                                STARTFILE,
                                EFI_FILE_MODE_READ |
                                    EFI_FILE_MODE_WRITE |
                                    EFI_FILE_MODE_CREATE,
                                0);
            if (EFI_ERROR(Status))
            {
                break;
            }

            Status = StartFile->Delete(StartFile);
            if (EFI_ERROR(Status))
            {
                break;
            }

            StartFile = NULL;

            Status = (*CurDir)->Open(
                                *CurDir,
                                &StartFile,
                                STARTFILE,
                                EFI_FILE_MODE_READ |
                                    EFI_FILE_MODE_WRITE |
                                    EFI_FILE_MODE_CREATE,
                                0);
            if (!EFI_ERROR(Status))
            {
                PopulateStartFile(&StartFile);
            }
        }

    } while (FALSE);
    //
    // Clean up
    //
    if (StartFile)
    {
        StartFile->Close(StartFile);
    }

    return;
}

//
// Read in BOOT.NVR and return buffer of contents
//
void*
ReadBootFile(
    IN UINTN*           Size,
    IN EFI_FILE_HANDLE* FileHandle
    )
{
    char*          Buffer   = NULL;
    EFI_STATUS     Status;
    EFI_FILE_INFO* BootInfo = NULL;

    do
    {
        *Size = (SIZE_OF_EFI_FILE_INFO + 255) * sizeof(CHAR16);

        BootInfo = AllocateZeroPool(*Size);
        if (!BootInfo)
        {
            break;
        }

        Status = (*FileHandle)->GetInfo(
                    *FileHandle,
                    &GenericFileInfo,
                    Size,
                    BootInfo);
        if (EFI_ERROR(Status))
        {
            break;
        }
        //
        // Find out how much we will need to alloc
        //
        *Size = (UINTN) BootInfo->FileSize;

        Buffer = AllocateZeroPool((*Size) + 1);
        if (!Buffer)
        {
            break;
        }

        Status = (*FileHandle)->Read(*FileHandle, Size, Buffer);
        if (EFI_ERROR(Status))
        {
            Buffer = RutlFree(Buffer);
            break;
        }

    } while (FALSE);
    //
    // Clean up
    //
    if (BootInfo)
    {
        BootInfo = RutlFree(BootInfo);
    }

    return Buffer;
}

//
// Remove any extra semi-colons from BOOT.NVR
//
BOOLEAN
CleanBootFile(
    IN EFI_FILE_HANDLE* FileHandle,
    IN EFI_FILE_HANDLE* CurDir
    )
{
    char            *Buffer   = NULL,
                    *CpBuffer = NULL;
    UINTN           i,
                    Size      = 0,
                    NewSize   = 0;
    BOOLEAN         bError    = TRUE;
    EFI_STATUS      Status;
    EFI_FILE_HANDLE NewFile   = NULL;

    do
    {
        (*FileHandle)->SetPosition(*FileHandle, 0);

        Buffer = ReadBootFile(&Size, FileHandle);
        if (!Buffer)
        {
            break;
        }

        CpBuffer = AllocateZeroPool(Size);
        if (!CpBuffer)
        {
            break;
        }

        for (i = 0; i < Size; i++)
        {
            if ((*(Buffer + i) == ';')       &&
                ((*(Buffer + i + 1) == ';')  ||
                 (*(Buffer + i + 1) == '\r') ||
                 (i + 1 == Size)
                )
               )
            {
                continue;
            }

            *(CpBuffer + NewSize) = *(Buffer + i);
            NewSize++;
        }
        //
        // Remove the exisiting BOOT.NVR
        //
        Status = (*FileHandle)->Delete(*FileHandle);
        if (EFI_ERROR(Status))
        {
            break;
        }

        *FileHandle = NULL;

        Status = (*CurDir)->Open(
                            *CurDir,
                            &NewFile,
                            BOOT_NVR,
                            EFI_FILE_MODE_READ |
                                EFI_FILE_MODE_WRITE |
                                EFI_FILE_MODE_CREATE,
                            0);
        if (EFI_ERROR(Status))
        {
            break;
        }

        Status = NewFile->Write(NewFile, &NewSize, CpBuffer);
        if (EFI_ERROR(Status))
        {
            break;
        }

        bError = FALSE;

    } while (FALSE);
    //
    // Clean up
    //
    if (NewFile)
    {
        NewFile->Close(NewFile);
    }

    if (CpBuffer)
    {
        CpBuffer = RutlFree(CpBuffer);
    }

    if (Buffer)
    {
        Buffer = RutlFree(Buffer);
    }

    return bError;
}

//
// Backup the BOOT.NVR so we have a fall back
//
BOOLEAN
BackupBootFile(
    IN char*            Buffer,
    IN UINTN*           Size,
    IN EFI_FILE_HANDLE* CurDir
    )
{
    BOOLEAN         bError = FALSE;
    EFI_STATUS      Status;
    EFI_FILE_HANDLE FileHandle = NULL;

    do
    {
        //
        // Delete the backup file if already exists
        //
        Status = (*CurDir)->Open(
                            *CurDir,
                            &FileHandle,
                            BACKUP_NVR,
                            EFI_FILE_MODE_READ |
                                EFI_FILE_MODE_WRITE,
                            0);
        if (!EFI_ERROR(Status))
        {
            Status = FileHandle->Delete(FileHandle);
            if (EFI_ERROR(Status))
            {
                break;
            }
        }

        FileHandle = NULL;
        //
        // Copy current file data to a newly created backup file
        //
        Status = (*CurDir)->Open(
                            *CurDir,
                            &FileHandle,
                            BACKUP_NVR,
                            EFI_FILE_MODE_READ |
                                EFI_FILE_MODE_WRITE |
                                EFI_FILE_MODE_CREATE,
                            0);
        if (!EFI_ERROR(Status))
        {
            Status = FileHandle->Write(FileHandle, Size, Buffer);
        }

    } while (FALSE);
    //
    // Clean up
    //
    if (FileHandle)
    {
        FileHandle->Close(FileHandle);
    }

    if (EFI_ERROR(Status))
    {
        bError = TRUE;
    }

    return bError;
}

//
// EFI Entry Point
//
EFI_STATUS
EfiMain(
    IN EFI_HANDLE        ImageHandle,
    IN EFI_SYSTEM_TABLE* ST
    )
{
    char*             Buffer      = NULL;
    char*             OSPath      = NULL;
    UINTN             Size        = 0,
                      Launch      = 0,
                      Menu        = 0;
    BOOT_DATA*        pBootData   = NULL;
    EFI_STATUS        Status;
    EFI_FILE_HANDLE   FileHandle  = NULL,
                      RootFs      = NULL;
    EFI_DEVICE_PATH*  DevicePath  = NULL;
    EFI_LOADED_IMAGE* LoadedImage = NULL;

    do
    {
        InitializeLib(ImageHandle, ST);
        //
        // Get the device handle and file path to the EFI OS Loader itself.
        //
        Status = BS->HandleProtocol(
                    ImageHandle,
                    &LoadedImageProtocol,
                    &LoadedImage);
        if (EFI_ERROR(Status))
        {
            Print(L"Can not retrieve LoadedImageProtocol handle\n");
            break;
        }

        Status = BS->HandleProtocol(
                    LoadedImage->DeviceHandle,
                    &DevicePathProtocol,
                    &DevicePath);
        if (EFI_ERROR(Status) || DevicePath == NULL)
        {
            Print(L"Can not find DevicePath handle\n");
            break;
        }
        //
        // Open volume for the device where the EFI OS Loader was loaded from
        //
        RootFs = LibOpenRoot(LoadedImage->DeviceHandle);
        if (!RootFs)
        {
            Print(L"Can not open the volume for the file system\n");
            break;
        }
        //
        // Look for any cmd line params
        //
        ParseArgs(&RootFs, LoadedImage);
        //
        // Attempt to open the boot.nvr
        //
        Status = RootFs->Open(
                            RootFs,
                            &FileHandle,
                            BOOT_NVR,
                            EFI_FILE_MODE_READ |
                                EFI_FILE_MODE_WRITE,
                            0);
        if (EFI_ERROR(Status))
        {
            Print(L"Can not open the file %s\n", BOOT_NVR);
            break;
        }

        Buffer = ReadBootFile(&Size, &FileHandle);
        if (!Buffer)
        {
            Print(L"ReadBootFile() failed!\n");
            break;
        }

        if (BackupBootFile(Buffer, &Size, &RootFs))
        {
            Print(L"BackupBootFile() failed!\n");
            break;
        }
        //
        // Alloc for boot file data struct
        //
        pBootData = (BOOT_DATA*) AllocateZeroPool(sizeof(BOOT_DATA));
        if (!pBootData)
        {
            Print(L"Failed to allocate memory for BOOT_DATA!\n");
            break;
        }

        if (GetBootData(pBootData, Buffer))
        {
            Print(L"Failed in GetBootData()!\n");
            break;
        }

        Menu = DisplayMenu(pBootData);

        if (Menu < pBootData->dwIndex)
        {
            if (!OrderBootFile(Menu, Buffer, pBootData))
            {
                FileHandle->SetPosition(FileHandle, 0);
                FileHandle->Write(FileHandle, &Size, Buffer);

                if (SortLoadOptions(
                        pBootData,
                        Buffer,
                        &Size,
                        &Menu,
                        &(pBootData->dwIndex),
                        &FileHandle)
                   )
                {
                    Print(L"Failed to SortLoadOptions()!\n");
                    break;
                }

                if (CleanBootFile(&FileHandle, &RootFs))
                {
                    Print(L"Failed to CleanBootFile()!\n");
                    break;
                }
            }
            else
            {
                Print(L"Failed to OrderBootFile()!\n");
                break;
            }
        }
        else
        {
            break;
        }

        OSPath = RutlStrDup(strstr(pBootData->pszOSLdr[Menu], wacks) + 1);
        if (!OSPath)
        {
            Print(L"Failed to allocate memory for OSPath!\n");
            break;
        }

        Launch = 1;

    } while (FALSE);
    //
    // Clean up
    //
    if (pBootData)
    {
        if (pBootData->dwIndex)
        {
            FreeBootData(pBootData);
        }

        pBootData = RutlFree(pBootData);
    }

    if (Buffer)
    {
        Buffer = RutlFree(Buffer);
    }

    if (FileHandle)
    {
        FileHandle->Close(FileHandle);
    }

    if (Launch)
    {
        if (LaunchOS(OSPath, ImageHandle, &RootFs, LoadedImage))
        {
            Print (L"Failed to LaunchOS()!\n");
        }
    }

    return EFI_SUCCESS;
}