]> git.proxmox.com Git - mirror_edk2.git/blob - NetworkPkg/IScsiDxe/IScsiConfig.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
EdkCompatibilityPkg/PrintLite: Fix ErrorPrint() wrong NULL char check
[mirror_edk2.git] / NetworkPkg / IScsiDxe / IScsiConfig.c
1 /** @file
2 Helper functions for configuring or getting the parameters relating to iSCSI.
3
4 Copyright (c) 2004 - 2016, 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 "IScsiImpl.h"
16
17 CHAR16 mVendorStorageName[] = L"ISCSI_CONFIG_IFR_NVDATA";
18 BOOLEAN mIScsiDeviceListUpdated = FALSE;
19 UINTN mNumberOfIScsiDevices = 0;
20 ISCSI_FORM_CALLBACK_INFO *mCallbackInfo = NULL;
21
22 HII_VENDOR_DEVICE_PATH mIScsiHiiVendorDevicePath = {
23 {
24 {
25 HARDWARE_DEVICE_PATH,
26 HW_VENDOR_DP,
27 {
28 (UINT8) (sizeof (VENDOR_DEVICE_PATH)),
29 (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
30 }
31 },
32 ISCSI_CONFIG_GUID
33 },
34 {
35 END_DEVICE_PATH_TYPE,
36 END_ENTIRE_DEVICE_PATH_SUBTYPE,
37 {
38 (UINT8) (END_DEVICE_PATH_LENGTH),
39 (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
40 }
41 }
42 };
43
44
45 /**
46 Convert the IP address into a dotted string.
47
48 @param[in] Ip The IP address.
49 @param[in] Ipv6Flag Indicates whether the IP address is version 4 or version 6.
50 @param[out] Str The formatted IP string.
51
52 **/
53 VOID
54 IScsiIpToStr (
55 IN EFI_IP_ADDRESS *Ip,
56 IN BOOLEAN Ipv6Flag,
57 OUT CHAR16 *Str
58 )
59 {
60 EFI_IPv4_ADDRESS *Ip4;
61 EFI_IPv6_ADDRESS *Ip6;
62 UINTN Index;
63 BOOLEAN Short;
64 UINTN Number;
65 CHAR16 FormatString[8];
66
67 if (!Ipv6Flag) {
68 Ip4 = &Ip->v4;
69
70 UnicodeSPrint (
71 Str,
72 (UINTN) 2 * IP4_STR_MAX_SIZE,
73 L"%d.%d.%d.%d",
74 (UINTN) Ip4->Addr[0],
75 (UINTN) Ip4->Addr[1],
76 (UINTN) Ip4->Addr[2],
77 (UINTN) Ip4->Addr[3]
78 );
79
80 return ;
81 }
82
83 Ip6 = &Ip->v6;
84 Short = FALSE;
85
86 for (Index = 0; Index < 15; Index = Index + 2) {
87 if (!Short &&
88 Index % 2 == 0 &&
89 Ip6->Addr[Index] == 0 &&
90 Ip6->Addr[Index + 1] == 0
91 ) {
92 //
93 // Deal with the case of ::.
94 //
95 if (Index == 0) {
96 *Str = L':';
97 *(Str + 1) = L':';
98 Str = Str + 2;
99 } else {
100 *Str = L':';
101 Str = Str + 1;
102 }
103
104 while ((Index < 15) && (Ip6->Addr[Index] == 0) && (Ip6->Addr[Index + 1] == 0)) {
105 Index = Index + 2;
106 }
107
108 Short = TRUE;
109
110 if (Index == 16) {
111 //
112 // :: is at the end of the address.
113 //
114 *Str = L'\0';
115 break;
116 }
117 }
118
119 ASSERT (Index < 15);
120
121 if (Ip6->Addr[Index] == 0) {
122 Number = UnicodeSPrint (Str, 2 * IP_STR_MAX_SIZE, L"%x:", (UINTN) Ip6->Addr[Index + 1]);
123 } else {
124 if (Ip6->Addr[Index + 1] < 0x10) {
125 CopyMem (FormatString, L"%x0%x:", StrSize (L"%x0%x:"));
126 } else {
127 CopyMem (FormatString, L"%x%x:", StrSize (L"%x%x:"));
128 }
129
130 Number = UnicodeSPrint (
131 Str,
132 2 * IP_STR_MAX_SIZE,
133 (CONST CHAR16 *) FormatString,
134 (UINTN) Ip6->Addr[Index],
135 (UINTN) Ip6->Addr[Index + 1]
136 );
137 }
138
139 Str = Str + Number;
140
141 if (Index + 2 == 16) {
142 *Str = L'\0';
143 if (*(Str - 1) == L':') {
144 *(Str - 1) = L'\0';
145 }
146 }
147 }
148 }
149
150 /**
151 Check whether the input IP address is valid.
152
153 @param[in] Ip The IP address.
154 @param[in] IpMode Indicates iSCSI running on IP4 or IP6 stack.
155
156 @retval TRUE The input IP address is valid.
157 @retval FALSE Otherwise
158
159 **/
160 BOOLEAN
161 IpIsUnicast (
162 IN EFI_IP_ADDRESS *Ip,
163 IN UINT8 IpMode
164 )
165 {
166 if (IpMode == IP_MODE_IP4) {
167 if (IP4_IS_UNSPECIFIED (NTOHL (Ip->Addr[0])) || IP4_IS_LOCAL_BROADCAST (NTOHL (Ip->Addr[0]))) {
168 return FALSE;
169 }
170 return TRUE;
171 } else if (IpMode == IP_MODE_IP6) {
172 return NetIp6IsValidUnicast (&Ip->v6);
173 } else {
174 DEBUG ((DEBUG_ERROR, "IpMode %d is invalid when configuring the iSCSI target IP!\n", IpMode));
175 return FALSE;
176 }
177 }
178
179 /**
180 Parse IsId in string format and convert it to binary.
181
182 @param[in] String The buffer of the string to be parsed.
183 @param[in, out] IsId The buffer to store IsId.
184
185 @retval EFI_SUCCESS The operation finished successfully.
186 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
187
188 **/
189 EFI_STATUS
190 IScsiParseIsIdFromString (
191 IN CONST CHAR16 *String,
192 IN OUT UINT8 *IsId
193 )
194 {
195 UINT8 Index;
196 CHAR16 *IsIdStr;
197 CHAR16 TempStr[3];
198 UINTN NodeVal;
199 CHAR16 PortString[ISCSI_NAME_IFR_MAX_SIZE];
200 EFI_INPUT_KEY Key;
201
202 if ((String == NULL) || (IsId == NULL)) {
203 return EFI_INVALID_PARAMETER;
204 }
205
206 IsIdStr = (CHAR16 *) String;
207
208 if (StrLen (IsIdStr) != 6) {
209 UnicodeSPrint (
210 PortString,
211 (UINTN) ISCSI_NAME_IFR_MAX_SIZE,
212 L"Error! Input is incorrect, please input 6 hex numbers!\n"
213 );
214
215 CreatePopUp (
216 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
217 &Key,
218 PortString,
219 NULL
220 );
221
222 return EFI_INVALID_PARAMETER;
223 }
224
225 for (Index = 3; Index < 6; Index++) {
226 CopyMem (TempStr, IsIdStr, sizeof (TempStr));
227 TempStr[2] = L'\0';
228
229 //
230 // Convert the string to IsId. StrHexToUintn stops at the first character
231 // that is not a valid hex character, '\0' here.
232 //
233 NodeVal = StrHexToUintn (TempStr);
234
235 IsId[Index] = (UINT8) NodeVal;
236
237 IsIdStr = IsIdStr + 2;
238 }
239
240 return EFI_SUCCESS;
241 }
242
243 /**
244 Convert IsId from binary to string format.
245
246 @param[out] String The buffer to store the converted string.
247 @param[in] IsId The buffer to store IsId.
248
249 @retval EFI_SUCCESS The string converted successfully.
250 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
251
252 **/
253 EFI_STATUS
254 IScsiConvertIsIdToString (
255 OUT CHAR16 *String,
256 IN UINT8 *IsId
257 )
258 {
259 UINT8 Index;
260 UINTN Number;
261
262 if ((String == NULL) || (IsId == NULL)) {
263 return EFI_INVALID_PARAMETER;
264 }
265
266 for (Index = 0; Index < 6; Index++) {
267 if (IsId[Index] <= 0xF) {
268 Number = UnicodeSPrint (
269 String,
270 2 * ISID_CONFIGURABLE_STORAGE,
271 L"0%X",
272 (UINTN) IsId[Index]
273 );
274 } else {
275 Number = UnicodeSPrint (
276 String,
277 2 * ISID_CONFIGURABLE_STORAGE,
278 L"%X",
279 (UINTN) IsId[Index]
280 );
281
282 }
283
284 String = String + Number;
285 }
286
287 *String = L'\0';
288
289 return EFI_SUCCESS;
290 }
291
292 /**
293 Get the attempt config data from global structure by the ConfigIndex.
294
295 @param[in] AttemptConfigIndex The unique index indicates the attempt.
296
297 @return Pointer to the attempt config data.
298 @retval NULL The attempt configuration data cannot be found.
299
300 **/
301 ISCSI_ATTEMPT_CONFIG_NVDATA *
302 IScsiConfigGetAttemptByConfigIndex (
303 IN UINT8 AttemptConfigIndex
304 )
305 {
306 LIST_ENTRY *Entry;
307 ISCSI_ATTEMPT_CONFIG_NVDATA *Attempt;
308
309 NET_LIST_FOR_EACH (Entry, &mPrivate->AttemptConfigs) {
310 Attempt = NET_LIST_USER_STRUCT (Entry, ISCSI_ATTEMPT_CONFIG_NVDATA, Link);
311 if (Attempt->AttemptConfigIndex == AttemptConfigIndex) {
312 return Attempt;
313 }
314 }
315
316 return NULL;
317 }
318
319
320 /**
321 Get the existing attempt config data from global structure by the NicIndex.
322
323 @param[in] NewAttempt The created new attempt
324 @param[in] IScsiMode The IScsi Mode of the new attempt, Enabled or
325 Enabled for MPIO.
326
327 @return Pointer to the existing attempt config data which
328 has the same NICIndex as the new created attempt.
329 @retval NULL The attempt with NicIndex does not exist.
330
331 **/
332 ISCSI_ATTEMPT_CONFIG_NVDATA *
333 IScsiConfigGetAttemptByNic (
334 IN ISCSI_ATTEMPT_CONFIG_NVDATA *NewAttempt,
335 IN UINT8 IScsiMode
336 )
337 {
338 LIST_ENTRY *Entry;
339 ISCSI_ATTEMPT_CONFIG_NVDATA *Attempt;
340
341 NET_LIST_FOR_EACH (Entry, &mPrivate->AttemptConfigs) {
342 Attempt = NET_LIST_USER_STRUCT (Entry, ISCSI_ATTEMPT_CONFIG_NVDATA, Link);
343 if (Attempt != NewAttempt && Attempt->NicIndex == NewAttempt->NicIndex &&
344 Attempt->SessionConfigData.Enabled == IScsiMode) {
345 return Attempt;
346 }
347 }
348
349 return NULL;
350 }
351
352
353 /**
354 Convert the iSCSI configuration data into the IFR data.
355
356 @param[in] Attempt The iSCSI attempt config data.
357 @param[in, out] IfrNvData The IFR nv data.
358
359 **/
360 VOID
361 IScsiConvertAttemptConfigDataToIfrNvData (
362 IN ISCSI_ATTEMPT_CONFIG_NVDATA *Attempt,
363 IN OUT ISCSI_CONFIG_IFR_NVDATA *IfrNvData
364 )
365 {
366 ISCSI_SESSION_CONFIG_NVDATA *SessionConfigData;
367 ISCSI_CHAP_AUTH_CONFIG_NVDATA *AuthConfigData;
368 EFI_IP_ADDRESS Ip;
369
370 //
371 // Normal session configuration parameters.
372 //
373 SessionConfigData = &Attempt->SessionConfigData;
374 IfrNvData->Enabled = SessionConfigData->Enabled;
375 IfrNvData->IpMode = SessionConfigData->IpMode;
376
377 IfrNvData->InitiatorInfoFromDhcp = SessionConfigData->InitiatorInfoFromDhcp;
378 IfrNvData->TargetInfoFromDhcp = SessionConfigData->TargetInfoFromDhcp;
379 IfrNvData->TargetPort = SessionConfigData->TargetPort;
380
381 if (IfrNvData->IpMode == IP_MODE_IP4) {
382 CopyMem (&Ip.v4, &SessionConfigData->LocalIp, sizeof (EFI_IPv4_ADDRESS));
383 IScsiIpToStr (&Ip, FALSE, IfrNvData->LocalIp);
384 CopyMem (&Ip.v4, &SessionConfigData->SubnetMask, sizeof (EFI_IPv4_ADDRESS));
385 IScsiIpToStr (&Ip, FALSE, IfrNvData->SubnetMask);
386 CopyMem (&Ip.v4, &SessionConfigData->Gateway, sizeof (EFI_IPv4_ADDRESS));
387 IScsiIpToStr (&Ip, FALSE, IfrNvData->Gateway);
388 CopyMem (&Ip.v4, &SessionConfigData->TargetIp, sizeof (EFI_IPv4_ADDRESS));
389 IScsiIpToStr (&Ip, FALSE, IfrNvData->TargetIp);
390 } else if (IfrNvData->IpMode == IP_MODE_IP6) {
391 ZeroMem (IfrNvData->TargetIp, sizeof (IfrNvData->TargetIp));
392 IP6_COPY_ADDRESS (&Ip.v6, &SessionConfigData->TargetIp);
393 IScsiIpToStr (&Ip, TRUE, IfrNvData->TargetIp);
394 }
395
396 AsciiStrToUnicodeStrS (
397 SessionConfigData->TargetName,
398 IfrNvData->TargetName,
399 sizeof (IfrNvData->TargetName) / sizeof (IfrNvData->TargetName[0])
400 );
401 IScsiLunToUnicodeStr (SessionConfigData->BootLun, IfrNvData->BootLun);
402 IScsiConvertIsIdToString (IfrNvData->IsId, SessionConfigData->IsId);
403
404 IfrNvData->ConnectRetryCount = SessionConfigData->ConnectRetryCount;
405 IfrNvData->ConnectTimeout = SessionConfigData->ConnectTimeout;
406
407 //
408 // Authentication parameters.
409 //
410 IfrNvData->AuthenticationType = Attempt->AuthenticationType;
411
412 if (IfrNvData->AuthenticationType == ISCSI_AUTH_TYPE_CHAP) {
413 AuthConfigData = &Attempt->AuthConfigData.CHAP;
414 IfrNvData->CHAPType = AuthConfigData->CHAPType;
415 AsciiStrToUnicodeStrS (
416 AuthConfigData->CHAPName,
417 IfrNvData->CHAPName,
418 sizeof (IfrNvData->CHAPName) / sizeof (IfrNvData->CHAPName[0])
419 );
420 AsciiStrToUnicodeStrS (
421 AuthConfigData->CHAPSecret,
422 IfrNvData->CHAPSecret,
423 sizeof (IfrNvData->CHAPSecret) / sizeof (IfrNvData->CHAPSecret[0])
424 );
425 AsciiStrToUnicodeStrS (
426 AuthConfigData->ReverseCHAPName,
427 IfrNvData->ReverseCHAPName,
428 sizeof (IfrNvData->ReverseCHAPName) / sizeof (IfrNvData->ReverseCHAPName[0])
429 );
430 AsciiStrToUnicodeStrS (
431 AuthConfigData->ReverseCHAPSecret,
432 IfrNvData->ReverseCHAPSecret,
433 sizeof (IfrNvData->ReverseCHAPSecret) / sizeof (IfrNvData->ReverseCHAPSecret[0])
434 );
435 }
436
437 //
438 // Other parameters.
439 //
440 AsciiStrToUnicodeStrS (
441 Attempt->AttemptName,
442 IfrNvData->AttemptName,
443 sizeof (IfrNvData->AttemptName) / sizeof (IfrNvData->AttemptName[0])
444 );
445 }
446
447 /**
448 Convert the IFR data to iSCSI configuration data.
449
450 @param[in] IfrNvData Point to ISCSI_CONFIG_IFR_NVDATA.
451 @param[in, out] Attempt The iSCSI attempt config data.
452
453 @retval EFI_INVALID_PARAMETER Any input or configured parameter is invalid.
454 @retval EFI_NOT_FOUND Cannot find the corresponding variable.
455 @retval EFI_OUT_OF_RESOURCES The operation is failed due to lack of resources.
456 @retval EFI_ABORTED The operation is aborted.
457 @retval EFI_SUCCESS The operation is completed successfully.
458
459 **/
460 EFI_STATUS
461 IScsiConvertIfrNvDataToAttemptConfigData (
462 IN ISCSI_CONFIG_IFR_NVDATA *IfrNvData,
463 IN OUT ISCSI_ATTEMPT_CONFIG_NVDATA *Attempt
464 )
465 {
466 EFI_IP_ADDRESS HostIp;
467 EFI_IP_ADDRESS SubnetMask;
468 EFI_IP_ADDRESS Gateway;
469 CHAR16 *MacString;
470 CHAR16 *AttemptName1;
471 CHAR16 *AttemptName2;
472 ISCSI_ATTEMPT_CONFIG_NVDATA *ExistAttempt;
473 ISCSI_ATTEMPT_CONFIG_NVDATA *SameNicAttempt;
474 CHAR16 IScsiMode[64];
475 CHAR16 IpMode[64];
476 ISCSI_NIC_INFO *NicInfo;
477 EFI_INPUT_KEY Key;
478 UINT8 *AttemptConfigOrder;
479 UINTN AttemptConfigOrderSize;
480 UINT8 *AttemptOrderTmp;
481 UINTN TotalNumber;
482 EFI_STATUS Status;
483
484 if (IfrNvData == NULL || Attempt == NULL) {
485 return EFI_INVALID_PARAMETER;
486 }
487
488 //
489 // Update those fields which don't have INTERACTIVE attribute.
490 //
491 Attempt->SessionConfigData.ConnectRetryCount = IfrNvData->ConnectRetryCount;
492 Attempt->SessionConfigData.ConnectTimeout = IfrNvData->ConnectTimeout;
493 Attempt->SessionConfigData.IpMode = IfrNvData->IpMode;
494
495 if (IfrNvData->IpMode < IP_MODE_AUTOCONFIG) {
496 Attempt->SessionConfigData.InitiatorInfoFromDhcp = IfrNvData->InitiatorInfoFromDhcp;
497 Attempt->SessionConfigData.TargetPort = IfrNvData->TargetPort;
498
499 if (Attempt->SessionConfigData.TargetPort == 0) {
500 Attempt->SessionConfigData.TargetPort = ISCSI_WELL_KNOWN_PORT;
501 }
502
503 Attempt->SessionConfigData.TargetInfoFromDhcp = IfrNvData->TargetInfoFromDhcp;
504 }
505
506 Attempt->AuthenticationType = IfrNvData->AuthenticationType;
507
508 if (Attempt->AuthenticationType == ISCSI_AUTH_TYPE_CHAP) {
509 Attempt->AuthConfigData.CHAP.CHAPType = IfrNvData->CHAPType;
510 }
511
512 //
513 // Only do full parameter validation if iSCSI is enabled on this device.
514 //
515 if (IfrNvData->Enabled != ISCSI_DISABLED) {
516 if (Attempt->SessionConfigData.ConnectTimeout < CONNECT_MIN_TIMEOUT) {
517 CreatePopUp (
518 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
519 &Key,
520 L"Connection Establishing Timeout is less than minimum value 100ms.",
521 NULL
522 );
523
524 return EFI_INVALID_PARAMETER;
525 }
526
527 //
528 // Validate the address configuration of the Initiator if DHCP isn't
529 // deployed.
530 //
531 if (!Attempt->SessionConfigData.InitiatorInfoFromDhcp) {
532 CopyMem (&HostIp.v4, &Attempt->SessionConfigData.LocalIp, sizeof (HostIp.v4));
533 CopyMem (&SubnetMask.v4, &Attempt->SessionConfigData.SubnetMask, sizeof (SubnetMask.v4));
534 CopyMem (&Gateway.v4, &Attempt->SessionConfigData.Gateway, sizeof (Gateway.v4));
535
536 if ((Gateway.Addr[0] != 0)) {
537 if (SubnetMask.Addr[0] == 0) {
538 CreatePopUp (
539 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
540 &Key,
541 L"Gateway address is set but subnet mask is zero.",
542 NULL
543 );
544
545 return EFI_INVALID_PARAMETER;
546 } else if (!IP4_NET_EQUAL (HostIp.Addr[0], Gateway.Addr[0], SubnetMask.Addr[0])) {
547 CreatePopUp (
548 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
549 &Key,
550 L"Local IP and Gateway are not in the same subnet.",
551 NULL
552 );
553
554 return EFI_INVALID_PARAMETER;
555 }
556 }
557 }
558 //
559 // Validate target configuration if DHCP isn't deployed.
560 //
561 if (!Attempt->SessionConfigData.TargetInfoFromDhcp && Attempt->SessionConfigData.IpMode < IP_MODE_AUTOCONFIG) {
562 if (!IpIsUnicast (&Attempt->SessionConfigData.TargetIp, IfrNvData->IpMode)) {
563 CreatePopUp (
564 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
565 &Key,
566 L"Target IP is invalid!",
567 NULL
568 );
569 return EFI_INVALID_PARAMETER;
570 }
571
572 //
573 // Validate iSCSI target name configuration again:
574 // The format of iSCSI target name is already verified in IScsiFormCallback() when
575 // user input the name; here we only check the case user does not input the name.
576 //
577 if (Attempt->SessionConfigData.TargetName[0] == '\0') {
578 CreatePopUp (
579 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
580 &Key,
581 L"iSCSI target name is NULL!",
582 NULL
583 );
584 return EFI_INVALID_PARAMETER;
585 }
586 }
587
588
589 //
590 // Validate the authentication info.
591 //
592 if (IfrNvData->AuthenticationType == ISCSI_AUTH_TYPE_CHAP) {
593 if ((IfrNvData->CHAPName[0] == '\0') || (IfrNvData->CHAPSecret[0] == '\0')) {
594 CreatePopUp (
595 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
596 &Key,
597 L"CHAP Name or CHAP Secret is invalid!",
598 NULL
599 );
600
601 return EFI_INVALID_PARAMETER;
602 }
603
604 if ((IfrNvData->CHAPType == ISCSI_CHAP_MUTUAL) &&
605 ((IfrNvData->ReverseCHAPName[0] == '\0') || (IfrNvData->ReverseCHAPSecret[0] == '\0'))
606 ) {
607 CreatePopUp (
608 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
609 &Key,
610 L"Reverse CHAP Name or Reverse CHAP Secret is invalid!",
611 NULL
612 );
613 return EFI_INVALID_PARAMETER;
614 }
615 }
616
617 //
618 // Check whether this attempt uses NIC which is already used by existing attempt.
619 //
620 SameNicAttempt = IScsiConfigGetAttemptByNic (Attempt, IfrNvData->Enabled);
621 if (SameNicAttempt != NULL) {
622 AttemptName1 = (CHAR16 *) AllocateZeroPool (ATTEMPT_NAME_MAX_SIZE * sizeof (CHAR16));
623 if (AttemptName1 == NULL) {
624 return EFI_OUT_OF_RESOURCES;
625 }
626
627 AttemptName2 = (CHAR16 *) AllocateZeroPool (ATTEMPT_NAME_MAX_SIZE * sizeof (CHAR16));
628 if (AttemptName2 == NULL) {
629 FreePool (AttemptName1);
630 return EFI_OUT_OF_RESOURCES;
631 }
632
633 AsciiStrToUnicodeStrS (Attempt->AttemptName, AttemptName1, ATTEMPT_NAME_MAX_SIZE);
634 if (StrLen (AttemptName1) > ATTEMPT_NAME_SIZE) {
635 CopyMem (&AttemptName1[ATTEMPT_NAME_SIZE], L"...", 4 * sizeof (CHAR16));
636 }
637
638 AsciiStrToUnicodeStrS (SameNicAttempt->AttemptName, AttemptName2, ATTEMPT_NAME_MAX_SIZE);
639 if (StrLen (AttemptName2) > ATTEMPT_NAME_SIZE) {
640 CopyMem (&AttemptName2[ATTEMPT_NAME_SIZE], L"...", 4 * sizeof (CHAR16));
641 }
642
643 UnicodeSPrint (
644 mPrivate->PortString,
645 (UINTN) ISCSI_NAME_IFR_MAX_SIZE,
646 L"Warning! Attempt \"%s\" uses same NIC as Attempt \"%s\".",
647 AttemptName1,
648 AttemptName2
649 );
650
651 CreatePopUp (
652 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
653 &Key,
654 mPrivate->PortString,
655 NULL
656 );
657
658 FreePool (AttemptName1);
659 FreePool (AttemptName2);
660 }
661 }
662
663 //
664 // Update the iSCSI Mode data and record it in attempt help info.
665 //
666 Attempt->SessionConfigData.Enabled = IfrNvData->Enabled;
667 if (IfrNvData->Enabled == ISCSI_DISABLED) {
668 UnicodeSPrint (IScsiMode, 64, L"Disabled");
669 } else if (IfrNvData->Enabled == ISCSI_ENABLED) {
670 UnicodeSPrint (IScsiMode, 64, L"Enabled");
671 } else if (IfrNvData->Enabled == ISCSI_ENABLED_FOR_MPIO) {
672 UnicodeSPrint (IScsiMode, 64, L"Enabled for MPIO");
673 }
674
675 if (IfrNvData->IpMode == IP_MODE_IP4) {
676 UnicodeSPrint (IpMode, 64, L"IP4");
677 } else if (IfrNvData->IpMode == IP_MODE_IP6) {
678 UnicodeSPrint (IpMode, 64, L"IP6");
679 } else if (IfrNvData->IpMode == IP_MODE_AUTOCONFIG) {
680 UnicodeSPrint (IpMode, 64, L"Autoconfigure");
681 }
682
683 NicInfo = IScsiGetNicInfoByIndex (Attempt->NicIndex);
684 if (NicInfo == NULL) {
685 return EFI_NOT_FOUND;
686 }
687
688 MacString = (CHAR16 *) AllocateZeroPool (ISCSI_MAX_MAC_STRING_LEN * sizeof (CHAR16));
689 if (MacString == NULL) {
690 return EFI_OUT_OF_RESOURCES;
691 }
692
693 AsciiStrToUnicodeStrS (Attempt->MacString, MacString, ISCSI_MAX_MAC_STRING_LEN);
694
695 UnicodeSPrint (
696 mPrivate->PortString,
697 (UINTN) ISCSI_NAME_IFR_MAX_SIZE,
698 L"MAC: %s, PFA: Bus %d | Dev %d | Func %d, iSCSI mode: %s, IP version: %s",
699 MacString,
700 NicInfo->BusNumber,
701 NicInfo->DeviceNumber,
702 NicInfo->FunctionNumber,
703 IScsiMode,
704 IpMode
705 );
706
707 Attempt->AttemptTitleHelpToken = HiiSetString (
708 mCallbackInfo->RegisteredHandle,
709 Attempt->AttemptTitleHelpToken,
710 mPrivate->PortString,
711 NULL
712 );
713 if (Attempt->AttemptTitleHelpToken == 0) {
714 FreePool (MacString);
715 return EFI_OUT_OF_RESOURCES;
716 }
717
718 //
719 // Check whether this attempt is an existing one.
720 //
721 ExistAttempt = IScsiConfigGetAttemptByConfigIndex (Attempt->AttemptConfigIndex);
722 if (ExistAttempt != NULL) {
723 ASSERT (ExistAttempt == Attempt);
724
725 if (IfrNvData->Enabled == ISCSI_DISABLED &&
726 Attempt->SessionConfigData.Enabled != ISCSI_DISABLED) {
727
728 //
729 // User updates the Attempt from "Enabled"/"Enabled for MPIO" to "Disabled".
730 //
731 if (Attempt->SessionConfigData.Enabled == ISCSI_ENABLED_FOR_MPIO) {
732 if (mPrivate->MpioCount < 1) {
733 return EFI_ABORTED;
734 }
735
736 if (--mPrivate->MpioCount == 0) {
737 mPrivate->EnableMpio = FALSE;
738 }
739 } else if (Attempt->SessionConfigData.Enabled == ISCSI_ENABLED) {
740 if (mPrivate->SinglePathCount < 1) {
741 return EFI_ABORTED;
742 }
743 mPrivate->SinglePathCount--;
744 }
745
746 } else if (IfrNvData->Enabled == ISCSI_ENABLED_FOR_MPIO &&
747 Attempt->SessionConfigData.Enabled == ISCSI_ENABLED) {
748 //
749 // User updates the Attempt from "Enabled" to "Enabled for MPIO".
750 //
751 if (mPrivate->SinglePathCount < 1) {
752 return EFI_ABORTED;
753 }
754
755 mPrivate->EnableMpio = TRUE;
756 mPrivate->MpioCount++;
757 mPrivate->SinglePathCount--;
758
759 } else if (IfrNvData->Enabled == ISCSI_ENABLED &&
760 Attempt->SessionConfigData.Enabled == ISCSI_ENABLED_FOR_MPIO) {
761 //
762 // User updates the Attempt from "Enabled for MPIO" to "Enabled".
763 //
764 if (mPrivate->MpioCount < 1) {
765 return EFI_ABORTED;
766 }
767
768 if (--mPrivate->MpioCount == 0) {
769 mPrivate->EnableMpio = FALSE;
770 }
771 mPrivate->SinglePathCount++;
772
773 } else if (IfrNvData->Enabled != ISCSI_DISABLED &&
774 Attempt->SessionConfigData.Enabled == ISCSI_DISABLED) {
775 //
776 // User updates the Attempt from "Disabled" to "Enabled"/"Enabled for MPIO".
777 //
778 if (IfrNvData->Enabled == ISCSI_ENABLED_FOR_MPIO) {
779 mPrivate->EnableMpio = TRUE;
780 mPrivate->MpioCount++;
781
782 } else if (IfrNvData->Enabled == ISCSI_ENABLED) {
783 mPrivate->SinglePathCount++;
784 }
785 }
786
787 } else if (ExistAttempt == NULL) {
788 //
789 // When a new attempt is created, pointer of the attempt is saved to
790 // mPrivate->NewAttempt, and also saved to mCallbackInfo->Current in
791 // IScsiConfigProcessDefault. If input Attempt does not match any existing
792 // attempt, it should be a new created attempt. Save it to system now.
793 //
794 ASSERT (Attempt == mPrivate->NewAttempt);
795
796 //
797 // Save current order number for this attempt.
798 //
799 AttemptConfigOrder = IScsiGetVariableAndSize (
800 L"AttemptOrder",
801 &gIScsiConfigGuid,
802 &AttemptConfigOrderSize
803 );
804
805 TotalNumber = AttemptConfigOrderSize / sizeof (UINT8);
806 TotalNumber++;
807
808 //
809 // Append the new created attempt order to the end.
810 //
811 AttemptOrderTmp = AllocateZeroPool (TotalNumber * sizeof (UINT8));
812 if (AttemptOrderTmp == NULL) {
813 if (AttemptConfigOrder != NULL) {
814 FreePool (AttemptConfigOrder);
815 }
816 return EFI_OUT_OF_RESOURCES;
817 }
818
819 if (AttemptConfigOrder != NULL) {
820 CopyMem (AttemptOrderTmp, AttemptConfigOrder, AttemptConfigOrderSize);
821 FreePool (AttemptConfigOrder);
822 }
823
824 AttemptOrderTmp[TotalNumber - 1] = Attempt->AttemptConfigIndex;
825 AttemptConfigOrder = AttemptOrderTmp;
826 AttemptConfigOrderSize = TotalNumber * sizeof (UINT8);
827
828 Status = gRT->SetVariable (
829 L"AttemptOrder",
830 &gIScsiConfigGuid,
831 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,
832 AttemptConfigOrderSize,
833 AttemptConfigOrder
834 );
835 FreePool (AttemptConfigOrder);
836 if (EFI_ERROR (Status)) {
837 return Status;
838 }
839
840 //
841 // Insert new created attempt to array.
842 //
843 InsertTailList (&mPrivate->AttemptConfigs, &Attempt->Link);
844 mPrivate->AttemptCount++;
845 //
846 // Reset mPrivate->NewAttempt to NULL, which indicates none attempt is created
847 // but not saved now.
848 //
849 mPrivate->NewAttempt = NULL;
850
851 if (IfrNvData->Enabled == ISCSI_ENABLED_FOR_MPIO) {
852 //
853 // This new Attempt is enabled for MPIO; enable the multipath mode.
854 //
855 mPrivate->EnableMpio = TRUE;
856 mPrivate->MpioCount++;
857 } else if (IfrNvData->Enabled == ISCSI_ENABLED) {
858 mPrivate->SinglePathCount++;
859 }
860
861 IScsiConfigUpdateAttempt ();
862 }
863
864 //
865 // Record the user configuration information in NVR.
866 //
867 UnicodeSPrint (
868 mPrivate->PortString,
869 (UINTN) ISCSI_NAME_IFR_MAX_SIZE,
870 L"%s%d",
871 MacString,
872 (UINTN) Attempt->AttemptConfigIndex
873 );
874
875 FreePool (MacString);
876
877 return gRT->SetVariable (
878 mPrivate->PortString,
879 &gEfiIScsiInitiatorNameProtocolGuid,
880 ISCSI_CONFIG_VAR_ATTR,
881 sizeof (ISCSI_ATTEMPT_CONFIG_NVDATA),
882 Attempt
883 );
884 }
885
886 /**
887 Create Hii Extend Label OpCode as the start opcode and end opcode. It is
888 a help function.
889
890 @param[in] StartLabelNumber The number of start label.
891 @param[out] StartOpCodeHandle Points to the start opcode handle.
892 @param[out] StartLabel Points to the created start opcode.
893 @param[out] EndOpCodeHandle Points to the end opcode handle.
894 @param[out] EndLabel Points to the created end opcode.
895
896 @retval EFI_OUT_OF_RESOURCES Do not have sufficient resource to finish this
897 operation.
898 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
899 @retval EFI_SUCCESS The operation is completed successfully.
900
901 **/
902 EFI_STATUS
903 IScsiCreateOpCode (
904 IN UINT16 StartLabelNumber,
905 OUT VOID **StartOpCodeHandle,
906 OUT EFI_IFR_GUID_LABEL **StartLabel,
907 OUT VOID **EndOpCodeHandle,
908 OUT EFI_IFR_GUID_LABEL **EndLabel
909 )
910 {
911 EFI_STATUS Status;
912 EFI_IFR_GUID_LABEL *InternalStartLabel;
913 EFI_IFR_GUID_LABEL *InternalEndLabel;
914
915 if (StartOpCodeHandle == NULL || StartLabel == NULL || EndOpCodeHandle == NULL || EndLabel == NULL) {
916 return EFI_INVALID_PARAMETER;
917 }
918
919 *StartOpCodeHandle = NULL;
920 *EndOpCodeHandle = NULL;
921 Status = EFI_OUT_OF_RESOURCES;
922
923 //
924 // Initialize the container for dynamic opcodes.
925 //
926 *StartOpCodeHandle = HiiAllocateOpCodeHandle ();
927 if (*StartOpCodeHandle == NULL) {
928 return Status;
929 }
930
931 *EndOpCodeHandle = HiiAllocateOpCodeHandle ();
932 if (*EndOpCodeHandle == NULL) {
933 goto Exit;
934 }
935
936 //
937 // Create Hii Extend Label OpCode as the start opcode.
938 //
939 InternalStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
940 *StartOpCodeHandle,
941 &gEfiIfrTianoGuid,
942 NULL,
943 sizeof (EFI_IFR_GUID_LABEL)
944 );
945 if (InternalStartLabel == NULL) {
946 goto Exit;
947 }
948
949 InternalStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
950 InternalStartLabel->Number = StartLabelNumber;
951
952 //
953 // Create Hii Extend Label OpCode as the end opcode.
954 //
955 InternalEndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
956 *EndOpCodeHandle,
957 &gEfiIfrTianoGuid,
958 NULL,
959 sizeof (EFI_IFR_GUID_LABEL)
960 );
961 if (InternalEndLabel == NULL) {
962 goto Exit;
963 }
964
965 InternalEndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
966 InternalEndLabel->Number = LABEL_END;
967
968 *StartLabel = InternalStartLabel;
969 *EndLabel = InternalEndLabel;
970
971 return EFI_SUCCESS;
972
973 Exit:
974
975 if (*StartOpCodeHandle != NULL) {
976 HiiFreeOpCodeHandle (*StartOpCodeHandle);
977 }
978
979 if (*EndOpCodeHandle != NULL) {
980 HiiFreeOpCodeHandle (*EndOpCodeHandle);
981 }
982
983 return Status;
984 }
985
986 /**
987 Callback function when user presses "Add an Attempt".
988
989 @retval EFI_OUT_OF_RESOURCES Does not have sufficient resources to finish this
990 operation.
991 @retval EFI_SUCCESS The operation is completed successfully.
992
993 **/
994 EFI_STATUS
995 IScsiConfigAddAttempt (
996 VOID
997 )
998 {
999 LIST_ENTRY *Entry;
1000 ISCSI_NIC_INFO *NicInfo;
1001 EFI_STRING_ID PortTitleToken;
1002 EFI_STRING_ID PortTitleHelpToken;
1003 CHAR16 MacString[ISCSI_MAX_MAC_STRING_LEN];
1004 EFI_STATUS Status;
1005 VOID *StartOpCodeHandle;
1006 EFI_IFR_GUID_LABEL *StartLabel;
1007 VOID *EndOpCodeHandle;
1008 EFI_IFR_GUID_LABEL *EndLabel;
1009
1010 Status = IScsiCreateOpCode (
1011 MAC_ENTRY_LABEL,
1012 &StartOpCodeHandle,
1013 &StartLabel,
1014 &EndOpCodeHandle,
1015 &EndLabel
1016 );
1017 if (EFI_ERROR (Status)) {
1018 return Status;
1019 }
1020
1021 //
1022 // Ask user to select a MAC for this attempt.
1023 //
1024 NET_LIST_FOR_EACH (Entry, &mPrivate->NicInfoList) {
1025 NicInfo = NET_LIST_USER_STRUCT (Entry, ISCSI_NIC_INFO, Link);
1026 IScsiMacAddrToStr (
1027 &NicInfo->PermanentAddress,
1028 NicInfo->HwAddressSize,
1029 NicInfo->VlanId,
1030 MacString
1031 );
1032
1033 UnicodeSPrint (mPrivate->PortString, (UINTN) ISCSI_NAME_IFR_MAX_SIZE, L"MAC %s", MacString);
1034 PortTitleToken = HiiSetString (
1035 mCallbackInfo->RegisteredHandle,
1036 0,
1037 mPrivate->PortString,
1038 NULL
1039 );
1040 if (PortTitleToken == 0) {
1041 Status = EFI_INVALID_PARAMETER;
1042 goto Exit;
1043 }
1044
1045 UnicodeSPrint (
1046 mPrivate->PortString,
1047 (UINTN) ISCSI_NAME_IFR_MAX_SIZE,
1048 L"PFA: Bus %d | Dev %d | Func %d",
1049 NicInfo->BusNumber,
1050 NicInfo->DeviceNumber,
1051 NicInfo->FunctionNumber
1052 );
1053 PortTitleHelpToken = HiiSetString (mCallbackInfo->RegisteredHandle, 0, mPrivate->PortString, NULL);
1054 if (PortTitleHelpToken == 0) {
1055 Status = EFI_INVALID_PARAMETER;
1056 goto Exit;
1057 }
1058
1059 HiiCreateGotoOpCode (
1060 StartOpCodeHandle, // Container for dynamic created opcodes
1061 FORMID_ATTEMPT_FORM,
1062 PortTitleToken,
1063 PortTitleHelpToken,
1064 EFI_IFR_FLAG_CALLBACK, // Question flag
1065 (UINT16) (KEY_MAC_ENTRY_BASE + NicInfo->NicIndex)
1066 );
1067 }
1068
1069 Status = HiiUpdateForm (
1070 mCallbackInfo->RegisteredHandle, // HII handle
1071 &gIScsiConfigGuid, // Formset GUID
1072 FORMID_MAC_FORM, // Form ID
1073 StartOpCodeHandle, // Label for where to insert opcodes
1074 EndOpCodeHandle // Replace data
1075 );
1076
1077 Exit:
1078 HiiFreeOpCodeHandle (StartOpCodeHandle);
1079 HiiFreeOpCodeHandle (EndOpCodeHandle);
1080
1081 return Status;
1082 }
1083
1084
1085 /**
1086 Update the MAIN form to display the configured attempts.
1087
1088 **/
1089 VOID
1090 IScsiConfigUpdateAttempt (
1091 VOID
1092 )
1093 {
1094 CHAR16 AttemptName[ATTEMPT_NAME_MAX_SIZE];
1095 LIST_ENTRY *Entry;
1096 ISCSI_ATTEMPT_CONFIG_NVDATA *AttemptConfigData;
1097 VOID *StartOpCodeHandle;
1098 EFI_IFR_GUID_LABEL *StartLabel;
1099 VOID *EndOpCodeHandle;
1100 EFI_IFR_GUID_LABEL *EndLabel;
1101 EFI_STATUS Status;
1102
1103 Status = IScsiCreateOpCode (
1104 ATTEMPT_ENTRY_LABEL,
1105 &StartOpCodeHandle,
1106 &StartLabel,
1107 &EndOpCodeHandle,
1108 &EndLabel
1109 );
1110 if (EFI_ERROR (Status)) {
1111 return ;
1112 }
1113
1114 NET_LIST_FOR_EACH (Entry, &mPrivate->AttemptConfigs) {
1115 AttemptConfigData = NET_LIST_USER_STRUCT (Entry, ISCSI_ATTEMPT_CONFIG_NVDATA, Link);
1116
1117 AsciiStrToUnicodeStrS (AttemptConfigData->AttemptName, AttemptName, ARRAY_SIZE (AttemptName));
1118 UnicodeSPrint (mPrivate->PortString, (UINTN) 128, L"Attempt %s", AttemptName);
1119 AttemptConfigData->AttemptTitleToken = HiiSetString (
1120 mCallbackInfo->RegisteredHandle,
1121 0,
1122 mPrivate->PortString,
1123 NULL
1124 );
1125 if (AttemptConfigData->AttemptTitleToken == 0) {
1126 return ;
1127 }
1128
1129 HiiCreateGotoOpCode (
1130 StartOpCodeHandle, // Container for dynamic created opcodes
1131 FORMID_ATTEMPT_FORM, // Form ID
1132 AttemptConfigData->AttemptTitleToken, // Prompt text
1133 AttemptConfigData->AttemptTitleHelpToken, // Help text
1134 EFI_IFR_FLAG_CALLBACK, // Question flag
1135 (UINT16) (KEY_ATTEMPT_ENTRY_BASE + AttemptConfigData->AttemptConfigIndex) // Question ID
1136 );
1137 }
1138
1139 HiiUpdateForm (
1140 mCallbackInfo->RegisteredHandle, // HII handle
1141 &gIScsiConfigGuid, // Formset GUID
1142 FORMID_MAIN_FORM, // Form ID
1143 StartOpCodeHandle, // Label for where to insert opcodes
1144 EndOpCodeHandle // Replace data
1145 );
1146
1147 HiiFreeOpCodeHandle (StartOpCodeHandle);
1148 HiiFreeOpCodeHandle (EndOpCodeHandle);
1149 }
1150
1151
1152 /**
1153 Callback function when user presses "Commit Changes and Exit" in Delete Attempts.
1154
1155 @param[in] IfrNvData The IFR NV data.
1156
1157 @retval EFI_NOT_FOUND Cannot find the corresponding variable.
1158 @retval EFI_SUCCESS The operation is completed successfully.
1159 @retval EFI_ABOTRED This operation is aborted cause of error
1160 configuration.
1161 @retval EFI_OUT_OF_RESOURCES Fail to finish the operation due to lack of
1162 resources.
1163
1164 **/
1165 EFI_STATUS
1166 IScsiConfigDeleteAttempts (
1167 IN ISCSI_CONFIG_IFR_NVDATA *IfrNvData
1168 )
1169 {
1170 EFI_STATUS Status;
1171 UINTN Index;
1172 UINTN NewIndex;
1173 ISCSI_ATTEMPT_CONFIG_NVDATA *AttemptConfigData;
1174 UINT8 *AttemptConfigOrder;
1175 UINTN AttemptConfigOrderSize;
1176 UINT8 *AttemptNewOrder;
1177 UINT32 Attribute;
1178 UINTN Total;
1179 UINTN NewTotal;
1180 LIST_ENTRY *Entry;
1181 LIST_ENTRY *NextEntry;
1182 CHAR16 MacString[ISCSI_MAX_MAC_STRING_LEN];
1183
1184 AttemptConfigOrder = IScsiGetVariableAndSize (
1185 L"AttemptOrder",
1186 &gIScsiConfigGuid,
1187 &AttemptConfigOrderSize
1188 );
1189 if ((AttemptConfigOrder == NULL) || (AttemptConfigOrderSize == 0)) {
1190 return EFI_NOT_FOUND;
1191 }
1192
1193 AttemptNewOrder = AllocateZeroPool (AttemptConfigOrderSize);
1194 if (AttemptNewOrder == NULL) {
1195 Status = EFI_OUT_OF_RESOURCES;
1196 goto Error;
1197 }
1198
1199 Total = AttemptConfigOrderSize / sizeof (UINT8);
1200 NewTotal = Total;
1201 Index = 0;
1202
1203 NET_LIST_FOR_EACH_SAFE (Entry, NextEntry, &mPrivate->AttemptConfigs) {
1204 if (IfrNvData->DeleteAttemptList[Index] == 0) {
1205 Index++;
1206 continue;
1207 }
1208
1209 //
1210 // Delete the attempt.
1211 //
1212
1213 AttemptConfigData = NET_LIST_USER_STRUCT (Entry, ISCSI_ATTEMPT_CONFIG_NVDATA, Link);
1214 if (AttemptConfigData == NULL) {
1215 Status = EFI_NOT_FOUND;
1216 goto Error;
1217 }
1218
1219 //
1220 // Remove this attempt from UI configured attempt list.
1221 //
1222 RemoveEntryList (&AttemptConfigData->Link);
1223 mPrivate->AttemptCount--;
1224
1225 if (AttemptConfigData->SessionConfigData.Enabled == ISCSI_ENABLED_FOR_MPIO) {
1226 if (mPrivate->MpioCount < 1) {
1227 Status = EFI_ABORTED;
1228 goto Error;
1229 }
1230
1231 //
1232 // No more attempt is enabled for MPIO. Transit the iSCSI mode to single path.
1233 //
1234 if (--mPrivate->MpioCount == 0) {
1235 mPrivate->EnableMpio = FALSE;
1236 }
1237 } else if (AttemptConfigData->SessionConfigData.Enabled == ISCSI_ENABLED) {
1238 if (mPrivate->SinglePathCount < 1) {
1239 Status = EFI_ABORTED;
1240 goto Error;
1241 }
1242
1243 mPrivate->SinglePathCount--;
1244 }
1245
1246 AsciiStrToUnicodeStrS (AttemptConfigData->MacString, MacString, ARRAY_SIZE (MacString));
1247
1248 UnicodeSPrint (
1249 mPrivate->PortString,
1250 (UINTN) 128,
1251 L"%s%d",
1252 MacString,
1253 (UINTN) AttemptConfigData->AttemptConfigIndex
1254 );
1255
1256 gRT->SetVariable (
1257 mPrivate->PortString,
1258 &gEfiIScsiInitiatorNameProtocolGuid,
1259 0,
1260 0,
1261 NULL
1262 );
1263
1264 //
1265 // Mark the attempt order in NVR to be deleted - 0.
1266 //
1267 for (NewIndex = 0; NewIndex < Total; NewIndex++) {
1268 if (AttemptConfigOrder[NewIndex] == AttemptConfigData->AttemptConfigIndex) {
1269 AttemptConfigOrder[NewIndex] = 0;
1270 break;
1271 }
1272 }
1273
1274 NewTotal--;
1275 FreePool (AttemptConfigData);
1276
1277 //
1278 // Check next Attempt.
1279 //
1280 Index++;
1281 }
1282
1283 //
1284 // Construct AttemptNewOrder.
1285 //
1286 for (Index = 0, NewIndex = 0; Index < Total; Index++) {
1287 if (AttemptConfigOrder[Index] != 0) {
1288 AttemptNewOrder[NewIndex] = AttemptConfigOrder[Index];
1289 NewIndex++;
1290 }
1291 }
1292
1293 Attribute = EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE;
1294
1295 //
1296 // Update AttemptOrder in NVR.
1297 //
1298 Status = gRT->SetVariable (
1299 L"AttemptOrder",
1300 &gIScsiConfigGuid,
1301 Attribute,
1302 NewTotal * sizeof (UINT8),
1303 AttemptNewOrder
1304 );
1305
1306 Error:
1307 if (AttemptConfigOrder != NULL) {
1308 FreePool (AttemptConfigOrder);
1309 }
1310
1311 if (AttemptNewOrder != NULL) {
1312 FreePool (AttemptNewOrder);
1313 }
1314
1315 return Status;
1316 }
1317
1318
1319 /**
1320 Callback function when user presses "Delete Attempts".
1321
1322 @param[in] IfrNvData The IFR nv data.
1323
1324 @retval EFI_INVALID_PARAMETER Any parameter is invalid.
1325 @retval EFI_BUFFER_TOO_SMALL The buffer in UpdateData is too small.
1326 @retval EFI_SUCCESS The operation is completed successfully.
1327
1328 **/
1329 EFI_STATUS
1330 IScsiConfigDisplayDeleteAttempts (
1331 IN ISCSI_CONFIG_IFR_NVDATA *IfrNvData
1332 )
1333 {
1334
1335 UINT8 *AttemptConfigOrder;
1336 UINTN AttemptConfigOrderSize;
1337 LIST_ENTRY *Entry;
1338 ISCSI_ATTEMPT_CONFIG_NVDATA *AttemptConfigData;
1339 UINT8 Index;
1340 VOID *StartOpCodeHandle;
1341 EFI_IFR_GUID_LABEL *StartLabel;
1342 VOID *EndOpCodeHandle;
1343 EFI_IFR_GUID_LABEL *EndLabel;
1344 EFI_STATUS Status;
1345
1346 Status = IScsiCreateOpCode (
1347 DELETE_ENTRY_LABEL,
1348 &StartOpCodeHandle,
1349 &StartLabel,
1350 &EndOpCodeHandle,
1351 &EndLabel
1352 );
1353 if (EFI_ERROR (Status)) {
1354 return Status;
1355 }
1356
1357 AttemptConfigOrder = IScsiGetVariableAndSize (
1358 L"AttemptOrder",
1359 &gIScsiConfigGuid,
1360 &AttemptConfigOrderSize
1361 );
1362 if (AttemptConfigOrder != NULL) {
1363 //
1364 // Create the check box opcode to be deleted.
1365 //
1366 Index = 0;
1367
1368 NET_LIST_FOR_EACH (Entry, &mPrivate->AttemptConfigs) {
1369 AttemptConfigData = NET_LIST_USER_STRUCT (Entry, ISCSI_ATTEMPT_CONFIG_NVDATA, Link);
1370 IfrNvData->DeleteAttemptList[Index] = 0x00;
1371
1372 HiiCreateCheckBoxOpCode(
1373 StartOpCodeHandle,
1374 (EFI_QUESTION_ID) (ATTEMPT_DEL_QUESTION_ID + Index),
1375 CONFIGURATION_VARSTORE_ID,
1376 (UINT16) (ATTEMPT_DEL_VAR_OFFSET + Index),
1377 AttemptConfigData->AttemptTitleToken,
1378 AttemptConfigData->AttemptTitleHelpToken,
1379 0,
1380 0,
1381 NULL
1382 );
1383
1384 Index++;
1385
1386 if (Index == ISCSI_MAX_ATTEMPTS_NUM) {
1387 break;
1388 }
1389 }
1390
1391 FreePool (AttemptConfigOrder);
1392 }
1393
1394 Status = HiiUpdateForm (
1395 mCallbackInfo->RegisteredHandle, // HII handle
1396 &gIScsiConfigGuid, // Formset GUID
1397 FORMID_DELETE_FORM, // Form ID
1398 StartOpCodeHandle, // Label for where to insert opcodes
1399 EndOpCodeHandle // Replace data
1400 );
1401
1402 HiiFreeOpCodeHandle (StartOpCodeHandle);
1403 HiiFreeOpCodeHandle (EndOpCodeHandle);
1404
1405 return Status;
1406 }
1407
1408
1409 /**
1410 Callback function when user presses "Change Attempt Order".
1411
1412 @retval EFI_INVALID_PARAMETER Any parameter is invalid.
1413 @retval EFI_OUT_OF_RESOURCES Does not have sufficient resources to finish this
1414 operation.
1415 @retval EFI_SUCCESS The operation is completed successfully.
1416
1417 **/
1418 EFI_STATUS
1419 IScsiConfigDisplayOrderAttempts (
1420 VOID
1421 )
1422 {
1423 EFI_STATUS Status;
1424 UINT8 Index;
1425 LIST_ENTRY *Entry;
1426 ISCSI_ATTEMPT_CONFIG_NVDATA *AttemptConfigData;
1427 VOID *StartOpCodeHandle;
1428 EFI_IFR_GUID_LABEL *StartLabel;
1429 VOID *EndOpCodeHandle;
1430 EFI_IFR_GUID_LABEL *EndLabel;
1431 VOID *OptionsOpCodeHandle;
1432
1433 Status = IScsiCreateOpCode (
1434 ORDER_ENTRY_LABEL,
1435 &StartOpCodeHandle,
1436 &StartLabel,
1437 &EndOpCodeHandle,
1438 &EndLabel
1439 );
1440 if (EFI_ERROR (Status)) {
1441 return Status;
1442 }
1443 ASSERT (StartOpCodeHandle != NULL);
1444
1445 OptionsOpCodeHandle = NULL;
1446
1447 //
1448 // If no attempt to be ordered, update the original form and exit.
1449 //
1450 if (mPrivate->AttemptCount == 0) {
1451 goto Exit;
1452 }
1453
1454 //
1455 // Create Option OpCode.
1456 //
1457 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1458 if (OptionsOpCodeHandle == NULL) {
1459 Status = EFI_OUT_OF_RESOURCES;
1460 goto Error;
1461 }
1462
1463 Index = 0;
1464
1465 NET_LIST_FOR_EACH (Entry, &mPrivate->AttemptConfigs) {
1466 AttemptConfigData = NET_LIST_USER_STRUCT (Entry, ISCSI_ATTEMPT_CONFIG_NVDATA, Link);
1467 HiiCreateOneOfOptionOpCode (
1468 OptionsOpCodeHandle,
1469 AttemptConfigData->AttemptTitleToken,
1470 0,
1471 EFI_IFR_NUMERIC_SIZE_1,
1472 AttemptConfigData->AttemptConfigIndex
1473 );
1474 Index++;
1475 }
1476
1477 ASSERT (Index == mPrivate->AttemptCount);
1478
1479 HiiCreateOrderedListOpCode (
1480 StartOpCodeHandle, // Container for dynamic created opcodes
1481 DYNAMIC_ORDERED_LIST_QUESTION_ID, // Question ID
1482 CONFIGURATION_VARSTORE_ID, // VarStore ID
1483 DYNAMIC_ORDERED_LIST_VAR_OFFSET, // Offset in Buffer Storage
1484 STRING_TOKEN (STR_ORDER_ATTEMPT_ENTRY), // Question prompt text
1485 STRING_TOKEN (STR_ORDER_ATTEMPT_ENTRY), // Question help text
1486 0, // Question flag
1487 EFI_IFR_UNIQUE_SET, // Ordered list flag, e.g. EFI_IFR_UNIQUE_SET
1488 EFI_IFR_NUMERIC_SIZE_1, // Data type of Question value
1489 ISCSI_MAX_ATTEMPTS_NUM, // Maximum container
1490 OptionsOpCodeHandle, // Option Opcode list
1491 NULL // Default Opcode is NULL
1492 );
1493
1494 Exit:
1495 Status = HiiUpdateForm (
1496 mCallbackInfo->RegisteredHandle, // HII handle
1497 &gIScsiConfigGuid, // Formset GUID
1498 FORMID_ORDER_FORM, // Form ID
1499 StartOpCodeHandle, // Label for where to insert opcodes
1500 EndOpCodeHandle // Replace data
1501 );
1502
1503 Error:
1504 HiiFreeOpCodeHandle (StartOpCodeHandle);
1505 HiiFreeOpCodeHandle (EndOpCodeHandle);
1506 if (OptionsOpCodeHandle != NULL) {
1507 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1508 }
1509
1510 return Status;
1511 }
1512
1513
1514 /**
1515 Callback function when user presses "Commit Changes and Exit" in Change Attempt Order.
1516
1517 @param[in] IfrNvData The IFR nv data.
1518
1519 @retval EFI_OUT_OF_RESOURCES Does not have sufficient resources to finish this
1520 operation.
1521 @retval EFI_NOT_FOUND Cannot find the corresponding variable.
1522 @retval EFI_SUCCESS The operation is completed successfully.
1523
1524 **/
1525 EFI_STATUS
1526 IScsiConfigOrderAttempts (
1527 IN ISCSI_CONFIG_IFR_NVDATA *IfrNvData
1528 )
1529 {
1530 EFI_STATUS Status;
1531 UINTN Index;
1532 UINTN Indexj;
1533 UINT8 AttemptConfigIndex;
1534 ISCSI_ATTEMPT_CONFIG_NVDATA *AttemptConfigData;
1535 UINT8 *AttemptConfigOrder;
1536 UINT8 *AttemptConfigOrderTmp;
1537 UINTN AttemptConfigOrderSize;
1538
1539 AttemptConfigOrder = IScsiGetVariableAndSize (
1540 L"AttemptOrder",
1541 &gIScsiConfigGuid,
1542 &AttemptConfigOrderSize
1543 );
1544 if (AttemptConfigOrder == NULL) {
1545 return EFI_NOT_FOUND;
1546 }
1547
1548 AttemptConfigOrderTmp = AllocateZeroPool (AttemptConfigOrderSize);
1549 if (AttemptConfigOrderTmp == NULL) {
1550 Status = EFI_OUT_OF_RESOURCES;
1551 goto Exit;
1552 }
1553
1554 for (Index = 0; Index < ISCSI_MAX_ATTEMPTS_NUM; Index++) {
1555 //
1556 // The real content ends with 0.
1557 //
1558 if (IfrNvData->DynamicOrderedList[Index] == 0) {
1559 break;
1560 }
1561
1562 AttemptConfigIndex = IfrNvData->DynamicOrderedList[Index];
1563 AttemptConfigData = IScsiConfigGetAttemptByConfigIndex (AttemptConfigIndex);
1564 if (AttemptConfigData == NULL) {
1565 Status = EFI_NOT_FOUND;
1566 goto Exit;
1567 }
1568
1569 //
1570 // Reorder the Attempt List.
1571 //
1572 RemoveEntryList (&AttemptConfigData->Link);
1573 InsertTailList (&mPrivate->AttemptConfigs, &AttemptConfigData->Link);
1574
1575 AttemptConfigOrderTmp[Index] = AttemptConfigIndex;
1576
1577 //
1578 // Mark it to be deleted - 0.
1579 //
1580 for (Indexj = 0; Indexj < AttemptConfigOrderSize / sizeof (UINT8); Indexj++) {
1581 if (AttemptConfigOrder[Indexj] == AttemptConfigIndex) {
1582 AttemptConfigOrder[Indexj] = 0;
1583 break;
1584 }
1585 }
1586 }
1587
1588 //
1589 // Adjust the attempt order in NVR.
1590 //
1591 for (; Index < AttemptConfigOrderSize / sizeof (UINT8); Index++) {
1592 for (Indexj = 0; Indexj < AttemptConfigOrderSize / sizeof (UINT8); Indexj++) {
1593 if (AttemptConfigOrder[Indexj] != 0) {
1594 AttemptConfigOrderTmp[Index] = AttemptConfigOrder[Indexj];
1595 AttemptConfigOrder[Indexj] = 0;
1596 continue;
1597 }
1598 }
1599 }
1600
1601 Status = gRT->SetVariable (
1602 L"AttemptOrder",
1603 &gIScsiConfigGuid,
1604 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,
1605 AttemptConfigOrderSize,
1606 AttemptConfigOrderTmp
1607 );
1608
1609 Exit:
1610 if (AttemptConfigOrderTmp != NULL) {
1611 FreePool (AttemptConfigOrderTmp);
1612 }
1613
1614 FreePool (AttemptConfigOrder);
1615 return Status;
1616 }
1617
1618
1619 /**
1620 Callback function when a user presses "Attempt *" or when a user selects a NIC to
1621 create the new attempt.
1622
1623 @param[in] KeyValue A unique value which is sent to the original
1624 exporting driver so that it can identify the type
1625 of data to expect.
1626 @param[in] IfrNvData The IFR nv data.
1627
1628 @retval EFI_OUT_OF_RESOURCES Does not have sufficient resources to finish this
1629 operation.
1630 @retval EFI_NOT_FOUND Cannot find the corresponding variable.
1631 @retval EFI_SUCCESS The operation is completed successfully.
1632
1633 **/
1634 EFI_STATUS
1635 IScsiConfigProcessDefault (
1636 IN EFI_QUESTION_ID KeyValue,
1637 IN ISCSI_CONFIG_IFR_NVDATA *IfrNvData
1638 )
1639 {
1640 BOOLEAN NewAttempt;
1641 ISCSI_ATTEMPT_CONFIG_NVDATA *AttemptConfigData;
1642 ISCSI_SESSION_CONFIG_NVDATA *ConfigData;
1643 UINT8 CurrentAttemptConfigIndex;
1644 ISCSI_NIC_INFO *NicInfo;
1645 UINT8 NicIndex;
1646 CHAR16 MacString[ISCSI_MAX_MAC_STRING_LEN];
1647 UINT8 *AttemptConfigOrder;
1648 UINTN AttemptConfigOrderSize;
1649 UINTN TotalNumber;
1650 UINTN Index;
1651
1652 //
1653 // Is User creating a new attempt?
1654 //
1655 NewAttempt = FALSE;
1656
1657 if ((KeyValue >= KEY_MAC_ENTRY_BASE) &&
1658 (KeyValue <= (UINT16) (mPrivate->MaxNic + KEY_MAC_ENTRY_BASE))) {
1659 //
1660 // User has pressed "Add an Attempt" and then selects a NIC.
1661 //
1662 NewAttempt = TRUE;
1663 } else if ((KeyValue >= KEY_ATTEMPT_ENTRY_BASE) &&
1664 (KeyValue < (ISCSI_MAX_ATTEMPTS_NUM + KEY_ATTEMPT_ENTRY_BASE))) {
1665
1666 //
1667 // User has pressed "Attempt *".
1668 //
1669 NewAttempt = FALSE;
1670 } else {
1671 //
1672 // Don't process anything.
1673 //
1674 return EFI_SUCCESS;
1675 }
1676
1677 //
1678 // Free any attempt that is previously created but not saved to system.
1679 //
1680 if (mPrivate->NewAttempt != NULL) {
1681 FreePool (mPrivate->NewAttempt);
1682 mPrivate->NewAttempt = NULL;
1683 }
1684
1685 if (NewAttempt) {
1686 //
1687 // Determine which NIC user has selected for the new created attempt.
1688 //
1689 NicIndex = (UINT8) (KeyValue - KEY_MAC_ENTRY_BASE);
1690 NicInfo = IScsiGetNicInfoByIndex (NicIndex);
1691 if (NicInfo == NULL) {
1692 return EFI_NOT_FOUND;
1693 }
1694
1695 //
1696 // Create new attempt.
1697 //
1698
1699 AttemptConfigData = AllocateZeroPool (sizeof (ISCSI_ATTEMPT_CONFIG_NVDATA));
1700 if (AttemptConfigData == NULL) {
1701 return EFI_OUT_OF_RESOURCES;
1702 }
1703
1704 ConfigData = &AttemptConfigData->SessionConfigData;
1705 ConfigData->TargetPort = ISCSI_WELL_KNOWN_PORT;
1706 ConfigData->ConnectTimeout = CONNECT_DEFAULT_TIMEOUT;
1707 ConfigData->ConnectRetryCount = CONNECT_MIN_RETRY;
1708
1709 AttemptConfigData->AuthenticationType = ISCSI_AUTH_TYPE_CHAP;
1710 AttemptConfigData->AuthConfigData.CHAP.CHAPType = ISCSI_CHAP_UNI;
1711
1712 //
1713 // Get current order number for this attempt.
1714 //
1715 AttemptConfigOrder = IScsiGetVariableAndSize (
1716 L"AttemptOrder",
1717 &gIScsiConfigGuid,
1718 &AttemptConfigOrderSize
1719 );
1720
1721 TotalNumber = AttemptConfigOrderSize / sizeof (UINT8);
1722
1723 if (AttemptConfigOrder == NULL) {
1724 CurrentAttemptConfigIndex = 1;
1725 } else {
1726 //
1727 // Get the max attempt config index.
1728 //
1729 CurrentAttemptConfigIndex = AttemptConfigOrder[0];
1730 for (Index = 1; Index < TotalNumber; Index++) {
1731 if (CurrentAttemptConfigIndex < AttemptConfigOrder[Index]) {
1732 CurrentAttemptConfigIndex = AttemptConfigOrder[Index];
1733 }
1734 }
1735
1736 CurrentAttemptConfigIndex++;
1737 }
1738
1739 TotalNumber++;
1740
1741 //
1742 // Record the mapping between attempt order and attempt's configdata.
1743 //
1744 AttemptConfigData->AttemptConfigIndex = CurrentAttemptConfigIndex;
1745
1746 if (AttemptConfigOrder != NULL) {
1747 FreePool (AttemptConfigOrder);
1748 }
1749
1750 //
1751 // Record the MAC info in Config Data.
1752 //
1753 IScsiMacAddrToStr (
1754 &NicInfo->PermanentAddress,
1755 NicInfo->HwAddressSize,
1756 NicInfo->VlanId,
1757 MacString
1758 );
1759
1760 UnicodeStrToAsciiStrS (MacString, AttemptConfigData->MacString, sizeof (AttemptConfigData->MacString));
1761 AttemptConfigData->NicIndex = NicIndex;
1762
1763 //
1764 // Generate OUI-format ISID based on MAC address.
1765 //
1766 CopyMem (AttemptConfigData->SessionConfigData.IsId, &NicInfo->PermanentAddress, 6);
1767 AttemptConfigData->SessionConfigData.IsId[0] =
1768 (UINT8) (AttemptConfigData->SessionConfigData.IsId[0] & 0x3F);
1769
1770 //
1771 // Add the help info for the new attempt.
1772 //
1773 UnicodeSPrint (
1774 mPrivate->PortString,
1775 (UINTN) ISCSI_NAME_IFR_MAX_SIZE,
1776 L"MAC: %s, PFA: Bus %d | Dev %d | Func %d",
1777 MacString,
1778 NicInfo->BusNumber,
1779 NicInfo->DeviceNumber,
1780 NicInfo->FunctionNumber
1781 );
1782
1783 AttemptConfigData->AttemptTitleHelpToken = HiiSetString (
1784 mCallbackInfo->RegisteredHandle,
1785 0,
1786 mPrivate->PortString,
1787 NULL
1788 );
1789 if (AttemptConfigData->AttemptTitleHelpToken == 0) {
1790 FreePool (AttemptConfigData);
1791 return EFI_INVALID_PARAMETER;
1792 }
1793
1794 //
1795 // Set the attempt name to default.
1796 //
1797 UnicodeSPrint (
1798 mPrivate->PortString,
1799 (UINTN) 128,
1800 L"%d",
1801 (UINTN) AttemptConfigData->AttemptConfigIndex
1802 );
1803 UnicodeStrToAsciiStrS (mPrivate->PortString, AttemptConfigData->AttemptName, sizeof (AttemptConfigData->AttemptName));
1804
1805 //
1806 // Save the created Attempt temporarily. If user does not save the attempt
1807 // by press 'KEY_SAVE_ATTEMPT_CONFIG' later, iSCSI driver would know that
1808 // and free resources.
1809 //
1810 mPrivate->NewAttempt = (VOID *) AttemptConfigData;
1811
1812 } else {
1813 //
1814 // Determine which Attempt user has selected to configure.
1815 // Get the attempt configuration data.
1816 //
1817 CurrentAttemptConfigIndex = (UINT8) (KeyValue - KEY_ATTEMPT_ENTRY_BASE);
1818
1819 AttemptConfigData = IScsiConfigGetAttemptByConfigIndex (CurrentAttemptConfigIndex);
1820 if (AttemptConfigData == NULL) {
1821 DEBUG ((DEBUG_ERROR, "Corresponding configuration data can not be retrieved!\n"));
1822 return EFI_NOT_FOUND;
1823 }
1824 }
1825
1826 //
1827 // Clear the old IFR data to avoid sharing it with other attempts.
1828 //
1829 if (IfrNvData->AuthenticationType == ISCSI_AUTH_TYPE_CHAP) {
1830 ZeroMem (IfrNvData->CHAPName, sizeof (IfrNvData->CHAPName));
1831 ZeroMem (IfrNvData->CHAPSecret, sizeof (IfrNvData->CHAPSecret));
1832 ZeroMem (IfrNvData->ReverseCHAPName, sizeof (IfrNvData->ReverseCHAPName));
1833 ZeroMem (IfrNvData->ReverseCHAPSecret, sizeof (IfrNvData->ReverseCHAPSecret));
1834 }
1835
1836 IScsiConvertAttemptConfigDataToIfrNvData (AttemptConfigData, IfrNvData);
1837
1838 //
1839 // Update current attempt to be a new created attempt or an existing attempt.
1840 //
1841 mCallbackInfo->Current = AttemptConfigData;
1842
1843 return EFI_SUCCESS;
1844 }
1845
1846
1847 /**
1848
1849 This function allows the caller to request the current
1850 configuration for one or more named elements. The resulting
1851 string is in <ConfigAltResp> format. Also, any and all alternative
1852 configuration strings shall be appended to the end of the
1853 current configuration string. If they are, they must appear
1854 after the current configuration. They must contain the same
1855 routing (GUID, NAME, PATH) as the current configuration string.
1856 They must have an additional description indicating the type of
1857 alternative configuration the string represents,
1858 "ALTCFG=<StringToken>". That <StringToken> (when
1859 converted from Hex UNICODE to binary) is a reference to a
1860 string in the associated string pack.
1861
1862 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1863
1864 @param[in] Request A null-terminated Unicode string in
1865 <ConfigRequest> format. Note that this
1866 includes the routing information as well as
1867 the configurable name / value pairs. It is
1868 invalid for this string to be in
1869 <MultiConfigRequest> format.
1870
1871 @param[out] Progress On return, points to a character in the
1872 Request string. Points to the string's null
1873 terminator if request was successful. Points
1874 to the most recent "&" before the first
1875 failing name / value pair (or the beginning
1876 of the string if the failure is in the first
1877 name / value pair) if the request was not successful.
1878
1879 @param[out] Results A null-terminated Unicode string in
1880 <ConfigAltResp> format which has all values
1881 filled in for the names in the Request string.
1882 String to be allocated by the called function.
1883
1884 @retval EFI_SUCCESS The Results string is filled with the
1885 values corresponding to all requested
1886 names.
1887
1888 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the
1889 parts of the results that must be
1890 stored awaiting possible future
1891 protocols.
1892
1893 @retval EFI_INVALID_PARAMETER For example, passing in a NULL
1894 for the Request parameter
1895 would result in this type of
1896 error. In this case, the
1897 Progress parameter would be
1898 set to NULL.
1899
1900 @retval EFI_NOT_FOUND Routing data doesn't match any
1901 known driver. Progress set to the
1902 first character in the routing header.
1903 Note: There is no requirement that the
1904 driver validate the routing data. It
1905 must skip the <ConfigHdr> in order to
1906 process the names.
1907
1908 @retval EFI_INVALID_PARAMETER Illegal syntax. Progress set
1909 to most recent "&" before the
1910 error or the beginning of the
1911 string.
1912
1913 @retval EFI_INVALID_PARAMETER Unknown name. Progress points
1914 to the & before the name in
1915 question.
1916
1917 **/
1918 EFI_STATUS
1919 EFIAPI
1920 IScsiFormExtractConfig (
1921 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
1922 IN CONST EFI_STRING Request,
1923 OUT EFI_STRING *Progress,
1924 OUT EFI_STRING *Results
1925 )
1926 {
1927 EFI_STATUS Status;
1928 CHAR8 *InitiatorName;
1929 UINTN BufferSize;
1930 ISCSI_CONFIG_IFR_NVDATA *IfrNvData;
1931 ISCSI_FORM_CALLBACK_INFO *Private;
1932 EFI_STRING ConfigRequestHdr;
1933 EFI_STRING ConfigRequest;
1934 BOOLEAN AllocatedRequest;
1935 UINTN Size;
1936
1937 if (This == NULL || Progress == NULL || Results == NULL) {
1938 return EFI_INVALID_PARAMETER;
1939 }
1940
1941 *Progress = Request;
1942 if ((Request != NULL) && !HiiIsConfigHdrMatch (Request, &gIScsiConfigGuid, mVendorStorageName)) {
1943 return EFI_NOT_FOUND;
1944 }
1945
1946 ConfigRequestHdr = NULL;
1947 ConfigRequest = NULL;
1948 AllocatedRequest = FALSE;
1949 Size = 0;
1950
1951 Private = ISCSI_FORM_CALLBACK_INFO_FROM_FORM_CALLBACK (This);
1952 IfrNvData = AllocateZeroPool (sizeof (ISCSI_CONFIG_IFR_NVDATA));
1953 if (IfrNvData == NULL) {
1954 return EFI_OUT_OF_RESOURCES;
1955 }
1956
1957 if (Private->Current != NULL) {
1958 IScsiConvertAttemptConfigDataToIfrNvData (Private->Current, IfrNvData);
1959 }
1960
1961 BufferSize = ISCSI_NAME_MAX_SIZE;
1962 InitiatorName = (CHAR8 *) AllocateZeroPool (BufferSize);
1963 if (InitiatorName == NULL) {
1964 FreePool (IfrNvData);
1965 return EFI_OUT_OF_RESOURCES;
1966 }
1967
1968 Status = gIScsiInitiatorName.Get (&gIScsiInitiatorName, &BufferSize, InitiatorName);
1969 if (EFI_ERROR (Status)) {
1970 IfrNvData->InitiatorName[0] = L'\0';
1971 } else {
1972 AsciiStrToUnicodeStrS (
1973 InitiatorName,
1974 IfrNvData->InitiatorName,
1975 sizeof (IfrNvData->InitiatorName) / sizeof (IfrNvData->InitiatorName[0])
1976 );
1977 }
1978
1979 //
1980 // Convert buffer data to <ConfigResp> by helper function BlockToConfig().
1981 //
1982 BufferSize = sizeof (ISCSI_CONFIG_IFR_NVDATA);
1983 ConfigRequest = Request;
1984 if ((Request == NULL) || (StrStr (Request, L"OFFSET") == NULL)) {
1985 //
1986 // Request has no request element, construct full request string.
1987 // Allocate and fill a buffer large enough to hold the <ConfigHdr> template
1988 // followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator
1989 //
1990 ConfigRequestHdr = HiiConstructConfigHdr (&gIScsiConfigGuid, mVendorStorageName, Private->DriverHandle);
1991 Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16);
1992 ConfigRequest = AllocateZeroPool (Size);
1993 if (ConfigRequest == NULL) {
1994 FreePool (IfrNvData);
1995 FreePool (InitiatorName);
1996 return EFI_OUT_OF_RESOURCES;
1997 }
1998 AllocatedRequest = TRUE;
1999 UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", ConfigRequestHdr, (UINT64)BufferSize);
2000 FreePool (ConfigRequestHdr);
2001 }
2002
2003 Status = gHiiConfigRouting->BlockToConfig (
2004 gHiiConfigRouting,
2005 ConfigRequest,
2006 (UINT8 *) IfrNvData,
2007 BufferSize,
2008 Results,
2009 Progress
2010 );
2011 FreePool (IfrNvData);
2012 FreePool (InitiatorName);
2013
2014 //
2015 // Free the allocated config request string.
2016 //
2017 if (AllocatedRequest) {
2018 FreePool (ConfigRequest);
2019 ConfigRequest = NULL;
2020 }
2021 //
2022 // Set Progress string to the original request string.
2023 //
2024 if (Request == NULL) {
2025 *Progress = NULL;
2026 } else if (StrStr (Request, L"OFFSET") == NULL) {
2027 *Progress = Request + StrLen (Request);
2028 }
2029
2030 return Status;
2031 }
2032
2033
2034 /**
2035
2036 This function applies changes in a driver's configuration.
2037 Input is a Configuration, which has the routing data for this
2038 driver followed by name / value configuration pairs. The driver
2039 must apply those pairs to its configurable storage. If the
2040 driver's configuration is stored in a linear block of data
2041 and the driver's name / value pairs are in <BlockConfig>
2042 format, it may use the ConfigToBlock helper function (above) to
2043 simplify the job.
2044
2045 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
2046
2047 @param[in] Configuration A null-terminated Unicode string in
2048 <ConfigString> format.
2049
2050 @param[out] Progress A pointer to a string filled in with the
2051 offset of the most recent '&' before the
2052 first failing name / value pair (or the
2053 beginning of the string if the failure
2054 is in the first name / value pair) or
2055 the terminating NULL if all was
2056 successful.
2057
2058 @retval EFI_SUCCESS The results have been distributed or are
2059 awaiting distribution.
2060
2061 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the
2062 parts of the results that must be
2063 stored awaiting possible future
2064 protocols.
2065
2066 @retval EFI_INVALID_PARAMETERS Passing in a NULL for the
2067 Results parameter would result
2068 in this type of error.
2069
2070 @retval EFI_NOT_FOUND Target for the specified routing data
2071 was not found.
2072
2073 **/
2074 EFI_STATUS
2075 EFIAPI
2076 IScsiFormRouteConfig (
2077 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
2078 IN CONST EFI_STRING Configuration,
2079 OUT EFI_STRING *Progress
2080 )
2081 {
2082 if (This == NULL || Configuration == NULL || Progress == NULL) {
2083 return EFI_INVALID_PARAMETER;
2084 }
2085
2086 //
2087 // Check routing data in <ConfigHdr>.
2088 // Note: if only one Storage is used, then this checking could be skipped.
2089 //
2090 if (!HiiIsConfigHdrMatch (Configuration, &gIScsiConfigGuid, mVendorStorageName)) {
2091 *Progress = Configuration;
2092 return EFI_NOT_FOUND;
2093 }
2094
2095 *Progress = Configuration + StrLen (Configuration);
2096 return EFI_SUCCESS;
2097 }
2098
2099
2100 /**
2101
2102 This function is called to provide results data to the driver.
2103 This data consists of a unique key that is used to identify
2104 which data is either being passed back or being asked for.
2105
2106 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
2107 @param[in] Action Specifies the type of action taken by the browser.
2108 @param[in] QuestionId A unique value which is sent to the original
2109 exporting driver so that it can identify the type
2110 of data to expect. The format of the data tends to
2111 vary based on the opcode that generated the callback.
2112 @param[in] Type The type of value for the question.
2113 @param[in, out] Value A pointer to the data being sent to the original
2114 exporting driver.
2115 @param[out] ActionRequest On return, points to the action requested by the
2116 callback function.
2117
2118 @retval EFI_SUCCESS The callback successfully handled the action.
2119 @retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the
2120 variable and its data.
2121 @retval EFI_DEVICE_ERROR The variable could not be saved.
2122 @retval EFI_UNSUPPORTED The specified Action is not supported by the
2123 callback.
2124 **/
2125 EFI_STATUS
2126 EFIAPI
2127 IScsiFormCallback (
2128 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
2129 IN EFI_BROWSER_ACTION Action,
2130 IN EFI_QUESTION_ID QuestionId,
2131 IN UINT8 Type,
2132 IN OUT EFI_IFR_TYPE_VALUE *Value,
2133 OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest
2134 )
2135 {
2136 ISCSI_FORM_CALLBACK_INFO *Private;
2137 UINTN BufferSize;
2138 CHAR8 *IScsiName;
2139 CHAR8 IpString[IP_STR_MAX_SIZE];
2140 CHAR8 LunString[ISCSI_LUN_STR_MAX_LEN];
2141 UINT64 Lun;
2142 EFI_IP_ADDRESS HostIp;
2143 EFI_IP_ADDRESS SubnetMask;
2144 EFI_IP_ADDRESS Gateway;
2145 ISCSI_CONFIG_IFR_NVDATA *IfrNvData;
2146 ISCSI_CONFIG_IFR_NVDATA OldIfrNvData;
2147 EFI_STATUS Status;
2148 CHAR16 AttemptName[ATTEMPT_NAME_SIZE + 4];
2149 EFI_INPUT_KEY Key;
2150
2151 if ((Action == EFI_BROWSER_ACTION_FORM_OPEN) || (Action == EFI_BROWSER_ACTION_FORM_CLOSE)) {
2152 //
2153 // Do nothing for UEFI OPEN/CLOSE Action
2154 //
2155 return EFI_SUCCESS;
2156 }
2157
2158 if ((Action != EFI_BROWSER_ACTION_CHANGING) && (Action != EFI_BROWSER_ACTION_CHANGED)) {
2159 //
2160 // All other type return unsupported.
2161 //
2162 return EFI_UNSUPPORTED;
2163 }
2164
2165 if ((Value == NULL) || (ActionRequest == NULL)) {
2166 return EFI_INVALID_PARAMETER;
2167 }
2168
2169 Private = ISCSI_FORM_CALLBACK_INFO_FROM_FORM_CALLBACK (This);
2170
2171 //
2172 // Retrieve uncommitted data from Browser
2173 //
2174
2175 BufferSize = sizeof (ISCSI_CONFIG_IFR_NVDATA);
2176 IfrNvData = AllocateZeroPool (BufferSize);
2177 if (IfrNvData == NULL) {
2178 return EFI_OUT_OF_RESOURCES;
2179 }
2180
2181 IScsiName = (CHAR8 *) AllocateZeroPool (ISCSI_NAME_MAX_SIZE);
2182 if (IScsiName == NULL) {
2183 FreePool (IfrNvData);
2184 return EFI_OUT_OF_RESOURCES;
2185 }
2186
2187 Status = EFI_SUCCESS;
2188
2189 ZeroMem (&OldIfrNvData, BufferSize);
2190
2191 HiiGetBrowserData (NULL, NULL, BufferSize, (UINT8 *) IfrNvData);
2192
2193 CopyMem (&OldIfrNvData, IfrNvData, BufferSize);
2194
2195 if (Action == EFI_BROWSER_ACTION_CHANGING) {
2196 switch (QuestionId) {
2197 case KEY_ADD_ATTEMPT:
2198 //
2199 // Check whether iSCSI initiator name is configured already.
2200 //
2201 mPrivate->InitiatorNameLength = ISCSI_NAME_MAX_SIZE;
2202 Status = gIScsiInitiatorName.Get (
2203 &gIScsiInitiatorName,
2204 &mPrivate->InitiatorNameLength,
2205 mPrivate->InitiatorName
2206 );
2207 if (EFI_ERROR (Status)) {
2208 CreatePopUp (
2209 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
2210 &Key,
2211 L"Error: please configure iSCSI initiator name first!",
2212 NULL
2213 );
2214 break;
2215 }
2216
2217 Status = IScsiConfigAddAttempt ();
2218 break;
2219
2220 case KEY_DELETE_ATTEMPT:
2221 CopyMem (
2222 OldIfrNvData.DeleteAttemptList,
2223 IfrNvData->DeleteAttemptList,
2224 sizeof (IfrNvData->DeleteAttemptList)
2225 );
2226 Status = IScsiConfigDisplayDeleteAttempts (IfrNvData);
2227 break;
2228
2229 case KEY_ORDER_ATTEMPT_CONFIG:
2230 //
2231 // Order the attempt according to user input.
2232 //
2233 CopyMem (
2234 OldIfrNvData.DynamicOrderedList,
2235 IfrNvData->DynamicOrderedList,
2236 sizeof (IfrNvData->DynamicOrderedList)
2237 );
2238 IScsiConfigDisplayOrderAttempts ();
2239 break;
2240
2241 default:
2242 Status = IScsiConfigProcessDefault (QuestionId, IfrNvData);
2243 break;
2244 }
2245 } else if (Action == EFI_BROWSER_ACTION_CHANGED) {
2246 switch (QuestionId) {
2247 case KEY_INITIATOR_NAME:
2248 UnicodeStrToAsciiStrS (IfrNvData->InitiatorName, IScsiName, ISCSI_NAME_MAX_SIZE);
2249 BufferSize = AsciiStrSize (IScsiName);
2250
2251 Status = gIScsiInitiatorName.Set (&gIScsiInitiatorName, &BufferSize, IScsiName);
2252 if (EFI_ERROR (Status)) {
2253 CreatePopUp (
2254 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
2255 &Key,
2256 L"Invalid iSCSI Name!",
2257 NULL
2258 );
2259 }
2260
2261 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY;
2262 break;
2263 case KEY_ATTEMPT_NAME:
2264 if (StrLen (IfrNvData->AttemptName) > ATTEMPT_NAME_SIZE) {
2265 CopyMem (AttemptName, IfrNvData->AttemptName, ATTEMPT_NAME_SIZE * sizeof (CHAR16));
2266 CopyMem (&AttemptName[ATTEMPT_NAME_SIZE], L"...", 4 * sizeof (CHAR16));
2267 } else {
2268 CopyMem (
2269 AttemptName,
2270 IfrNvData->AttemptName,
2271 (StrLen (IfrNvData->AttemptName) + 1) * sizeof (CHAR16)
2272 );
2273 }
2274
2275 UnicodeStrToAsciiStrS (IfrNvData->AttemptName, Private->Current->AttemptName, sizeof (Private->Current->AttemptName));
2276
2277 IScsiConfigUpdateAttempt ();
2278
2279 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY;
2280 break;
2281
2282 case KEY_SAVE_ATTEMPT_CONFIG:
2283 Status = IScsiConvertIfrNvDataToAttemptConfigData (IfrNvData, Private->Current);
2284 if (EFI_ERROR (Status)) {
2285 break;
2286 }
2287
2288 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY;
2289 break;
2290
2291 case KEY_SAVE_ORDER_CHANGES:
2292 //
2293 // Sync the Attempt Order to NVR.
2294 //
2295 Status = IScsiConfigOrderAttempts (IfrNvData);
2296 if (EFI_ERROR (Status)) {
2297 break;
2298 }
2299
2300 IScsiConfigUpdateAttempt ();
2301 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;
2302 break;
2303
2304 case KEY_IGNORE_ORDER_CHANGES:
2305 CopyMem (
2306 IfrNvData->DynamicOrderedList,
2307 OldIfrNvData.DynamicOrderedList,
2308 sizeof (IfrNvData->DynamicOrderedList)
2309 );
2310 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT;
2311 break;
2312
2313 case KEY_SAVE_DELETE_ATTEMPT:
2314 //
2315 // Delete the Attempt Order from NVR
2316 //
2317 Status = IScsiConfigDeleteAttempts (IfrNvData);
2318 if (EFI_ERROR (Status)) {
2319 break;
2320 }
2321
2322 IScsiConfigUpdateAttempt ();
2323 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;
2324 break;
2325
2326 case KEY_IGNORE_DELETE_ATTEMPT:
2327 CopyMem (
2328 IfrNvData->DeleteAttemptList,
2329 OldIfrNvData.DeleteAttemptList,
2330 sizeof (IfrNvData->DeleteAttemptList)
2331 );
2332 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT;
2333 break;
2334
2335 case KEY_IP_MODE:
2336 switch (Value->u8) {
2337 case IP_MODE_IP6:
2338 ZeroMem (IfrNvData->TargetIp, sizeof (IfrNvData->TargetIp));
2339 IScsiIpToStr (&Private->Current->SessionConfigData.TargetIp, TRUE, IfrNvData->TargetIp);
2340 Private->Current->AutoConfigureMode = 0;
2341 break;
2342
2343 case IP_MODE_IP4:
2344 ZeroMem (IfrNvData->TargetIp, sizeof (IfrNvData->TargetIp));
2345 IScsiIpToStr (&Private->Current->SessionConfigData.TargetIp, FALSE, IfrNvData->TargetIp);
2346 Private->Current->AutoConfigureMode = 0;
2347
2348 break;
2349 }
2350
2351 break;
2352
2353 case KEY_LOCAL_IP:
2354 Status = NetLibStrToIp4 (IfrNvData->LocalIp, &HostIp.v4);
2355 if (EFI_ERROR (Status) ||
2356 ((Private->Current->SessionConfigData.SubnetMask.Addr[0] != 0) &&
2357 !NetIp4IsUnicast (NTOHL (HostIp.Addr[0]), NTOHL(*(UINT32*)Private->Current->SessionConfigData.SubnetMask.Addr)))) {
2358 CreatePopUp (
2359 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
2360 &Key,
2361 L"Invalid IP address!",
2362 NULL
2363 );
2364
2365 Status = EFI_INVALID_PARAMETER;
2366 } else {
2367 CopyMem (&Private->Current->SessionConfigData.LocalIp, &HostIp.v4, sizeof (HostIp.v4));
2368 }
2369
2370 break;
2371
2372 case KEY_SUBNET_MASK:
2373 Status = NetLibStrToIp4 (IfrNvData->SubnetMask, &SubnetMask.v4);
2374 if (EFI_ERROR (Status) || ((SubnetMask.Addr[0] != 0) && (IScsiGetSubnetMaskPrefixLength (&SubnetMask.v4) == 0))) {
2375 CreatePopUp (
2376 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
2377 &Key,
2378 L"Invalid Subnet Mask!",
2379 NULL
2380 );
2381
2382 Status = EFI_INVALID_PARAMETER;
2383 } else {
2384 CopyMem (&Private->Current->SessionConfigData.SubnetMask, &SubnetMask.v4, sizeof (SubnetMask.v4));
2385 }
2386
2387 break;
2388
2389 case KEY_GATE_WAY:
2390 Status = NetLibStrToIp4 (IfrNvData->Gateway, &Gateway.v4);
2391 if (EFI_ERROR (Status) ||
2392 ((Gateway.Addr[0] != 0) &&
2393 (Private->Current->SessionConfigData.SubnetMask.Addr[0] != 0) &&
2394 !NetIp4IsUnicast (NTOHL (Gateway.Addr[0]), NTOHL(*(UINT32*)Private->Current->SessionConfigData.SubnetMask.Addr)))) {
2395 CreatePopUp (
2396 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
2397 &Key,
2398 L"Invalid Gateway!",
2399 NULL
2400 );
2401 Status = EFI_INVALID_PARAMETER;
2402 } else {
2403 CopyMem (&Private->Current->SessionConfigData.Gateway, &Gateway.v4, sizeof (Gateway.v4));
2404 }
2405
2406 break;
2407
2408 case KEY_TARGET_IP:
2409 UnicodeStrToAsciiStrS (IfrNvData->TargetIp, IpString, sizeof (IpString));
2410 Status = IScsiAsciiStrToIp (IpString, IfrNvData->IpMode, &HostIp);
2411 if (EFI_ERROR (Status) || IP4_IS_LOCAL_BROADCAST (EFI_NTOHL(HostIp.v4)) || IP4_IS_UNSPECIFIED (EFI_NTOHL(HostIp.v4))) {
2412 CreatePopUp (
2413 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
2414 &Key,
2415 L"Invalid IP address!",
2416 NULL
2417 );
2418 Status = EFI_INVALID_PARAMETER;
2419 } else {
2420 CopyMem (&Private->Current->SessionConfigData.TargetIp, &HostIp, sizeof (HostIp));
2421 }
2422
2423 break;
2424
2425 case KEY_TARGET_NAME:
2426 UnicodeStrToAsciiStrS (IfrNvData->TargetName, IScsiName, ISCSI_NAME_MAX_SIZE);
2427 Status = IScsiNormalizeName (IScsiName, AsciiStrLen (IScsiName));
2428 if (EFI_ERROR (Status)) {
2429 CreatePopUp (
2430 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
2431 &Key,
2432 L"Invalid iSCSI Name!",
2433 NULL
2434 );
2435 } else {
2436 AsciiStrCpyS (Private->Current->SessionConfigData.TargetName, ISCSI_NAME_MAX_SIZE, IScsiName);
2437 }
2438
2439 break;
2440
2441 case KEY_DHCP_ENABLE:
2442 if (IfrNvData->InitiatorInfoFromDhcp == 0) {
2443 IfrNvData->TargetInfoFromDhcp = 0;
2444 }
2445
2446 break;
2447
2448 case KEY_BOOT_LUN:
2449 UnicodeStrToAsciiStrS (IfrNvData->BootLun, LunString, sizeof (LunString));
2450 Status = IScsiAsciiStrToLun (LunString, (UINT8 *) &Lun);
2451 if (EFI_ERROR (Status)) {
2452 CreatePopUp (
2453 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
2454 &Key,
2455 L"Invalid LUN string!",
2456 NULL
2457 );
2458 } else {
2459 CopyMem (Private->Current->SessionConfigData.BootLun, &Lun, sizeof (Lun));
2460 }
2461
2462 break;
2463
2464 case KEY_AUTH_TYPE:
2465 switch (Value->u8) {
2466 case ISCSI_AUTH_TYPE_CHAP:
2467 IfrNvData->CHAPType = ISCSI_CHAP_UNI;
2468 break;
2469 default:
2470 break;
2471 }
2472
2473 break;
2474
2475 case KEY_CHAP_NAME:
2476 UnicodeStrToAsciiStrS (
2477 IfrNvData->CHAPName,
2478 Private->Current->AuthConfigData.CHAP.CHAPName,
2479 sizeof (Private->Current->AuthConfigData.CHAP.CHAPName)
2480 );
2481 break;
2482
2483 case KEY_CHAP_SECRET:
2484 UnicodeStrToAsciiStrS (
2485 IfrNvData->CHAPSecret,
2486 Private->Current->AuthConfigData.CHAP.CHAPSecret,
2487 sizeof (Private->Current->AuthConfigData.CHAP.CHAPSecret)
2488 );
2489 break;
2490
2491 case KEY_REVERSE_CHAP_NAME:
2492 UnicodeStrToAsciiStrS (
2493 IfrNvData->ReverseCHAPName,
2494 Private->Current->AuthConfigData.CHAP.ReverseCHAPName,
2495 sizeof (Private->Current->AuthConfigData.CHAP.ReverseCHAPName)
2496 );
2497 break;
2498
2499 case KEY_REVERSE_CHAP_SECRET:
2500 UnicodeStrToAsciiStrS (
2501 IfrNvData->ReverseCHAPSecret,
2502 Private->Current->AuthConfigData.CHAP.ReverseCHAPSecret,
2503 sizeof (Private->Current->AuthConfigData.CHAP.ReverseCHAPSecret)
2504 );
2505 break;
2506
2507 case KEY_CONFIG_ISID:
2508 IScsiParseIsIdFromString (IfrNvData->IsId, Private->Current->SessionConfigData.IsId);
2509 IScsiConvertIsIdToString (IfrNvData->IsId, Private->Current->SessionConfigData.IsId);
2510
2511 break;
2512
2513 default:
2514 break;
2515 }
2516 }
2517
2518 if (!EFI_ERROR (Status)) {
2519 //
2520 // Pass changed uncommitted data back to Form Browser.
2521 //
2522 BufferSize = sizeof (ISCSI_CONFIG_IFR_NVDATA);
2523 HiiSetBrowserData (NULL, NULL, BufferSize, (UINT8 *) IfrNvData, NULL);
2524 }
2525
2526 FreePool (IfrNvData);
2527 FreePool (IScsiName);
2528
2529 return Status;
2530 }
2531
2532
2533 /**
2534 Initialize the iSCSI configuration form.
2535
2536 @param[in] DriverBindingHandle The iSCSI driverbinding handle.
2537
2538 @retval EFI_SUCCESS The iSCSI configuration form is initialized.
2539 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
2540
2541 **/
2542 EFI_STATUS
2543 IScsiConfigFormInit (
2544 IN EFI_HANDLE DriverBindingHandle
2545 )
2546 {
2547 EFI_STATUS Status;
2548 ISCSI_FORM_CALLBACK_INFO *CallbackInfo;
2549
2550 CallbackInfo = (ISCSI_FORM_CALLBACK_INFO *) AllocateZeroPool (sizeof (ISCSI_FORM_CALLBACK_INFO));
2551 if (CallbackInfo == NULL) {
2552 return EFI_OUT_OF_RESOURCES;
2553 }
2554
2555 CallbackInfo->Signature = ISCSI_FORM_CALLBACK_INFO_SIGNATURE;
2556 CallbackInfo->Current = NULL;
2557
2558 CallbackInfo->ConfigAccess.ExtractConfig = IScsiFormExtractConfig;
2559 CallbackInfo->ConfigAccess.RouteConfig = IScsiFormRouteConfig;
2560 CallbackInfo->ConfigAccess.Callback = IScsiFormCallback;
2561
2562 //
2563 // Install Device Path Protocol and Config Access protocol to driver handle.
2564 //
2565 Status = gBS->InstallMultipleProtocolInterfaces (
2566 &CallbackInfo->DriverHandle,
2567 &gEfiDevicePathProtocolGuid,
2568 &mIScsiHiiVendorDevicePath,
2569 &gEfiHiiConfigAccessProtocolGuid,
2570 &CallbackInfo->ConfigAccess,
2571 NULL
2572 );
2573 ASSERT_EFI_ERROR (Status);
2574
2575 //
2576 // Publish our HII data.
2577 //
2578 CallbackInfo->RegisteredHandle = HiiAddPackages (
2579 &gIScsiConfigGuid,
2580 CallbackInfo->DriverHandle,
2581 IScsiDxeStrings,
2582 IScsiConfigVfrBin,
2583 NULL
2584 );
2585 if (CallbackInfo->RegisteredHandle == NULL) {
2586 gBS->UninstallMultipleProtocolInterfaces (
2587 &CallbackInfo->DriverHandle,
2588 &gEfiDevicePathProtocolGuid,
2589 &mIScsiHiiVendorDevicePath,
2590 &gEfiHiiConfigAccessProtocolGuid,
2591 &CallbackInfo->ConfigAccess,
2592 NULL
2593 );
2594 FreePool(CallbackInfo);
2595 return EFI_OUT_OF_RESOURCES;
2596 }
2597
2598 mCallbackInfo = CallbackInfo;
2599
2600 return EFI_SUCCESS;
2601 }
2602
2603
2604 /**
2605 Unload the iSCSI configuration form, this includes: delete all the iSCSI
2606 configuration entries, uninstall the form callback protocol, and
2607 free the resources used.
2608
2609 @param[in] DriverBindingHandle The iSCSI driverbinding handle.
2610
2611 @retval EFI_SUCCESS The iSCSI configuration form is unloaded.
2612 @retval Others Failed to unload the form.
2613
2614 **/
2615 EFI_STATUS
2616 IScsiConfigFormUnload (
2617 IN EFI_HANDLE DriverBindingHandle
2618 )
2619 {
2620 ISCSI_ATTEMPT_CONFIG_NVDATA *AttemptConfigData;
2621 ISCSI_NIC_INFO *NicInfo;
2622 LIST_ENTRY *Entry;
2623 EFI_STATUS Status;
2624
2625 while (!IsListEmpty (&mPrivate->AttemptConfigs)) {
2626 Entry = NetListRemoveHead (&mPrivate->AttemptConfigs);
2627 AttemptConfigData = NET_LIST_USER_STRUCT (Entry, ISCSI_ATTEMPT_CONFIG_NVDATA, Link);
2628 FreePool (AttemptConfigData);
2629 mPrivate->AttemptCount--;
2630 }
2631
2632 ASSERT (mPrivate->AttemptCount == 0);
2633
2634 while (!IsListEmpty (&mPrivate->NicInfoList)) {
2635 Entry = NetListRemoveHead (&mPrivate->NicInfoList);
2636 NicInfo = NET_LIST_USER_STRUCT (Entry, ISCSI_NIC_INFO, Link);
2637 FreePool (NicInfo);
2638 mPrivate->NicCount--;
2639 }
2640
2641 ASSERT (mPrivate->NicCount == 0);
2642
2643 //
2644 // Free attempt is created but not saved to system.
2645 //
2646 if (mPrivate->NewAttempt != NULL) {
2647 FreePool (mPrivate->NewAttempt);
2648 }
2649
2650 FreePool (mPrivate);
2651 mPrivate = NULL;
2652
2653 //
2654 // Remove HII package list.
2655 //
2656 HiiRemovePackages (mCallbackInfo->RegisteredHandle);
2657
2658 //
2659 // Uninstall Device Path Protocol and Config Access protocol.
2660 //
2661 Status = gBS->UninstallMultipleProtocolInterfaces (
2662 mCallbackInfo->DriverHandle,
2663 &gEfiDevicePathProtocolGuid,
2664 &mIScsiHiiVendorDevicePath,
2665 &gEfiHiiConfigAccessProtocolGuid,
2666 &mCallbackInfo->ConfigAccess,
2667 NULL
2668 );
2669
2670 FreePool (mCallbackInfo);
2671
2672 return Status;
2673 }
EFI Development Kit II mirror for PVE