SecurityPkg/UserIdentification/UserProfileManagerDxe/UserProfileModify.c

   1 /** @file
   2   The functions to modify a user profile.
   3
   4 Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "UserProfileManager.h"
  16
  17 EFI_USER_PROFILE_HANDLE           mModifyUser = NULL;
  18
  19 /**
  20   Display user select form, cab select a user to modify.
  21
  22 **/
  23 VOID
  24 SelectUserToModify  (
  25   VOID
  26   )
  27 {
  28   EFI_STATUS              Status;
  29   UINT8                   Index;
  30   EFI_USER_PROFILE_HANDLE User;
  31   EFI_USER_PROFILE_HANDLE CurrentUser;
  32   UINT32                  CurrentAccessRight;
  33   VOID                    *StartOpCodeHandle;
  34   VOID                    *EndOpCodeHandle;
  35   EFI_IFR_GUID_LABEL      *StartLabel;
  36   EFI_IFR_GUID_LABEL      *EndLabel;
  37
  38   //
  39   // Initialize the container for dynamic opcodes.
  40   //
  41   StartOpCodeHandle = HiiAllocateOpCodeHandle ();
  42   ASSERT (StartOpCodeHandle != NULL);
  43
  44   EndOpCodeHandle = HiiAllocateOpCodeHandle ();
  45   ASSERT (EndOpCodeHandle != NULL);
  46
  47   //
  48   // Create Hii Extend Label OpCode.
  49   //
  50   StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
  51                                         StartOpCodeHandle,
  52                                         &gEfiIfrTianoGuid,
  53                                         NULL,
  54                                         sizeof (EFI_IFR_GUID_LABEL)
  55                                         );
  56   StartLabel->ExtendOpCode  = EFI_IFR_EXTEND_OP_LABEL;
  57   StartLabel->Number        = LABEL_USER_MOD_FUNC;
  58
  59   EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
  60                                       EndOpCodeHandle,
  61                                       &gEfiIfrTianoGuid,
  62                                       NULL,
  63                                       sizeof (EFI_IFR_GUID_LABEL)
  64                                       );
  65   EndLabel->ExtendOpCode  = EFI_IFR_EXTEND_OP_LABEL;
  66   EndLabel->Number        = LABEL_END;
  67
  68   //
  69   // Add each user can be modified.
  70   //
  71   User  = NULL;
  72   Index = 1;
  73   mUserManager->Current (mUserManager, &CurrentUser);
  74   while (TRUE) {
  75     Status = mUserManager->GetNext (mUserManager, &User);
  76     if (EFI_ERROR (Status)) {
  77       break;
  78     }
  79
  80     Status = GetAccessRight (&CurrentAccessRight);
  81     if (EFI_ERROR (Status)) {
  82       CurrentAccessRight = EFI_USER_INFO_ACCESS_ENROLL_SELF;
  83     }
  84
  85     if ((CurrentAccessRight == EFI_USER_INFO_ACCESS_MANAGE) || (User == CurrentUser)) {
  86       AddUserToForm (User, (UINT16)(KEY_MODIFY_USER | KEY_SELECT_USER | Index), StartOpCodeHandle);
  87     }
  88     Index++;
  89   }
  90
  91   HiiUpdateForm (
  92     mCallbackInfo->HiiHandle, // HII handle
  93     &gUserProfileManagerGuid, // Formset GUID
  94     FORMID_MODIFY_USER,       // Form ID
  95     StartOpCodeHandle,        // Label for where to insert opcodes
  96     EndOpCodeHandle           // Replace data
  97     );
  98
  99   HiiFreeOpCodeHandle (StartOpCodeHandle);
 100   HiiFreeOpCodeHandle (EndOpCodeHandle);
 101 }
 102
 103
 104 /**
 105   Get all the user info from mModifyUser in the user manager, and save on the
 106   global variable.
 107
 108 **/
 109 VOID
 110 GetAllUserInfo (
 111   VOID
 112   )
 113 {
 114   EFI_STATUS            Status;
 115   EFI_USER_INFO_HANDLE  UserInfo;
 116   EFI_USER_INFO         *Info;
 117   UINTN                 InfoSize;
 118   UINTN                 MemSize;
 119   UINTN                 DataLen;
 120
 121   //
 122   // Init variable to default value.
 123   //
 124   mProviderChoice                   = 0;
 125   mConncetLogical                   = 0;
 126
 127   mUserInfo.CreateDateExist         = FALSE;
 128   mUserInfo.UsageDateExist          = FALSE;
 129   mUserInfo.UsageCount              = 0;
 130
 131   mUserInfo.AccessPolicyLen         = 0;
 132   mUserInfo.AccessPolicyModified    = FALSE;
 133   if (mUserInfo.AccessPolicy != NULL) {
 134     FreePool (mUserInfo.AccessPolicy);
 135     mUserInfo.AccessPolicy = NULL;
 136   }
 137   mUserInfo.IdentityPolicyLen       = 0;
 138   mUserInfo.IdentityPolicyModified  = FALSE;
 139   if (mUserInfo.IdentityPolicy != NULL) {
 140     FreePool (mUserInfo.IdentityPolicy);
 141     mUserInfo.IdentityPolicy = NULL;
 142   }
 143
 144   //
 145   // Allocate user information memory.
 146   //
 147   MemSize = sizeof (EFI_USER_INFO) + 63;
 148   Info    = AllocateZeroPool (MemSize);
 149   if (Info == NULL) {
 150     return ;
 151   }
 152
 153   //
 154   // Get each user information.
 155   //
 156   UserInfo = NULL;
 157   while (TRUE) {
 158     Status = mUserManager->GetNextInfo (mUserManager, mModifyUser, &UserInfo);
 159     if (EFI_ERROR (Status)) {
 160       break;
 161     }
 162     //
 163     // Get information.
 164     //
 165     InfoSize  = MemSize;
 166     Status    = mUserManager->GetInfo (
 167                                 mUserManager,
 168                                 mModifyUser,
 169                                 UserInfo,
 170                                 Info,
 171                                 &InfoSize
 172                                 );
 173     if (Status == EFI_BUFFER_TOO_SMALL) {
 174       MemSize = InfoSize;
 175       FreePool (Info);
 176       Info = AllocateZeroPool (MemSize);
 177       if (Info == NULL) {
 178         return ;
 179       }
 180
 181       Status = mUserManager->GetInfo (
 182                                mUserManager,
 183                                mModifyUser,
 184                                UserInfo,
 185                                Info,
 186                                &InfoSize
 187                                );
 188     }
 189
 190     if (Status == EFI_SUCCESS) {
 191       //
 192       // Deal with each information according to informaiton type.
 193       //
 194       DataLen = Info->InfoSize - sizeof (EFI_USER_INFO);
 195       switch (Info->InfoType) {
 196       case EFI_USER_INFO_NAME_RECORD:
 197         CopyMem (&mUserInfo.UserName, (UINT8 *) (Info + 1), DataLen);
 198         break;
 199
 200       case EFI_USER_INFO_CREATE_DATE_RECORD:
 201         CopyMem (&mUserInfo.CreateDate, (UINT8 *) (Info + 1), DataLen);
 202         mUserInfo.CreateDateExist = TRUE;
 203         break;
 204
 205       case EFI_USER_INFO_USAGE_DATE_RECORD:
 206         CopyMem (&mUserInfo.UsageDate, (UINT8 *) (Info + 1), DataLen);
 207         mUserInfo.UsageDateExist = TRUE;
 208         break;
 209
 210       case EFI_USER_INFO_USAGE_COUNT_RECORD:
 211         CopyMem (&mUserInfo.UsageCount, (UINT8 *) (Info + 1), DataLen);
 212         break;
 213
 214       case EFI_USER_INFO_ACCESS_POLICY_RECORD:
 215         mUserInfo.AccessPolicy = AllocateZeroPool (DataLen);
 216         if (mUserInfo.AccessPolicy == NULL) {
 217           break;
 218         }
 219
 220         CopyMem (mUserInfo.AccessPolicy, (UINT8 *) (Info + 1), DataLen);
 221         mUserInfo.AccessPolicyLen = DataLen;
 222         break;
 223
 224       case EFI_USER_INFO_IDENTITY_POLICY_RECORD:
 225         mUserInfo.IdentityPolicy = AllocateZeroPool (DataLen);
 226         if (mUserInfo.IdentityPolicy == NULL) {
 227           break;
 228         }
 229
 230         CopyMem (mUserInfo.IdentityPolicy, (UINT8 *) (Info + 1), DataLen);
 231         mUserInfo.IdentityPolicyLen = DataLen;
 232         break;
 233
 234       default:
 235         break;
 236       }
 237     }
 238   }
 239   FreePool (Info);
 240 }
 241
 242
 243 /**
 244   Convert the Date to a string, and update the Hii database DateID string with it.
 245
 246   @param[in] Date       Points to the date to be converted.
 247   @param[in] DateId     String ID in the HII database to be replaced.
 248
 249 **/
 250 VOID
 251 ResolveDate (
 252   IN EFI_TIME                                   *Date,
 253   IN EFI_STRING_ID                              DateId
 254   )
 255 {
 256   CHAR16  *Str;
 257   UINTN   DateBufLen;
 258
 259   //
 260   // Convert date to string.
 261   //
 262   DateBufLen = 64;
 263   Str        = AllocateZeroPool (DateBufLen);
 264   if (Str == NULL) {
 265     return ;
 266   }
 267
 268   UnicodeSPrint (
 269     Str,
 270     DateBufLen,
 271     L"%4d-%2d-%2d ",
 272     Date->Year,
 273     Date->Month,
 274     Date->Day
 275     );
 276
 277   //
 278   // Convert time to string.
 279   //
 280   DateBufLen -= StrLen (Str);
 281   UnicodeSPrint (
 282     Str + StrLen (Str),
 283     DateBufLen,
 284     L"%2d:%2d:%2d",
 285     Date->Hour,
 286     Date->Minute,
 287     Date->Second
 288     );
 289
 290   HiiSetString (mCallbackInfo->HiiHandle, DateId, Str, NULL);
 291   FreePool (Str);
 292 }
 293
 294
 295 /**
 296   Convert the CountVal to a string, and update the Hii database CountId string
 297   with it.
 298
 299   @param[in]  CountVal   The hex value to convert.
 300   @param[in]  CountId    String ID in the HII database to be replaced.
 301
 302 **/
 303 VOID
 304 ResolveCount (
 305   IN UINT32                                     CountVal,
 306   IN EFI_STRING_ID                              CountId
 307   )
 308 {
 309   CHAR16  Count[10];
 310
 311   UnicodeSPrint (Count, 20, L"%d", CountVal);
 312   HiiSetString (mCallbackInfo->HiiHandle, CountId, Count, NULL);
 313 }
 314
 315
 316 /**
 317   Concatenates one Null-terminated Unicode string to another Null-terminated
 318   Unicode string.
 319
 320   @param[in, out]  Source1      On entry, point to a Null-terminated Unicode string.
 321                                 On exit, point to a new concatenated Unicode string
 322   @param[in]       Source2      Pointer to a Null-terminated Unicode string.
 323
 324 **/
 325 VOID
 326 AddStr (
 327   IN OUT  CHAR16                  **Source1,
 328   IN      CONST CHAR16            *Source2
 329   )
 330 {
 331   CHAR16                        *TmpStr;
 332   UINTN                         StrLength;
 333
 334   ASSERT (Source1 != NULL);
 335   ASSERT (Source2 != NULL);
 336
 337   if (*Source1 == NULL) {
 338     StrLength = StrSize (Source2);
 339   } else {
 340     StrLength  = StrSize (*Source1);
 341     StrLength += StrSize (Source2) -1;
 342   }
 343
 344   TmpStr     = AllocateZeroPool (StrLength);
 345   ASSERT (TmpStr != NULL);
 346
 347   if (*Source1 == NULL) {
 348     StrCpy (TmpStr, Source2);;
 349   } else {
 350     StrCpy (TmpStr, *Source1);
 351     FreePool (*Source1);
 352     StrCat (TmpStr, Source2);
 353   }
 354
 355   *Source1 = TmpStr;
 356 }
 357
 358
 359 /**
 360   Convert the identity policy to a unicode string and update the Hii database
 361   IpStringId string with it.
 362
 363   @param[in]  Ip         Points to identity policy.
 364   @param[in]  IpLen      The identity policy length.
 365   @param[in]  IpStringId String ID in the HII database to be replaced.
 366
 367 **/
 368 VOID
 369 ResolveIdentityPolicy (
 370   IN  UINT8                                     *Ip,
 371   IN  UINTN                                     IpLen,
 372   IN  EFI_STRING_ID                             IpStringId
 373   )
 374 {
 375   CHAR16                        *TmpStr;
 376   UINTN                         ChkLen;
 377   EFI_USER_INFO_IDENTITY_POLICY *Identity;
 378   UINT16                        Index;
 379   CHAR16                        *ProvStr;
 380   EFI_STRING_ID                 ProvId;
 381   EFI_HII_HANDLE                HiiHandle;
 382   EFI_USER_CREDENTIAL2_PROTOCOL *UserCredential;
 383
 384   TmpStr = NULL;
 385
 386   //
 387   // Resolve each policy.
 388   //
 389   ChkLen  = 0;
 390   while (ChkLen < IpLen) {
 391     Identity = (EFI_USER_INFO_IDENTITY_POLICY *) (Ip + ChkLen);
 392     switch (Identity->Type) {
 393     case EFI_USER_INFO_IDENTITY_FALSE:
 394       AddStr (&TmpStr, L"False");
 395       break;
 396
 397     case EFI_USER_INFO_IDENTITY_TRUE:
 398       AddStr (&TmpStr, L"None");
 399       break;
 400
 401     case EFI_USER_INFO_IDENTITY_NOT:
 402       AddStr (&TmpStr, L"! ");
 403       break;
 404
 405     case EFI_USER_INFO_IDENTITY_AND:
 406       AddStr (&TmpStr, L" && ");
 407       break;
 408
 409     case EFI_USER_INFO_IDENTITY_OR:
 410       AddStr (&TmpStr, L" || ");
 411       break;
 412
 413     case EFI_USER_INFO_IDENTITY_CREDENTIAL_TYPE:
 414       for (Index = 0; Index < mProviderInfo->Count; Index++) {
 415         UserCredential = mProviderInfo->Provider[Index];
 416         if (CompareGuid ((EFI_GUID *) (Identity + 1), &UserCredential->Type)) {
 417           UserCredential->Title (
 418                             UserCredential,
 419                             &HiiHandle,
 420                             &ProvId
 421                             );
 422           ProvStr = HiiGetString (HiiHandle, ProvId, NULL);
 423           if (ProvStr != NULL) {
 424             AddStr (&TmpStr, ProvStr);
 425             FreePool (ProvStr);
 426           }
 427           break;
 428         }
 429       }
 430       break;
 431
 432     case EFI_USER_INFO_IDENTITY_CREDENTIAL_PROVIDER:
 433       for (Index = 0; Index < mProviderInfo->Count; Index++) {
 434         UserCredential = mProviderInfo->Provider[Index];
 435         if (CompareGuid ((EFI_GUID *) (Identity + 1), &UserCredential->Identifier)) {
 436           UserCredential->Title (
 437                             UserCredential,
 438                             &HiiHandle,
 439                             &ProvId
 440                             );
 441           ProvStr = HiiGetString (HiiHandle, ProvId, NULL);
 442           if (ProvStr != NULL) {
 443             AddStr (&TmpStr, ProvStr);
 444             FreePool (ProvStr);
 445           }
 446           break;
 447         }
 448       }
 449       break;
 450     }
 451
 452     ChkLen += Identity->Length;
 453   }
 454
 455   if (TmpStr != NULL) {
 456     HiiSetString (mCallbackInfo->HiiHandle, IpStringId, TmpStr, NULL);
 457     FreePool (TmpStr);
 458   }
 459 }
 460
 461
 462 /**
 463   Display modify user information form.
 464
 465   This form displays, username, create Date, usage date, usage count, identity policy,
 466   and access policy.
 467
 468   @param[in] UserIndex       The index of the user in display list to modify.
 469
 470 **/
 471 VOID
 472 ModifyUserInfo (
 473   IN UINT8                                      UserIndex
 474   )
 475 {
 476   EFI_STATUS               Status;
 477   EFI_USER_PROFILE_HANDLE  CurrentUser;
 478   UINT32                   CurrentAccessRight;
 479   VOID                     *StartOpCodeHandle;
 480   VOID                     *EndOpCodeHandle;
 481   EFI_IFR_GUID_LABEL       *StartLabel;
 482   EFI_IFR_GUID_LABEL       *EndLabel;
 483
 484   //
 485   // Initialize the container for dynamic opcodes.
 486   //
 487   StartOpCodeHandle = HiiAllocateOpCodeHandle ();
 488   ASSERT (StartOpCodeHandle != NULL);
 489
 490   EndOpCodeHandle = HiiAllocateOpCodeHandle ();
 491   ASSERT (EndOpCodeHandle != NULL);
 492
 493   //
 494   // Create Hii Extend Label OpCode.
 495   //
 496   StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
 497                                         StartOpCodeHandle,
 498                                         &gEfiIfrTianoGuid,
 499                                         NULL,
 500                                         sizeof (EFI_IFR_GUID_LABEL)
 501                                         );
 502   StartLabel->ExtendOpCode  = EFI_IFR_EXTEND_OP_LABEL;
 503   StartLabel->Number        = LABEL_USER_INFO_FUNC;
 504
 505   EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
 506                                       EndOpCodeHandle,
 507                                       &gEfiIfrTianoGuid,
 508                                       NULL,
 509                                       sizeof (EFI_IFR_GUID_LABEL)
 510                                       );
 511   EndLabel->ExtendOpCode  = EFI_IFR_EXTEND_OP_LABEL;
 512   EndLabel->Number        = LABEL_END;
 513
 514   //
 515   // Find the user profile to be modified.
 516   //
 517   mModifyUser = NULL;
 518   Status      = mUserManager->GetNext (mUserManager, &mModifyUser);
 519   if (EFI_ERROR (Status)) {
 520     return ;
 521   }
 522
 523   while (UserIndex > 1) {
 524     Status = mUserManager->GetNext (mUserManager, &mModifyUser);
 525     if (EFI_ERROR (Status)) {
 526       return ;
 527     }
 528     UserIndex--;
 529   }
 530
 531   //
 532   // Get user profile information.
 533   //
 534   GetAllUserInfo ();
 535
 536   //
 537   // Update user name.
 538   HiiSetString (
 539     mCallbackInfo->HiiHandle,
 540     STRING_TOKEN (STR_USER_NAME_VAL),
 541     mUserInfo.UserName,
 542     NULL
 543     );
 544
 545   //
 546   // Update create date.
 547   //
 548   if (mUserInfo.CreateDateExist) {
 549     ResolveDate (&mUserInfo.CreateDate, STRING_TOKEN (STR_CREATE_DATE_VAL));
 550   } else {
 551     HiiSetString (
 552       mCallbackInfo->HiiHandle,
 553       STRING_TOKEN (STR_CREATE_DATE_VAL),
 554       L"",
 555       NULL
 556       );
 557   }
 558
 559   //
 560   // Add usage date.
 561   //
 562   if (mUserInfo.UsageDateExist) {
 563     ResolveDate (&mUserInfo.UsageDate, STRING_TOKEN (STR_USAGE_DATE_VAL));
 564   } else {
 565     HiiSetString (
 566       mCallbackInfo->HiiHandle,
 567       STRING_TOKEN (STR_USAGE_DATE_VAL),
 568       L"",
 569       NULL
 570       );
 571   }
 572
 573   //
 574   // Add usage count.
 575   //
 576   ResolveCount ((UINT32) mUserInfo.UsageCount, STRING_TOKEN (STR_USAGE_COUNT_VAL));
 577
 578   //
 579   // Add identity policy.
 580   //
 581   mUserManager->Current (mUserManager, &CurrentUser);
 582   if (mModifyUser == CurrentUser) {
 583     ResolveIdentityPolicy (
 584       mUserInfo.IdentityPolicy,
 585       mUserInfo.IdentityPolicyLen,
 586       STRING_TOKEN (STR_IDENTIFY_POLICY_VAL)
 587       );
 588     HiiCreateGotoOpCode (
 589       StartOpCodeHandle,                                  // Container for opcodes
 590       FORMID_MODIFY_IP,                                   // Target Form ID
 591       STRING_TOKEN (STR_IDENTIFY_POLICY),                 // Prompt text
 592       STRING_TOKEN (STR_IDENTIFY_POLICY_VAL),             // Help text
 593       EFI_IFR_FLAG_CALLBACK,                              // Question flag
 594       KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_IP   // Question ID
 595       );
 596   }
 597
 598   //
 599   // Add access policy.
 600   //
 601   Status = GetAccessRight (&CurrentAccessRight);
 602   if (EFI_ERROR (Status)) {
 603     CurrentAccessRight = EFI_USER_INFO_ACCESS_ENROLL_SELF;
 604   }
 605
 606   if (CurrentAccessRight == EFI_USER_INFO_ACCESS_MANAGE) {
 607     HiiCreateGotoOpCode (
 608       StartOpCodeHandle,                                  // Container for opcodes
 609       FORMID_MODIFY_AP,                                   // Target Form ID
 610       STRING_TOKEN (STR_ACCESS_POLICY),                   // Prompt text
 611       STRING_TOKEN (STR_NULL_STRING),                     // Help text
 612       EFI_IFR_FLAG_CALLBACK,                              // Question flag
 613       KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_AP   // Question ID
 614       );
 615   }
 616
 617   HiiUpdateForm (
 618     mCallbackInfo->HiiHandle,                             // HII handle
 619     &gUserProfileManagerGuid,                             // Formset GUID
 620     FORMID_USER_INFO,                                     // Form ID
 621     StartOpCodeHandle,                                    // Label
 622     EndOpCodeHandle                                       // Replace data
 623     );
 624
 625   HiiFreeOpCodeHandle (StartOpCodeHandle);
 626   HiiFreeOpCodeHandle (EndOpCodeHandle);
 627 }
 628
 629
 630 /**
 631   Get all the access policy info from current user info, and save in the global
 632   variable.
 633
 634 **/
 635 VOID
 636 ResolveAccessPolicy (
 637   VOID
 638   )
 639 {
 640   UINTN                         OffSet;
 641   EFI_USER_INFO_ACCESS_CONTROL  Control;
 642   UINTN                         ValLen;
 643   UINT8                         *AccessData;
 644
 645   //
 646   // Set default value
 647   //
 648   mAccessInfo.AccessRight       = EFI_USER_INFO_ACCESS_ENROLL_SELF;
 649   mAccessInfo.AccessSetup       = ACCESS_SETUP_RESTRICTED;
 650   mAccessInfo.AccessBootOrder   = EFI_USER_INFO_ACCESS_BOOT_ORDER_INSERT;
 651
 652   mAccessInfo.LoadPermitLen     = 0;
 653   mAccessInfo.LoadForbidLen     = 0;
 654   mAccessInfo.ConnectPermitLen  = 0;
 655   mAccessInfo.ConnectForbidLen  = 0;
 656
 657   //
 658   // Get each user access policy.
 659   //
 660   OffSet = 0;
 661   while (OffSet < mUserInfo.AccessPolicyLen) {
 662     CopyMem (&Control, mUserInfo.AccessPolicy + OffSet, sizeof (Control));
 663     ValLen = Control.Size - sizeof (Control);
 664     switch (Control.Type) {
 665     case EFI_USER_INFO_ACCESS_ENROLL_SELF:
 666       mAccessInfo.AccessRight = EFI_USER_INFO_ACCESS_ENROLL_SELF;
 667       break;
 668
 669     case EFI_USER_INFO_ACCESS_ENROLL_OTHERS:
 670       mAccessInfo.AccessRight = EFI_USER_INFO_ACCESS_ENROLL_OTHERS;
 671       break;
 672
 673     case EFI_USER_INFO_ACCESS_MANAGE:
 674       mAccessInfo.AccessRight = EFI_USER_INFO_ACCESS_MANAGE;
 675       break;
 676
 677     case EFI_USER_INFO_ACCESS_SETUP:
 678       AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);
 679       if (CompareGuid ((EFI_GUID *) AccessData, &gEfiUserInfoAccessSetupNormalGuid)) {
 680         mAccessInfo.AccessSetup = ACCESS_SETUP_NORMAL;
 681       } else if (CompareGuid ((EFI_GUID *) AccessData, &gEfiUserInfoAccessSetupRestrictedGuid)) {
 682         mAccessInfo.AccessSetup = ACCESS_SETUP_RESTRICTED;
 683       } else if (CompareGuid ((EFI_GUID *) AccessData, &gEfiUserInfoAccessSetupAdminGuid)) {
 684         mAccessInfo.AccessSetup = ACCESS_SETUP_ADMIN;
 685       }
 686       break;
 687
 688     case EFI_USER_INFO_ACCESS_BOOT_ORDER:
 689       AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);
 690       CopyMem (&mAccessInfo.AccessBootOrder, AccessData, sizeof (UINT32));
 691       break;
 692
 693     case EFI_USER_INFO_ACCESS_FORBID_LOAD:
 694       if (mAccessInfo.LoadForbid != NULL) {
 695         FreePool (mAccessInfo.LoadForbid);
 696       }
 697
 698       mAccessInfo.LoadForbid = AllocateZeroPool (ValLen);
 699       if (mAccessInfo.LoadForbid != NULL) {
 700         AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);
 701         CopyMem (mAccessInfo.LoadForbid, AccessData, ValLen);
 702         mAccessInfo.LoadForbidLen = ValLen;
 703       }
 704       break;
 705
 706     case EFI_USER_INFO_ACCESS_PERMIT_LOAD:
 707       if (mAccessInfo.LoadPermit != NULL) {
 708         FreePool (mAccessInfo.LoadPermit);
 709       }
 710
 711       mAccessInfo.LoadPermit = AllocateZeroPool (ValLen);
 712       if (mAccessInfo.LoadPermit != NULL) {
 713         AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);
 714         CopyMem (mAccessInfo.LoadPermit, AccessData, ValLen);
 715         mAccessInfo.LoadPermitLen = ValLen;
 716       }
 717       break;
 718
 719     case EFI_USER_INFO_ACCESS_FORBID_CONNECT:
 720       if (mAccessInfo.ConnectForbid != NULL) {
 721         FreePool (mAccessInfo.ConnectForbid);
 722       }
 723
 724       mAccessInfo.ConnectForbid = AllocateZeroPool (ValLen);
 725       if (mAccessInfo.ConnectForbid != NULL) {
 726         AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);
 727         CopyMem (mAccessInfo.ConnectForbid, AccessData, ValLen);
 728         mAccessInfo.ConnectForbidLen = ValLen;
 729       }
 730       break;
 731
 732     case EFI_USER_INFO_ACCESS_PERMIT_CONNECT:
 733       if (mAccessInfo.ConnectPermit != NULL) {
 734         FreePool (mAccessInfo.ConnectPermit);
 735       }
 736
 737       mAccessInfo.ConnectPermit = AllocateZeroPool (ValLen);
 738       if (mAccessInfo.ConnectPermit != NULL) {
 739         AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);
 740         CopyMem (mAccessInfo.ConnectPermit, AccessData, ValLen);
 741         mAccessInfo.ConnectPermitLen = ValLen;
 742       }
 743       break;
 744     }
 745
 746     OffSet += Control.Size;
 747   }
 748 }
 749
 750
 751 /**
 752   Find the specified info in User profile by the InfoType.
 753
 754   @param[in]  User         Handle of the user whose information will be searched.
 755   @param[in]  InfoType     The user information type to find.
 756   @param[out] UserInfo     Points to user information handle found.
 757
 758   @retval EFI_SUCCESS      Find the user information successfully.
 759   @retval Others           Fail to find the user information.
 760
 761 **/
 762 EFI_STATUS
 763 FindInfoByType (
 764   IN  EFI_USER_PROFILE_HANDLE                   User,
 765   IN  UINT8                                     InfoType,
 766   OUT EFI_USER_INFO_HANDLE                      *UserInfo
 767   )
 768 {
 769   EFI_STATUS    Status;
 770   EFI_USER_INFO *Info;
 771   UINTN         InfoSize;
 772   UINTN         MemSize;
 773
 774   if (UserInfo == NULL) {
 775     return EFI_INVALID_PARAMETER;
 776   }
 777
 778   *UserInfo = NULL;
 779   //
 780   // Allocate user information memory.
 781   //
 782   MemSize = sizeof (EFI_USER_INFO) + 63;
 783   Info    = AllocateZeroPool (MemSize);
 784   if (Info == NULL) {
 785     return EFI_OUT_OF_RESOURCES;
 786   }
 787
 788   //
 789   // Get each user information.
 790   //
 791   while (TRUE) {
 792     Status = mUserManager->GetNextInfo (mUserManager, User, UserInfo);
 793     if (EFI_ERROR (Status)) {
 794       break;
 795     }
 796     //
 797     // Get information.
 798     //
 799     InfoSize  = MemSize;
 800     Status    = mUserManager->GetInfo (
 801                                 mUserManager,
 802                                 User,
 803                                 *UserInfo,
 804                                 Info,
 805                                 &InfoSize
 806                                 );
 807     if (Status == EFI_BUFFER_TOO_SMALL) {
 808       MemSize = InfoSize;
 809       FreePool (Info);
 810       Info = AllocateZeroPool (MemSize);
 811       if (Info == NULL) {
 812         return EFI_OUT_OF_RESOURCES;
 813       }
 814       Status = mUserManager->GetInfo (
 815                                mUserManager,
 816                                User,
 817                                *UserInfo,
 818                                Info,
 819                                &InfoSize
 820                                );
 821     }
 822     if (Status == EFI_SUCCESS) {
 823       if (Info->InfoType == InfoType) {
 824         break;
 825       }
 826     }
 827   }
 828
 829   FreePool (Info);
 830   return Status;
 831 }
 832
 833
 834 /**
 835   Display modify user access policy form.
 836
 837   In this form, access right, access setup and access boot order are dynamically
 838   added. Load devicepath and connect devicepath are displayed too.
 839
 840 **/
 841 VOID
 842 ModidyAccessPolicy (
 843   VOID
 844   )
 845 {
 846   VOID                *StartOpCodeHandle;
 847   VOID                *EndOpCodeHandle;
 848   VOID                *OptionsOpCodeHandle;
 849   EFI_IFR_GUID_LABEL  *StartLabel;
 850   EFI_IFR_GUID_LABEL  *EndLabel;
 851   VOID                *DefaultOpCodeHandle;
 852
 853   //
 854   // Initialize the container for dynamic opcodes.
 855   //
 856   StartOpCodeHandle = HiiAllocateOpCodeHandle ();
 857   ASSERT (StartOpCodeHandle != NULL);
 858
 859   EndOpCodeHandle = HiiAllocateOpCodeHandle ();
 860   ASSERT (EndOpCodeHandle != NULL);
 861
 862   //
 863   // Create Hii Extend Label OpCode.
 864   //
 865   StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
 866                                         StartOpCodeHandle,
 867                                         &gEfiIfrTianoGuid,
 868                                         NULL,
 869                                         sizeof (EFI_IFR_GUID_LABEL)
 870                                         );
 871   StartLabel->ExtendOpCode  = EFI_IFR_EXTEND_OP_LABEL;
 872   StartLabel->Number        = LABEL_AP_MOD_FUNC;
 873
 874   EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
 875                                       EndOpCodeHandle,
 876                                       &gEfiIfrTianoGuid,
 877                                       NULL,
 878                                       sizeof (EFI_IFR_GUID_LABEL)
 879                                       );
 880   EndLabel->ExtendOpCode  = EFI_IFR_EXTEND_OP_LABEL;
 881   EndLabel->Number        = LABEL_END;
 882
 883
 884   //
 885   // Resolve access policy information.
 886   //
 887   ResolveAccessPolicy ();
 888
 889   //
 890   // Add access right one-of-code.
 891   //
 892   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 893   ASSERT (OptionsOpCodeHandle != NULL);
 894   DefaultOpCodeHandle = HiiAllocateOpCodeHandle ();
 895   ASSERT (DefaultOpCodeHandle != NULL);
 896
 897   HiiCreateOneOfOptionOpCode (
 898     OptionsOpCodeHandle,
 899     STRING_TOKEN (STR_NORMAL),
 900     0,
 901     EFI_IFR_NUMERIC_SIZE_1,
 902     EFI_USER_INFO_ACCESS_ENROLL_SELF
 903     );
 904
 905   HiiCreateOneOfOptionOpCode (
 906     OptionsOpCodeHandle,
 907     STRING_TOKEN (STR_ENROLL),
 908     0,
 909     EFI_IFR_NUMERIC_SIZE_1,
 910     EFI_USER_INFO_ACCESS_ENROLL_OTHERS
 911     );
 912
 913   HiiCreateOneOfOptionOpCode (
 914     OptionsOpCodeHandle,
 915     STRING_TOKEN (STR_MANAGE),
 916     0,
 917     EFI_IFR_NUMERIC_SIZE_1,
 918     EFI_USER_INFO_ACCESS_MANAGE
 919     );
 920
 921   HiiCreateDefaultOpCode (
 922     DefaultOpCodeHandle,
 923     EFI_HII_DEFAULT_CLASS_STANDARD,
 924     EFI_IFR_NUMERIC_SIZE_1,
 925     mAccessInfo.AccessRight
 926     );
 927
 928   HiiCreateOneOfOpCode (
 929     StartOpCodeHandle,                    // Container for dynamic created opcodes
 930     KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_AP | KEY_MODIFY_RIGHT, // Question ID
 931     0,                                    // VarStore ID
 932     0,                                    // Offset in Buffer Storage
 933     STRING_TOKEN (STR_ACCESS_RIGHT),      // Question prompt text
 934     STRING_TOKEN (STR_ACCESS_RIGHT_HELP), // Question help text
 935     EFI_IFR_FLAG_CALLBACK,                // Question flag
 936     EFI_IFR_NUMERIC_SIZE_1,               // Data type of Question Value
 937     OptionsOpCodeHandle,                  // Option Opcode list
 938     DefaultOpCodeHandle                   // Default Opcode
 939     );
 940   HiiFreeOpCodeHandle (DefaultOpCodeHandle);
 941   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 942
 943
 944   //
 945   // Add setup type one-of-code.
 946   //
 947   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 948   ASSERT (OptionsOpCodeHandle != NULL);
 949   DefaultOpCodeHandle = HiiAllocateOpCodeHandle ();
 950   ASSERT (DefaultOpCodeHandle != NULL);
 951
 952   HiiCreateOneOfOptionOpCode (
 953     OptionsOpCodeHandle,
 954     STRING_TOKEN (STR_RESTRICTED),
 955     0,
 956     EFI_IFR_NUMERIC_SIZE_1,
 957     ACCESS_SETUP_RESTRICTED
 958     );
 959
 960   HiiCreateOneOfOptionOpCode (
 961     OptionsOpCodeHandle,
 962     STRING_TOKEN (STR_NORMAL),
 963     0,
 964     EFI_IFR_NUMERIC_SIZE_1,
 965     ACCESS_SETUP_NORMAL
 966     );
 967
 968   HiiCreateOneOfOptionOpCode (
 969     OptionsOpCodeHandle,
 970     STRING_TOKEN (STR_ADMIN),
 971     0,
 972     EFI_IFR_NUMERIC_SIZE_1,
 973     ACCESS_SETUP_ADMIN
 974     );
 975
 976   HiiCreateDefaultOpCode (
 977     DefaultOpCodeHandle,
 978     EFI_HII_DEFAULT_CLASS_STANDARD,
 979     EFI_IFR_NUMERIC_SIZE_1,
 980     mAccessInfo.AccessSetup
 981     );
 982
 983   HiiCreateOneOfOpCode (
 984     StartOpCodeHandle,                    // Container for dynamic created opcodes
 985     KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_AP | KEY_MODIFY_SETUP, // Question ID
 986     0,                                    // VarStore ID
 987     0,                                    // Offset in Buffer Storage
 988     STRING_TOKEN (STR_ACCESS_SETUP),      // Question prompt text
 989     STRING_TOKEN (STR_ACCESS_SETUP_HELP), // Question help text
 990     EFI_IFR_FLAG_CALLBACK,                // Question flag
 991     EFI_IFR_NUMERIC_SIZE_1,               // Data type of Question Value
 992     OptionsOpCodeHandle,                  // Option Opcode list
 993     DefaultOpCodeHandle                   // Default Opcode
 994     );
 995   HiiFreeOpCodeHandle (DefaultOpCodeHandle);
 996   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 997
 998   //
 999   // Add boot order one-of-code.
