]> git.proxmox.com Git - mirror_edk2.git/blob - Nt32Pkg/WinNtSimpleFileSystemDxe/WinNtSimpleFileSystem.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
In this fix, WinNtSimpleFileSystemOpen only trims the leading and trailing blank...
[mirror_edk2.git] / Nt32Pkg / WinNtSimpleFileSystemDxe / WinNtSimpleFileSystem.c
1 /**@file
2
3 Copyright (c) 2006 - 2008, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
8
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11
12 Module Name:
13
14 WinNtSimpleFileSystem.c
15
16 Abstract:
17
18 Produce Simple File System abstractions for directories on your PC using Win32 APIs.
19 The configuration of what devices to mount or emulate comes from NT
20 environment variables. The variables must be visible to the Microsoft*
21 Developer Studio for them to work.
22
23 * Other names and brands may be claimed as the property of others.
24
25 **/
26
27 //
28 // The package level header files this module uses
29 //
30 #include <Uefi.h>
31 #include <WinNtDxe.h>
32 //
33 // The protocols, PPI and GUID defintions for this module
34 //
35 #include <Guid/FileSystemVolumeLabelInfo.h>
36 #include <Protocol/WinNtIo.h>
37 #include <Protocol/ComponentName.h>
38 #include <Guid/FileInfo.h>
39 #include <Protocol/DriverBinding.h>
40 #include <Guid/FileSystemInfo.h>
41 #include <Protocol/SimpleFileSystem.h>
42 //
43 // The Library classes this module consumes
44 //
45 #include <Library/DebugLib.h>
46 #include <Library/BaseLib.h>
47 #include <Library/UefiDriverEntryPoint.h>
48 #include <Library/UefiLib.h>
49 #include <Library/BaseMemoryLib.h>
50 #include <Library/UefiBootServicesTableLib.h>
51 #include <Library/MemoryAllocationLib.h>
52
53 #include "WinNtSimpleFileSystem.h"
54
55 EFI_DRIVER_BINDING_PROTOCOL gWinNtSimpleFileSystemDriverBinding = {
56 WinNtSimpleFileSystemDriverBindingSupported,
57 WinNtSimpleFileSystemDriverBindingStart,
58 WinNtSimpleFileSystemDriverBindingStop,
59 0xa,
60 NULL,
61 NULL
62 };
63
64 /**
65 The user Entry Point for module WinNtSimpleFileSystem. The user code starts with this function.
66
67 @param[in] ImageHandle The firmware allocated handle for the EFI image.
68 @param[in] SystemTable A pointer to the EFI System Table.
69
70 @retval EFI_SUCCESS The entry point is executed successfully.
71 @retval other Some error occurs when executing this entry point.
72
73 **/
74 EFI_STATUS
75 EFIAPI
76 InitializeWinNtSimpleFileSystem(
77 IN EFI_HANDLE ImageHandle,
78 IN EFI_SYSTEM_TABLE *SystemTable
79 )
80 {
81 EFI_STATUS Status;
82
83 //
84 // Install driver model protocol(s).
85 //
86 Status = EfiLibInstallDriverBindingComponentName2 (
87 ImageHandle,
88 SystemTable,
89 &gWinNtSimpleFileSystemDriverBinding,
90 ImageHandle,
91 &gWinNtSimpleFileSystemComponentName,
92 &gWinNtSimpleFileSystemComponentName2
93 );
94 ASSERT_EFI_ERROR (Status);
95
96
97 return Status;
98 }
99
100 CHAR16 *
101 EfiStrChr (
102 IN CHAR16 *Str,
103 IN CHAR16 Chr
104 )
105 /*++
106
107 Routine Description:
108
109 Locate the first occurance of a character in a string.
110
111 Arguments:
112
113 Str - Pointer to NULL terminated unicode string.
114 Chr - Character to locate.
115
116 Returns:
117
118 If Str is NULL, then NULL is returned.
119 If Chr is not contained in Str, then NULL is returned.
120 If Chr is contained in Str, then a pointer to the first occurance of Chr in Str is returned.
121
122 --*/
123 {
124 if (Str == NULL) {
125 return Str;
126 }
127
128 while (*Str != '\0' && *Str != Chr) {
129 ++Str;
130 }
131
132 return (*Str == Chr) ? Str : NULL;
133 }
134
135 BOOLEAN
136 IsZero (
137 IN VOID *Buffer,
138 IN UINTN Length
139 )
140 /*++
141
142 Routine Description:
143
144 TODO: Add function description
145
146 Arguments:
147
148 Buffer - TODO: add argument description
149 Length - TODO: add argument description
150
151 Returns:
152
153 TODO: add return values
154
155 --*/
156 {
157 if (Buffer == NULL || Length == 0) {
158 return FALSE;
159 }
160
161 if (*(UINT8 *) Buffer != 0) {
162 return FALSE;
163 }
164
165 if (Length > 1) {
166 if (!CompareMem (Buffer, (UINT8 *) Buffer + 1, Length - 1)) {
167 return FALSE;
168 }
169 }
170
171 return TRUE;
172 }
173
174 VOID
175 CutPrefix (
176 IN CHAR16 *Str,
177 IN UINTN Count
178 )
179 /*++
180
181 Routine Description:
182
183 TODO: Add function description
184
185 Arguments:
186
187 Str - TODO: add argument description
188 Count - TODO: add argument description
189
190 Returns:
191
192 TODO: add return values
193
194 --*/
195 {
196 CHAR16 *Pointer;
197
198 if (StrLen (Str) < Count) {
199 ASSERT (0);
200 }
201
202 if (Count != 0) {
203 for (Pointer = Str; *(Pointer + Count); Pointer++) {
204 *Pointer = *(Pointer + Count);
205 }
206 *Pointer = *(Pointer + Count);
207 }
208 }
209
210
211
212 EFI_STATUS
213 EFIAPI
214 WinNtSimpleFileSystemDriverBindingSupported (
215 IN EFI_DRIVER_BINDING_PROTOCOL *This,
216 IN EFI_HANDLE ControllerHandle,
217 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
218 )
219 /*++
220
221 Routine Description:
222
223 Check to see if the driver supports a given controller.
224
225 Arguments:
226
227 This - A pointer to an instance of the EFI_DRIVER_BINDING_PROTOCOL.
228
229 ControllerHandle - EFI handle of the controller to test.
230
231 RemainingDevicePath - Pointer to remaining portion of a device path.
232
233 Returns:
234
235 EFI_SUCCESS - The device specified by ControllerHandle and RemainingDevicePath is supported by the driver
236 specified by This.
237
238 EFI_ALREADY_STARTED - The device specified by ControllerHandle and RemainingDevicePath is already being managed by
239 the driver specified by This.
240
241 EFI_ACCESS_DENIED - The device specified by ControllerHandle and RemainingDevicePath is already being managed by
242 a different driver or an application that requires exclusive access.
243
244 EFI_UNSUPPORTED - The device specified by ControllerHandle and RemainingDevicePath is not supported by the
245 driver specified by This.
246
247 --*/
248 {
249 EFI_STATUS Status;
250 EFI_WIN_NT_IO_PROTOCOL *WinNtIo;
251
252 //
253 // Open the IO Abstraction(s) needed to perform the supported test
254 //
255 Status = gBS->OpenProtocol (
256 ControllerHandle,
257 &gEfiWinNtIoProtocolGuid,
258 &WinNtIo,
259 This->DriverBindingHandle,
260 ControllerHandle,
261 EFI_OPEN_PROTOCOL_BY_DRIVER
262 );
263 if (EFI_ERROR (Status)) {
264 return Status;
265 }
266
267 //
268 // Make sure GUID is for a File System handle.
269 //
270 Status = EFI_UNSUPPORTED;
271 if (CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtFileSystemGuid)) {
272 Status = EFI_SUCCESS;
273 }
274
275 //
276 // Close the I/O Abstraction(s) used to perform the supported test
277 //
278 gBS->CloseProtocol (
279 ControllerHandle,
280 &gEfiWinNtIoProtocolGuid,
281 This->DriverBindingHandle,
282 ControllerHandle
283 );
284
285 return Status;
286 }
287
288 EFI_STATUS
289 EFIAPI
290 WinNtSimpleFileSystemDriverBindingStart (
291 IN EFI_DRIVER_BINDING_PROTOCOL *This,
292 IN EFI_HANDLE ControllerHandle,
293 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
294 )
295 /*++
296
297 Routine Description:
298
299 Starts a device controller or a bus controller.
300
301 Arguments:
302
303 This - A pointer to an instance of the EFI_DRIVER_BINDING_PROTOCOL.
304
305 ControllerHandle - EFI handle of the controller to start.
306
307 RemainingDevicePath - Pointer to remaining portion of a device path.
308
309 Returns:
310
311 EFI_SUCCESS - The device or bus controller has been started.
312
313 EFI_DEVICE_ERROR - The device could not be started due to a device failure.
314
315 EFI_OUT_OF_RESOURCES - The request could not be completed due to lack of resources.
316
317 --*/
318 {
319 EFI_STATUS Status;
320 EFI_WIN_NT_IO_PROTOCOL *WinNtIo;
321 WIN_NT_SIMPLE_FILE_SYSTEM_PRIVATE *Private;
322
323 Private = NULL;
324
325 //
326 // Open the IO Abstraction(s) needed
327 //
328 Status = gBS->OpenProtocol (
329 ControllerHandle,
330 &gEfiWinNtIoProtocolGuid,
331 &WinNtIo,
332 This->DriverBindingHandle,
333 ControllerHandle,
334 EFI_OPEN_PROTOCOL_BY_DRIVER
335 );
336 if (EFI_ERROR (Status)) {
337 return Status;
338 }
339
340 //
341 // Validate GUID
342 //
343 if (!CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtFileSystemGuid)) {
344 Status = EFI_UNSUPPORTED;
345 goto Done;
346 }
347
348 Private = AllocatePool (sizeof (WIN_NT_SIMPLE_FILE_SYSTEM_PRIVATE));
349 if (Private == NULL) {
350 Status = EFI_OUT_OF_RESOURCES;
351
352 goto Done;
353 }
354
355 Private->Signature = WIN_NT_SIMPLE_FILE_SYSTEM_PRIVATE_SIGNATURE;
356 Private->WinNtThunk = WinNtIo->WinNtThunk;
357
358 Private->FilePath = WinNtIo->EnvString;
359
360 Private->VolumeLabel = AllocatePool (StrSize (L"EFI_EMULATED"));
361 if (Private->VolumeLabel == NULL) {
362 Status = EFI_OUT_OF_RESOURCES;
363 goto Done;
364 }
365
366 StrCpy (Private->VolumeLabel, L"EFI_EMULATED");
367
368 Private->SimpleFileSystem.Revision = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION;
369 Private->SimpleFileSystem.OpenVolume = WinNtSimpleFileSystemOpenVolume;
370
371 Private->WinNtThunk->SetErrorMode (SEM_FAILCRITICALERRORS);
372
373 Private->ControllerNameTable = NULL;
374
375 AddUnicodeString2 (
376 "eng",
377 gWinNtSimpleFileSystemComponentName.SupportedLanguages,
378 &Private->ControllerNameTable,
379 WinNtIo->EnvString,
380 TRUE
381 );
382 AddUnicodeString2 (
383 "en",
384 gWinNtSimpleFileSystemComponentName2.SupportedLanguages,
385 &Private->ControllerNameTable,
386 WinNtIo->EnvString,
387 FALSE
388 );
389
390
391 Status = gBS->InstallMultipleProtocolInterfaces (
392 &ControllerHandle,
393 &gEfiSimpleFileSystemProtocolGuid,
394 &Private->SimpleFileSystem,
395 NULL
396 );
397
398 Done:
399 if (EFI_ERROR (Status)) {
400
401 if (Private != NULL) {
402
403 FreeUnicodeStringTable (Private->ControllerNameTable);
404
405 FreePool (Private);
406 }
407
408 gBS->CloseProtocol (
409 ControllerHandle,
410 &gEfiWinNtIoProtocolGuid,
411 This->DriverBindingHandle,
412 ControllerHandle
413 );
414 }
415
416 return Status;
417 }
418
419 EFI_STATUS
420 EFIAPI
421 WinNtSimpleFileSystemDriverBindingStop (
422 IN EFI_DRIVER_BINDING_PROTOCOL *This,
423 IN EFI_HANDLE ControllerHandle,
424 IN UINTN NumberOfChildren,
425 IN EFI_HANDLE *ChildHandleBuffer
426 )
427 /*++
428
429 Routine Description:
430
431 TODO: Add function description
432
433 Arguments:
434
435 This - A pointer to an instance of the EFI_DRIVER_BINDING_PROTOCOL.
436
437 ControllerHandle - A handle to the device to be stopped.
438
439 NumberOfChildren - The number of child device handles in ChildHandleBuffer.
440
441 ChildHandleBuffer - An array of child device handles to be freed.
442
443 Returns:
444
445 EFI_SUCCESS - The device has been stopped.
446
447 EFI_DEVICE_ERROR - The device could not be stopped due to a device failure.
448
449 --*/
450 // TODO: EFI_UNSUPPORTED - add return value to function comment
451 {
452 EFI_STATUS Status;
453 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *SimpleFileSystem;
454 WIN_NT_SIMPLE_FILE_SYSTEM_PRIVATE *Private;
455
456 //
457 // Get our context back
458 //
459 Status = gBS->OpenProtocol (
460 ControllerHandle,
461 &gEfiSimpleFileSystemProtocolGuid,
462 &SimpleFileSystem,
463 This->DriverBindingHandle,
464 ControllerHandle,
465 EFI_OPEN_PROTOCOL_GET_PROTOCOL
466 );
467 if (EFI_ERROR (Status)) {
468 return EFI_UNSUPPORTED;
469 }
470
471 Private = WIN_NT_SIMPLE_FILE_SYSTEM_PRIVATE_DATA_FROM_THIS (SimpleFileSystem);
472
473 //
474 // Uninstall the Simple File System Protocol from ControllerHandle
475 //
476 Status = gBS->UninstallMultipleProtocolInterfaces (
477 ControllerHandle,
478 &gEfiSimpleFileSystemProtocolGuid,
479 &Private->SimpleFileSystem,
480 NULL
481 );
482 if (!EFI_ERROR (Status)) {
483 Status = gBS->CloseProtocol (
484 ControllerHandle,
485 &gEfiWinNtIoProtocolGuid,
486 This->DriverBindingHandle,
487 ControllerHandle
488 );
489 }
490
491 if (!EFI_ERROR (Status)) {
492 //
493 // Free our instance data
494 //
495 FreeUnicodeStringTable (Private->ControllerNameTable);
496
497 FreePool (Private);
498 }
499
500 return Status;
501 }
502
503 EFI_STATUS
504 EFIAPI
505 WinNtSimpleFileSystemOpenVolume (
506 IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
507 OUT EFI_FILE **Root
508 )
509 /*++
510
511 Routine Description:
512
513 Open the root directory on a volume.
514
515 Arguments:
516
517 This - A pointer to the volume to open.
518
519 Root - A pointer to storage for the returned opened file handle of the root directory.
520
521 Returns:
522
523 EFI_SUCCESS - The volume was opened.
524
525 EFI_UNSUPPORTED - The volume does not support the requested file system type.
526
527 EFI_NO_MEDIA - The device has no media.
528
529 EFI_DEVICE_ERROR - The device reported an error.
530
531 EFI_VOLUME_CORRUPTED - The file system structures are corrupted.
532
533 EFI_ACCESS_DENIED - The service denied access to the file.
534
535 EFI_OUT_OF_RESOURCES - The file volume could not be opened due to lack of resources.
536
537 EFI_MEDIA_CHANGED - The device has new media or the media is no longer supported.
538
539 --*/
540 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
541 {
542 EFI_STATUS Status;
543 WIN_NT_SIMPLE_FILE_SYSTEM_PRIVATE *Private;
544 WIN_NT_EFI_FILE_PRIVATE *PrivateFile;
545 EFI_TPL OldTpl;
546
547 if (This == NULL || Root == NULL) {
548 return EFI_INVALID_PARAMETER;
549 }
550
551 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
552
553 Private = WIN_NT_SIMPLE_FILE_SYSTEM_PRIVATE_DATA_FROM_THIS (This);
554
555 PrivateFile = AllocatePool (sizeof (WIN_NT_EFI_FILE_PRIVATE));
556 if (PrivateFile == NULL) {
557 Status = EFI_OUT_OF_RESOURCES;
558 goto Done;
559 }
560
561 PrivateFile->FileName = AllocatePool (StrSize (Private->FilePath));
562 if (PrivateFile->FileName == NULL) {
563 Status = EFI_OUT_OF_RESOURCES;
564 goto Done;
565 }
566
567 PrivateFile->FilePath = AllocatePool (StrSize (Private->FilePath));
568 if (PrivateFile->FilePath == NULL) {
569 Status = EFI_OUT_OF_RESOURCES;
570 goto Done;
571 }
572
573 StrCpy (PrivateFile->FilePath, Private->FilePath);
574 StrCpy (PrivateFile->FileName, PrivateFile->FilePath);
575 PrivateFile->Signature = WIN_NT_EFI_FILE_PRIVATE_SIGNATURE;
576 PrivateFile->WinNtThunk = Private->WinNtThunk;
577 PrivateFile->SimpleFileSystem = This;
578 PrivateFile->IsRootDirectory = TRUE;
579 PrivateFile->IsDirectoryPath = TRUE;
580 PrivateFile->IsOpenedByRead = TRUE;
581 PrivateFile->EfiFile.Revision = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION;
582 PrivateFile->EfiFile.Open = WinNtSimpleFileSystemOpen;
583 PrivateFile->EfiFile.Close = WinNtSimpleFileSystemClose;
584 PrivateFile->EfiFile.Delete = WinNtSimpleFileSystemDelete;
585 PrivateFile->EfiFile.Read = WinNtSimpleFileSystemRead;
586 PrivateFile->EfiFile.Write = WinNtSimpleFileSystemWrite;
587 PrivateFile->EfiFile.GetPosition = WinNtSimpleFileSystemGetPosition;
588 PrivateFile->EfiFile.SetPosition = WinNtSimpleFileSystemSetPosition;
589 PrivateFile->EfiFile.GetInfo = WinNtSimpleFileSystemGetInfo;
590 PrivateFile->EfiFile.SetInfo = WinNtSimpleFileSystemSetInfo;
591 PrivateFile->EfiFile.Flush = WinNtSimpleFileSystemFlush;
592 PrivateFile->LHandle = INVALID_HANDLE_VALUE;
593 PrivateFile->DirHandle = INVALID_HANDLE_VALUE;
594 PrivateFile->IsValidFindBuf = FALSE;
595
596 *Root = &PrivateFile->EfiFile;
597
598 Status = EFI_SUCCESS;
599
600 Done:
601 if (EFI_ERROR (Status)) {
602 if (PrivateFile) {
603 if (PrivateFile->FileName) {
604 FreePool (PrivateFile->FileName);
605 }
606
607 if (PrivateFile->FilePath) {
608 FreePool (PrivateFile->FilePath);
609 }
610
611 FreePool (PrivateFile);
612 }
613 }
614
615 gBS->RestoreTPL (OldTpl);
616
617 return Status;
618 }
619
620 /**
621 Count the number of Leading Dot in FileNameToken.
622
623 @param FileNameToken A string representing a token in the path name.
624
625 @return UINTN The number of leading dot in the name.
626
627 **/
628 UINTN
629 CountLeadingDots (
630 IN CONST CHAR16 * FileNameToken
631 )
632 {
633 UINTN Num;
634
635 Num = 0;
636 while (*FileNameToken == L'.') {
637 Num++;
638 FileNameToken++;
639 }
640
641 return Num;
642 }
643
644 BOOLEAN
645 IsFileNameTokenValid (
646 IN CONST CHAR16 * FileNameToken
647 )
648 {
649 UINTN Num;
650 if (StrStr (FileNameToken, L"/") != NULL) {
651 //
652 // No L'/' in file name.
653 //
654 return FALSE;
655 } else {
656 //
657 // If Token has all dot, the number should not exceed 2
658 //
659 Num = CountLeadingDots (FileNameToken);
660
661 if (Num == StrLen (FileNameToken)) {
662 //
663 // If the FileNameToken only contains a number of L'.'.
664 //
665 if (Num > 2) {
666 return FALSE;
667 }
668 }
669 }
670
671 return TRUE;
672 }
673
674 /**
675 Return the first string token found in the indirect pointer a String named by FileName.
676
677 On input, FileName is a indirect pointer pointing to a String.
678 On output, FileName is a updated to point to the next character after the first
679 found L"\" or NULL if there is no L"\" found.
680
681 @param FileName A indirect pointer pointing to a FileName.
682
683 @return Token The first string token found before a L"\".
684
685 **/
686 CHAR16 *
687 GetNextFileNameToken (
688 IN OUT CONST CHAR16 ** FileName
689 )
690 {
691 CHAR16 *SlashPos;
692 CHAR16 *Token;
693 UINTN Offset;
694 ASSERT (**FileName != L'\\');
695 ASSERT (**FileName != L'\0');
696
697 SlashPos = StrStr (*FileName, L"\\");
698 if (SlashPos == NULL) {
699 Token = AllocateCopyPool (StrSize(*FileName), *FileName);
700 *FileName = NULL;
701 } else {
702 Offset = SlashPos - *FileName;
703 Token = AllocateZeroPool ((Offset + 1) * sizeof (CHAR16));
704 StrnCpy (Token, *FileName, Offset);
705 //
706 // Point *FileName to the next character after L'\'.
707 //
708 *FileName = *FileName + Offset + 1;
709 }
710
711 return Token;
712 }
713
714 /**
715 Check if a FileName contains only Valid Characters.
716
717 If FileName contains only a single L'\', return TRUE.
718 If FileName contains two adjacent L'\', return FALSE.
719 If FileName conatins L'/' , return FALSE.
720 If FielName contains more than two dots seperated with other FileName characters
721 by L'\', return FALSE. For example, L'.\...\filename.txt' is invalid path name. But L'..TwoDots\filename.txt' is valid path name.
722
723 @param FileName The File Name String to check.
724
725 @return TRUE FileName only contains valid characters.
726 @return FALSE FileName contains at least one invalid character.
727
728 **/
729
730 BOOLEAN
731 IsFileNameValid (
732 IN CONST CHAR16 *FileName
733 )
734 {
735 CHAR16 *Token;
736 BOOLEAN Valid;
737
738 //
739 // If FileName is just L'\', then it is a valid pathname.
740 //
741 if (StrCmp (FileName, L"\\") == 0) {
742 return TRUE;
743 }
744 //
745 // We don't support two or more adjacent L'\'.
746 //
747 if (StrStr (FileName, L"\\\\") != NULL) {
748 return FALSE;
749 }
750
751 //
752 // Is FileName has a leading L"\", skip to next character.
753 //
754 if (FileName [0] == L'\\') {
755 FileName++;
756 }
757
758 do {
759 Token = GetNextFileNameToken (&FileName);
760 Valid = IsFileNameTokenValid (Token);
761 FreePool (Token);
762
763 if (!Valid)
764 return FALSE;
765 } while (FileName != NULL);
766
767 return TRUE;
768 }
769
770 EFI_STATUS
771 EFIAPI
772 WinNtSimpleFileSystemOpen (
773 IN EFI_FILE *This,
774 OUT EFI_FILE **NewHandle,
775 IN CHAR16 *FileName,
776 IN UINT64 OpenMode,
777 IN UINT64 Attributes
778 )
779 /*++
780
781 Routine Description:
782
783 Open a file relative to the source file location.
784
785 Arguments:
786
787 This - A pointer to the seource file location.
788
789 NewHandle - Pointer to storage for the new file handle.
790
791 FileName - Pointer to the file name to be opened.
792
793 OpenMode - File open mode information.
794
795 Attributes - File creation attributes.
796
797 Returns:
798
799 EFI_SUCCESS - The file was opened.
800
801 EFI_NOT_FOUND - The file could not be found in the volume.
802
803 EFI_NO_MEDIA - The device has no media.
804
805 EFI_MEDIA_CHANGED - The device has new media or the media is no longer supported.
806
807 EFI_DEVICE_ERROR - The device reported an error.
808
809 EFI_VOLUME_CORRUPTED - The file system structures are corrupted.
810
811 EFI_WRITE_PROTECTED - The volume or file is write protected.
812
813 EFI_ACCESS_DENIED - The service denied access to the file.
814
815 EFI_OUT_OF_RESOURCES - Not enough resources were available to open the file.
816
817 EFI_VOLUME_FULL - There is not enough space left to create the new file.
818
819 --*/
820 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
821 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
822 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
823 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
824 {
825 EFI_FILE *Root;
826 WIN_NT_EFI_FILE_PRIVATE *PrivateFile;
827 WIN_NT_EFI_FILE_PRIVATE *NewPrivateFile;
828 WIN_NT_SIMPLE_FILE_SYSTEM_PRIVATE *PrivateRoot;
829 EFI_STATUS Status;
830 CHAR16 *RealFileName;
831 CHAR16 *TempFileName;
832 CHAR16 *ParseFileName;
833 CHAR16 *GuardPointer;
834 CHAR16 TempChar;
835 DWORD LastError;
836 UINTN Count;
837 BOOLEAN LoopFinish;
838 UINTN InfoSize;
839 EFI_FILE_INFO *Info;
840
841 //
842 // Check for obvious invalid parameters.
843 //
844 if (This == NULL || NewHandle == NULL || FileName == NULL) {
845 return EFI_INVALID_PARAMETER;
846 }
847
848 switch (OpenMode) {
849 case EFI_FILE_MODE_CREATE | EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE:
850 if (Attributes &~EFI_FILE_VALID_ATTR) {
851 return EFI_INVALID_PARAMETER;
852 }
853
854 if (Attributes & EFI_FILE_READ_ONLY) {
855 return EFI_INVALID_PARAMETER;
856 }
857
858 //
859 // fall through
860 //
861 case EFI_FILE_MODE_READ:
862 case EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE:
863 break;
864
865 default:
866 return EFI_INVALID_PARAMETER;
867 }
868
869 //
870 // Init local variables
871 //
872 PrivateFile = WIN_NT_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
873 PrivateRoot = WIN_NT_SIMPLE_FILE_SYSTEM_PRIVATE_DATA_FROM_THIS (PrivateFile->SimpleFileSystem);
874 NewPrivateFile = NULL;
875
876 //
877 // Allocate buffer for FileName as the passed in FileName may be read only
878 //
879 TempFileName = AllocatePool (StrSize (FileName));
880 if (TempFileName == NULL) {
881 return EFI_OUT_OF_RESOURCES;
882 }
883 StrCpy (TempFileName, FileName);
884 FileName = TempFileName;
885
886 //
887 // BUGBUG: assume an open of root
888 // if current location, return current data
889 //
890 if (StrCmp (FileName, L"\\") == 0 || (StrCmp (FileName, L".") == 0 && PrivateFile->IsRootDirectory)) {
891 //
892 // BUGBUG: assume an open root
893 //
894 OpenRoot:
895 Status = WinNtSimpleFileSystemOpenVolume (PrivateFile->SimpleFileSystem, &Root);
896 NewPrivateFile = WIN_NT_EFI_FILE_PRIVATE_DATA_FROM_THIS (Root);
897 goto Done;
898 }
899
900 if (FileName[StrLen (FileName) - 1] == L'\\') {
901 FileName[StrLen (FileName) - 1] = 0;
902 }
903
904 //
905 // If file name does not equal to "." or "..",
906 // then we trim the leading/trailing blanks and trailing dots
907 //
908 if (StrCmp (FileName, L".") != 0 && StrCmp (FileName, L"..") != 0) {
909 //
910 // Trim leading blanks
911 //
912 Count = 0;
913 for (TempFileName = FileName;
914 *TempFileName != 0 && *TempFileName == L' ';
915 TempFileName++) {
916 Count++;
917 }
918 CutPrefix (FileName, Count);
919 //
920 // Trim trailing blanks
921 //
922 for (TempFileName = FileName + StrLen (FileName) - 1;
923 TempFileName >= FileName && (*TempFileName == L' ');
924 TempFileName--) {
925 ;
926 }
927 *(TempFileName + 1) = 0;
928 }
929
930 //
931 // Attempt to open the file
932 //
933 NewPrivateFile = AllocatePool (sizeof (WIN_NT_EFI_FILE_PRIVATE));
934 if (NewPrivateFile == NULL) {
935 Status = EFI_OUT_OF_RESOURCES;
936 goto Done;
937 }
938
939 CopyMem (NewPrivateFile, PrivateFile, sizeof (WIN_NT_EFI_FILE_PRIVATE));
940
941 NewPrivateFile->FilePath = AllocatePool (StrSize (PrivateFile->FileName));
942 if (NewPrivateFile->FilePath == NULL) {
943 Status = EFI_OUT_OF_RESOURCES;
944 goto Done;
945 }
946
947 if (PrivateFile->IsDirectoryPath) {
948 StrCpy (NewPrivateFile->FilePath, PrivateFile->FileName);
949 } else {
950 StrCpy (NewPrivateFile->FilePath, PrivateFile->FilePath);
951 }
952
953 NewPrivateFile->FileName = AllocatePool (StrSize (NewPrivateFile->FilePath) + StrSize (L"\\") + StrSize (FileName));
954 if (NewPrivateFile->FileName == NULL) {
955 Status = EFI_OUT_OF_RESOURCES;
956 goto Done;
957 }
958
959 if (*FileName == L'\\') {
960 StrCpy (NewPrivateFile->FileName, PrivateRoot->FilePath);
961 StrCat (NewPrivateFile->FileName, L"\\");
962 StrCat (NewPrivateFile->FileName, FileName + 1);
963 } else {
964 StrCpy (NewPrivateFile->FileName, NewPrivateFile->FilePath);
965 if (StrCmp (FileName, L"") != 0) {
966 //
967 // In case the filename becomes empty, especially after trimming dots and blanks
968 //
969 StrCat (NewPrivateFile->FileName, L"\\");
970 StrCat (NewPrivateFile->FileName, FileName);
971 }
972 }
973
974 if (!IsFileNameValid (NewPrivateFile->FileName)) {
975 Status = EFI_NOT_FOUND;
976 goto Done;
977 }
978
979 //
980 // Get rid of . and .., except leading . or ..
981 //
982
983 //
984 // GuardPointer protect simplefilesystem root path not be destroyed
985 //
986 GuardPointer = NewPrivateFile->FileName + StrLen (PrivateRoot->FilePath);
987
988 LoopFinish = FALSE;
989
990 while (!LoopFinish) {
991
992 LoopFinish = TRUE;
993
994 for (ParseFileName = GuardPointer; *ParseFileName; ParseFileName++) {
995 if (*ParseFileName == L'.' &&
996 (*(ParseFileName + 1) == 0 || *(ParseFileName + 1) == L'\\') &&
997 *(ParseFileName - 1) == L'\\'
998 ) {
999
1000 //
1001 // cut \.
1002 //
1003 CutPrefix (ParseFileName - 1, 2);
1004 LoopFinish = FALSE;
1005 break;
1006 }
1007
1008 if (*ParseFileName == L'.' &&
1009 *(ParseFileName + 1) == L'.' &&
1010 (*(ParseFileName + 2) == 0 || *(ParseFileName + 2) == L'\\') &&
1011 *(ParseFileName - 1) == L'\\'
1012 ) {
1013
1014 ParseFileName--;
1015 Count = 3;
1016
1017 while (ParseFileName != GuardPointer) {
1018 ParseFileName--;
1019 Count++;
1020 if (*ParseFileName == L'\\') {
1021 break;
1022 }
1023 }
1024
1025 //
1026 // cut \.. and its left directory
1027 //
1028 CutPrefix (ParseFileName, Count);
1029 LoopFinish = FALSE;
1030 break;
1031 }
1032 }
1033 }
1034
1035 if (StrCmp (NewPrivateFile->FileName, PrivateRoot->FilePath) == 0) {
1036 NewPrivateFile->IsRootDirectory = TRUE;
1037 FreePool (NewPrivateFile->FilePath);
1038 FreePool (NewPrivateFile->FileName);
1039 FreePool (NewPrivateFile);
1040 goto OpenRoot;
1041 }
1042
1043 RealFileName = NewPrivateFile->FileName;
1044 while (EfiStrChr (RealFileName, L'\\') != NULL) {
1045 RealFileName = EfiStrChr (RealFileName, L'\\') + 1;
1046 }
1047
1048 TempChar = *(RealFileName - 1);
1049 *(RealFileName - 1) = 0;
1050
1051 FreePool (NewPrivateFile->FilePath);
1052 NewPrivateFile->FilePath = NULL;
1053 NewPrivateFile->FilePath = AllocatePool (StrSize (NewPrivateFile->FileName));
1054 if (NewPrivateFile->FilePath == NULL) {
1055 Status = EFI_OUT_OF_RESOURCES;
1056 goto Done;
1057 }
1058
1059 StrCpy (NewPrivateFile->FilePath, NewPrivateFile->FileName);
1060
1061 *(RealFileName - 1) = TempChar;
1062
1063 NewPrivateFile->IsRootDirectory = FALSE;
1064
1065 //
1066 // Test whether file or directory
1067 //
1068 if (OpenMode & EFI_FILE_MODE_CREATE) {
1069 if (Attributes & EFI_FILE_DIRECTORY) {
1070 NewPrivateFile->IsDirectoryPath = TRUE;
1071 } else {
1072 NewPrivateFile->IsDirectoryPath = FALSE;
1073 }
1074 } else {
1075 NewPrivateFile->LHandle = INVALID_HANDLE_VALUE;
1076 NewPrivateFile->LHandle = NewPrivateFile->WinNtThunk->CreateFile (
1077 NewPrivateFile->FileName,
1078 GENERIC_READ,
1079 FILE_SHARE_READ | FILE_SHARE_WRITE,
1080 NULL,
1081 OPEN_EXISTING,
1082 0,
1083 NULL
1084 );
1085
1086 if (NewPrivateFile->LHandle != INVALID_HANDLE_VALUE) {
1087 NewPrivateFile->IsDirectoryPath = FALSE;
1088 NewPrivateFile->WinNtThunk->CloseHandle (NewPrivateFile->LHandle);
1089 } else {
1090 NewPrivateFile->IsDirectoryPath = TRUE;
1091 }
1092
1093 NewPrivateFile->LHandle = INVALID_HANDLE_VALUE;
1094 }
1095
1096 if (OpenMode & EFI_FILE_MODE_WRITE) {
1097 NewPrivateFile->IsOpenedByRead = FALSE;
1098 } else {
1099 NewPrivateFile->IsOpenedByRead = TRUE;
1100 }
1101
1102 Status = EFI_SUCCESS;
1103
1104 //
1105 // deal with directory
1106 //
1107 if (NewPrivateFile->IsDirectoryPath) {
1108
1109 TempFileName = AllocatePool (StrSize (NewPrivateFile->FileName) + StrSize (L"\\*"));
1110 if (TempFileName == NULL) {
1111 Status = EFI_OUT_OF_RESOURCES;
1112 goto Done;
1113 }
1114
1115 StrCpy (TempFileName, NewPrivateFile->FileName);
1116
1117 if ((OpenMode & EFI_FILE_MODE_CREATE)) {
1118 //
1119 // Create a directory
1120 //
1121 if (!NewPrivateFile->WinNtThunk->CreateDirectory (TempFileName, NULL)) {
1122
1123 LastError = PrivateFile->WinNtThunk->GetLastError ();
1124 if (LastError != ERROR_ALREADY_EXISTS) {
1125 FreePool (TempFileName);
1126 Status = EFI_ACCESS_DENIED;
1127 goto Done;
1128 }
1129 }
1130 }
1131
1132 NewPrivateFile->DirHandle = NewPrivateFile->WinNtThunk->CreateFile (
1133 TempFileName,
1134 NewPrivateFile->IsOpenedByRead ? GENERIC_READ : (GENERIC_READ | GENERIC_WRITE),
1135 FILE_SHARE_READ | FILE_SHARE_WRITE,
1136 NULL,
1137 OPEN_EXISTING,
1138 FILE_FLAG_BACKUP_SEMANTICS,
1139 NULL
1140 );
1141
1142 if (NewPrivateFile->DirHandle == INVALID_HANDLE_VALUE) {
1143
1144 NewPrivateFile->DirHandle = NewPrivateFile->WinNtThunk->CreateFile (
1145 TempFileName,
1146 GENERIC_READ,
1147 FILE_SHARE_READ | FILE_SHARE_WRITE,
1148 NULL,
1149 OPEN_EXISTING,
1150 FILE_FLAG_BACKUP_SEMANTICS,
1151 NULL
1152 );
1153
1154 if (NewPrivateFile->DirHandle != INVALID_HANDLE_VALUE) {
1155 NewPrivateFile->WinNtThunk->CloseHandle (NewPrivateFile->DirHandle);
1156 NewPrivateFile->DirHandle = INVALID_HANDLE_VALUE;
1157 Status = EFI_ACCESS_DENIED;
1158 } else {
1159 Status = EFI_NOT_FOUND;
1160 }
1161
1162 goto Done;
1163 }
1164
1165 //
1166 // Find the first file under it
1167 //
1168 StrCat (TempFileName, L"\\*");
1169 NewPrivateFile->LHandle = NewPrivateFile->WinNtThunk->FindFirstFile (TempFileName, &NewPrivateFile->FindBuf);
1170
1171 if (NewPrivateFile->LHandle == INVALID_HANDLE_VALUE) {
1172 NewPrivateFile->IsValidFindBuf = FALSE;
1173 } else {
1174 NewPrivateFile->IsValidFindBuf = TRUE;
1175 }
1176 } else {
1177 //
1178 // deal with file
1179 //
1180 if (!NewPrivateFile->IsOpenedByRead) {
1181 NewPrivateFile->LHandle = NewPrivateFile->WinNtThunk->CreateFile (
1182 NewPrivateFile->FileName,
1183 GENERIC_READ | GENERIC_WRITE,
1184 FILE_SHARE_READ | FILE_SHARE_WRITE,
1185 NULL,
1186 (OpenMode & EFI_FILE_MODE_CREATE) ? OPEN_ALWAYS : OPEN_EXISTING,
1187 0,
1188 NULL
1189 );
1190
1191 if (NewPrivateFile->LHandle == INVALID_HANDLE_VALUE) {
1192 NewPrivateFile->LHandle = NewPrivateFile->WinNtThunk->CreateFile (
1193 NewPrivateFile->FileName,
1194 GENERIC_READ,
1195 FILE_SHARE_READ | FILE_SHARE_WRITE,
1196 NULL,
1197 OPEN_EXISTING,
1198 0,
1199 NULL
1200 );
1201
1202 if (NewPrivateFile->LHandle == INVALID_HANDLE_VALUE) {
1203 Status = EFI_NOT_FOUND;
1204 } else {
1205 Status = EFI_ACCESS_DENIED;
1206 NewPrivateFile->WinNtThunk->CloseHandle (NewPrivateFile->LHandle);
1207 NewPrivateFile->LHandle = INVALID_HANDLE_VALUE;
1208 }
1209 }
1210 } else {
1211 NewPrivateFile->LHandle = NewPrivateFile->WinNtThunk->CreateFile (
1212 NewPrivateFile->FileName,
1213 GENERIC_READ,
1214 FILE_SHARE_READ | FILE_SHARE_WRITE,
1215 NULL,
1216 OPEN_EXISTING,
1217 0,
1218 NULL
1219 );
1220
1221 if (NewPrivateFile->LHandle == INVALID_HANDLE_VALUE) {
1222 Status = EFI_NOT_FOUND;
1223 }
1224 }
1225 }
1226
1227 if ((OpenMode & EFI_FILE_MODE_CREATE) && Status == EFI_SUCCESS) {
1228 //
1229 // Set the attribute
1230 //
1231 InfoSize = 0;
1232 Info = NULL;
1233
1234 Status = WinNtSimpleFileSystemGetInfo (&NewPrivateFile->EfiFile, &gEfiFileInfoGuid, &InfoSize, Info);
1235
1236 if (Status != EFI_BUFFER_TOO_SMALL) {
1237 Status = EFI_DEVICE_ERROR;
1238 goto Done;
1239 }
1240
1241 Info = AllocatePool (InfoSize);
1242 if (Info == NULL) {
1243 Status = EFI_OUT_OF_RESOURCES;
1244 goto Done;
1245 }
1246
1247 Status = WinNtSimpleFileSystemGetInfo (&NewPrivateFile->EfiFile, &gEfiFileInfoGuid, &InfoSize, Info);
1248
1249 if (EFI_ERROR (Status)) {
1250 goto Done;
1251 }
1252
1253 Info->Attribute = Attributes;
1254
1255 WinNtSimpleFileSystemSetInfo (&NewPrivateFile->EfiFile, &gEfiFileInfoGuid, InfoSize, Info);
1256 }
1257
1258 Done: ;
1259 FreePool (FileName);
1260
1261 if (EFI_ERROR (Status)) {
1262 if (NewPrivateFile) {
1263 if (NewPrivateFile->FileName) {
1264 FreePool (NewPrivateFile->FileName);
1265 }
1266
1267 if (NewPrivateFile->FilePath) {
1268 FreePool (NewPrivateFile->FilePath);
1269 }
1270
1271 FreePool (NewPrivateFile);
1272 }
1273 } else {
1274 *NewHandle = &NewPrivateFile->EfiFile;
1275 }
1276
1277 return Status;
1278 }
1279
1280 EFI_STATUS
1281 EFIAPI
1282 WinNtSimpleFileSystemClose (
1283 IN EFI_FILE *This
1284 )
1285 /*++
1286
1287 Routine Description:
1288
1289 Close the specified file handle.
1290
1291 Arguments:
1292
1293 This - Pointer to a returned opened file handle.
1294
1295 Returns:
1296
1297 EFI_SUCCESS - The file handle has been closed.
1298
1299 --*/
1300 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
1301 {
1302 WIN_NT_EFI_FILE_PRIVATE *PrivateFile;
1303 EFI_TPL OldTpl;
1304
1305 if (This == NULL) {
1306 return EFI_INVALID_PARAMETER;
1307 }
1308
1309 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1310
1311 PrivateFile = WIN_NT_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
1312
1313 if (PrivateFile->LHandle != INVALID_HANDLE_VALUE) {
1314 if (PrivateFile->IsDirectoryPath) {
1315 PrivateFile->WinNtThunk->FindClose (PrivateFile->LHandle);
1316 } else {
1317 PrivateFile->WinNtThunk->CloseHandle (PrivateFile->LHandle);
1318 }
1319
1320 PrivateFile->LHandle = INVALID_HANDLE_VALUE;
1321 }
1322
1323 if (PrivateFile->IsDirectoryPath && PrivateFile->DirHandle != INVALID_HANDLE_VALUE) {
1324 PrivateFile->WinNtThunk->CloseHandle (PrivateFile->DirHandle);
1325 PrivateFile->DirHandle = INVALID_HANDLE_VALUE;
1326 }
1327
1328 if (PrivateFile->FileName) {
1329 FreePool (PrivateFile->FileName);
1330 }
1331
1332 FreePool (PrivateFile);
1333
1334 gBS->RestoreTPL (OldTpl);
1335
1336 return EFI_SUCCESS;
1337 }
1338
1339 EFI_STATUS
1340 EFIAPI
1341 WinNtSimpleFileSystemDelete (
1342 IN EFI_FILE *This
1343 )
1344 /*++
1345
1346 Routine Description:
1347
1348 Close and delete a file.
1349
1350 Arguments:
1351
1352 This - Pointer to a returned opened file handle.
1353
1354 Returns:
1355
1356 EFI_SUCCESS - The file handle was closed and deleted.
1357
1358 EFI_WARN_DELETE_FAILURE - The handle was closed but could not be deleted.
1359
1360 --*/
1361 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
1362 {
1363 EFI_STATUS Status;
1364 WIN_NT_EFI_FILE_PRIVATE *PrivateFile;
1365 EFI_TPL OldTpl;
1366
1367 if (This == NULL) {
1368 return EFI_INVALID_PARAMETER;
1369 }
1370
1371 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1372
1373 PrivateFile = WIN_NT_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
1374
1375 Status = EFI_WARN_DELETE_FAILURE;
1376
1377 if (PrivateFile->IsDirectoryPath) {
1378 if (PrivateFile->LHandle != INVALID_HANDLE_VALUE) {
1379 PrivateFile->WinNtThunk->FindClose (PrivateFile->LHandle);
1380 }
1381
1382 if (PrivateFile->DirHandle != INVALID_HANDLE_VALUE) {
1383 PrivateFile->WinNtThunk->CloseHandle (PrivateFile->DirHandle);
1384 PrivateFile->DirHandle = INVALID_HANDLE_VALUE;
1385 }
1386
1387 if (PrivateFile->WinNtThunk->RemoveDirectory (PrivateFile->FileName)) {
1388 Status = EFI_SUCCESS;
1389 }
1390 } else {
1391 PrivateFile->WinNtThunk->CloseHandle (PrivateFile->LHandle);
1392 PrivateFile->LHandle = INVALID_HANDLE_VALUE;
1393
1394 if (!PrivateFile->IsOpenedByRead) {
1395 if (PrivateFile->WinNtThunk->DeleteFile (PrivateFile->FileName)) {
1396 Status = EFI_SUCCESS;
1397 }
1398 }
1399 }
1400
1401 FreePool (PrivateFile->FileName);
1402 FreePool (PrivateFile);
1403
1404 gBS->RestoreTPL (OldTpl);
1405
1406 return Status;
1407 }
1408
1409 STATIC
1410 VOID
1411 WinNtSystemTimeToEfiTime (
1412 IN SYSTEMTIME *SystemTime,
1413 IN TIME_ZONE_INFORMATION *TimeZone,
1414 OUT EFI_TIME *Time
1415 )
1416 /*++
1417
1418 Routine Description:
1419
1420 TODO: Add function description
1421
1422 Arguments:
1423
1424 SystemTime - TODO: add argument description
1425 TimeZone - TODO: add argument description
1426 Time - TODO: add argument description
1427
1428 Returns:
1429
1430 TODO: add return values
1431
1432 --*/
1433 {
1434 Time->Year = (UINT16) SystemTime->wYear;
1435 Time->Month = (UINT8) SystemTime->wMonth;
1436 Time->Day = (UINT8) SystemTime->wDay;
1437 Time->Hour = (UINT8) SystemTime->wHour;
1438 Time->Minute = (UINT8) SystemTime->wMinute;
1439 Time->Second = (UINT8) SystemTime->wSecond;
1440 Time->Nanosecond = (UINT32) SystemTime->wMilliseconds * 1000000;
1441 Time->TimeZone = (INT16) TimeZone->Bias;
1442
1443 if (TimeZone->StandardDate.wMonth) {
1444 Time->Daylight = EFI_TIME_ADJUST_DAYLIGHT;
1445 }
1446 }
1447
1448 EFI_STATUS
1449 EFIAPI
1450 WinNtSimpleFileSystemRead (
1451 IN EFI_FILE *This,
1452 IN OUT UINTN *BufferSize,
1453 OUT VOID *Buffer
1454 )
1455 /*++
1456
1457 Routine Description:
1458
1459 Read data from a file.
1460
1461 Arguments:
1462
1463 This - Pointer to a returned open file handle.
1464
1465 BufferSize - On input, the size of the Buffer. On output, the number of bytes stored in the Buffer.
1466
1467 Buffer - Pointer to the first byte of the read Buffer.
1468
1469 Returns:
1470
1471 EFI_SUCCESS - The data was read.
1472
1473 EFI_NO_MEDIA - The device has no media.
1474
1475 EFI_DEVICE_ERROR - The device reported an error.
1476
1477 EFI_VOLUME_CORRUPTED - The file system structures are corrupted.
1478
1479 EFI_BUFFER_TOO_SMALL - The supplied buffer size was too small to store the current directory entry.
1480 *BufferSize has been updated with the size needed to complete the request.
1481
1482 --*/
1483 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
1484 {
1485 WIN_NT_EFI_FILE_PRIVATE *PrivateFile;
1486 EFI_STATUS Status;
1487 UINTN Size;
1488 UINTN NameSize;
1489 UINTN ResultSize;
1490 UINTN Index;
1491 SYSTEMTIME SystemTime;
1492 EFI_FILE_INFO *Info;
1493 WCHAR *pw;
1494 TIME_ZONE_INFORMATION TimeZone;
1495 EFI_FILE_INFO *FileInfo;
1496 UINT64 Pos;
1497 UINT64 FileSize;
1498 UINTN FileInfoSize;
1499 EFI_TPL OldTpl;
1500
1501 if (This == NULL || BufferSize == NULL) {
1502 return EFI_INVALID_PARAMETER;
1503 }
1504
1505 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1506
1507 PrivateFile = WIN_NT_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
1508
1509 if (PrivateFile->LHandle == INVALID_HANDLE_VALUE) {
1510 Status = EFI_DEVICE_ERROR;
1511 goto Done;
1512 }
1513
1514 if (!PrivateFile->IsDirectoryPath) {
1515
1516 if (This->GetPosition (This, &Pos) != EFI_SUCCESS) {
1517 Status = EFI_DEVICE_ERROR;
1518 goto Done;
1519 }
1520
1521 FileInfoSize = SIZE_OF_EFI_FILE_SYSTEM_INFO;
1522 FileInfo = AllocatePool (FileInfoSize);
1523
1524 Status = This->GetInfo (
1525 This,
1526 &gEfiFileInfoGuid,
1527 &FileInfoSize,
1528 FileInfo
1529 );
1530
1531 if (Status == EFI_BUFFER_TOO_SMALL) {
1532 FreePool (FileInfo);
1533 FileInfo = AllocatePool (FileInfoSize);
1534 Status = This->GetInfo (
1535 This,
1536 &gEfiFileInfoGuid,
1537 &FileInfoSize,
1538 FileInfo
1539 );
1540 }
1541
1542 if (EFI_ERROR (Status)) {
1543 Status = EFI_DEVICE_ERROR;
1544 goto Done;
1545 }
1546
1547 FileSize = FileInfo->FileSize;
1548
1549 FreePool (FileInfo);
1550
1551 if (Pos >= FileSize) {
1552 *BufferSize = 0;
1553 if (Pos == FileSize) {
1554 Status = EFI_SUCCESS;
1555 goto Done;
1556 } else {
1557 Status = EFI_DEVICE_ERROR;
1558 goto Done;
1559 }
1560 }
1561
1562 Status = PrivateFile->WinNtThunk->ReadFile (
1563 PrivateFile->LHandle,
1564 Buffer,
1565 *BufferSize,
1566 BufferSize,
1567 NULL
1568 ) ? EFI_SUCCESS : EFI_DEVICE_ERROR;
1569 goto Done;
1570 }
1571
1572 //
1573 // Read on a directory. Perform a find next
1574 //
1575 if (!PrivateFile->IsValidFindBuf) {
1576 *BufferSize = 0;
1577 Status = EFI_SUCCESS;
1578 goto Done;
1579 }
1580
1581 Size = SIZE_OF_EFI_FILE_INFO;
1582
1583 NameSize = StrSize (PrivateFile->FindBuf.cFileName);
1584
1585 ResultSize = Size + NameSize;
1586
1587 Status = EFI_BUFFER_TOO_SMALL;
1588
1589 if (*BufferSize >= ResultSize) {
1590 Status = EFI_SUCCESS;
1591
1592 Info = Buffer;
1593 ZeroMem (Info, ResultSize);
1594
1595 Info->Size = ResultSize;
1596
1597 PrivateFile->WinNtThunk->GetTimeZoneInformation (&TimeZone);
1598
1599 PrivateFile->WinNtThunk->FileTimeToLocalFileTime (
1600 &PrivateFile->FindBuf.ftCreationTime,
1601 &PrivateFile->FindBuf.ftCreationTime
1602 );
1603
1604 PrivateFile->WinNtThunk->FileTimeToSystemTime (&PrivateFile->FindBuf.ftCreationTime, &SystemTime);
1605
1606 WinNtSystemTimeToEfiTime (&SystemTime, &TimeZone, &Info->CreateTime);
1607
1608 PrivateFile->WinNtThunk->FileTimeToLocalFileTime (
1609 &PrivateFile->FindBuf.ftLastWriteTime,
1610 &PrivateFile->FindBuf.ftLastWriteTime
1611 );
1612
1613 PrivateFile->WinNtThunk->FileTimeToSystemTime (&PrivateFile->FindBuf.ftLastWriteTime, &SystemTime);
1614
1615 WinNtSystemTimeToEfiTime (&SystemTime, &TimeZone, &Info->ModificationTime);
1616
1617 Info->FileSize = PrivateFile->FindBuf.nFileSizeLow;
1618
1619 Info->PhysicalSize = PrivateFile->FindBuf.nFileSizeLow;
1620
1621 if (PrivateFile->FindBuf.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE) {
1622 Info->Attribute |= EFI_FILE_ARCHIVE;
1623 }
1624
1625 if (PrivateFile->FindBuf.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) {
1626 Info->Attribute |= EFI_FILE_HIDDEN;
1627 }
1628
1629 if (PrivateFile->FindBuf.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) {
1630 Info->Attribute |= EFI_FILE_SYSTEM;
1631 }
1632
1633 if (PrivateFile->FindBuf.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
1634 Info->Attribute |= EFI_FILE_READ_ONLY;
1635 }
1636
1637 if (PrivateFile->FindBuf.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
1638 Info->Attribute |= EFI_FILE_DIRECTORY;
1639 }
1640
1641 NameSize = NameSize / sizeof (WCHAR);
1642
1643 pw = (WCHAR *) (((CHAR8 *) Buffer) + Size);
1644
1645 for (Index = 0; Index < NameSize; Index++) {
1646 pw[Index] = PrivateFile->FindBuf.cFileName[Index];
1647 }
1648
1649 if (PrivateFile->WinNtThunk->FindNextFile (PrivateFile->LHandle, &PrivateFile->FindBuf)) {
1650 PrivateFile->IsValidFindBuf = TRUE;
1651 } else {
1652 PrivateFile->IsValidFindBuf = FALSE;
1653 }
1654 }
1655
1656 *BufferSize = ResultSize;
1657
1658 Done:
1659 gBS->RestoreTPL (OldTpl);
1660 return Status;
1661 }
1662
1663 EFI_STATUS
1664 EFIAPI
1665 WinNtSimpleFileSystemWrite (
1666 IN EFI_FILE *This,
1667 IN OUT UINTN *BufferSize,
1668 IN VOID *Buffer
1669 )
1670 /*++
1671
1672 Routine Description:
1673
1674 Write data to a file.
1675
1676 Arguments:
1677
1678 This - Pointer to an opened file handle.
1679
1680 BufferSize - On input, the number of bytes in the Buffer to write to the file. On output, the number of bytes
1681 of data written to the file.
1682
1683 Buffer - Pointer to the first by of data in the buffer to write to the file.
1684
1685 Returns:
1686
1687 EFI_SUCCESS - The data was written to the file.
1688
1689 EFI_UNSUPPORTED - Writes to an open directory are not supported.
1690
1691 EFI_NO_MEDIA - The device has no media.
1692
1693 EFI_DEVICE_ERROR - The device reported an error.
1694
1695 EFI_VOLUME_CORRUPTED - The file system structures are corrupt.
1696
1697 EFI_WRITE_PROTECTED - The file, directory, volume, or device is write protected.
1698
1699 EFI_ACCESS_DENIED - The file was opened read-only.
1700
1701 EFI_VOLUME_FULL - The volume is full.
1702
1703 --*/
1704 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
1705 {
1706 WIN_NT_EFI_FILE_PRIVATE *PrivateFile;
1707 EFI_STATUS Status;
1708 EFI_TPL OldTpl;
1709
1710 if (This == NULL || BufferSize == NULL || Buffer == NULL) {
1711 return EFI_INVALID_PARAMETER;
1712 }
1713
1714 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1715
1716 PrivateFile = WIN_NT_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
1717
1718 if (PrivateFile->LHandle == INVALID_HANDLE_VALUE) {
1719 Status = EFI_DEVICE_ERROR;
1720 goto Done;
1721 }
1722
1723 if (PrivateFile->IsDirectoryPath) {
1724 Status = EFI_UNSUPPORTED;
1725 goto Done;
1726 }
1727
1728 if (PrivateFile->IsOpenedByRead) {
1729 Status = EFI_ACCESS_DENIED;
1730 goto Done;
1731 }
1732
1733 Status = PrivateFile->WinNtThunk->WriteFile (
1734 PrivateFile->LHandle,
1735 Buffer,
1736 *BufferSize,
1737 BufferSize,
1738 NULL
1739 ) ? EFI_SUCCESS : EFI_DEVICE_ERROR;
1740
1741 Done:
1742 gBS->RestoreTPL (OldTpl);
1743 return Status;
1744
1745 //
1746 // bugbug: need to access windows error reporting
1747 //
1748 }
1749
1750 EFI_STATUS
1751 EFIAPI
1752 WinNtSimpleFileSystemSetPosition (
1753 IN EFI_FILE *This,
1754 IN UINT64 Position
1755 )
1756 /*++
1757
1758 Routine Description:
1759
1760 Set a file's current position.
1761
1762 Arguments:
1763
1764 This - Pointer to an opened file handle.
1765
1766 Position - The byte position from the start of the file to set.
1767
1768 Returns:
1769
1770 EFI_SUCCESS - The file position has been changed.
1771
1772 EFI_UNSUPPORTED - The seek request for non-zero is not supported for directories.
1773
1774 --*/
1775 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
1776 {
1777 EFI_STATUS Status;
1778 WIN_NT_EFI_FILE_PRIVATE *PrivateFile;
1779 UINT32 PosLow;
1780 UINT32 PosHigh;
1781 CHAR16 *FileName;
1782 EFI_TPL OldTpl;
1783
1784 if (This == NULL) {
1785 return EFI_INVALID_PARAMETER;
1786 }
1787
1788 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1789
1790 PrivateFile = WIN_NT_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
1791
1792 if (PrivateFile->IsDirectoryPath) {
1793 if (Position != 0) {
1794 Status = EFI_UNSUPPORTED;
1795 goto Done;
1796 }
1797
1798 FileName = AllocatePool (StrSize (PrivateFile->FileName) + StrSize (L"\\*"));
1799 if (FileName == NULL) {
1800 Status = EFI_OUT_OF_RESOURCES;
1801 goto Done;
1802 }
1803
1804 StrCpy (FileName, PrivateFile->FileName);
1805 StrCat (FileName, L"\\*");
1806
1807 if (PrivateFile->LHandle != INVALID_HANDLE_VALUE) {
1808 PrivateFile->WinNtThunk->FindClose (PrivateFile->LHandle);
1809 }
1810
1811 PrivateFile->LHandle = PrivateFile->WinNtThunk->FindFirstFile (FileName, &PrivateFile->FindBuf);
1812
1813 if (PrivateFile->LHandle == INVALID_HANDLE_VALUE) {
1814 PrivateFile->IsValidFindBuf = FALSE;
1815 } else {
1816 PrivateFile->IsValidFindBuf = TRUE;
1817 }
1818
1819 FreePool (FileName);
1820
1821 Status = (PrivateFile->LHandle == INVALID_HANDLE_VALUE) ? EFI_DEVICE_ERROR : EFI_SUCCESS;
1822 } else {
1823 if (Position == (UINT64) -1) {
1824 PosLow = PrivateFile->WinNtThunk->SetFilePointer (PrivateFile->LHandle, (ULONG) 0, NULL, FILE_END);
1825 } else {
1826 PosHigh = (UINT32) RShiftU64 (Position, 32);
1827
1828 PosLow = PrivateFile->WinNtThunk->SetFilePointer (PrivateFile->LHandle, (ULONG) Position, &PosHigh, FILE_BEGIN);
1829 }
1830
1831 Status = (PosLow == 0xFFFFFFFF) ? EFI_DEVICE_ERROR : EFI_SUCCESS;
1832 }
1833
1834 Done:
1835 gBS->RestoreTPL (OldTpl);
1836 return Status;
1837 }
1838
1839 EFI_STATUS
1840 EFIAPI
1841 WinNtSimpleFileSystemGetPosition (
1842 IN EFI_FILE *This,
1843 OUT UINT64 *Position
1844 )
1845 /*++
1846
1847 Routine Description:
1848
1849 Get a file's current position.
1850
1851 Arguments:
1852
1853 This - Pointer to an opened file handle.
1854
1855 Position - Pointer to storage for the current position.
1856
1857 Returns:
1858
1859 EFI_SUCCESS - The file position has been reported.
1860
1861 EFI_UNSUPPORTED - Not valid for directories.
1862
1863 --*/
1864 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
1865 {
1866 EFI_STATUS Status;
1867 WIN_NT_EFI_FILE_PRIVATE *PrivateFile;
1868 INT32 PositionHigh;
1869 UINT64 PosHigh64;
1870 EFI_TPL OldTpl;
1871
1872 if (This == NULL || Position == NULL) {
1873 return EFI_INVALID_PARAMETER;
1874 }
1875
1876 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1877 PrivateFile = WIN_NT_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
1878
1879 PositionHigh = 0;
1880 PosHigh64 = 0;
1881
1882 if (PrivateFile->IsDirectoryPath) {
1883
1884 Status = EFI_UNSUPPORTED;
1885 goto Done;
1886
1887 } else {
1888
1889 PositionHigh = 0;
1890 *Position = PrivateFile->WinNtThunk->SetFilePointer (
1891 PrivateFile->LHandle,
1892 0,
1893 &PositionHigh,
1894 FILE_CURRENT
1895 );
1896
1897 Status = *Position == 0xffffffff ? EFI_DEVICE_ERROR : EFI_SUCCESS;
1898 if (EFI_ERROR (Status)) {
1899 goto Done;
1900 }
1901
1902 PosHigh64 = PositionHigh;
1903 *Position += LShiftU64 (PosHigh64, 32);
1904 }
1905
1906 Done:
1907 gBS->RestoreTPL (OldTpl);
1908 return Status;
1909 }
1910
1911 STATIC
1912 EFI_STATUS
1913 WinNtSimpleFileSystemFileInfo (
1914 IN WIN_NT_EFI_FILE_PRIVATE *PrivateFile,
1915 IN OUT UINTN *BufferSize,
1916 OUT VOID *Buffer
1917 )
1918 /*++
1919
1920 Routine Description:
1921
1922 TODO: Add function description
1923
1924 Arguments:
1925
1926 PrivateFile - TODO: add argument description
1927 BufferSize - TODO: add argument description
1928 Buffer - TODO: add argument description
1929
1930 Returns:
1931
1932 TODO: add return values
1933
1934 --*/
1935 {
1936 EFI_STATUS Status;
1937 UINTN Size;
1938 UINTN NameSize;
1939 UINTN ResultSize;
1940 EFI_FILE_INFO *Info;
1941 BY_HANDLE_FILE_INFORMATION FileInfo;
1942 SYSTEMTIME SystemTime;
1943 CHAR16 *RealFileName;
1944 CHAR16 *TempPointer;
1945 EFI_FILE_INFO *DirInfo;
1946 UINTN ReadSize;
1947 UINT64 Location;
1948 EFI_STATUS DirStatus;
1949
1950
1951 Size = SIZE_OF_EFI_FILE_INFO;
1952 NameSize = StrSize (PrivateFile->FileName);
1953 ResultSize = Size + NameSize;
1954
1955 Status = EFI_BUFFER_TOO_SMALL;
1956 if (*BufferSize >= ResultSize) {
1957 Status = EFI_SUCCESS;
1958
1959 Info = Buffer;
1960 ZeroMem (Info, ResultSize);
1961
1962 Info->Size = ResultSize;
1963 PrivateFile->WinNtThunk->GetFileInformationByHandle (
1964 PrivateFile->IsDirectoryPath ? PrivateFile->DirHandle : PrivateFile->LHandle,
1965 &FileInfo
1966 );
1967 Info->FileSize = FileInfo.nFileSizeLow;
1968 Info->PhysicalSize = Info->FileSize;
1969
1970 PrivateFile->WinNtThunk->FileTimeToSystemTime (&FileInfo.ftCreationTime, &SystemTime);
1971 Info->CreateTime.Year = SystemTime.wYear;
1972 Info->CreateTime.Month = (UINT8) SystemTime.wMonth;
1973 Info->CreateTime.Day = (UINT8) SystemTime.wDay;
1974 Info->CreateTime.Hour = (UINT8) SystemTime.wHour;
1975 Info->CreateTime.Minute = (UINT8) SystemTime.wMinute;
1976 Info->CreateTime.Second = (UINT8) SystemTime.wSecond;
1977
1978 PrivateFile->WinNtThunk->FileTimeToSystemTime (&FileInfo.ftLastAccessTime, &SystemTime);
1979 Info->LastAccessTime.Year = SystemTime.wYear;
1980 Info->LastAccessTime.Month = (UINT8) SystemTime.wMonth;
1981 Info->LastAccessTime.Day = (UINT8) SystemTime.wDay;
1982 Info->LastAccessTime.Hour = (UINT8) SystemTime.wHour;
1983 Info->LastAccessTime.Minute = (UINT8) SystemTime.wMinute;
1984 Info->LastAccessTime.Second = (UINT8) SystemTime.wSecond;
1985
1986 PrivateFile->WinNtThunk->FileTimeToSystemTime (&FileInfo.ftLastWriteTime, &SystemTime);
1987 Info->ModificationTime.Year = SystemTime.wYear;
1988 Info->ModificationTime.Month = (UINT8) SystemTime.wMonth;
1989 Info->ModificationTime.Day = (UINT8) SystemTime.wDay;
1990 Info->ModificationTime.Hour = (UINT8) SystemTime.wHour;
1991 Info->ModificationTime.Minute = (UINT8) SystemTime.wMinute;
1992 Info->ModificationTime.Second = (UINT8) SystemTime.wSecond;
1993
1994 if (FileInfo.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE) {
1995 Info->Attribute |= EFI_FILE_ARCHIVE;
1996 }
1997
1998 if (FileInfo.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) {
1999 Info->Attribute |= EFI_FILE_HIDDEN;
2000 }
2001
2002 if (FileInfo.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
2003 Info->Attribute |= EFI_FILE_READ_ONLY;
2004 }
2005
2006 if (FileInfo.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) {
2007 Info->Attribute |= EFI_FILE_SYSTEM;
2008 }
2009
2010 if (FileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
2011 Info->Attribute |= EFI_FILE_DIRECTORY;
2012 }
2013
2014 if (PrivateFile->IsDirectoryPath) {
2015 Info->Attribute |= EFI_FILE_DIRECTORY;
2016 }
2017
2018 RealFileName = PrivateFile->FileName;
2019 TempPointer = RealFileName;
2020
2021 while (*TempPointer) {
2022 if (*TempPointer == '\\') {
2023 RealFileName = TempPointer + 1;
2024 }
2025
2026 TempPointer++;
2027 }
2028
2029 if (PrivateFile->IsRootDirectory) {
2030 *((CHAR8 *) Buffer + Size) = 0;
2031 } else {
2032 CopyMem ((CHAR8 *) Buffer + Size, RealFileName, NameSize);
2033 }
2034
2035 if (Info->Attribute & EFI_FILE_DIRECTORY) {
2036 //
2037 // The GetFileInformationByHandle.nFileSizeLow is bogus for dir so we
2038 // need to do the same thing the caller would do to get the right value
2039 //
2040 ASSERT (PrivateFile->EfiFile.Read != NULL);
2041 DirStatus = PrivateFile->EfiFile.GetPosition (&PrivateFile->EfiFile, &Location);
2042 if (EFI_ERROR (DirStatus)) {
2043 Location = 0;
2044 }
2045
2046 PrivateFile->EfiFile.SetPosition (&PrivateFile->EfiFile, 0);
2047 Info->FileSize = 0;
2048 do {
2049 ReadSize = 0;
2050 DirInfo = NULL;
2051 DirStatus = PrivateFile->EfiFile.Read (&PrivateFile->EfiFile, &ReadSize, DirInfo);
2052 if (DirStatus == EFI_BUFFER_TOO_SMALL) {
2053 DirInfo = AllocatePool (ReadSize);
2054 if (DirInfo != NULL) {
2055 //
2056 // Read each dir entry to figure out how big the directory is
2057 //
2058 DirStatus = PrivateFile->EfiFile.Read (&PrivateFile->EfiFile, &ReadSize, DirInfo);
2059 if (!EFI_ERROR (DirStatus) && (ReadSize != 0)) {
2060 Info->FileSize += ReadSize;
2061 }
2062 FreePool (DirInfo);
2063 }
2064 }
2065
2066 } while (!EFI_ERROR (DirStatus) && (ReadSize != 0));
2067
2068 //
2069 // reset the file possition back to the previous location
2070 //
2071 PrivateFile->EfiFile.SetPosition (&PrivateFile->EfiFile, Location);
2072 }
2073 }
2074
2075 *BufferSize = ResultSize;
2076 return Status;
2077 }
2078
2079 EFI_STATUS
2080 EFIAPI
2081 WinNtSimpleFileSystemGetInfo (
2082 IN EFI_FILE *This,
2083 IN EFI_GUID *InformationType,
2084 IN OUT UINTN *BufferSize,
2085 OUT VOID *Buffer
2086 )
2087 /*++
2088
2089 Routine Description:
2090
2091 Return information about a file or volume.
2092
2093 Arguments:
2094
2095 This - Pointer to an opened file handle.
2096
2097 InformationType - GUID describing the type of information to be returned.
2098
2099 BufferSize - On input, the size of the information buffer. On output, the number of bytes written to the
2100 information buffer.
2101
2102 Buffer - Pointer to the first byte of the information buffer.
2103
2104 Returns:
2105
2106 EFI_SUCCESS - The requested information has been written into the buffer.
2107
2108 EFI_UNSUPPORTED - The InformationType is not known.
2109
2110 EFI_NO_MEDIA - The device has no media.
2111
2112 EFI_DEVICE_ERROR - The device reported an error.
2113
2114 EFI_VOLUME_CORRUPTED - The file system structures are corrupt.
2115
2116 EFI_BUFFER_TOO_SMALL - The buffer size was too small to contain the requested information. The buffer size has
2117 been updated with the size needed to complete the requested operation.
2118
2119 --*/
2120 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
2121 {
2122 EFI_STATUS Status;
2123 WIN_NT_EFI_FILE_PRIVATE *PrivateFile;
2124 EFI_FILE_SYSTEM_INFO *FileSystemInfoBuffer;
2125 UINT32 SectorsPerCluster;
2126 UINT32 BytesPerSector;
2127 UINT32 FreeClusters;
2128 UINT32 TotalClusters;
2129 UINT32 BytesPerCluster;
2130 CHAR16 *DriveName;
2131 BOOLEAN DriveNameFound;
2132 BOOL NtStatus;
2133 UINTN Index;
2134 WIN_NT_SIMPLE_FILE_SYSTEM_PRIVATE *PrivateRoot;
2135 EFI_TPL OldTpl;
2136
2137 if (This == NULL || InformationType == NULL || BufferSize == NULL) {
2138 return EFI_INVALID_PARAMETER;
2139 }
2140
2141 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
2142
2143 PrivateFile = WIN_NT_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
2144 PrivateRoot = WIN_NT_SIMPLE_FILE_SYSTEM_PRIVATE_DATA_FROM_THIS (PrivateFile->SimpleFileSystem);
2145
2146 Status = EFI_UNSUPPORTED;
2147
2148 if (CompareGuid (InformationType, &gEfiFileInfoGuid)) {
2149 Status = WinNtSimpleFileSystemFileInfo (PrivateFile, BufferSize, Buffer);
2150 }
2151
2152 if (CompareGuid (InformationType, &gEfiFileSystemInfoGuid)) {
2153 if (*BufferSize < SIZE_OF_EFI_FILE_SYSTEM_INFO + StrSize (PrivateRoot->VolumeLabel)) {
2154 *BufferSize = SIZE_OF_EFI_FILE_SYSTEM_INFO + StrSize (PrivateRoot->VolumeLabel);
2155 Status = EFI_BUFFER_TOO_SMALL;
2156 goto Done;
2157 }
2158
2159 FileSystemInfoBuffer = (EFI_FILE_SYSTEM_INFO *) Buffer;
2160 FileSystemInfoBuffer->Size = SIZE_OF_EFI_FILE_SYSTEM_INFO + StrSize (PrivateRoot->VolumeLabel);
2161 FileSystemInfoBuffer->ReadOnly = FALSE;
2162
2163 //
2164 // Try to get the drive name
2165 //
2166 DriveNameFound = FALSE;
2167 DriveName = AllocatePool (StrSize (PrivateFile->FilePath) + 1);
2168 if (DriveName == NULL) {
2169 Status = EFI_OUT_OF_RESOURCES;
2170 goto Done;
2171 }
2172
2173 StrCpy (DriveName, PrivateFile->FilePath);
2174 for (Index = 0; DriveName[Index] != 0 && DriveName[Index] != ':'; Index++) {
2175 ;
2176 }
2177
2178 if (DriveName[Index] == ':') {
2179 DriveName[Index + 1] = '\\';
2180 DriveName[Index + 2] = 0;
2181 DriveNameFound = TRUE;
2182 } else if (DriveName[0] == '\\' && DriveName[1] == '\\') {
2183 for (Index = 2; DriveName[Index] != 0 && DriveName[Index] != '\\'; Index++) {
2184 ;
2185 }
2186
2187 if (DriveName[Index] == '\\') {
2188 DriveNameFound = TRUE;
2189 for (Index++; DriveName[Index] != 0 && DriveName[Index] != '\\'; Index++) {
2190 ;
2191 }
2192
2193 DriveName[Index] = '\\';
2194 DriveName[Index + 1] = 0;
2195 }
2196 }
2197
2198 //
2199 // Try GetDiskFreeSpace first
2200 //
2201 NtStatus = PrivateFile->WinNtThunk->GetDiskFreeSpace (
2202 DriveNameFound ? DriveName : NULL,
2203 &SectorsPerCluster,
2204 &BytesPerSector,
2205 &FreeClusters,
2206 &TotalClusters
2207 );
2208 if (DriveName) {
2209 FreePool (DriveName);
2210 }
2211
2212 if (NtStatus) {
2213 //
2214 // Succeeded
2215 //
2216 BytesPerCluster = BytesPerSector * SectorsPerCluster;
2217 FileSystemInfoBuffer->VolumeSize = MultU64x32 (TotalClusters, BytesPerCluster);
2218 FileSystemInfoBuffer->FreeSpace = MultU64x32 (FreeClusters, BytesPerCluster);
2219 FileSystemInfoBuffer->BlockSize = BytesPerCluster;
2220
2221 } else {
2222 //
2223 // try GetDiskFreeSpaceEx then
2224 //
2225 FileSystemInfoBuffer->BlockSize = 0;
2226 NtStatus = PrivateFile->WinNtThunk->GetDiskFreeSpaceEx (
2227 PrivateFile->FilePath,
2228 (PULARGE_INTEGER) (&FileSystemInfoBuffer->FreeSpace),
2229 (PULARGE_INTEGER) (&FileSystemInfoBuffer->VolumeSize),
2230 NULL
2231 );
2232 if (!NtStatus) {
2233 Status = EFI_DEVICE_ERROR;
2234 goto Done;
2235 }
2236 }
2237
2238 StrCpy ((CHAR16 *) FileSystemInfoBuffer->VolumeLabel, PrivateRoot->VolumeLabel);
2239 *BufferSize = SIZE_OF_EFI_FILE_SYSTEM_INFO + StrSize (PrivateRoot->VolumeLabel);
2240 Status = EFI_SUCCESS;
2241 }
2242
2243 if (CompareGuid (InformationType, &gEfiFileSystemVolumeLabelInfoIdGuid)) {
2244 if (*BufferSize < StrSize (PrivateRoot->VolumeLabel)) {
2245 *BufferSize = StrSize (PrivateRoot->VolumeLabel);
2246 Status = EFI_BUFFER_TOO_SMALL;
2247 goto Done;
2248 }
2249
2250 StrCpy ((CHAR16 *) Buffer, PrivateRoot->VolumeLabel);
2251 *BufferSize = StrSize (PrivateRoot->VolumeLabel);
2252 Status = EFI_SUCCESS;
2253 }
2254
2255 Done:
2256 gBS->RestoreTPL (OldTpl);
2257 return Status;
2258 }
2259
2260 EFI_STATUS
2261 EFIAPI
2262 WinNtSimpleFileSystemSetInfo (
2263 IN EFI_FILE *This,
2264 IN EFI_GUID *InformationType,
2265 IN UINTN BufferSize,
2266 IN VOID *Buffer
2267 )
2268 /*++
2269
2270 Routine Description:
2271
2272 Set information about a file or volume.
2273
2274 Arguments:
2275
2276 This - Pointer to an opened file handle.
2277
2278 InformationType - GUID identifying the type of information to set.
2279
2280 BufferSize - Number of bytes of data in the information buffer.
2281
2282 Buffer - Pointer to the first byte of data in the information buffer.
2283
2284 Returns:
2285
2286 EFI_SUCCESS - The file or volume information has been updated.
2287
2288 EFI_UNSUPPORTED - The information identifier is not recognised.
2289
2290 EFI_NO_MEDIA - The device has no media.
2291
2292 EFI_DEVICE_ERROR - The device reported an error.
2293
2294 EFI_VOLUME_CORRUPTED - The file system structures are corrupt.
2295
2296 EFI_WRITE_PROTECTED - The file, directory, volume, or device is write protected.
2297
2298 EFI_ACCESS_DENIED - The file was opened read-only.
2299
2300 EFI_VOLUME_FULL - The volume is full.
2301
2302 EFI_BAD_BUFFER_SIZE - The buffer size is smaller than the type indicated by InformationType.
2303
2304 --*/
2305 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
2306 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
2307 {
2308 WIN_NT_SIMPLE_FILE_SYSTEM_PRIVATE *PrivateRoot;
2309 WIN_NT_EFI_FILE_PRIVATE *PrivateFile;
2310 EFI_FILE_INFO *OldFileInfo;
2311 EFI_FILE_INFO *NewFileInfo;
2312 EFI_STATUS Status;
2313 UINTN OldInfoSize;
2314 INTN NtStatus;
2315 UINT32 NewAttr;
2316 UINT32 OldAttr;
2317 CHAR16 *OldFileName;
2318 CHAR16 *NewFileName;
2319 CHAR16 *TempFileName;
2320 CHAR16 *CharPointer;
2321 BOOLEAN AttrChangeFlag;
2322 BOOLEAN NameChangeFlag;
2323 BOOLEAN SizeChangeFlag;
2324 BOOLEAN TimeChangeFlag;
2325 UINT64 CurPos;
2326 SYSTEMTIME NewCreationSystemTime;
2327 SYSTEMTIME NewLastAccessSystemTime;
2328 SYSTEMTIME NewLastWriteSystemTime;
2329 FILETIME NewCreationFileTime;
2330 FILETIME NewLastAccessFileTime;
2331 FILETIME NewLastWriteFileTime;
2332 WIN32_FIND_DATA FindBuf;
2333 EFI_FILE_SYSTEM_INFO *NewFileSystemInfo;
2334 EFI_TPL OldTpl;
2335
2336 //
2337 // Check for invalid parameters.
2338 //
2339 if (This == NULL || InformationType == NULL || BufferSize == 0 || Buffer == NULL) {
2340 return EFI_INVALID_PARAMETER;
2341 }
2342
2343 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
2344
2345 //
2346 // Initialise locals.
2347 //
2348 PrivateFile = WIN_NT_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
2349 PrivateRoot = WIN_NT_SIMPLE_FILE_SYSTEM_PRIVATE_DATA_FROM_THIS (PrivateFile->SimpleFileSystem);
2350
2351 Status = EFI_UNSUPPORTED;
2352 OldFileInfo = NewFileInfo = NULL;
2353 OldFileName = NewFileName = NULL;
2354 AttrChangeFlag = NameChangeFlag = SizeChangeFlag = TimeChangeFlag = FALSE;
2355
2356 //
2357 // Set file system information.
2358 //
2359 if (CompareGuid (InformationType, &gEfiFileSystemInfoGuid)) {
2360 if (BufferSize < SIZE_OF_EFI_FILE_SYSTEM_INFO + StrSize (PrivateRoot->VolumeLabel)) {
2361 Status = EFI_BAD_BUFFER_SIZE;
2362 goto Done;
2363 }
2364
2365 NewFileSystemInfo = (EFI_FILE_SYSTEM_INFO *) Buffer;
2366
2367 FreePool (PrivateRoot->VolumeLabel);
2368 PrivateRoot->VolumeLabel = AllocatePool (StrSize (NewFileSystemInfo->VolumeLabel));
2369 if (PrivateRoot->VolumeLabel == NULL) {
2370 Status = EFI_OUT_OF_RESOURCES;
2371 goto Done;
2372 }
2373
2374 StrCpy (PrivateRoot->VolumeLabel, NewFileSystemInfo->VolumeLabel);
2375
2376 Status = EFI_SUCCESS;
2377 goto Done;
2378 }
2379
2380 //
2381 // Set volume label information.
2382 //
2383 if (CompareGuid (InformationType, &gEfiFileSystemVolumeLabelInfoIdGuid)) {
2384 if (BufferSize < StrSize (PrivateRoot->VolumeLabel)) {
2385 Status = EFI_BAD_BUFFER_SIZE;
2386 goto Done;
2387 }
2388
2389 StrCpy (PrivateRoot->VolumeLabel, (CHAR16 *) Buffer);
2390
2391 Status = EFI_SUCCESS;
2392 goto Done;
2393 }
2394
2395 if (!CompareGuid (InformationType, &gEfiFileInfoGuid)) {
2396 Status = EFI_UNSUPPORTED;
2397 goto Done;
2398 }
2399
2400 if (BufferSize < SIZE_OF_EFI_FILE_INFO) {
2401 Status = EFI_BAD_BUFFER_SIZE;
2402 goto Done;
2403 }
2404
2405 //
2406 // Set file/directory information.
2407 //
2408
2409 //
2410 // Check for invalid set file information parameters.
2411 //
2412 NewFileInfo = (EFI_FILE_INFO *) Buffer;
2413
2414 if (NewFileInfo->Size <= sizeof (EFI_FILE_INFO) ||
2415 (NewFileInfo->Attribute &~(EFI_FILE_VALID_ATTR)) ||
2416 (sizeof (UINTN) == 4 && NewFileInfo->Size > 0xFFFFFFFF)
2417 ) {
2418 Status = EFI_INVALID_PARAMETER;
2419 goto Done;
2420 }
2421
2422 //
2423 // bugbug: - This is not safe. We need something like EfiStrMaxSize()
2424 // that would have an additional parameter that would be the size
2425 // of the string array just in case there are no NULL characters in
2426 // the string array.
2427 //
2428 //
2429 // Get current file information so we can determine what kind
2430 // of change request this is.
2431 //
2432 OldInfoSize = 0;
2433 Status = WinNtSimpleFileSystemFileInfo (PrivateFile, &OldInfoSize, NULL);
2434
2435 if (Status != EFI_BUFFER_TOO_SMALL) {
2436 Status = EFI_DEVICE_ERROR;
2437 goto Done;
2438 }
2439
2440 OldFileInfo = AllocatePool (OldInfoSize);
2441 if (OldFileInfo == NULL) {
2442 Status = EFI_OUT_OF_RESOURCES;
2443 goto Done;
2444 }
2445
2446 Status = WinNtSimpleFileSystemFileInfo (PrivateFile, &OldInfoSize, OldFileInfo);
2447
2448 if (EFI_ERROR (Status)) {
2449 goto Done;
2450 }
2451
2452 OldFileName = AllocatePool (StrSize (PrivateFile->FileName));
2453 if (OldFileName == NULL) {
2454 Status = EFI_OUT_OF_RESOURCES;
2455 goto Done;
2456 }
2457
2458 StrCpy (OldFileName, PrivateFile->FileName);
2459
2460 //
2461 // Make full pathname from new filename and rootpath.
2462 //
2463 if (NewFileInfo->FileName[0] == '\\') {
2464 NewFileName = AllocatePool (StrSize (PrivateRoot->FilePath) + StrSize (L"\\") + StrSize (NewFileInfo->FileName));
2465 if (NewFileName == NULL) {
2466 Status = EFI_OUT_OF_RESOURCES;
2467 goto Done;
2468 }
2469
2470 StrCpy (NewFileName, PrivateRoot->FilePath);
2471 StrCat (NewFileName, L"\\");
2472 StrCat (NewFileName, NewFileInfo->FileName + 1);
2473 } else {
2474 NewFileName = AllocatePool (StrSize (PrivateFile->FilePath) + StrSize (L"\\") + StrSize (NewFileInfo->FileName));
2475 if (NewFileName == NULL) {
2476 Status = EFI_OUT_OF_RESOURCES;
2477 goto Done;
2478 }
2479
2480 StrCpy (NewFileName, PrivateFile->FilePath);
2481 StrCat (NewFileName, L"\\");
2482 StrCat (NewFileName, NewFileInfo->FileName);
2483 }
2484
2485 //
2486 // Is there an attribute change request?
2487 //
2488 if (NewFileInfo->Attribute != OldFileInfo->Attribute) {
2489 if ((NewFileInfo->Attribute & EFI_FILE_DIRECTORY) != (OldFileInfo->Attribute & EFI_FILE_DIRECTORY)) {
2490 Status = EFI_INVALID_PARAMETER;
2491 goto Done;
2492 }
2493
2494 AttrChangeFlag = TRUE;
2495 }
2496
2497 //
2498 // Is there a name change request?
2499 // bugbug: - Need EfiStrCaseCmp()
2500 //
2501 if (StrCmp (NewFileInfo->FileName, OldFileInfo->FileName)) {
2502 NameChangeFlag = TRUE;
2503 }
2504
2505 //
2506 // Is there a size change request?
2507 //
2508 if (NewFileInfo->FileSize != OldFileInfo->FileSize) {
2509 SizeChangeFlag = TRUE;
2510 }
2511
2512 //
2513 // Is there a time stamp change request?
2514 //
2515 if (!IsZero (&NewFileInfo->CreateTime, sizeof (EFI_TIME)) &&
2516 CompareMem (&NewFileInfo->CreateTime, &OldFileInfo->CreateTime, sizeof (EFI_TIME))
2517 ) {
2518 TimeChangeFlag = TRUE;
2519 } else if (!IsZero (&NewFileInfo->LastAccessTime, sizeof (EFI_TIME)) &&
2520 CompareMem (&NewFileInfo->LastAccessTime, &OldFileInfo->LastAccessTime, sizeof (EFI_TIME))
2521 ) {
2522 TimeChangeFlag = TRUE;
2523 } else if (!IsZero (&NewFileInfo->ModificationTime, sizeof (EFI_TIME)) &&
2524 CompareMem (&NewFileInfo->ModificationTime, &OldFileInfo->ModificationTime, sizeof (EFI_TIME))
2525 ) {
2526 TimeChangeFlag = TRUE;
2527 }
2528
2529 //
2530 // All done if there are no change requests being made.
2531 //
2532 if (!(AttrChangeFlag || NameChangeFlag || SizeChangeFlag || TimeChangeFlag)) {
2533 Status = EFI_SUCCESS;
2534 goto Done;
2535 }
2536
2537 //
2538 // Set file or directory information.
2539 //
2540 OldAttr = PrivateFile->WinNtThunk->GetFileAttributes (OldFileName);
2541
2542 //
2543 // Name change.
2544 //
2545 if (NameChangeFlag) {
2546 //
2547 // Close the handles first
2548 //
2549 if (PrivateFile->IsOpenedByRead) {
2550 Status = EFI_ACCESS_DENIED;
2551 goto Done;
2552 }
2553
2554 for (CharPointer = NewFileName; *CharPointer != 0 && *CharPointer != L'/'; CharPointer++) {
2555 }
2556
2557 if (*CharPointer != 0) {
2558 Status = EFI_ACCESS_DENIED;
2559 goto Done;
2560 }
2561
2562 if (PrivateFile->LHandle != INVALID_HANDLE_VALUE) {
2563 if (PrivateFile->IsDirectoryPath) {
2564 PrivateFile->WinNtThunk->FindClose (PrivateFile->LHandle);
2565 } else {
2566 PrivateFile->WinNtThunk->CloseHandle (PrivateFile->LHandle);
2567 PrivateFile->LHandle = INVALID_HANDLE_VALUE;
2568 }
2569 }
2570
2571 if (PrivateFile->IsDirectoryPath && PrivateFile->DirHandle != INVALID_HANDLE_VALUE) {
2572 PrivateFile->WinNtThunk->CloseHandle (PrivateFile->DirHandle);
2573 PrivateFile->DirHandle = INVALID_HANDLE_VALUE;
2574 }
2575
2576 NtStatus = PrivateFile->WinNtThunk->MoveFile (OldFileName, NewFileName);
2577
2578 if (NtStatus) {
2579 //
2580 // modify file name
2581 //
2582 FreePool (PrivateFile->FileName);
2583
2584 PrivateFile->FileName = AllocatePool (StrSize (NewFileName));
2585 if (PrivateFile->FileName == NULL) {
2586 Status = EFI_OUT_OF_RESOURCES;
2587 goto Done;
2588 }
2589
2590 StrCpy (PrivateFile->FileName, NewFileName);
2591
2592 TempFileName = AllocatePool (StrSize (NewFileName) + StrSize (L"\\*"));
2593
2594 StrCpy (TempFileName, NewFileName);
2595
2596 if (!PrivateFile->IsDirectoryPath) {
2597 PrivateFile->LHandle = PrivateFile->WinNtThunk->CreateFile (
2598 TempFileName,
2599 PrivateFile->IsOpenedByRead ? GENERIC_READ : GENERIC_READ | GENERIC_WRITE,
2600 FILE_SHARE_READ | FILE_SHARE_WRITE,
2601 NULL,
2602 OPEN_EXISTING,
2603 0,
2604 NULL
2605 );
2606
2607 FreePool (TempFileName);
2608
2609 //
2610 // Flush buffers just in case
2611 //
2612 if (PrivateFile->WinNtThunk->FlushFileBuffers (PrivateFile->LHandle) == 0) {
2613 Status = EFI_DEVICE_ERROR;
2614 goto Done;
2615 }
2616 } else {
2617 PrivateFile->DirHandle = PrivateFile->WinNtThunk->CreateFile (
2618 TempFileName,
2619 PrivateFile->IsOpenedByRead ? GENERIC_READ : GENERIC_READ | GENERIC_WRITE,
2620 FILE_SHARE_READ | FILE_SHARE_WRITE,
2621 NULL,
2622 OPEN_EXISTING,
2623 FILE_FLAG_BACKUP_SEMANTICS,
2624 NULL
2625 );
2626
2627 StrCat (TempFileName, L"\\*");
2628 PrivateFile->LHandle = PrivateFile->WinNtThunk->FindFirstFile (TempFileName, &FindBuf);
2629
2630 FreePool (TempFileName);
2631 }
2632 } else {
2633 Reopen: ;
2634 Status = EFI_DEVICE_ERROR;
2635
2636 NtStatus = PrivateFile->WinNtThunk->SetFileAttributes (OldFileName, OldAttr);
2637
2638 if (!NtStatus) {
2639 goto Done;
2640 }
2641
2642 TempFileName = AllocatePool (StrSize (OldFileName) + StrSize (L"\\*"));
2643
2644 StrCpy (TempFileName, OldFileName);
2645
2646 if (!PrivateFile->IsDirectoryPath) {
2647 PrivateFile->LHandle = PrivateFile->WinNtThunk->CreateFile (
2648 TempFileName,
2649 PrivateFile->IsOpenedByRead ? GENERIC_READ : GENERIC_READ | GENERIC_WRITE,
2650 FILE_SHARE_READ | FILE_SHARE_WRITE,
2651 NULL,
2652 OPEN_EXISTING,
2653 0,
2654 NULL
2655 );
2656 } else {
2657 PrivateFile->DirHandle = PrivateFile->WinNtThunk->CreateFile (
2658 TempFileName,
2659 PrivateFile->IsOpenedByRead ? GENERIC_READ : GENERIC_READ | GENERIC_WRITE,
2660 FILE_SHARE_READ | FILE_SHARE_WRITE,
2661 NULL,
2662 OPEN_EXISTING,
2663 FILE_FLAG_BACKUP_SEMANTICS,
2664 NULL
2665 );
2666
2667 StrCat (TempFileName, L"\\*");
2668 PrivateFile->LHandle = PrivateFile->WinNtThunk->FindFirstFile (TempFileName, &FindBuf);
2669 }
2670
2671 FreePool (TempFileName);
2672
2673 goto Done;
2674
2675 }
2676 }
2677
2678 //
2679 // Size change
2680 //
2681 if (SizeChangeFlag) {
2682 if (PrivateFile->IsDirectoryPath) {
2683 Status = EFI_UNSUPPORTED;
2684 goto Done;
2685 }
2686
2687 if (PrivateFile->IsOpenedByRead || OldFileInfo->Attribute & EFI_FILE_READ_ONLY) {
2688 Status = EFI_ACCESS_DENIED;
2689 goto Done;
2690 }
2691
2692 Status = This->GetPosition (This, &CurPos);
2693 if (EFI_ERROR (Status)) {
2694 goto Done;
2695 }
2696
2697 Status = This->SetPosition (This, NewFileInfo->FileSize);
2698 if (EFI_ERROR (Status)) {
2699 goto Done;
2700 }
2701
2702 if (PrivateFile->WinNtThunk->SetEndOfFile (PrivateFile->LHandle) == 0) {
2703 Status = EFI_DEVICE_ERROR;
2704 goto Done;
2705 }
2706
2707 Status = This->SetPosition (This, CurPos);
2708 if (EFI_ERROR (Status)) {
2709 goto Done;
2710 }
2711 }
2712
2713 //
2714 // Time change
2715 //
2716 if (TimeChangeFlag) {
2717
2718 NewCreationSystemTime.wYear = NewFileInfo->CreateTime.Year;
2719 NewCreationSystemTime.wMonth = NewFileInfo->CreateTime.Month;
2720 NewCreationSystemTime.wDay = NewFileInfo->CreateTime.Day;
2721 NewCreationSystemTime.wHour = NewFileInfo->CreateTime.Hour;
2722 NewCreationSystemTime.wMinute = NewFileInfo->CreateTime.Minute;
2723 NewCreationSystemTime.wSecond = NewFileInfo->CreateTime.Second;
2724 NewCreationSystemTime.wMilliseconds = 0;
2725
2726 if (!PrivateFile->WinNtThunk->SystemTimeToFileTime (
2727 &NewCreationSystemTime,
2728 &NewCreationFileTime
2729 )) {
2730 goto Done;
2731 }
2732
2733 NewLastAccessSystemTime.wYear = NewFileInfo->LastAccessTime.Year;
2734 NewLastAccessSystemTime.wMonth = NewFileInfo->LastAccessTime.Month;
2735 NewLastAccessSystemTime.wDay = NewFileInfo->LastAccessTime.Day;
2736 NewLastAccessSystemTime.wHour = NewFileInfo->LastAccessTime.Hour;
2737 NewLastAccessSystemTime.wMinute = NewFileInfo->LastAccessTime.Minute;
2738 NewLastAccessSystemTime.wSecond = NewFileInfo->LastAccessTime.Second;
2739 NewLastAccessSystemTime.wMilliseconds = 0;
2740
2741 if (!PrivateFile->WinNtThunk->SystemTimeToFileTime (
2742 &NewLastAccessSystemTime,
2743 &NewLastAccessFileTime
2744 )) {
2745 goto Done;
2746 }
2747
2748 NewLastWriteSystemTime.wYear = NewFileInfo->ModificationTime.Year;
2749 NewLastWriteSystemTime.wMonth = NewFileInfo->ModificationTime.Month;
2750 NewLastWriteSystemTime.wDay = NewFileInfo->ModificationTime.Day;
2751 NewLastWriteSystemTime.wHour = NewFileInfo->ModificationTime.Hour;
2752 NewLastWriteSystemTime.wMinute = NewFileInfo->ModificationTime.Minute;
2753 NewLastWriteSystemTime.wSecond = NewFileInfo->ModificationTime.Second;
2754 NewLastWriteSystemTime.wMilliseconds = 0;
2755
2756 if (!PrivateFile->WinNtThunk->SystemTimeToFileTime (
2757 &NewLastWriteSystemTime,
2758 &NewLastWriteFileTime
2759 )) {
2760 goto Done;
2761 }
2762
2763 if (!PrivateFile->WinNtThunk->SetFileTime (
2764 PrivateFile->IsDirectoryPath ? PrivateFile->DirHandle : PrivateFile->LHandle,
2765 &NewCreationFileTime,
2766 &NewLastAccessFileTime,
2767 &NewLastWriteFileTime
2768 )) {
2769 Status = EFI_DEVICE_ERROR;
2770 goto Done;
2771 }
2772
2773 }
2774
2775 //
2776 // No matter about AttrChangeFlag, Attribute must be set.
2777 // Because operation before may cause attribute change.
2778 //
2779 NewAttr = OldAttr;
2780
2781 if (NewFileInfo->Attribute & EFI_FILE_ARCHIVE) {
2782 NewAttr |= FILE_ATTRIBUTE_ARCHIVE;
2783 } else {
2784 NewAttr &= ~FILE_ATTRIBUTE_ARCHIVE;
2785 }
2786
2787 if (NewFileInfo->Attribute & EFI_FILE_HIDDEN) {
2788 NewAttr |= FILE_ATTRIBUTE_HIDDEN;
2789 } else {
2790 NewAttr &= ~FILE_ATTRIBUTE_HIDDEN;
2791 }
2792
2793 if (NewFileInfo->Attribute & EFI_FILE_SYSTEM) {
2794 NewAttr |= FILE_ATTRIBUTE_SYSTEM;
2795 } else {
2796 NewAttr &= ~FILE_ATTRIBUTE_SYSTEM;
2797 }
2798
2799 if (NewFileInfo->Attribute & EFI_FILE_READ_ONLY) {
2800 NewAttr |= FILE_ATTRIBUTE_READONLY;
2801 } else {
2802 NewAttr &= ~FILE_ATTRIBUTE_READONLY;
2803 }
2804
2805 NtStatus = PrivateFile->WinNtThunk->SetFileAttributes (NewFileName, NewAttr);
2806
2807 if (!NtStatus) {
2808 goto Reopen;
2809 }
2810
2811 Done:
2812 if (OldFileInfo != NULL) {
2813 FreePool (OldFileInfo);
2814 }
2815
2816 if (OldFileName != NULL) {
2817 FreePool (OldFileName);
2818 }
2819
2820 if (NewFileName != NULL) {
2821 FreePool (NewFileName);
2822 }
2823
2824 gBS->RestoreTPL (OldTpl);
2825 return Status;
2826 }
2827
2828 EFI_STATUS
2829 EFIAPI
2830 WinNtSimpleFileSystemFlush (
2831 IN EFI_FILE *This
2832 )
2833 /*++
2834
2835 Routine Description:
2836
2837 Flush all modified data to the media.
2838
2839 Arguments:
2840
2841 This - Pointer to an opened file handle.
2842
2843 Returns:
2844
2845 EFI_SUCCESS - The data has been flushed.
2846
2847 EFI_NO_MEDIA - The device has no media.
2848
2849 EFI_DEVICE_ERROR - The device reported an error.
2850
2851 EFI_VOLUME_CORRUPTED - The file system structures have been corrupted.
2852
2853 EFI_WRITE_PROTECTED - The file, directory, volume, or device is write protected.
2854
2855 EFI_ACCESS_DENIED - The file was opened read-only.
2856
2857 EFI_VOLUME_FULL - The volume is full.
2858
2859 --*/
2860 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
2861 {
2862 BY_HANDLE_FILE_INFORMATION FileInfo;
2863 WIN_NT_EFI_FILE_PRIVATE *PrivateFile;
2864 EFI_STATUS Status;
2865 EFI_TPL OldTpl;
2866
2867 if (This == NULL) {
2868 return EFI_INVALID_PARAMETER;
2869 }
2870
2871 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
2872
2873 PrivateFile = WIN_NT_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
2874
2875 if (PrivateFile->LHandle == INVALID_HANDLE_VALUE) {
2876 Status = EFI_DEVICE_ERROR;
2877 goto Done;
2878 }
2879
2880 if (PrivateFile->IsDirectoryPath) {
2881 Status = EFI_SUCCESS;
2882 goto Done;
2883 }
2884
2885 if (PrivateFile->IsOpenedByRead) {
2886 Status = EFI_ACCESS_DENIED;
2887 goto Done;
2888 }
2889
2890 PrivateFile->WinNtThunk->GetFileInformationByHandle (PrivateFile->LHandle, &FileInfo);
2891
2892 if (FileInfo.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
2893 Status = EFI_ACCESS_DENIED;
2894 goto Done;
2895 }
2896
2897 Status = PrivateFile->WinNtThunk->FlushFileBuffers (PrivateFile->LHandle) ? EFI_SUCCESS : EFI_DEVICE_ERROR;
2898
2899 Done:
2900 gBS->RestoreTPL (OldTpl);
2901 return Status;
2902 //
2903 // bugbug: - Use Windows error reporting.
2904 //
2905 }
2906
2907
EFI Development Kit II mirror for PVE