]> git.proxmox.com Git - mirror_edk2.git/blame - SecurityPkg/UserIdentification/UserProfileManagerDxe/UserProfileModify.c
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix error: Multiline option info only shows the first line error, should shows the...
[mirror_edk2.git] / SecurityPkg / UserIdentification / UserProfileManagerDxe / UserProfileModify.c
CommitLineData
0c18794e 1/** @file\r
2 The functions to modify a user profile.\r
3 \r
a0c56a82 4Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>\r
0c18794e 5This program and the accompanying materials \r
6are licensed and made available under the terms and conditions of the BSD License \r
7which accompanies this distribution. The full text of the license may be found at \r
8http://opensource.org/licenses/bsd-license.php\r
9\r
10THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
11WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
12\r
13**/\r
14\r
15#include "UserProfileManager.h"\r
16\r
17EFI_USER_PROFILE_HANDLE mModifyUser = NULL;\r
18\r
19/**\r
20 Display user select form, cab select a user to modify.\r
21\r
22**/\r
23VOID\r
24SelectUserToModify (\r
25 VOID\r
26 )\r
27{\r
28 EFI_STATUS Status;\r
29 UINT8 Index;\r
30 EFI_USER_PROFILE_HANDLE User;\r
31 EFI_USER_PROFILE_HANDLE CurrentUser;\r
32 UINT32 CurrentAccessRight;\r
33 VOID *StartOpCodeHandle;\r
34 VOID *EndOpCodeHandle;\r
35 EFI_IFR_GUID_LABEL *StartLabel;\r
36 EFI_IFR_GUID_LABEL *EndLabel;\r
37\r
38 //\r
39 // Initialize the container for dynamic opcodes.\r
40 //\r
41 StartOpCodeHandle = HiiAllocateOpCodeHandle ();\r
42 ASSERT (StartOpCodeHandle != NULL);\r
43\r
44 EndOpCodeHandle = HiiAllocateOpCodeHandle ();\r
45 ASSERT (EndOpCodeHandle != NULL);\r
46\r
47 //\r
48 // Create Hii Extend Label OpCode.\r
49 //\r
50 StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (\r
51 StartOpCodeHandle,\r
52 &gEfiIfrTianoGuid,\r
53 NULL,\r
54 sizeof (EFI_IFR_GUID_LABEL)\r
55 );\r
56 StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
57 StartLabel->Number = LABEL_USER_MOD_FUNC;\r
58\r
59 EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (\r
60 EndOpCodeHandle,\r
61 &gEfiIfrTianoGuid,\r
62 NULL,\r
63 sizeof (EFI_IFR_GUID_LABEL)\r
64 );\r
65 EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
66 EndLabel->Number = LABEL_END;\r
67\r
68 //\r
69 // Add each user can be modified.\r
70 //\r
71 User = NULL;\r
72 Index = 1;\r
73 mUserManager->Current (mUserManager, &CurrentUser);\r
74 while (TRUE) {\r
75 Status = mUserManager->GetNext (mUserManager, &User);\r
76 if (EFI_ERROR (Status)) {\r
77 break;\r
78 }\r
79\r
80 Status = GetAccessRight (&CurrentAccessRight);\r
81 if (EFI_ERROR (Status)) {\r
82 CurrentAccessRight = EFI_USER_INFO_ACCESS_ENROLL_SELF;\r
83 }\r
84\r
85 if ((CurrentAccessRight == EFI_USER_INFO_ACCESS_MANAGE) || (User == CurrentUser)) {\r
86 AddUserToForm (User, (UINT16)(KEY_MODIFY_USER | KEY_SELECT_USER | Index), StartOpCodeHandle);\r
87 }\r
88 Index++;\r
89 }\r
90\r
91 HiiUpdateForm (\r
92 mCallbackInfo->HiiHandle, // HII handle\r
a0c56a82 93 &gUserProfileManagerGuid, // Formset GUID\r
0c18794e 94 FORMID_MODIFY_USER, // Form ID\r
95 StartOpCodeHandle, // Label for where to insert opcodes\r
96 EndOpCodeHandle // Replace data\r
97 );\r
98\r
99 HiiFreeOpCodeHandle (StartOpCodeHandle);\r
100 HiiFreeOpCodeHandle (EndOpCodeHandle);\r
101}\r
102\r
103\r
104/**\r
105 Get all the user info from mModifyUser in the user manager, and save on the\r
106 global variable.\r
107\r
108**/\r
109VOID\r
110GetAllUserInfo (\r
111 VOID\r
112 )\r
113{\r
114 EFI_STATUS Status;\r
115 EFI_USER_INFO_HANDLE UserInfo;\r
116 EFI_USER_INFO *Info;\r
117 UINTN InfoSize;\r
118 UINTN MemSize;\r
119 UINTN DataLen;\r
120\r
121 //\r
122 // Init variable to default value.\r
123 //\r
124 mProviderChoice = 0;\r
125 mConncetLogical = 0;\r
126\r
127 mUserInfo.CreateDateExist = FALSE;\r
128 mUserInfo.UsageDateExist = FALSE;\r
129 mUserInfo.UsageCount = 0;\r
130 \r
131 mUserInfo.AccessPolicyLen = 0;\r
132 mUserInfo.AccessPolicyModified = FALSE;\r
133 if (mUserInfo.AccessPolicy != NULL) {\r
134 FreePool (mUserInfo.AccessPolicy);\r
135 mUserInfo.AccessPolicy = NULL;\r
136 }\r
137 mUserInfo.IdentityPolicyLen = 0;\r
138 mUserInfo.IdentityPolicyModified = FALSE;\r
139 if (mUserInfo.IdentityPolicy != NULL) {\r
140 FreePool (mUserInfo.IdentityPolicy);\r
141 mUserInfo.IdentityPolicy = NULL;\r
142 }\r
143 \r
144 //\r
145 // Allocate user information memory.\r
146 //\r
147 MemSize = sizeof (EFI_USER_INFO) + 63;\r
148 Info = AllocateZeroPool (MemSize);\r
149 if (Info == NULL) {\r
150 return ;\r
151 }\r
152 \r
153 //\r
154 // Get each user information.\r
155 //\r
156 UserInfo = NULL;\r
157 while (TRUE) {\r
158 Status = mUserManager->GetNextInfo (mUserManager, mModifyUser, &UserInfo);\r
159 if (EFI_ERROR (Status)) {\r
160 break;\r
161 }\r
162 //\r
163 // Get information.\r
164 //\r
165 InfoSize = MemSize;\r
166 Status = mUserManager->GetInfo (\r
167 mUserManager, \r
168 mModifyUser, \r
169 UserInfo, \r
170 Info, \r
171 &InfoSize\r
172 );\r
173 if (Status == EFI_BUFFER_TOO_SMALL) {\r
174 MemSize = InfoSize;\r
175 FreePool (Info);\r
176 Info = AllocateZeroPool (MemSize);\r
177 if (Info == NULL) {\r
178 return ;\r
179 }\r
180\r
181 Status = mUserManager->GetInfo (\r
182 mUserManager,\r
183 mModifyUser,\r
184 UserInfo,\r
185 Info,\r
186 &InfoSize\r
187 );\r
188 }\r
189\r
190 if (Status == EFI_SUCCESS) {\r
191 //\r
192 // Deal with each information according to informaiton type.\r
193 //\r
194 DataLen = Info->InfoSize - sizeof (EFI_USER_INFO);\r
195 switch (Info->InfoType) {\r
196 case EFI_USER_INFO_NAME_RECORD:\r
197 CopyMem (&mUserInfo.UserName, (UINT8 *) (Info + 1), DataLen);\r
198 break;\r
199\r
200 case EFI_USER_INFO_CREATE_DATE_RECORD:\r
201 CopyMem (&mUserInfo.CreateDate, (UINT8 *) (Info + 1), DataLen);\r
202 mUserInfo.CreateDateExist = TRUE;\r
203 break;\r
204\r
205 case EFI_USER_INFO_USAGE_DATE_RECORD:\r
206 CopyMem (&mUserInfo.UsageDate, (UINT8 *) (Info + 1), DataLen);\r
207 mUserInfo.UsageDateExist = TRUE;\r
208 break;\r
209\r
210 case EFI_USER_INFO_USAGE_COUNT_RECORD:\r
211 CopyMem (&mUserInfo.UsageCount, (UINT8 *) (Info + 1), DataLen);\r
212 break;\r
213\r
214 case EFI_USER_INFO_ACCESS_POLICY_RECORD:\r
215 mUserInfo.AccessPolicy = AllocateZeroPool (DataLen);\r
216 if (mUserInfo.AccessPolicy == NULL) {\r
217 break;\r
218 }\r
219\r
220 CopyMem (mUserInfo.AccessPolicy, (UINT8 *) (Info + 1), DataLen);\r
221 mUserInfo.AccessPolicyLen = DataLen;\r
222 break;\r
223\r
224 case EFI_USER_INFO_IDENTITY_POLICY_RECORD:\r
225 mUserInfo.IdentityPolicy = AllocateZeroPool (DataLen);\r
226 if (mUserInfo.IdentityPolicy == NULL) {\r
227 break;\r
228 }\r
229\r
230 CopyMem (mUserInfo.IdentityPolicy, (UINT8 *) (Info + 1), DataLen);\r
231 mUserInfo.IdentityPolicyLen = DataLen;\r
232 break;\r
233\r
234 default:\r
235 break;\r
236 }\r
237 }\r
238 }\r
239 FreePool (Info);\r
240}\r
241\r
242\r
243/**\r
244 Convert the Date to a string, and update the Hii database DateID string with it.\r
245\r
246 @param[in] Date Points to the date to be converted.\r
247 @param[in] DateId String ID in the HII database to be replaced.\r
248\r
249**/\r
250VOID\r
251ResolveDate (\r
252 IN EFI_TIME *Date,\r
253 IN EFI_STRING_ID DateId\r
254 )\r
255{\r
256 CHAR16 *Str;\r
257 UINTN DateBufLen;\r
258\r
259 //\r
260 // Convert date to string.\r
261 //\r
262 DateBufLen = 64;\r
263 Str = AllocateZeroPool (DateBufLen);\r
264 if (Str == NULL) {\r
265 return ;\r
266 }\r
267\r
268 UnicodeSPrint (\r
269 Str,\r
270 DateBufLen,\r
271 L"%4d-%2d-%2d ",\r
272 Date->Year,\r
273 Date->Month,\r
274 Date->Day\r
275 );\r
276\r
277 //\r
278 // Convert time to string.\r
279 //\r
280 DateBufLen -= StrLen (Str);\r
281 UnicodeSPrint (\r
282 Str + StrLen (Str),\r
283 DateBufLen,\r
284 L"%2d:%2d:%2d", \r
285 Date->Hour,\r
286 Date->Minute,\r
287 Date->Second\r
288 );\r
289 \r
290 HiiSetString (mCallbackInfo->HiiHandle, DateId, Str, NULL);\r
291 FreePool (Str);\r
292}\r
293\r
294\r
295/**\r
296 Convert the CountVal to a string, and update the Hii database CountId string\r
297 with it.\r
298\r
299 @param[in] CountVal The hex value to convert.\r
300 @param[in] CountId String ID in the HII database to be replaced.\r
301\r
302**/\r
303VOID\r
304ResolveCount (\r
305 IN UINT32 CountVal,\r
306 IN EFI_STRING_ID CountId\r
307 )\r
308{\r
309 CHAR16 Count[10];\r
310\r
311 UnicodeSPrint (Count, 20, L"%d", CountVal); \r
312 HiiSetString (mCallbackInfo->HiiHandle, CountId, Count, NULL);\r
313}\r
314\r
315\r
316/**\r
317 Concatenates one Null-terminated Unicode string to another Null-terminated\r
318 Unicode string.\r
319\r
320 @param[in, out] Source1 On entry, point to a Null-terminated Unicode string.\r
321 On exit, point to a new concatenated Unicode string \r
322 @param[in] Source2 Pointer to a Null-terminated Unicode string.\r
323\r
324**/\r
325VOID\r
326AddStr (\r
327 IN OUT CHAR16 **Source1,\r
328 IN CONST CHAR16 *Source2\r
329 )\r
330{\r
331 CHAR16 *TmpStr;\r
332 UINTN StrLength;\r
333\r
334 ASSERT (Source1 != NULL);\r
335 ASSERT (Source2 != NULL);\r
336\r
337 if (*Source1 == NULL) {\r
338 StrLength = StrSize (Source2);\r
339 } else {\r
340 StrLength = StrSize (*Source1);\r
341 StrLength += StrSize (Source2) -1;\r
342 }\r
343\r
344 TmpStr = AllocateZeroPool (StrLength);\r
345 ASSERT (TmpStr != NULL);\r
346\r
347 if (*Source1 == NULL) {\r
348 StrCpy (TmpStr, Source2);;\r
349 } else {\r
350 StrCpy (TmpStr, *Source1);\r
351 FreePool (*Source1);\r
352 StrCat (TmpStr, Source2);\r
353 }\r
354\r
355 *Source1 = TmpStr;\r
356}\r
357\r
358\r
359/**\r
360 Convert the identity policy to a unicode string and update the Hii database\r
361 IpStringId string with it.\r
362\r
363 @param[in] Ip Points to identity policy.\r
364 @param[in] IpLen The identity policy length.\r
365 @param[in] IpStringId String ID in the HII database to be replaced.\r
366\r
367**/\r
368VOID\r
369ResolveIdentityPolicy (\r
370 IN UINT8 *Ip,\r
371 IN UINTN IpLen,\r
372 IN EFI_STRING_ID IpStringId\r
373 )\r
374{\r
375 CHAR16 *TmpStr;\r
376 UINTN ChkLen;\r
377 EFI_USER_INFO_IDENTITY_POLICY *Identity;\r
378 UINT16 Index;\r
379 CHAR16 *ProvStr;\r
380 EFI_STRING_ID ProvId;\r
381 EFI_HII_HANDLE HiiHandle;\r
6f0b8648 382 EFI_USER_CREDENTIAL2_PROTOCOL *UserCredential;\r
0c18794e 383 \r
384 TmpStr = NULL;\r
385 \r
386 //\r
387 // Resolve each policy.\r
388 //\r
389 ChkLen = 0;\r
390 while (ChkLen < IpLen) {\r
391 Identity = (EFI_USER_INFO_IDENTITY_POLICY *) (Ip + ChkLen);\r
392 switch (Identity->Type) {\r
393 case EFI_USER_INFO_IDENTITY_FALSE:\r
394 AddStr (&TmpStr, L"False");\r
395 break;\r
396\r
397 case EFI_USER_INFO_IDENTITY_TRUE:\r
398 AddStr (&TmpStr, L"None");\r
399 break;\r
400\r
401 case EFI_USER_INFO_IDENTITY_NOT:\r
402 AddStr (&TmpStr, L"! ");\r
403 break;\r
404\r
405 case EFI_USER_INFO_IDENTITY_AND:\r
406 AddStr (&TmpStr, L" && ");\r
407 break;\r
408\r
409 case EFI_USER_INFO_IDENTITY_OR:\r
410 AddStr (&TmpStr, L" || ");\r
411 break;\r
412\r
413 case EFI_USER_INFO_IDENTITY_CREDENTIAL_TYPE:\r
414 for (Index = 0; Index < mProviderInfo->Count; Index++) {\r
415 UserCredential = mProviderInfo->Provider[Index];\r
416 if (CompareGuid ((EFI_GUID *) (Identity + 1), &UserCredential->Type)) { \r
417 UserCredential->Title (\r
418 UserCredential, \r
419 &HiiHandle, \r
420 &ProvId\r
421 );\r
422 ProvStr = HiiGetString (HiiHandle, ProvId, NULL);\r
423 if (ProvStr != NULL) {\r
424 AddStr (&TmpStr, ProvStr);\r
425 FreePool (ProvStr);\r
426 }\r
427 break;\r
428 }\r
429 }\r
430 break;\r
431\r
432 case EFI_USER_INFO_IDENTITY_CREDENTIAL_PROVIDER:\r
433 for (Index = 0; Index < mProviderInfo->Count; Index++) {\r
434 UserCredential = mProviderInfo->Provider[Index];\r
435 if (CompareGuid ((EFI_GUID *) (Identity + 1), &UserCredential->Identifier)) { \r
436 UserCredential->Title (\r
437 UserCredential,\r
438 &HiiHandle,\r
439 &ProvId\r
440 );\r
441 ProvStr = HiiGetString (HiiHandle, ProvId, NULL);\r
442 if (ProvStr != NULL) {\r
443 AddStr (&TmpStr, ProvStr);\r
444 FreePool (ProvStr);\r
445 }\r
446 break;\r
447 }\r
448 }\r
449 break;\r
450 }\r
451\r
452 ChkLen += Identity->Length;\r
453 }\r
454\r
455 if (TmpStr != NULL) {\r
456 HiiSetString (mCallbackInfo->HiiHandle, IpStringId, TmpStr, NULL);\r
457 FreePool (TmpStr);\r
458 }\r
459}\r
460\r
461\r
462/**\r
463 Display modify user information form.\r
464\r
465 This form displays, username, create Date, usage date, usage count, identity policy,\r
466 and access policy.\r
467\r
468 @param[in] UserIndex The index of the user in display list to modify.\r
469 \r
470**/\r
471VOID\r
472ModifyUserInfo (\r
473 IN UINT8 UserIndex\r
474 )\r
475{\r
476 EFI_STATUS Status;\r
477 EFI_USER_PROFILE_HANDLE CurrentUser;\r
478 UINT32 CurrentAccessRight;\r
479 VOID *StartOpCodeHandle;\r
480 VOID *EndOpCodeHandle;\r
481 EFI_IFR_GUID_LABEL *StartLabel;\r
482 EFI_IFR_GUID_LABEL *EndLabel;\r
483\r
484 //\r
485 // Initialize the container for dynamic opcodes.\r
486 //\r
487 StartOpCodeHandle = HiiAllocateOpCodeHandle ();\r
488 ASSERT (StartOpCodeHandle != NULL);\r
489\r
490 EndOpCodeHandle = HiiAllocateOpCodeHandle ();\r
491 ASSERT (EndOpCodeHandle != NULL);\r
492\r
493 //\r
494 // Create Hii Extend Label OpCode.\r
495 //\r
496 StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (\r
497 StartOpCodeHandle,\r
498 &gEfiIfrTianoGuid,\r
499 NULL,\r
500 sizeof (EFI_IFR_GUID_LABEL)\r
501 );\r
502 StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
503 StartLabel->Number = LABEL_USER_INFO_FUNC;\r
504\r
505 EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (\r
506 EndOpCodeHandle,\r
507 &gEfiIfrTianoGuid,\r
508 NULL,\r
509 sizeof (EFI_IFR_GUID_LABEL)\r
510 );\r
511 EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
512 EndLabel->Number = LABEL_END;\r
513\r
514 //\r
515 // Find the user profile to be modified.\r
516 //\r
517 mModifyUser = NULL;\r
518 Status = mUserManager->GetNext (mUserManager, &mModifyUser);\r
519 if (EFI_ERROR (Status)) {\r
520 return ;\r
521 }\r
522\r
523 while (UserIndex > 1) {\r
524 Status = mUserManager->GetNext (mUserManager, &mModifyUser);\r
525 if (EFI_ERROR (Status)) {\r
526 return ;\r
527 }\r
528 UserIndex--;\r
529 }\r
530 \r
531 //\r
532 // Get user profile information.\r
533 //\r
534 GetAllUserInfo ();\r
535\r
536 //\r
537 // Update user name.\r
538 HiiSetString (\r
539 mCallbackInfo->HiiHandle,\r
540 STRING_TOKEN (STR_USER_NAME_VAL),\r
541 mUserInfo.UserName,\r
542 NULL\r
543 );\r
544 \r
545 //\r
546 // Update create date.\r
547 //\r
548 if (mUserInfo.CreateDateExist) {\r
549 ResolveDate (&mUserInfo.CreateDate, STRING_TOKEN (STR_CREATE_DATE_VAL));\r
550 } else {\r
551 HiiSetString (\r
552 mCallbackInfo->HiiHandle,\r
553 STRING_TOKEN (STR_CREATE_DATE_VAL),\r
554 L"",\r
555 NULL\r
556 );\r
557 }\r
558 \r
559 //\r
560 // Add usage date.\r
561 //\r
562 if (mUserInfo.UsageDateExist) {\r
563 ResolveDate (&mUserInfo.UsageDate, STRING_TOKEN (STR_USAGE_DATE_VAL));\r
564 } else {\r
565 HiiSetString (\r
566 mCallbackInfo->HiiHandle,\r
567 STRING_TOKEN (STR_USAGE_DATE_VAL),\r
568 L"",\r
569 NULL\r
570 );\r
571 }\r
572 \r
573 //\r
574 // Add usage count.\r
575 //\r
576 ResolveCount ((UINT32) mUserInfo.UsageCount, STRING_TOKEN (STR_USAGE_COUNT_VAL));\r
577 \r
578 //\r
579 // Add identity policy.\r
580 //\r
581 mUserManager->Current (mUserManager, &CurrentUser);\r
582 if (mModifyUser == CurrentUser) {\r
583 ResolveIdentityPolicy (\r
584 mUserInfo.IdentityPolicy,\r
585 mUserInfo.IdentityPolicyLen,\r
586 STRING_TOKEN (STR_IDENTIFY_POLICY_VAL)\r
587 );\r
588 HiiCreateGotoOpCode (\r
589 StartOpCodeHandle, // Container for opcodes\r
590 FORMID_MODIFY_IP, // Target Form ID\r
591 STRING_TOKEN (STR_IDENTIFY_POLICY), // Prompt text\r
592 STRING_TOKEN (STR_IDENTIFY_POLICY_VAL), // Help text\r
593 EFI_IFR_FLAG_CALLBACK, // Question flag\r
594 KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_IP // Question ID\r
595 );\r
596 }\r
597 \r
598 //\r
599 // Add access policy.\r
600 //\r
601 Status = GetAccessRight (&CurrentAccessRight);\r
602 if (EFI_ERROR (Status)) {\r
603 CurrentAccessRight = EFI_USER_INFO_ACCESS_ENROLL_SELF;\r
604 }\r
605\r
606 if (CurrentAccessRight == EFI_USER_INFO_ACCESS_MANAGE) {\r
607 HiiCreateGotoOpCode (\r
608 StartOpCodeHandle, // Container for opcodes\r
609 FORMID_MODIFY_AP, // Target Form ID\r
610 STRING_TOKEN (STR_ACCESS_POLICY), // Prompt text\r
611 STRING_TOKEN (STR_NULL_STRING), // Help text\r
612 EFI_IFR_FLAG_CALLBACK, // Question flag\r
613 KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_AP // Question ID\r
614 );\r
615 }\r
616\r
617 HiiUpdateForm (\r
618 mCallbackInfo->HiiHandle, // HII handle\r
a0c56a82 619 &gUserProfileManagerGuid, // Formset GUID\r
0c18794e 620 FORMID_USER_INFO, // Form ID\r
621 StartOpCodeHandle, // Label\r
622 EndOpCodeHandle // Replace data\r
623 );\r
624\r
625 HiiFreeOpCodeHandle (StartOpCodeHandle);\r
626 HiiFreeOpCodeHandle (EndOpCodeHandle);\r
627}\r
628\r
629\r
630/**\r
631 Get all the access policy info from current user info, and save in the global\r
632 variable.\r
633\r
634**/\r
635VOID\r
636ResolveAccessPolicy (\r
637 VOID\r
638 )\r
639{\r
640 UINTN OffSet;\r
641 EFI_USER_INFO_ACCESS_CONTROL Control;\r
642 UINTN ValLen;\r
643 UINT8 *AccessData;\r
644\r
645 //\r
646 // Set default value \r
647 //\r
648 mAccessInfo.AccessRight = EFI_USER_INFO_ACCESS_ENROLL_SELF;\r
649 mAccessInfo.AccessSetup = ACCESS_SETUP_RESTRICTED;\r
650 mAccessInfo.AccessBootOrder = EFI_USER_INFO_ACCESS_BOOT_ORDER_INSERT;\r
651\r
652 mAccessInfo.LoadPermitLen = 0;\r
653 mAccessInfo.LoadForbidLen = 0;\r
654 mAccessInfo.ConnectPermitLen = 0;\r
655 mAccessInfo.ConnectForbidLen = 0;\r
656 \r
657 //\r
658 // Get each user access policy.\r
659 //\r
660 OffSet = 0;\r
661 while (OffSet < mUserInfo.AccessPolicyLen) {\r
662 CopyMem (&Control, mUserInfo.AccessPolicy + OffSet, sizeof (Control)); \r
663 ValLen = Control.Size - sizeof (Control);\r
664 switch (Control.Type) {\r
665 case EFI_USER_INFO_ACCESS_ENROLL_SELF:\r
666 mAccessInfo.AccessRight = EFI_USER_INFO_ACCESS_ENROLL_SELF;\r
667 break;\r
668\r
669 case EFI_USER_INFO_ACCESS_ENROLL_OTHERS:\r
670 mAccessInfo.AccessRight = EFI_USER_INFO_ACCESS_ENROLL_OTHERS;\r
671 break;\r
672\r
673 case EFI_USER_INFO_ACCESS_MANAGE:\r
674 mAccessInfo.AccessRight = EFI_USER_INFO_ACCESS_MANAGE;\r
675 break;\r
676\r
677 case EFI_USER_INFO_ACCESS_SETUP:\r
678 AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);\r
679 if (CompareGuid ((EFI_GUID *) AccessData, &gEfiUserInfoAccessSetupNormalGuid)) {\r
680 mAccessInfo.AccessSetup = ACCESS_SETUP_NORMAL;\r
681 } else if (CompareGuid ((EFI_GUID *) AccessData, &gEfiUserInfoAccessSetupRestrictedGuid)) {\r
682 mAccessInfo.AccessSetup = ACCESS_SETUP_RESTRICTED;\r
683 } else if (CompareGuid ((EFI_GUID *) AccessData, &gEfiUserInfoAccessSetupAdminGuid)) {\r
684 mAccessInfo.AccessSetup = ACCESS_SETUP_ADMIN;\r
685 }\r
686 break;\r
687\r
688 case EFI_USER_INFO_ACCESS_BOOT_ORDER:\r
689 AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);\r
690 CopyMem (&mAccessInfo.AccessBootOrder, AccessData, sizeof (UINT32));\r
691 break;\r
692\r
693 case EFI_USER_INFO_ACCESS_FORBID_LOAD:\r
694 if (mAccessInfo.LoadForbid != NULL) {\r
695 FreePool (mAccessInfo.LoadForbid);\r
696 }\r
697\r
698 mAccessInfo.LoadForbid = AllocateZeroPool (ValLen);\r
699 if (mAccessInfo.LoadForbid != NULL) {\r
700 AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);\r
701 CopyMem (mAccessInfo.LoadForbid, AccessData, ValLen);\r
702 mAccessInfo.LoadForbidLen = ValLen;\r
703 }\r
704 break;\r
705\r
706 case EFI_USER_INFO_ACCESS_PERMIT_LOAD:\r
707 if (mAccessInfo.LoadPermit != NULL) {\r
708 FreePool (mAccessInfo.LoadPermit);\r
709 }\r
710\r
711 mAccessInfo.LoadPermit = AllocateZeroPool (ValLen);\r
712 if (mAccessInfo.LoadPermit != NULL) {\r
713 AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);\r
714 CopyMem (mAccessInfo.LoadPermit, AccessData, ValLen);\r
715 mAccessInfo.LoadPermitLen = ValLen;\r
716 }\r
717 break;\r
718\r
719 case EFI_USER_INFO_ACCESS_FORBID_CONNECT:\r
720 if (mAccessInfo.ConnectForbid != NULL) {\r
721 FreePool (mAccessInfo.ConnectForbid);\r
722 }\r
723\r
724 mAccessInfo.ConnectForbid = AllocateZeroPool (ValLen);\r
725 if (mAccessInfo.ConnectForbid != NULL) {\r
726 AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);\r
727 CopyMem (mAccessInfo.ConnectForbid, AccessData, ValLen);\r
728 mAccessInfo.ConnectForbidLen = ValLen;\r
729 }\r
730 break;\r
731\r
732 case EFI_USER_INFO_ACCESS_PERMIT_CONNECT:\r
733 if (mAccessInfo.ConnectPermit != NULL) {\r
734 FreePool (mAccessInfo.ConnectPermit);\r
735 }\r
736\r
737 mAccessInfo.ConnectPermit = AllocateZeroPool (ValLen);\r
738 if (mAccessInfo.ConnectPermit != NULL) {\r
739 AccessData = mUserInfo.AccessPolicy + OffSet + sizeof (Control);\r
740 CopyMem (mAccessInfo.ConnectPermit, AccessData, ValLen);\r
741 mAccessInfo.ConnectPermitLen = ValLen;\r
742 }\r
743 break;\r
744 }\r
745\r
746 OffSet += Control.Size;\r
747 }\r
748}\r
749\r
750\r
751/**\r
752 Find the specified info in profile mModifyUser by the InfoType.\r
753\r
754 @param[in] InfoType The user information type to find.\r
755 @param[out] UserInfo Points to user information handle found.\r
756 \r
757 @retval EFI_SUCCESS Find the user information successfully.\r
758 @retval Others Fail to find the user information.\r
759\r
760**/\r
761EFI_STATUS\r
762FindInfoByType (\r
763 IN UINT8 InfoType,\r
764 OUT EFI_USER_INFO_HANDLE *UserInfo\r
765 )\r
766{\r
767 EFI_STATUS Status;\r
768 EFI_USER_INFO *Info;\r
769 UINTN InfoSize;\r
770 UINTN MemSize;\r
771\r
772 if (UserInfo == NULL) {\r
773 return EFI_INVALID_PARAMETER;\r
774 }\r
775\r
776 *UserInfo = NULL;\r
777 //\r
778 // Allocate user information memory.\r
779 //\r
780 MemSize = sizeof (EFI_USER_INFO) + 63;\r
781 Info = AllocateZeroPool (MemSize);\r
782 if (Info == NULL) {\r
783 return EFI_OUT_OF_RESOURCES;\r
784 }\r
785 \r
786 //\r
787 // Get each user information.\r
788 //\r
789 while (TRUE) {\r
790 Status = mUserManager->GetNextInfo (mUserManager, mModifyUser, UserInfo);\r
791 if (EFI_ERROR (Status)) {\r
792 break;\r
793 }\r
794 //\r
795 // Get information.\r
796 //\r
797 InfoSize = MemSize;\r
798 Status = mUserManager->GetInfo (\r
799 mUserManager,\r
800 mModifyUser,\r
801 *UserInfo,\r
802 Info,\r
803 &InfoSize\r
804 );\r
805 if (Status == EFI_BUFFER_TOO_SMALL) {\r
806 MemSize = InfoSize;\r
807 FreePool (Info);\r
808 Info = AllocateZeroPool (MemSize);\r
809 if (Info == NULL) {\r
810 return EFI_OUT_OF_RESOURCES;\r
811 }\r
812 Status = mUserManager->GetInfo (\r
813 mUserManager,\r
814 mModifyUser,\r
815 *UserInfo,\r
816 Info,\r
817 &InfoSize\r
818 );\r
819 }\r
820 if (Status == EFI_SUCCESS) {\r
821 if (Info->InfoType == InfoType) {\r
822 break;\r
823 }\r
824 }\r
825 }\r
826\r
827 FreePool (Info);\r
828 return Status;\r
829}\r
830\r
831\r
832/**\r
833 Display modify user access policy form.\r
834\r
835 In this form, access right, access setup and access boot order are dynamically\r
836 added. Load devicepath and connect devicepath are displayed too.\r
837 \r
838**/\r
839VOID\r
840ModidyAccessPolicy (\r
841 VOID\r
842 )\r
843{\r
844 VOID *StartOpCodeHandle;\r
845 VOID *EndOpCodeHandle;\r
846 VOID *OptionsOpCodeHandle;\r
847 EFI_IFR_GUID_LABEL *StartLabel;\r
848 EFI_IFR_GUID_LABEL *EndLabel;\r
849 VOID *DefaultOpCodeHandle;\r
850 \r
851 //\r
852 // Initialize the container for dynamic opcodes.\r
853 //\r
854 StartOpCodeHandle = HiiAllocateOpCodeHandle ();\r
855 ASSERT (StartOpCodeHandle != NULL);\r
856\r
857 EndOpCodeHandle = HiiAllocateOpCodeHandle ();\r
858 ASSERT (EndOpCodeHandle != NULL);\r
859\r
860 //\r
861 // Create Hii Extend Label OpCode.\r
862 //\r
863 StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (\r
864 StartOpCodeHandle,\r
865 &gEfiIfrTianoGuid,\r
866 NULL,\r
867 sizeof (EFI_IFR_GUID_LABEL)\r
868 );\r
869 StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
870 StartLabel->Number = LABEL_AP_MOD_FUNC;\r
871\r
872 EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (\r
873 EndOpCodeHandle,\r
874 &gEfiIfrTianoGuid,\r
875 NULL,\r
876 sizeof (EFI_IFR_GUID_LABEL)\r
877 );\r
878 EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
879 EndLabel->Number = LABEL_END;\r
880\r
881\r
882 //\r
883 // Resolve access policy information.\r
884 //\r
885 ResolveAccessPolicy ();\r
886\r
887 //\r
888 // Add access right one-of-code.\r
889 //\r
890 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();\r
891 ASSERT (OptionsOpCodeHandle != NULL);\r
892 DefaultOpCodeHandle = HiiAllocateOpCodeHandle ();\r
893 ASSERT (DefaultOpCodeHandle != NULL);\r
894 \r
895 HiiCreateOneOfOptionOpCode (\r
896 OptionsOpCodeHandle,\r
897 STRING_TOKEN (STR_NORMAL),\r
898 0,\r
899 EFI_IFR_NUMERIC_SIZE_1,\r
900 EFI_USER_INFO_ACCESS_ENROLL_SELF\r
901 );\r
902\r
903 HiiCreateOneOfOptionOpCode (\r
904 OptionsOpCodeHandle,\r
905 STRING_TOKEN (STR_ENROLL),\r
906 0,\r
907 EFI_IFR_NUMERIC_SIZE_1,\r
908 EFI_USER_INFO_ACCESS_ENROLL_OTHERS\r
909 );\r
910\r
911 HiiCreateOneOfOptionOpCode (\r
912 OptionsOpCodeHandle,\r
913 STRING_TOKEN (STR_MANAGE),\r
914 0,\r
915 EFI_IFR_NUMERIC_SIZE_1,\r
916 EFI_USER_INFO_ACCESS_MANAGE\r
917 );\r
918\r
919 HiiCreateDefaultOpCode (\r
920 DefaultOpCodeHandle, \r
921 EFI_HII_DEFAULT_CLASS_STANDARD, \r
922 EFI_IFR_NUMERIC_SIZE_1, \r
923 mAccessInfo.AccessRight\r
924 );\r
925 \r
926 HiiCreateOneOfOpCode (\r
927 StartOpCodeHandle, // Container for dynamic created opcodes\r
928 KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_AP | KEY_MODIFY_RIGHT, // Question ID\r
929 0, // VarStore ID\r
930 0, // Offset in Buffer Storage\r
931 STRING_TOKEN (STR_ACCESS_RIGHT), // Question prompt text\r
932 STRING_TOKEN (STR_ACCESS_RIGHT_HELP), // Question help text\r
933 EFI_IFR_FLAG_CALLBACK, // Question flag\r
934 EFI_IFR_NUMERIC_SIZE_1, // Data type of Question Value\r
935 OptionsOpCodeHandle, // Option Opcode list\r
936 DefaultOpCodeHandle // Default Opcode\r
937 );\r
938 HiiFreeOpCodeHandle (DefaultOpCodeHandle);\r
939 HiiFreeOpCodeHandle (OptionsOpCodeHandle);\r
940\r
941\r
942 //\r
943 // Add setup type one-of-code.\r
944 //\r
945 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();\r
946 ASSERT (OptionsOpCodeHandle != NULL);\r
947 DefaultOpCodeHandle = HiiAllocateOpCodeHandle ();\r
948 ASSERT (DefaultOpCodeHandle != NULL);\r
949 \r
950 HiiCreateOneOfOptionOpCode (\r
951 OptionsOpCodeHandle,\r
952 STRING_TOKEN (STR_RESTRICTED),\r
953 0,\r
954 EFI_IFR_NUMERIC_SIZE_1,\r
955 ACCESS_SETUP_RESTRICTED\r
956 );\r
957 \r
958 HiiCreateOneOfOptionOpCode (\r
959 OptionsOpCodeHandle,\r
960 STRING_TOKEN (STR_NORMAL),\r
961 0,\r
962 EFI_IFR_NUMERIC_SIZE_1,\r
963 ACCESS_SETUP_NORMAL\r
964 );\r
965\r
966 HiiCreateOneOfOptionOpCode (\r
967 OptionsOpCodeHandle,\r
968 STRING_TOKEN (STR_ADMIN),\r
969 0,\r
970 EFI_IFR_NUMERIC_SIZE_1,\r
971 ACCESS_SETUP_ADMIN\r
972 );\r
973\r
974 HiiCreateDefaultOpCode (\r
975 DefaultOpCodeHandle, \r
976 EFI_HII_DEFAULT_CLASS_STANDARD, \r
977 EFI_IFR_NUMERIC_SIZE_1, \r
978 mAccessInfo.AccessSetup\r
979 ); \r
980\r
981 HiiCreateOneOfOpCode (\r
982 StartOpCodeHandle, // Container for dynamic created opcodes\r
983 KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_AP | KEY_MODIFY_SETUP, // Question ID\r
984 0, // VarStore ID\r
985 0, // Offset in Buffer Storage\r
986 STRING_TOKEN (STR_ACCESS_SETUP), // Question prompt text\r
987 STRING_TOKEN (STR_ACCESS_SETUP_HELP), // Question help text\r
988 EFI_IFR_FLAG_CALLBACK, // Question flag\r
989 EFI_IFR_NUMERIC_SIZE_1, // Data type of Question Value\r
990 OptionsOpCodeHandle, // Option Opcode list\r
991 DefaultOpCodeHandle // Default Opcode\r
992 );\r
993 HiiFreeOpCodeHandle (DefaultOpCodeHandle);\r
994 HiiFreeOpCodeHandle (OptionsOpCodeHandle);\r
995 \r
996 //\r
997 // Add boot order one-of-code.\r
998 //\r
999 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();\r
1000 ASSERT (OptionsOpCodeHandle != NULL);\r
1001 DefaultOpCodeHandle = HiiAllocateOpCodeHandle ();\r
1002 ASSERT (DefaultOpCodeHandle != NULL);\r
1003 \r
1004 HiiCreateOneOfOptionOpCode (\r
1005 OptionsOpCodeHandle,\r
1006 STRING_TOKEN (STR_INSERT),\r
1007 0,\r
1008 EFI_IFR_NUMERIC_SIZE_4,\r
1009 EFI_USER_INFO_ACCESS_BOOT_ORDER_INSERT\r
1010 );\r
1011\r
1012 HiiCreateOneOfOptionOpCode (\r
1013 OptionsOpCodeHandle,\r
1014 STRING_TOKEN (STR_APPEND),\r
1015 0,\r
1016 EFI_IFR_NUMERIC_SIZE_4,\r
1017 EFI_USER_INFO_ACCESS_BOOT_ORDER_APPEND\r
1018 );\r
1019\r
1020 HiiCreateOneOfOptionOpCode (\r
1021 OptionsOpCodeHandle,\r
1022 STRING_TOKEN (STR_REPLACE),\r
1023 0,\r
1024 EFI_IFR_NUMERIC_SIZE_4,\r
1025 EFI_USER_INFO_ACCESS_BOOT_ORDER_REPLACE\r
1026 );\r
1027 \r
1028 HiiCreateOneOfOptionOpCode (\r
1029 OptionsOpCodeHandle,\r
1030 STRING_TOKEN (STR_NODEFAULT),\r
1031 0,\r
1032 EFI_IFR_NUMERIC_SIZE_4,\r
1033 EFI_USER_INFO_ACCESS_BOOT_ORDER_NODEFAULT\r
1034 );\r
1035\r
1036 HiiCreateDefaultOpCode (\r
1037 DefaultOpCodeHandle, \r
1038 EFI_HII_DEFAULT_CLASS_STANDARD, \r
1039 EFI_IFR_NUMERIC_SIZE_4, \r
1040 mAccessInfo.AccessBootOrder\r
1041 );\r
1042 \r
1043 HiiCreateOneOfOpCode (\r
1044 StartOpCodeHandle, // Container for dynamic created opcodes\r
1045 KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_AP | KEY_MODIFY_BOOT, // Question ID\r
1046 0, // VarStore ID\r
1047 0, // Offset in Buffer Storage\r
1048 STRING_TOKEN (STR_BOOR_ORDER), // Question prompt text\r
1049 STRING_TOKEN (STR_BOOT_ORDER_HELP), // Question help text\r
1050 EFI_IFR_FLAG_CALLBACK, // Question flag\r
1051 EFI_IFR_NUMERIC_SIZE_1, // Data type of Question Value\r
1052 OptionsOpCodeHandle, // Option Opcode list\r
1053 DefaultOpCodeHandle // Default Opcode\r
1054 );\r
1055 HiiFreeOpCodeHandle (DefaultOpCodeHandle); \r
1056 HiiFreeOpCodeHandle (OptionsOpCodeHandle);\r
1057\r
1058 //\r
1059 // Update Form.\r
1060 //\r
1061 HiiUpdateForm (\r
1062 mCallbackInfo->HiiHandle, // HII handle\r
a0c56a82 1063 &gUserProfileManagerGuid, // Formset GUID\r
0c18794e 1064 FORMID_MODIFY_AP, // Form ID\r
1065 StartOpCodeHandle, // Label for where to insert opcodes\r
1066 EndOpCodeHandle // Replace data\r
1067 );\r
1068\r
1069 HiiFreeOpCodeHandle (StartOpCodeHandle);\r
1070 HiiFreeOpCodeHandle (EndOpCodeHandle);\r
1071}\r
1072\r
1073\r
1074/**\r
1075 Expand access policy memory size.\r
1076\r
1077 @param[in] ValidLen The valid access policy length.\r
1078 @param[in] ExpandLen The length that is needed to expand.\r
1079 \r
1080**/\r
1081VOID\r
1082ExpandMemory (\r
1083 IN UINTN ValidLen,\r
1084 IN UINTN ExpandLen\r
1085 )\r
1086{\r
1087 UINT8 *Mem;\r
1088 UINTN Len;\r
1089\r
1090 //\r
1091 // Expand memory.\r
1092 //\r
1093 Len = mUserInfo.AccessPolicyLen + (ExpandLen / 64 + 1) * 64;\r
1094 Mem = AllocateZeroPool (Len);\r
1095 ASSERT (Mem != NULL);\r
1096\r
1097 if (mUserInfo.AccessPolicy != NULL) {\r
1098 CopyMem (Mem, mUserInfo.AccessPolicy, ValidLen);\r
1099 FreePool (mUserInfo.AccessPolicy);\r
1100 }\r
1101\r
1102 mUserInfo.AccessPolicy = Mem;\r
1103 mUserInfo.AccessPolicyLen = Len;\r
1104}\r
1105\r
1106\r
1107/**\r
1108 Collect all the access policy data to mUserInfo.AccessPolicy, \r
1109 and save it to user profile.\r
1110\r
1111**/\r
1112VOID\r
1113SaveAccessPolicy (\r
1114 VOID\r
1115 )\r
1116{\r
1117 EFI_STATUS Status;\r
1118 UINTN OffSet;\r
1119 UINTN Size;\r
1120 EFI_USER_INFO_ACCESS_CONTROL Control;\r
1121 EFI_USER_INFO_HANDLE UserInfo;\r
1122 EFI_USER_INFO *Info;\r
1123\r
1124 if (mUserInfo.AccessPolicy != NULL) {\r
1125 FreePool (mUserInfo.AccessPolicy);\r
1126 }\r
1127 mUserInfo.AccessPolicy = NULL;\r
1128 mUserInfo.AccessPolicyLen = 0;\r
1129 mUserInfo.AccessPolicyModified = TRUE;\r
1130 OffSet = 0;\r
1131 \r
1132 //\r
1133 // Save access right.\r
1134 //\r
1135 Size = sizeof (EFI_USER_INFO_ACCESS_CONTROL);\r
1136 if (mUserInfo.AccessPolicyLen - OffSet < Size) {\r
1137 ExpandMemory (OffSet, Size);\r
1138 }\r
1139\r
1140 Control.Type = mAccessInfo.AccessRight;\r
1141 Control.Size = (UINT32) Size;\r
1142 CopyMem (mUserInfo.AccessPolicy + OffSet, &Control, sizeof (Control));\r
1143 OffSet += sizeof (Control);\r
1144 \r
1145 //\r
1146 // Save access setup.\r
1147 //\r
1148 Size = sizeof (EFI_USER_INFO_ACCESS_CONTROL) + sizeof (EFI_GUID);\r
1149 if (mUserInfo.AccessPolicyLen - OffSet < Size) {\r
1150 ExpandMemory (OffSet, Size);\r
1151 }\r
1152\r
1153 Control.Type = EFI_USER_INFO_ACCESS_SETUP;\r
1154 Control.Size = (UINT32) Size; \r
1155 CopyMem (mUserInfo.AccessPolicy + OffSet, &Control, sizeof (Control));\r
1156 OffSet += sizeof (Control);\r
1157 \r
1158 if (mAccessInfo.AccessSetup == ACCESS_SETUP_NORMAL) {\r
1159 CopyGuid ((EFI_GUID *) (mUserInfo.AccessPolicy + OffSet), &gEfiUserInfoAccessSetupNormalGuid);\r
1160 } else if (mAccessInfo.AccessSetup == ACCESS_SETUP_RESTRICTED) {\r
1161 CopyGuid ((EFI_GUID *) (mUserInfo.AccessPolicy + OffSet), &gEfiUserInfoAccessSetupRestrictedGuid);\r
1162 } else if (mAccessInfo.AccessSetup == ACCESS_SETUP_ADMIN) {\r
1163 CopyGuid ((EFI_GUID *) (mUserInfo.AccessPolicy + OffSet), &gEfiUserInfoAccessSetupAdminGuid);\r
1164 }\r
1165 OffSet += sizeof (EFI_GUID);\r
1166 \r
1167 //\r
1168 // Save access of boot order.\r
1169 //\r
1170 Size = sizeof (EFI_USER_INFO_ACCESS_CONTROL) + sizeof (UINT32);\r
1171 if (mUserInfo.AccessPolicyLen - OffSet < Size) {\r
1172 ExpandMemory (OffSet, Size);\r
1173 }\r
1174\r
1175 Control.Type = EFI_USER_INFO_ACCESS_BOOT_ORDER;\r
1176 Control.Size = (UINT32) Size; \r
1177 CopyMem (mUserInfo.AccessPolicy + OffSet, &Control, sizeof (Control));\r
1178 OffSet += sizeof (Control);\r
1179\r
1180 CopyMem ((UINT8 *) (mUserInfo.AccessPolicy + OffSet), &mAccessInfo.AccessBootOrder, sizeof (UINT32));\r
1181 OffSet += sizeof (UINT32);\r
1182 \r
1183 //\r
1184 // Save permit load.\r
1185 //\r
1186 if (mAccessInfo.LoadPermitLen > 0) {\r
1187 Size = sizeof (EFI_USER_INFO_ACCESS_CONTROL) + mAccessInfo.LoadPermitLen;\r
1188 if (mUserInfo.AccessPolicyLen - OffSet < Size) {\r
1189 ExpandMemory (OffSet, Size);\r
1190 }\r
1191\r
1192 Control.Type = EFI_USER_INFO_ACCESS_PERMIT_LOAD;\r
1193 Control.Size = (UINT32) Size; \r
1194 CopyMem (mUserInfo.AccessPolicy + OffSet, &Control, sizeof (Control));\r
1195 OffSet += sizeof (Control);\r
1196 \r
1197 CopyMem (mUserInfo.AccessPolicy + OffSet, mAccessInfo.LoadPermit, mAccessInfo.LoadPermitLen);\r
1198 OffSet += mAccessInfo.LoadPermitLen;\r
1199 }\r
1200 \r
1201 //\r
1202 // Save forbid load.\r
1203 //\r
1204 if (mAccessInfo.LoadForbidLen > 0) {\r
1205 Size = sizeof (EFI_USER_INFO_ACCESS_CONTROL) + mAccessInfo.LoadForbidLen;\r
1206 if (mUserInfo.AccessPolicyLen - OffSet < Size) {\r
1207 ExpandMemory (OffSet, Size);\r
1208 }\r
1209\r
1210 Control.Type = EFI_USER_INFO_ACCESS_FORBID_LOAD;\r
1211 Control.Size = (UINT32) Size; \r
1212 CopyMem (mUserInfo.AccessPolicy + OffSet, &Control, sizeof (Control));\r
1213 OffSet += sizeof (Control);\r
1214 \r
1215 CopyMem (mUserInfo.AccessPolicy + OffSet, mAccessInfo.LoadForbid, mAccessInfo.LoadForbidLen);\r
1216 OffSet += mAccessInfo.LoadForbidLen;\r
1217 }\r
1218 \r
1219 //\r
1220 // Save permit connect.\r
1221 //\r
1222 if (mAccessInfo.ConnectPermitLen > 0) {\r
1223 Size = sizeof (EFI_USER_INFO_ACCESS_CONTROL) + mAccessInfo.ConnectPermitLen;\r
1224 if (mUserInfo.AccessPolicyLen - OffSet < Size) {\r
1225 ExpandMemory (OffSet, Size);\r
1226 }\r
1227\r
1228 Control.Type = EFI_USER_INFO_ACCESS_PERMIT_CONNECT;\r
1229 Control.Size = (UINT32) Size; \r
1230 CopyMem (mUserInfo.AccessPolicy + OffSet, &Control, sizeof (Control));\r
1231 OffSet += sizeof (Control);\r
1232 \r
1233 CopyMem (mUserInfo.AccessPolicy + OffSet, mAccessInfo.ConnectPermit, mAccessInfo.ConnectPermitLen);\r
1234 OffSet += mAccessInfo.ConnectPermitLen;\r
1235 }\r
1236 \r
1237 //\r
1238 // Save forbid connect.\r
1239 //\r
1240 if (mAccessInfo.ConnectForbidLen > 0) {\r
1241 Size = sizeof (EFI_USER_INFO_ACCESS_CONTROL) + mAccessInfo.ConnectForbidLen;\r
1242 if (mUserInfo.AccessPolicyLen - OffSet < Size) {\r
1243 ExpandMemory (OffSet, Size);\r
1244 }\r
1245\r
1246 Control.Type = EFI_USER_INFO_ACCESS_FORBID_CONNECT;\r
1247 Control.Size = (UINT32) Size; \r
1248 CopyMem (mUserInfo.AccessPolicy + OffSet, &Control, sizeof (Control));\r
1249 OffSet += sizeof (Control);\r
1250 \r
1251 CopyMem (mUserInfo.AccessPolicy + OffSet, mAccessInfo.ConnectForbid, mAccessInfo.ConnectForbidLen);\r
1252 OffSet += mAccessInfo.ConnectForbidLen;\r
1253 }\r
1254\r
1255 mUserInfo.AccessPolicyLen = OffSet;\r
1256\r
1257 //\r
1258 // Save access policy.\r
1259 //\r
1260 if (mUserInfo.AccessPolicyModified && (mUserInfo.AccessPolicyLen > 0)) {\r
1261 Info = AllocateZeroPool (sizeof (EFI_USER_INFO) + mUserInfo.AccessPolicyLen);\r
1262 if (Info == NULL) {\r
1263 return ;\r
1264 }\r
1265\r
1266 Status = FindInfoByType (EFI_USER_INFO_ACCESS_POLICY_RECORD, &UserInfo);\r
1267 if (!EFI_ERROR (Status)) {\r
1268 Info->InfoType = EFI_USER_INFO_ACCESS_POLICY_RECORD;\r
1269 Info->InfoAttribs = EFI_USER_INFO_STORAGE_PLATFORM_NV |\r
1270 EFI_USER_INFO_PUBLIC |\r
1271 EFI_USER_INFO_EXCLUSIVE;\r
1272 Info->InfoSize = (UINT32) (sizeof (EFI_USER_INFO) + mUserInfo.AccessPolicyLen);\r
1273 CopyMem ((UINT8 *) (Info + 1), mUserInfo.AccessPolicy, mUserInfo.AccessPolicyLen);\r
1274 Status = mUserManager->SetInfo (\r
1275 mUserManager,\r
1276 mModifyUser,\r
1277 &UserInfo,\r
1278 Info,\r
1279 Info->InfoSize\r
1280 );\r
1281 mUserInfo.AccessPolicyModified = FALSE;\r
1282 }\r
1283 FreePool (Info);\r
1284 }\r
1285\r
1286 if (mAccessInfo.ConnectForbid != NULL) {\r
1287 FreePool (mAccessInfo.ConnectForbid);\r
1288 mAccessInfo.ConnectForbid = NULL;\r
1289 }\r
1290\r
1291 if (mAccessInfo.ConnectPermit != NULL) {\r
1292 FreePool (mAccessInfo.ConnectPermit);\r
1293 mAccessInfo.ConnectPermit = NULL;\r
1294 }\r
1295\r
1296 if (mAccessInfo.LoadForbid != NULL) {\r
1297 FreePool (mAccessInfo.LoadForbid);\r
1298 mAccessInfo.LoadForbid = NULL;\r
1299 }\r
1300\r
1301 if (mAccessInfo.LoadPermit != NULL) {\r
1302 FreePool (mAccessInfo.LoadPermit);\r
1303 mAccessInfo.LoadPermit = NULL;\r
1304 }\r
1305}\r
1306\r
1307\r
1308/**\r
1309 Get the username from user input, and update username string in the Hii \r
1310 database with it.\r
1311\r
1312**/\r
1313VOID\r
1314ModifyUserName (\r
1315 VOID\r
1316 )\r
1317{\r
1318 EFI_STATUS Status;\r
1319 CHAR16 UserName[USER_NAME_LENGTH];\r
1320 UINTN Len;\r
1321 EFI_INPUT_KEY Key;\r
1322 EFI_USER_INFO_HANDLE UserInfo;\r
1323 EFI_USER_INFO *Info;\r
1324 EFI_USER_PROFILE_HANDLE TempUser;\r
1325\r
1326 //\r
1327 // Get the new user name.\r
1328 //\r
1329 Len = sizeof (UserName);\r
1330 Status = GetUserNameInput (&Len, UserName);\r
1331 if (EFI_ERROR (Status)) {\r
1332 if (Status != EFI_ABORTED) {\r
1333 CreatePopUp (\r
1334 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
1335 &Key,\r
1336 L"Failed To Get User Name.",\r
1337 L"",\r
1338 L"Please Press Any Key to Continue ...",\r
1339 NULL\r
1340 );\r
1341 }\r
1342 return ;\r
1343 }\r
1344 \r
1345 //\r
1346 // Check whether the username had been used or not.\r
1347 //\r
1348 Info = AllocateZeroPool (sizeof (EFI_USER_INFO) + Len);\r
1349 if (Info == NULL) {\r
1350 return ;\r
1351 }\r
1352\r
1353 Info->InfoType = EFI_USER_INFO_NAME_RECORD;\r
1354 Info->InfoAttribs = EFI_USER_INFO_STORAGE_PLATFORM_NV |\r
1355 EFI_USER_INFO_PUBLIC |\r
1356 EFI_USER_INFO_EXCLUSIVE;\r
1357 Info->InfoSize = (UINT32) (sizeof (EFI_USER_INFO) + Len);\r
1358 CopyMem ((UINT8 *) (Info + 1), UserName, Len);\r
1359\r
1360 TempUser = NULL;\r
1361 Status = mUserManager->Find (\r
1362 mUserManager,\r
1363 &TempUser,\r
1364 NULL,\r
1365 Info,\r
1366 Info->InfoSize\r
1367 );\r
1368 if (!EFI_ERROR (Status)) {\r
1369 CreatePopUp (\r
1370 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
1371 &Key,\r
1372 L"The User Name Had Been Used.",\r
1373 L"",\r
1374 L"Please Use Other User Name",\r
1375 NULL\r
1376 );\r
1377 FreePool (Info);\r
1378 return ;\r
1379 }\r
1380 \r
1381 //\r
1382 // Update username display in the form.\r
1383 //\r
1384 CopyMem (mUserInfo.UserName, UserName, Len);\r
1385 HiiSetString (\r
1386 mCallbackInfo->HiiHandle, \r
1387 STRING_TOKEN (STR_USER_NAME_VAL), \r
1388 mUserInfo.UserName, \r
1389 NULL\r
1390 );\r
1391\r
1392 //\r
1393 // Save the user name.\r
1394 //\r
1395 Status = FindInfoByType (EFI_USER_INFO_NAME_RECORD, &UserInfo);\r
1396 if (!EFI_ERROR (Status)) {\r
1397 mUserManager->SetInfo (\r
1398 mUserManager,\r
1399 mModifyUser,\r
1400 &UserInfo,\r
1401 Info,\r
1402 Info->InfoSize\r
1403 );\r
1404 }\r
1405 FreePool (Info);\r
1406}\r
1407\r
1408\r
1409/**\r
1410 Display the form of the modifying user identity policy.\r
1411\r
1412**/\r
1413VOID\r
1414ModifyIdentityPolicy (\r
1415 VOID\r
1416 )\r
1417{\r
1418 UINTN Index;\r
1419 CHAR16 *ProvStr;\r
1420 EFI_STRING_ID ProvID;\r
1421 EFI_HII_HANDLE HiiHandle;\r
1422 VOID *OptionsOpCodeHandle;\r
1423 VOID *StartOpCodeHandle;\r
1424 VOID *EndOpCodeHandle;\r
1425 EFI_IFR_GUID_LABEL *StartLabel;\r
1426 EFI_IFR_GUID_LABEL *EndLabel;\r
1427\r
1428 //\r
1429 // Initialize the container for dynamic opcodes.\r
1430 //\r
1431 StartOpCodeHandle = HiiAllocateOpCodeHandle ();\r
1432 ASSERT (StartOpCodeHandle != NULL);\r
1433\r
1434 EndOpCodeHandle = HiiAllocateOpCodeHandle ();\r
1435 ASSERT (EndOpCodeHandle != NULL);\r
1436\r
1437 //\r
1438 // Create Hii Extend Label OpCode.\r
1439 //\r
1440 StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (\r
1441 StartOpCodeHandle,\r
1442 &gEfiIfrTianoGuid,\r
1443 NULL,\r
1444 sizeof (EFI_IFR_GUID_LABEL)\r
1445 );\r
1446 StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
1447 StartLabel->Number = LABEL_IP_MOD_FUNC;\r
1448\r
1449 EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (\r
1450 EndOpCodeHandle,\r
1451 &gEfiIfrTianoGuid,\r
1452 NULL,\r
1453 sizeof (EFI_IFR_GUID_LABEL)\r
1454 );\r
1455 EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
1456 EndLabel->Number = LABEL_END;\r
1457\r
1458 //\r
1459 // Add credential providers\r
1460 //.\r
1461 if (mProviderInfo->Count > 0) {\r
1462 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();\r
1463 ASSERT (OptionsOpCodeHandle != NULL);\r
1464\r
1465 //\r
1466 // Add credential provider Option OpCode.\r
1467 //\r
1468 for (Index = 0; Index < mProviderInfo->Count; Index++) {\r
1469 mProviderInfo->Provider[Index]->Title (\r
1470 mProviderInfo->Provider[Index],\r
1471 &HiiHandle,\r
1472 &ProvID\r
1473 );\r
1474 ProvStr = HiiGetString (HiiHandle, ProvID, NULL);\r
1475 ProvID = HiiSetString (mCallbackInfo->HiiHandle, 0, ProvStr, NULL);\r
1476 FreePool (ProvStr);\r
1477 if (ProvID == 0) {\r
1478 return ;\r
1479 }\r
1480\r
1481 HiiCreateOneOfOptionOpCode (\r
1482 OptionsOpCodeHandle,\r
1483 ProvID,\r
1484 0,\r
1485 EFI_IFR_NUMERIC_SIZE_1,\r
1486 (UINT8) Index\r
1487 );\r
1488 }\r
1489\r
1490 HiiCreateOneOfOpCode (\r
1491 StartOpCodeHandle, // Container for dynamic created opcodes\r
1492 KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_IP | KEY_MODIFY_PROV, // Question ID\r
1493 0, // VarStore ID\r
1494 0, // Offset in Buffer Storage\r
1495 STRING_TOKEN (STR_PROVIDER), // Question prompt text\r
1496 STRING_TOKEN (STR_PROVIDER_HELP), // Question help text\r
1497 EFI_IFR_FLAG_CALLBACK, // Question flag\r
1498 EFI_IFR_NUMERIC_SIZE_1, // Data type of Question Value\r
1499 OptionsOpCodeHandle, // Option Opcode list\r
1500 NULL // Default Opcode is NULl\r
1501 );\r
1502\r
1503 HiiFreeOpCodeHandle (OptionsOpCodeHandle);\r
1504 }\r
1505 \r
1506 //\r
1507 // Add logical connector Option OpCode.\r
1508 //\r
1509 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();\r
1510 ASSERT (OptionsOpCodeHandle != NULL);\r
1511\r
1512 HiiCreateOneOfOptionOpCode (\r
1513 OptionsOpCodeHandle,\r
1514 STRING_TOKEN (STR_AND_CON),\r
1515 0,\r
1516 EFI_IFR_NUMERIC_SIZE_1,\r
1517 0\r
1518 );\r
1519\r
1520 HiiCreateOneOfOptionOpCode (\r
1521 OptionsOpCodeHandle,\r
1522 STRING_TOKEN (STR_OR_CON),\r
1523 0,\r
1524 EFI_IFR_NUMERIC_SIZE_1,\r
1525 1\r
1526 );\r
1527\r
1528 HiiCreateOneOfOpCode (\r
1529 StartOpCodeHandle, // Container for dynamic created opcodes\r
1530 KEY_MODIFY_USER | KEY_SELECT_USER | KEY_MODIFY_IP | KEY_MODIFY_CONN, // Question ID\r
1531 0, // VarStore ID\r
1532 0, // Offset in Buffer Storage\r
1533 STRING_TOKEN (STR_CONNECTOR), // Question prompt text\r
1534 STRING_TOKEN (STR_CONNECTOR_HELP), // Question help text\r
1535 EFI_IFR_FLAG_CALLBACK, // Question flag\r
1536 EFI_IFR_NUMERIC_SIZE_1, // Data type of Question Value\r
1537 OptionsOpCodeHandle, // Option Opcode list\r
1538 NULL // Default Opcode is NULl\r
1539 );\r
1540\r
1541 HiiFreeOpCodeHandle (OptionsOpCodeHandle);\r
1542\r
1543 //\r
1544 // Update identity policy in the form.\r
1545 //\r
1546 ResolveIdentityPolicy (\r
1547 mUserInfo.IdentityPolicy, \r
1548 mUserInfo.IdentityPolicyLen, \r
1549 STRING_TOKEN (STR_IDENTIFY_POLICY_VALUE)\r
1550 );\r
1551\r
1552 if (mUserInfo.NewIdentityPolicy != NULL) {\r
1553 FreePool (mUserInfo.NewIdentityPolicy);\r
1554 mUserInfo.NewIdentityPolicy = NULL;\r
1555 mUserInfo.NewIdentityPolicyLen = 0;\r
1556 mUserInfo.NewIdentityPolicyModified = FALSE;\r
1557 }\r
1558 mProviderChoice = 0;\r
1559 mConncetLogical = 0;\r
1560\r
1561 HiiUpdateForm (\r
1562 mCallbackInfo->HiiHandle, // HII handle\r
a0c56a82 1563 &gUserProfileManagerGuid, // Formset GUID\r
0c18794e 1564 FORMID_MODIFY_IP, // Form ID\r
1565 StartOpCodeHandle, // Label for where to insert opcodes\r
1566 EndOpCodeHandle // Replace data\r
1567 );\r
1568\r
1569 HiiFreeOpCodeHandle (StartOpCodeHandle);\r
1570 HiiFreeOpCodeHandle (EndOpCodeHandle);\r
1571}\r
1572\r
1573\r
1574/**\r
1575 Save the identity policy and update UI with it.\r
1576 \r
1577 This funciton will verify the new identity policy, in current implementation, \r
1578 the identity policy can be: T, P & P & P & ..., P | P | P | ...\r
1579 Here, "T" means "True", "P" means "Credential Provider", "&" means "and", "|" means "or".\r
1580 Other identity policies are not supported. \r
1581\r
1582**/\r
1583VOID\r
1584SaveIdentityPolicy (\r
1585 VOID\r
1586 )\r
1587{\r
1588 EFI_STATUS Status;\r
1589 EFI_USER_INFO_IDENTITY_POLICY *Identity;\r
1590 EFI_USER_INFO_HANDLE UserInfo;\r
1591 EFI_USER_INFO *Info;\r
1592 EFI_INPUT_KEY Key;\r
1593 UINTN Offset;\r
1594 UINT32 OpCode;\r
1595 UINTN InfoSize;\r
1596\r
1597 if (!mUserInfo.NewIdentityPolicyModified || (mUserInfo.NewIdentityPolicyLen == 0)) {\r
1598 return;\r
1599 }\r
1600 \r
1601 //\r
1602 // Check policy expression.\r
1603 //\r
1604 OpCode = EFI_USER_INFO_IDENTITY_FALSE;\r
1605 Offset = 0;\r
1606 while (Offset < mUserInfo.NewIdentityPolicyLen) {\r
1607 //\r
1608 // Check access policy according to type\r
1609 //\r
1610 Identity = (EFI_USER_INFO_IDENTITY_POLICY *) (mUserInfo.NewIdentityPolicy + Offset);\r
1611 switch (Identity->Type) {\r
1612\r
1613 case EFI_USER_INFO_IDENTITY_TRUE:\r
1614 break;\r
1615\r
1616 case EFI_USER_INFO_IDENTITY_OR:\r
1617 if (OpCode == EFI_USER_INFO_IDENTITY_AND) {\r
1618 CreatePopUp (\r
1619 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
1620 &Key,\r
1621 L"Invalid Identity Policy, Mixed Connector Unsupport!",\r
1622 L"",\r
1623 L"Press Any Key to Continue ...",\r
1624 NULL\r
1625 );\r
1626 return ;\r
1627 }\r
1628\r
1629 OpCode = EFI_USER_INFO_IDENTITY_OR;\r
1630 break;\r
1631\r
1632 case EFI_USER_INFO_IDENTITY_AND:\r
1633 if (OpCode == EFI_USER_INFO_IDENTITY_OR) {\r
1634 CreatePopUp (\r
1635 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
1636 &Key,\r
1637 L"Invalid Identity Policy, Mixed Connector Unsupport!",\r
1638 L"",\r
1639 L"Press Any Key to Continue ...",\r
1640 NULL\r
1641 );\r
1642 return ;\r
1643 }\r
1644\r
1645 OpCode = EFI_USER_INFO_IDENTITY_AND;\r
1646 break;\r
1647\r
1648 case EFI_USER_INFO_IDENTITY_CREDENTIAL_PROVIDER:\r
1649 break;\r
1650\r
1651 default:\r
1652 CreatePopUp (\r
1653 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
1654 &Key,\r
1655 L"Unsupport parameter",\r
1656 L"",\r
1657 L"Press Any Key to Continue ...",\r
1658 NULL\r
1659 );\r
1660 return ;\r
1661 }\r
1662 Offset += Identity->Length;\r
1663 }\r
1664\r
1665 //\r
1666 // Save identity policy.\r
1667 //\r
1668 Info = AllocateZeroPool (\r
1669 sizeof (EFI_USER_INFO) + \r
1670 mUserInfo.NewIdentityPolicyLen\r
1671 );\r
1672 if (Info == NULL) {\r
1673 return ;\r
1674 }\r
1675\r
1676 Status = FindInfoByType (EFI_USER_INFO_IDENTITY_POLICY_RECORD, &UserInfo);\r
1677 if (EFI_ERROR (Status)) {\r
1678 FreePool (Info);\r
1679 return ;\r
1680 }\r
1681 \r
1682 Info->InfoType = EFI_USER_INFO_IDENTITY_POLICY_RECORD;\r
1683 Info->InfoAttribs = EFI_USER_INFO_STORAGE_PLATFORM_NV |\r
1684 EFI_USER_INFO_PRIVATE |\r
1685 EFI_USER_INFO_EXCLUSIVE;\r
1686 Info->InfoSize = (UINT32) (sizeof (EFI_USER_INFO) + mUserInfo.NewIdentityPolicyLen);\r
1687 CopyMem ((UINT8 *) (Info + 1), mUserInfo.NewIdentityPolicy, mUserInfo.NewIdentityPolicyLen);\r
1688 Status = mUserManager->SetInfo (\r
1689 mUserManager,\r
1690 mModifyUser,\r
1691 &UserInfo,\r
1692 Info,\r
1693 Info->InfoSize\r
1694 );\r
1695 FreePool (Info); \r
1696 if (EFI_ERROR (Status)) {\r
1697 //\r
1698 // Get the user information again, it may be changed during saving it.\r
1699 //\r
1700 InfoSize = 0;\r
1701 Status = mUserManager->GetInfo (\r
1702 mUserManager,\r
1703 mModifyUser,\r
1704 UserInfo,\r
1705 Info,\r
1706 &InfoSize\r
1707 );\r
1708 if (Status == EFI_BUFFER_TOO_SMALL) {\r
1709 Info = AllocateZeroPool (InfoSize);\r
1710 ASSERT (Info != NULL);\r
1711 Status = mUserManager->GetInfo (\r
1712 mUserManager,\r
1713 mModifyUser,\r
1714 UserInfo,\r
1715 Info,\r
1716 &InfoSize\r
1717 );\r
1718 }\r
1719 ASSERT_EFI_ERROR (Status);\r
1720 \r
1721 //\r
1722 // Save current identification policy to mUserInfo.IdentityPolicy. \r
1723 //\r
1724 ASSERT (Info != NULL);\r
1725 if (mUserInfo.IdentityPolicy != NULL) {\r
1726 FreePool (mUserInfo.IdentityPolicy);\r
1727 }\r
1728\r
1729 mUserInfo.IdentityPolicyLen = Info->InfoSize - sizeof (EFI_USER_INFO);\r
1730 mUserInfo.IdentityPolicy = AllocateCopyPool (mUserInfo.IdentityPolicyLen, Info + 1); \r
1731 ASSERT (mUserInfo.IdentityPolicy != NULL); \r
1732\r
1733 //\r
1734 // Free the memory\r
1735 //\r
1736 FreePool (Info);\r
1737 FreePool (mUserInfo.NewIdentityPolicy);\r
1738 } else { \r
1739 //\r
1740 // Update the mUserInfo.IdentityPolicy by mUserInfo.NewIdentityPolicy\r
1741 //\r
1742 if (mUserInfo.IdentityPolicy != NULL) {\r
1743 FreePool (mUserInfo.IdentityPolicy);\r
1744 }\r
1745 mUserInfo.IdentityPolicy = mUserInfo.NewIdentityPolicy;\r
1746 mUserInfo.IdentityPolicyLen = mUserInfo.NewIdentityPolicyLen;\r
1747 }\r
1748\r
1749 mUserInfo.NewIdentityPolicy = NULL;\r
1750 mUserInfo.NewIdentityPolicyLen = 0;\r
1751 mUserInfo.NewIdentityPolicyModified = FALSE; \r
1752\r
1753 //\r
1754 // Update identity policy choice.\r
1755 //\r
1756 ResolveIdentityPolicy (\r
1757 mUserInfo.IdentityPolicy, \r
1758 mUserInfo.IdentityPolicyLen, \r
1759 STRING_TOKEN (STR_IDENTIFY_POLICY_VAL)\r
1760 );\r
1761}\r
1762\r
1763\r
1764/**\r
1765 Verify the new identity policy in the current implementation. The same credential\r
1766 provider can't appear twice in one identity policy.\r
1767\r
1768 @param[in] NewGuid Points to the credential provider guid.\r
1769 \r
1770 @retval TRUE The NewGuid was found in the identity policy.\r
1771 @retval FALSE The NewGuid was not found.\r
1772\r
1773**/\r
1774BOOLEAN\r
1775CheckIdentityPolicy (\r
1776 IN EFI_GUID *NewGuid\r
1777 )\r
1778{\r
1779 UINTN Offset;\r
1780 EFI_USER_INFO_IDENTITY_POLICY *Identity;\r
1781 EFI_INPUT_KEY Key;\r
1782\r
1783 Offset = 0;\r
1784 while (Offset < mUserInfo.NewIdentityPolicyLen) {\r
1785 //\r
1786 // Check access policy according to type.\r
1787 //\r
1788 Identity = (EFI_USER_INFO_IDENTITY_POLICY *) (mUserInfo.NewIdentityPolicy + Offset);\r
1789 switch (Identity->Type) {\r
1790\r
1791 case EFI_USER_INFO_IDENTITY_TRUE:\r
1792 case EFI_USER_INFO_IDENTITY_OR:\r
1793 case EFI_USER_INFO_IDENTITY_AND:\r
1794 break;\r
1795\r
1796 case EFI_USER_INFO_IDENTITY_CREDENTIAL_PROVIDER:\r
1797 if (CompareGuid (NewGuid, (EFI_GUID *) (Identity + 1))) {\r
1798 CreatePopUp (\r
1799 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
1800 &Key,\r
1801 L"This Credential Provider Are Already Used!",\r
1802 L"",\r
1803 L"Press Any Key to Continue ...",\r
1804 NULL\r
1805 );\r
1806 return FALSE;\r
1807 }\r
1808 break;\r
1809\r
1810 default:\r
1811 CreatePopUp (\r
1812 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
1813 &Key,\r
1814 L"Unsupport parameter",\r
1815 L"",\r
1816 L"Press Any Key to Continue ...",\r
1817 NULL\r
1818 );\r
1819 return FALSE;\r
1820 }\r
1821\r
1822 Offset += Identity->Length;\r
1823 }\r
1824 return TRUE;\r
1825}\r
1826\r
1827\r
1828/**\r
1829 Update the mUserInfo.NewIdentityPolicy, and UI when 'add option' is pressed.\r
1830\r
1831**/\r
1832VOID\r
1833AddIdentityPolicyItem (\r
1834 VOID\r
1835 )\r
1836{\r
1837 UINT8 *NewInfo;\r
1838 EFI_USER_INFO_IDENTITY_POLICY *Policy;\r
1839\r
1840 if (mProviderInfo->Count == 0) {\r
1841 return ;\r
1842 }\r
1843\r
1844 if (!mUserInfo.NewIdentityPolicyModified && (mUserInfo.NewIdentityPolicyLen > 0)) {\r
1845 FreePool (mUserInfo.NewIdentityPolicy);\r
1846 mUserInfo.NewIdentityPolicy = NULL;\r
1847 mUserInfo.NewIdentityPolicyLen = 0;\r
1848 }\r
1849 //\r
1850 // Expand the identity policy memory for the newly added policy info.\r
1851 //\r
1852 if (mUserInfo.NewIdentityPolicyLen > 0) {\r
1853 //\r
1854 // The new policy is not empty, expand space for connetor and provider.\r
1855 //\r
1856 if (!CheckIdentityPolicy (&mProviderInfo->Provider[mProviderChoice]->Identifier)) {\r
1857 return ;\r
1858 }\r
1859 NewInfo = AllocateZeroPool (\r
1860 mUserInfo.NewIdentityPolicyLen + \r
1861 sizeof (EFI_USER_INFO_IDENTITY_POLICY) * 2 + \r
1862 sizeof (EFI_GUID)\r
1863 );\r
1864 } else {\r
1865 //\r
1866 // The new policy is empty, only expand space for provider.\r
1867 //\r
1868 NewInfo = AllocateZeroPool (\r
1869 mUserInfo.NewIdentityPolicyLen + \r
1870 sizeof (EFI_USER_INFO_IDENTITY_POLICY) + \r
1871 sizeof (EFI_GUID)\r
1872 );\r
1873 }\r
1874\r
1875 if (NewInfo == NULL) {\r
1876 return ;\r
1877 }\r
1878\r
1879 if (mUserInfo.NewIdentityPolicyLen > 0) {\r
1880 CopyMem (NewInfo, mUserInfo.NewIdentityPolicy, mUserInfo.NewIdentityPolicyLen);\r
1881 FreePool (mUserInfo.NewIdentityPolicy);\r
1882 }\r
1883 mUserInfo.NewIdentityPolicy = NewInfo;\r
1884\r
1885 //\r
1886 // Save logical connector.\r
1887 //\r
1888 if (mUserInfo.NewIdentityPolicyLen > 0) {\r
1889 Policy = (EFI_USER_INFO_IDENTITY_POLICY *) (mUserInfo.NewIdentityPolicy +\r
1890 mUserInfo.NewIdentityPolicyLen);\r
1891 if (mConncetLogical == 0) {\r
1892 Policy->Type = EFI_USER_INFO_IDENTITY_AND;\r
1893 } else {\r
1894 Policy->Type = EFI_USER_INFO_IDENTITY_OR;\r
1895 }\r
1896\r
1897 Policy->Length = sizeof (EFI_USER_INFO_IDENTITY_POLICY);\r
1898 mUserInfo.NewIdentityPolicyLen += Policy->Length;\r
1899 }\r
1900 \r
1901 //\r
1902 // Save credential provider.\r
1903 //\r
1904 Policy = (EFI_USER_INFO_IDENTITY_POLICY *) (mUserInfo.NewIdentityPolicy + \r
1905 mUserInfo.NewIdentityPolicyLen);\r
1906 Policy->Length = sizeof (EFI_USER_INFO_IDENTITY_POLICY) + sizeof (EFI_GUID);\r
1907 Policy->Type = EFI_USER_INFO_IDENTITY_CREDENTIAL_PROVIDER;\r
1908 CopyGuid ((EFI_GUID *) (Policy + 1), &mProviderInfo->Provider[mProviderChoice]->Identifier);\r
1909 mUserInfo.NewIdentityPolicyLen += Policy->Length;\r
1910\r
1911 //\r
1912 // Update identity policy choice.\r
1913 //\r
1914 mUserInfo.NewIdentityPolicyModified = TRUE;\r
1915 ResolveIdentityPolicy (\r
1916 mUserInfo.NewIdentityPolicy, \r
1917 mUserInfo.NewIdentityPolicyLen, \r
1918 STRING_TOKEN (STR_IDENTIFY_POLICY_VALUE)\r
1919 );\r
1920}\r
1921\r
1922\r
1923/**\r
1924 Create an action OpCode with QuestionID and DevicePath on a given OpCodeHandle.\r
1925\r
1926 @param[in] QuestionID The question ID.\r
1927 @param[in] DevicePath Points to device path.\r
1928 @param[in] OpCodeHandle Points to container for dynamic created opcodes.\r
1929\r
1930**/\r
1931VOID\r
1932AddDevicePath (\r
1933 IN UINTN QuestionID,\r
1934 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,\r
1935 IN VOID *OpCodeHandle\r
1936 )\r
1937{\r
1938 EFI_STATUS Status;\r
1939 EFI_DEVICE_PATH_PROTOCOL *Next;\r
1940 EFI_STRING_ID NameID;\r
1941 EFI_STRING DriverName;\r
1942 EFI_DEVICE_PATH_TO_TEXT_PROTOCOL *DevicePathText;\r
1943\r
1944 //\r
1945 // Locate device path to text protocol.\r
1946 //\r
1947 Status = gBS->LocateProtocol (\r
1948 &gEfiDevicePathToTextProtocolGuid,\r
1949 NULL,\r
1950 (VOID **) &DevicePathText\r
1951 );\r
1952 if (EFI_ERROR (Status)) {\r
1953 return ;\r
1954 }\r
1955 \r
1956 //\r
1957 // Get driver file name node.\r
1958 //\r
1959 Next = DevicePath;\r
1960 while (!IsDevicePathEnd (Next)) {\r
1961 DevicePath = Next;\r
1962 Next = NextDevicePathNode (Next);\r
1963 }\r
1964\r
1965 //\r
1966 // Display the device path in form.\r
1967 //\r
1968 DriverName = DevicePathText->ConvertDevicePathToText (DevicePath, FALSE, FALSE);\r
1969 NameID = HiiSetString (mCallbackInfo->HiiHandle, 0, DriverName, NULL);\r
1970 FreePool (DriverName);\r
1971 if (NameID == 0) {\r
1972 return ;\r
1973 }\r
1974\r
1975 HiiCreateActionOpCode (\r
1976 OpCodeHandle, // Container for dynamic created opcodes\r
1977 (UINT16) QuestionID, // Question ID\r
1978 NameID, // Prompt text\r
1979 STRING_TOKEN (STR_NULL_STRING), // Help text\r
1980 EFI_IFR_FLAG_CALLBACK, // Question flag\r
1981 0 // Action String ID\r
1982 );\r
1983}\r
1984\r
1985\r
1986/**\r
1987 Check whether the DevicePath is in the device path forbid list \r
1988 (mAccessInfo.LoadForbid).\r
1989\r
1990 @param[in] DevicePath Points to device path.\r
1991 \r
1992 @retval TRUE The DevicePath is in the device path forbid list.\r
1993 @retval FALSE The DevicePath is not in the device path forbid list.\r
1994\r
1995**/\r
1996BOOLEAN\r
1997IsLoadForbidden (\r
1998 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath\r
1999 )\r
2000{\r
2001 UINTN OffSet;\r
2002 UINTN DPSize;\r
2003 UINTN Size;\r
2004 EFI_DEVICE_PATH_PROTOCOL *Dp;\r
2005\r
2006 OffSet = 0;\r
2007 Size = GetDevicePathSize (DevicePath);\r
2008 //\r
2009 // Check each device path.\r
2010 //\r
2011 while (OffSet < mAccessInfo.LoadForbidLen) {\r
2012 Dp = (EFI_DEVICE_PATH_PROTOCOL *) (mAccessInfo.LoadForbid + OffSet);\r
2013 DPSize = GetDevicePathSize (Dp);\r
2014 //\r
2015 // Compare device path.\r
2016 //\r
2017 if ((DPSize == Size) && (CompareMem (DevicePath, Dp, Size) == 0)) {\r
2018 return TRUE;\r
2019 }\r
2020 OffSet += DPSize;\r
2021 }\r
2022 return FALSE;\r
2023}\r
2024\r
2025\r
2026/**\r
2027 Display the permit load device path in the loadable device path list.\r
2028\r
2029**/\r
2030VOID\r
2031DisplayLoadPermit(\r
2032 VOID\r
2033 )\r
2034{\r
2035 EFI_STATUS Status;\r
2036 CHAR16 *Order;\r
2037 UINTN OrderSize;\r
2038 UINTN ListCount;\r
2039 UINTN Index;\r
2040 UINT8 *Var;\r
2041 UINT8 *VarPtr;\r
2042 CHAR16 VarName[12];\r
2043 VOID *StartOpCodeHandle;\r
2044 VOID *EndOpCodeHandle;\r
2045 EFI_IFR_GUID_LABEL *StartLabel;\r
2046 EFI_IFR_GUID_LABEL *EndLabel;\r
2047\r
2048 //\r
2049 // Get DriverOrder.\r
2050 //\r
2051 OrderSize = 0;\r
2052 Status = gRT->GetVariable (\r
2053 L"DriverOrder", \r
2054 &gEfiGlobalVariableGuid, \r
2055 NULL, \r
2056 &OrderSize, \r
2057 NULL\r
2058 );\r
2059 if (Status != EFI_BUFFER_TOO_SMALL) {\r
2060 return ;\r
2061 }\r
2062\r
2063 Order = AllocateZeroPool (OrderSize);\r
2064 if (Order == NULL) {\r
2065 return ;\r
2066 }\r
2067\r
2068 Status = gRT->GetVariable (\r
2069 L"DriverOrder", \r
2070 &gEfiGlobalVariableGuid, \r
2071 NULL, \r
2072 &OrderSize, \r
2073 Order\r
2074 );\r
2075 if (EFI_ERROR (Status)) {\r
2076 return ;\r
2077 }\r
2078 \r
2079 //\r
2080 // Initialize the container for dynamic opcodes.\r
2081 //\r
2082 StartOpCodeHandle = HiiAllocateOpCodeHandle ();\r
2083 ASSERT (StartOpCodeHandle != NULL);\r
2084\r
2085 EndOpCodeHandle = HiiAllocateOpCodeHandle ();\r
2086 ASSERT (EndOpCodeHandle != NULL);\r
2087\r
2088 //\r
2089 // Create Hii Extend Label OpCode.\r
2090 //\r
2091 StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (\r
2092 StartOpCodeHandle,\r
2093 &gEfiIfrTianoGuid,\r
2094 NULL,\r
2095 sizeof (EFI_IFR_GUID_LABEL)\r
2096 );\r
2097 StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
2098 StartLabel->Number = LABEL_PERMIT_LOAD_FUNC;\r
2099\r
2100 EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (\r
2101 EndOpCodeHandle,\r
2102 &gEfiIfrTianoGuid,\r
2103 NULL,\r
2104 sizeof (EFI_IFR_GUID_LABEL)\r
2105 );\r
2106 EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
2107 EndLabel->Number = LABEL_END;\r
2108\r
2109 //\r
2110 // Add each driver option.\r
2111 //\r
2112 Var = NULL;\r
2113 ListCount = OrderSize / sizeof (UINT16);\r
2114 for (Index = 0; Index < ListCount; Index++) {\r
2115 //\r
2116 // Get driver device path.\r
2117 //\r
2118 UnicodeSPrint (VarName, sizeof (VarName), L"Driver%04x", Order[Index]);\r
2119 Var = GetEfiGlobalVariable (VarName);\r
2120 if (Var == NULL) {\r
2121 continue;\r
2122 }\r
2123 \r
2124 //\r
2125 // Check whether the driver is already forbidden.\r
2126 //\r
2127 \r
2128 VarPtr = Var;\r
2129 //\r
2130 // Skip attribute.\r
2131 //\r
2132 VarPtr += sizeof (UINT32);\r
2133\r
2134 //\r
2135 // Skip device path lenth.\r
2136 //\r
2137 VarPtr += sizeof (UINT16);\r
2138\r
2139 //\r
2140 // Skip descript string.\r
2141 //\r
2142 VarPtr += StrSize ((UINT16 *) VarPtr);\r
2143\r
2144 if (IsLoadForbidden ((EFI_DEVICE_PATH_PROTOCOL *) VarPtr)) {\r
2145 FreePool (Var);\r
2146 Var = NULL;\r
2147 continue;\r
2148 }\r
2149\r
2150 AddDevicePath (\r
2151 KEY_MODIFY_USER | KEY_MODIFY_AP_DP | KEY_LOAD_PERMIT_MODIFY | Order[Index],\r
2152 (EFI_DEVICE_PATH_PROTOCOL *) VarPtr,\r
2153 StartOpCodeHandle\r
2154 );\r
2155 FreePool (Var);\r
2156 Var = NULL;\r
2157 }\r
2158\r
2159 HiiUpdateForm (\r
2160 mCallbackInfo->HiiHandle, // HII handle\r
a0c56a82 2161 &gUserProfileManagerGuid, // Formset GUID\r
0c18794e 2162 FORMID_PERMIT_LOAD_DP, // Form ID\r
2163 StartOpCodeHandle, // Label for where to insert opcodes\r
2164 EndOpCodeHandle // Replace data\r
2165 );\r
2166\r
2167 HiiFreeOpCodeHandle (StartOpCodeHandle);\r
2168 HiiFreeOpCodeHandle (EndOpCodeHandle);\r
2169\r
2170 //\r
2171 // Clear Environment.\r
2172 //\r
2173 if (Var != NULL) {\r
2174 FreePool (Var);\r
2175 }\r
2176 FreePool (Order);\r
2177}\r
2178\r
2179\r
2180/**\r
2181 Display the forbid load device path list (mAccessInfo.LoadForbid).\r
2182\r
2183**/\r
2184VOID\r
2185DisplayLoadForbid (\r
2186 VOID\r
2187 )\r
2188{\r
2189 UINTN Offset;\r
2190 UINTN DPSize;\r
2191 UINTN Index;\r
2192 EFI_DEVICE_PATH_PROTOCOL *Dp;\r
2193 VOID *StartOpCodeHandle;\r
2194 VOID *EndOpCodeHandle;\r
2195 EFI_IFR_GUID_LABEL *StartLabel;\r
2196 EFI_IFR_GUID_LABEL *EndLabel;\r
2197\r
2198 //\r
2199 // Initialize the container for dynamic opcodes.\r
2200 //\r
2201 StartOpCodeHandle = HiiAllocateOpCodeHandle ();\r
2202 ASSERT (StartOpCodeHandle != NULL);\r
2203\r
2204 EndOpCodeHandle = HiiAllocateOpCodeHandle ();\r
2205 ASSERT (EndOpCodeHandle != NULL);\r
2206\r
2207 //\r
2208 // Create Hii Extend Label OpCode.\r
2209 //\r
2210 StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (\r
2211 StartOpCodeHandle,\r
2212 &gEfiIfrTianoGuid,\r
2213 NULL,\r
2214 sizeof (EFI_IFR_GUID_LABEL)\r
2215 );\r
2216 StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
2217 StartLabel->Number = LABLE_FORBID_LOAD_FUNC;\r
2218\r
2219 EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (\r
2220 EndOpCodeHandle,\r
2221 &gEfiIfrTianoGuid,\r
2222 NULL,\r
2223 sizeof (EFI_IFR_GUID_LABEL)\r
2224 );\r
2225 EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
2226 EndLabel->Number = LABEL_END;\r
2227\r
2228 //\r
2229 // Add each forbid load drivers.\r
2230 //\r
2231 Offset = 0;\r
2232 Index = 0;\r
2233 while (Offset < mAccessInfo.LoadForbidLen) {\r
2234 Dp = (EFI_DEVICE_PATH_PROTOCOL *) (mAccessInfo.LoadForbid + Offset);\r
2235 DPSize = GetDevicePathSize (Dp);\r
2236 AddDevicePath (\r
2237 KEY_MODIFY_USER | KEY_MODIFY_AP_DP | KEY_LOAD_FORBID_MODIFY | Index,\r
2238 Dp,\r
2239 StartOpCodeHandle\r
2240 );\r
2241 Index++;\r
2242 Offset += DPSize;\r
2243 }\r
2244\r
2245 HiiUpdateForm (\r
2246 mCallbackInfo->HiiHandle, // HII handle\r
a0c56a82 2247 &gUserProfileManagerGuid, // Formset GUID\r
0c18794e 2248 FORMID_FORBID_LOAD_DP, // Form ID\r
2249 StartOpCodeHandle, // Label for where to insert opcodes\r
2250 EndOpCodeHandle // Replace data\r
2251 );\r
2252\r
2253 HiiFreeOpCodeHandle (StartOpCodeHandle);\r
2254 HiiFreeOpCodeHandle (EndOpCodeHandle);\r
2255}\r
2256\r
2257\r
2258/**\r
2259 Display the permit connect device path.\r
2260\r
2261**/\r
2262VOID\r
2263DisplayConnectPermit (\r
2264 VOID\r
2265 )\r
2266{\r
2267 //\r
2268 // Note: \r
2269 // As no architect protocol/interface to be called in ConnectController()\r
2270 // to verify the device path, just add a place holder for permitted connect\r
2271 // device path.\r
2272 //\r
2273}\r
2274\r
2275\r
2276/**\r
2277 Display the forbid connect device path list.\r
2278\r
2279**/\r
2280VOID\r
2281DisplayConnectForbid (\r
2282 VOID\r
2283 )\r
2284{\r
2285 //\r
2286 // Note: \r
2287 // As no architect protocol/interface to be called in ConnectController()\r
2288 // to verify the device path, just add a place holder for forbidden connect\r
2289 // device path.\r
2290 //\r
2291}\r
2292\r
2293\r
2294/**\r
2295 Delete the specified device path by DriverIndex from the forbid device path \r
2296 list (mAccessInfo.LoadForbid).\r
2297\r
2298 @param[in] DriverIndex The index of driver in forbidden device path list.\r
2299 \r
2300**/\r
2301VOID\r
2302DeleteFromForbidLoad (\r
2303 IN UINT16 DriverIndex\r
2304 )\r
2305{\r
2306 UINTN OffSet;\r
2307 UINTN DPSize;\r
2308 UINTN OffLen;\r
2309 EFI_DEVICE_PATH_PROTOCOL *Dp;\r
2310\r
2311 OffSet = 0;\r
2312 //\r
2313 // Find the specified device path.\r
2314 //\r
2315 while ((OffSet < mAccessInfo.LoadForbidLen) && (DriverIndex > 0)) {\r
2316 Dp = (EFI_DEVICE_PATH_PROTOCOL *) (mAccessInfo.LoadForbid + OffSet);\r
2317 DPSize = GetDevicePathSize (Dp);\r
2318 OffSet += DPSize;\r
2319 DriverIndex--;\r
2320 }\r
2321 \r
2322 //\r
2323 // Specified device path found.\r
2324 //\r
2325 if (DriverIndex == 0) {\r
2326 Dp = (EFI_DEVICE_PATH_PROTOCOL *) (mAccessInfo.LoadForbid + OffSet);\r
2327 DPSize = GetDevicePathSize (Dp);\r
2328 OffLen = mAccessInfo.LoadForbidLen - OffSet - DPSize;\r
2329 if (OffLen > 0) {\r
2330 CopyMem (\r
2331 mAccessInfo.LoadForbid + OffSet, \r
2332 mAccessInfo.LoadForbid + OffSet + DPSize, \r
2333 OffLen\r
2334 );\r
2335 }\r
2336 mAccessInfo.LoadForbidLen -= DPSize;\r
2337 }\r
2338}\r
2339\r
2340\r
2341/**\r
2342 Add the specified device path by DriverIndex to the forbid device path \r
2343 list (mAccessInfo.LoadForbid).\r
2344\r
2345 @param[in] DriverIndex The index of driver saved in driver options.\r
2346 \r
2347**/\r
2348VOID\r
2349AddToForbidLoad (\r
2350 IN UINT16 DriverIndex\r
2351 )\r
2352{\r
2353 UINTN DevicePathLen;\r
2354 UINT8 *Var;\r
2355 UINT8 *VarPtr;\r
2356 UINTN NewLen;\r
2357 UINT8 *NewFL;\r
2358 CHAR16 VarName[13];\r
2359\r
2360 //\r
2361 // Get loadable driver device path.\r
2362 //\r
2363 UnicodeSPrint (VarName, sizeof (VarName), L"Driver%04x", DriverIndex);\r
2364 Var = GetEfiGlobalVariable (VarName);\r
2365 if (Var == NULL) {\r
2366 return;\r
2367 }\r
2368 \r
2369 //\r
2370 // Save forbid load driver.\r
2371 //\r
2372 \r
2373 VarPtr = Var;\r
2374 //\r
2375 // Skip attribute.\r
2376 //\r
2377 VarPtr += sizeof (UINT32);\r
2378\r
2379 DevicePathLen = *(UINT16 *) VarPtr;\r
2380 //\r
2381 // Skip device path length.\r
2382 //\r
2383 VarPtr += sizeof (UINT16);\r
2384\r
2385 //\r
2386 // Skip description string.\r
2387 //\r
2388 VarPtr += StrSize ((UINT16 *) VarPtr);\r
2389\r
2390 NewLen = mAccessInfo.LoadForbidLen + DevicePathLen;\r
2391 NewFL = AllocateZeroPool (NewLen);\r
2392 if (NewFL == NULL) {\r
2393 FreePool (Var);\r
2394 return ;\r
2395 }\r
2396\r
2397 if (mAccessInfo.LoadForbidLen > 0) {\r
2398 CopyMem (NewFL, mAccessInfo.LoadForbid, mAccessInfo.LoadForbidLen);\r
2399 FreePool (mAccessInfo.LoadForbid);\r
2400 }\r
2401\r
2402 CopyMem (NewFL + mAccessInfo.LoadForbidLen, VarPtr, DevicePathLen);\r
2403 mAccessInfo.LoadForbidLen = NewLen;\r
2404 mAccessInfo.LoadForbid = NewFL;\r
2405 FreePool (Var);\r
2406}\r
2407\r
2408\r
2409/**\r
2410 Get current user's access right.\r
2411\r
2412 @param[out] AccessRight Points to the buffer used for user's access right.\r
2413\r
2414 @retval EFI_SUCCESS Get current user access right successfully.\r
2415 @retval others Fail to get current user access right.\r
2416\r
2417**/\r
2418EFI_STATUS\r
2419GetAccessRight (\r
2420 OUT UINT32 *AccessRight\r
2421 )\r
2422{\r
2423 EFI_STATUS Status;\r
2424 EFI_USER_INFO_HANDLE UserInfo;\r
2425 EFI_USER_INFO *Info;\r
2426 UINTN InfoSize;\r
2427 UINTN MemSize;\r
2428 EFI_USER_INFO_ACCESS_CONTROL Access;\r
2429 EFI_USER_PROFILE_HANDLE CurrentUser;\r
2430 UINTN TotalLen;\r
2431 UINTN CheckLen;\r
2432\r
2433 //\r
2434 // Allocate user information memory.\r
2435 //\r
2436 MemSize = sizeof (EFI_USER_INFO) + 63;\r
2437 Info = AllocateZeroPool (MemSize);\r
2438 if (Info == NULL) {\r
2439 return EFI_OUT_OF_RESOURCES;\r
2440 }\r
2441 \r
2442 //\r
2443 // Get user access information.\r
2444 //\r
2445 UserInfo = NULL;\r
2446 mUserManager->Current (mUserManager, &CurrentUser);\r
2447 while (TRUE) {\r
2448 InfoSize = MemSize;\r
2449 //\r
2450 // Get next user information.\r
2451 //\r
2452 Status = mUserManager->GetNextInfo (mUserManager, CurrentUser, &UserInfo);\r
2453 if (EFI_ERROR (Status)) {\r
2454 break;\r
2455 }\r
2456\r
2457 Status = mUserManager->GetInfo (\r
2458 mUserManager,\r
2459 CurrentUser,\r
2460 UserInfo,\r
2461 Info,\r
2462 &InfoSize\r
2463 );\r
2464 if (Status == EFI_BUFFER_TOO_SMALL) {\r
2465 MemSize = InfoSize;\r
2466 FreePool (Info);\r
2467 Info = AllocateZeroPool (MemSize);\r
2468 if (Info == NULL) {\r
2469 return EFI_OUT_OF_RESOURCES;\r
2470 }\r
2471 Status = mUserManager->GetInfo (\r
2472 mUserManager,\r
2473 CurrentUser,\r
2474 UserInfo,\r
2475 Info,\r
2476 &InfoSize\r
2477 );\r
2478 }\r
2479 if (EFI_ERROR (Status)) {\r
2480 break;\r
2481 }\r
2482 \r
2483 //\r
2484 // Check user information.\r
2485 //\r
2486 if (Info->InfoType == EFI_USER_INFO_ACCESS_POLICY_RECORD) {\r
2487 TotalLen = Info->InfoSize - sizeof (EFI_USER_INFO);\r
2488 CheckLen = 0;\r
2489 //\r
2490 // Get specified access information.\r
2491 //\r
2492 while (CheckLen < TotalLen) {\r
2493 CopyMem (&Access, (UINT8 *) (Info + 1) + CheckLen, sizeof (Access));\r
2494 if ((Access.Type == EFI_USER_INFO_ACCESS_ENROLL_SELF) ||\r
2495 (Access.Type == EFI_USER_INFO_ACCESS_ENROLL_OTHERS) ||\r
2496 (Access.Type == EFI_USER_INFO_ACCESS_MANAGE)\r
2497 ) {\r
2498 *AccessRight = Access.Type;\r
2499 FreePool (Info);\r
2500 return EFI_SUCCESS;\r
2501 }\r
2502 CheckLen += Access.Size;\r
2503 }\r
2504 }\r
2505 }\r
2506 FreePool (Info);\r
2507 return EFI_NOT_FOUND;\r
2508}\r
2509\r
2510\r
2511\r
EFI Development Kit II mirror for PVE