tyler.durden/audk
1
0
Fork 0
mirror of https://github.com/acidanthera/audk.git synced 2025-07-28 16:14:04 +02:00
Code Issues Packages Projects Releases Wiki Activity

MdeModulePkg: Enhance the check for numeric opcode with EFI_IFR_DISPLAY_INT_DEC attribute.

Browse Source 
Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Eric Dong <eric.dong@intel.com>
Reviewed-by: Liming Gao <liming.gao@intel.com>

git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@17345 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
Eric Dong 2015-05-06 12:30:13 +00:00 committed by ydong10
parent 1afac950f9
commit afc9bf796c
3 changed files with 282 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
MdeModulePkg/Library/UefiHiiLib/HiiLib.c
View File

@ -1298,41 +1298,77 @@ ValidateQuestionFromVfr (
VarValue = 0; VarValue = 0;
CopyMem (&VarValue, VarBuffer + Offset, Width); CopyMem (&VarValue, VarBuffer + Offset, Width);
} }
switch (IfrNumeric->Flags & EFI_IFR_NUMERIC_SIZE) { if ((IfrNumeric->Flags & EFI_IFR_DISPLAY) == 0) {
case EFI_IFR_NUMERIC_SIZE_1: switch (IfrNumeric->Flags & EFI_IFR_NUMERIC_SIZE) {
if ((UINT8) VarValue < IfrNumeric->data.u8.MinValue || (UINT8) VarValue > IfrNumeric->data.u8.MaxValue) { case EFI_IFR_NUMERIC_SIZE_1:
// if ((INT8) VarValue < (INT8) IfrNumeric->data.u8.MinValue || (INT8) VarValue > (INT8) IfrNumeric->data.u8.MaxValue) {
// Not in the valid range. //
// // Not in the valid range.
return EFI_INVALID_PARAMETER; //
return EFI_INVALID_PARAMETER;
}
break;
case EFI_IFR_NUMERIC_SIZE_2:
if ((INT16) VarValue < (INT16) IfrNumeric->data.u16.MinValue || (INT16) VarValue > (INT16) IfrNumeric->data.u16.MaxValue) {
//
// Not in the valid range.
//
return EFI_INVALID_PARAMETER;
}
break;
case EFI_IFR_NUMERIC_SIZE_4:
if ((INT32) VarValue < (INT32) IfrNumeric->data.u32.MinValue || (INT32) VarValue > (INT32) IfrNumeric->data.u32.MaxValue) {
//
// Not in the valid range.
//
return EFI_INVALID_PARAMETER;
}
break;
case EFI_IFR_NUMERIC_SIZE_8:
if ((INT64) VarValue < (INT64) IfrNumeric->data.u64.MinValue || (INT64) VarValue > (INT64) IfrNumeric->data.u64.MaxValue) {
//
// Not in the valid range.
//
return EFI_INVALID_PARAMETER;
}
break;
} }
break; } else {
case EFI_IFR_NUMERIC_SIZE_2: switch (IfrNumeric->Flags & EFI_IFR_NUMERIC_SIZE) {
if ((UINT16) VarValue < IfrNumeric->data.u16.MinValue || (UINT16) VarValue > IfrNumeric->data.u16.MaxValue) { case EFI_IFR_NUMERIC_SIZE_1:
// if ((UINT8) VarValue < IfrNumeric->data.u8.MinValue || (UINT8) VarValue > IfrNumeric->data.u8.MaxValue) {
// Not in the valid range. //
// // Not in the valid range.
return EFI_INVALID_PARAMETER; //
return EFI_INVALID_PARAMETER;
}
break;
case EFI_IFR_NUMERIC_SIZE_2:
if ((UINT16) VarValue < IfrNumeric->data.u16.MinValue || (UINT16) VarValue > IfrNumeric->data.u16.MaxValue) {
//
// Not in the valid range.
//
return EFI_INVALID_PARAMETER;
}
break;
case EFI_IFR_NUMERIC_SIZE_4:
if ((UINT32) VarValue < IfrNumeric->data.u32.MinValue || (UINT32) VarValue > IfrNumeric->data.u32.MaxValue) {
//
// Not in the valid range.
//
return EFI_INVALID_PARAMETER;
}
break;
case EFI_IFR_NUMERIC_SIZE_8:
if ((UINT64) VarValue < IfrNumeric->data.u64.MinValue || (UINT64) VarValue > IfrNumeric->data.u64.MaxValue) {
//
// Not in the valid range.
//
return EFI_INVALID_PARAMETER;
}
break;
} }
break;
case EFI_IFR_NUMERIC_SIZE_4:
if ((UINT32) VarValue < IfrNumeric->data.u32.MinValue || (UINT32) VarValue > IfrNumeric->data.u32.MaxValue) {
//
// Not in the valid range.
//
return EFI_INVALID_PARAMETER;
}
break;
case EFI_IFR_NUMERIC_SIZE_8:
if ((UINT64) VarValue < IfrNumeric->data.u64.MinValue || (UINT64) VarValue > IfrNumeric->data.u64.MaxValue) {
//
// Not in the valid range.
//
return EFI_INVALID_PARAMETER;
}
break;
} }
break; break;
case EFI_IFR_CHECKBOX_OP: case EFI_IFR_CHECKBOX_OP:
// //

