a0c56a8219
0. Remove the unused private GUID from module source files. 1. Use gEfiCallerIdGuid replace of the private module GUID. 2. Add the public header files to define HII FormSet and PackageList GUID used in every HII driver. Signed-off-by: lgao4 Reviewed-by: ydong10 gdong1 tye jfan12 wli12 rsun3 jyao1 ftian git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@12375 6f19259b-4bc3-4df7-8a09-765794883524
2512 lines
71 KiB
C
2512 lines
71 KiB
C
/** @file
|
|
The functions to modify a user profile.
|
|
|
|
Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
|
|
This program and the accompanying materials
|
|
are licensed and made available under the terms and conditions of the BSD License
|
|
which accompanies this distribution. The full text of the license may be found at
|
|
http://opensource.org/licenses/bsd-license.php
|
|
|
|
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
|
|
**/
|
|
|
|
#include "UserProfileManager.h"
|
|
|
|
EFI_USER_PROFILE_HANDLE mModifyUser = NULL;
|
|
|
|
/**
|
|
Display user select form, cab select a user to modify.
|
|
|
|
**/
|
|
VOID
|
|
SelectUserToModify (
|
|
VOID
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINT8 Index;
|
|
EFI_USER_PROFILE_HANDLE User;
|
|
EFI_USER_PROFILE_HANDLE CurrentUser;
|
|
UINT32 CurrentAccessRight;
|
|
VOID *StartOpCodeHandle;
|
|
VOID *EndOpCodeHandle;
|
|
EFI_IFR_GUID_LABEL *StartLabel;
|
|
EFI_IFR_GUID_LABEL *EndLabel;
|
|
|
|
//
|
|
// Initialize the container for dynamic opcodes.
|
|
//
|
|
StartOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (StartOpCodeHandle != NULL);
|
|
|
|
EndOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (EndOpCodeHandle != NULL);
|
|
|
|
//
|
|
// Create Hii Extend Label OpCode.
|
|
//
|
|
StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
|
|
StartOpCodeHandle,
|
|
&gEfiIfrTianoGuid,
|
|
NULL,
|
|
sizeof (EFI_IFR_GUID_LABEL)
|
|
);
|
|
StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
|
|
StartLabel->Number = LABEL_USER_MOD_FUNC;
|
|
|
|
EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
|
|
EndOpCodeHandle,
|
|
&gEfiIfrTianoGuid,
|
|
NULL,
|
|
sizeof (EFI_IFR_GUID_LABEL)
|
|
);
|
|
EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
|
|
EndLabel->Number = LABEL_END;
|
|
|
|
//
|
|
// Add each user can be modified.
|
|
//
|
|
User = NULL;
|
|
Index = 1;
|
|
mUserManager->Current (mUserManager, &CurrentUser);
|
|
while (TRUE) {
|
|
Status = mUserManager->GetNext (mUserManager, &User);
|
|
if (EFI_ERROR (Status)) {
|
|
break;
|
|
}
|
|
|
|
Status = GetAccessRight (&CurrentAccessRight);
|
|
if (EFI_ERROR (Status)) {
|
|
CurrentAccessRight = EFI_USER_INFO_ACCESS_ENROLL_SELF;
|
|
}
|
|
|
|
if ((CurrentAccessRight == EFI_USER_INFO_ACCESS_MANAGE) || (User == CurrentUser)) {
|
|
AddUserToForm (User, (UINT16)(KEY_MODIFY_USER | KEY_SELECT_USER | Index), StartOpCodeHandle);
|
|
}
|
|
Index++;
|
|
}
|
|
|
|
HiiUpdateForm (
|
|
mCallbackInfo->HiiHandle, // HII handle
|
|
&gUserProfileManagerGuid, // Formset GUID
|
|
FORMID_MODIFY_USER, // Form ID
|
|
StartOpCodeHandle, // Label for where to insert opcodes
|
|
EndOpCodeHandle // Replace data
|
|
);
|
|
|
|
HiiFreeOpCodeHandle (StartOpCodeHandle);
|
|
HiiFreeOpCodeHandle (EndOpCodeHandle);
|
|
}
|
|
|
|
|
|
/**
|
|
Get all the user info from mModifyUser in the user manager, and save on the
|
|
global variable.
|
|
|
|
**/
|
|
VOID
|
|
GetAllUserInfo (
|
|
VOID
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_USER_INFO_HANDLE UserInfo;
|
|
EFI_USER_INFO *Info;
|
|
UINTN InfoSize;
|
|
UINTN MemSize;
|
|
UINTN DataLen;
|
|
|
|
//
|
|
// Init variable to default value.
|
|
//
|
|
mProviderChoice = 0;
|
|
mConncetLogical = 0;
|
|
|
|
mUserInfo.CreateDateExist = FALSE;
|
|
mUserInfo.UsageDateExist = FALSE;
|
|
mUserInfo.UsageCount = 0;
|
|
|
|
mUserInfo.AccessPolicyLen = 0;
|
|
mUserInfo.AccessPolicyModified = FALSE;
|
|
if (mUserInfo.AccessPolicy != NULL) {
|
|
FreePool (mUserInfo.AccessPolicy);
|
|
mUserInfo.AccessPolicy = NULL;
|
|
}
|
|
mUserInfo.IdentityPolicyLen = 0;
|
|
mUserInfo.IdentityPolicyModified = FALSE;
|
|
if (mUserInfo.IdentityPolicy != NULL) {
|
|
FreePool (mUserInfo.IdentityPolicy);
|
|
mUserInfo.IdentityPolicy = NULL;
|
|
}
|
|
|
|
//
|
|
// Allocate user information memory.
|
|
//
|
|
MemSize = sizeof (EFI_USER_INFO) + 63;
|
|
Info = AllocateZeroPool (MemSize);
|
|
if (Info == NULL) {
|
|
return ;
|
|
}
|
|
|
|
//
|
|
// Get each user information.
|
|
//
|
|
UserInfo = NULL;
|
|
while (TRUE) {
|
|
Status = mUserManager->GetNextInfo (mUserManager, mModifyUser, &UserInfo);
|
|
if (EFI_ERROR (Status)) {
|
|
break;
|
|
}
|
|
//
|
|
// Get information.
|
|
//
|
|
InfoSize = MemSize;
|
|
Status = mUserManager->GetInfo (
|
|
mUserManager,
|
|
mModifyUser,
|
|
UserInfo,
|
|
Info,
|
|
&InfoSize
|
|
);
|
|
if (Status == EFI_BUFFER_TOO_SMALL) {
|
|
MemSize = InfoSize;
|
|
FreePool (Info);
|
|
Info = AllocateZeroPool (MemSize);
|
|
if (Info == NULL) {
|
|
return ;
|
|
}
|
|
|
|
Status = mUserManager->GetInfo (
|
|
mUserManager,
|
|
mModifyUser,
|
|
UserInfo,
|
|
Info,
|
|
&InfoSize
|
|
);
|
|
}
|
|
|
|
if (Status == EFI_SUCCESS) {
|
|
//
|
|
// Deal with each information according to informaiton type.
|
|
//
|
|
DataLen = Info->InfoSize - sizeof (EFI_USER_INFO);
|
|
switch (Info->InfoType) {
|
|
case EFI_USER_INFO_NAME_RECORD:
|
|
CopyMem (&mUserInfo.UserName, (UINT8 *) (Info + 1), DataLen);
|
|
break;
|
|
|
|
case EFI_USER_INFO_CREATE_DATE_RECORD:
|
|
CopyMem (&mUserInfo.CreateDate, (UINT8 *) (Info + 1), DataLen);
|
|
mUserInfo.CreateDateExist = TRUE;
|
|
break;
|
|
|
|
case EFI_USER_INFO_USAGE_DATE_RECORD:
|
|
CopyMem (&mUserInfo.UsageDate, (UINT8 *) (Info + 1), DataLen);
|
|
mUserInfo.UsageDateExist = TRUE;
|
|
break;
|
|
|
|
case EFI_USER_INFO_USAGE_COUNT_RECORD:
|
|
CopyMem (&mUserInfo.UsageCount, (UINT8 *) (Info + 1), DataLen);
|
|
break;
|
|
|
|
case EFI_USER_INFO_ACCESS_POLICY_RECORD:
|
|
mUserInfo.AccessPolicy = AllocateZeroPool (DataLen);
|
|
if (mUserInfo.AccessPolicy == NULL) {
|
|
break;
|
|
}
|
|
|
|
CopyMem (mUserInfo.AccessPolicy, (UINT8 *) (Info + 1), DataLen);
|
|
mUserInfo.AccessPolicyLen = DataLen;
|
|
break;
|
|
|
|
case EFI_USER_INFO_IDENTITY_POLICY_RECORD:
|
|
mUserInfo.IdentityPolicy = AllocateZeroPool (DataLen);
|
|
if (mUserInfo.IdentityPolicy == NULL) {
|
|
break;
|
|
}
|
|
|
|
CopyMem (mUserInfo.IdentityPolicy, (UINT8 *) (Info + 1), DataLen);
|
|
mUserInfo.IdentityPolicyLen = DataLen;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
FreePool (Info);
|
|
}
|
|
|
|
|
|
/**
|
|
Convert the Date to a string, and update the Hii database DateID string with it.
|
|
|
|
@param[in] Date Points to the date to be converted.
|
|
@param[in] DateId String ID in the HII database to be replaced.
|
|
|
|
**/
|
|
VOID
|
|
ResolveDate (
|
|
IN EFI_TIME *Date,
|
|
IN EFI_STRING_ID DateId
|
|
)
|
|
{
|
|
CHAR16 *Str;
|
|
UINTN DateBufLen;
|
|
|
|
//
|
|
// Convert date to string.
|
|
//
|
|
DateBufLen = 64;
|
|
Str = AllocateZeroPool (DateBufLen);
|
|
if (Str == NULL) {
|
|
return ;
|
|
}
|
|
|
|
UnicodeSPrint (
|
|
Str,
|
|
DateBufLen,
|
|
L"%4d-%2d-%2d ",
|
|
Date->Year,
|
|
Date->Month,
|
|
Date->Day
|
|
);
|
|
|
|
//
|
|
// Convert time to string.
|
|
//
|
|
DateBufLen -= StrLen (Str);
|
|
UnicodeSPrint (
|
|
Str + StrLen (Str),
|
|
DateBufLen,
|
|
L"%2d:%2d:%2d",
|
|
Date->Hour,
|
|
Date->Minute,
|
|
Date->Second
|
|
);
|
|
|
|
HiiSetString (mCallbackInfo->HiiHandle, DateId, Str, NULL);
|
|
FreePool (Str);
|
|
}
|
|
|
|
|
|
/**
|
|
Convert the CountVal to a string, and update the Hii database CountId string
|
|
with it.
|
|
|
|
@param[in] CountVal The hex value to convert.
|
|
@param[in] CountId String ID in the HII database to be replaced.
|
|
|
|
**/
|
|
VOID
|
|
ResolveCount (
|
|
IN UINT32 CountVal,
|
|
IN EFI_STRING_ID CountId
|
|
)
|
|
{
|
|
CHAR16 Count[10];
|
|
|
|
UnicodeSPrint (Count, 20, L"%d", CountVal);
|
|
HiiSetString (mCallbackInfo->HiiHandle, CountId, Count, NULL);
|
|
}
|
|
|
|
|
|
/**
|
|
Concatenates one Null-terminated Unicode string to another Null-terminated
|
|
Unicode string.
|
|
|
|
@param[in, out] Source1 On entry, point to a Null-terminated Unicode string.
|
|
On exit, point to a new concatenated Unicode string
|
|
@param[in] Source2 Pointer to a Null-terminated Unicode string.
|
|
|
|
**/
|
|
VOID
|
|
AddStr (
|
|
IN OUT CHAR16 **Source1,
|
|
IN CONST CHAR16 *Source2
|
|
)
|
|
{
|
|
CHAR16 *TmpStr;
|
|
UINTN StrLength;
|
|
|
|
ASSERT (Source1 != NULL);
|
|
ASSERT (Source2 != NULL);
|
|
|
|
if (*Source1 == NULL) {
|
|
StrLength = StrSize (Source2);
|
|
} else {
|
|
StrLength = StrSize (*Source1);
|
|
StrLength += StrSize (Source2) -1;
|
|
}
|
|
|
|
TmpStr = AllocateZeroPool (StrLength);
|
|
ASSERT (TmpStr != NULL);
|
|
|
|
if (*Source1 == NULL) {
|
|
StrCpy (TmpStr, Source2);;
|
|
} else {
|
|
StrCpy (TmpStr, *Source1);
|
|
FreePool (*Source1);
|
|
StrCat (TmpStr, Source2);
|
|
}
|
|
|
|
*Source1 = TmpStr;
|
|
}
|
|
|
|
|
|
/**
|
|
Convert the identity policy to a unicode string and update the Hii database
|
|
IpStringId string with it.
|
|
|
|
@param[in] Ip Points to identity policy.
|
|
@param[in] IpLen The identity policy length.
|
|
@param[in] IpStringId String ID in the HII database to be replaced.
|
|
|
|
**/
|
|
VOID
|
|
ResolveIdentityPolicy (
|
|
IN UINT8 *Ip,
|
|
IN UINTN IpLen,
|
|
IN EFI_STRING_ID IpStringId
|
|
)
|
|
{
|
|
CHAR16 *TmpStr;
|
|
UINTN ChkLen;
|
|
EFI_USER_INFO_IDENTITY_POLICY *Identity;
|
|
UINT16 Index;
|
|
CHAR16 *ProvStr;
|
|
EFI_STRING_ID ProvId;
|
|
EFI_HII_HANDLE HiiHandle;
|
|
EFI_USER_CREDENTIAL_PROTOCOL *UserCredential;
|
|
|
|
TmpStr = NULL;
|
|
|
|
//
|
|
// Resolve each policy.
|
|
//
|
|
ChkLen = 0;
|
|
while (ChkLen < IpLen) {
|
|
Identity = (EFI_USER_INFO_IDENTITY_POLICY *) (Ip + ChkLen);
|
|
switch (Identity->Type) {
|
|
case EFI_USER_INFO_IDENTITY_FALSE:
|
|
AddStr (&TmpStr, L"False");
|
|
break;
|
|
|
|
case EFI_USER_INFO_IDENTITY_TRUE:
|
|
AddStr (&TmpStr, L"None");
|
|
break;
|
|
|
|
case EFI_USER_INFO_IDENTITY_NOT:
|
|
AddStr (&TmpStr, L"! ");
|
|
break;
|
|
|
|
case EFI_USER_INFO_IDENTITY_AND:
|
|
AddStr (&TmpStr, L" && ");
|
|
break;
|
|
|
|
case EFI_USER_INFO_IDENTITY_OR:
|
|
AddStr (&TmpStr, L" || ");
|
|
break;
|
|
|
|
case EFI_USER_INFO_IDENTITY_CREDENTIAL_TYPE:
|
|
for (Index = 0; Index < mProviderInfo->Count; Index++) {
|
|
UserCredential = mProviderInfo->Provider[Index];
|
|
if (CompareGuid ((EFI_GUID *) (Identity + 1), &UserCredential->Type)) {
|
|
UserCredential->Title (
|
|
UserCredential,
|
|
&HiiHandle,
|
|
&ProvId
|
|
);
|
|
ProvStr = HiiGetString (HiiHandle, ProvId, NULL);
|
|
if (ProvStr != NULL) {
|
|
AddStr (&TmpStr, ProvStr);
|
|
FreePool (ProvStr);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EFI_USER_INFO_IDENTITY_CREDENTIAL_PROVIDER:
|
|
for (Index = 0; Index < mProviderInfo->Count; Index++) {
|
|
UserCredential = mProviderInfo->Provider[Index];
|
|
if (CompareGuid ((EFI_GUID *) (Identity + 1), &UserCredential->Identifier)) {
|
|
UserCredential->Title (
|
|
UserCredential,
|
|
&HiiHandle,
|
|
&ProvId
|
|
);
|
|
ProvStr = HiiGetString (HiiHandle, ProvId, NULL);
|
|
if (ProvStr != NULL) {
|
|
AddStr (&TmpStr, ProvStr);
|
|
FreePool (ProvStr);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
ChkLen += Identity->Length;
|
|
}
|
|
|
|
if (TmpStr != NULL) {
|
|
HiiSetString (mCallbackInfo->HiiHandle, IpStringId, TmpStr, NULL);
|
|
FreePool (TmpStr);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
Display modify user information form.
|
|
|
|
This form displays, username, create Date, usage date, usage count, identity policy,
|
|
and access policy.
|
|
|
|
@param[in] UserIndex The index of the user in display list to modify.
|
|
|
|
**/
|
|
VOID
|
|
ModifyUserInfo (
|
|
IN UINT8 UserIndex
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_USER_PROFILE_HANDLE CurrentUser;
|
|
UINT32 CurrentAccessRight;
|
|
VOID *StartOpCodeHandle;
|
|
VOID *EndOpCodeHandle;
|
|
EFI_IFR_GUID_LABEL *StartLabel;
|
|
EFI_IFR_GUID_LABEL *EndLabel;
|
|
|
|
//
|
|
// Initialize the container for dynamic opcodes.
|
|
//
|
|
StartOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (StartOpCodeHandle != NULL);
|
|
|
|
EndOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (EndOpCodeHandle != NULL);
|
|
|
|
//
|
|
// Create Hii Extend Label OpCode.
|
|
//
|
|
StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
|
|
StartOpCodeHandle,
|
|
&gEfiIfrTianoGuid,
|
|
NULL,
|
|
sizeof (EFI_IFR_GUID_LABEL)
|
|
);
|
|
StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
|
|
StartLabel->Number = LABEL_USER_INFO_FUNC;
|
|
|
|
EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
|
|
EndOpCodeHandle,
|
|
&gEfiIfrTianoGuid,
|
|
NULL,
|
|
sizeof (EFI_IFR_GUID_LABEL)
|
|
);
|
|
EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
|
|
EndLabel->Number = LABEL_END;
|
|
|
|
//
|
|
// Find the user profile to be modified.
|
|
//
|
|
mModifyUser = NULL;
|
|
Status = mUserManager->GetNext (mUserManager, &mModifyUser);
|
|
if (EFI_ERROR (Status)) {
|
|
return ;
|
|
}
|
|
|
|
while (UserIndex > 1) {
|
|
Status = mUserManager->GetNext (mUserManager, &mModifyUser);
|
|
if (EFI_ERROR (Status)) {
|
|
return ;
|
|
}
|
|
UserIndex--;
|
|
}
|
|
|
|
//
|
|
// Get user profile information.
|
|
//
|
|
GetAllUserInfo ();
|
|
|
|
//
|
|
// Update user name.
|
|
HiiSetString (
|
|
mCallbackInfo->HiiHandle,
|
|
STRING_TOKEN (STR_USER_NAME_VAL),
|
|
mUserInfo.UserName,
|
|
NULL
|
|
);
|
|
|
|
//
|
|
// Update create date.
|
|
//
|
|
if (mUserInfo.CreateDateExist) {
|
|
ResolveDate (&mUserInfo.CreateDate, STRING_TOKEN (STR_CREATE_DATE_VAL));
|
|
} else {
|
|
HiiSetString (
|
|
mCallbackInfo->HiiHandle,
|
|
STRING_TOKEN (STR_CREATE_DATE_VAL),
|
|
L"",
|
|
NULL
|
|
);
|
|
}
|
|
|
|
//
|
|
// Add usage date.
|
|
//
|
|
if (mUserInfo.UsageDateExist) {
|
|
ResolveDate (&mUserInfo.UsageDate, STRING_TOKEN (STR_USAGE_DATE_VAL));
|
|
} else {
|
|
HiiSetString (
|
|
mCallbackInfo->HiiHandle,
|
|
STRING_TOKEN (STR_USAGE_DATE_VAL),
|
|
L"",
|
|
NULL
|
|
);
|
|
}
|
|
|
|
//
|
|
// Add usage count.
|
|
//
|
|
ResolveCount ((UINT32) mUserInfo.UsageCount, STRING_TOKEN (STR_USAGE_COUNT_VAL));
|
|
|
|
//
|
|
// Add identity policy.
|
|
//
|
|
mUserManager->Current (mUserManager, &CurrentUser);
|
|
if (mModifyUser == CurrentUser) {
|
|
ResolveIdentityPolicy (
|
|
mUserInfo.IdentityPolicy,
|
|
mUserInfo.IdentityPolicyLen,
|
|
STRING_TOKEN (STR_IDENTIFY_POLICY_VAL)
|
|
);
|
|
HiiCreateGotoOpCode (
|
|
StartOpCodeHandle, // Container for opcodes
|
|
FORMID_MODIFY_IP, // Target Form ID
|
|
STRING_TOKEN (STR_IDENTIFY_POLICY), // Prompt text
|
|
STRING_TOKEN (STR_IDENTIFY_POLICY_VAL), // Help text
|
|
EFI_IFR_FLAG_CALLBACK, // Question flag
|
|
KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_IP // Question ID
|
|
);
|
|
}
|
|
|
|
//
|
|
// Add access policy.
|
|
//
|
|
Status = GetAccessRight (&CurrentAccessRight);
|
|
if (EFI_ERROR (Status)) {
|
|
CurrentAccessRight = EFI_USER_INFO_ACCESS_ENROLL_SELF;
|
|
}
|
|
|
|
if (CurrentAccessRight == EFI_USER_INFO_ACCESS_MANAGE) {
|
|
HiiCreateGotoOpCode (
|
|
StartOpCodeHandle, // Container for opcodes
|
|
FORMID_MODIFY_AP, // Target Form ID
|
|
STRING_TOKEN (STR_ACCESS_POLICY), // Prompt text
|
|
STRING_TOKEN (STR_NULL_STRING), // Help text
|
|
EFI_IFR_FLAG_CALLBACK, // Question flag
|
|
KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_AP // Question ID
|
|
);
|
|
}
|
|
|
|
HiiUpdateForm (
|
|
mCallbackInfo->HiiHandle, // HII handle
|
|
&gUserProfileManagerGuid, // Formset GUID
|
|
FORMID_USER_INFO, // Form ID
|
|
StartOpCodeHandle, // Label
|
|
EndOpCodeHandle // Replace data
|
|
);
|
|
|
|
HiiFreeOpCodeHandle (StartOpCodeHandle);
|
|
HiiFreeOpCodeHandle (EndOpCodeHandle);
|
|
}
|
|
|
|
|
|
/**
|
|
Get all the access policy info from current user info, and save in the global
|
|
variable.
|
|
|
|
**/
|
|
VOID
|
|
ResolveAccessPolicy (
|
|
VOID
|
|
)
|
|
{
|
|
UINTN OffSet;
|
|
EFI_USER_INFO_ACCESS_CONTROL Control;
|
|
UINTN ValLen;
|
|
UINT8 *AccessData;
|
|
|
|
//
|
|
// Set default value
|
|
//
|
|
mAccessInfo.AccessRight = EFI_USER_INFO_ACCESS_ENROLL_SELF;
|
|
mAccessInfo.AccessSetup = ACCESS_SETUP_RESTRICTED;
|
|
mAccessInfo.AccessBootOrder = EFI_USER_INFO_ACCESS_BOOT_ORDER_INSERT;
|
|
|
|
mAccessInfo.LoadPermitLen = 0;
|
|
mAccessInfo.LoadForbidLen = 0;
|
|
mAccessInfo.ConnectPermitLen = 0;
|
|
mAccessInfo.ConnectForbidLen = 0;
|
|
|
|
//
|
|
// Get each user access policy.
|
|
//
|
|
OffSet = 0;
|
|
while (OffSet < mUserInfo.AccessPolicyLen) {
|
|
CopyMem (&Control, mUserInfo.AccessPolicy + OffSet, sizeof (Control));
|
|
ValLen = Control.Size - sizeof (Control);
|
|
switch (Control.Type) {
|
|
case EFI_USER_INFO_ACCESS_ENROLL_SELF:
|
|
mAccessInfo.AccessRight = EFI_USER_INFO_ACCESS_ENROLL_SELF;
|
|
break;
|
|
|
|
case EFI_USER_INFO_ACCESS_ENROLL_OTHERS:
|
|
mAccessInfo.AccessRight = EFI_USER_INFO_ACCESS_ENROLL_OTHERS;
|
|
break;
|
|
|
|
case EFI_USER_INFO_ACCESS_MANAGE:
|
|
mAccessInfo.AccessRight = EFI_USER_INFO_ACCESS_MANAGE;
|
|
break;
|
|
|
|
case EFI_USER_INFO_ACCESS_SETUP:
|
|
AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);
|
|
if (CompareGuid ((EFI_GUID *) AccessData, &gEfiUserInfoAccessSetupNormalGuid)) {
|
|
mAccessInfo.AccessSetup = ACCESS_SETUP_NORMAL;
|
|
} else if (CompareGuid ((EFI_GUID *) AccessData, &gEfiUserInfoAccessSetupRestrictedGuid)) {
|
|
mAccessInfo.AccessSetup = ACCESS_SETUP_RESTRICTED;
|
|
} else if (CompareGuid ((EFI_GUID *) AccessData, &gEfiUserInfoAccessSetupAdminGuid)) {
|
|
mAccessInfo.AccessSetup = ACCESS_SETUP_ADMIN;
|
|
}
|
|
break;
|
|
|
|
case EFI_USER_INFO_ACCESS_BOOT_ORDER:
|
|
AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);
|
|
CopyMem (&mAccessInfo.AccessBootOrder, AccessData, sizeof (UINT32));
|
|
break;
|
|
|
|
case EFI_USER_INFO_ACCESS_FORBID_LOAD:
|
|
if (mAccessInfo.LoadForbid != NULL) {
|
|
FreePool (mAccessInfo.LoadForbid);
|
|
}
|
|
|
|
mAccessInfo.LoadForbid = AllocateZeroPool (ValLen);
|
|
if (mAccessInfo.LoadForbid != NULL) {
|
|
AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);
|
|
CopyMem (mAccessInfo.LoadForbid, AccessData, ValLen);
|
|
mAccessInfo.LoadForbidLen = ValLen;
|
|
}
|
|
break;
|
|
|
|
case EFI_USER_INFO_ACCESS_PERMIT_LOAD:
|
|
if (mAccessInfo.LoadPermit != NULL) {
|
|
FreePool (mAccessInfo.LoadPermit);
|
|
}
|
|
|
|
mAccessInfo.LoadPermit = AllocateZeroPool (ValLen);
|
|
if (mAccessInfo.LoadPermit != NULL) {
|
|
AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);
|
|
CopyMem (mAccessInfo.LoadPermit, AccessData, ValLen);
|
|
mAccessInfo.LoadPermitLen = ValLen;
|
|
}
|
|
break;
|
|
|
|
case EFI_USER_INFO_ACCESS_FORBID_CONNECT:
|
|
if (mAccessInfo.ConnectForbid != NULL) {
|
|
FreePool (mAccessInfo.ConnectForbid);
|
|
}
|
|
|
|
mAccessInfo.ConnectForbid = AllocateZeroPool (ValLen);
|
|
if (mAccessInfo.ConnectForbid != NULL) {
|
|
AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);
|
|
CopyMem (mAccessInfo.ConnectForbid, AccessData, ValLen);
|
|
mAccessInfo.ConnectForbidLen = ValLen;
|
|
}
|
|
break;
|
|
|
|
case EFI_USER_INFO_ACCESS_PERMIT_CONNECT:
|
|
if (mAccessInfo.ConnectPermit != NULL) {
|
|
FreePool (mAccessInfo.ConnectPermit);
|
|
}
|
|
|
|
mAccessInfo.ConnectPermit = AllocateZeroPool (ValLen);
|
|
if (mAccessInfo.ConnectPermit != NULL) {
|
|
AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);
|
|
CopyMem (mAccessInfo.ConnectPermit, AccessData, ValLen);
|
|
mAccessInfo.ConnectPermitLen = ValLen;
|
|
}
|
|
break;
|
|
}
|
|
|
|
OffSet += Control.Size;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
Find the specified info in profile mModifyUser by the InfoType.
|
|
|
|
@param[in] InfoType The user information type to find.
|
|
@param[out] UserInfo Points to user information handle found.
|
|
|
|
@retval EFI_SUCCESS Find the user information successfully.
|
|
@retval Others Fail to find the user information.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
FindInfoByType (
|
|
IN UINT8 InfoType,
|
|
OUT EFI_USER_INFO_HANDLE *UserInfo
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_USER_INFO *Info;
|
|
UINTN InfoSize;
|
|
UINTN MemSize;
|
|
|
|
if (UserInfo == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
*UserInfo = NULL;
|
|
//
|
|
// Allocate user information memory.
|
|
//
|
|
MemSize = sizeof (EFI_USER_INFO) + 63;
|
|
Info = AllocateZeroPool (MemSize);
|
|
if (Info == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
//
|
|
// Get each user information.
|
|
//
|
|
while (TRUE) {
|
|
Status = mUserManager->GetNextInfo (mUserManager, mModifyUser, UserInfo);
|
|
if (EFI_ERROR (Status)) {
|
|
break;
|
|
}
|
|
//
|
|
// Get information.
|
|
//
|
|
InfoSize = MemSize;
|
|
Status = mUserManager->GetInfo (
|
|
mUserManager,
|
|
mModifyUser,
|
|
*UserInfo,
|
|
Info,
|
|
&InfoSize
|
|
);
|
|
if (Status == EFI_BUFFER_TOO_SMALL) {
|
|
MemSize = InfoSize;
|
|
FreePool (Info);
|
|
Info = AllocateZeroPool (MemSize);
|
|
if (Info == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
Status = mUserManager->GetInfo (
|
|
mUserManager,
|
|
mModifyUser,
|
|
*UserInfo,
|
|
Info,
|
|
&InfoSize
|
|
);
|
|
}
|
|
if (Status == EFI_SUCCESS) {
|
|
if (Info->InfoType == InfoType) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
FreePool (Info);
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Display modify user access policy form.
|
|
|
|
In this form, access right, access setup and access boot order are dynamically
|
|
added. Load devicepath and connect devicepath are displayed too.
|
|
|
|
**/
|
|
VOID
|
|
ModidyAccessPolicy (
|
|
VOID
|
|
)
|
|
{
|
|
VOID *StartOpCodeHandle;
|
|
VOID *EndOpCodeHandle;
|
|
VOID *OptionsOpCodeHandle;
|
|
EFI_IFR_GUID_LABEL *StartLabel;
|
|
EFI_IFR_GUID_LABEL *EndLabel;
|
|
VOID *DefaultOpCodeHandle;
|
|
|
|
//
|
|
// Initialize the container for dynamic opcodes.
|
|
//
|
|
StartOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (StartOpCodeHandle != NULL);
|
|
|
|
EndOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (EndOpCodeHandle != NULL);
|
|
|
|
//
|
|
// Create Hii Extend Label OpCode.
|
|
//
|
|
StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
|
|
StartOpCodeHandle,
|
|
&gEfiIfrTianoGuid,
|
|
NULL,
|
|
sizeof (EFI_IFR_GUID_LABEL)
|
|
);
|
|
StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
|
|
StartLabel->Number = LABEL_AP_MOD_FUNC;
|
|
|
|
EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
|
|
EndOpCodeHandle,
|
|
&gEfiIfrTianoGuid,
|
|
NULL,
|
|
sizeof (EFI_IFR_GUID_LABEL)
|
|
);
|
|
EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
|
|
EndLabel->Number = LABEL_END;
|
|
|
|
|
|
//
|
|
// Resolve access policy information.
|
|
//
|
|
ResolveAccessPolicy ();
|
|
|
|
//
|
|
// Add access right one-of-code.
|
|
//
|
|
OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (OptionsOpCodeHandle != NULL);
|
|
DefaultOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (DefaultOpCodeHandle != NULL);
|
|
|
|
HiiCreateOneOfOptionOpCode (
|
|
OptionsOpCodeHandle,
|
|
STRING_TOKEN (STR_NORMAL),
|
|
0,
|
|
EFI_IFR_NUMERIC_SIZE_1,
|
|
EFI_USER_INFO_ACCESS_ENROLL_SELF
|
|
);
|
|
|
|
HiiCreateOneOfOptionOpCode (
|
|
OptionsOpCodeHandle,
|
|
STRING_TOKEN (STR_ENROLL),
|
|
0,
|
|
EFI_IFR_NUMERIC_SIZE_1,
|
|
EFI_USER_INFO_ACCESS_ENROLL_OTHERS
|
|
);
|
|
|
|
HiiCreateOneOfOptionOpCode (
|
|
OptionsOpCodeHandle,
|
|
STRING_TOKEN (STR_MANAGE),
|
|
0,
|
|
EFI_IFR_NUMERIC_SIZE_1,
|
|
EFI_USER_INFO_ACCESS_MANAGE
|
|
);
|
|
|
|
HiiCreateDefaultOpCode (
|
|
DefaultOpCodeHandle,
|
|
EFI_HII_DEFAULT_CLASS_STANDARD,
|
|
EFI_IFR_NUMERIC_SIZE_1,
|
|
mAccessInfo.AccessRight
|
|
);
|
|
|
|
HiiCreateOneOfOpCode (
|
|
StartOpCodeHandle, // Container for dynamic created opcodes
|
|
KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_AP | KEY_MODIFY_RIGHT, // Question ID
|
|
0, // VarStore ID
|
|
0, // Offset in Buffer Storage
|
|
STRING_TOKEN (STR_ACCESS_RIGHT), // Question prompt text
|
|
STRING_TOKEN (STR_ACCESS_RIGHT_HELP), // Question help text
|
|
EFI_IFR_FLAG_CALLBACK, // Question flag
|
|
EFI_IFR_NUMERIC_SIZE_1, // Data type of Question Value
|
|
OptionsOpCodeHandle, // Option Opcode list
|
|
DefaultOpCodeHandle // Default Opcode
|
|
);
|
|
HiiFreeOpCodeHandle (DefaultOpCodeHandle);
|
|
HiiFreeOpCodeHandle (OptionsOpCodeHandle);
|
|
|
|
|
|
//
|
|
// Add setup type one-of-code.
|
|
//
|
|
OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (OptionsOpCodeHandle != NULL);
|
|
DefaultOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (DefaultOpCodeHandle != NULL);
|
|
|
|
HiiCreateOneOfOptionOpCode (
|
|
OptionsOpCodeHandle,
|
|
STRING_TOKEN (STR_RESTRICTED),
|
|
0,
|
|
EFI_IFR_NUMERIC_SIZE_1,
|
|
ACCESS_SETUP_RESTRICTED
|
|
);
|
|
|
|
HiiCreateOneOfOptionOpCode (
|
|
OptionsOpCodeHandle,
|
|
STRING_TOKEN (STR_NORMAL),
|
|
0,
|
|
EFI_IFR_NUMERIC_SIZE_1,
|
|
ACCESS_SETUP_NORMAL
|
|
);
|
|
|
|
HiiCreateOneOfOptionOpCode (
|
|
OptionsOpCodeHandle,
|
|
STRING_TOKEN (STR_ADMIN),
|
|
0,
|
|
EFI_IFR_NUMERIC_SIZE_1,
|
|
ACCESS_SETUP_ADMIN
|
|
);
|
|
|
|
HiiCreateDefaultOpCode (
|
|
DefaultOpCodeHandle,
|
|
EFI_HII_DEFAULT_CLASS_STANDARD,
|
|
EFI_IFR_NUMERIC_SIZE_1,
|
|
mAccessInfo.AccessSetup
|
|
);
|
|
|
|
HiiCreateOneOfOpCode (
|
|
StartOpCodeHandle, // Container for dynamic created opcodes
|
|
KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_AP | KEY_MODIFY_SETUP, // Question ID
|
|
0, // VarStore ID
|
|
0, // Offset in Buffer Storage
|
|
STRING_TOKEN (STR_ACCESS_SETUP), // Question prompt text
|
|
STRING_TOKEN (STR_ACCESS_SETUP_HELP), // Question help text
|
|
EFI_IFR_FLAG_CALLBACK, // Question flag
|
|
EFI_IFR_NUMERIC_SIZE_1, // Data type of Question Value
|
|
OptionsOpCodeHandle, // Option Opcode list
|
|
DefaultOpCodeHandle // Default Opcode
|
|
);
|
|
HiiFreeOpCodeHandle (DefaultOpCodeHandle);
|
|
HiiFreeOpCodeHandle (OptionsOpCodeHandle);
|
|
|
|
//
|
|
// Add boot order one-of-code.
|
|
//
|
|
OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (OptionsOpCodeHandle != NULL);
|
|
DefaultOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (DefaultOpCodeHandle != NULL);
|
|
|
|
HiiCreateOneOfOptionOpCode (
|
|
OptionsOpCodeHandle,
|
|
STRING_TOKEN (STR_INSERT),
|
|
0,
|
|
EFI_IFR_NUMERIC_SIZE_4,
|
|
EFI_USER_INFO_ACCESS_BOOT_ORDER_INSERT
|
|
);
|
|
|
|
HiiCreateOneOfOptionOpCode (
|
|
OptionsOpCodeHandle,
|
|
STRING_TOKEN (STR_APPEND),
|
|
0,
|
|
EFI_IFR_NUMERIC_SIZE_4,
|
|
EFI_USER_INFO_ACCESS_BOOT_ORDER_APPEND
|
|
);
|
|
|
|
HiiCreateOneOfOptionOpCode (
|
|
OptionsOpCodeHandle,
|
|
STRING_TOKEN (STR_REPLACE),
|
|
0,
|
|
EFI_IFR_NUMERIC_SIZE_4,
|
|
EFI_USER_INFO_ACCESS_BOOT_ORDER_REPLACE
|
|
);
|
|
|
|
HiiCreateOneOfOptionOpCode (
|
|
OptionsOpCodeHandle,
|
|
STRING_TOKEN (STR_NODEFAULT),
|
|
0,
|
|
EFI_IFR_NUMERIC_SIZE_4,
|
|
EFI_USER_INFO_ACCESS_BOOT_ORDER_NODEFAULT
|
|
);
|
|
|
|
HiiCreateDefaultOpCode (
|
|
DefaultOpCodeHandle,
|
|
EFI_HII_DEFAULT_CLASS_STANDARD,
|
|
EFI_IFR_NUMERIC_SIZE_4,
|
|
mAccessInfo.AccessBootOrder
|
|
);
|
|
|
|
HiiCreateOneOfOpCode (
|
|
StartOpCodeHandle, // Container for dynamic created opcodes
|
|
KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_AP | KEY_MODIFY_BOOT, // Question ID
|
|
0, // VarStore ID
|
|
0, // Offset in Buffer Storage
|
|
STRING_TOKEN (STR_BOOR_ORDER), // Question prompt text
|
|
STRING_TOKEN (STR_BOOT_ORDER_HELP), // Question help text
|
|
EFI_IFR_FLAG_CALLBACK, // Question flag
|
|
EFI_IFR_NUMERIC_SIZE_1, // Data type of Question Value
|
|
OptionsOpCodeHandle, // Option Opcode list
|
|
DefaultOpCodeHandle // Default Opcode
|
|
);
|
|
HiiFreeOpCodeHandle (DefaultOpCodeHandle);
|
|
HiiFreeOpCodeHandle (OptionsOpCodeHandle);
|
|
|
|
//
|
|
// Update Form.
|
|
//
|
|
HiiUpdateForm (
|
|
mCallbackInfo->HiiHandle, // HII handle
|
|
&gUserProfileManagerGuid, // Formset GUID
|
|
FORMID_MODIFY_AP, // Form ID
|
|
StartOpCodeHandle, // Label for where to insert opcodes
|
|
EndOpCodeHandle // Replace data
|
|
);
|
|
|
|
HiiFreeOpCodeHandle (StartOpCodeHandle);
|
|
HiiFreeOpCodeHandle (EndOpCodeHandle);
|
|
}
|
|
|
|
|
|
/**
|
|
Expand access policy memory size.
|
|
|
|
@param[in] ValidLen The valid access policy length.
|
|
@param[in] ExpandLen The length that is needed to expand.
|
|
|
|
**/
|
|
VOID
|
|
ExpandMemory (
|
|
IN UINTN ValidLen,
|
|
IN UINTN ExpandLen
|
|
)
|
|
{
|
|
UINT8 *Mem;
|
|
UINTN Len;
|
|
|
|
//
|
|
// Expand memory.
|
|
//
|
|
Len = mUserInfo.AccessPolicyLen + (ExpandLen / 64 + 1) * 64;
|
|
Mem = AllocateZeroPool (Len);
|
|
ASSERT (Mem != NULL);
|
|
|
|
if (mUserInfo.AccessPolicy != NULL) {
|
|
CopyMem (Mem, mUserInfo.AccessPolicy, ValidLen);
|
|
FreePool (mUserInfo.AccessPolicy);
|
|
}
|
|
|
|
mUserInfo.AccessPolicy = Mem;
|
|
mUserInfo.AccessPolicyLen = Len;
|
|
}
|
|
|
|
|
|
/**
|
|
Collect all the access policy data to mUserInfo.AccessPolicy,
|
|
and save it to user profile.
|
|
|
|
**/
|
|
VOID
|
|
SaveAccessPolicy (
|
|
VOID
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINTN OffSet;
|
|
UINTN Size;
|
|
EFI_USER_INFO_ACCESS_CONTROL Control;
|
|
EFI_USER_INFO_HANDLE UserInfo;
|
|
EFI_USER_INFO *Info;
|
|
|
|
if (mUserInfo.AccessPolicy != NULL) {
|
|
FreePool (mUserInfo.AccessPolicy);
|
|
}
|
|
mUserInfo.AccessPolicy = NULL;
|
|
mUserInfo.AccessPolicyLen = 0;
|
|
mUserInfo.AccessPolicyModified = TRUE;
|
|
OffSet = 0;
|
|
|
|
//
|
|
// Save access right.
|
|
//
|
|
Size = sizeof (EFI_USER_INFO_ACCESS_CONTROL);
|
|
if (mUserInfo.AccessPolicyLen - OffSet < Size) {
|
|
ExpandMemory (OffSet, Size);
|
|
}
|
|
|
|
Control.Type = mAccessInfo.AccessRight;
|
|
Control.Size = (UINT32) Size;
|
|
CopyMem (mUserInfo.AccessPolicy + OffSet, &Control, sizeof (Control));
|
|
OffSet += sizeof (Control);
|
|
|
|
//
|
|
// Save access setup.
|
|
//
|
|
Size = sizeof (EFI_USER_INFO_ACCESS_CONTROL) + sizeof (EFI_GUID);
|
|
if (mUserInfo.AccessPolicyLen - OffSet < Size) {
|
|
ExpandMemory (OffSet, Size);
|
|
}
|
|
|
|
Control.Type = EFI_USER_INFO_ACCESS_SETUP;
|
|
Control.Size = (UINT32) Size;
|
|
CopyMem (mUserInfo.AccessPolicy + OffSet, &Control, sizeof (Control));
|
|
OffSet += sizeof (Control);
|
|
|
|
if (mAccessInfo.AccessSetup == ACCESS_SETUP_NORMAL) {
|
|
CopyGuid ((EFI_GUID *) (mUserInfo.AccessPolicy + OffSet), &gEfiUserInfoAccessSetupNormalGuid);
|
|
} else if (mAccessInfo.AccessSetup == ACCESS_SETUP_RESTRICTED) {
|
|
CopyGuid ((EFI_GUID *) (mUserInfo.AccessPolicy + OffSet), &gEfiUserInfoAccessSetupRestrictedGuid);
|
|
} else if (mAccessInfo.AccessSetup == ACCESS_SETUP_ADMIN) {
|
|
CopyGuid ((EFI_GUID *) (mUserInfo.AccessPolicy + OffSet), &gEfiUserInfoAccessSetupAdminGuid);
|
|
}
|
|
OffSet += sizeof (EFI_GUID);
|
|
|
|
//
|
|
// Save access of boot order.
|
|
//
|
|
Size = sizeof (EFI_USER_INFO_ACCESS_CONTROL) + sizeof (UINT32);
|
|
if (mUserInfo.AccessPolicyLen - OffSet < Size) {
|
|
ExpandMemory (OffSet, Size);
|
|
}
|
|
|
|
Control.Type = EFI_USER_INFO_ACCESS_BOOT_ORDER;
|
|
Control.Size = (UINT32) Size;
|
|
CopyMem (mUserInfo.AccessPolicy + OffSet, &Control, sizeof (Control));
|
|
OffSet += sizeof (Control);
|
|
|
|
CopyMem ((UINT8 *) (mUserInfo.AccessPolicy + OffSet), &mAccessInfo.AccessBootOrder, sizeof (UINT32));
|
|
OffSet += sizeof (UINT32);
|
|
|
|
//
|
|
// Save permit load.
|
|
//
|
|
if (mAccessInfo.LoadPermitLen > 0) {
|
|
Size = sizeof (EFI_USER_INFO_ACCESS_CONTROL) + mAccessInfo.LoadPermitLen;
|
|
if (mUserInfo.AccessPolicyLen - OffSet < Size) {
|
|
ExpandMemory (OffSet, Size);
|
|
}
|
|
|
|
Control.Type = EFI_USER_INFO_ACCESS_PERMIT_LOAD;
|
|
Control.Size = (UINT32) Size;
|
|
CopyMem (mUserInfo.AccessPolicy + OffSet, &Control, sizeof (Control));
|
|
OffSet += sizeof (Control);
|
|
|
|
CopyMem (mUserInfo.AccessPolicy + OffSet, mAccessInfo.LoadPermit, mAccessInfo.LoadPermitLen);
|
|
OffSet += mAccessInfo.LoadPermitLen;
|
|
}
|
|
|
|
//
|
|
// Save forbid load.
|
|
//
|
|
if (mAccessInfo.LoadForbidLen > 0) {
|
|
Size = sizeof (EFI_USER_INFO_ACCESS_CONTROL) + mAccessInfo.LoadForbidLen;
|
|
if (mUserInfo.AccessPolicyLen - OffSet < Size) {
|
|
ExpandMemory (OffSet, Size);
|
|
}
|
|
|
|
Control.Type = EFI_USER_INFO_ACCESS_FORBID_LOAD;
|
|
Control.Size = (UINT32) Size;
|
|
CopyMem (mUserInfo.AccessPolicy + OffSet, &Control, sizeof (Control));
|
|
OffSet += sizeof (Control);
|
|
|
|
CopyMem (mUserInfo.AccessPolicy + OffSet, mAccessInfo.LoadForbid, mAccessInfo.LoadForbidLen);
|
|
OffSet += mAccessInfo.LoadForbidLen;
|
|
}
|
|
|
|
//
|
|
// Save permit connect.
|
|
//
|
|
if (mAccessInfo.ConnectPermitLen > 0) {
|
|
Size = sizeof (EFI_USER_INFO_ACCESS_CONTROL) + mAccessInfo.ConnectPermitLen;
|
|
if (mUserInfo.AccessPolicyLen - OffSet < Size) {
|
|
ExpandMemory (OffSet, Size);
|
|
}
|
|
|
|
Control.Type = EFI_USER_INFO_ACCESS_PERMIT_CONNECT;
|
|
Control.Size = (UINT32) Size;
|
|
CopyMem (mUserInfo.AccessPolicy + OffSet, &Control, sizeof (Control));
|
|
OffSet += sizeof (Control);
|
|
|
|
CopyMem (mUserInfo.AccessPolicy + OffSet, mAccessInfo.ConnectPermit, mAccessInfo.ConnectPermitLen);
|
|
OffSet += mAccessInfo.ConnectPermitLen;
|
|
}
|
|
|
|
//
|
|
// Save forbid connect.
|
|
//
|
|
if (mAccessInfo.ConnectForbidLen > 0) {
|
|
Size = sizeof (EFI_USER_INFO_ACCESS_CONTROL) + mAccessInfo.ConnectForbidLen;
|
|
if (mUserInfo.AccessPolicyLen - OffSet < Size) {
|
|
ExpandMemory (OffSet, Size);
|
|
}
|
|
|
|
Control.Type = EFI_USER_INFO_ACCESS_FORBID_CONNECT;
|
|
Control.Size = (UINT32) Size;
|
|
CopyMem (mUserInfo.AccessPolicy + OffSet, &Control, sizeof (Control));
|
|
OffSet += sizeof (Control);
|
|
|
|
CopyMem (mUserInfo.AccessPolicy + OffSet, mAccessInfo.ConnectForbid, mAccessInfo.ConnectForbidLen);
|
|
OffSet += mAccessInfo.ConnectForbidLen;
|
|
}
|
|
|
|
mUserInfo.AccessPolicyLen = OffSet;
|
|
|
|
//
|
|
// Save access policy.
|
|
//
|
|
if (mUserInfo.AccessPolicyModified && (mUserInfo.AccessPolicyLen > 0)) {
|
|
Info = AllocateZeroPool (sizeof (EFI_USER_INFO) + mUserInfo.AccessPolicyLen);
|
|
if (Info == NULL) {
|
|
return ;
|
|
}
|
|
|
|
Status = FindInfoByType (EFI_USER_INFO_ACCESS_POLICY_RECORD, &UserInfo);
|
|
if (!EFI_ERROR (Status)) {
|
|
Info->InfoType = EFI_USER_INFO_ACCESS_POLICY_RECORD;
|
|
Info->InfoAttribs = EFI_USER_INFO_STORAGE_PLATFORM_NV |
|
|
EFI_USER_INFO_PUBLIC |
|
|
EFI_USER_INFO_EXCLUSIVE;
|
|
Info->InfoSize = (UINT32) (sizeof (EFI_USER_INFO) + mUserInfo.AccessPolicyLen);
|
|
CopyMem ((UINT8 *) (Info + 1), mUserInfo.AccessPolicy, mUserInfo.AccessPolicyLen);
|
|
Status = mUserManager->SetInfo (
|
|
mUserManager,
|
|
mModifyUser,
|
|
&UserInfo,
|
|
Info,
|
|
Info->InfoSize
|
|
);
|
|
mUserInfo.AccessPolicyModified = FALSE;
|
|
}
|
|
FreePool (Info);
|
|
}
|
|
|
|
if (mAccessInfo.ConnectForbid != NULL) {
|
|
FreePool (mAccessInfo.ConnectForbid);
|
|
mAccessInfo.ConnectForbid = NULL;
|
|
}
|
|
|
|
if (mAccessInfo.ConnectPermit != NULL) {
|
|
FreePool (mAccessInfo.ConnectPermit);
|
|
mAccessInfo.ConnectPermit = NULL;
|
|
}
|
|
|
|
if (mAccessInfo.LoadForbid != NULL) {
|
|
FreePool (mAccessInfo.LoadForbid);
|
|
mAccessInfo.LoadForbid = NULL;
|
|
}
|
|
|
|
if (mAccessInfo.LoadPermit != NULL) {
|
|
FreePool (mAccessInfo.LoadPermit);
|
|
mAccessInfo.LoadPermit = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
Get the username from user input, and update username string in the Hii
|
|
database with it.
|
|
|
|
**/
|
|
VOID
|
|
ModifyUserName (
|
|
VOID
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
CHAR16 UserName[USER_NAME_LENGTH];
|
|
UINTN Len;
|
|
EFI_INPUT_KEY Key;
|
|
EFI_USER_INFO_HANDLE UserInfo;
|
|
EFI_USER_INFO *Info;
|
|
EFI_USER_PROFILE_HANDLE TempUser;
|
|
|
|
//
|
|
// Get the new user name.
|
|
//
|
|
Len = sizeof (UserName);
|
|
Status = GetUserNameInput (&Len, UserName);
|
|
if (EFI_ERROR (Status)) {
|
|
if (Status != EFI_ABORTED) {
|
|
CreatePopUp (
|
|
EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
|
|
&Key,
|
|
L"Failed To Get User Name.",
|
|
L"",
|
|
L"Please Press Any Key to Continue ...",
|
|
NULL
|
|
);
|
|
}
|
|
return ;
|
|
}
|
|
|
|
//
|
|
// Check whether the username had been used or not.
|
|
//
|
|
Info = AllocateZeroPool (sizeof (EFI_USER_INFO) + Len);
|
|
if (Info == NULL) {
|
|
return ;
|
|
}
|
|
|
|
Info->InfoType = EFI_USER_INFO_NAME_RECORD;
|
|
Info->InfoAttribs = EFI_USER_INFO_STORAGE_PLATFORM_NV |
|
|
EFI_USER_INFO_PUBLIC |
|
|
EFI_USER_INFO_EXCLUSIVE;
|
|
Info->InfoSize = (UINT32) (sizeof (EFI_USER_INFO) + Len);
|
|
CopyMem ((UINT8 *) (Info + 1), UserName, Len);
|
|
|
|
TempUser = NULL;
|
|
Status = mUserManager->Find (
|
|
mUserManager,
|
|
&TempUser,
|
|
NULL,
|
|
Info,
|
|
Info->InfoSize
|
|
);
|
|
if (!EFI_ERROR (Status)) {
|
|
CreatePopUp (
|
|
EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
|
|
&Key,
|
|
L"The User Name Had Been Used.",
|
|
L"",
|
|
L"Please Use Other User Name",
|
|
NULL
|
|
);
|
|
FreePool (Info);
|
|
return ;
|
|
}
|
|
|
|
//
|
|
// Update username display in the form.
|
|
//
|
|
CopyMem (mUserInfo.UserName, UserName, Len);
|
|
HiiSetString (
|
|
mCallbackInfo->HiiHandle,
|
|
STRING_TOKEN (STR_USER_NAME_VAL),
|
|
mUserInfo.UserName,
|
|
NULL
|
|
);
|
|
|
|
//
|
|
// Save the user name.
|
|
//
|
|
Status = FindInfoByType (EFI_USER_INFO_NAME_RECORD, &UserInfo);
|
|
if (!EFI_ERROR (Status)) {
|
|
mUserManager->SetInfo (
|
|
mUserManager,
|
|
mModifyUser,
|
|
&UserInfo,
|
|
Info,
|
|
Info->InfoSize
|
|
);
|
|
}
|
|
FreePool (Info);
|
|
}
|
|
|
|
|
|
/**
|
|
Display the form of the modifying user identity policy.
|
|
|
|
**/
|
|
VOID
|
|
ModifyIdentityPolicy (
|
|
VOID
|
|
)
|
|
{
|
|
UINTN Index;
|
|
CHAR16 *ProvStr;
|
|
EFI_STRING_ID ProvID;
|
|
EFI_HII_HANDLE HiiHandle;
|
|
VOID *OptionsOpCodeHandle;
|
|
VOID *StartOpCodeHandle;
|
|
VOID *EndOpCodeHandle;
|
|
EFI_IFR_GUID_LABEL *StartLabel;
|
|
EFI_IFR_GUID_LABEL *EndLabel;
|
|
|
|
//
|
|
// Initialize the container for dynamic opcodes.
|
|
//
|
|
StartOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (StartOpCodeHandle != NULL);
|
|
|
|
EndOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (EndOpCodeHandle != NULL);
|
|
|
|
//
|
|
// Create Hii Extend Label OpCode.
|
|
//
|
|
StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
|
|
StartOpCodeHandle,
|
|
&gEfiIfrTianoGuid,
|
|
NULL,
|
|
sizeof (EFI_IFR_GUID_LABEL)
|
|
);
|
|
StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
|
|
StartLabel->Number = LABEL_IP_MOD_FUNC;
|
|
|
|
EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
|
|
EndOpCodeHandle,
|
|
&gEfiIfrTianoGuid,
|
|
NULL,
|
|
sizeof (EFI_IFR_GUID_LABEL)
|
|
);
|
|
EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
|
|
EndLabel->Number = LABEL_END;
|
|
|
|
//
|
|
// Add credential providers
|
|
//.
|
|
if (mProviderInfo->Count > 0) {
|
|
OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (OptionsOpCodeHandle != NULL);
|
|
|
|
//
|
|
// Add credential provider Option OpCode.
|
|
//
|
|
for (Index = 0; Index < mProviderInfo->Count; Index++) {
|
|
mProviderInfo->Provider[Index]->Title (
|
|
mProviderInfo->Provider[Index],
|
|
&HiiHandle,
|
|
&ProvID
|
|
);
|
|
ProvStr = HiiGetString (HiiHandle, ProvID, NULL);
|
|
ProvID = HiiSetString (mCallbackInfo->HiiHandle, 0, ProvStr, NULL);
|
|
FreePool (ProvStr);
|
|
if (ProvID == 0) {
|
|
return ;
|
|
}
|
|
|
|
HiiCreateOneOfOptionOpCode (
|
|
OptionsOpCodeHandle,
|
|
ProvID,
|
|
0,
|
|
EFI_IFR_NUMERIC_SIZE_1,
|
|
(UINT8) Index
|
|
);
|
|
}
|
|
|
|
HiiCreateOneOfOpCode (
|
|
StartOpCodeHandle, // Container for dynamic created opcodes
|
|
KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_IP | KEY_MODIFY_PROV, // Question ID
|
|
0, // VarStore ID
|
|
0, // Offset in Buffer Storage
|
|
STRING_TOKEN (STR_PROVIDER), // Question prompt text
|
|
STRING_TOKEN (STR_PROVIDER_HELP), // Question help text
|
|
EFI_IFR_FLAG_CALLBACK, // Question flag
|
|
EFI_IFR_NUMERIC_SIZE_1, // Data type of Question Value
|
|
OptionsOpCodeHandle, // Option Opcode list
|
|
NULL // Default Opcode is NULl
|
|
);
|
|
|
|
HiiFreeOpCodeHandle (OptionsOpCodeHandle);
|
|
}
|
|
|
|
//
|
|
// Add logical connector Option OpCode.
|
|
//
|
|
OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (OptionsOpCodeHandle != NULL);
|
|
|
|
HiiCreateOneOfOptionOpCode (
|
|
OptionsOpCodeHandle,
|
|
STRING_TOKEN (STR_AND_CON),
|
|
0,
|
|
EFI_IFR_NUMERIC_SIZE_1,
|
|
0
|
|
);
|
|
|
|
HiiCreateOneOfOptionOpCode (
|
|
OptionsOpCodeHandle,
|
|
STRING_TOKEN (STR_OR_CON),
|
|
0,
|
|
EFI_IFR_NUMERIC_SIZE_1,
|
|
1
|
|
);
|
|
|
|
HiiCreateOneOfOpCode (
|
|
StartOpCodeHandle, // Container for dynamic created opcodes
|
|
KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_IP | KEY_MODIFY_CONN, // Question ID
|
|
0, // VarStore ID
|
|
0, // Offset in Buffer Storage
|
|
STRING_TOKEN (STR_CONNECTOR), // Question prompt text
|
|
STRING_TOKEN (STR_CONNECTOR_HELP), // Question help text
|
|
EFI_IFR_FLAG_CALLBACK, // Question flag
|
|
EFI_IFR_NUMERIC_SIZE_1, // Data type of Question Value
|
|
OptionsOpCodeHandle, // Option Opcode list
|
|
NULL // Default Opcode is NULl
|
|
);
|
|
|
|
HiiFreeOpCodeHandle (OptionsOpCodeHandle);
|
|
|
|
//
|
|
// Update identity policy in the form.
|
|
//
|
|
ResolveIdentityPolicy (
|
|
mUserInfo.IdentityPolicy,
|
|
mUserInfo.IdentityPolicyLen,
|
|
STRING_TOKEN (STR_IDENTIFY_POLICY_VALUE)
|
|
);
|
|
|
|
if (mUserInfo.NewIdentityPolicy != NULL) {
|
|
FreePool (mUserInfo.NewIdentityPolicy);
|
|
mUserInfo.NewIdentityPolicy = NULL;
|
|
mUserInfo.NewIdentityPolicyLen = 0;
|
|
mUserInfo.NewIdentityPolicyModified = FALSE;
|
|
}
|
|
mProviderChoice = 0;
|
|
mConncetLogical = 0;
|
|
|
|
HiiUpdateForm (
|
|
mCallbackInfo->HiiHandle, // HII handle
|
|
&gUserProfileManagerGuid, // Formset GUID
|
|
FORMID_MODIFY_IP, // Form ID
|
|
StartOpCodeHandle, // Label for where to insert opcodes
|
|
EndOpCodeHandle // Replace data
|
|
);
|
|
|
|
HiiFreeOpCodeHandle (StartOpCodeHandle);
|
|
HiiFreeOpCodeHandle (EndOpCodeHandle);
|
|
}
|
|
|
|
|
|
/**
|
|
Save the identity policy and update UI with it.
|
|
|
|
This funciton will verify the new identity policy, in current implementation,
|
|
the identity policy can be: T, P & P & P & ..., P | P | P | ...
|
|
Here, "T" means "True", "P" means "Credential Provider", "&" means "and", "|" means "or".
|
|
Other identity policies are not supported.
|
|
|
|
**/
|
|
VOID
|
|
SaveIdentityPolicy (
|
|
VOID
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_USER_INFO_IDENTITY_POLICY *Identity;
|
|
EFI_USER_INFO_HANDLE UserInfo;
|
|
EFI_USER_INFO *Info;
|
|
EFI_INPUT_KEY Key;
|
|
UINTN Offset;
|
|
UINT32 OpCode;
|
|
UINTN InfoSize;
|
|
|
|
if (!mUserInfo.NewIdentityPolicyModified || (mUserInfo.NewIdentityPolicyLen == 0)) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Check policy expression.
|
|
//
|
|
OpCode = EFI_USER_INFO_IDENTITY_FALSE;
|
|
Offset = 0;
|
|
while (Offset < mUserInfo.NewIdentityPolicyLen) {
|
|
//
|
|
// Check access policy according to type
|
|
//
|
|
Identity = (EFI_USER_INFO_IDENTITY_POLICY *) (mUserInfo.NewIdentityPolicy + Offset);
|
|
switch (Identity->Type) {
|
|
|
|
case EFI_USER_INFO_IDENTITY_TRUE:
|
|
break;
|
|
|
|
case EFI_USER_INFO_IDENTITY_OR:
|
|
if (OpCode == EFI_USER_INFO_IDENTITY_AND) {
|
|
CreatePopUp (
|
|
EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
|
|
&Key,
|
|
L"Invalid Identity Policy, Mixed Connector Unsupport!",
|
|
L"",
|
|
L"Press Any Key to Continue ...",
|
|
NULL
|
|
);
|
|
return ;
|
|
}
|
|
|
|
OpCode = EFI_USER_INFO_IDENTITY_OR;
|
|
break;
|
|
|
|
case EFI_USER_INFO_IDENTITY_AND:
|
|
if (OpCode == EFI_USER_INFO_IDENTITY_OR) {
|
|
CreatePopUp (
|
|
EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
|
|
&Key,
|
|
L"Invalid Identity Policy, Mixed Connector Unsupport!",
|
|
L"",
|
|
L"Press Any Key to Continue ...",
|
|
NULL
|
|
);
|
|
return ;
|
|
}
|
|
|
|
OpCode = EFI_USER_INFO_IDENTITY_AND;
|
|
break;
|
|
|
|
case EFI_USER_INFO_IDENTITY_CREDENTIAL_PROVIDER:
|
|
break;
|
|
|
|
default:
|
|
CreatePopUp (
|
|
EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
|
|
&Key,
|
|
L"Unsupport parameter",
|
|
L"",
|
|
L"Press Any Key to Continue ...",
|
|
NULL
|
|
);
|
|
return ;
|
|
}
|
|
Offset += Identity->Length;
|
|
}
|
|
|
|
//
|
|
// Save identity policy.
|
|
//
|
|
Info = AllocateZeroPool (
|
|
sizeof (EFI_USER_INFO) +
|
|
mUserInfo.NewIdentityPolicyLen
|
|
);
|
|
if (Info == NULL) {
|
|
return ;
|
|
}
|
|
|
|
Status = FindInfoByType (EFI_USER_INFO_IDENTITY_POLICY_RECORD, &UserInfo);
|
|
if (EFI_ERROR (Status)) {
|
|
FreePool (Info);
|
|
return ;
|
|
}
|
|
|
|
Info->InfoType = EFI_USER_INFO_IDENTITY_POLICY_RECORD;
|
|
Info->InfoAttribs = EFI_USER_INFO_STORAGE_PLATFORM_NV |
|
|
EFI_USER_INFO_PRIVATE |
|
|
EFI_USER_INFO_EXCLUSIVE;
|
|
Info->InfoSize = (UINT32) (sizeof (EFI_USER_INFO) + mUserInfo.NewIdentityPolicyLen);
|
|
CopyMem ((UINT8 *) (Info + 1), mUserInfo.NewIdentityPolicy, mUserInfo.NewIdentityPolicyLen);
|
|
Status = mUserManager->SetInfo (
|
|
mUserManager,
|
|
mModifyUser,
|
|
&UserInfo,
|
|
Info,
|
|
Info->InfoSize
|
|
);
|
|
FreePool (Info);
|
|
if (EFI_ERROR (Status)) {
|
|
//
|
|
// Get the user information again, it may be changed during saving it.
|
|
//
|
|
InfoSize = 0;
|
|
Status = mUserManager->GetInfo (
|
|
mUserManager,
|
|
mModifyUser,
|
|
UserInfo,
|
|
Info,
|
|
&InfoSize
|
|
);
|
|
if (Status == EFI_BUFFER_TOO_SMALL) {
|
|
Info = AllocateZeroPool (InfoSize);
|
|
ASSERT (Info != NULL);
|
|
Status = mUserManager->GetInfo (
|
|
mUserManager,
|
|
mModifyUser,
|
|
UserInfo,
|
|
Info,
|
|
&InfoSize
|
|
);
|
|
}
|
|
ASSERT_EFI_ERROR (Status);
|
|
|
|
//
|
|
// Save current identification policy to mUserInfo.IdentityPolicy.
|
|
//
|
|
ASSERT (Info != NULL);
|
|
if (mUserInfo.IdentityPolicy != NULL) {
|
|
FreePool (mUserInfo.IdentityPolicy);
|
|
}
|
|
|
|
mUserInfo.IdentityPolicyLen = Info->InfoSize - sizeof (EFI_USER_INFO);
|
|
mUserInfo.IdentityPolicy = AllocateCopyPool (mUserInfo.IdentityPolicyLen, Info + 1);
|
|
ASSERT (mUserInfo.IdentityPolicy != NULL);
|
|
|
|
//
|
|
// Free the memory
|
|
//
|
|
FreePool (Info);
|
|
FreePool (mUserInfo.NewIdentityPolicy);
|
|
} else {
|
|
//
|
|
// Update the mUserInfo.IdentityPolicy by mUserInfo.NewIdentityPolicy
|
|
//
|
|
if (mUserInfo.IdentityPolicy != NULL) {
|
|
FreePool (mUserInfo.IdentityPolicy);
|
|
}
|
|
mUserInfo.IdentityPolicy = mUserInfo.NewIdentityPolicy;
|
|
mUserInfo.IdentityPolicyLen = mUserInfo.NewIdentityPolicyLen;
|
|
}
|
|
|
|
mUserInfo.NewIdentityPolicy = NULL;
|
|
mUserInfo.NewIdentityPolicyLen = 0;
|
|
mUserInfo.NewIdentityPolicyModified = FALSE;
|
|
|
|
//
|
|
// Update identity policy choice.
|
|
//
|
|
ResolveIdentityPolicy (
|
|
mUserInfo.IdentityPolicy,
|
|
mUserInfo.IdentityPolicyLen,
|
|
STRING_TOKEN (STR_IDENTIFY_POLICY_VAL)
|
|
);
|
|
}
|
|
|
|
|
|
/**
|
|
Verify the new identity policy in the current implementation. The same credential
|
|
provider can't appear twice in one identity policy.
|
|
|
|
@param[in] NewGuid Points to the credential provider guid.
|
|
|
|
@retval TRUE The NewGuid was found in the identity policy.
|
|
@retval FALSE The NewGuid was not found.
|
|
|
|
**/
|
|
BOOLEAN
|
|
CheckIdentityPolicy (
|
|
IN EFI_GUID *NewGuid
|
|
)
|
|
{
|
|
UINTN Offset;
|
|
EFI_USER_INFO_IDENTITY_POLICY *Identity;
|
|
EFI_INPUT_KEY Key;
|
|
|
|
Offset = 0;
|
|
while (Offset < mUserInfo.NewIdentityPolicyLen) {
|
|
//
|
|
// Check access policy according to type.
|
|
//
|
|
Identity = (EFI_USER_INFO_IDENTITY_POLICY *) (mUserInfo.NewIdentityPolicy + Offset);
|
|
switch (Identity->Type) {
|
|
|
|
case EFI_USER_INFO_IDENTITY_TRUE:
|
|
case EFI_USER_INFO_IDENTITY_OR:
|
|
case EFI_USER_INFO_IDENTITY_AND:
|
|
break;
|
|
|
|
case EFI_USER_INFO_IDENTITY_CREDENTIAL_PROVIDER:
|
|
if (CompareGuid (NewGuid, (EFI_GUID *) (Identity + 1))) {
|
|
CreatePopUp (
|
|
EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
|
|
&Key,
|
|
L"This Credential Provider Are Already Used!",
|
|
L"",
|
|
L"Press Any Key to Continue ...",
|
|
NULL
|
|
);
|
|
return FALSE;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
CreatePopUp (
|
|
EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
|
|
&Key,
|
|
L"Unsupport parameter",
|
|
L"",
|
|
L"Press Any Key to Continue ...",
|
|
NULL
|
|
);
|
|
return FALSE;
|
|
}
|
|
|
|
Offset += Identity->Length;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/**
|
|
Update the mUserInfo.NewIdentityPolicy, and UI when 'add option' is pressed.
|
|
|
|
**/
|
|
VOID
|
|
AddIdentityPolicyItem (
|
|
VOID
|
|
)
|
|
{
|
|
UINT8 *NewInfo;
|
|
EFI_USER_INFO_IDENTITY_POLICY *Policy;
|
|
|
|
if (mProviderInfo->Count == 0) {
|
|
return ;
|
|
}
|
|
|
|
if (!mUserInfo.NewIdentityPolicyModified && (mUserInfo.NewIdentityPolicyLen > 0)) {
|
|
FreePool (mUserInfo.NewIdentityPolicy);
|
|
mUserInfo.NewIdentityPolicy = NULL;
|
|
mUserInfo.NewIdentityPolicyLen = 0;
|
|
}
|
|
//
|
|
// Expand the identity policy memory for the newly added policy info.
|
|
//
|
|
if (mUserInfo.NewIdentityPolicyLen > 0) {
|
|
//
|
|
// The new policy is not empty, expand space for connetor and provider.
|
|
//
|
|
if (!CheckIdentityPolicy (&mProviderInfo->Provider[mProviderChoice]->Identifier)) {
|
|
return ;
|
|
}
|
|
NewInfo = AllocateZeroPool (
|
|
mUserInfo.NewIdentityPolicyLen +
|
|
sizeof (EFI_USER_INFO_IDENTITY_POLICY) * 2 +
|
|
sizeof (EFI_GUID)
|
|
);
|
|
} else {
|
|
//
|
|
// The new policy is empty, only expand space for provider.
|
|
//
|
|
NewInfo = AllocateZeroPool (
|
|
mUserInfo.NewIdentityPolicyLen +
|
|
sizeof (EFI_USER_INFO_IDENTITY_POLICY) +
|
|
sizeof (EFI_GUID)
|
|
);
|
|
}
|
|
|
|
if (NewInfo == NULL) {
|
|
return ;
|
|
}
|
|
|
|
if (mUserInfo.NewIdentityPolicyLen > 0) {
|
|
CopyMem (NewInfo, mUserInfo.NewIdentityPolicy, mUserInfo.NewIdentityPolicyLen);
|
|
FreePool (mUserInfo.NewIdentityPolicy);
|
|
}
|
|
mUserInfo.NewIdentityPolicy = NewInfo;
|
|
|
|
//
|
|
// Save logical connector.
|
|
//
|
|
if (mUserInfo.NewIdentityPolicyLen > 0) {
|
|
Policy = (EFI_USER_INFO_IDENTITY_POLICY *) (mUserInfo.NewIdentityPolicy +
|
|
mUserInfo.NewIdentityPolicyLen);
|
|
if (mConncetLogical == 0) {
|
|
Policy->Type = EFI_USER_INFO_IDENTITY_AND;
|
|
} else {
|
|
Policy->Type = EFI_USER_INFO_IDENTITY_OR;
|
|
}
|
|
|
|
Policy->Length = sizeof (EFI_USER_INFO_IDENTITY_POLICY);
|
|
mUserInfo.NewIdentityPolicyLen += Policy->Length;
|
|
}
|
|
|
|
//
|
|
// Save credential provider.
|
|
//
|
|
Policy = (EFI_USER_INFO_IDENTITY_POLICY *) (mUserInfo.NewIdentityPolicy +
|
|
mUserInfo.NewIdentityPolicyLen);
|
|
Policy->Length = sizeof (EFI_USER_INFO_IDENTITY_POLICY) + sizeof (EFI_GUID);
|
|
Policy->Type = EFI_USER_INFO_IDENTITY_CREDENTIAL_PROVIDER;
|
|
CopyGuid ((EFI_GUID *) (Policy + 1), &mProviderInfo->Provider[mProviderChoice]->Identifier);
|
|
mUserInfo.NewIdentityPolicyLen += Policy->Length;
|
|
|
|
//
|
|
// Update identity policy choice.
|
|
//
|
|
mUserInfo.NewIdentityPolicyModified = TRUE;
|
|
ResolveIdentityPolicy (
|
|
mUserInfo.NewIdentityPolicy,
|
|
mUserInfo.NewIdentityPolicyLen,
|
|
STRING_TOKEN (STR_IDENTIFY_POLICY_VALUE)
|
|
);
|
|
}
|
|
|
|
|
|
/**
|
|
Create an action OpCode with QuestionID and DevicePath on a given OpCodeHandle.
|
|
|
|
@param[in] QuestionID The question ID.
|
|
@param[in] DevicePath Points to device path.
|
|
@param[in] OpCodeHandle Points to container for dynamic created opcodes.
|
|
|
|
**/
|
|
VOID
|
|
AddDevicePath (
|
|
IN UINTN QuestionID,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
|
|
IN VOID *OpCodeHandle
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_DEVICE_PATH_PROTOCOL *Next;
|
|
EFI_STRING_ID NameID;
|
|
EFI_STRING DriverName;
|
|
EFI_DEVICE_PATH_TO_TEXT_PROTOCOL *DevicePathText;
|
|
|
|
//
|
|
// Locate device path to text protocol.
|
|
//
|
|
Status = gBS->LocateProtocol (
|
|
&gEfiDevicePathToTextProtocolGuid,
|
|
NULL,
|
|
(VOID **) &DevicePathText
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return ;
|
|
}
|
|
|
|
//
|
|
// Get driver file name node.
|
|
//
|
|
Next = DevicePath;
|
|
while (!IsDevicePathEnd (Next)) {
|
|
DevicePath = Next;
|
|
Next = NextDevicePathNode (Next);
|
|
}
|
|
|
|
//
|
|
// Display the device path in form.
|
|
//
|
|
DriverName = DevicePathText->ConvertDevicePathToText (DevicePath, FALSE, FALSE);
|
|
NameID = HiiSetString (mCallbackInfo->HiiHandle, 0, DriverName, NULL);
|
|
FreePool (DriverName);
|
|
if (NameID == 0) {
|
|
return ;
|
|
}
|
|
|
|
HiiCreateActionOpCode (
|
|
OpCodeHandle, // Container for dynamic created opcodes
|
|
(UINT16) QuestionID, // Question ID
|
|
NameID, // Prompt text
|
|
STRING_TOKEN (STR_NULL_STRING), // Help text
|
|
EFI_IFR_FLAG_CALLBACK, // Question flag
|
|
0 // Action String ID
|
|
);
|
|
}
|
|
|
|
|
|
/**
|
|
Check whether the DevicePath is in the device path forbid list
|
|
(mAccessInfo.LoadForbid).
|
|
|
|
@param[in] DevicePath Points to device path.
|
|
|
|
@retval TRUE The DevicePath is in the device path forbid list.
|
|
@retval FALSE The DevicePath is not in the device path forbid list.
|
|
|
|
**/
|
|
BOOLEAN
|
|
IsLoadForbidden (
|
|
IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
|
|
)
|
|
{
|
|
UINTN OffSet;
|
|
UINTN DPSize;
|
|
UINTN Size;
|
|
EFI_DEVICE_PATH_PROTOCOL *Dp;
|
|
|
|
OffSet = 0;
|
|
Size = GetDevicePathSize (DevicePath);
|
|
//
|
|
// Check each device path.
|
|
//
|
|
while (OffSet < mAccessInfo.LoadForbidLen) {
|
|
Dp = (EFI_DEVICE_PATH_PROTOCOL *) (mAccessInfo.LoadForbid + OffSet);
|
|
DPSize = GetDevicePathSize (Dp);
|
|
//
|
|
// Compare device path.
|
|
//
|
|
if ((DPSize == Size) && (CompareMem (DevicePath, Dp, Size) == 0)) {
|
|
return TRUE;
|
|
}
|
|
OffSet += DPSize;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/**
|
|
Display the permit load device path in the loadable device path list.
|
|
|
|
**/
|
|
VOID
|
|
DisplayLoadPermit(
|
|
VOID
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
CHAR16 *Order;
|
|
UINTN OrderSize;
|
|
UINTN ListCount;
|
|
UINTN Index;
|
|
UINT8 *Var;
|
|
UINT8 *VarPtr;
|
|
CHAR16 VarName[12];
|
|
VOID *StartOpCodeHandle;
|
|
VOID *EndOpCodeHandle;
|
|
EFI_IFR_GUID_LABEL *StartLabel;
|
|
EFI_IFR_GUID_LABEL *EndLabel;
|
|
|
|
//
|
|
// Get DriverOrder.
|
|
//
|
|
OrderSize = 0;
|
|
Status = gRT->GetVariable (
|
|
L"DriverOrder",
|
|
&gEfiGlobalVariableGuid,
|
|
NULL,
|
|
&OrderSize,
|
|
NULL
|
|
);
|
|
if (Status != EFI_BUFFER_TOO_SMALL) {
|
|
return ;
|
|
}
|
|
|
|
Order = AllocateZeroPool (OrderSize);
|
|
if (Order == NULL) {
|
|
return ;
|
|
}
|
|
|
|
Status = gRT->GetVariable (
|
|
L"DriverOrder",
|
|
&gEfiGlobalVariableGuid,
|
|
NULL,
|
|
&OrderSize,
|
|
Order
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return ;
|
|
}
|
|
|
|
//
|
|
// Initialize the container for dynamic opcodes.
|
|
//
|
|
StartOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (StartOpCodeHandle != NULL);
|
|
|
|
EndOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (EndOpCodeHandle != NULL);
|
|
|
|
//
|
|
// Create Hii Extend Label OpCode.
|
|
//
|
|
StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
|
|
StartOpCodeHandle,
|
|
&gEfiIfrTianoGuid,
|
|
NULL,
|
|
sizeof (EFI_IFR_GUID_LABEL)
|
|
);
|
|
StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
|
|
StartLabel->Number = LABEL_PERMIT_LOAD_FUNC;
|
|
|
|
EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
|
|
EndOpCodeHandle,
|
|
&gEfiIfrTianoGuid,
|
|
NULL,
|
|
sizeof (EFI_IFR_GUID_LABEL)
|
|
);
|
|
EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
|
|
EndLabel->Number = LABEL_END;
|
|
|
|
//
|
|
// Add each driver option.
|
|
//
|
|
Var = NULL;
|
|
ListCount = OrderSize / sizeof (UINT16);
|
|
for (Index = 0; Index < ListCount; Index++) {
|
|
//
|
|
// Get driver device path.
|
|
//
|
|
UnicodeSPrint (VarName, sizeof (VarName), L"Driver%04x", Order[Index]);
|
|
Var = GetEfiGlobalVariable (VarName);
|
|
if (Var == NULL) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Check whether the driver is already forbidden.
|
|
//
|
|
|
|
VarPtr = Var;
|
|
//
|
|
// Skip attribute.
|
|
//
|
|
VarPtr += sizeof (UINT32);
|
|
|
|
//
|
|
// Skip device path lenth.
|
|
//
|
|
VarPtr += sizeof (UINT16);
|
|
|
|
//
|
|
// Skip descript string.
|
|
//
|
|
VarPtr += StrSize ((UINT16 *) VarPtr);
|
|
|
|
if (IsLoadForbidden ((EFI_DEVICE_PATH_PROTOCOL *) VarPtr)) {
|
|
FreePool (Var);
|
|
Var = NULL;
|
|
continue;
|
|
}
|
|
|
|
AddDevicePath (
|
|
KEY_MODIFY_USER | KEY_MODIFY_AP_DP | KEY_LOAD_PERMIT_MODIFY | Order[Index],
|
|
(EFI_DEVICE_PATH_PROTOCOL *) VarPtr,
|
|
StartOpCodeHandle
|
|
);
|
|
FreePool (Var);
|
|
Var = NULL;
|
|
}
|
|
|
|
HiiUpdateForm (
|
|
mCallbackInfo->HiiHandle, // HII handle
|
|
&gUserProfileManagerGuid, // Formset GUID
|
|
FORMID_PERMIT_LOAD_DP, // Form ID
|
|
StartOpCodeHandle, // Label for where to insert opcodes
|
|
EndOpCodeHandle // Replace data
|
|
);
|
|
|
|
HiiFreeOpCodeHandle (StartOpCodeHandle);
|
|
HiiFreeOpCodeHandle (EndOpCodeHandle);
|
|
|
|
//
|
|
// Clear Environment.
|
|
//
|
|
if (Var != NULL) {
|
|
FreePool (Var);
|
|
}
|
|
FreePool (Order);
|
|
}
|
|
|
|
|
|
/**
|
|
Display the forbid load device path list (mAccessInfo.LoadForbid).
|
|
|
|
**/
|
|
VOID
|
|
DisplayLoadForbid (
|
|
VOID
|
|
)
|
|
{
|
|
UINTN Offset;
|
|
UINTN DPSize;
|
|
UINTN Index;
|
|
EFI_DEVICE_PATH_PROTOCOL *Dp;
|
|
VOID *StartOpCodeHandle;
|
|
VOID *EndOpCodeHandle;
|
|
EFI_IFR_GUID_LABEL *StartLabel;
|
|
EFI_IFR_GUID_LABEL *EndLabel;
|
|
|
|
//
|
|
// Initialize the container for dynamic opcodes.
|
|
//
|
|
StartOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (StartOpCodeHandle != NULL);
|
|
|
|
EndOpCodeHandle = HiiAllocateOpCodeHandle ();
|
|
ASSERT (EndOpCodeHandle != NULL);
|
|
|
|
//
|
|
// Create Hii Extend Label OpCode.
|
|
//
|
|
StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
|
|
StartOpCodeHandle,
|
|
&gEfiIfrTianoGuid,
|
|
NULL,
|
|
sizeof (EFI_IFR_GUID_LABEL)
|
|
);
|
|
StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
|
|
StartLabel->Number = LABLE_FORBID_LOAD_FUNC;
|
|
|
|
EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
|
|
EndOpCodeHandle,
|
|
&gEfiIfrTianoGuid,
|
|
NULL,
|
|
sizeof (EFI_IFR_GUID_LABEL)
|
|
);
|
|
EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
|
|
EndLabel->Number = LABEL_END;
|
|
|
|
//
|
|
// Add each forbid load drivers.
|
|
//
|
|
Offset = 0;
|
|
Index = 0;
|
|
while (Offset < mAccessInfo.LoadForbidLen) {
|
|
Dp = (EFI_DEVICE_PATH_PROTOCOL *) (mAccessInfo.LoadForbid + Offset);
|
|
DPSize = GetDevicePathSize (Dp);
|
|
AddDevicePath (
|
|
KEY_MODIFY_USER | KEY_MODIFY_AP_DP | KEY_LOAD_FORBID_MODIFY | Index,
|
|
Dp,
|
|
StartOpCodeHandle
|
|
);
|
|
Index++;
|
|
Offset += DPSize;
|
|
}
|
|
|
|
HiiUpdateForm (
|
|
mCallbackInfo->HiiHandle, // HII handle
|
|
&gUserProfileManagerGuid, // Formset GUID
|
|
FORMID_FORBID_LOAD_DP, // Form ID
|
|
StartOpCodeHandle, // Label for where to insert opcodes
|
|
EndOpCodeHandle // Replace data
|
|
);
|
|
|
|
HiiFreeOpCodeHandle (StartOpCodeHandle);
|
|
HiiFreeOpCodeHandle (EndOpCodeHandle);
|
|
}
|
|
|
|
|
|
/**
|
|
Display the permit connect device path.
|
|
|
|
**/
|
|
VOID
|
|
DisplayConnectPermit (
|
|
VOID
|
|
)
|
|
{
|
|
//
|
|
// Note:
|
|
// As no architect protocol/interface to be called in ConnectController()
|
|
// to verify the device path, just add a place holder for permitted connect
|
|
// device path.
|
|
//
|
|
}
|
|
|
|
|
|
/**
|
|
Display the forbid connect device path list.
|
|
|
|
**/
|
|
VOID
|
|
DisplayConnectForbid (
|
|
VOID
|
|
)
|
|
{
|
|
//
|
|
// Note:
|
|
// As no architect protocol/interface to be called in ConnectController()
|
|
// to verify the device path, just add a place holder for forbidden connect
|
|
// device path.
|
|
//
|
|
}
|
|
|
|
|
|
/**
|
|
Delete the specified device path by DriverIndex from the forbid device path
|
|
list (mAccessInfo.LoadForbid).
|
|
|
|
@param[in] DriverIndex The index of driver in forbidden device path list.
|
|
|
|
**/
|
|
VOID
|
|
DeleteFromForbidLoad (
|
|
IN UINT16 DriverIndex
|
|
)
|
|
{
|
|
UINTN OffSet;
|
|
UINTN DPSize;
|
|
UINTN OffLen;
|
|
EFI_DEVICE_PATH_PROTOCOL *Dp;
|
|
|
|
OffSet = 0;
|
|
//
|
|
// Find the specified device path.
|
|
//
|
|
while ((OffSet < mAccessInfo.LoadForbidLen) && (DriverIndex > 0)) {
|
|
Dp = (EFI_DEVICE_PATH_PROTOCOL *) (mAccessInfo.LoadForbid + OffSet);
|
|
DPSize = GetDevicePathSize (Dp);
|
|
OffSet += DPSize;
|
|
DriverIndex--;
|
|
}
|
|
|
|
//
|
|
// Specified device path found.
|
|
//
|
|
if (DriverIndex == 0) {
|
|
Dp = (EFI_DEVICE_PATH_PROTOCOL *) (mAccessInfo.LoadForbid + OffSet);
|
|
DPSize = GetDevicePathSize (Dp);
|
|
OffLen = mAccessInfo.LoadForbidLen - OffSet - DPSize;
|
|
if (OffLen > 0) {
|
|
CopyMem (
|
|
mAccessInfo.LoadForbid + OffSet,
|
|
mAccessInfo.LoadForbid + OffSet + DPSize,
|
|
OffLen
|
|
);
|
|
}
|
|
mAccessInfo.LoadForbidLen -= DPSize;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
Add the specified device path by DriverIndex to the forbid device path
|
|
list (mAccessInfo.LoadForbid).
|
|
|
|
@param[in] DriverIndex The index of driver saved in driver options.
|
|
|
|
**/
|
|
VOID
|
|
AddToForbidLoad (
|
|
IN UINT16 DriverIndex
|
|
)
|
|
{
|
|
UINTN DevicePathLen;
|
|
UINT8 *Var;
|
|
UINT8 *VarPtr;
|
|
UINTN NewLen;
|
|
UINT8 *NewFL;
|
|
CHAR16 VarName[13];
|
|
|
|
//
|
|
// Get loadable driver device path.
|
|
//
|
|
UnicodeSPrint (VarName, sizeof (VarName), L"Driver%04x", DriverIndex);
|
|
Var = GetEfiGlobalVariable (VarName);
|
|
if (Var == NULL) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Save forbid load driver.
|
|
//
|
|
|
|
VarPtr = Var;
|
|
//
|
|
// Skip attribute.
|
|
//
|
|
VarPtr += sizeof (UINT32);
|
|
|
|
DevicePathLen = *(UINT16 *) VarPtr;
|
|
//
|
|
// Skip device path length.
|
|
//
|
|
VarPtr += sizeof (UINT16);
|
|
|
|
//
|
|
// Skip description string.
|
|
//
|
|
VarPtr += StrSize ((UINT16 *) VarPtr);
|
|
|
|
NewLen = mAccessInfo.LoadForbidLen + DevicePathLen;
|
|
NewFL = AllocateZeroPool (NewLen);
|
|
if (NewFL == NULL) {
|
|
FreePool (Var);
|
|
return ;
|
|
}
|
|
|
|
if (mAccessInfo.LoadForbidLen > 0) {
|
|
CopyMem (NewFL, mAccessInfo.LoadForbid, mAccessInfo.LoadForbidLen);
|
|
FreePool (mAccessInfo.LoadForbid);
|
|
}
|
|
|
|
CopyMem (NewFL + mAccessInfo.LoadForbidLen, VarPtr, DevicePathLen);
|
|
mAccessInfo.LoadForbidLen = NewLen;
|
|
mAccessInfo.LoadForbid = NewFL;
|
|
FreePool (Var);
|
|
}
|
|
|
|
|
|
/**
|
|
Get current user's access right.
|
|
|
|
@param[out] AccessRight Points to the buffer used for user's access right.
|
|
|
|
@retval EFI_SUCCESS Get current user access right successfully.
|
|
@retval others Fail to get current user access right.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
GetAccessRight (
|
|
OUT UINT32 *AccessRight
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_USER_INFO_HANDLE UserInfo;
|
|
EFI_USER_INFO *Info;
|
|
UINTN InfoSize;
|
|
UINTN MemSize;
|
|
EFI_USER_INFO_ACCESS_CONTROL Access;
|
|
EFI_USER_PROFILE_HANDLE CurrentUser;
|
|
UINTN TotalLen;
|
|
UINTN CheckLen;
|
|
|
|
//
|
|
// Allocate user information memory.
|
|
//
|
|
MemSize = sizeof (EFI_USER_INFO) + 63;
|
|
Info = AllocateZeroPool (MemSize);
|
|
if (Info == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
//
|
|
// Get user access information.
|
|
//
|
|
UserInfo = NULL;
|
|
mUserManager->Current (mUserManager, &CurrentUser);
|
|
while (TRUE) {
|
|
InfoSize = MemSize;
|
|
//
|
|
// Get next user information.
|
|
//
|
|
Status = mUserManager->GetNextInfo (mUserManager, CurrentUser, &UserInfo);
|
|
if (EFI_ERROR (Status)) {
|
|
break;
|
|
}
|
|
|
|
Status = mUserManager->GetInfo (
|
|
mUserManager,
|
|
CurrentUser,
|
|
UserInfo,
|
|
Info,
|
|
&InfoSize
|
|
);
|
|
if (Status == EFI_BUFFER_TOO_SMALL) {
|
|
MemSize = InfoSize;
|
|
FreePool (Info);
|
|
Info = AllocateZeroPool (MemSize);
|
|
if (Info == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
Status = mUserManager->GetInfo (
|
|
mUserManager,
|
|
CurrentUser,
|
|
UserInfo,
|
|
Info,
|
|
&InfoSize
|
|
);
|
|
}
|
|
if (EFI_ERROR (Status)) {
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Check user information.
|
|
//
|
|
if (Info->InfoType == EFI_USER_INFO_ACCESS_POLICY_RECORD) {
|
|
TotalLen = Info->InfoSize - sizeof (EFI_USER_INFO);
|
|
CheckLen = 0;
|
|
//
|
|
// Get specified access information.
|
|
//
|
|
while (CheckLen < TotalLen) {
|
|
CopyMem (&Access, (UINT8 *) (Info + 1) + CheckLen, sizeof (Access));
|
|
if ((Access.Type == EFI_USER_INFO_ACCESS_ENROLL_SELF) ||
|
|
(Access.Type == EFI_USER_INFO_ACCESS_ENROLL_OTHERS) ||
|
|
(Access.Type == EFI_USER_INFO_ACCESS_MANAGE)
|
|
) {
|
|
*AccessRight = Access.Type;
|
|
FreePool (Info);
|
|
return EFI_SUCCESS;
|
|
}
|
|
CheckLen += Access.Size;
|
|
}
|
|
}
|
|
}
|
|
FreePool (Info);
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
|
|
|