1000   //
1001   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1002   ASSERT (OptionsOpCodeHandle != NULL);
1003   DefaultOpCodeHandle = HiiAllocateOpCodeHandle ();
1004   ASSERT (DefaultOpCodeHandle != NULL);
1005
1006   HiiCreateOneOfOptionOpCode (
1007     OptionsOpCodeHandle,
1008     STRING_TOKEN (STR_INSERT),
1009     0,
1010     EFI_IFR_NUMERIC_SIZE_4,
1011     EFI_USER_INFO_ACCESS_BOOT_ORDER_INSERT
1012     );
1013
1014   HiiCreateOneOfOptionOpCode (
1015     OptionsOpCodeHandle,
1016     STRING_TOKEN (STR_APPEND),
1017     0,
1018     EFI_IFR_NUMERIC_SIZE_4,
1019     EFI_USER_INFO_ACCESS_BOOT_ORDER_APPEND
1020     );
1021
1022   HiiCreateOneOfOptionOpCode (
1023     OptionsOpCodeHandle,
1024     STRING_TOKEN (STR_REPLACE),
1025     0,
1026     EFI_IFR_NUMERIC_SIZE_4,
1027     EFI_USER_INFO_ACCESS_BOOT_ORDER_REPLACE
1028     );
1029
1030   HiiCreateOneOfOptionOpCode (
1031     OptionsOpCodeHandle,
1032     STRING_TOKEN (STR_NODEFAULT),
1033     0,
1034     EFI_IFR_NUMERIC_SIZE_4,
1035     EFI_USER_INFO_ACCESS_BOOT_ORDER_NODEFAULT
1036     );
1037
1038   HiiCreateDefaultOpCode (
1039     DefaultOpCodeHandle,
1040     EFI_HII_DEFAULT_CLASS_STANDARD,
1041     EFI_IFR_NUMERIC_SIZE_4,
1042     mAccessInfo.AccessBootOrder
1043     );
1044
1045   HiiCreateOneOfOpCode (
1046     StartOpCodeHandle,                  // Container for dynamic created opcodes
1047     KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_AP | KEY_MODIFY_BOOT, // Question ID
1048     0,                                  // VarStore ID
1049     0,                                  // Offset in Buffer Storage
1050     STRING_TOKEN (STR_BOOR_ORDER),      // Question prompt text
1051     STRING_TOKEN (STR_BOOT_ORDER_HELP), // Question help text
1052     EFI_IFR_FLAG_CALLBACK,              // Question flag
1053     EFI_IFR_NUMERIC_SIZE_1,             // Data type of Question Value
1054     OptionsOpCodeHandle,                // Option Opcode list
1055     DefaultOpCodeHandle                 // Default Opcode
1056     );
1057   HiiFreeOpCodeHandle (DefaultOpCodeHandle);
1058   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1059
1060   //
1061   // Update Form.
1062   //
1063   HiiUpdateForm (
1064     mCallbackInfo->HiiHandle,           // HII handle
1065     &gUserProfileManagerGuid,           // Formset GUID
1066     FORMID_MODIFY_AP,                   // Form ID
1067     StartOpCodeHandle,                  // Label for where to insert opcodes
1068     EndOpCodeHandle                     // Replace data
1069     );
1070
1071   HiiFreeOpCodeHandle (StartOpCodeHandle);
1072   HiiFreeOpCodeHandle (EndOpCodeHandle);
1073 }
1074
1075
1076 /**
1077   Expand access policy memory size.
1078
1079   @param[in] ValidLen       The valid access policy length.
1080   @param[in] ExpandLen      The length that is needed to expand.
1081
1082 **/
1083 VOID
1084 ExpandMemory (
1085   IN      UINTN                                 ValidLen,
1086   IN      UINTN                                 ExpandLen
1087   )
1088 {
1089   UINT8 *Mem;
1090   UINTN Len;
1091
1092   //
1093   // Expand memory.
1094   //
1095   Len = mUserInfo.AccessPolicyLen + (ExpandLen / 64 + 1) * 64;
1096   Mem = AllocateZeroPool (Len);
1097   ASSERT (Mem != NULL);
1098
1099   if (mUserInfo.AccessPolicy != NULL) {
1100     CopyMem (Mem, mUserInfo.AccessPolicy, ValidLen);
1101     FreePool (mUserInfo.AccessPolicy);
1102   }
1103
1104   mUserInfo.AccessPolicy    = Mem;
1105   mUserInfo.AccessPolicyLen = Len;
1106 }
1107
1108
1109 /**
1110   Get the username from user input, and update username string in the Hii
1111   database with it.
1112
1113 **/
1114 VOID
1115 ModifyUserName (
1116   VOID
1117   )
1118 {
1119   EFI_STATUS              Status;
1120   CHAR16                  UserName[USER_NAME_LENGTH];
1121   UINTN                   Len;
1122   EFI_INPUT_KEY           Key;
1123   EFI_USER_INFO_HANDLE    UserInfo;
1124   EFI_USER_INFO           *Info;
1125   EFI_USER_PROFILE_HANDLE TempUser;
1126
1127   //
1128   // Get the new user name.
1129   //
1130   Len = sizeof (UserName);
1131   Status = GetUserNameInput (&Len, UserName);
1132   if (EFI_ERROR (Status)) {
1133     if (Status != EFI_ABORTED) {
1134       CreatePopUp (
1135         EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
1136         &Key,
1137         L"Failed To Get User Name.",
1138         L"",
1139         L"Please Press Any Key to Continue ...",
1140         NULL
1141         );
1142     }
1143     return ;
1144   }
1145
1146   //
1147   // Check whether the username had been used or not.
1148   //
1149   Info = AllocateZeroPool (sizeof (EFI_USER_INFO) + Len);
1150   if (Info == NULL) {
1151     return ;
1152   }
1153
1154   Info->InfoType    = EFI_USER_INFO_NAME_RECORD;
1155   Info->InfoAttribs = EFI_USER_INFO_STORAGE_PLATFORM_NV |
1156                       EFI_USER_INFO_PUBLIC |
1157                       EFI_USER_INFO_EXCLUSIVE;
1158   Info->InfoSize    = (UINT32) (sizeof (EFI_USER_INFO) + Len);
1159   CopyMem ((UINT8 *) (Info + 1), UserName, Len);
1160
1161   TempUser  = NULL;
1162   Status    = mUserManager->Find (
1163                               mUserManager,
1164                               &TempUser,
1165                               NULL,
1166                               Info,
1167                               Info->InfoSize
1168                               );
1169   if (!EFI_ERROR (Status)) {
1170     CreatePopUp (
1171       EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
1172       &Key,
1173       L"The User Name Had Been Used.",
1174       L"",
1175       L"Please Use Other User Name",
1176       NULL
1177       );
1178     FreePool (Info);
1179     return ;
1180   }
1181
1182   //
1183   // Update username display in the form.
1184   //
1185   CopyMem (mUserInfo.UserName, UserName, Len);
1186   HiiSetString (
1187     mCallbackInfo->HiiHandle,
1188     STRING_TOKEN (STR_USER_NAME_VAL),
1189     mUserInfo.UserName,
1190     NULL
1191     );
1192
1193   //
1194   // Save the user name.
1195   //
1196   Status = FindInfoByType (mModifyUser, EFI_USER_INFO_NAME_RECORD, &UserInfo);
1197   if (!EFI_ERROR (Status)) {
1198     mUserManager->SetInfo (
1199                     mUserManager,
1200                     mModifyUser,
1201                     &UserInfo,
1202                     Info,
1203                     Info->InfoSize
1204                     );
1205   }
1206   FreePool (Info);
1207 }
1208
1209
1210 /**
1211   Display the form of the modifying user identity policy.
1212
1213 **/
1214 VOID
1215 ModifyIdentityPolicy (
1216   VOID
1217   )
1218 {
1219   UINTN               Index;
1220   CHAR16              *ProvStr;
1221   EFI_STRING_ID       ProvID;
1222   EFI_HII_HANDLE      HiiHandle;
1223   VOID                *OptionsOpCodeHandle;
1224   VOID                *StartOpCodeHandle;
1225   VOID                *EndOpCodeHandle;
1226   EFI_IFR_GUID_LABEL  *StartLabel;
1227   EFI_IFR_GUID_LABEL  *EndLabel;
1228
1229   //
1230   // Initialize the container for dynamic opcodes.
1231   //
1232   StartOpCodeHandle = HiiAllocateOpCodeHandle ();
1233   ASSERT (StartOpCodeHandle != NULL);
1234
1235   EndOpCodeHandle = HiiAllocateOpCodeHandle ();
1236   ASSERT (EndOpCodeHandle != NULL);
1237
1238   //
1239   // Create Hii Extend Label OpCode.
1240   //
1241   StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
1242                                         StartOpCodeHandle,
1243                                         &gEfiIfrTianoGuid,
1244                                         NULL,
1245                                         sizeof (EFI_IFR_GUID_LABEL)
1246                                         );
1247   StartLabel->ExtendOpCode  = EFI_IFR_EXTEND_OP_LABEL;
1248   StartLabel->Number        = LABEL_IP_MOD_FUNC;
1249
1250   EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
1251                                       EndOpCodeHandle,
1252                                       &gEfiIfrTianoGuid,
1253                                       NULL,
1254                                       sizeof (EFI_IFR_GUID_LABEL)
1255                                       );
1256   EndLabel->ExtendOpCode  = EFI_IFR_EXTEND_OP_LABEL;
1257   EndLabel->Number        = LABEL_END;
1258
1259   //
1260   // Add credential providers
1261   //.
1262   if (mProviderInfo->Count > 0) {
1263     OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1264     ASSERT (OptionsOpCodeHandle != NULL);
1265
1266     //
1267     // Add credential provider Option OpCode.
1268     //
1269     for (Index = 0; Index < mProviderInfo->Count; Index++) {
1270       mProviderInfo->Provider[Index]->Title (
1271                                         mProviderInfo->Provider[Index],
1272                                         &HiiHandle,
1273                                         &ProvID
1274                                         );
1275       ProvStr = HiiGetString (HiiHandle, ProvID, NULL);
1276       ProvID  = HiiSetString (mCallbackInfo->HiiHandle, 0, ProvStr, NULL);
1277       FreePool (ProvStr);
1278       if (ProvID == 0) {
1279         return ;
1280       }
1281
1282       HiiCreateOneOfOptionOpCode (
1283         OptionsOpCodeHandle,
1284         ProvID,
1285         0,
1286         EFI_IFR_NUMERIC_SIZE_1,
1287         (UINT8) Index
1288         );
1289     }
1290
1291     HiiCreateOneOfOpCode (
1292       StartOpCodeHandle,                // Container for dynamic created opcodes
1293       KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_IP | KEY_MODIFY_PROV,  // Question ID
1294       0,                                // VarStore ID
1295       0,                                // Offset in Buffer Storage
1296       STRING_TOKEN (STR_PROVIDER),      // Question prompt text
1297       STRING_TOKEN (STR_PROVIDER_HELP), // Question help text
1298       EFI_IFR_FLAG_CALLBACK,            // Question flag
1299       EFI_IFR_NUMERIC_SIZE_1,           // Data type of Question Value
1300       OptionsOpCodeHandle,              // Option Opcode list
1301       NULL                              // Default Opcode is NULl
1302       );
1303
1304     HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1305   }
1306
1307   //
1308   // Add logical connector Option OpCode.
1309   //
1310   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1311   ASSERT (OptionsOpCodeHandle != NULL);
1312
1313   HiiCreateOneOfOptionOpCode (
1314     OptionsOpCodeHandle,
1315     STRING_TOKEN (STR_AND_CON),
1316     0,
1317     EFI_IFR_NUMERIC_SIZE_1,
1318     0
1319     );
1320
1321   HiiCreateOneOfOptionOpCode (
1322     OptionsOpCodeHandle,
1323     STRING_TOKEN (STR_OR_CON),
1324     0,
1325     EFI_IFR_NUMERIC_SIZE_1,
1326     1
1327     );
1328
1329   HiiCreateOneOfOpCode (
1330     StartOpCodeHandle,                  // Container for dynamic created opcodes
1331     KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_IP | KEY_MODIFY_CONN,  // Question ID
1332     0,                                  // VarStore ID
1333     0,                                  // Offset in Buffer Storage
1334     STRING_TOKEN (STR_CONNECTOR),       // Question prompt text
1335     STRING_TOKEN (STR_CONNECTOR_HELP),  // Question help text
1336     EFI_IFR_FLAG_CALLBACK,              // Question flag
1337     EFI_IFR_NUMERIC_SIZE_1,             // Data type of Question Value
1338     OptionsOpCodeHandle,                // Option Opcode list
1339     NULL                                // Default Opcode is NULl
1340     );
1341
1342   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1343
1344   //
1345   // Update identity policy in the form.
1346   //
1347   ResolveIdentityPolicy (
1348     mUserInfo.IdentityPolicy,
1349     mUserInfo.IdentityPolicyLen,
1350     STRING_TOKEN (STR_IDENTIFY_POLICY_VALUE)
1351     );
1352
1353   if (mUserInfo.NewIdentityPolicy != NULL) {
1354     FreePool (mUserInfo.NewIdentityPolicy);
1355     mUserInfo.NewIdentityPolicy         = NULL;
1356     mUserInfo.NewIdentityPolicyLen      = 0;
1357     mUserInfo.NewIdentityPolicyModified = FALSE;
1358   }
1359   mProviderChoice = 0;
1360   mConncetLogical = 0;
1361
1362   HiiUpdateForm (
1363     mCallbackInfo->HiiHandle, // HII handle
1364     &gUserProfileManagerGuid, // Formset GUID
1365     FORMID_MODIFY_IP,         // Form ID
1366     StartOpCodeHandle,        // Label for where to insert opcodes
1367     EndOpCodeHandle           // Replace data
1368     );
1369
1370   HiiFreeOpCodeHandle (StartOpCodeHandle);
1371   HiiFreeOpCodeHandle (EndOpCodeHandle);
1372 }
1373
1374
1375 /**
1376   Get current user's access right.
1377
1378   @param[out]  AccessRight  Points to the buffer used for user's access right.
1379
1380   @retval EFI_SUCCESS       Get current user access right successfully.
1381   @retval others            Fail to get current user access right.
1382
1383 **/
1384 EFI_STATUS
1385 GetAccessRight (
1386   OUT  UINT32                                    *AccessRight
1387   )
1388 {
1389   EFI_STATUS                    Status;
1390   EFI_USER_INFO_HANDLE          UserInfo;
1391   EFI_USER_INFO                 *Info;
1392   UINTN                         InfoSize;
1393   UINTN                         MemSize;
1394   EFI_USER_INFO_ACCESS_CONTROL  Access;
1395   EFI_USER_PROFILE_HANDLE       CurrentUser;
1396   UINTN                         TotalLen;
1397   UINTN                         CheckLen;
1398
1399   //
1400   // Allocate user information memory.
1401   //
1402   MemSize = sizeof (EFI_USER_INFO) + 63;
1403   Info    = AllocateZeroPool (MemSize);
1404   if (Info == NULL) {
1405     return EFI_OUT_OF_RESOURCES;
1406   }
1407
1408   //
1409   // Get user access information.
1410   //
1411   UserInfo = NULL;
1412   mUserManager->Current (mUserManager, &CurrentUser);
1413   while (TRUE) {
1414     InfoSize = MemSize;
1415     //
1416     // Get next user information.
1417     //
1418     Status = mUserManager->GetNextInfo (mUserManager, CurrentUser, &UserInfo);
1419     if (EFI_ERROR (Status)) {
1420       break;
1421     }
1422
1423     Status = mUserManager->GetInfo (
1424                              mUserManager,
1425                              CurrentUser,
1426                              UserInfo,
1427                              Info,
1428                              &InfoSize
1429                              );
1430     if (Status == EFI_BUFFER_TOO_SMALL) {
1431       MemSize = InfoSize;
1432       FreePool (Info);
1433       Info = AllocateZeroPool (MemSize);
1434       if (Info == NULL) {
1435         return EFI_OUT_OF_RESOURCES;
1436       }
1437       Status = mUserManager->GetInfo (
1438                                mUserManager,
1439                                CurrentUser,
1440                                UserInfo,
1441                                Info,
1442                                &InfoSize
1443                                );
1444     }
1445     if (EFI_ERROR (Status)) {
1446       break;
1447     }
1448
1449     //
1450     // Check user information.
1451     //
1452     if (Info->InfoType == EFI_USER_INFO_ACCESS_POLICY_RECORD) {
1453       TotalLen  = Info->InfoSize - sizeof (EFI_USER_INFO);
1454       CheckLen  = 0;
1455       //
1456       // Get specified access information.
1457       //
1458       while (CheckLen < TotalLen) {
1459         CopyMem (&Access, (UINT8 *) (Info + 1) + CheckLen, sizeof (Access));
1460         if ((Access.Type == EFI_USER_INFO_ACCESS_ENROLL_SELF) ||
1461             (Access.Type == EFI_USER_INFO_ACCESS_ENROLL_OTHERS) ||
1462             (Access.Type == EFI_USER_INFO_ACCESS_MANAGE)
1463             ) {
1464           *AccessRight = Access.Type;
1465           FreePool (Info);
1466           return EFI_SUCCESS;
1467         }
1468         CheckLen += Access.Size;
1469       }
1470     }
1471   }
1472   FreePool (Info);
1473   return EFI_NOT_FOUND;
1474 }
1475