217
MdeModulePkg/Universal/DisplayEngineDxe/InputHandler.c
View File

@ -368,6 +368,9 @@ AdjustQuestionValue (
Get field info from numeric opcode. Get field info from numeric opcode.
@param OpCode Pointer to the current input opcode. @param OpCode Pointer to the current input opcode.
@param IntInput Whether question shows with EFI_IFR_DISPLAY_INT_DEC type.
@param QuestionValue Input question value, with EFI_HII_VALUE type.
@param Value Return question value, always return UINT64 type.
@param Minimum The minimum size info for this opcode. @param Minimum The minimum size info for this opcode.
@param Maximum The maximum size info for this opcode. @param Maximum The maximum size info for this opcode.
@param Step The step size info for this opcode. @param Step The step size info for this opcode.
@ -377,6 +380,9 @@ AdjustQuestionValue (
VOID VOID
GetValueFromNum ( GetValueFromNum (
IN EFI_IFR_OP_HEADER *OpCode, IN EFI_IFR_OP_HEADER *OpCode,
IN BOOLEAN IntInput,
IN EFI_HII_VALUE *QuestionValue,
OUT UINT64 *Value,
OUT UINT64 *Minimum, OUT UINT64 *Minimum,
OUT UINT64 *Maximum, OUT UINT64 *Maximum,
OUT UINT64 *Step, OUT UINT64 *Step,
@ -389,29 +395,57 @@ GetValueFromNum (
switch (NumericOp->Flags & EFI_IFR_NUMERIC_SIZE) { switch (NumericOp->Flags & EFI_IFR_NUMERIC_SIZE) {
case EFI_IFR_NUMERIC_SIZE_1: case EFI_IFR_NUMERIC_SIZE_1:
*Minimum = NumericOp->data.u8.MinValue; if (IntInput) {
*Maximum = NumericOp->data.u8.MaxValue; *Minimum = (INT64) (INT8) NumericOp->data.u8.MinValue;
*Maximum = (INT64) (INT8) NumericOp->data.u8.MaxValue;
*Value = (INT64) (INT8) QuestionValue->Value.u8;
} else {
*Minimum = NumericOp->data.u8.MinValue;
*Maximum = NumericOp->data.u8.MaxValue;
*Value = QuestionValue->Value.u8;
}
*Step = NumericOp->data.u8.Step; *Step = NumericOp->data.u8.Step;
*StorageWidth = (UINT16) sizeof (UINT8); *StorageWidth = (UINT16) sizeof (UINT8);
break; break;
case EFI_IFR_NUMERIC_SIZE_2: case EFI_IFR_NUMERIC_SIZE_2:
*Minimum = NumericOp->data.u16.MinValue; if (IntInput) {
*Maximum = NumericOp->data.u16.MaxValue; *Minimum = (INT64) (INT16) NumericOp->data.u16.MinValue;
*Maximum = (INT64) (INT16) NumericOp->data.u16.MaxValue;
*Value = (INT64) (INT16) QuestionValue->Value.u16;
} else {
*Minimum = NumericOp->data.u16.MinValue;
*Maximum = NumericOp->data.u16.MaxValue;
*Value = QuestionValue->Value.u16;
}
*Step = NumericOp->data.u16.Step; *Step = NumericOp->data.u16.Step;
*StorageWidth = (UINT16) sizeof (UINT16); *StorageWidth = (UINT16) sizeof (UINT16);
break; break;
case EFI_IFR_NUMERIC_SIZE_4: case EFI_IFR_NUMERIC_SIZE_4:
*Minimum = NumericOp->data.u32.MinValue; if (IntInput) {
*Maximum = NumericOp->data.u32.MaxValue; *Minimum = (INT64) (INT32) NumericOp->data.u32.MinValue;
*Maximum = (INT64) (INT32) NumericOp->data.u32.MaxValue;
*Value = (INT64) (INT32) QuestionValue->Value.u32;
} else {
*Minimum = NumericOp->data.u32.MinValue;
*Maximum = NumericOp->data.u32.MaxValue;
*Value = QuestionValue->Value.u32;
}
*Step = NumericOp->data.u32.Step; *Step = NumericOp->data.u32.Step;
*StorageWidth = (UINT16) sizeof (UINT32); *StorageWidth = (UINT16) sizeof (UINT32);
break; break;
case EFI_IFR_NUMERIC_SIZE_8: case EFI_IFR_NUMERIC_SIZE_8:
*Minimum = NumericOp->data.u64.MinValue; if (IntInput) {
*Maximum = NumericOp->data.u64.MaxValue; *Minimum = (INT64) NumericOp->data.u64.MinValue;
*Maximum = (INT64) NumericOp->data.u64.MaxValue;
*Value = (INT64) QuestionValue->Value.u64;
} else {
*Minimum = NumericOp->data.u64.MinValue;
*Maximum = NumericOp->data.u64.MaxValue;
*Value = QuestionValue->Value.u64;
}
*Step = NumericOp->data.u64.Step; *Step = NumericOp->data.u64.Step;
*StorageWidth = (UINT16) sizeof (UINT64); *StorageWidth = (UINT16) sizeof (UINT64);
break; break;
@ -448,6 +482,9 @@ GetNumericInput (
UINTN Loop; UINTN Loop;
BOOLEAN ManualInput; BOOLEAN ManualInput;
BOOLEAN HexInput; BOOLEAN HexInput;
BOOLEAN IntInput;
BOOLEAN Negative;
BOOLEAN ValidateFail;
BOOLEAN DateOrTime; BOOLEAN DateOrTime;
UINTN InputWidth; UINTN InputWidth;
UINT64 EditValue; UINT64 EditValue;
@ -472,6 +509,10 @@ GetNumericInput (
Minimum = 0; Minimum = 0;
Maximum = 0; Maximum = 0;
NumericOp = NULL; NumericOp = NULL;
IntInput = FALSE;
HexInput = FALSE;
Negative = FALSE;
ValidateFail = FALSE;
Question = MenuOption->ThisTag; Question = MenuOption->ThisTag;
QuestionValue = &Question->CurrentValue; QuestionValue = &Question->CurrentValue;
@ -568,16 +609,19 @@ GetNumericInput (
} else { } else {
ASSERT (Question->OpCode->OpCode == EFI_IFR_NUMERIC_OP); ASSERT (Question->OpCode->OpCode == EFI_IFR_NUMERIC_OP);
NumericOp = (EFI_IFR_NUMERIC *) Question->OpCode; NumericOp = (EFI_IFR_NUMERIC *) Question->OpCode;
GetValueFromNum(Question->OpCode, &Minimum, &Maximum, &Step, &StorageWidth); GetValueFromNum(Question->OpCode, (NumericOp->Flags & EFI_IFR_DISPLAY) == 0, QuestionValue, &EditValue, &Minimum, &Maximum, &Step, &StorageWidth);
EditValue = QuestionValue->Value.u64;
EraseLen = gOptionBlockWidth; EraseLen = gOptionBlockWidth;
} }
if ((Question->OpCode->OpCode == EFI_IFR_NUMERIC_OP) && (NumericOp != NULL) && if ((Question->OpCode->OpCode == EFI_IFR_NUMERIC_OP) && (NumericOp != NULL)) {
((NumericOp->Flags & EFI_IFR_DISPLAY) == EFI_IFR_DISPLAY_UINT_HEX)) { if ((NumericOp->Flags & EFI_IFR_DISPLAY) == EFI_IFR_DISPLAY_UINT_HEX){
HexInput = TRUE; HexInput = TRUE;
} else { } else if ((NumericOp->Flags & EFI_IFR_DISPLAY) == 0){
HexInput = FALSE; //
// Display with EFI_IFR_DISPLAY_INT_DEC type. Support negative number.
//
IntInput = TRUE;
}
} }
// //
@ -609,6 +653,13 @@ GetNumericInput (
InputWidth = 0; InputWidth = 0;
break; break;
} }
if (IntInput) {
//
// Support an extra '-' for negative number.
//
InputWidth += 1;
}
} }
InputText[0] = LEFT_NUMERIC_DELIMITER; InputText[0] = LEFT_NUMERIC_DELIMITER;
@ -691,13 +742,27 @@ TheKey2:
case '+': case '+':
case '-': case '-':
if (Key.UnicodeChar == '+') { if (ManualInput && IntInput) {
Key.ScanCode = SCAN_RIGHT; //
// In Manual input mode, check whether input the negative flag.
//
if (Key.UnicodeChar == '-') {
if (Negative) {
break;
}
Negative = TRUE;
PrintCharAt (Column++, Row, Key.UnicodeChar);
}
} else { } else {
Key.ScanCode = SCAN_LEFT; if (Key.UnicodeChar == '+') {
Key.ScanCode = SCAN_RIGHT;
} else {
Key.ScanCode = SCAN_LEFT;
}
Key.UnicodeChar = CHAR_NULL;
goto TheKey2;
} }
Key.UnicodeChar = CHAR_NULL; break;
goto TheKey2;
case CHAR_NULL: case CHAR_NULL:
switch (Key.ScanCode) { switch (Key.ScanCode) {
@ -715,20 +780,40 @@ TheKey2:
if ((Step != 0) && !ManualInput) { if ((Step != 0) && !ManualInput) {
if (Key.ScanCode == SCAN_LEFT) { if (Key.ScanCode == SCAN_LEFT) {
if (EditValue >= Minimum + Step) { if (IntInput) {
EditValue = EditValue - Step; if ((INT64) EditValue >= (INT64) Minimum + (INT64) Step) {
} else if (EditValue > Minimum){ EditValue = EditValue - Step;
EditValue = Minimum; } else if ((INT64) EditValue > (INT64) Minimum){
EditValue = Minimum;
} else {
EditValue = Maximum;
}
} else { } else {
EditValue = Maximum; if (EditValue >= Minimum + Step) {
EditValue = EditValue - Step;
} else if (EditValue > Minimum){
EditValue = Minimum;
} else {
EditValue = Maximum;
}
} }
} else if (Key.ScanCode == SCAN_RIGHT) { } else if (Key.ScanCode == SCAN_RIGHT) {
if (EditValue + Step <= Maximum) { if (IntInput) {
EditValue = EditValue + Step; if ((INT64) EditValue + (INT64) Step <= (INT64) Maximum) {
} else if (EditValue < Maximum) { EditValue = EditValue + Step;
EditValue = Maximum; } else if ((INT64) EditValue < (INT64) Maximum) {
EditValue = Maximum;
} else {
EditValue = Minimum;
}
} else { } else {
EditValue = Minimum; if (EditValue + Step <= Maximum) {
EditValue = EditValue + Step;
} else if (EditValue < Maximum) {
EditValue = Maximum;
} else {
EditValue = Minimum;
}
} }
} }
@ -808,13 +893,29 @@ EnterCarriageReturn:
// //
// Validate input value with Minimum value. // Validate input value with Minimum value.
// //
if (EditValue < Minimum) { ValidateFail = FALSE;
if (IntInput) {
//
// After user input Enter, need to check whether the input value.
// If input a negative value, should compare with maximum value.
// else compare with the minimum value.
//
if (Negative) {
ValidateFail = (INT64) EditValue > (INT64) Maximum ? TRUE : FALSE;
} else {
ValidateFail = (INT64) EditValue < (INT64) Minimum ? TRUE : FALSE;
}
if (ValidateFail) {
UpdateStatusBar (INPUT_ERROR, TRUE);
break;
}
} else if (EditValue < Minimum) {
UpdateStatusBar (INPUT_ERROR, TRUE); UpdateStatusBar (INPUT_ERROR, TRUE);
break; break;
} else {
UpdateStatusBar (INPUT_ERROR, FALSE);
} }
UpdateStatusBar (INPUT_ERROR, FALSE);
CopyMem (&gUserInput->InputValue, &Question->CurrentValue, sizeof (EFI_HII_VALUE)); CopyMem (&gUserInput->InputValue, &Question->CurrentValue, sizeof (EFI_HII_VALUE));
QuestionValue = &gUserInput->InputValue; QuestionValue = &gUserInput->InputValue;
// //
@ -877,6 +978,11 @@ EnterCarriageReturn:
case CHAR_BACKSPACE: case CHAR_BACKSPACE:
if (ManualInput) { if (ManualInput) {
if (Count == 0) { if (Count == 0) {
if (Negative) {
Negative = FALSE;
Column--;
PrintStringAt (Column, Row, L" ");
}
break; break;
} }
// //
@ -922,26 +1028,57 @@ EnterCarriageReturn:
if (Count != 0) { if (Count != 0) {
if (HexInput) { if (HexInput) {
EditValue = LShiftU64 (EditValue, 4) + Digital; EditValue = LShiftU64 (EditValue, 4) + Digital;
} else if (IntInput && Negative) {
//
// Save the negative number.
//
EditValue = ~(MultU64x32 (~(EditValue - 1), 10) + (Key.UnicodeChar - L'0')) + 1;
} else { } else {
EditValue = MultU64x32 (EditValue, 10) + (Key.UnicodeChar - L'0'); EditValue = MultU64x32 (EditValue, 10) + (Key.UnicodeChar - L'0');
} }
} else { } else {
if (HexInput) { if (HexInput) {
EditValue = Digital; EditValue = Digital;
} else if (IntInput && Negative) {
//
// Save the negative number.
//
EditValue = ~(Key.UnicodeChar - L'0') + 1;
} else { } else {
EditValue = Key.UnicodeChar - L'0'; EditValue = Key.UnicodeChar - L'0';
} }
} }
if (EditValue > Maximum) { if (IntInput) {
UpdateStatusBar (INPUT_ERROR, TRUE); ValidateFail = FALSE;
ASSERT (Count < sizeof (PreviousNumber) / sizeof (PreviousNumber[0])); //
EditValue = PreviousNumber[Count]; // When user input a new value, should check the current value.
break; // If user input a negative value, should compare it with minimum
// value, else compare it with maximum value.
//
if (Negative) {
ValidateFail = (INT64) EditValue < (INT64) Minimum ? TRUE : FALSE;
} else {
ValidateFail = (INT64) EditValue > (INT64) Maximum ? TRUE : FALSE;
}
if (ValidateFail) {
UpdateStatusBar (INPUT_ERROR, TRUE);
ASSERT (Count < sizeof (PreviousNumber) / sizeof (PreviousNumber[0]));
EditValue = PreviousNumber[Count];
break;
}
} else { } else {
UpdateStatusBar (INPUT_ERROR, FALSE); if (EditValue > Maximum) {
UpdateStatusBar (INPUT_ERROR, TRUE);
ASSERT (Count < sizeof (PreviousNumber) / sizeof (PreviousNumber[0]));
EditValue = PreviousNumber[Count];
break;
}
} }
UpdateStatusBar (INPUT_ERROR, FALSE);
Count++; Count++;
ASSERT (Count < (sizeof (PreviousNumber) / sizeof (PreviousNumber[0]))); ASSERT (Count < (sizeof (PreviousNumber) / sizeof (PreviousNumber[0])));
PreviousNumber[Count] = EditValue; PreviousNumber[Count] = EditValue;

40
MdeModulePkg/Universal/SetupBrowserDxe/Setup.c
View File

@ -3944,9 +3944,43 @@ GetQuestionDefault (
// //
// Take minimum value as numeric default value // Take minimum value as numeric default value
// //
if ((HiiValue->Value.u64 < Question->Minimum) || (HiiValue->Value.u64 > Question->Maximum)) { if ((Question->Flags & EFI_IFR_DISPLAY) == 0) {
HiiValue->Value.u64 = Question->Minimum; //
Status = EFI_SUCCESS; // In EFI_IFR_DISPLAY_INT_DEC type, should check value with int* type.
//
switch (Question->Flags & EFI_IFR_NUMERIC_SIZE) {
case EFI_IFR_NUMERIC_SIZE_1:
if (((INT8) HiiValue->Value.u8 < (INT8) Question->Minimum) || ((INT8) HiiValue->Value.u8 > (INT8) Question->Maximum)) {
HiiValue->Value.u8 = (UINT8) Question->Minimum;
Status = EFI_SUCCESS;
}
break;
case EFI_IFR_NUMERIC_SIZE_2:
if (((INT16) HiiValue->Value.u16 < (INT16) Question->Minimum) || ((INT16) HiiValue->Value.u16 > (INT16) Question->Maximum)) {
HiiValue->Value.u16 = (UINT16) Question->Minimum;
Status = EFI_SUCCESS;
}
break;
case EFI_IFR_NUMERIC_SIZE_4:
if (((INT32) HiiValue->Value.u32 < (INT32) Question->Minimum) || ((INT32) HiiValue->Value.u32 > (INT32) Question->Maximum)) {
HiiValue->Value.u32 = (UINT32) Question->Minimum;
Status = EFI_SUCCESS;
}
break;
case EFI_IFR_NUMERIC_SIZE_8:
if (((INT64) HiiValue->Value.u64 < (INT64) Question->Minimum) || ((INT64) HiiValue->Value.u64 > (INT64) Question->Maximum)) {
HiiValue->Value.u64 = Question->Minimum;
Status = EFI_SUCCESS;
}
break;
default:
break;
}
} else {
if ((HiiValue->Value.u64 < Question->Minimum) || (HiiValue->Value.u64 > Question->Maximum)) {
HiiValue->Value.u64 = Question->Minimum;
Status = EFI_SUCCESS;
}
} }
break; break;