#include "screen.h"
#include "../include/refit_call_wrapper.h"
#include "../include/RemovableMedia.h"
-//#include "../include/UsbMass.h"
+#include "gpt.h"
#ifdef __MAKEWITH_GNUEFI
#define EfiReallocatePool ReallocatePool
REFIT_VOLUME *SelfVolume = NULL;
REFIT_VOLUME **Volumes = NULL;
UINTN VolumesCount = 0;
+extern GPT_DATA *gPartitions;
// Maximum size for disk sectors
#define SECTOR_SIZE 4096
if (FindMem(Buffer, 512, "Press any key to restart", 24) >= 0)
Volume->HasBootCode = FALSE;
- // dummy FAT boot sector (created by iPartition)
- if ((FindMem(Buffer, 512, "Medienfehler", 12) >= 0) &&
- (FindMem(Buffer, 512, "Neustart: Taste dr\x81" "ken", 22) >= 0))
- Volume->HasBootCode = FALSE;
-
// check for MBR partition table
if (*((UINT16 *)(Buffer + 510)) == 0xaa55) {
MbrTable = (MBR_PARTITION_INFO *)(Buffer + 446);
SPrint(TheValue, 255, L"%ld%s", SizeInIeee, Units);
} // if
return TheValue;
-} // CHAR16 *SizeInSIUnits()
+} // CHAR16 *SizeInIEEEUnits()
// Return a name for the volume. Ideally this should be the label for the
// filesystem it contains, but this function falls back to describing the
// this information can be extracted.
// The calling function is responsible for freeing the memory allocated
// for the name string.
-static CHAR16 *GetVolumeName(IN REFIT_VOLUME *Volume) {
+static CHAR16 *GetVolumeName(REFIT_VOLUME *Volume) {
EFI_FILE_SYSTEM_INFO *FileSystemInfoPtr;
CHAR16 *FoundName = NULL;
CHAR16 *SISize, *TypeName;
FoundName = StrDuplicate(FileSystemInfoPtr->VolumeLabel);
}
- // Special case: rEFInd HFS+ driver always returns label of "HFS+ volume", so wipe
+ // Special case: Old versions of the rEFInd HFS+ driver always returns label of "HFS+ volume", so wipe
// this so that we can build a new name that includes the size....
if ((FoundName != NULL) && (StrCmp(FoundName, L"HFS+ volume") == 0) && (Volume->FSType == FS_TYPE_HFSPLUS)) {
MyFreePool(FoundName);
FoundName = NULL;
} // if rEFInd HFS+ driver suspected
- if (FoundName == NULL) { // filesystem has no name, so use fs type and size
+ // If no filesystem name, try to use the partition name....
+ if ((FoundName == NULL) && (Volume->PartName != NULL) && (StrLen(Volume->PartName) > 0) &&
+ !IsIn(Volume->PartName, IGNORE_PARTITION_NAMES)) {
+ FoundName = StrDuplicate(Volume->PartName);
+ } // if use partition name
+
+ // No filesystem or acceptable partition name, so use fs type and size
+ if (FoundName == NULL) {
FoundName = AllocateZeroPool(sizeof(CHAR16) * 256);
if (FoundName != NULL) {
SISize = SizeInIEEEUnits(FileSystemInfoPtr->VolumeSize);
return FoundName;
} // static CHAR16 *GetVolumeName()
+// Determine the unique GUID of the volume and store it.
+static VOID SetPartGuidAndName(REFIT_VOLUME *Volume, EFI_DEVICE_PATH_PROTOCOL *DevicePath) {
+ HARDDRIVE_DEVICE_PATH *HdDevicePath;
+
+ if (Volume == NULL)
+ return;
+
+ if ((DevicePath->Type == MEDIA_DEVICE_PATH) && (DevicePath->SubType == MEDIA_HARDDRIVE_DP)) {
+ HdDevicePath = (HARDDRIVE_DEVICE_PATH*) DevicePath;
+ if (HdDevicePath->SignatureType == SIGNATURE_TYPE_GUID) {
+ Volume->PartGuid = *((EFI_GUID*) HdDevicePath->Signature);
+ Volume->PartName = PartNameFromGuid(&(Volume->PartGuid));
+ } // if
+ } // if
+} // VOID SetPartGuid()
+
VOID ScanVolume(REFIT_VOLUME *Volume)
{
EFI_STATUS Status;
while (DevicePath != NULL && !IsDevicePathEndType(DevicePath)) {
NextDevicePath = NextDevicePathNode(DevicePath);
+ if (DevicePathType(DevicePath) == MEDIA_DEVICE_PATH) {
+ SetPartGuidAndName(Volume, DevicePath);
+ }
if (DevicePathType(DevicePath) == MESSAGING_DEVICE_PATH &&
(DevicePathSubType(DevicePath) == MSG_USB_DP ||
DevicePathSubType(DevicePath) == MSG_USB_CLASS_DP ||
}
// look at the BlockIO protocol
- Status = refit_call3_wrapper(BS->HandleProtocol, WholeDiskHandle, &BlockIoProtocol, (VOID **) &Volume->WholeDiskBlockIO);
+ Status = refit_call3_wrapper(BS->HandleProtocol, WholeDiskHandle, &BlockIoProtocol,
+ (VOID **) &Volume->WholeDiskBlockIO);
if (!EFI_ERROR(Status)) {
// check the media block size
UINTN SectorSum, i, VolNumber = 0;
UINT8 *SectorBuffer1, *SectorBuffer2;
EFI_GUID *UuidList;
- EFI_GUID NullUuid = { 00000000, 0000, 0000, {0000, 0000, 0000, 0000} };
+ EFI_GUID NullUuid = NULL_GUID_VALUE;
MyFreePool(Volumes);
Volumes = NULL;
VolumesCount = 0;
+ ForgetPartitionTables();
// get all filesystem handles
Status = LibLocateHandle(ByProtocol, &BlockIoProtocol, NULL, &HandleCount, &Handles);
UuidList = AllocateZeroPool(sizeof(EFI_GUID) * HandleCount);
- // was: &FileSystemProtocol
if (Status == EFI_NOT_FOUND) {
return; // no filesystems. strange, but true...
}
for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
Volume = AllocateZeroPool(sizeof(REFIT_VOLUME));
Volume->DeviceHandle = Handles[HandleIndex];
+ AddPartitionTable(Volume);
ScanVolume(Volume);
if (UuidList) {
UuidList[HandleIndex] = Volume->VolUuid;
Volume->BlockIO != Volume->WholeDiskBlockIO) {
for (VolumeIndex2 = 0; VolumeIndex2 < VolumesCount; VolumeIndex2++) {
if (Volumes[VolumeIndex2]->BlockIO == Volume->WholeDiskBlockIO &&
- Volumes[VolumeIndex2]->BlockIOOffset == 0)
+ Volumes[VolumeIndex2]->BlockIOOffset == 0) {
WholeDiskVolume = Volumes[VolumeIndex2];
+ }
}
}
MyFreePool(SectorBuffer1);
MyFreePool(SectorBuffer2);
}
-
} // for
} /* VOID ScanVolumes() */
return (PathOnly);
}
+/*++
+ *
+ * Routine Description:
+ *
+ * Find a substring.
+ *
+ * Arguments:
+ *
+ * String - Null-terminated string to search.
+ * StrCharSet - Null-terminated string to search for.
+ *
+ * Returns:
+ * The address of the first occurrence of the matching substring if successful, or NULL otherwise.
+ * --*/
+CHAR16* MyStrStr (CHAR16 *String, CHAR16 *StrCharSet)
+{
+ CHAR16 *Src;
+ CHAR16 *Sub;
+
+ if ((String == NULL) || (StrCharSet == NULL))
+ return NULL;
+
+ Src = String;
+ Sub = StrCharSet;
+
+ while ((*String != L'\0') && (*StrCharSet != L'\0')) {
+ if (*String++ != *StrCharSet) {
+ String = ++Src;
+ StrCharSet = Sub;
+ } else {
+ StrCharSet++;
+ }
+ }
+ if (*StrCharSet == L'\0') {
+ return Src;
+ } else {
+ return NULL;
+ }
+} // CHAR16 *MyStrStr()
+
+// Restrict TheString to at most Limit characters.
+// Does this in two ways:
+// - Locates stretches of two or more spaces and compresses
+// them down to one space.
+// - Truncates TheString
+// Returns TRUE if changes were made, FALSE otherwise
+BOOLEAN LimitStringLength(CHAR16 *TheString, UINTN Limit) {
+ CHAR16 *SubString, *TempString;
+ UINTN i;
+ BOOLEAN HasChanged = FALSE;
+
+ // SubString will be NULL or point WITHIN TheString
+ SubString = MyStrStr(TheString, L" ");
+ while (SubString != NULL) {
+ i = 0;
+ while (SubString[i] == L' ')
+ i++;
+ if (i >= StrLen(SubString)) {
+ SubString[0] = '\0';
+ HasChanged = TRUE;
+ } else {
+ TempString = StrDuplicate(&SubString[i]);
+ if (TempString != NULL) {
+ StrCpy(&SubString[1], TempString);
+ MyFreePool(TempString);
+ HasChanged = TRUE;
+ } else {
+ // memory allocation problem; abort to avoid potentially infinite loop!
+ break;
+ } // if/else
+ } // if/else
+ SubString = MyStrStr(TheString, L" ");
+ } // while
+
+ // If the string is still too long, truncate it....
+ if (StrLen(TheString) > Limit) {
+ TheString[Limit] = '\0';
+ HasChanged = TRUE;
+ } // if
+
+ return HasChanged;
+} // BOOLEAN LimitStringLength()
+
// Takes an input loadpath, splits it into disk and filename components, finds a matching
// DeviceVolume, and returns that and the filename (*loader).
VOID FindVolumeAndFilename(IN EFI_DEVICE_PATH *loadpath, OUT REFIT_VOLUME **DeviceVolume, OUT CHAR16 **loader) {
Found = TRUE;
} // while
} // if
- return Found;
+ return Found;
} // BOOLEAN IsIn()
+// Returns TRUE if any element of List can be found as a substring of
+// BigString, FALSE otherwise. Performs comparisons case-insensitively.
+BOOLEAN IsInSubstring(IN CHAR16 *BigString, IN CHAR16 *List) {
+ UINTN i = 0, ElementLength;
+ BOOLEAN Found = FALSE;
+ CHAR16 *OneElement;
+
+ if (BigString && List) {
+ while (!Found && (OneElement = FindCommaDelimited(List, i++))) {
+ ElementLength = StrLen(OneElement);
+ if ((ElementLength <= StrLen(BigString)) && (StriSubCmp(OneElement, BigString)))
+ Found = TRUE;
+ } // while
+ } // if
+ return Found;
+} // BOOLEAN IsSubstringIn()
+
// Returns TRUE if specified Volume, Directory, and Filename correspond to an
// element in the comma-delimited List, FALSE otherwise. Note that Directory and
// Filename must *NOT* include a volume or path specification (that's part of
return (Ejected > 0);
} // VOID EjectMedia()
+// Converts consecutive characters in the input string into a
+// number, interpreting the string as a hexadecimal number, starting
+// at the specified position and continuing for the specified number
+// of characters or until the end of the string, whichever is first.
+// NumChars must be between 1 and 16. Ignores invalid characters.
+UINT64 StrToHex(CHAR16 *Input, UINTN Pos, UINTN NumChars) {
+ UINT64 retval = 0x00;
+ UINTN NumDone = 0;
+ CHAR16 a;
+
+ if ((Input == NULL) || (StrLen(Input) < Pos) || (NumChars == 0) || (NumChars > 16)) {
+ return 0;
+ }
+
+ while ((StrLen(Input) >= Pos) && (NumDone < NumChars)) {
+ a = Input[Pos];
+ if ((a >= '0') && (a <= '9')) {
+ retval *= 0x10;
+ retval += (a - '0');
+ NumDone++;
+ }
+ if ((a >= 'a') && (a <= 'f')) {
+ retval *= 0x10;
+ retval += (a - 'a' + 0x0a);
+ NumDone++;
+ }
+ if ((a >= 'A') && (a <= 'F')) {
+ retval *= 0x10;
+ retval += (a - 'A' + 0x0a);
+ NumDone++;
+ }
+ Pos++;
+ } // while()
+ return retval;
+} // StrToHex()
+
+// Returns TRUE if UnknownString can be interpreted as a GUID, FALSE otherwise.
+// Note that the input string must have no extraneous spaces and must be
+// conventionally formatted as a 36-character GUID, complete with dashes in
+// appropriate places.
+BOOLEAN IsGuid(CHAR16 *UnknownString) {
+ UINTN Length, i;
+ BOOLEAN retval = TRUE;
+ CHAR16 a;
+
+ if (UnknownString == NULL)
+ return FALSE;
+
+ Length = StrLen(UnknownString);
+ if (Length != 36)
+ return FALSE;
+
+ for (i = 0; i < Length; i++) {
+ a = UnknownString[i];
+ if ((i == 8) || (i == 13) || (i == 18) || (i == 23)) {
+ if (a != '-')
+ retval = FALSE;
+ } else if (((a < 'a') || (a > 'f')) && ((a < 'A') || (a > 'F')) && ((a < '0') && (a > '9'))) {
+ retval = FALSE;
+ } // if/else if
+ } // for
+ return retval;
+} // BOOLEAN IsGuid()
// Return the GUID as a string, suitable for display to the user. Note that the calling
// function is responsible for freeing the allocated memory.
}
return TheString;
} // GuidAsString(EFI_GUID *GuidData)
+
+EFI_GUID StringAsGuid(CHAR16 * InString) {
+ EFI_GUID Guid = NULL_GUID_VALUE;
+
+ if (!IsGuid(InString)) {
+ return Guid;
+ }
+
+ Guid.Data1 = (UINT32) StrToHex(InString, 0, 8);
+ Guid.Data2 = (UINT16) StrToHex(InString, 9, 4);
+ Guid.Data3 = (UINT16) StrToHex(InString, 14, 4);
+ Guid.Data4[0] = (UINT8) StrToHex(InString, 19, 2);
+ Guid.Data4[1] = (UINT8) StrToHex(InString, 21, 2);
+ Guid.Data4[2] = (UINT8) StrToHex(InString, 23, 2);
+ Guid.Data4[3] = (UINT8) StrToHex(InString, 26, 2);
+ Guid.Data4[4] = (UINT8) StrToHex(InString, 28, 2);
+ Guid.Data4[5] = (UINT8) StrToHex(InString, 30, 2);
+ Guid.Data4[6] = (UINT8) StrToHex(InString, 32, 2);
+ Guid.Data4[7] = (UINT8) StrToHex(InString, 34, 2);
+
+ return Guid;
+} // EFI_GUID StringAsGuid()
+
+// Returns TRUE if the two GUIDs are equal, FALSE otherwise
+BOOLEAN GuidsAreEqual(EFI_GUID *Guid1, EFI_GUID *Guid2) {
+ return (CompareMem(Guid1, Guid2, 16) == 0);
+} // BOOLEAN CompareGuids()
+