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