VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/UefiPxeBcDxe/PxeBcMtftp.c@ 99404

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

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 37.1 KB
Line 
1/** @file
2 Functions implementation related with Mtftp for UefiPxeBc Driver.
3
4 Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
5
6 SPDX-License-Identifier: BSD-2-Clause-Patent
7
8**/
9
10#include "PxeBcImpl.h"
11
12CHAR8 *mMtftpOptions[PXE_MTFTP_OPTION_MAXIMUM_INDEX] = {
13 "blksize",
14 "timeout",
15 "tsize",
16 "multicast",
17 "windowsize"
18};
19
20/**
21 This is a callback function when packets are received or transmitted in Mtftp driver.
22
23 A callback function that is provided by the caller to intercept
24 the EFI_MTFTP6_OPCODE_DATA or EFI_MTFTP6_OPCODE_DATA8 packets processed in the
25 EFI_MTFTP6_PROTOCOL.ReadFile() function, and alternatively to intercept
26 EFI_MTFTP6_OPCODE_OACK or EFI_MTFTP6_OPCODE_ERROR packets during a call to
27 EFI_MTFTP6_PROTOCOL.ReadFile(), WriteFile() or ReadDirectory().
28
29 @param[in] This Pointer to EFI_MTFTP6_PROTOCOL.
30 @param[in] Token Pointer to EFI_MTFTP6_TOKEN.
31 @param[in] PacketLen Length of EFI_MTFTP6_PACKET.
32 @param[in] Packet Pointer to EFI_MTFTP6_PACKET to be checked.
33
34 @retval EFI_SUCCESS The current operation succeeded.
35 @retval EFI_ABORTED Abort the current transfer process.
36
37**/
38EFI_STATUS
39EFIAPI
40PxeBcMtftp6CheckPacket (
41 IN EFI_MTFTP6_PROTOCOL *This,
42 IN EFI_MTFTP6_TOKEN *Token,
43 IN UINT16 PacketLen,
44 IN EFI_MTFTP6_PACKET *Packet
45 )
46{
47 PXEBC_PRIVATE_DATA *Private;
48 EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL *Callback;
49 EFI_STATUS Status;
50
51 Private = (PXEBC_PRIVATE_DATA *)Token->Context;
52 Callback = Private->PxeBcCallback;
53 Status = EFI_SUCCESS;
54
55 if (Packet->OpCode == EFI_MTFTP6_OPCODE_ERROR) {
56 //
57 // Store the tftp error message into mode data and set the received flag.
58 //
59 Private->Mode.TftpErrorReceived = TRUE;
60 Private->Mode.TftpError.ErrorCode = (UINT8)Packet->Error.ErrorCode;
61 AsciiStrnCpyS (
62 Private->Mode.TftpError.ErrorString,
63 PXE_MTFTP_ERROR_STRING_LENGTH,
64 (CHAR8 *)Packet->Error.ErrorMessage,
65 PXE_MTFTP_ERROR_STRING_LENGTH - 1
66 );
67 Private->Mode.TftpError.ErrorString[PXE_MTFTP_ERROR_STRING_LENGTH - 1] = '\0';
68 }
69
70 if (Callback != NULL) {
71 //
72 // Callback to user if has when received any tftp packet.
73 //
74 Status = Callback->Callback (
75 Callback,
76 Private->Function,
77 TRUE,
78 PacketLen,
79 (EFI_PXE_BASE_CODE_PACKET *)Packet
80 );
81 if (Status != EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE) {
82 //
83 // User wants to abort current process if not EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE.
84 //
85 Status = EFI_ABORTED;
86 } else {
87 //
88 // User wants to continue current process if EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE.
89 //
90 Status = EFI_SUCCESS;
91 }
92 }
93
94 return Status;
95}
96
97/**
98 This function is to get the size of a file using Tftp.
99
100 @param[in] Private Pointer to PxeBc private data.
101 @param[in] Config Pointer to EFI_MTFTP6_CONFIG_DATA.
102 @param[in] Filename Pointer to boot file name.
103 @param[in] BlockSize Pointer to required block size.
104 @param[in] WindowSize Pointer to required window size.
105 @param[in, out] BufferSize Pointer to buffer size.
106
107 @retval EFI_SUCCESS Successfully obtained the size of file.
108 @retval EFI_NOT_FOUND Parse the tftp options failed.
109 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
110 @retval Others Has not obtained the size of the file.
111
112**/
113EFI_STATUS
114PxeBcMtftp6GetFileSize (
115 IN PXEBC_PRIVATE_DATA *Private,
116 IN EFI_MTFTP6_CONFIG_DATA *Config,
117 IN UINT8 *Filename,
118 IN UINTN *BlockSize,
119 IN UINTN *WindowSize,
120 IN OUT UINT64 *BufferSize
121 )
122{
123 EFI_MTFTP6_PROTOCOL *Mtftp6;
124 EFI_MTFTP6_OPTION ReqOpt[3];
125 EFI_MTFTP6_PACKET *Packet;
126 EFI_MTFTP6_OPTION *Option;
127 UINT32 PktLen;
128 UINT8 OptBuf[PXE_MTFTP_OPTBUF_MAXNUM_INDEX];
129 UINTN OptBufSize;
130 UINT32 OptCnt;
131 EFI_STATUS Status;
132
133 *BufferSize = 0;
134 Status = EFI_DEVICE_ERROR;
135 Mtftp6 = Private->Mtftp6;
136 Packet = NULL;
137 Option = NULL;
138 PktLen = 0;
139 OptBufSize = PXE_MTFTP_OPTBUF_MAXNUM_INDEX;
140 OptCnt = 1;
141 Config->InitialServerPort = PXEBC_BS_DOWNLOAD_PORT;
142
143 Status = Mtftp6->Configure (Mtftp6, Config);
144 if (EFI_ERROR (Status)) {
145 return Status;
146 }
147
148 //
149 // Build the required options for get info.
150 //
151 ReqOpt[0].OptionStr = (UINT8 *)mMtftpOptions[PXE_MTFTP_OPTION_TSIZE_INDEX];
152 PxeBcUintnToAscDec (0, OptBuf, OptBufSize);
153 ReqOpt[0].ValueStr = OptBuf;
154
155 if (BlockSize != NULL) {
156 ReqOpt[OptCnt].OptionStr = (UINT8 *)mMtftpOptions[PXE_MTFTP_OPTION_BLKSIZE_INDEX];
157 ReqOpt[OptCnt].ValueStr = (UINT8 *)(ReqOpt[OptCnt-1].ValueStr + AsciiStrLen ((CHAR8 *)ReqOpt[OptCnt-1].ValueStr) + 1);
158 OptBufSize -= (AsciiStrLen ((CHAR8 *)ReqOpt[OptCnt-1].ValueStr) + 1);
159 PxeBcUintnToAscDec (*BlockSize, ReqOpt[OptCnt].ValueStr, OptBufSize);
160 OptCnt++;
161 }
162
163 if (WindowSize != NULL) {
164 ReqOpt[OptCnt].OptionStr = (UINT8 *)mMtftpOptions[PXE_MTFTP_OPTION_WINDOWSIZE_INDEX];
165 ReqOpt[OptCnt].ValueStr = (UINT8 *)(ReqOpt[OptCnt-1].ValueStr + AsciiStrLen ((CHAR8 *)ReqOpt[OptCnt-1].ValueStr) + 1);
166 OptBufSize -= (AsciiStrLen ((CHAR8 *)ReqOpt[OptCnt-1].ValueStr) + 1);
167 PxeBcUintnToAscDec (*WindowSize, ReqOpt[OptCnt].ValueStr, OptBufSize);
168 OptCnt++;
169 }
170
171 Status = Mtftp6->GetInfo (
172 Mtftp6,
173 NULL,
174 Filename,
175 NULL,
176 (UINT8)OptCnt,
177 ReqOpt,
178 &PktLen,
179 &Packet
180 );
181 if (EFI_ERROR (Status)) {
182 if (Status == EFI_TFTP_ERROR) {
183 //
184 // Store the tftp error message into mode data and set the received flag.
185 //
186 Private->Mode.TftpErrorReceived = TRUE;
187 Private->Mode.TftpError.ErrorCode = (UINT8)Packet->Error.ErrorCode;
188 AsciiStrnCpyS (
189 Private->Mode.TftpError.ErrorString,
190 PXE_MTFTP_ERROR_STRING_LENGTH,
191 (CHAR8 *)Packet->Error.ErrorMessage,
192 PXE_MTFTP_ERROR_STRING_LENGTH - 1
193 );
194 Private->Mode.TftpError.ErrorString[PXE_MTFTP_ERROR_STRING_LENGTH - 1] = '\0';
195 }
196
197 goto ON_ERROR;
198 }
199
200 //
201 // Parse the options in the reply packet.
202 //
203 OptCnt = 0;
204 Status = Mtftp6->ParseOptions (
205 Mtftp6,
206 PktLen,
207 Packet,
208 (UINT32 *)&OptCnt,
209 &Option
210 );
211 if (EFI_ERROR (Status)) {
212 goto ON_ERROR;
213 }
214
215 //
216 // Parse out the value of "tsize" option.
217 //
218 Status = EFI_NOT_FOUND;
219 while (OptCnt != 0) {
220 if (AsciiStrnCmp ((CHAR8 *)Option[OptCnt - 1].OptionStr, "tsize", 5) == 0) {
221 *BufferSize = AsciiStrDecimalToUint64 ((CHAR8 *)(Option[OptCnt - 1].ValueStr));
222 Status = EFI_SUCCESS;
223 }
224
225 OptCnt--;
226 }
227
228 FreePool (Option);
229
230ON_ERROR:
231 if (Packet != NULL) {
232 FreePool (Packet);
233 }
234
235 Mtftp6->Configure (Mtftp6, NULL);
236
237 return Status;
238}
239
240/**
241 This function is to get data of a file using Tftp.
242
243 @param[in] Private Pointer to PxeBc private data.
244 @param[in] Config Pointer to EFI_MTFTP6_CONFIG_DATA.
245 @param[in] Filename Pointer to boot file name.
246 @param[in] BlockSize Pointer to required block size.
247 @param[in] WindowSize Pointer to required window size.
248 @param[in] BufferPtr Pointer to buffer.
249 @param[in, out] BufferSize Pointer to buffer size.
250 @param[in] DontUseBuffer Indicates whether with a receive buffer.
251
252 @retval EFI_SUCCESS Successfully read the data from the special file.
253 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
254 @retval Others Read data from file failed.
255
256**/
257EFI_STATUS
258PxeBcMtftp6ReadFile (
259 IN PXEBC_PRIVATE_DATA *Private,
260 IN EFI_MTFTP6_CONFIG_DATA *Config,
261 IN UINT8 *Filename,
262 IN UINTN *BlockSize,
263 IN UINTN *WindowSize,
264 IN UINT8 *BufferPtr,
265 IN OUT UINT64 *BufferSize,
266 IN BOOLEAN DontUseBuffer
267 )
268{
269 EFI_MTFTP6_PROTOCOL *Mtftp6;
270 EFI_MTFTP6_TOKEN Token;
271 EFI_MTFTP6_OPTION ReqOpt[2];
272 UINT32 OptCnt;
273 UINT8 BlksizeBuf[10];
274 UINT8 WindowsizeBuf[10];
275 EFI_STATUS Status;
276
277 Status = EFI_DEVICE_ERROR;
278 Mtftp6 = Private->Mtftp6;
279 OptCnt = 0;
280 Config->InitialServerPort = PXEBC_BS_DOWNLOAD_PORT;
281
282 Status = Mtftp6->Configure (Mtftp6, Config);
283 if (EFI_ERROR (Status)) {
284 return Status;
285 }
286
287 if (BlockSize != NULL) {
288 ReqOpt[OptCnt].OptionStr = (UINT8 *)mMtftpOptions[PXE_MTFTP_OPTION_BLKSIZE_INDEX];
289 ReqOpt[OptCnt].ValueStr = BlksizeBuf;
290 PxeBcUintnToAscDec (*BlockSize, ReqOpt[OptCnt].ValueStr, sizeof (BlksizeBuf));
291 OptCnt++;
292 }
293
294 if (WindowSize != NULL) {
295 ReqOpt[OptCnt].OptionStr = (UINT8 *)mMtftpOptions[PXE_MTFTP_OPTION_WINDOWSIZE_INDEX];
296 ReqOpt[OptCnt].ValueStr = WindowsizeBuf;
297 PxeBcUintnToAscDec (*WindowSize, ReqOpt[OptCnt].ValueStr, sizeof (WindowsizeBuf));
298 OptCnt++;
299 }
300
301 Token.Event = NULL;
302 Token.OverrideData = NULL;
303 Token.Filename = Filename;
304 Token.ModeStr = NULL;
305 Token.OptionCount = OptCnt;
306 Token.OptionList = ReqOpt;
307 Token.Context = Private;
308
309 if (DontUseBuffer) {
310 Token.BufferSize = 0;
311 Token.Buffer = NULL;
312 } else {
313 Token.BufferSize = *BufferSize;
314 Token.Buffer = BufferPtr;
315 }
316
317 Token.CheckPacket = PxeBcMtftp6CheckPacket;
318 Token.TimeoutCallback = NULL;
319 Token.PacketNeeded = NULL;
320
321 Status = Mtftp6->ReadFile (Mtftp6, &Token);
322 //
323 // Get the real size of received buffer.
324 //
325 *BufferSize = Token.BufferSize;
326
327 Mtftp6->Configure (Mtftp6, NULL);
328
329 return Status;
330}
331
332/**
333 This function is used to write the data of a file using Tftp.
334
335 @param[in] Private Pointer to PxeBc private data.
336 @param[in] Config Pointer to EFI_MTFTP6_CONFIG_DATA.
337 @param[in] Filename Pointer to boot file name.
338 @param[in] Overwrite Indicate whether with overwrite attribute.
339 @param[in] BlockSize Pointer to required block size.
340 @param[in] BufferPtr Pointer to buffer.
341 @param[in, out] BufferSize Pointer to buffer size.
342
343 @retval EFI_SUCCESS Successfully wrote the data into a special file.
344 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
345 @retval other Write data into file failed.
346
347**/
348EFI_STATUS
349PxeBcMtftp6WriteFile (
350 IN PXEBC_PRIVATE_DATA *Private,
351 IN EFI_MTFTP6_CONFIG_DATA *Config,
352 IN UINT8 *Filename,
353 IN BOOLEAN Overwrite,
354 IN UINTN *BlockSize,
355 IN UINT8 *BufferPtr,
356 IN OUT UINT64 *BufferSize
357 )
358{
359 EFI_MTFTP6_PROTOCOL *Mtftp6;
360 EFI_MTFTP6_TOKEN Token;
361 EFI_MTFTP6_OPTION ReqOpt[1];
362 UINT32 OptCnt;
363 UINT8 OptBuf[128];
364 EFI_STATUS Status;
365
366 Status = EFI_DEVICE_ERROR;
367 Mtftp6 = Private->Mtftp6;
368 OptCnt = 0;
369 Config->InitialServerPort = PXEBC_BS_DOWNLOAD_PORT;
370
371 Status = Mtftp6->Configure (Mtftp6, Config);
372 if (EFI_ERROR (Status)) {
373 return Status;
374 }
375
376 if (BlockSize != NULL) {
377 ReqOpt[0].OptionStr = (UINT8 *)mMtftpOptions[PXE_MTFTP_OPTION_BLKSIZE_INDEX];
378 ReqOpt[0].ValueStr = OptBuf;
379 PxeBcUintnToAscDec (*BlockSize, ReqOpt[0].ValueStr, PXE_MTFTP_OPTBUF_MAXNUM_INDEX);
380 OptCnt++;
381 }
382
383 Token.Event = NULL;
384 Token.OverrideData = NULL;
385 Token.Filename = Filename;
386 Token.ModeStr = NULL;
387 Token.OptionCount = OptCnt;
388 Token.OptionList = ReqOpt;
389 Token.BufferSize = *BufferSize;
390 Token.Buffer = BufferPtr;
391 Token.CheckPacket = PxeBcMtftp6CheckPacket;
392 Token.TimeoutCallback = NULL;
393 Token.PacketNeeded = NULL;
394
395 Status = Mtftp6->WriteFile (Mtftp6, &Token);
396 //
397 // Get the real size of transmitted buffer.
398 //
399 *BufferSize = Token.BufferSize;
400
401 Mtftp6->Configure (Mtftp6, NULL);
402
403 return Status;
404}
405
406/**
407 This function is to read the data (file) from a directory using Tftp.
408
409 @param[in] Private Pointer to PxeBc private data.
410 @param[in] Config Pointer to EFI_MTFTP6_CONFIG_DATA.
411 @param[in] Filename Pointer to boot file name.
412 @param[in] BlockSize Pointer to required block size.
413 @param[in] WindowSize Pointer to required window size.
414 @param[in] BufferPtr Pointer to buffer.
415 @param[in, out] BufferSize Pointer to buffer size.
416 @param[in] DontUseBuffer Indicates whether to use a receive buffer.
417
418 @retval EFI_SUCCESS Successfully obtained the data from the file included in directory.
419 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
420 @retval Others Operation failed.
421
422**/
423EFI_STATUS
424PxeBcMtftp6ReadDirectory (
425 IN PXEBC_PRIVATE_DATA *Private,
426 IN EFI_MTFTP6_CONFIG_DATA *Config,
427 IN UINT8 *Filename,
428 IN UINTN *BlockSize,
429 IN UINTN *WindowSize,
430 IN UINT8 *BufferPtr,
431 IN OUT UINT64 *BufferSize,
432 IN BOOLEAN DontUseBuffer
433 )
434{
435 EFI_MTFTP6_PROTOCOL *Mtftp6;
436 EFI_MTFTP6_TOKEN Token;
437 EFI_MTFTP6_OPTION ReqOpt[2];
438 UINT32 OptCnt;
439 UINT8 BlksizeBuf[10];
440 UINT8 WindowsizeBuf[10];
441 EFI_STATUS Status;
442
443 Status = EFI_DEVICE_ERROR;
444 Mtftp6 = Private->Mtftp6;
445 OptCnt = 0;
446 Config->InitialServerPort = PXEBC_BS_DOWNLOAD_PORT;
447
448 Status = Mtftp6->Configure (Mtftp6, Config);
449 if (EFI_ERROR (Status)) {
450 return Status;
451 }
452
453 if (BlockSize != NULL) {
454 ReqOpt[OptCnt].OptionStr = (UINT8 *)mMtftpOptions[PXE_MTFTP_OPTION_BLKSIZE_INDEX];
455 ReqOpt[OptCnt].ValueStr = BlksizeBuf;
456 PxeBcUintnToAscDec (*BlockSize, ReqOpt[OptCnt].ValueStr, sizeof (BlksizeBuf));
457 OptCnt++;
458 }
459
460 if (WindowSize != NULL) {
461 ReqOpt[OptCnt].OptionStr = (UINT8 *)mMtftpOptions[PXE_MTFTP_OPTION_WINDOWSIZE_INDEX];
462 ReqOpt[OptCnt].ValueStr = WindowsizeBuf;
463 PxeBcUintnToAscDec (*WindowSize, ReqOpt[OptCnt].ValueStr, sizeof (WindowsizeBuf));
464 OptCnt++;
465 }
466
467 Token.Event = NULL;
468 Token.OverrideData = NULL;
469 Token.Filename = Filename;
470 Token.ModeStr = NULL;
471 Token.OptionCount = OptCnt;
472 Token.OptionList = ReqOpt;
473 Token.Context = Private;
474
475 if (DontUseBuffer) {
476 Token.BufferSize = 0;
477 Token.Buffer = NULL;
478 } else {
479 Token.BufferSize = *BufferSize;
480 Token.Buffer = BufferPtr;
481 }
482
483 Token.CheckPacket = PxeBcMtftp6CheckPacket;
484 Token.TimeoutCallback = NULL;
485 Token.PacketNeeded = NULL;
486
487 Status = Mtftp6->ReadDirectory (Mtftp6, &Token);
488 //
489 // Get the real size of received buffer.
490 //
491 *BufferSize = Token.BufferSize;
492
493 Mtftp6->Configure (Mtftp6, NULL);
494
495 return Status;
496}
497
498/**
499 This is a callback function when packets are received or transmitted in Mtftp driver.
500
501 A callback function that is provided by the caller to intercept
502 the EFI_MTFTP6_OPCODE_DATA or EFI_MTFTP4_OPCODE_DATA8 packets processed in the
503 EFI_MTFTP4_PROTOCOL.ReadFile() function, and alternatively to intercept
504 EFI_MTFTP4_OPCODE_OACK or EFI_MTFTP4_OPCODE_ERROR packets during a call to
505 EFI_MTFTP4_PROTOCOL.ReadFile(), WriteFile() or ReadDirectory().
506
507 @param[in] This Pointer to EFI_MTFTP4_PROTOCOL.
508 @param[in] Token Pointer to EFI_MTFTP4_TOKEN.
509 @param[in] PacketLen Length of EFI_MTFTP4_PACKET.
510 @param[in] Packet Pointer to EFI_MTFTP4_PACKET to be checked.
511
512 @retval EFI_SUCCESS The current operation succeeded.
513 @retval EFI_ABORTED Abort the current transfer process.
514
515**/
516EFI_STATUS
517EFIAPI
518PxeBcMtftp4CheckPacket (
519 IN EFI_MTFTP4_PROTOCOL *This,
520 IN EFI_MTFTP4_TOKEN *Token,
521 IN UINT16 PacketLen,
522 IN EFI_MTFTP4_PACKET *Packet
523 )
524{
525 PXEBC_PRIVATE_DATA *Private;
526 EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL *Callback;
527 EFI_STATUS Status;
528
529 Private = (PXEBC_PRIVATE_DATA *)Token->Context;
530 Callback = Private->PxeBcCallback;
531 Status = EFI_SUCCESS;
532
533 if (Packet->OpCode == EFI_MTFTP4_OPCODE_ERROR) {
534 //
535 // Store the tftp error message into mode data and set the received flag.
536 //
537 Private->Mode.TftpErrorReceived = TRUE;
538 Private->Mode.TftpError.ErrorCode = (UINT8)Packet->Error.ErrorCode;
539 AsciiStrnCpyS (
540 Private->Mode.TftpError.ErrorString,
541 PXE_MTFTP_ERROR_STRING_LENGTH,
542 (CHAR8 *)Packet->Error.ErrorMessage,
543 PXE_MTFTP_ERROR_STRING_LENGTH - 1
544 );
545 Private->Mode.TftpError.ErrorString[PXE_MTFTP_ERROR_STRING_LENGTH - 1] = '\0';
546 }
547
548 if (Callback != NULL) {
549 //
550 // Callback to user if has when received any tftp packet.
551 //
552 Status = Callback->Callback (
553 Callback,
554 Private->Function,
555 TRUE,
556 PacketLen,
557 (EFI_PXE_BASE_CODE_PACKET *)Packet
558 );
559 if (Status != EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE) {
560 //
561 // User wants to abort current process if not EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE.
562 //
563 Status = EFI_ABORTED;
564 } else {
565 //
566 // User wants to continue current process if EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE.
567 //
568 Status = EFI_SUCCESS;
569 }
570 }
571
572 return Status;
573}
574
575/**
576 This function is to get size of a file using Tftp.
577
578 @param[in] Private Pointer to PxeBc private data.
579 @param[in] Config Pointer to EFI_MTFTP4_CONFIG_DATA.
580 @param[in] Filename Pointer to boot file name.
581 @param[in] BlockSize Pointer to required block size.
582 @param[in] WindowSize Pointer to required window size.
583 @param[in, out] BufferSize Pointer to buffer size.
584
585 @retval EFI_SUCCESS Successfully obtained the size of file.
586 @retval EFI_NOT_FOUND Parse the tftp options failed.
587 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
588 @retval Others Did not obtain the size of the file.
589
590**/
591EFI_STATUS
592PxeBcMtftp4GetFileSize (
593 IN PXEBC_PRIVATE_DATA *Private,
594 IN EFI_MTFTP4_CONFIG_DATA *Config,
595 IN UINT8 *Filename,
596 IN UINTN *BlockSize,
597 IN UINTN *WindowSize,
598 IN OUT UINT64 *BufferSize
599 )
600{
601 EFI_MTFTP4_PROTOCOL *Mtftp4;
602 EFI_MTFTP4_OPTION ReqOpt[3];
603 EFI_MTFTP4_PACKET *Packet;
604 EFI_MTFTP4_OPTION *Option;
605 UINT32 PktLen;
606 UINT8 OptBuf[PXE_MTFTP_OPTBUF_MAXNUM_INDEX];
607 UINTN OptBufSize;
608 UINT32 OptCnt;
609 EFI_STATUS Status;
610
611 *BufferSize = 0;
612 Status = EFI_DEVICE_ERROR;
613 Mtftp4 = Private->Mtftp4;
614 Packet = NULL;
615 Option = NULL;
616 PktLen = 0;
617 OptBufSize = PXE_MTFTP_OPTBUF_MAXNUM_INDEX;
618 OptCnt = 1;
619 Config->InitialServerPort = PXEBC_BS_DOWNLOAD_PORT;
620
621 Status = Mtftp4->Configure (Mtftp4, Config);
622 if (EFI_ERROR (Status)) {
623 return Status;
624 }
625
626 //
627 // Build the required options for get info.
628 //
629 ReqOpt[0].OptionStr = (UINT8 *)mMtftpOptions[PXE_MTFTP_OPTION_TSIZE_INDEX];
630 PxeBcUintnToAscDec (0, OptBuf, OptBufSize);
631 ReqOpt[0].ValueStr = OptBuf;
632
633 if (BlockSize != NULL) {
634 ReqOpt[OptCnt].OptionStr = (UINT8 *)mMtftpOptions[PXE_MTFTP_OPTION_BLKSIZE_INDEX];
635 ReqOpt[OptCnt].ValueStr = (UINT8 *)(ReqOpt[OptCnt-1].ValueStr + AsciiStrLen ((CHAR8 *)ReqOpt[OptCnt-1].ValueStr) + 1);
636 OptBufSize -= (AsciiStrLen ((CHAR8 *)ReqOpt[OptCnt-1].ValueStr) + 1);
637 PxeBcUintnToAscDec (*BlockSize, ReqOpt[OptCnt].ValueStr, OptBufSize);
638 OptCnt++;
639 }
640
641 if (WindowSize != NULL) {
642 ReqOpt[OptCnt].OptionStr = (UINT8 *)mMtftpOptions[PXE_MTFTP_OPTION_WINDOWSIZE_INDEX];
643 ReqOpt[OptCnt].ValueStr = (UINT8 *)(ReqOpt[OptCnt-1].ValueStr + AsciiStrLen ((CHAR8 *)ReqOpt[OptCnt-1].ValueStr) + 1);
644 OptBufSize -= (AsciiStrLen ((CHAR8 *)ReqOpt[OptCnt-1].ValueStr) + 1);
645 PxeBcUintnToAscDec (*WindowSize, ReqOpt[OptCnt].ValueStr, OptBufSize);
646 OptCnt++;
647 }
648
649 Status = Mtftp4->GetInfo (
650 Mtftp4,
651 NULL,
652 Filename,
653 NULL,
654 (UINT8)OptCnt,
655 ReqOpt,
656 &PktLen,
657 &Packet
658 );
659 if (EFI_ERROR (Status)) {
660 if (Status == EFI_TFTP_ERROR) {
661 //
662 // Store the tftp error message into mode data and set the received flag.
663 //
664 Private->Mode.TftpErrorReceived = TRUE;
665 Private->Mode.TftpError.ErrorCode = (UINT8)Packet->Error.ErrorCode;
666 AsciiStrnCpyS (
667 Private->Mode.TftpError.ErrorString,
668 PXE_MTFTP_ERROR_STRING_LENGTH,
669 (CHAR8 *)Packet->Error.ErrorMessage,
670 PXE_MTFTP_ERROR_STRING_LENGTH - 1
671 );
672 Private->Mode.TftpError.ErrorString[PXE_MTFTP_ERROR_STRING_LENGTH - 1] = '\0';
673 }
674
675 goto ON_ERROR;
676 }
677
678 //
679 // Parse the options in the reply packet.
680 //
681 OptCnt = 0;
682 Status = Mtftp4->ParseOptions (
683 Mtftp4,
684 PktLen,
685 Packet,
686 (UINT32 *)&OptCnt,
687 &Option
688 );
689 if (EFI_ERROR (Status)) {
690 goto ON_ERROR;
691 }
692
693 //
694 // Parse out the value of "tsize" option.
695 //
696 Status = EFI_NOT_FOUND;
697 while (OptCnt != 0) {
698 if (AsciiStrnCmp ((CHAR8 *)Option[OptCnt - 1].OptionStr, "tsize", 5) == 0) {
699 *BufferSize = AsciiStrDecimalToUint64 ((CHAR8 *)(Option[OptCnt - 1].ValueStr));
700 Status = EFI_SUCCESS;
701 }
702
703 OptCnt--;
704 }
705
706 FreePool (Option);
707
708ON_ERROR:
709 if (Packet != NULL) {
710 FreePool (Packet);
711 }
712
713 Mtftp4->Configure (Mtftp4, NULL);
714
715 return Status;
716}
717
718/**
719 This function is to read the data of a file using Tftp.
720
721 @param[in] Private Pointer to PxeBc private data.
722 @param[in] Config Pointer to EFI_MTFTP4_CONFIG_DATA.
723 @param[in] Filename Pointer to boot file name.
724 @param[in] BlockSize Pointer to required block size.
725 @param[in] WindowSize Pointer to required window size.
726 @param[in] BufferPtr Pointer to buffer.
727 @param[in, out] BufferSize Pointer to buffer size.
728 @param[in] DontUseBuffer Indicates whether to use a receive buffer.
729
730 @retval EFI_SUCCESS Successfully read the data from the special file.
731 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
732 @retval Others Read data from file failed.
733
734**/
735EFI_STATUS
736PxeBcMtftp4ReadFile (
737 IN PXEBC_PRIVATE_DATA *Private,
738 IN EFI_MTFTP4_CONFIG_DATA *Config,
739 IN UINT8 *Filename,
740 IN UINTN *BlockSize,
741 IN UINTN *WindowSize,
742 IN UINT8 *BufferPtr,
743 IN OUT UINT64 *BufferSize,
744 IN BOOLEAN DontUseBuffer
745 )
746{
747 EFI_MTFTP4_PROTOCOL *Mtftp4;
748 EFI_MTFTP4_TOKEN Token;
749 EFI_MTFTP4_OPTION ReqOpt[2];
750 UINT32 OptCnt;
751 UINT8 BlksizeBuf[10];
752 UINT8 WindowsizeBuf[10];
753 EFI_STATUS Status;
754
755 Status = EFI_DEVICE_ERROR;
756 Mtftp4 = Private->Mtftp4;
757 OptCnt = 0;
758 Config->InitialServerPort = PXEBC_BS_DOWNLOAD_PORT;
759
760 Status = Mtftp4->Configure (Mtftp4, Config);
761 if (EFI_ERROR (Status)) {
762 return Status;
763 }
764
765 if (BlockSize != NULL) {
766 ReqOpt[OptCnt].OptionStr = (UINT8 *)mMtftpOptions[PXE_MTFTP_OPTION_BLKSIZE_INDEX];
767 ReqOpt[OptCnt].ValueStr = BlksizeBuf;
768 PxeBcUintnToAscDec (*BlockSize, ReqOpt[OptCnt].ValueStr, sizeof (BlksizeBuf));
769 OptCnt++;
770 }
771
772 if (WindowSize != NULL) {
773 ReqOpt[OptCnt].OptionStr = (UINT8 *)mMtftpOptions[PXE_MTFTP_OPTION_WINDOWSIZE_INDEX];
774 ReqOpt[OptCnt].ValueStr = WindowsizeBuf;
775 PxeBcUintnToAscDec (*WindowSize, ReqOpt[OptCnt].ValueStr, sizeof (WindowsizeBuf));
776 OptCnt++;
777 }
778
779 Token.Event = NULL;
780 Token.OverrideData = NULL;
781 Token.Filename = Filename;
782 Token.ModeStr = NULL;
783 Token.OptionCount = OptCnt;
784 Token.OptionList = ReqOpt;
785 Token.Context = Private;
786
787 if (DontUseBuffer) {
788 Token.BufferSize = 0;
789 Token.Buffer = NULL;
790 } else {
791 Token.BufferSize = *BufferSize;
792 Token.Buffer = BufferPtr;
793 }
794
795 Token.CheckPacket = PxeBcMtftp4CheckPacket;
796 Token.TimeoutCallback = NULL;
797 Token.PacketNeeded = NULL;
798
799 Status = Mtftp4->ReadFile (Mtftp4, &Token);
800 //
801 // Get the real size of received buffer.
802 //
803 *BufferSize = Token.BufferSize;
804
805 Mtftp4->Configure (Mtftp4, NULL);
806
807 return Status;
808}
809
810/**
811 This function is to write the data of a file using Tftp.
812
813 @param[in] Private Pointer to PxeBc private data.
814 @param[in] Config Pointer to EFI_MTFTP4_CONFIG_DATA.
815 @param[in] Filename Pointer to boot file name.
816 @param[in] Overwrite Indicates whether to use the overwrite attribute.
817 @param[in] BlockSize Pointer to required block size.
818 @param[in] BufferPtr Pointer to buffer.
819 @param[in, out] BufferSize Pointer to buffer size.
820
821 @retval EFI_SUCCESS Successfully write the data into the special file.
822 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
823 @retval other Write data into file failed.
824
825**/
826EFI_STATUS
827PxeBcMtftp4WriteFile (
828 IN PXEBC_PRIVATE_DATA *Private,
829 IN EFI_MTFTP4_CONFIG_DATA *Config,
830 IN UINT8 *Filename,
831 IN BOOLEAN Overwrite,
832 IN UINTN *BlockSize,
833 IN UINT8 *BufferPtr,
834 IN OUT UINT64 *BufferSize
835 )
836{
837 EFI_MTFTP4_PROTOCOL *Mtftp4;
838 EFI_MTFTP4_TOKEN Token;
839 EFI_MTFTP4_OPTION ReqOpt[1];
840 UINT32 OptCnt;
841 UINT8 OptBuf[128];
842 EFI_STATUS Status;
843
844 Status = EFI_DEVICE_ERROR;
845 Mtftp4 = Private->Mtftp4;
846 OptCnt = 0;
847 Config->InitialServerPort = PXEBC_BS_DOWNLOAD_PORT;
848
849 Status = Mtftp4->Configure (Mtftp4, Config);
850 if (EFI_ERROR (Status)) {
851 return Status;
852 }
853
854 if (BlockSize != NULL) {
855 ReqOpt[0].OptionStr = (UINT8 *)mMtftpOptions[PXE_MTFTP_OPTION_BLKSIZE_INDEX];
856 ReqOpt[0].ValueStr = OptBuf;
857 PxeBcUintnToAscDec (*BlockSize, ReqOpt[0].ValueStr, PXE_MTFTP_OPTBUF_MAXNUM_INDEX);
858 OptCnt++;
859 }
860
861 Token.Event = NULL;
862 Token.OverrideData = NULL;
863 Token.Filename = Filename;
864 Token.ModeStr = NULL;
865 Token.OptionCount = OptCnt;
866 Token.OptionList = ReqOpt;
867 Token.BufferSize = *BufferSize;
868 Token.Buffer = BufferPtr;
869 Token.CheckPacket = PxeBcMtftp4CheckPacket;
870 Token.TimeoutCallback = NULL;
871 Token.PacketNeeded = NULL;
872
873 Status = Mtftp4->WriteFile (Mtftp4, &Token);
874 //
875 // Get the real size of transmitted buffer.
876 //
877 *BufferSize = Token.BufferSize;
878
879 Mtftp4->Configure (Mtftp4, NULL);
880
881 return Status;
882}
883
884/**
885 This function is to get data (file) from a directory using Tftp.
886
887 @param[in] Private Pointer to PxeBc private data.
888 @param[in] Config Pointer to EFI_MTFTP4_CONFIG_DATA.
889 @param[in] Filename Pointer to boot file name.
890 @param[in] BlockSize Pointer to required block size.
891 @param[in] WindowSize Pointer to required window size.
892 @param[in] BufferPtr Pointer to buffer.
893 @param[in, out] BufferSize Pointer to buffer size.
894 @param[in] DontUseBuffer Indicates whether to use a receive buffer.
895
896 @retval EFI_SUCCESS Successfully obtained the data from the file included in the directory.
897 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
898 @retval Others Operation failed.
899
900**/
901EFI_STATUS
902PxeBcMtftp4ReadDirectory (
903 IN PXEBC_PRIVATE_DATA *Private,
904 IN EFI_MTFTP4_CONFIG_DATA *Config,
905 IN UINT8 *Filename,
906 IN UINTN *BlockSize,
907 IN UINTN *WindowSize,
908 IN UINT8 *BufferPtr,
909 IN OUT UINT64 *BufferSize,
910 IN BOOLEAN DontUseBuffer
911 )
912{
913 EFI_MTFTP4_PROTOCOL *Mtftp4;
914 EFI_MTFTP4_TOKEN Token;
915 EFI_MTFTP4_OPTION ReqOpt[2];
916 UINT32 OptCnt;
917 UINT8 BlksizeBuf[10];
918 UINT8 WindowsizeBuf[10];
919 EFI_STATUS Status;
920
921 Status = EFI_DEVICE_ERROR;
922 Mtftp4 = Private->Mtftp4;
923 OptCnt = 0;
924 Config->InitialServerPort = PXEBC_BS_DOWNLOAD_PORT;
925
926 Status = Mtftp4->Configure (Mtftp4, Config);
927 if (EFI_ERROR (Status)) {
928 return Status;
929 }
930
931 if (BlockSize != NULL) {
932 ReqOpt[OptCnt].OptionStr = (UINT8 *)mMtftpOptions[PXE_MTFTP_OPTION_BLKSIZE_INDEX];
933 ReqOpt[OptCnt].ValueStr = BlksizeBuf;
934 PxeBcUintnToAscDec (*BlockSize, ReqOpt[OptCnt].ValueStr, sizeof (BlksizeBuf));
935 OptCnt++;
936 }
937
938 if (WindowSize != NULL) {
939 ReqOpt[OptCnt].OptionStr = (UINT8 *)mMtftpOptions[PXE_MTFTP_OPTION_WINDOWSIZE_INDEX];
940 ReqOpt[OptCnt].ValueStr = WindowsizeBuf;
941 PxeBcUintnToAscDec (*WindowSize, ReqOpt[OptCnt].ValueStr, sizeof (WindowsizeBuf));
942 OptCnt++;
943 }
944
945 Token.Event = NULL;
946 Token.OverrideData = NULL;
947 Token.Filename = Filename;
948 Token.ModeStr = NULL;
949 Token.OptionCount = OptCnt;
950 Token.OptionList = ReqOpt;
951 Token.Context = Private;
952
953 if (DontUseBuffer) {
954 Token.BufferSize = 0;
955 Token.Buffer = NULL;
956 } else {
957 Token.BufferSize = *BufferSize;
958 Token.Buffer = BufferPtr;
959 }
960
961 Token.CheckPacket = PxeBcMtftp4CheckPacket;
962 Token.TimeoutCallback = NULL;
963 Token.PacketNeeded = NULL;
964
965 Status = Mtftp4->ReadDirectory (Mtftp4, &Token);
966 //
967 // Get the real size of received buffer.
968 //
969 *BufferSize = Token.BufferSize;
970
971 Mtftp4->Configure (Mtftp4, NULL);
972
973 return Status;
974}
975
976/**
977 This function is wrapper to get the file size using TFTP.
978
979 @param[in] Private Pointer to PxeBc private data.
980 @param[in] Config Pointer to configure data.
981 @param[in] Filename Pointer to boot file name.
982 @param[in] BlockSize Pointer to required block size.
983 @param[in] WindowSize Pointer to required window size.
984 @param[in, out] BufferSize Pointer to buffer size.
985
986 @retval EFI_SUCCESS Successfully obtained the size of file.
987 @retval EFI_NOT_FOUND Parse the tftp options failed.
988 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
989 @retval Others Did not obtain the size of the file.
990
991**/
992EFI_STATUS
993PxeBcTftpGetFileSize (
994 IN PXEBC_PRIVATE_DATA *Private,
995 IN VOID *Config,
996 IN UINT8 *Filename,
997 IN UINTN *BlockSize,
998 IN UINTN *WindowSize,
999 IN OUT UINT64 *BufferSize
1000 )
1001{
1002 if (Private->PxeBc.Mode->UsingIpv6) {
1003 return PxeBcMtftp6GetFileSize (
1004 Private,
1005 (EFI_MTFTP6_CONFIG_DATA *)Config,
1006 Filename,
1007 BlockSize,
1008 WindowSize,
1009 BufferSize
1010 );
1011 } else {
1012 return PxeBcMtftp4GetFileSize (
1013 Private,
1014 (EFI_MTFTP4_CONFIG_DATA *)Config,
1015 Filename,
1016 BlockSize,
1017 WindowSize,
1018 BufferSize
1019 );
1020 }
1021}
1022
1023/**
1024 This function is a wrapper to get file using TFTP.
1025
1026 @param[in] Private Pointer to PxeBc private data.
1027 @param[in] Config Pointer to config data.
1028 @param[in] Filename Pointer to boot file name.
1029 @param[in] BlockSize Pointer to required block size.
1030 @param[in] WindowSize Pointer to required window size.
1031 @param[in] BufferPtr Pointer to buffer.
1032 @param[in, out] BufferSize Pointer to buffer size.
1033 @param[in] DontUseBuffer Indicates whether to use a receive buffer.
1034
1035 @retval EFI_SUCCESS Successfully read the data from the special file.
1036 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
1037 @retval Others Read data from file failed.
1038
1039**/
1040EFI_STATUS
1041PxeBcTftpReadFile (
1042 IN PXEBC_PRIVATE_DATA *Private,
1043 IN VOID *Config,
1044 IN UINT8 *Filename,
1045 IN UINTN *BlockSize,
1046 IN UINTN *WindowSize,
1047 IN UINT8 *BufferPtr,
1048 IN OUT UINT64 *BufferSize,
1049 IN BOOLEAN DontUseBuffer
1050 )
1051{
1052 if (Private->PxeBc.Mode->UsingIpv6) {
1053 return PxeBcMtftp6ReadFile (
1054 Private,
1055 (EFI_MTFTP6_CONFIG_DATA *)Config,
1056 Filename,
1057 BlockSize,
1058 WindowSize,
1059 BufferPtr,
1060 BufferSize,
1061 DontUseBuffer
1062 );
1063 } else {
1064 return PxeBcMtftp4ReadFile (
1065 Private,
1066 (EFI_MTFTP4_CONFIG_DATA *)Config,
1067 Filename,
1068 BlockSize,
1069 WindowSize,
1070 BufferPtr,
1071 BufferSize,
1072 DontUseBuffer
1073 );
1074 }
1075}
1076
1077/**
1078 This function is a wrapper to write file using TFTP.
1079
1080 @param[in] Private Pointer to PxeBc private data.
1081 @param[in] Config Pointer to config data.
1082 @param[in] Filename Pointer to boot file name.
1083 @param[in] Overwrite Indicate whether with overwrite attribute.
1084 @param[in] BlockSize Pointer to required block size.
1085 @param[in] BufferPtr Pointer to buffer.
1086 @param[in, out] BufferSize Pointer to buffer size.
1087
1088 @retval EFI_SUCCESS Successfully wrote the data into a special file.
1089 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
1090 @retval other Write data into file failed.
1091
1092**/
1093EFI_STATUS
1094PxeBcTftpWriteFile (
1095 IN PXEBC_PRIVATE_DATA *Private,
1096 IN VOID *Config,
1097 IN UINT8 *Filename,
1098 IN BOOLEAN Overwrite,
1099 IN UINTN *BlockSize,
1100 IN UINT8 *BufferPtr,
1101 IN OUT UINT64 *BufferSize
1102 )
1103{
1104 if (Private->PxeBc.Mode->UsingIpv6) {
1105 return PxeBcMtftp6WriteFile (
1106 Private,
1107 (EFI_MTFTP6_CONFIG_DATA *)Config,
1108 Filename,
1109 Overwrite,
1110 BlockSize,
1111 BufferPtr,
1112 BufferSize
1113 );
1114 } else {
1115 return PxeBcMtftp4WriteFile (
1116 Private,
1117 (EFI_MTFTP4_CONFIG_DATA *)Config,
1118 Filename,
1119 Overwrite,
1120 BlockSize,
1121 BufferPtr,
1122 BufferSize
1123 );
1124 }
1125}
1126
1127/**
1128 This function is a wrapper to get the data (file) from a directory using TFTP.
1129
1130 @param[in] Private Pointer to PxeBc private data.
1131 @param[in] Config Pointer to config data.
1132 @param[in] Filename Pointer to boot file name.
1133 @param[in] BlockSize Pointer to required block size.
1134 @param[in] WindowSize Pointer to required window size.
1135 @param[in] BufferPtr Pointer to buffer.
1136 @param[in, out] BufferSize Pointer to buffer size.
1137 @param[in] DontUseBuffer Indicatse whether to use a receive buffer.
1138
1139 @retval EFI_SUCCESS Successfully obtained the data from the file included in the directory.
1140 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
1141 @retval Others Operation failed.
1142
1143**/
1144EFI_STATUS
1145PxeBcTftpReadDirectory (
1146 IN PXEBC_PRIVATE_DATA *Private,
1147 IN VOID *Config,
1148 IN UINT8 *Filename,
1149 IN UINTN *BlockSize,
1150 IN UINTN *WindowSize,
1151 IN UINT8 *BufferPtr,
1152 IN OUT UINT64 *BufferSize,
1153 IN BOOLEAN DontUseBuffer
1154 )
1155{
1156 if (Private->PxeBc.Mode->UsingIpv6) {
1157 return PxeBcMtftp6ReadDirectory (
1158 Private,
1159 (EFI_MTFTP6_CONFIG_DATA *)Config,
1160 Filename,
1161 BlockSize,
1162 WindowSize,
1163 BufferPtr,
1164 BufferSize,
1165 DontUseBuffer
1166 );
1167 } else {
1168 return PxeBcMtftp4ReadDirectory (
1169 Private,
1170 (EFI_MTFTP4_CONFIG_DATA *)Config,
1171 Filename,
1172 BlockSize,
1173 WindowSize,
1174 BufferPtr,
1175 BufferSize,
1176 DontUseBuffer
1177 );
1178 }
1179}
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