HttpProto.c 66 KB

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