VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/HttpDxe/HttpProto.c@ 99404

Last change on this file since 99404 was 99404, checked in by vboxsync, 22 months ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 64.1 KB
Line 
1/** @file
2 Miscellaneous routines for HttpDxe driver.
3
4Copyright (c) 2015 - 2021, Intel Corporation. All rights reserved.<BR>
5(C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
6SPDX-License-Identifier: BSD-2-Clause-Patent
7
8**/
9
10#include "HttpDriver.h"
11
12/**
13 The common notify function used in HTTP driver.
14
15 @param[in] Event The event signaled.
16 @param[in] Context The context.
17
18**/
19VOID
20EFIAPI
21HttpCommonNotify (
22 IN EFI_EVENT Event,
23 IN VOID *Context
24 )
25{
26 if ((Event == NULL) || (Context == NULL)) {
27 return;
28 }
29
30 *((BOOLEAN *)Context) = TRUE;
31}
32
33/**
34 The notify function associated with Tx4Token for Tcp4->Transmit() or Tx6Token for Tcp6->Transmit().
35
36 @param[in] Context The context.
37
38**/
39VOID
40EFIAPI
41HttpTcpTransmitNotifyDpc (
42 IN VOID *Context
43 )
44{
45 HTTP_TOKEN_WRAP *Wrap;
46 HTTP_PROTOCOL *HttpInstance;
47
48 if (Context == NULL) {
49 return;
50 }
51
52 Wrap = (HTTP_TOKEN_WRAP *)Context;
53 HttpInstance = Wrap->HttpInstance;
54
55 if (!HttpInstance->LocalAddressIsIPv6) {
56 Wrap->HttpToken->Status = Wrap->TcpWrap.Tx4Token.CompletionToken.Status;
57 gBS->SignalEvent (Wrap->HttpToken->Event);
58
59 //
60 // Free resources.
61 //
62 if (Wrap->TcpWrap.Tx4Token.Packet.TxData->FragmentTable[0].FragmentBuffer != NULL) {
63 FreePool (Wrap->TcpWrap.Tx4Token.Packet.TxData->FragmentTable[0].FragmentBuffer);
64 }
65
66 if (Wrap->TcpWrap.Tx4Token.CompletionToken.Event != NULL) {
67 gBS->CloseEvent (Wrap->TcpWrap.Tx4Token.CompletionToken.Event);
68 }
69 } else {
70 Wrap->HttpToken->Status = Wrap->TcpWrap.Tx6Token.CompletionToken.Status;
71 gBS->SignalEvent (Wrap->HttpToken->Event);
72
73 //
74 // Free resources.
75 //
76 if (Wrap->TcpWrap.Tx6Token.Packet.TxData->FragmentTable[0].FragmentBuffer != NULL) {
77 FreePool (Wrap->TcpWrap.Tx6Token.Packet.TxData->FragmentTable[0].FragmentBuffer);
78 }
79
80 if (Wrap->TcpWrap.Tx6Token.CompletionToken.Event != NULL) {
81 gBS->CloseEvent (Wrap->TcpWrap.Tx6Token.CompletionToken.Event);
82 }
83 }
84
85 Wrap->TcpWrap.IsTxDone = TRUE;
86
87 //
88 // Check pending TxTokens and sent out.
89 //
90 NetMapIterate (&Wrap->HttpInstance->TxTokens, HttpTcpTransmit, NULL);
91}
92
93/**
94 Request HttpTcpTransmitNotifyDpc as a DPC at TPL_CALLBACK.
95
96 @param Event The receive event delivered to TCP for transmit.
97 @param Context Context for the callback.
98
99**/
100VOID
101EFIAPI
102HttpTcpTransmitNotify (
103 IN EFI_EVENT Event,
104 IN VOID *Context
105 )
106{
107 //
108 // Request HttpTcpTransmitNotifyDpc as a DPC at TPL_CALLBACK
109 //
110 QueueDpc (TPL_CALLBACK, HttpTcpTransmitNotifyDpc, Context);
111}
112
113/**
114 The notify function associated with Rx4Token for Tcp4->Receive () or Rx6Token for Tcp6->Receive().
115
116 @param[in] Context The context.
117
118**/
119VOID
120EFIAPI
121HttpTcpReceiveNotifyDpc (
122 IN VOID *Context
123 )
124{
125 HTTP_TOKEN_WRAP *Wrap;
126 NET_MAP_ITEM *Item;
127 UINTN Length;
128 EFI_STATUS Status;
129 HTTP_PROTOCOL *HttpInstance;
130 BOOLEAN UsingIpv6;
131
132 if (Context == NULL) {
133 return;
134 }
135
136 Wrap = (HTTP_TOKEN_WRAP *)Context;
137 HttpInstance = Wrap->HttpInstance;
138 UsingIpv6 = HttpInstance->LocalAddressIsIPv6;
139
140 if (UsingIpv6) {
141 gBS->CloseEvent (Wrap->TcpWrap.Rx6Token.CompletionToken.Event);
142 Wrap->TcpWrap.Rx6Token.CompletionToken.Event = NULL;
143
144 if (EFI_ERROR (Wrap->TcpWrap.Rx6Token.CompletionToken.Status)) {
145 DEBUG ((DEBUG_ERROR, "HttpTcpReceiveNotifyDpc: %r!\n", Wrap->TcpWrap.Rx6Token.CompletionToken.Status));
146 Wrap->HttpToken->Status = Wrap->TcpWrap.Rx6Token.CompletionToken.Status;
147 gBS->SignalEvent (Wrap->HttpToken->Event);
148
149 Item = NetMapFindKey (&HttpInstance->RxTokens, Wrap->HttpToken);
150 if (Item != NULL) {
151 NetMapRemoveItem (&HttpInstance->RxTokens, Item, NULL);
152 }
153
154 FreePool (Wrap);
155 Wrap = NULL;
156
157 return;
158 }
159 } else {
160 gBS->CloseEvent (Wrap->TcpWrap.Rx4Token.CompletionToken.Event);
161 Wrap->TcpWrap.Rx4Token.CompletionToken.Event = NULL;
162
163 if (EFI_ERROR (Wrap->TcpWrap.Rx4Token.CompletionToken.Status)) {
164 DEBUG ((DEBUG_ERROR, "HttpTcpReceiveNotifyDpc: %r!\n", Wrap->TcpWrap.Rx4Token.CompletionToken.Status));
165 Wrap->HttpToken->Status = Wrap->TcpWrap.Rx4Token.CompletionToken.Status;
166 gBS->SignalEvent (Wrap->HttpToken->Event);
167
168 Item = NetMapFindKey (&HttpInstance->RxTokens, Wrap->HttpToken);
169 if (Item != NULL) {
170 NetMapRemoveItem (&HttpInstance->RxTokens, Item, NULL);
171 }
172
173 FreePool (Wrap);
174 Wrap = NULL;
175
176 return;
177 }
178 }
179
180 //
181 // Check whether we receive a complete HTTP message.
182 //
183 ASSERT (HttpInstance->MsgParser != NULL);
184 if (UsingIpv6) {
185 Length = (UINTN)Wrap->TcpWrap.Rx6Data.FragmentTable[0].FragmentLength;
186 } else {
187 Length = (UINTN)Wrap->TcpWrap.Rx4Data.FragmentTable[0].FragmentLength;
188 }
189
190 //
191 // Record the CallbackData data.
192 //
193 HttpInstance->CallbackData.Wrap = (VOID *)Wrap;
194 HttpInstance->CallbackData.ParseData = Wrap->HttpToken->Message->Body;
195 HttpInstance->CallbackData.ParseDataLength = Length;
196
197 //
198 // Parse Body with CallbackData data.
199 //
200 Status = HttpParseMessageBody (
201 HttpInstance->MsgParser,
202 Length,
203 Wrap->HttpToken->Message->Body
204 );
205 if (EFI_ERROR (Status)) {
206 return;
207 }
208
209 if (HttpIsMessageComplete (HttpInstance->MsgParser)) {
210 //
211 // Free the MsgParse since we already have a full HTTP message.
212 //
213 HttpFreeMsgParser (HttpInstance->MsgParser);
214 HttpInstance->MsgParser = NULL;
215 }
216
217 Wrap->HttpToken->Message->BodyLength = Length;
218 ASSERT (HttpInstance->CacheBody == NULL);
219 //
220 // We receive part of header of next HTTP msg.
221 //
222 if (HttpInstance->NextMsg != NULL) {
223 Wrap->HttpToken->Message->BodyLength = HttpInstance->NextMsg -
224 (CHAR8 *)Wrap->HttpToken->Message->Body;
225 HttpInstance->CacheLen = Length - Wrap->HttpToken->Message->BodyLength;
226 if (HttpInstance->CacheLen != 0) {
227 HttpInstance->CacheBody = AllocateZeroPool (HttpInstance->CacheLen);
228 if (HttpInstance->CacheBody == NULL) {
229 return;
230 }
231
232 CopyMem (HttpInstance->CacheBody, HttpInstance->NextMsg, HttpInstance->CacheLen);
233 HttpInstance->NextMsg = HttpInstance->CacheBody;
234 HttpInstance->CacheOffset = 0;
235 }
236 }
237
238 Item = NetMapFindKey (&Wrap->HttpInstance->RxTokens, Wrap->HttpToken);
239 if (Item != NULL) {
240 NetMapRemoveItem (&Wrap->HttpInstance->RxTokens, Item, NULL);
241 }
242
243 Wrap->TcpWrap.IsRxDone = TRUE;
244 if (UsingIpv6) {
245 Wrap->HttpToken->Status = Wrap->TcpWrap.Rx6Token.CompletionToken.Status;
246 } else {
247 Wrap->HttpToken->Status = Wrap->TcpWrap.Rx4Token.CompletionToken.Status;
248 }
249
250 gBS->SignalEvent (Wrap->HttpToken->Event);
251
252 //
253 // Check pending RxTokens and receive the HTTP message.
254 //
255 NetMapIterate (&Wrap->HttpInstance->RxTokens, HttpTcpReceive, NULL);
256
257 FreePool (Wrap);
258 Wrap = NULL;
259}
260
261/**
262 Request HttpTcpReceiveNotifyDpc as a DPC at TPL_CALLBACK.
263
264 @param Event The receive event delivered to TCP for receive.
265 @param Context Context for the callback.
266
267**/
268VOID
269EFIAPI
270HttpTcpReceiveNotify (
271 IN EFI_EVENT Event,
272 IN VOID *Context
273 )
274{
275 //
276 // Request HttpTcpTransmitNotifyDpc as a DPC at TPL_CALLBACK
277 //
278 QueueDpc (TPL_CALLBACK, HttpTcpReceiveNotifyDpc, Context);
279}
280
281/**
282 Create events for the TCP connection token and TCP close token.
283
284 @param[in] HttpInstance Pointer to HTTP_PROTOCOL structure.
285
286 @retval EFI_SUCCESS The events are created successfully.
287 @retval others Other error as indicated.
288
289**/
290EFI_STATUS
291HttpCreateTcpConnCloseEvent (
292 IN HTTP_PROTOCOL *HttpInstance
293 )
294{
295 EFI_STATUS Status;
296
297 if (!HttpInstance->LocalAddressIsIPv6) {
298 //
299 // Create events for various asynchronous operations.
300 //
301 Status = gBS->CreateEvent (
302 EVT_NOTIFY_SIGNAL,
303 TPL_NOTIFY,
304 HttpCommonNotify,
305 &HttpInstance->IsTcp4ConnDone,
306 &HttpInstance->Tcp4ConnToken.CompletionToken.Event
307 );
308 if (EFI_ERROR (Status)) {
309 goto ERROR;
310 }
311
312 //
313 // Initialize Tcp4CloseToken
314 //
315 Status = gBS->CreateEvent (
316 EVT_NOTIFY_SIGNAL,
317 TPL_NOTIFY,
318 HttpCommonNotify,
319 &HttpInstance->IsTcp4CloseDone,
320 &HttpInstance->Tcp4CloseToken.CompletionToken.Event
321 );
322 if (EFI_ERROR (Status)) {
323 goto ERROR;
324 }
325 } else {
326 //
327 // Create events for various asynchronous operations.
328 //
329 Status = gBS->CreateEvent (
330 EVT_NOTIFY_SIGNAL,
331 TPL_NOTIFY,
332 HttpCommonNotify,
333 &HttpInstance->IsTcp6ConnDone,
334 &HttpInstance->Tcp6ConnToken.CompletionToken.Event
335 );
336 if (EFI_ERROR (Status)) {
337 goto ERROR;
338 }
339
340 //
341 // Initialize Tcp6CloseToken
342 //
343 Status = gBS->CreateEvent (
344 EVT_NOTIFY_SIGNAL,
345 TPL_NOTIFY,
346 HttpCommonNotify,
347 &HttpInstance->IsTcp6CloseDone,
348 &HttpInstance->Tcp6CloseToken.CompletionToken.Event
349 );
350 if (EFI_ERROR (Status)) {
351 goto ERROR;
352 }
353 }
354
355 return EFI_SUCCESS;
356
357ERROR:
358 //
359 // Error handling
360 //
361 HttpCloseTcpConnCloseEvent (HttpInstance);
362
363 return Status;
364}
365
366/**
367 Close events in the TCP connection token and TCP close token.
368
369 @param[in] HttpInstance Pointer to HTTP_PROTOCOL structure.
370
371**/
372VOID
373HttpCloseTcpConnCloseEvent (
374 IN HTTP_PROTOCOL *HttpInstance
375 )
376{
377 ASSERT (HttpInstance != NULL);
378
379 if (HttpInstance->LocalAddressIsIPv6) {
380 if (NULL != HttpInstance->Tcp6ConnToken.CompletionToken.Event) {
381 gBS->CloseEvent (HttpInstance->Tcp6ConnToken.CompletionToken.Event);
382 HttpInstance->Tcp6ConnToken.CompletionToken.Event = NULL;
383 }
384
385 if (NULL != HttpInstance->Tcp6CloseToken.CompletionToken.Event) {
386 gBS->CloseEvent (HttpInstance->Tcp6CloseToken.CompletionToken.Event);
387 HttpInstance->Tcp6CloseToken.CompletionToken.Event = NULL;
388 }
389 } else {
390 if (NULL != HttpInstance->Tcp4ConnToken.CompletionToken.Event) {
391 gBS->CloseEvent (HttpInstance->Tcp4ConnToken.CompletionToken.Event);
392 HttpInstance->Tcp4ConnToken.CompletionToken.Event = NULL;
393 }
394
395 if (NULL != HttpInstance->Tcp4CloseToken.CompletionToken.Event) {
396 gBS->CloseEvent (HttpInstance->Tcp4CloseToken.CompletionToken.Event);
397 HttpInstance->Tcp4CloseToken.CompletionToken.Event = NULL;
398 }
399 }
400}
401
402/**
403 Create event for the TCP transmit token.
404
405 @param[in] Wrap Point to HTTP token's wrap data.
406
407 @retval EFI_SUCCESS The events is created successfully.
408 @retval others Other error as indicated.
409
410**/
411EFI_STATUS
412HttpCreateTcpTxEvent (
413 IN HTTP_TOKEN_WRAP *Wrap
414 )
415{
416 EFI_STATUS Status;
417 HTTP_PROTOCOL *HttpInstance;
418 HTTP_TCP_TOKEN_WRAP *TcpWrap;
419
420 HttpInstance = Wrap->HttpInstance;
421 TcpWrap = &Wrap->TcpWrap;
422
423 if (!HttpInstance->LocalAddressIsIPv6) {
424 Status = gBS->CreateEvent (
425 EVT_NOTIFY_SIGNAL,
426 TPL_NOTIFY,
427 HttpTcpTransmitNotify,
428 Wrap,
429 &TcpWrap->Tx4Token.CompletionToken.Event
430 );
431 if (EFI_ERROR (Status)) {
432 return Status;
433 }
434
435 TcpWrap->Tx4Data.Push = TRUE;
436 TcpWrap->Tx4Data.Urgent = FALSE;
437 TcpWrap->Tx4Data.FragmentCount = 1;
438 TcpWrap->Tx4Token.Packet.TxData = &Wrap->TcpWrap.Tx4Data;
439 TcpWrap->Tx4Token.CompletionToken.Status = EFI_NOT_READY;
440 } else {
441 Status = gBS->CreateEvent (
442 EVT_NOTIFY_SIGNAL,
443 TPL_NOTIFY,
444 HttpTcpTransmitNotify,
445 Wrap,
446 &TcpWrap->Tx6Token.CompletionToken.Event
447 );
448 if (EFI_ERROR (Status)) {
449 return Status;
450 }
451
452 TcpWrap->Tx6Data.Push = TRUE;
453 TcpWrap->Tx6Data.Urgent = FALSE;
454 TcpWrap->Tx6Data.FragmentCount = 1;
455 TcpWrap->Tx6Token.Packet.TxData = &Wrap->TcpWrap.Tx6Data;
456 TcpWrap->Tx6Token.CompletionToken.Status = EFI_NOT_READY;
457 }
458
459 return EFI_SUCCESS;
460}
461
462/**
463 Create event for the TCP receive token which is used to receive HTTP header.
464
465 @param[in] HttpInstance Pointer to HTTP_PROTOCOL structure.
466
467 @retval EFI_SUCCESS The events is created successfully.
468 @retval others Other error as indicated.
469
470**/
471EFI_STATUS
472HttpCreateTcpRxEventForHeader (
473 IN HTTP_PROTOCOL *HttpInstance
474 )
475{
476 EFI_STATUS Status;
477
478 if (!HttpInstance->LocalAddressIsIPv6) {
479 Status = gBS->CreateEvent (
480 EVT_NOTIFY_SIGNAL,
481 TPL_NOTIFY,
482 HttpCommonNotify,
483 &HttpInstance->IsRxDone,
484 &HttpInstance->Rx4Token.CompletionToken.Event
485 );
486 if (EFI_ERROR (Status)) {
487 return Status;
488 }
489
490 HttpInstance->Rx4Data.FragmentCount = 1;
491 HttpInstance->Rx4Token.Packet.RxData = &HttpInstance->Rx4Data;
492 HttpInstance->Rx4Token.CompletionToken.Status = EFI_NOT_READY;
493 } else {
494 Status = gBS->CreateEvent (
495 EVT_NOTIFY_SIGNAL,
496 TPL_NOTIFY,
497 HttpCommonNotify,
498 &HttpInstance->IsRxDone,
499 &HttpInstance->Rx6Token.CompletionToken.Event
500 );
501 if (EFI_ERROR (Status)) {
502 return Status;
503 }
504
505 HttpInstance->Rx6Data.FragmentCount = 1;
506 HttpInstance->Rx6Token.Packet.RxData = &HttpInstance->Rx6Data;
507 HttpInstance->Rx6Token.CompletionToken.Status = EFI_NOT_READY;
508 }
509
510 return EFI_SUCCESS;
511}
512
513/**
514 Create event for the TCP receive token which is used to receive HTTP body.
515
516 @param[in] Wrap Point to HTTP token's wrap data.
517
518 @retval EFI_SUCCESS The events is created successfully.
519 @retval others Other error as indicated.
520
521**/
522EFI_STATUS
523HttpCreateTcpRxEvent (
524 IN HTTP_TOKEN_WRAP *Wrap
525 )
526{
527 EFI_STATUS Status;
528 HTTP_PROTOCOL *HttpInstance;
529 HTTP_TCP_TOKEN_WRAP *TcpWrap;
530
531 HttpInstance = Wrap->HttpInstance;
532 TcpWrap = &Wrap->TcpWrap;
533 if (!HttpInstance->LocalAddressIsIPv6) {
534 Status = gBS->CreateEvent (
535 EVT_NOTIFY_SIGNAL,
536 TPL_NOTIFY,
537 HttpTcpReceiveNotify,
538 Wrap,
539 &TcpWrap->Rx4Token.CompletionToken.Event
540 );
541 if (EFI_ERROR (Status)) {
542 return Status;
543 }
544
545 TcpWrap->Rx4Data.FragmentCount = 1;
546 TcpWrap->Rx4Token.Packet.RxData = &Wrap->TcpWrap.Rx4Data;
547 TcpWrap->Rx4Token.CompletionToken.Status = EFI_NOT_READY;
548 } else {
549 Status = gBS->CreateEvent (
550 EVT_NOTIFY_SIGNAL,
551 TPL_NOTIFY,
552 HttpTcpReceiveNotify,
553 Wrap,
554 &TcpWrap->Rx6Token.CompletionToken.Event
555 );
556 if (EFI_ERROR (Status)) {
557 return Status;
558 }
559
560 TcpWrap->Rx6Data.FragmentCount = 1;
561 TcpWrap->Rx6Token.Packet.RxData = &Wrap->TcpWrap.Rx6Data;
562 TcpWrap->Rx6Token.CompletionToken.Status = EFI_NOT_READY;
563 }
564
565 return EFI_SUCCESS;
566}
567
568/**
569 Close Events for Tcp Receive Tokens for HTTP body and HTTP header.
570
571 @param[in] Wrap Pointer to HTTP token's wrap data.
572
573**/
574VOID
575HttpCloseTcpRxEvent (
576 IN HTTP_TOKEN_WRAP *Wrap
577 )
578{
579 HTTP_PROTOCOL *HttpInstance;
580
581 ASSERT (Wrap != NULL);
582 HttpInstance = Wrap->HttpInstance;
583
584 if (HttpInstance->LocalAddressIsIPv6) {
585 if (Wrap->TcpWrap.Rx6Token.CompletionToken.Event != NULL) {
586 gBS->CloseEvent (Wrap->TcpWrap.Rx6Token.CompletionToken.Event);
587 }
588
589 if (HttpInstance->Rx6Token.CompletionToken.Event != NULL) {
590 gBS->CloseEvent (HttpInstance->Rx6Token.CompletionToken.Event);
591 HttpInstance->Rx6Token.CompletionToken.Event = NULL;
592 }
593 } else {
594 if (Wrap->TcpWrap.Rx4Token.CompletionToken.Event != NULL) {
595 gBS->CloseEvent (Wrap->TcpWrap.Rx4Token.CompletionToken.Event);
596 }
597
598 if (HttpInstance->Rx4Token.CompletionToken.Event != NULL) {
599 gBS->CloseEvent (HttpInstance->Rx4Token.CompletionToken.Event);
600 HttpInstance->Rx4Token.CompletionToken.Event = NULL;
601 }
602 }
603}
604
605/**
606 Initialize the HTTP_PROTOCOL structure to the unconfigured state.
607
608 @param[in, out] HttpInstance Pointer to HTTP_PROTOCOL structure.
609 @param[in] IpVersion Indicate us TCP4 protocol or TCP6 protocol.
610
611 @retval EFI_SUCCESS HTTP_PROTOCOL structure is initialized successfully.
612 @retval Others Other error as indicated.
613
614**/
615EFI_STATUS
616HttpInitProtocol (
617 IN OUT HTTP_PROTOCOL *HttpInstance,
618 IN BOOLEAN IpVersion
619 )
620{
621 EFI_STATUS Status;
622 VOID *Interface;
623 BOOLEAN UsingIpv6;
624
625 ASSERT (HttpInstance != NULL);
626 UsingIpv6 = IpVersion;
627
628 if (!UsingIpv6) {
629 //
630 // Create TCP4 child.
631 //
632 Status = NetLibCreateServiceChild (
633 HttpInstance->Service->ControllerHandle,
634 HttpInstance->Service->Ip4DriverBindingHandle,
635 &gEfiTcp4ServiceBindingProtocolGuid,
636 &HttpInstance->Tcp4ChildHandle
637 );
638
639 if (EFI_ERROR (Status)) {
640 goto ON_ERROR;
641 }
642
643 Status = gBS->OpenProtocol (
644 HttpInstance->Tcp4ChildHandle,
645 &gEfiTcp4ProtocolGuid,
646 (VOID **)&Interface,
647 HttpInstance->Service->Ip4DriverBindingHandle,
648 HttpInstance->Service->ControllerHandle,
649 EFI_OPEN_PROTOCOL_BY_DRIVER
650 );
651
652 if (EFI_ERROR (Status)) {
653 goto ON_ERROR;
654 }
655
656 Status = gBS->OpenProtocol (
657 HttpInstance->Tcp4ChildHandle,
658 &gEfiTcp4ProtocolGuid,
659 (VOID **)&HttpInstance->Tcp4,
660 HttpInstance->Service->Ip4DriverBindingHandle,
661 HttpInstance->Handle,
662 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
663 );
664 if (EFI_ERROR (Status)) {
665 goto ON_ERROR;
666 }
667
668 Status = gBS->OpenProtocol (
669 HttpInstance->Service->Tcp4ChildHandle,
670 &gEfiTcp4ProtocolGuid,
671 (VOID **)&Interface,
672 HttpInstance->Service->Ip4DriverBindingHandle,
673 HttpInstance->Handle,
674 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
675 );
676 if (EFI_ERROR (Status)) {
677 goto ON_ERROR;
678 }
679 } else {
680 //
681 // Create TCP6 Child.
682 //
683 Status = NetLibCreateServiceChild (
684 HttpInstance->Service->ControllerHandle,
685 HttpInstance->Service->Ip6DriverBindingHandle,
686 &gEfiTcp6ServiceBindingProtocolGuid,
687 &HttpInstance->Tcp6ChildHandle
688 );
689
690 if (EFI_ERROR (Status)) {
691 goto ON_ERROR;
692 }
693
694 Status = gBS->OpenProtocol (
695 HttpInstance->Tcp6ChildHandle,
696 &gEfiTcp6ProtocolGuid,
697 (VOID **)&Interface,
698 HttpInstance->Service->Ip6DriverBindingHandle,
699 HttpInstance->Service->ControllerHandle,
700 EFI_OPEN_PROTOCOL_BY_DRIVER
701 );
702
703 if (EFI_ERROR (Status)) {
704 goto ON_ERROR;
705 }
706
707 Status = gBS->OpenProtocol (
708 HttpInstance->Tcp6ChildHandle,
709 &gEfiTcp6ProtocolGuid,
710 (VOID **)&HttpInstance->Tcp6,
711 HttpInstance->Service->Ip6DriverBindingHandle,
712 HttpInstance->Handle,
713 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
714 );
715
716 if (EFI_ERROR (Status)) {
717 goto ON_ERROR;
718 }
719
720 Status = gBS->OpenProtocol (
721 HttpInstance->Service->Tcp6ChildHandle,
722 &gEfiTcp6ProtocolGuid,
723 (VOID **)&Interface,
724 HttpInstance->Service->Ip6DriverBindingHandle,
725 HttpInstance->Handle,
726 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
727 );
728
729 if (EFI_ERROR (Status)) {
730 goto ON_ERROR;
731 }
732 }
733
734 HttpInstance->Url = AllocateZeroPool (HTTP_URL_BUFFER_LEN);
735 if (HttpInstance->Url == NULL) {
736 Status = EFI_OUT_OF_RESOURCES;
737 goto ON_ERROR;
738 }
739
740 return EFI_SUCCESS;
741
742ON_ERROR:
743
744 if (HttpInstance->Tcp4ChildHandle != NULL) {
745 gBS->CloseProtocol (
746 HttpInstance->Tcp4ChildHandle,
747 &gEfiTcp4ProtocolGuid,
748 HttpInstance->Service->Ip4DriverBindingHandle,
749 HttpInstance->Service->ControllerHandle
750 );
751
752 gBS->CloseProtocol (
753 HttpInstance->Tcp4ChildHandle,
754 &gEfiTcp4ProtocolGuid,
755 HttpInstance->Service->Ip4DriverBindingHandle,
756 HttpInstance->Handle
757 );
758
759 NetLibDestroyServiceChild (
760 HttpInstance->Service->ControllerHandle,
761 HttpInstance->Service->Ip4DriverBindingHandle,
762 &gEfiTcp4ServiceBindingProtocolGuid,
763 HttpInstance->Tcp4ChildHandle
764 );
765 }
766
767 if (HttpInstance->Service->Tcp4ChildHandle != NULL) {
768 gBS->CloseProtocol (
769 HttpInstance->Service->Tcp4ChildHandle,
770 &gEfiTcp4ProtocolGuid,
771 HttpInstance->Service->Ip4DriverBindingHandle,
772 HttpInstance->Handle
773 );
774 }
775
776 if (HttpInstance->Tcp6ChildHandle != NULL) {
777 gBS->CloseProtocol (
778 HttpInstance->Tcp6ChildHandle,
779 &gEfiTcp6ProtocolGuid,
780 HttpInstance->Service->Ip6DriverBindingHandle,
781 HttpInstance->Service->ControllerHandle
782 );
783
784 gBS->CloseProtocol (
785 HttpInstance->Tcp6ChildHandle,
786 &gEfiTcp6ProtocolGuid,
787 HttpInstance->Service->Ip6DriverBindingHandle,
788 HttpInstance->Handle
789 );
790
791 NetLibDestroyServiceChild (
792 HttpInstance->Service->ControllerHandle,
793 HttpInstance->Service->Ip6DriverBindingHandle,
794 &gEfiTcp6ServiceBindingProtocolGuid,
795 HttpInstance->Tcp6ChildHandle
796 );
797 }
798
799 if (HttpInstance->Service->Tcp6ChildHandle != NULL) {
800 gBS->CloseProtocol (
801 HttpInstance->Service->Tcp6ChildHandle,
802 &gEfiTcp6ProtocolGuid,
803 HttpInstance->Service->Ip6DriverBindingHandle,
804 HttpInstance->Handle
805 );
806 }
807
808 return EFI_UNSUPPORTED;
809}
810
811/**
812 Clean up the HTTP child, release all the resources used by it.
813
814 @param[in] HttpInstance The HTTP child to clean up.
815
816**/
817VOID
818HttpCleanProtocol (
819 IN HTTP_PROTOCOL *HttpInstance
820 )
821{
822 HttpCloseConnection (HttpInstance);
823
824 HttpCloseTcpConnCloseEvent (HttpInstance);
825
826 if (HttpInstance->TimeoutEvent != NULL) {
827 gBS->CloseEvent (HttpInstance->TimeoutEvent);
828 HttpInstance->TimeoutEvent = NULL;
829 }
830
831 if (HttpInstance->CacheBody != NULL) {
832 FreePool (HttpInstance->CacheBody);
833 HttpInstance->CacheBody = NULL;
834 HttpInstance->NextMsg = NULL;
835 }
836
837 if (HttpInstance->RemoteHost != NULL) {
838 FreePool (HttpInstance->RemoteHost);
839 HttpInstance->RemoteHost = NULL;
840 }
841
842 if (HttpInstance->MsgParser != NULL) {
843 HttpFreeMsgParser (HttpInstance->MsgParser);
844 HttpInstance->MsgParser = NULL;
845 }
846
847 if (HttpInstance->Url != NULL) {
848 FreePool (HttpInstance->Url);
849 HttpInstance->Url = NULL;
850 }
851
852 NetMapClean (&HttpInstance->TxTokens);
853 NetMapClean (&HttpInstance->RxTokens);
854
855 if ((HttpInstance->TlsSb != NULL) && (HttpInstance->TlsChildHandle != NULL)) {
856 //
857 // Destroy the TLS instance.
858 //
859 HttpInstance->TlsSb->DestroyChild (HttpInstance->TlsSb, HttpInstance->TlsChildHandle);
860 HttpInstance->TlsChildHandle = NULL;
861 }
862
863 if (HttpInstance->Tcp4ChildHandle != NULL) {
864 gBS->CloseProtocol (
865 HttpInstance->Tcp4ChildHandle,
866 &gEfiTcp4ProtocolGuid,
867 HttpInstance->Service->Ip4DriverBindingHandle,
868 HttpInstance->Service->ControllerHandle
869 );
870
871 gBS->CloseProtocol (
872 HttpInstance->Tcp4ChildHandle,
873 &gEfiTcp4ProtocolGuid,
874 HttpInstance->Service->Ip4DriverBindingHandle,
875 HttpInstance->Handle
876 );
877
878 NetLibDestroyServiceChild (
879 HttpInstance->Service->ControllerHandle,
880 HttpInstance->Service->Ip4DriverBindingHandle,
881 &gEfiTcp4ServiceBindingProtocolGuid,
882 HttpInstance->Tcp4ChildHandle
883 );
884 }
885
886 if (HttpInstance->Service->Tcp4ChildHandle != NULL) {
887 gBS->CloseProtocol (
888 HttpInstance->Service->Tcp4ChildHandle,
889 &gEfiTcp4ProtocolGuid,
890 HttpInstance->Service->Ip4DriverBindingHandle,
891 HttpInstance->Handle
892 );
893 }
894
895 if (HttpInstance->Tcp6ChildHandle != NULL) {
896 gBS->CloseProtocol (
897 HttpInstance->Tcp6ChildHandle,
898 &gEfiTcp6ProtocolGuid,
899 HttpInstance->Service->Ip6DriverBindingHandle,
900 HttpInstance->Service->ControllerHandle
901 );
902
903 gBS->CloseProtocol (
904 HttpInstance->Tcp6ChildHandle,
905 &gEfiTcp6ProtocolGuid,
906 HttpInstance->Service->Ip6DriverBindingHandle,
907 HttpInstance->Handle
908 );
909
910 NetLibDestroyServiceChild (
911 HttpInstance->Service->ControllerHandle,
912 HttpInstance->Service->Ip6DriverBindingHandle,
913 &gEfiTcp6ServiceBindingProtocolGuid,
914 HttpInstance->Tcp6ChildHandle
915 );
916 }
917
918 if (HttpInstance->Service->Tcp6ChildHandle != NULL) {
919 gBS->CloseProtocol (
920 HttpInstance->Service->Tcp6ChildHandle,
921 &gEfiTcp6ProtocolGuid,
922 HttpInstance->Service->Ip6DriverBindingHandle,
923 HttpInstance->Handle
924 );
925 }
926
927 TlsCloseTxRxEvent (HttpInstance);
928}
929
930/**
931 Establish TCP connection with HTTP server.
932
933 @param[in] HttpInstance The HTTP instance private data.
934
935 @retval EFI_SUCCESS The TCP connection is established.
936 @retval Others Other error as indicated.
937
938**/
939EFI_STATUS
940HttpCreateConnection (
941 IN HTTP_PROTOCOL *HttpInstance
942 )
943{
944 EFI_STATUS Status;
945
946 //
947 // Connect to Http server
948 //
949 if (!HttpInstance->LocalAddressIsIPv6) {
950 HttpInstance->IsTcp4ConnDone = FALSE;
951 HttpInstance->Tcp4ConnToken.CompletionToken.Status = EFI_NOT_READY;
952 Status = HttpInstance->Tcp4->Connect (HttpInstance->Tcp4, &HttpInstance->Tcp4ConnToken);
953 HttpNotify (HttpEventConnectTcp, Status);
954 if (EFI_ERROR (Status)) {
955 DEBUG ((DEBUG_ERROR, "HttpCreateConnection: Tcp4->Connect() = %r\n", Status));
956 return Status;
957 }
958
959 while (!HttpInstance->IsTcp4ConnDone) {
960 HttpInstance->Tcp4->Poll (HttpInstance->Tcp4);
961 }
962
963 Status = HttpInstance->Tcp4ConnToken.CompletionToken.Status;
964 } else {
965 HttpInstance->IsTcp6ConnDone = FALSE;
966 HttpInstance->Tcp6ConnToken.CompletionToken.Status = EFI_NOT_READY;
967 Status = HttpInstance->Tcp6->Connect (HttpInstance->Tcp6, &HttpInstance->Tcp6ConnToken);
968 HttpNotify (HttpEventConnectTcp, Status);
969 if (EFI_ERROR (Status)) {
970 DEBUG ((DEBUG_ERROR, "HttpCreateConnection: Tcp6->Connect() = %r\n", Status));
971 return Status;
972 }
973
974 while (!HttpInstance->IsTcp6ConnDone) {
975 HttpInstance->Tcp6->Poll (HttpInstance->Tcp6);
976 }
977
978 Status = HttpInstance->Tcp6ConnToken.CompletionToken.Status;
979 }
980
981 if (!EFI_ERROR (Status)) {
982 HttpInstance->State = HTTP_STATE_TCP_CONNECTED;
983 }
984
985 return Status;
986}
987
988/**
989 Close existing TCP connection.
990
991 @param[in] HttpInstance The HTTP instance private data.
992
993 @retval EFI_SUCCESS The TCP connection is closed.
994 @retval Others Other error as indicated.
995
996**/
997EFI_STATUS
998HttpCloseConnection (
999 IN HTTP_PROTOCOL *HttpInstance
1000 )
1001{
1002 EFI_STATUS Status;
1003
1004 if (HttpInstance->State == HTTP_STATE_TCP_CONNECTED) {
1005 if (HttpInstance->LocalAddressIsIPv6) {
1006 HttpInstance->Tcp6CloseToken.AbortOnClose = TRUE;
1007 HttpInstance->IsTcp6CloseDone = FALSE;
1008 Status = HttpInstance->Tcp6->Close (HttpInstance->Tcp6, &HttpInstance->Tcp6CloseToken);
1009 if (EFI_ERROR (Status)) {
1010 return Status;
1011 }
1012
1013 while (!HttpInstance->IsTcp6CloseDone) {
1014 HttpInstance->Tcp6->Poll (HttpInstance->Tcp6);
1015 }
1016 } else {
1017 HttpInstance->Tcp4CloseToken.AbortOnClose = TRUE;
1018 HttpInstance->IsTcp4CloseDone = FALSE;
1019 Status = HttpInstance->Tcp4->Close (HttpInstance->Tcp4, &HttpInstance->Tcp4CloseToken);
1020 if (EFI_ERROR (Status)) {
1021 return Status;
1022 }
1023
1024 while (!HttpInstance->IsTcp4CloseDone) {
1025 HttpInstance->Tcp4->Poll (HttpInstance->Tcp4);
1026 }
1027 }
1028 }
1029
1030 HttpInstance->State = HTTP_STATE_TCP_CLOSED;
1031 return EFI_SUCCESS;
1032}
1033
1034/**
1035 Configure TCP4 protocol child.
1036
1037 @param[in] HttpInstance The HTTP instance private data.
1038 @param[in] Wrap The HTTP token's wrap data.
1039
1040 @retval EFI_SUCCESS The TCP4 protocol child is configured.
1041 @retval Others Other error as indicated.
1042
1043**/
1044EFI_STATUS
1045HttpConfigureTcp4 (
1046 IN HTTP_PROTOCOL *HttpInstance,
1047 IN HTTP_TOKEN_WRAP *Wrap
1048 )
1049{
1050 EFI_STATUS Status;
1051 EFI_TCP4_CONFIG_DATA *Tcp4CfgData;
1052 EFI_TCP4_ACCESS_POINT *Tcp4AP;
1053 EFI_TCP4_OPTION *Tcp4Option;
1054
1055 ASSERT (HttpInstance != NULL);
1056
1057 Tcp4CfgData = &HttpInstance->Tcp4CfgData;
1058 ZeroMem (Tcp4CfgData, sizeof (EFI_TCP4_CONFIG_DATA));
1059
1060 Tcp4CfgData->TypeOfService = HTTP_TOS_DEAULT;
1061 Tcp4CfgData->TimeToLive = HTTP_TTL_DEAULT;
1062 Tcp4CfgData->ControlOption = &HttpInstance->Tcp4Option;
1063
1064 Tcp4AP = &Tcp4CfgData->AccessPoint;
1065 Tcp4AP->UseDefaultAddress = HttpInstance->IPv4Node.UseDefaultAddress;
1066 if (!Tcp4AP->UseDefaultAddress) {
1067 IP4_COPY_ADDRESS (&Tcp4AP->StationAddress, &HttpInstance->IPv4Node.LocalAddress);
1068 IP4_COPY_ADDRESS (&Tcp4AP->SubnetMask, &HttpInstance->IPv4Node.LocalSubnet);
1069 }
1070
1071 Tcp4AP->StationPort = HttpInstance->IPv4Node.LocalPort;
1072 Tcp4AP->RemotePort = HttpInstance->RemotePort;
1073 Tcp4AP->ActiveFlag = TRUE;
1074 IP4_COPY_ADDRESS (&Tcp4AP->RemoteAddress, &HttpInstance->RemoteAddr);
1075
1076 Tcp4Option = Tcp4CfgData->ControlOption;
1077 Tcp4Option->ReceiveBufferSize = HTTP_BUFFER_SIZE_DEAULT;
1078 Tcp4Option->SendBufferSize = HTTP_BUFFER_SIZE_DEAULT;
1079 Tcp4Option->MaxSynBackLog = HTTP_MAX_SYN_BACK_LOG;
1080 Tcp4Option->ConnectionTimeout = HTTP_CONNECTION_TIMEOUT;
1081 Tcp4Option->DataRetries = HTTP_DATA_RETRIES;
1082 Tcp4Option->FinTimeout = HTTP_FIN_TIMEOUT;
1083 Tcp4Option->KeepAliveProbes = HTTP_KEEP_ALIVE_PROBES;
1084 Tcp4Option->KeepAliveTime = HTTP_KEEP_ALIVE_TIME;
1085 Tcp4Option->KeepAliveInterval = HTTP_KEEP_ALIVE_INTERVAL;
1086 Tcp4Option->EnableNagle = TRUE;
1087 Tcp4CfgData->ControlOption = Tcp4Option;
1088
1089 if ((HttpInstance->State == HTTP_STATE_TCP_CONNECTED) ||
1090 (HttpInstance->State == HTTP_STATE_TCP_CLOSED))
1091 {
1092 Status = HttpInstance->Tcp4->Configure (HttpInstance->Tcp4, NULL);
1093 if (EFI_ERROR (Status)) {
1094 DEBUG ((DEBUG_ERROR, "HttpConfigureTcp4(NULL) - %r\n", Status));
1095 return Status;
1096 }
1097
1098 HttpInstance->State = HTTP_STATE_TCP_UNCONFIGED;
1099 }
1100
1101 Status = HttpInstance->Tcp4->Configure (HttpInstance->Tcp4, Tcp4CfgData);
1102 if (EFI_ERROR (Status)) {
1103 DEBUG ((DEBUG_ERROR, "HttpConfigureTcp4 - %r\n", Status));
1104 return Status;
1105 }
1106
1107 Status = HttpCreateTcpConnCloseEvent (HttpInstance);
1108 if (EFI_ERROR (Status)) {
1109 return Status;
1110 }
1111
1112 Status = HttpCreateTcpTxEvent (Wrap);
1113 if (EFI_ERROR (Status)) {
1114 return Status;
1115 }
1116
1117 HttpInstance->State = HTTP_STATE_TCP_CONFIGED;
1118
1119 return EFI_SUCCESS;
1120}
1121
1122/**
1123 Configure TCP6 protocol child.
1124
1125 @param[in] HttpInstance The HTTP instance private data.
1126 @param[in] Wrap The HTTP token's wrap data.
1127
1128 @retval EFI_SUCCESS The TCP6 protocol child is configured.
1129 @retval Others Other error as indicated.
1130
1131**/
1132EFI_STATUS
1133HttpConfigureTcp6 (
1134 IN HTTP_PROTOCOL *HttpInstance,
1135 IN HTTP_TOKEN_WRAP *Wrap
1136 )
1137{
1138 EFI_STATUS Status;
1139 EFI_TCP6_CONFIG_DATA *Tcp6CfgData;
1140 EFI_TCP6_ACCESS_POINT *Tcp6Ap;
1141 EFI_TCP6_OPTION *Tcp6Option;
1142
1143 ASSERT (HttpInstance != NULL);
1144
1145 Tcp6CfgData = &HttpInstance->Tcp6CfgData;
1146 ZeroMem (Tcp6CfgData, sizeof (EFI_TCP6_CONFIG_DATA));
1147
1148 Tcp6CfgData->TrafficClass = 0;
1149 Tcp6CfgData->HopLimit = 255;
1150 Tcp6CfgData->ControlOption = &HttpInstance->Tcp6Option;
1151
1152 Tcp6Ap = &Tcp6CfgData->AccessPoint;
1153 Tcp6Ap->ActiveFlag = TRUE;
1154 Tcp6Ap->StationPort = HttpInstance->Ipv6Node.LocalPort;
1155 Tcp6Ap->RemotePort = HttpInstance->RemotePort;
1156 IP6_COPY_ADDRESS (&Tcp6Ap->StationAddress, &HttpInstance->Ipv6Node.LocalAddress);
1157 IP6_COPY_ADDRESS (&Tcp6Ap->RemoteAddress, &HttpInstance->RemoteIpv6Addr);
1158
1159 Tcp6Option = Tcp6CfgData->ControlOption;
1160 Tcp6Option->ReceiveBufferSize = HTTP_BUFFER_SIZE_DEAULT;
1161 Tcp6Option->SendBufferSize = HTTP_BUFFER_SIZE_DEAULT;
1162 Tcp6Option->MaxSynBackLog = HTTP_MAX_SYN_BACK_LOG;
1163 Tcp6Option->ConnectionTimeout = HTTP_CONNECTION_TIMEOUT;
1164 Tcp6Option->DataRetries = HTTP_DATA_RETRIES;
1165 Tcp6Option->FinTimeout = HTTP_FIN_TIMEOUT;
1166 Tcp6Option->KeepAliveProbes = HTTP_KEEP_ALIVE_PROBES;
1167 Tcp6Option->KeepAliveTime = HTTP_KEEP_ALIVE_TIME;
1168 Tcp6Option->KeepAliveInterval = HTTP_KEEP_ALIVE_INTERVAL;
1169 Tcp6Option->EnableNagle = TRUE;
1170
1171 if ((HttpInstance->State == HTTP_STATE_TCP_CONNECTED) ||
1172 (HttpInstance->State == HTTP_STATE_TCP_CLOSED))
1173 {
1174 Status = HttpInstance->Tcp6->Configure (HttpInstance->Tcp6, NULL);
1175 if (EFI_ERROR (Status)) {
1176 DEBUG ((DEBUG_ERROR, "HttpConfigureTcp6(NULL) - %r\n", Status));
1177 return Status;
1178 }
1179
1180 HttpInstance->State = HTTP_STATE_TCP_UNCONFIGED;
1181 }
1182
1183 Status = HttpInstance->Tcp6->Configure (HttpInstance->Tcp6, Tcp6CfgData);
1184 if (EFI_ERROR (Status)) {
1185 DEBUG ((DEBUG_ERROR, "HttpConfigureTcp6 - %r\n", Status));
1186 return Status;
1187 }
1188
1189 Status = HttpCreateTcpConnCloseEvent (HttpInstance);
1190 if (EFI_ERROR (Status)) {
1191 return Status;
1192 }
1193
1194 Status = HttpCreateTcpTxEvent (Wrap);
1195 if (EFI_ERROR (Status)) {
1196 return Status;
1197 }
1198
1199 HttpInstance->State = HTTP_STATE_TCP_CONFIGED;
1200
1201 return EFI_SUCCESS;
1202}
1203
1204/**
1205 Check existing TCP connection, if in error state, recover TCP4 connection. Then,
1206 connect one TLS session if required.
1207
1208 @param[in] HttpInstance The HTTP instance private data.
1209
1210 @retval EFI_SUCCESS The TCP connection is established.
1211 @retval EFI_NOT_READY TCP4 protocol child is not created or configured.
1212 @retval Others Other error as indicated.
1213
1214**/
1215EFI_STATUS
1216HttpConnectTcp4 (
1217 IN HTTP_PROTOCOL *HttpInstance
1218 )
1219{
1220 EFI_STATUS Status;
1221 EFI_TCP4_CONNECTION_STATE Tcp4State;
1222
1223 if ((HttpInstance->State < HTTP_STATE_TCP_CONFIGED) || (HttpInstance->Tcp4 == NULL)) {
1224 return EFI_NOT_READY;
1225 }
1226
1227 Status = HttpInstance->Tcp4->GetModeData (
1228 HttpInstance->Tcp4,
1229 &Tcp4State,
1230 NULL,
1231 NULL,
1232 NULL,
1233 NULL
1234 );
1235 if (EFI_ERROR (Status)) {
1236 DEBUG ((DEBUG_ERROR, "Tcp4 GetModeData fail - %x\n", Status));
1237 return Status;
1238 }
1239
1240 if (Tcp4State == Tcp4StateEstablished) {
1241 return EFI_SUCCESS;
1242 } else if (Tcp4State > Tcp4StateEstablished ) {
1243 HttpCloseConnection (HttpInstance);
1244 }
1245
1246 Status = HttpCreateConnection (HttpInstance);
1247 if (EFI_ERROR (Status)) {
1248 DEBUG ((DEBUG_ERROR, "Tcp4 Connection fail - %x\n", Status));
1249 return Status;
1250 }
1251
1252 //
1253 // Tls session connection.
1254 //
1255 if (HttpInstance->UseHttps) {
1256 if (HttpInstance->TimeoutEvent == NULL) {
1257 //
1258 // Create TimeoutEvent for TLS connection.
1259 //
1260 Status = gBS->CreateEvent (
1261 EVT_TIMER,
1262 TPL_CALLBACK,
1263 NULL,
1264 NULL,
1265 &HttpInstance->TimeoutEvent
1266 );
1267 if (EFI_ERROR (Status)) {
1268 TlsCloseTxRxEvent (HttpInstance);
1269 return Status;
1270 }
1271 }
1272
1273 //
1274 // Start the timer, and wait Timeout seconds for connection.
1275 //
1276 Status = gBS->SetTimer (HttpInstance->TimeoutEvent, TimerRelative, HTTP_CONNECTION_TIMEOUT * TICKS_PER_SECOND);
1277 if (EFI_ERROR (Status)) {
1278 TlsCloseTxRxEvent (HttpInstance);
1279 return Status;
1280 }
1281
1282 Status = TlsConnectSession (HttpInstance, HttpInstance->TimeoutEvent);
1283 HttpNotify (HttpEventTlsConnectSession, Status);
1284
1285 gBS->SetTimer (HttpInstance->TimeoutEvent, TimerCancel, 0);
1286
1287 if (EFI_ERROR (Status)) {
1288 TlsCloseTxRxEvent (HttpInstance);
1289 return Status;
1290 }
1291 }
1292
1293 return Status;
1294}
1295
1296/**
1297 Check existing TCP connection, if in error state, recover TCP6 connection. Then,
1298 connect one TLS session if required.
1299
1300 @param[in] HttpInstance The HTTP instance private data.
1301
1302 @retval EFI_SUCCESS The TCP connection is established.
1303 @retval EFI_NOT_READY TCP6 protocol child is not created or configured.
1304 @retval Others Other error as indicated.
1305
1306**/
1307EFI_STATUS
1308HttpConnectTcp6 (
1309 IN HTTP_PROTOCOL *HttpInstance
1310 )
1311{
1312 EFI_STATUS Status;
1313 EFI_TCP6_CONNECTION_STATE Tcp6State;
1314
1315 if ((HttpInstance->State < HTTP_STATE_TCP_CONFIGED) || (HttpInstance->Tcp6 == NULL)) {
1316 return EFI_NOT_READY;
1317 }
1318
1319 Status = HttpInstance->Tcp6->GetModeData (
1320 HttpInstance->Tcp6,
1321 &Tcp6State,
1322 NULL,
1323 NULL,
1324 NULL,
1325 NULL
1326 );
1327
1328 if (EFI_ERROR (Status)) {
1329 DEBUG ((DEBUG_ERROR, "Tcp6 GetModeData fail - %x\n", Status));
1330 return Status;
1331 }
1332
1333 if (Tcp6State == Tcp6StateEstablished) {
1334 return EFI_SUCCESS;
1335 } else if (Tcp6State > Tcp6StateEstablished ) {
1336 HttpCloseConnection (HttpInstance);
1337 }
1338
1339 Status = HttpCreateConnection (HttpInstance);
1340 if (EFI_ERROR (Status)) {
1341 DEBUG ((DEBUG_ERROR, "Tcp6 Connection fail - %x\n", Status));
1342 return Status;
1343 }
1344
1345 //
1346 // Tls session connection.
1347 //
1348 if (HttpInstance->UseHttps) {
1349 if (HttpInstance->TimeoutEvent == NULL) {
1350 //
1351 // Create TimeoutEvent for TLS connection.
1352 //
1353 Status = gBS->CreateEvent (
1354 EVT_TIMER,
1355 TPL_CALLBACK,
1356 NULL,
1357 NULL,
1358 &HttpInstance->TimeoutEvent
1359 );
1360 if (EFI_ERROR (Status)) {
1361 TlsCloseTxRxEvent (HttpInstance);
1362 return Status;
1363 }
1364 }
1365
1366 //
1367 // Start the timer, and wait Timeout seconds for connection.
1368 //
1369 Status = gBS->SetTimer (HttpInstance->TimeoutEvent, TimerRelative, HTTP_CONNECTION_TIMEOUT * TICKS_PER_SECOND);
1370 if (EFI_ERROR (Status)) {
1371 TlsCloseTxRxEvent (HttpInstance);
1372 return Status;
1373 }
1374
1375 Status = TlsConnectSession (HttpInstance, HttpInstance->TimeoutEvent);
1376 HttpNotify (HttpEventTlsConnectSession, Status);
1377
1378 gBS->SetTimer (HttpInstance->TimeoutEvent, TimerCancel, 0);
1379
1380 if (EFI_ERROR (Status)) {
1381 TlsCloseTxRxEvent (HttpInstance);
1382 return Status;
1383 }
1384 }
1385
1386 return Status;
1387}
1388
1389/**
1390 Initialize Http session.
1391
1392 @param[in] HttpInstance The HTTP instance private data.
1393 @param[in] Wrap The HTTP token's wrap data.
1394 @param[in] Configure The Flag indicates whether need to initialize session.
1395 @param[in] TlsConfigure The Flag indicates whether it's the new Tls session.
1396
1397 @retval EFI_SUCCESS The initialization of session is done.
1398 @retval Others Other error as indicated.
1399
1400**/
1401EFI_STATUS
1402HttpInitSession (
1403 IN HTTP_PROTOCOL *HttpInstance,
1404 IN HTTP_TOKEN_WRAP *Wrap,
1405 IN BOOLEAN Configure,
1406 IN BOOLEAN TlsConfigure
1407 )
1408{
1409 EFI_STATUS Status;
1410
1411 ASSERT (HttpInstance != NULL);
1412
1413 //
1414 // Configure Tls session.
1415 //
1416 if (TlsConfigure) {
1417 Status = TlsConfigureSession (HttpInstance);
1418 if (EFI_ERROR (Status)) {
1419 return Status;
1420 }
1421 }
1422
1423 if (!HttpInstance->LocalAddressIsIPv6) {
1424 //
1425 // Configure TCP instance.
1426 //
1427 if (Configure) {
1428 Status = HttpConfigureTcp4 (HttpInstance, Wrap);
1429 if (EFI_ERROR (Status)) {
1430 return Status;
1431 }
1432 }
1433
1434 //
1435 // Connect TCP.
1436 //
1437 Status = HttpConnectTcp4 (HttpInstance);
1438 if (EFI_ERROR (Status)) {
1439 return Status;
1440 }
1441 } else {
1442 //
1443 // Configure TCP instance.
1444 //
1445 if (Configure) {
1446 Status = HttpConfigureTcp6 (HttpInstance, Wrap);
1447 if (EFI_ERROR (Status)) {
1448 return Status;
1449 }
1450 }
1451
1452 //
1453 // Connect TCP.
1454 //
1455 Status = HttpConnectTcp6 (HttpInstance);
1456 if (EFI_ERROR (Status)) {
1457 return Status;
1458 }
1459 }
1460
1461 return EFI_SUCCESS;
1462}
1463
1464/**
1465 Send the HTTP or HTTPS message through TCP4 or TCP6.
1466
1467 @param[in] HttpInstance The HTTP instance private data.
1468 @param[in] Wrap The HTTP token's wrap data.
1469 @param[in] TxString Buffer containing the HTTP message string.
1470 @param[in] TxStringLen Length of the HTTP message string in bytes.
1471
1472 @retval EFI_SUCCESS The HTTP message is queued into TCP transmit queue.
1473 @retval Others Other error as indicated.
1474
1475**/
1476EFI_STATUS
1477HttpTransmitTcp (
1478 IN HTTP_PROTOCOL *HttpInstance,
1479 IN HTTP_TOKEN_WRAP *Wrap,
1480 IN UINT8 *TxString,
1481 IN UINTN TxStringLen
1482 )
1483{
1484 EFI_STATUS Status;
1485 EFI_TCP4_IO_TOKEN *Tx4Token;
1486 EFI_TCP4_PROTOCOL *Tcp4;
1487 EFI_TCP6_IO_TOKEN *Tx6Token;
1488 EFI_TCP6_PROTOCOL *Tcp6;
1489 UINT8 *TlsRecord;
1490 UINT16 PayloadSize;
1491 NET_FRAGMENT TempFragment;
1492 NET_FRAGMENT Fragment;
1493 UINTN RecordCount;
1494 UINTN RemainingLen;
1495
1496 Status = EFI_SUCCESS;
1497 TlsRecord = NULL;
1498 PayloadSize = 0;
1499 TempFragment.Len = 0;
1500 TempFragment.Bulk = NULL;
1501 Fragment.Len = 0;
1502 Fragment.Bulk = NULL;
1503 RecordCount = 0;
1504 RemainingLen = 0;
1505
1506 //
1507 // Need to encrypt data.
1508 //
1509 if (HttpInstance->UseHttps) {
1510 //
1511 // Allocate enough buffer for each TLS plaintext records.
1512 //
1513 TlsRecord = AllocateZeroPool (TLS_RECORD_HEADER_LENGTH + TLS_PLAINTEXT_RECORD_MAX_PAYLOAD_LENGTH);
1514 if (TlsRecord == NULL) {
1515 Status = EFI_OUT_OF_RESOURCES;
1516 return Status;
1517 }
1518
1519 //
1520 // Allocate enough buffer for all TLS ciphertext records.
1521 //
1522 RecordCount = TxStringLen / TLS_PLAINTEXT_RECORD_MAX_PAYLOAD_LENGTH + 1;
1523 Fragment.Bulk = AllocateZeroPool (RecordCount * (TLS_RECORD_HEADER_LENGTH + TLS_CIPHERTEXT_RECORD_MAX_PAYLOAD_LENGTH));
1524 if (Fragment.Bulk == NULL) {
1525 Status = EFI_OUT_OF_RESOURCES;
1526 goto ON_ERROR;
1527 }
1528
1529 //
1530 // Encrypt each TLS plaintext records.
1531 //
1532 RemainingLen = TxStringLen;
1533 while (RemainingLen != 0) {
1534 PayloadSize = (UINT16)MIN (TLS_PLAINTEXT_RECORD_MAX_PAYLOAD_LENGTH, RemainingLen);
1535
1536 ((TLS_RECORD_HEADER *)TlsRecord)->ContentType = TlsContentTypeApplicationData;
1537 ((TLS_RECORD_HEADER *)TlsRecord)->Version.Major = HttpInstance->TlsConfigData.Version.Major;
1538 ((TLS_RECORD_HEADER *)TlsRecord)->Version.Minor = HttpInstance->TlsConfigData.Version.Minor;
1539 ((TLS_RECORD_HEADER *)TlsRecord)->Length = PayloadSize;
1540
1541 CopyMem (TlsRecord + TLS_RECORD_HEADER_LENGTH, TxString + (TxStringLen - RemainingLen), PayloadSize);
1542
1543 Status = TlsProcessMessage (
1544 HttpInstance,
1545 TlsRecord,
1546 TLS_RECORD_HEADER_LENGTH + PayloadSize,
1547 EfiTlsEncrypt,
1548 &TempFragment
1549 );
1550 if (EFI_ERROR (Status)) {
1551 goto ON_ERROR;
1552 }
1553
1554 //
1555 // Record the processed/encrypted Packet.
1556 //
1557 CopyMem (Fragment.Bulk + Fragment.Len, TempFragment.Bulk, TempFragment.Len);
1558 Fragment.Len += TempFragment.Len;
1559
1560 FreePool (TempFragment.Bulk);
1561 TempFragment.Len = 0;
1562 TempFragment.Bulk = NULL;
1563
1564 RemainingLen -= (UINTN)PayloadSize;
1565 ZeroMem (TlsRecord, TLS_RECORD_HEADER_LENGTH + TLS_PLAINTEXT_RECORD_MAX_PAYLOAD_LENGTH);
1566 }
1567
1568 FreePool (TlsRecord);
1569 TlsRecord = NULL;
1570 }
1571
1572 if (!HttpInstance->LocalAddressIsIPv6) {
1573 Tcp4 = HttpInstance->Tcp4;
1574 Tx4Token = &Wrap->TcpWrap.Tx4Token;
1575
1576 if (HttpInstance->UseHttps) {
1577 Tx4Token->Packet.TxData->DataLength = Fragment.Len;
1578 Tx4Token->Packet.TxData->FragmentTable[0].FragmentLength = Fragment.Len;
1579 Tx4Token->Packet.TxData->FragmentTable[0].FragmentBuffer = (VOID *)Fragment.Bulk;
1580 } else {
1581 Tx4Token->Packet.TxData->DataLength = (UINT32)TxStringLen;
1582 Tx4Token->Packet.TxData->FragmentTable[0].FragmentLength = (UINT32)TxStringLen;
1583 Tx4Token->Packet.TxData->FragmentTable[0].FragmentBuffer = (VOID *)TxString;
1584 }
1585
1586 Tx4Token->CompletionToken.Status = EFI_NOT_READY;
1587
1588 Wrap->TcpWrap.IsTxDone = FALSE;
1589 Status = Tcp4->Transmit (Tcp4, Tx4Token);
1590 if (EFI_ERROR (Status)) {
1591 DEBUG ((DEBUG_ERROR, "Transmit failed: %r\n", Status));
1592 goto ON_ERROR;
1593 }
1594 } else {
1595 Tcp6 = HttpInstance->Tcp6;
1596 Tx6Token = &Wrap->TcpWrap.Tx6Token;
1597
1598 if (HttpInstance->UseHttps) {
1599 Tx6Token->Packet.TxData->DataLength = Fragment.Len;
1600 Tx6Token->Packet.TxData->FragmentTable[0].FragmentLength = Fragment.Len;
1601 Tx6Token->Packet.TxData->FragmentTable[0].FragmentBuffer = (VOID *)Fragment.Bulk;
1602 } else {
1603 Tx6Token->Packet.TxData->DataLength = (UINT32)TxStringLen;
1604 Tx6Token->Packet.TxData->FragmentTable[0].FragmentLength = (UINT32)TxStringLen;
1605 Tx6Token->Packet.TxData->FragmentTable[0].FragmentBuffer = (VOID *)TxString;
1606 }
1607
1608 Tx6Token->CompletionToken.Status = EFI_NOT_READY;
1609
1610 Wrap->TcpWrap.IsTxDone = FALSE;
1611 Status = Tcp6->Transmit (Tcp6, Tx6Token);
1612 if (EFI_ERROR (Status)) {
1613 DEBUG ((DEBUG_ERROR, "Transmit failed: %r\n", Status));
1614 goto ON_ERROR;
1615 }
1616 }
1617
1618 return Status;
1619
1620ON_ERROR:
1621
1622 if (HttpInstance->UseHttps) {
1623 if (TlsRecord != NULL) {
1624 FreePool (TlsRecord);
1625 TlsRecord = NULL;
1626 }
1627
1628 if (Fragment.Bulk != NULL) {
1629 FreePool (Fragment.Bulk);
1630 Fragment.Bulk = NULL;
1631 }
1632 }
1633
1634 return Status;
1635}
1636
1637/**
1638 Check whether the user's token or event has already
1639 been enqueue on HTTP Tx or Rx Token list.
1640
1641 @param[in] Map The container of either user's transmit or receive
1642 token.
1643 @param[in] Item Current item to check against.
1644 @param[in] Context The Token to check against.
1645
1646 @retval EFI_ACCESS_DENIED The token or event has already been enqueued in IP
1647 @retval EFI_SUCCESS The current item isn't the same token/event as the
1648 context.
1649
1650**/
1651EFI_STATUS
1652EFIAPI
1653HttpTokenExist (
1654 IN NET_MAP *Map,
1655 IN NET_MAP_ITEM *Item,
1656 IN VOID *Context
1657 )
1658{
1659 EFI_HTTP_TOKEN *Token;
1660 EFI_HTTP_TOKEN *TokenInItem;
1661
1662 Token = (EFI_HTTP_TOKEN *)Context;
1663 TokenInItem = (EFI_HTTP_TOKEN *)Item->Key;
1664
1665 if ((Token == TokenInItem) || (Token->Event == TokenInItem->Event)) {
1666 return EFI_ACCESS_DENIED;
1667 }
1668
1669 return EFI_SUCCESS;
1670}
1671
1672/**
1673 Check whether the HTTP message associated with Tx4Token or Tx6Token is already sent out.
1674
1675 @param[in] Map The container of Tx4Token or Tx6Token.
1676 @param[in] Item Current item to check against.
1677 @param[in] Context The Token to check against.
1678
1679 @retval EFI_NOT_READY The HTTP message is still queued in the list.
1680 @retval EFI_SUCCESS The HTTP message has been sent out.
1681
1682**/
1683EFI_STATUS
1684EFIAPI
1685HttpTcpNotReady (
1686 IN NET_MAP *Map,
1687 IN NET_MAP_ITEM *Item,
1688 IN VOID *Context
1689 )
1690{
1691 HTTP_TOKEN_WRAP *ValueInItem;
1692
1693 ValueInItem = (HTTP_TOKEN_WRAP *)Item->Value;
1694
1695 if (!ValueInItem->TcpWrap.IsTxDone) {
1696 return EFI_NOT_READY;
1697 }
1698
1699 return EFI_SUCCESS;
1700}
1701
1702/**
1703 Transmit the HTTP or HTTPS message by processing the associated HTTP token.
1704
1705 @param[in] Map The container of Tx4Token or Tx6Token.
1706 @param[in] Item Current item to check against.
1707 @param[in] Context The Token to check against.
1708
1709 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources.
1710 @retval EFI_SUCCESS The HTTP message is queued into TCP transmit
1711 queue.
1712
1713**/
1714EFI_STATUS
1715EFIAPI
1716HttpTcpTransmit (
1717 IN NET_MAP *Map,
1718 IN NET_MAP_ITEM *Item,
1719 IN VOID *Context
1720 )
1721{
1722 HTTP_TOKEN_WRAP *ValueInItem;
1723 EFI_STATUS Status;
1724 CHAR8 *RequestMsg;
1725 CHAR8 *Url;
1726 UINTN UrlSize;
1727 UINTN RequestMsgSize;
1728
1729 RequestMsg = NULL;
1730
1731 ValueInItem = (HTTP_TOKEN_WRAP *)Item->Value;
1732 if (ValueInItem->TcpWrap.IsTxDone) {
1733 return EFI_SUCCESS;
1734 }
1735
1736 //
1737 // Parse the URI of the remote host.
1738 //
1739 UrlSize = StrLen (ValueInItem->HttpToken->Message->Data.Request->Url) + 1;
1740 Url = AllocatePool (UrlSize);
1741 if (Url == NULL) {
1742 return EFI_OUT_OF_RESOURCES;
1743 }
1744
1745 UnicodeStrToAsciiStrS (ValueInItem->HttpToken->Message->Data.Request->Url, Url, UrlSize);
1746
1747 //
1748 // Create request message.
1749 //
1750 Status = HttpGenRequestMessage (
1751 ValueInItem->HttpToken->Message,
1752 Url,
1753 &RequestMsg,
1754 &RequestMsgSize
1755 );
1756 FreePool (Url);
1757
1758 if (EFI_ERROR (Status) || (NULL == RequestMsg)) {
1759 return Status;
1760 }
1761
1762 ASSERT (RequestMsg != NULL);
1763
1764 //
1765 // Transmit the request message.
1766 //
1767 Status = HttpTransmitTcp (
1768 ValueInItem->HttpInstance,
1769 ValueInItem,
1770 (UINT8 *)RequestMsg,
1771 RequestMsgSize
1772 );
1773 FreePool (RequestMsg);
1774 return Status;
1775}
1776
1777/**
1778 Receive the HTTP response by processing the associated HTTP token.
1779
1780 @param[in] Map The container of Rx4Token or Rx6Token.
1781 @param[in] Item Current item to check against.
1782 @param[in] Context The Token to check against.
1783
1784 @retval EFI_SUCCESS The HTTP response is queued into TCP receive
1785 queue.
1786 @retval Others Other error as indicated.
1787
1788**/
1789EFI_STATUS
1790EFIAPI
1791HttpTcpReceive (
1792 IN NET_MAP *Map,
1793 IN NET_MAP_ITEM *Item,
1794 IN VOID *Context
1795 )
1796{
1797 //
1798 // Process the queued HTTP response.
1799 //
1800 return HttpResponseWorker ((HTTP_TOKEN_WRAP *)Item->Value);
1801}
1802
1803/**
1804 Receive the HTTP header by processing the associated HTTP token.
1805
1806 @param[in] HttpInstance The HTTP instance private data.
1807 @param[in, out] SizeofHeaders The HTTP header length.
1808 @param[in, out] BufferSize The size of buffer to cache the header message.
1809 @param[in] Timeout The time to wait for receiving the header packet.
1810
1811 @retval EFI_SUCCESS The HTTP header is received.
1812 @retval Others Other errors as indicated.
1813
1814**/
1815EFI_STATUS
1816HttpTcpReceiveHeader (
1817 IN HTTP_PROTOCOL *HttpInstance,
1818 IN OUT UINTN *SizeofHeaders,
1819 IN OUT UINTN *BufferSize,
1820 IN EFI_EVENT Timeout
1821 )
1822{
1823 EFI_STATUS Status;
1824 EFI_TCP4_IO_TOKEN *Rx4Token;
1825 EFI_TCP4_PROTOCOL *Tcp4;
1826 EFI_TCP6_IO_TOKEN *Rx6Token;
1827 EFI_TCP6_PROTOCOL *Tcp6;
1828 CHAR8 **EndofHeader;
1829 CHAR8 **HttpHeaders;
1830 CHAR8 *Buffer;
1831 NET_FRAGMENT Fragment;
1832
1833 ASSERT (HttpInstance != NULL);
1834
1835 EndofHeader = HttpInstance->EndofHeader;
1836 HttpHeaders = HttpInstance->HttpHeaders;
1837 Tcp4 = HttpInstance->Tcp4;
1838 Tcp6 = HttpInstance->Tcp6;
1839 Buffer = NULL;
1840 Rx4Token = NULL;
1841 Rx6Token = NULL;
1842 Fragment.Len = 0;
1843 Fragment.Bulk = NULL;
1844
1845 if (HttpInstance->LocalAddressIsIPv6) {
1846 ASSERT (Tcp6 != NULL);
1847 } else {
1848 ASSERT (Tcp4 != NULL);
1849 }
1850
1851 if (!HttpInstance->UseHttps) {
1852 Status = HttpCreateTcpRxEventForHeader (HttpInstance);
1853 if (EFI_ERROR (Status)) {
1854 return Status;
1855 }
1856 }
1857
1858 if (!HttpInstance->LocalAddressIsIPv6) {
1859 if (!HttpInstance->UseHttps) {
1860 Rx4Token = &HttpInstance->Rx4Token;
1861 Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer = AllocateZeroPool (DEF_BUF_LEN);
1862 if (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer == NULL) {
1863 Status = EFI_OUT_OF_RESOURCES;
1864 return Status;
1865 }
1866 }
1867
1868 //
1869 // Receive the HTTP headers only when EFI_HTTP_RESPONSE_DATA is not NULL.
1870 //
1871 while (*EndofHeader == NULL) {
1872 if (!HttpInstance->UseHttps) {
1873 HttpInstance->IsRxDone = FALSE;
1874 Rx4Token->Packet.RxData->DataLength = DEF_BUF_LEN;
1875 Rx4Token->Packet.RxData->FragmentTable[0].FragmentLength = DEF_BUF_LEN;
1876 Status = Tcp4->Receive (Tcp4, Rx4Token);
1877 if (EFI_ERROR (Status)) {
1878 DEBUG ((DEBUG_ERROR, "Tcp4 receive failed: %r\n", Status));
1879 return Status;
1880 }
1881
1882 while (!HttpInstance->IsRxDone && ((Timeout == NULL) || EFI_ERROR (gBS->CheckEvent (Timeout)))) {
1883 Tcp4->Poll (Tcp4);
1884 }
1885
1886 if (!HttpInstance->IsRxDone) {
1887 //
1888 // Cancel the Token before close its Event.
1889 //
1890 Tcp4->Cancel (HttpInstance->Tcp4, &Rx4Token->CompletionToken);
1891 gBS->CloseEvent (Rx4Token->CompletionToken.Event);
1892 Rx4Token->CompletionToken.Status = EFI_TIMEOUT;
1893 }
1894
1895 Status = Rx4Token->CompletionToken.Status;
1896 if (EFI_ERROR (Status)) {
1897 return Status;
1898 }
1899
1900 Fragment.Len = Rx4Token->Packet.RxData->FragmentTable[0].FragmentLength;
1901 Fragment.Bulk = (UINT8 *)Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer;
1902 } else {
1903 if (Fragment.Bulk != NULL) {
1904 FreePool (Fragment.Bulk);
1905 Fragment.Bulk = NULL;
1906 }
1907
1908 Status = HttpsReceive (HttpInstance, &Fragment, Timeout);
1909 if (EFI_ERROR (Status)) {
1910 DEBUG ((DEBUG_ERROR, "Tcp4 receive failed: %r\n", Status));
1911 return Status;
1912 }
1913 }
1914
1915 //
1916 // Append the response string along with a Null-terminator.
1917 //
1918 *BufferSize = *SizeofHeaders + Fragment.Len;
1919 Buffer = AllocatePool (*BufferSize + 1);
1920 if (Buffer == NULL) {
1921 Status = EFI_OUT_OF_RESOURCES;
1922 return Status;
1923 }
1924
1925 if (*HttpHeaders != NULL) {
1926 CopyMem (Buffer, *HttpHeaders, *SizeofHeaders);
1927 FreePool (*HttpHeaders);
1928 }
1929
1930 CopyMem (
1931 Buffer + *SizeofHeaders,
1932 Fragment.Bulk,
1933 Fragment.Len
1934 );
1935 *(Buffer + *BufferSize) = '\0';
1936 *HttpHeaders = Buffer;
1937 *SizeofHeaders = *BufferSize;
1938
1939 //
1940 // Check whether we received end of HTTP headers.
1941 //
1942 *EndofHeader = AsciiStrStr (*HttpHeaders, HTTP_END_OF_HDR_STR);
1943 }
1944
1945 //
1946 // Free the buffer.
1947 //
1948 if ((Rx4Token != NULL) && (Rx4Token->Packet.RxData != NULL) && (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer != NULL)) {
1949 FreePool (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer);
1950 Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;
1951 Fragment.Bulk = NULL;
1952 }
1953
1954 if (Fragment.Bulk != NULL) {
1955 FreePool (Fragment.Bulk);
1956 Fragment.Bulk = NULL;
1957 }
1958 } else {
1959 if (!HttpInstance->UseHttps) {
1960 Rx6Token = &HttpInstance->Rx6Token;
1961 Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer = AllocateZeroPool (DEF_BUF_LEN);
1962 if (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer == NULL) {
1963 Status = EFI_OUT_OF_RESOURCES;
1964 return Status;
1965 }
1966 }
1967
1968 //
1969 // Receive the HTTP headers only when EFI_HTTP_RESPONSE_DATA is not NULL.
1970 //
1971 while (*EndofHeader == NULL) {
1972 if (!HttpInstance->UseHttps) {
1973 HttpInstance->IsRxDone = FALSE;
1974 Rx6Token->Packet.RxData->DataLength = DEF_BUF_LEN;
1975 Rx6Token->Packet.RxData->FragmentTable[0].FragmentLength = DEF_BUF_LEN;
1976 Status = Tcp6->Receive (Tcp6, Rx6Token);
1977 if (EFI_ERROR (Status)) {
1978 DEBUG ((DEBUG_ERROR, "Tcp6 receive failed: %r\n", Status));
1979 return Status;
1980 }
1981
1982 while (!HttpInstance->IsRxDone && ((Timeout == NULL) || EFI_ERROR (gBS->CheckEvent (Timeout)))) {
1983 Tcp6->Poll (Tcp6);
1984 }
1985
1986 if (!HttpInstance->IsRxDone) {
1987 //
1988 // Cancel the Token before close its Event.
1989 //
1990 Tcp6->Cancel (HttpInstance->Tcp6, &Rx6Token->CompletionToken);
1991 gBS->CloseEvent (Rx6Token->CompletionToken.Event);
1992 Rx6Token->CompletionToken.Status = EFI_TIMEOUT;
1993 }
1994
1995 Status = Rx6Token->CompletionToken.Status;
1996 if (EFI_ERROR (Status)) {
1997 return Status;
1998 }
1999
2000 Fragment.Len = Rx6Token->Packet.RxData->FragmentTable[0].FragmentLength;
2001 Fragment.Bulk = (UINT8 *)Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer;
2002 } else {
2003 if (Fragment.Bulk != NULL) {
2004 FreePool (Fragment.Bulk);
2005 Fragment.Bulk = NULL;
2006 }
2007
2008 Status = HttpsReceive (HttpInstance, &Fragment, Timeout);
2009 if (EFI_ERROR (Status)) {
2010 DEBUG ((DEBUG_ERROR, "Tcp6 receive failed: %r\n", Status));
2011 return Status;
2012 }
2013 }
2014
2015 //
2016 // Append the response string along with a Null-terminator.
2017 //
2018 *BufferSize = *SizeofHeaders + Fragment.Len;
2019 Buffer = AllocatePool (*BufferSize + 1);
2020 if (Buffer == NULL) {
2021 Status = EFI_OUT_OF_RESOURCES;
2022 return Status;
2023 }
2024
2025 if (*HttpHeaders != NULL) {
2026 CopyMem (Buffer, *HttpHeaders, *SizeofHeaders);
2027 FreePool (*HttpHeaders);
2028 }
2029
2030 CopyMem (
2031 Buffer + *SizeofHeaders,
2032 Fragment.Bulk,
2033 Fragment.Len
2034 );
2035 *(Buffer + *BufferSize) = '\0';
2036 *HttpHeaders = Buffer;
2037 *SizeofHeaders = *BufferSize;
2038
2039 //
2040 // Check whether we received end of HTTP headers.
2041 //
2042 *EndofHeader = AsciiStrStr (*HttpHeaders, HTTP_END_OF_HDR_STR);
2043 }
2044
2045 //
2046 // Free the buffer.
2047 //
2048 if ((Rx6Token != NULL) && (Rx6Token->Packet.RxData != NULL) && (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer != NULL)) {
2049 FreePool (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer);
2050 Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;
2051 Fragment.Bulk = NULL;
2052 }
2053
2054 if (Fragment.Bulk != NULL) {
2055 FreePool (Fragment.Bulk);
2056 Fragment.Bulk = NULL;
2057 }
2058 }
2059
2060 //
2061 // Skip the CRLF after the HTTP headers.
2062 //
2063 *EndofHeader = *EndofHeader + AsciiStrLen (HTTP_END_OF_HDR_STR);
2064
2065 *SizeofHeaders = *EndofHeader - *HttpHeaders;
2066
2067 return EFI_SUCCESS;
2068}
2069
2070/**
2071 Receive the HTTP body by processing the associated HTTP token.
2072
2073 @param[in] Wrap The HTTP token's wrap data.
2074 @param[in] HttpMsg The HTTP message data.
2075
2076 @retval EFI_SUCCESS The HTTP body is received.
2077 @retval Others Other error as indicated.
2078
2079**/
2080EFI_STATUS
2081HttpTcpReceiveBody (
2082 IN HTTP_TOKEN_WRAP *Wrap,
2083 IN EFI_HTTP_MESSAGE *HttpMsg
2084 )
2085{
2086 EFI_STATUS Status;
2087 HTTP_PROTOCOL *HttpInstance;
2088 EFI_TCP6_PROTOCOL *Tcp6;
2089 EFI_TCP6_IO_TOKEN *Rx6Token;
2090 EFI_TCP4_PROTOCOL *Tcp4;
2091 EFI_TCP4_IO_TOKEN *Rx4Token;
2092
2093 HttpInstance = Wrap->HttpInstance;
2094 Tcp4 = HttpInstance->Tcp4;
2095 Tcp6 = HttpInstance->Tcp6;
2096 Rx4Token = NULL;
2097 Rx6Token = NULL;
2098
2099 if (HttpInstance->LocalAddressIsIPv6) {
2100 ASSERT (Tcp6 != NULL);
2101 } else {
2102 ASSERT (Tcp4 != NULL);
2103 }
2104
2105 if (HttpInstance->LocalAddressIsIPv6) {
2106 Rx6Token = &Wrap->TcpWrap.Rx6Token;
2107 Rx6Token->Packet.RxData->DataLength = (UINT32)MIN (MAX_UINT32, HttpMsg->BodyLength);
2108 Rx6Token->Packet.RxData->FragmentTable[0].FragmentLength = (UINT32)MIN (MAX_UINT32, HttpMsg->BodyLength);
2109 Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer = (VOID *)HttpMsg->Body;
2110 Rx6Token->CompletionToken.Status = EFI_NOT_READY;
2111
2112 Status = Tcp6->Receive (Tcp6, Rx6Token);
2113 if (EFI_ERROR (Status)) {
2114 DEBUG ((DEBUG_ERROR, "Tcp6 receive failed: %r\n", Status));
2115 return Status;
2116 }
2117 } else {
2118 Rx4Token = &Wrap->TcpWrap.Rx4Token;
2119 Rx4Token->Packet.RxData->DataLength = (UINT32)MIN (MAX_UINT32, HttpMsg->BodyLength);
2120 Rx4Token->Packet.RxData->FragmentTable[0].FragmentLength = (UINT32)MIN (MAX_UINT32, HttpMsg->BodyLength);
2121 Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer = (VOID *)HttpMsg->Body;
2122
2123 Rx4Token->CompletionToken.Status = EFI_NOT_READY;
2124 Status = Tcp4->Receive (Tcp4, Rx4Token);
2125 if (EFI_ERROR (Status)) {
2126 DEBUG ((DEBUG_ERROR, "Tcp4 receive failed: %r\n", Status));
2127 return Status;
2128 }
2129 }
2130
2131 return EFI_SUCCESS;
2132}
2133
2134/**
2135 Clean up Tcp Tokens while the Tcp transmission error occurs.
2136
2137 @param[in] Wrap Pointer to HTTP token's wrap data.
2138
2139**/
2140VOID
2141HttpTcpTokenCleanup (
2142 IN HTTP_TOKEN_WRAP *Wrap
2143 )
2144{
2145 HTTP_PROTOCOL *HttpInstance;
2146 EFI_TCP4_IO_TOKEN *Rx4Token;
2147 EFI_TCP6_IO_TOKEN *Rx6Token;
2148
2149 ASSERT (Wrap != NULL);
2150 HttpInstance = Wrap->HttpInstance;
2151 Rx4Token = NULL;
2152 Rx6Token = NULL;
2153
2154 if (HttpInstance->LocalAddressIsIPv6) {
2155 Rx6Token = &Wrap->TcpWrap.Rx6Token;
2156
2157 if (Rx6Token->CompletionToken.Event != NULL) {
2158 gBS->CloseEvent (Rx6Token->CompletionToken.Event);
2159 Rx6Token->CompletionToken.Event = NULL;
2160 }
2161
2162 FreePool (Wrap);
2163
2164 Rx6Token = &HttpInstance->Rx6Token;
2165
2166 if (Rx6Token->CompletionToken.Event != NULL) {
2167 gBS->CloseEvent (Rx6Token->CompletionToken.Event);
2168 Rx6Token->CompletionToken.Event = NULL;
2169 }
2170
2171 if (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer != NULL) {
2172 FreePool (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer);
2173 Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;
2174 }
2175 } else {
2176 Rx4Token = &Wrap->TcpWrap.Rx4Token;
2177
2178 if (Rx4Token->CompletionToken.Event != NULL) {
2179 gBS->CloseEvent (Rx4Token->CompletionToken.Event);
2180 Rx4Token->CompletionToken.Event = NULL;
2181 }
2182
2183 FreePool (Wrap);
2184
2185 Rx4Token = &HttpInstance->Rx4Token;
2186
2187 if (Rx4Token->CompletionToken.Event != NULL) {
2188 gBS->CloseEvent (Rx4Token->CompletionToken.Event);
2189 Rx4Token->CompletionToken.Event = NULL;
2190 }
2191
2192 if (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer != NULL) {
2193 FreePool (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer);
2194 Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;
2195 }
2196 }
2197}
2198
2199/**
2200 Send Events via EDKII_HTTP_CALLBACK_PROTOCOL.
2201
2202 @param[in] Event The event that occurs in the current state.
2203 @param[in] EventStatus The Status of Event, EFI_SUCCESS or other errors.
2204
2205**/
2206VOID
2207HttpNotify (
2208 IN EDKII_HTTP_CALLBACK_EVENT Event,
2209 IN EFI_STATUS EventStatus
2210 )
2211{
2212 EFI_STATUS Status;
2213 EFI_HANDLE *Handles;
2214 UINTN Index;
2215 UINTN HandleCount;
2216 EFI_HANDLE Handle;
2217 EDKII_HTTP_CALLBACK_PROTOCOL *HttpCallback;
2218
2219 DEBUG ((DEBUG_INFO, "HttpNotify: Event - %d, EventStatus - %r\n", Event, EventStatus));
2220
2221 Handles = NULL;
2222 HandleCount = 0;
2223 Status = gBS->LocateHandleBuffer (
2224 ByProtocol,
2225 &gEdkiiHttpCallbackProtocolGuid,
2226 NULL,
2227 &HandleCount,
2228 &Handles
2229 );
2230 if (Status == EFI_SUCCESS) {
2231 for (Index = 0; Index < HandleCount; Index++) {
2232 Handle = Handles[Index];
2233 Status = gBS->HandleProtocol (
2234 Handle,
2235 &gEdkiiHttpCallbackProtocolGuid,
2236 (VOID **)&HttpCallback
2237 );
2238 if (Status == EFI_SUCCESS) {
2239 DEBUG ((DEBUG_INFO, "HttpNotify: Notifying %p\n", HttpCallback));
2240 HttpCallback->Callback (
2241 HttpCallback,
2242 Event,
2243 EventStatus
2244 );
2245 }
2246 }
2247
2248 FreePool (Handles);
2249 }
2250}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette