projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[UDFS] Fix 64 bit issues
[reactos.git] / drivers / filesystems / udfs / create.cpp
1 ////////////////////////////////////////////////////////////////////
2 // Copyright (C) Alexander Telyatnikov, Ivan Keliukh, Yegor Anchishkin, SKIF Software, 1999-2013. Kiev, Ukraine
3 // All rights reserved
4 // This file was released under the GPLv2 on June 2015.
5 ////////////////////////////////////////////////////////////////////
6 /*************************************************************************
7 *
8 * File: Create.cpp
9 *
10 * Module: UDF File System Driver (Kernel mode execution only)
11 *
12 * Description:
13 * Contains code to handle the "Create"/"Open" dispatch entry point.
14 *
15 *************************************************************************/
16
17 #include "udffs.h"
18
19 #define IsFileObjectReadOnly(FO) (!((FO)->WriteAccess | (FO)->DeleteAccess))
20
21 // define the file specific bug-check id
22 #define UDF_BUG_CHECK_ID UDF_FILE_CREATE
23
24 #define MEM_USABS_TAG "US_Abs"
25 #define MEM_USLOC_TAG "US_Loc"
26 #define MEM_USOBJ_TAG "US_Obj"
27
28 #define UDF_LOG_CREATE_DISPOSITION
29
30 /*************************************************************************
31 *
32 * Function: UDFCreate()
33 *
34 * Description:
35 * The I/O Manager will invoke this routine to handle a create/open
36 * request
37 *
38 * Expected Interrupt Level (for execution) :
39 *
40 * IRQL_PASSIVE_LEVEL (invocation at higher IRQL will cause execution
41 * to be deferred to a worker thread context)
42 *
43 * Return Value: STATUS_SUCCESS/Error
44 *
45 *************************************************************************/
46 NTSTATUS
47 NTAPI
48 UDFCreate(
49 PDEVICE_OBJECT DeviceObject, // the logical volume device object
50 PIRP Irp) // I/O Request Packet
51 {
52 NTSTATUS RC = STATUS_SUCCESS;
53 PtrUDFIrpContext PtrIrpContext;
54 BOOLEAN AreWeTopLevel = FALSE;
55
56 TmPrint(("UDFCreate:\n"));
57
58 FsRtlEnterFileSystem();
59 ASSERT(DeviceObject);
60 ASSERT(Irp);
61
62 // sometimes, we may be called here with the device object representing
63 // the file system (instead of the device object created for a logical
64 // volume. In this case, there is not much we wish to do (this create
65 // typically will happen 'cause some process has to open the FSD device
66 // object so as to be able to send an IOCTL to the FSD)
67
68 // All of the logical volume device objects we create have a device
69 // extension whereas the device object representing the FSD has no
70 // device extension. This seems like a good enough method to identify
71 // between the two device objects ...
72 if (UDFIsFSDevObj(DeviceObject)) {
73 // this is an open of the FSD itself
74 Irp->IoStatus.Status = RC;
75 Irp->IoStatus.Information = FILE_OPENED;
76
77 IoCompleteRequest(Irp, IO_NO_INCREMENT);
78 FsRtlExitFileSystem();
79 return(RC);
80 }
81
82 // set the top level context
83 AreWeTopLevel = UDFIsIrpTopLevel(Irp);
84
85 _SEH2_TRY {
86
87 // get an IRP context structure and issue the request
88 PtrIrpContext = UDFAllocateIrpContext(Irp, DeviceObject);
89 if(PtrIrpContext) {
90 RC = UDFCommonCreate(PtrIrpContext, Irp);
91 } else {
92 RC = STATUS_INSUFFICIENT_RESOURCES;
93 Irp->IoStatus.Status = RC;
94 Irp->IoStatus.Information = 0;
95 // complete the IRP
96 IoCompleteRequest(Irp, IO_DISK_INCREMENT);
97 }
98
99 } _SEH2_EXCEPT(UDFExceptionFilter(PtrIrpContext, _SEH2_GetExceptionInformation())) {
100
101 RC = UDFExceptionHandler(PtrIrpContext, Irp);
102
103 UDFLogEvent(UDF_ERROR_INTERNAL_ERROR, RC);
104 } _SEH2_END;
105
106 if (AreWeTopLevel) {
107 IoSetTopLevelIrp(NULL);
108 }
109
110 AdPrint(("UDFCreate: %x\n", RC));
111
112 FsRtlExitFileSystem();
113
114 return(RC);
115
116 } // end UDFCreate()
117
118 /*
119 */
120 VOID
121 __fastcall
122 UDFReleaseResFromCreate(
123 IN PERESOURCE* PagingIoRes,
124 IN PERESOURCE* Res1,
125 IN PERESOURCE* Res2
126 )
127 {
128 if(*PagingIoRes) {
129 UDFReleaseResource(*PagingIoRes);
130 (*PagingIoRes) = NULL;
131 }
132 if(*Res1) {
133 UDFReleaseResource(*Res1);
134 (*Res1) = NULL;
135 }
136 if(*Res2) {
137 UDFReleaseResource(*Res2);
138 (*Res2) = NULL;
139 }
140 } // end UDFReleaseResFromCreate()
141
142 /*
143 */
144 VOID
145 __fastcall
146 UDFAcquireParent(
147 IN PUDF_FILE_INFO RelatedFileInfo,
148 IN PERESOURCE* Res1,
149 IN PERESOURCE* Res2
150 )
151 {
152 if(RelatedFileInfo->Fcb &&
153 RelatedFileInfo->Fcb->ParentFcb) {
154
155 UDF_CHECK_PAGING_IO_RESOURCE(RelatedFileInfo->Fcb->ParentFcb->NTRequiredFCB);
156 UDFAcquireResourceExclusive((*Res2) = &(RelatedFileInfo->Fcb->ParentFcb->NTRequiredFCB->MainResource),TRUE);
157 }
158
159 UDF_CHECK_PAGING_IO_RESOURCE(RelatedFileInfo->Fcb->NTRequiredFCB);
160 UDFAcquireResourceExclusive((*Res1) = &(RelatedFileInfo->Fcb->NTRequiredFCB->MainResource),TRUE);
161
162 UDFInterlockedIncrement((PLONG)&(RelatedFileInfo->Fcb->ReferenceCount));
163 UDFInterlockedIncrement((PLONG)&(RelatedFileInfo->Dloc->CommonFcb->CommonRefCount));
164 UDFReferenceFile__(RelatedFileInfo);
165 ASSERT_REF(RelatedFileInfo->Fcb->ReferenceCount >= RelatedFileInfo->RefCount);
166 } // end UDFAcquireParent()
167
168 /*************************************************************************
169 *
170 * Function: UDFCommonCreate()
171 *
172 * Description:
173 * The actual work is performed here. This routine may be invoked in one'
174 * of the two possible contexts:
175 * (a) in the context of a system worker thread
176 * (b) in the context of the original caller
177 *
178 * Expected Interrupt Level (for execution) :
179 *
180 * IRQL_PASSIVE_LEVEL
181 *
182 * Return Value: STATUS_SUCCESS/Error
183 *
184 *************************************************************************/
185 NTSTATUS
186 UDFCommonCreate(
187 PtrUDFIrpContext PtrIrpContext,
188 PIRP Irp
189 )
190 {
191 NTSTATUS RC = STATUS_SUCCESS;
192 PIO_STACK_LOCATION IrpSp = NULL;
193 PIO_SECURITY_CONTEXT PtrSecurityContext = NULL;
194 PFILE_OBJECT PtrNewFileObject = NULL;
195 PFILE_OBJECT PtrRelatedFileObject = NULL;
196 LONGLONG AllocationSize; // if we create a new file
197 PFILE_FULL_EA_INFORMATION PtrExtAttrBuffer = NULL;
198 ULONG RequestedOptions;
199 ULONG RequestedDisposition;
200 USHORT FileAttributes;
201 USHORT TmpFileAttributes;
202 USHORT ShareAccess;
203 ULONG ExtAttrLength = 0;
204 ACCESS_MASK DesiredAccess;
205 PACCESS_STATE AccessState;
206
207 PVCB Vcb = NULL;
208 _SEH2_VOLATILE BOOLEAN AcquiredVcb = FALSE;
209 BOOLEAN OpenExisting = FALSE;
210 PERESOURCE Res1 = NULL;
211 PERESOURCE Res2 = NULL;
212 PERESOURCE PagingIoRes = NULL;
213
214 // BOOLEAN DirectoryOnlyRequested;
215 // BOOLEAN FileOnlyRequested;
216 // BOOLEAN NoBufferingSpecified;
217 BOOLEAN WriteThroughRequested;
218 BOOLEAN DeleteOnCloseSpecified;
219 // BOOLEAN NoExtAttrKnowledge;
220 // BOOLEAN CreateTreeConnection = FALSE;
221 // BOOLEAN OpenByFileId;
222
223 // Are we dealing with a page file?
224 BOOLEAN PageFileManipulation;
225 // Is this open for a target directory (used in rename operations)?
226 BOOLEAN OpenTargetDirectory;
227 // Should we ignore case when attempting to locate the object?
228 BOOLEAN IgnoreCase;
229
230 PtrUDFCCB PtrRelatedCCB = NULL, PtrNewCcb = NULL;
231 PtrUDFFCB PtrRelatedFCB = NULL, PtrNewFcb = NULL;
232 PtrUDFNTRequiredFCB NtReqFcb;
233
234 ULONG ReturnedInformation;
235
236 UNICODE_STRING TargetObjectName;
237 UNICODE_STRING RelatedObjectName;
238
239 UNICODE_STRING AbsolutePathName; // '\aaa\cdf\fff\rrrr.tre:s'
240 UNICODE_STRING LocalPath; // '\aaa\cdf'
241 UNICODE_STRING CurName; // 'cdf'
242 UNICODE_STRING TailName; // 'fff\rrrr.tre:s'
243 UNICODE_STRING LastGoodName; // it depends...
244 UNICODE_STRING LastGoodTail; // it depends...
245 UNICODE_STRING StreamName; // ':s'
246
247 PUDF_FILE_INFO RelatedFileInfo;
248 PUDF_FILE_INFO OldRelatedFileInfo = NULL;
249 PUDF_FILE_INFO NewFileInfo = NULL;
250 PUDF_FILE_INFO LastGoodFileInfo = NULL;
251 PWCHAR TmpBuffer;
252 ULONG TreeLength = 0;
253 // ULONG i = 0;
254
255 BOOLEAN StreamOpen = FALSE;
256 BOOLEAN StreamExists = FALSE;
257 BOOLEAN RestoreVCBOpenCounter = FALSE;
258 BOOLEAN RestoreShareAccess = FALSE;
259 PWCHAR TailNameBuffer = NULL;
260 ULONG SNameIndex = 0;
261
262 TmPrint(("UDFCommonCreate:\n"));
263
264 ASSERT(PtrIrpContext);
265 ASSERT(Irp);
266
267 _SEH2_TRY {
268
269 AbsolutePathName.Buffer =
270 LocalPath.Buffer = NULL;
271 // If we were called with our file system device object instead of a
272 // volume device object, just complete this request with STATUS_SUCCESS.
273 if (!(PtrIrpContext->TargetDeviceObject->DeviceExtension)) {
274
275 ReturnedInformation = FILE_OPENED;
276 try_return(RC = STATUS_SUCCESS);
277 }
278
279 AbsolutePathName.Length = AbsolutePathName.MaximumLength =
280 LocalPath.Length = LocalPath.MaximumLength = 0;
281 // First, get a pointer to the current I/O stack location
282 IrpSp = IoGetCurrentIrpStackLocation(Irp);
283 ASSERT(IrpSp);
284
285 // If the caller cannot block, post the request to be handled
286 // asynchronously
287 if (!(PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_CAN_BLOCK)) {
288 // We must defer processing of this request since we could
289 // block anytime while performing the create/open ...
290 ASSERT(FALSE);
291 RC = UDFPostRequest(PtrIrpContext, Irp);
292 try_return(RC);
293 }
294
295 // Now, we can obtain the parameters specified by the user.
296 // Note that the file object is the new object created by the
297 // I/O Manager in anticipation that this create/open request
298 // will succeed.
299 PtrNewFileObject = IrpSp->FileObject;
300 TargetObjectName = PtrNewFileObject->FileName;
301 PtrRelatedFileObject = PtrNewFileObject->RelatedFileObject;
302
303 // If a related file object is present, get the pointers
304 // to the CCB and the FCB for the related file object
305 if (PtrRelatedFileObject) {
306 PtrRelatedCCB = (PtrUDFCCB)(PtrRelatedFileObject->FsContext2);
307 ASSERT(PtrRelatedCCB);
308 ASSERT(PtrRelatedCCB->NodeIdentifier.NodeType == UDF_NODE_TYPE_CCB);
309 // each CCB in turn points to a FCB
310 PtrRelatedFCB = PtrRelatedCCB->Fcb;
311 ASSERT(PtrRelatedFCB);
312 ASSERT((PtrRelatedFCB->NodeIdentifier.NodeType == UDF_NODE_TYPE_FCB)
313 ||(PtrRelatedFCB->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB));
314 RelatedObjectName = PtrRelatedFileObject->FileName;
315 if (!(RelatedObjectName.Length) || (RelatedObjectName.Buffer[0] != L'\\')) {
316 if(PtrRelatedFCB->FCBName)
317 RelatedObjectName = PtrRelatedFCB->FCBName->ObjectName;
318 }
319 }
320
321 // Allocation size is only used if a new file is created
322 // or a file is superseded.
323 AllocationSize = Irp->Overlay.AllocationSize.QuadPart;
324
325 // Get a ptr to the supplied security context
326 PtrSecurityContext = IrpSp->Parameters.Create.SecurityContext;
327 AccessState = PtrSecurityContext->AccessState;
328
329 // The desired access can be obtained from the SecurityContext
330 DesiredAccess = PtrSecurityContext->DesiredAccess;
331
332 // Two values are supplied in the Create.Options field:
333 // (a) the actual user supplied options
334 // (b) the create disposition
335 RequestedOptions = (IrpSp->Parameters.Create.Options & FILE_VALID_OPTION_FLAGS);
336
337 // The file disposition is packed with the user options ...
338 // Disposition includes FILE_SUPERSEDE, FILE_OPEN_IF, etc.
339 RequestedDisposition = (IrpSp->Parameters.Create.Options >> 24);// & 0xFF;
340
341 //#ifdef UDF_LOG_CREATE_DISPOSITION
342 switch(RequestedDisposition) {
343 case FILE_SUPERSEDE:
344 AdPrint((" Dispos: FILE_SUPERSEDE\n"));
345 break;
346 case FILE_OPEN:
347 AdPrint((" Dispos: FILE_OPEN\n"));
348 break;
349 case FILE_CREATE:
350 AdPrint((" Dispos: FILE_CREATE\n"));
351 break;
352 case FILE_OPEN_IF:
353 AdPrint((" Dispos: FILE_OPEN_IF\n"));
354 break;
355 case FILE_OVERWRITE:
356 AdPrint((" Dispos: FILE_OVERWRITE\n"));
357 break;
358 case FILE_OVERWRITE_IF:
359 AdPrint((" Dispos: FILE_OVERWRITE_IF\n"));
360 break;
361 default:
362 AdPrint((" Dispos: *** Unknown ***\n"));
363 break;
364 }
365 //#endif // UDF_LOG_CREATE_DISPOSITION
366
367 FileAttributes = (USHORT)(IrpSp->Parameters.Create.FileAttributes & FILE_ATTRIBUTE_VALID_FLAGS);
368 ShareAccess = IrpSp->Parameters.Create.ShareAccess;
369
370 // If the FSD does not support EA manipulation, we might return
371 // invalid parameter if the following are supplied.
372 // EA arguments are only used if a new file is created or a file is
373 // superseded
374
375 // But some applications _require_ EA support
376 // (Notepad... rather strange, isn't it ?)
377
378 // So, for such stupid ones
379 // !!! We shall ignore these parameters !!!
380
381 // PtrExtAttrBuffer = (struct _FILE_FULL_EA_INFORMATION *) Irp->AssociatedIrp.SystemBuffer;
382 // ExtAttrLength = IrpSp->Parameters.Create.EaLength;
383
384 // Get the options supplied by the user
385
386 #define OpenForBackup (RequestedOptions & FILE_OPEN_FOR_BACKUP_INTENT)
387 // User specifies that returned object MUST be a directory.
388 // Lack of presence of this flag does not mean it *cannot* be a
389 // directory *unless* FileOnlyRequested is set (see below)
390
391 // Presence of the flag however, does require that the returned object be
392 // a directory (container) object.
393 #define DirectoryOnlyRequested (RequestedOptions & FILE_DIRECTORY_FILE)
394
395 // User specifies that returned object MUST NOT be a directory.
396 // Lack of presence of this flag does not mean it *cannot* be a
397 // file *unless* DirectoryOnlyRequested is set (see above).
398
399 // Presence of the flag however does require that the returned object be
400 // a simple file (non-container) object.
401 #define FileOnlyRequested (RequestedOptions & FILE_NON_DIRECTORY_FILE)
402
403 // We cannot cache the file if the following flag is set.
404 // However, things do get a little bit interesting if caching
405 // has been already initiated due to a previous open ...
406 // (maintaining consistency then becomes a little bit more
407 // of a headache - see read/write file descriptions)
408 #define NoBufferingSpecified (RequestedOptions & FILE_NO_INTERMEDIATE_BUFFERING)
409
410 // Write-through simply means that the FSD must *not* return from
411 // a user write request until the data has been flushed to secondary
412 // storage (either to disks directly connected to the node or across
413 // the network in the case of a redirector)
414 WriteThroughRequested = (RequestedOptions & FILE_WRITE_THROUGH) ? TRUE : FALSE;
415
416 #define SequentialIoRequested (RequestedOptions & FILE_SEQUENTIAL_ONLY ? TRUE : FALSE)
417
418 // Not all of the native file system implementations support
419 // the delete-on-close option. All this means is that after the
420 // last close on the FCB has been performed, the FSD should
421 // delete the file. It simply saves the caller from issuing a
422 // separate delete request. Also, some FSD implementations might choose
423 // to implement a Windows NT idiosyncratic behavior wherein we
424 // could create such "delete-on-close" marked files under directories
425 // marked for deletion. Ordinarily, a FSD will not allow us to create
426 // a new file under a directory that has been marked for deletion.
427 DeleteOnCloseSpecified = (IrpSp->Parameters.Create.Options & FILE_DELETE_ON_CLOSE) ? TRUE : FALSE;
428
429 if(DeleteOnCloseSpecified) {
430 AdPrint((" DeleteOnClose\n"));
431 }
432
433 #define NoExtAttrKnowledge /*(RequestedOptions & FILE_NO_EA_KNOWLEDGE) ?*/ TRUE /*: FALSE*/
434
435 // The following flag is only used by the LAN Manager redirector
436 // to initiate a "new mapping" to a remote share. Typically,
437 // a FSD will not see this flag (especially disk based FSD's)
438 // CreateTreeConnection = (RequestedOptions & FILE_CREATE_TREE_CONNECTION) ? TRUE : FALSE;
439
440 // The NTFS file system for exmaple supports the OpenByFileId option.
441 // The FSD may also be able to associate a unique numerical ID with
442 // an on-disk object. The caller would get this ID in a "query file
443 // information" call.
444
445 // Later, the caller might decide to reopen the object, this time
446 // though it may supply the FSD with the file identifier instead of
447 // a file/path name.
448 #define OpenByFileId (RequestedOptions & FILE_OPEN_BY_FILE_ID)
449
450 // Are we dealing with a page file?
451 PageFileManipulation = (IrpSp->Flags & SL_OPEN_PAGING_FILE) ? TRUE : FALSE;
452
453 // The open target directory flag is used as part of the sequence of
454 // operations performed by the I/O Manager is response to a file/dir
455 // rename operation. See the explanation in the book for details.
456 OpenTargetDirectory = (IrpSp->Flags & SL_OPEN_TARGET_DIRECTORY) ? TRUE : FALSE;
457
458 // If the FSD supports case-sensitive file name checks, we may
459 // choose to honor the following flag ...
460 IgnoreCase = (IrpSp->Flags & SL_CASE_SENSITIVE) ? FALSE : TRUE;
461
462 // Ensure that the operation has been directed to a valid VCB ...
463 Vcb = (PVCB)(PtrIrpContext->TargetDeviceObject->DeviceExtension);
464 ASSERT(Vcb);
465 ASSERT(Vcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB);
466 // Vcb->VCBFlags |= UDF_VCB_SKIP_EJECT_CHECK;
467
468 WriteThroughRequested = WriteThroughRequested ||
469 (Vcb->CompatFlags & UDF_VCB_IC_FORCE_WRITE_THROUGH);
470
471 // Do some preliminary checks to make sure the operation is supported.
472 // We fail in the following cases immediately.
473 // - Open a paging file.
474 // - Open a file with Eas.
475 if(PageFileManipulation) {
476 ReturnedInformation = 0;
477 AdPrint(("Can't create a page file\n"));
478 try_return(RC = STATUS_ACCESS_DENIED);
479 }
480 if(ExtAttrLength) {
481 ReturnedInformation = 0;
482 AdPrint(("Can't create file with EAs\n"));
483 try_return(RC = STATUS_EAS_NOT_SUPPORTED);
484 }
485
486 UDFFlushTryBreak(Vcb);
487
488 if (Vcb->SoftEjectReq) {
489 AdPrint((" Eject requested\n"));
490 try_return(RC = STATUS_FILE_INVALID);
491 }
492
493 // If the volume has been locked, fail the request
494 if ((Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_LOCKED) &&
495 (Vcb->VolumeLockPID != GetCurrentPID())) {
496 AdPrint((" Volume is locked\n"));
497 RC = STATUS_ACCESS_DENIED;
498 try_return(RC);
499 }
500 // We need EXCLUSIVE access to Vcb to avoid parallel calls to UDFVerifyVcb()
501 UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
502 AcquiredVcb = TRUE;
503
504 // Disk based file systems might decide to verify the logical volume
505 // (if required and only if removable media are supported) at this time
506 RC = UDFVerifyVcb(PtrIrpContext,Vcb);
507 if(!NT_SUCCESS(RC))
508 try_return(RC);
509
510 UDFConvertExclusiveToSharedLite(&(Vcb->VCBResource));
511
512 ASSERT(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED);
513
514 // We fail in the following cases for Read-Only volumes
515 // - Open a target directory.
516 // - Create a file.
517 if(
518 (
519 ((Vcb->origIntegrityType == INTEGRITY_TYPE_OPEN) &&
520 (Vcb->CompatFlags & UDF_VCB_IC_DIRTY_RO))
521 #ifndef UDF_READ_ONLY_BUILD
522 || (Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_READ_ONLY)
523 #endif //UDF_READ_ONLY_BUILD
524 ) &&
525 (DeleteOnCloseSpecified ||
526 OpenTargetDirectory ||
527 (RequestedDisposition == FILE_CREATE) ||
528 (RequestedDisposition == FILE_OVERWRITE) ||
529 (RequestedDisposition == FILE_OVERWRITE_IF) ||
530 (RequestedDisposition == FILE_SUPERSEDE) ||
531 AllocationSize) ) {
532 ReturnedInformation = 0;
533 AdPrint((" Write protected or dirty\n"));
534 try_return(RC = STATUS_MEDIA_WRITE_PROTECTED);
535 }
536
537 /* if(DesiredAccess & (FILE_READ_EA | FILE_WRITE_EA)) {
538 ReturnedInformation = 0;
539 AdPrint((" EAs not supported\n"));
540 try_return(RC = STATUS_ACCESS_DENIED);
541 }*/
542
543 // ****************
544 // If a Volume open is requested, satisfy it now
545 // ****************
546 if (!(PtrNewFileObject->FileName.Length) && (!PtrRelatedFileObject ||
547 (PtrRelatedFCB->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB))) {
548
549 BOOLEAN UndoLock = FALSE;
550
551 AdPrint((" Opening Volume\n"));
552 // If the supplied file name is NULL *and* either there exists
553 // no related file object *or* if a related file object was supplied
554 // but it too refers to a previously opened instance of a logical
555 // volume, this open must be for a logical volume.
556
557 // Note: the FSD might decide to do "special" things (whatever they
558 // might be) in response to an open request for the logical volume.
559
560 // Logical volume open requests are done primarily to get/set volume
561 // information, lock the volume, dismount the volume (using the IOCTL
562 // FSCTL_DISMOUNT_VOLUME) etc.
563
564 // If a volume open is requested, perform checks to ensure that
565 // invalid options have not also been specified ...
566 if ((OpenTargetDirectory) || (PtrExtAttrBuffer)) {
567 try_return(RC = STATUS_INVALID_PARAMETER);
568 }
569
570 if (DirectoryOnlyRequested) {
571 // a volume is not a directory
572 try_return(RC = STATUS_NOT_A_DIRECTORY);
573 }
574
575 #ifndef UDF_READ_ONLY_BUILD
576 if (DeleteOnCloseSpecified) {
577 // delete volume.... hmm
578 try_return(RC = STATUS_CANNOT_DELETE);
579 }
580
581 if ((RequestedDisposition != FILE_OPEN) && (RequestedDisposition != FILE_OPEN_IF)) {
582 // cannot create a new volume, I'm afraid ...
583 try_return(RC = STATUS_ACCESS_DENIED);
584 }
585 #endif //UDF_READ_ONLY_BUILD
586
587 UDFPrint((" ShareAccess %x, DesiredAccess %x\n", ShareAccess, DesiredAccess));
588 /*
589 if(!(ShareAccess & (FILE_SHARE_WRITE | FILE_SHARE_DELETE)) &&
590 !(DesiredAccess & (FILE_GENERIC_WRITE & ~SYNCHRONIZE)) &&
591 (ShareAccess & FILE_SHARE_READ) ) {
592 */
593 if(!(DesiredAccess & ((GENERIC_WRITE | FILE_GENERIC_WRITE) & ~(SYNCHRONIZE | READ_CONTROL))) &&
594 (ShareAccess & FILE_SHARE_READ) ) {
595 UDFPrint((" R/O volume open\n"));
596 } else {
597
598 UDFPrint((" R/W volume open\n"));
599 if(Vcb->VCBFlags & UDF_VCB_FLAGS_MEDIA_READ_ONLY) {
600 UDFPrint((" media-ro\n"));
601 try_return(RC = STATUS_MEDIA_WRITE_PROTECTED);
602 }
603 }
604
605 if(!(ShareAccess & (FILE_SHARE_WRITE | FILE_SHARE_DELETE)) &&
606 !(DesiredAccess & ((GENERIC_WRITE | FILE_GENERIC_WRITE) & ~(SYNCHRONIZE | READ_CONTROL))) &&
607 (ShareAccess & FILE_SHARE_READ) ) {
608 // do nothing
609 } else {
610
611 if(!(ShareAccess & FILE_SHARE_READ) ||
612 (DesiredAccess & ((GENERIC_WRITE | FILE_GENERIC_WRITE) & ~(SYNCHRONIZE | READ_CONTROL))) ) {
613 // As soon as OpenVolume flushes the volume
614 // we should complete all pending requests (Close)
615
616 UDFPrint((" set UDF_IRP_CONTEXT_FLUSH2_REQUIRED\n"));
617 PtrIrpContext->IrpContextFlags |= UDF_IRP_CONTEXT_FLUSH2_REQUIRED;
618
619 /*
620 UDFInterlockedIncrement((PLONG)&(Vcb->VCBOpenCount));
621 UDFReleaseResource(&(Vcb->VCBResource));
622 AcquiredVcb = FALSE;
623
624 if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK)) {
625 UDFCloseAllSystemDelayedInDir(Vcb, Vcb->RootDirFCB->FileInfo);
626 }
627 #ifdef UDF_DELAYED_CLOSE
628 UDFCloseAllDelayed(Vcb);
629 #endif //UDF_DELAYED_CLOSE
630
631 UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
632 AcquiredVcb = TRUE;
633 UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount));
634 */
635 }
636 }
637
638 // If the user does not want to share write or delete then we will try
639 // and take out a lock on the volume.
640 if(!(ShareAccess & (FILE_SHARE_WRITE | FILE_SHARE_DELETE))) {
641 // Do a quick check here for handles on exclusive open.
642 if ((Vcb->VCBHandleCount) &&
643 !(ShareAccess & FILE_SHARE_READ)) {
644 // Sharing violation
645 UDFPrint((" !FILE_SHARE_READ + open handles (%d)\n", Vcb->VCBHandleCount));
646 try_return(RC = STATUS_SHARING_VIOLATION);
647 }
648 if(PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_FLUSH2_REQUIRED) {
649
650 UDFPrint((" perform flush\n"));
651 PtrIrpContext->IrpContextFlags &= ~UDF_IRP_CONTEXT_FLUSH2_REQUIRED;
652
653 UDFInterlockedIncrement((PLONG)&(Vcb->VCBOpenCount));
654 UDFReleaseResource(&(Vcb->VCBResource));
655 AcquiredVcb = FALSE;
656
657 if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK)) {
658 UDFCloseAllSystemDelayedInDir(Vcb, Vcb->RootDirFCB->FileInfo);
659 }
660 #ifdef UDF_DELAYED_CLOSE
661 UDFCloseAllDelayed(Vcb);
662 #endif //UDF_DELAYED_CLOSE
663
664 UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
665 AcquiredVcb = TRUE;
666 UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount));
667
668 UDFFlushLogicalVolume(NULL, NULL, Vcb);
669
670 if((ShareAccess & FILE_SHARE_READ) &&
671 ((Vcb->VCBOpenCount - UDF_RESIDUAL_REFERENCE) != (Vcb->VCBOpenCountRO))) {
672 UDFPrint((" FILE_SHARE_READ + R/W handles: %d(%d) -> STATUS_SHARING_VIOLATION ?\n",
673 Vcb->VCBOpenCount - UDF_RESIDUAL_REFERENCE,
674 Vcb->VCBOpenCountRO));
675 /* we shall not check it here, let System do it in IoCheckShareAccess() */
676 //try_return(RC = STATUS_SHARING_VIOLATION);
677 }
678 }
679 // Lock the volume
680 if(!(ShareAccess & FILE_SHARE_READ)) {
681 UDFPrint((" set Lock\n"));
682 Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_LOCKED;
683 Vcb->VolumeLockFileObject = PtrNewFileObject;
684 UndoLock = TRUE;
685 } else
686 if(DesiredAccess & ((GENERIC_WRITE | FILE_GENERIC_WRITE) & ~(SYNCHRONIZE | READ_CONTROL))) {
687 UDFPrint((" set UDF_IRP_CONTEXT_FLUSH_REQUIRED\n"));
688 PtrIrpContext->IrpContextFlags |= UDF_IRP_CONTEXT_FLUSH_REQUIRED;
689 }
690 }
691
692 PtrNewFcb = (PtrUDFFCB)Vcb;
693 ASSERT(!(PtrNewFcb->FCBFlags & UDF_FCB_DELETE_ON_CLOSE));
694
695 RC = UDFOpenFile(Vcb, PtrNewFileObject, PtrNewFcb);
696 if (!NT_SUCCESS(RC))
697 goto op_vol_accs_dnd;
698
699 PtrNewCcb = (PtrUDFCCB)(PtrNewFileObject->FsContext2);
700 if(PtrNewCcb) PtrNewCcb->CCBFlags |= UDF_CCB_VOLUME_OPEN;
701 // Check _Security_
702 RC = UDFCheckAccessRights(NULL, AccessState, Vcb->RootDirFCB, PtrNewCcb, DesiredAccess, ShareAccess);
703 if (!NT_SUCCESS(RC)) {
704 AdPrint((" Access violation (Volume)\n"));
705 goto op_vol_accs_dnd;
706 }
707 // Check _ShareAccess_
708 RC = UDFCheckAccessRights(PtrNewFileObject, AccessState, PtrNewFcb, PtrNewCcb, DesiredAccess, ShareAccess);
709 if(!NT_SUCCESS(RC)) {
710 AdPrint((" Sharing violation (Volume)\n"));
711 op_vol_accs_dnd:
712 if(UndoLock) {
713 Vcb->VCBFlags &= ~UDF_VCB_FLAGS_VOLUME_LOCKED;
714 Vcb->VolumeLockFileObject = NULL;
715 }
716 try_return(RC);
717 }
718
719 // NoBufferingSpecified = TRUE; See #define above
720 RequestedOptions |= FILE_NO_INTERMEDIATE_BUFFERING;
721
722 ReturnedInformation = FILE_OPENED;
723 UDFNotifyVolumeEvent(PtrNewFileObject, FSRTL_VOLUME_LOCK);
724 try_return(RC);
725 }
726
727 if((Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK) &&
728 (!(Vcb->CompatFlags & UDF_VCB_IC_SHOW_BLANK_CD) || UDFGlobalData.AutoFormatCount)) {
729 ReturnedInformation = 0;
730 AdPrint((" Can't open anything on blank volume ;)\n"));
731 try_return(RC = STATUS_OBJECT_NAME_NOT_FOUND);
732 }
733
734 if(UdfIllegalFcbAccess(Vcb,DesiredAccess)) {
735 ReturnedInformation = 0;
736 AdPrint((" Illegal share access\n"));
737 try_return(RC = STATUS_ACCESS_DENIED);
738 }
739 // we could mount blank R/RW media in order to allow
740 // user-mode applications to get access with Write privileges
741 ASSERT(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED);
742
743 // we should check appropriate privilege if OpenForBackup requested
744 if(OpenForBackup) {
745 if (!SeSinglePrivilegeCheck(SeExports->SeBackupPrivilege, UserMode)) {
746 try_return(RC = STATUS_PRIVILEGE_NOT_HELD);
747 }
748 }
749
750 // The FSD might wish to implement the open-by-id option. The "id"
751 // is some unique numerical representation of the on-disk object.
752 // The caller then therefore give us this file id and the FSD
753 // should be completely capable of "opening" the object (it must
754 // exist since the caller received an id for the object from the
755 // FSD in a "query file" call ...
756
757 // If the file has been deleted in the meantime, we'll return
758 // "not found"
759
760 // ****************
761 // Open by FileID
762 // ****************
763 if (OpenByFileId) {
764 // perform the open ...
765 PUNICODE_STRING TmpPath;
766 LONGLONG Id;
767
768 UDFPrint((" open by File ID\n"));
769 if(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK) {
770 ReturnedInformation = 0;
771 AdPrint((" Can't open by FileID on blank volume ;)\n"));
772 try_return(RC = STATUS_OBJECT_NAME_NOT_FOUND);
773 }
774
775 if (TargetObjectName.Length != sizeof(FILE_ID)) {
776 AdPrint((" Invalid file ID\n"));
777 try_return(RC = STATUS_INVALID_PARAMETER);
778 }
779 Id = *((FILE_ID*)(TargetObjectName.Buffer));
780 AdPrint((" Opening by ID %8.8x%8.8x\n", (ULONG)(Id>>32), (ULONG)Id));
781 if ((RequestedDisposition != FILE_OPEN) &&
782 (RequestedDisposition != FILE_OPEN_IF)) {
783 AdPrint((" Illegal disposition for ID open\n"));
784 try_return(RC = STATUS_ACCESS_DENIED);
785 }
786
787 RC = UDFGetOpenParamsByFileId(Vcb, Id, &TmpPath, &IgnoreCase);
788 if(!NT_SUCCESS(RC)) {
789 AdPrint((" ID open failed\n"));
790 try_return(RC);
791 }
792 // simulate absolute path open
793 /* if(!NT_SUCCESS(RC = MyInitUnicodeString(&TargetObjectName, L"")) ||
794 !NT_SUCCESS(RC = MyAppendUnicodeStringToStringTag(&TargetObjectName, TmpPath, MEM_USABS_TAG))) {*/
795 if(!NT_SUCCESS(RC = MyCloneUnicodeString(&TargetObjectName, TmpPath))) {
796 AdPrint((" Init String failed\n"));
797 try_return(RC);
798 }
799 //ASSERT(TargetObjectName.Buffer);
800 AbsolutePathName = TargetObjectName;
801 PtrRelatedFileObject = NULL;
802 } else
803 // ****************
804 // Relative open
805 // ****************
806 // Now determine the starting point from which to begin the parsing
807 if (PtrRelatedFileObject) {
808 // We have a user supplied related file object.
809 // This implies a "relative" open i.e. relative to the directory
810 // represented by the related file object ...
811
812 UDFPrint((" PtrRelatedFileObject %x, FCB %x\n", PtrRelatedFileObject, PtrRelatedFCB));
813 // Note: The only purpose FSD implementations ever have for
814 // the related file object is to determine whether this
815 // is a relative open or not. At all other times (including
816 // during I/O operations), this field is meaningless from
817 // the FSD's perspective.
818 if (!(PtrRelatedFCB->FCBFlags & UDF_FCB_DIRECTORY)) {
819 // we must have a directory as the "related" object
820 RC = STATUS_INVALID_PARAMETER;
821 AdPrint((" Related object must be a directory\n"));
822 AdPrint((" Flags %x\n", PtrRelatedFCB->FCBFlags));
823 _SEH2_TRY {
824 AdPrint((" ObjName %x, ", PtrRelatedFCB->FCBName->ObjectName));
825 AdPrint((" Name %S\n", PtrRelatedFCB->FCBName->ObjectName.Buffer));
826 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
827 AdPrint((" exception when printing name\n"));
828 } _SEH2_END;
829 try_return(RC);
830 }
831
832 // So we have a directory, ensure that the name begins with
833 // a "\" i.e. begins at the root and does *not* begin with a "\\"
834 // NOTE: This is just an example of the kind of path-name string
835 // validation that a FSD must do. Although the remainder of
836 // the code may not include such checks, any commercial
837 // FSD *must* include such checking (no one else, including
838 // the I/O Manager will perform checks on the FSD's behalf)
839 if (!(RelatedObjectName.Length) || (RelatedObjectName.Buffer[0] != L'\\')) {
840 AdPrint((" Wrong pathname (1)\n"));
841 RC = STATUS_INVALID_PARAMETER;
842 try_return(RC);
843 }
844 // similarly, if the target file name starts with a "\", it
845 // is wrong since the target file name can no longer be absolute
846 ASSERT(TargetObjectName.Buffer || !TargetObjectName.Length);
847 if (TargetObjectName.Length && (TargetObjectName.Buffer[0] == L'\\')) {
848 AdPrint((" Wrong pathname (2)\n"));
849 RC = STATUS_INVALID_PARAMETER;
850 try_return(RC);
851 }
852 // Create an absolute path-name. We could potentially use
853 // the absolute path-name if we cache previously opened
854 // file/directory object names.
855 /* if(!NT_SUCCESS(RC = MyInitUnicodeString(&AbsolutePathName, L"")) ||
856 !NT_SUCCESS(RC MyAppendUnicodeStringToStringTag(&AbsolutePathName, &RelatedObjectName, MEM_USABS_TAG)))*/
857 if(!NT_SUCCESS(RC = MyCloneUnicodeString(&AbsolutePathName, &RelatedObjectName)))
858 try_return(RC);
859 if(RelatedObjectName.Length &&
860 (RelatedObjectName.Buffer[ (RelatedObjectName.Length/sizeof(WCHAR)) - 1 ] != L'\\')) {
861 RC = MyAppendUnicodeToString(&AbsolutePathName, L"\\");
862 if(!NT_SUCCESS(RC)) try_return(RC);
863 }
864 if(!AbsolutePathName.Length ||
865 (AbsolutePathName.Buffer[ (AbsolutePathName.Length/sizeof(WCHAR)) - 1 ] != L'\\')) {
866 ASSERT(TargetObjectName.Buffer);
867 if(TargetObjectName.Length && TargetObjectName.Buffer[0] != L'\\') {
868 RC = MyAppendUnicodeToString(&AbsolutePathName, L"\\");
869 if(!NT_SUCCESS(RC)) try_return(RC);
870 }
871 }
872 //ASSERT(TargetObjectName.Buffer);
873 RC = MyAppendUnicodeStringToStringTag(&AbsolutePathName, &TargetObjectName, MEM_USABS_TAG);
874 if(!NT_SUCCESS(RC))
875 try_return(RC);
876
877 } else {
878 // ****************
879 // Absolute open
880 // ****************
881 // The suplied path-name must be an absolute path-name i.e.
882 // starting at the root of the file system tree
883 UDFPrint((" Absolute open\n"));
884 ASSERT(TargetObjectName.Buffer);
885 if (!TargetObjectName.Length || TargetObjectName.Buffer[0] != L'\\') {
886 AdPrint((" Wrong target name (1)\n"));
887 try_return(RC = STATUS_INVALID_PARAMETER);
888 }
889 /* if(!NT_SUCCESS(RC = MyInitUnicodeString(&AbsolutePathName, L"")) ||
890 !NT_SUCCESS(RC = MyAppendUnicodeStringToStringTag(&AbsolutePathName, &TargetObjectName, MEM_USABS_TAG)))*/
891 ASSERT(TargetObjectName.Buffer);
892 if(!NT_SUCCESS(RC = MyCloneUnicodeString(&AbsolutePathName, &TargetObjectName)))
893 try_return(RC);
894 }
895 // Win 32 protection :)
896 if ((AbsolutePathName.Length >= sizeof(WCHAR)*2) &&
897 (AbsolutePathName.Buffer[1] == L'\\') &&
898 (AbsolutePathName.Buffer[0] == L'\\')) {
899
900 // If there are still two beginning backslashes, the name is bogus.
901 if ((AbsolutePathName.Length > 2*sizeof(WCHAR)) &&
902 (AbsolutePathName.Buffer[2] == L'\\')) {
903 AdPrint((" Wrong target name (2)\n"));
904 try_return (RC = STATUS_OBJECT_NAME_INVALID);
905 }
906 // Slide the name down in the buffer.
907 RtlMoveMemory( AbsolutePathName.Buffer,
908 AbsolutePathName.Buffer + 1,
909 AbsolutePathName.Length ); // .Length includes
910 // NULL-terminator
911 AbsolutePathName.Length -= sizeof(WCHAR);
912 }
913 if ( (AbsolutePathName.Length > sizeof(WCHAR) ) &&
914 (AbsolutePathName.Buffer[ (AbsolutePathName.Length/sizeof(WCHAR)) - 1 ] == L'\\') ) {
915
916 AbsolutePathName.Length -= sizeof(WCHAR);
917 }
918 // TERMINATOR (2) ;)
919 AbsolutePathName.Buffer[AbsolutePathName.Length/sizeof(WCHAR)] = 0;
920
921 // Sometimes W2000 decides to duplicate handle of
922 // already opened File/Dir. In this case it sends us
923 // RelatedFileObject & specifies zero-filled RelativePath
924 if(!TargetObjectName.Length) {
925 TargetObjectName = AbsolutePathName;
926 OpenExisting = TRUE;
927 }
928 //ASSERT(TargetObjectName.Buffer);
929
930 // ****************
931 // First, check if the caller simply wishes to open the Root
932 // of the file system tree.
933 // ****************
934 if (AbsolutePathName.Length == sizeof(WCHAR)) {
935 AdPrint((" Opening RootDir\n"));
936 // this is an open of the root directory, ensure that the caller
937 // has not requested a file only
938 if (FileOnlyRequested || (RequestedDisposition == FILE_SUPERSEDE) ||
939 (RequestedDisposition == FILE_OVERWRITE) ||
940 (RequestedDisposition == FILE_OVERWRITE_IF)) {
941 AdPrint((" Can't overwrite RootDir\n"));
942 RC = STATUS_FILE_IS_A_DIRECTORY;
943 try_return(RC);
944 }
945
946 #if 0
947 CollectStatistics(Vcb, MetaDataReads);
948 #endif
949
950 if (DeleteOnCloseSpecified) {
951 // delete RootDir.... rather strange idea... I dislike it
952 AdPrint((" Can't delete RootDir\n"));
953 try_return(RC = STATUS_CANNOT_DELETE);
954 }
955
956 PtrNewFcb = Vcb->RootDirFCB;
957 RC = UDFOpenFile(Vcb, PtrNewFileObject, PtrNewFcb);
958 if(!NT_SUCCESS(RC)) try_return(RC);
959 // DbgPrint("UDF: Open/Create RootDir : ReferenceCount %x\n",PtrNewFcb->ReferenceCount);
960 UDFReferenceFile__(PtrNewFcb->FileInfo);
961 PtrNewCcb = (PtrUDFCCB)(PtrNewFileObject->FsContext2);
962 TreeLength = 1;
963
964 RC = UDFCheckAccessRights(PtrNewFileObject, AccessState, PtrNewFcb, PtrNewCcb, DesiredAccess, ShareAccess);
965 if(!NT_SUCCESS(RC)) {
966 AdPrint((" Access/Sharing violation (RootDir)\n"));
967 try_return(RC);
968 }
969
970 ReturnedInformation = FILE_OPENED;
971
972 try_return(RC);
973 } // end of OpenRootDir
974
975 _SEH2_TRY {
976 AdPrint((" Opening file %ws %8.8x\n",AbsolutePathName.Buffer, PtrNewFileObject));
977 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
978 AdPrint((" Exception when printing FN\n"));
979 } _SEH2_END;
980 // ****************
981 // Check if we have DuplicateHandle (or Reopen) request
982 // ****************
983 if(OpenExisting) {
984
985 // BrutePoint();
986 // We don't handle OpenTargetDirectory in this case
987 if(OpenTargetDirectory)
988 try_return(RC = STATUS_INVALID_PARAMETER);
989
990 // Init environment to simulate normal open procedure behavior
991 /* if(!NT_SUCCESS(RC = MyInitUnicodeString(&LocalPath, L"")) ||
992 !NT_SUCCESS(RC = MyAppendUnicodeStringToStringTag(&LocalPath, &TargetObjectName, MEM_USLOC_TAG)))*/
993 ASSERT(TargetObjectName.Buffer);
994 if(!NT_SUCCESS(RC = MyCloneUnicodeString(&LocalPath, &TargetObjectName)))
995 try_return(RC);
996
997 ASSERT(PtrRelatedFCB);
998 RelatedFileInfo = PtrRelatedFCB->FileInfo;
999
1000 RC = STATUS_SUCCESS;
1001 NewFileInfo =
1002 LastGoodFileInfo = RelatedFileInfo;
1003
1004 RelatedFileInfo =
1005 OldRelatedFileInfo = RelatedFileInfo->ParentFile;
1006 PtrRelatedFCB = PtrRelatedFCB->ParentFcb;
1007 // prevent releasing parent structures
1008 UDFAcquireParent(RelatedFileInfo, &Res1, &Res2);
1009 TreeLength++;
1010
1011 if(Res1) UDFReleaseResource(Res1);
1012 if(Res2) UDFReleaseResource(Res2);
1013
1014 UDF_CHECK_PAGING_IO_RESOURCE(RelatedFileInfo->Fcb->NTRequiredFCB);
1015 UDFAcquireResourceExclusive(Res2 = &(RelatedFileInfo->Fcb->NTRequiredFCB->MainResource),TRUE);
1016 PtrNewFcb = NewFileInfo->Fcb;
1017
1018 UDF_CHECK_PAGING_IO_RESOURCE(PtrNewFcb->NTRequiredFCB);
1019 UDFAcquireResourceExclusive(Res1 = &(PtrNewFcb->NTRequiredFCB->MainResource),TRUE);
1020 UDFReferenceFile__(NewFileInfo);
1021 TreeLength++;
1022
1023 goto AlreadyOpened;
1024 }
1025
1026 if(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK) {
1027 ReturnedInformation = 0;
1028 AdPrint((" Can't open File on blank volume ;)\n"));
1029 try_return(RC = STATUS_OBJECT_NAME_NOT_FOUND);
1030 }
1031
1032 //AdPrint((" Opening file %ws %8.8x\n",AbsolutePathName.Buffer, PtrNewFileObject));
1033
1034 if(AbsolutePathName.Length > UDF_X_PATH_LEN*sizeof(WCHAR)) {
1035 try_return(RC = STATUS_OBJECT_NAME_INVALID);
1036 }
1037
1038 // validate path specified
1039 // (sometimes we can see here very strange characters ;)
1040 if(!UDFIsNameValid(&AbsolutePathName, &StreamOpen, &SNameIndex)) {
1041 AdPrint((" Absolute path is not valid\n"));
1042 try_return(RC = STATUS_OBJECT_NAME_INVALID);
1043 }
1044 if(StreamOpen && !UDFStreamsSupported(Vcb)) {
1045 try_return(RC = STATUS_OBJECT_NAME_INVALID);
1046 }
1047
1048 RC = MyInitUnicodeString(&LocalPath, L"");
1049 if(!NT_SUCCESS(RC))
1050 try_return(RC);
1051 if (PtrRelatedFileObject) {
1052 // Our "start directory" is the one identified
1053 // by the related file object
1054 RelatedFileInfo = PtrRelatedFCB->FileInfo;
1055 if(RelatedFileInfo != Vcb->RootDirFCB->FileInfo) {
1056 RC = MyAppendUnicodeStringToStringTag(&LocalPath, &(PtrRelatedFCB->FCBName->ObjectName), MEM_USLOC_TAG);
1057 if(!NT_SUCCESS(RC))
1058 try_return(RC);
1059 }
1060 if(TargetObjectName.Buffer != AbsolutePathName.Buffer) {
1061 ASSERT(TargetObjectName.Buffer);
1062 if(!NT_SUCCESS(RC = MyCloneUnicodeString(&TailName, &TargetObjectName))) {
1063 AdPrint((" Init String 'TargetObjectName' failed\n"));
1064 try_return(RC);
1065 }
1066 TailNameBuffer = TailName.Buffer;
1067 } else {
1068 TailName = AbsolutePathName;
1069 }
1070 } else {
1071 // Start at the root of the file system
1072 RelatedFileInfo = Vcb->RootDirFCB->FileInfo;
1073 TailName = AbsolutePathName;
1074 }
1075
1076 if(StreamOpen) {
1077 StreamName = AbsolutePathName;
1078 StreamName.Buffer += SNameIndex;
1079 StreamName.Length -= (USHORT)SNameIndex*sizeof(WCHAR);
1080 // if StreamOpen specified & stream name starts with NULL character
1081 // we should create Stream Dir at first
1082 TailName.Length -= (AbsolutePathName.Length - (USHORT)SNameIndex*sizeof(WCHAR));
1083 AbsolutePathName.Length = (USHORT)SNameIndex*sizeof(WCHAR);
1084 }
1085 CurName.MaximumLength = TailName.MaximumLength;
1086
1087 RC = STATUS_SUCCESS;
1088 LastGoodName.Length = 0;
1089 LastGoodFileInfo = RelatedFileInfo;
1090 // reference RelatedObject to prevent releasing parent structures
1091 UDFAcquireParent(RelatedFileInfo, &Res1, &Res2);
1092 TreeLength++;
1093
1094 // go into a loop parsing the supplied name
1095
1096 // Note that we may have to "open" intermediate directory objects
1097 // while traversing the path. We should __try to reuse existing code
1098 // whenever possible therefore we should consider using a common
1099 // open routine regardless of whether the open is on behalf of the
1100 // caller or an intermediate (internal) open performed by the driver.
1101
1102 // ****************
1103 // now we'll parse path to desired file
1104 // ****************
1105
1106 while (TRUE) {
1107
1108 // remember last 'good' ('good' means NO ERRORS before) path tail
1109 if(NT_SUCCESS(RC)) {
1110 LastGoodTail = TailName;
1111 while(LastGoodTail.Buffer[0] == L'\\') {
1112 LastGoodTail.Buffer++;
1113 LastGoodTail.Length -= sizeof(WCHAR);
1114 }
1115 }
1116 // get next path part...
1117 TmpBuffer = TailName.Buffer;
1118 TailName.Buffer = UDFDissectName(TailName.Buffer,&(CurName.Length) );
1119 TailName.Length -= (USHORT)((ULONG_PTR)(TailName.Buffer) - (ULONG_PTR)TmpBuffer);
1120 CurName.Buffer = TailName.Buffer - CurName.Length;
1121 CurName.Length *= sizeof(WCHAR);
1122 CurName.MaximumLength = CurName.Length + sizeof(WCHAR);
1123 // check if we have already opened the component before last one
1124 // in this case OpenTargetDir request will be served in a special
1125 // way...
1126 if(OpenTargetDirectory && NT_SUCCESS(RC) && !TailName.Length) {
1127 // check if we should open SDir..
1128 if(!StreamOpen ||
1129 (TailName.Buffer[0]!=L':')) {
1130 // no, we should not. Continue with OpenTargetDir
1131 break;
1132 }
1133 }
1134
1135 if( CurName.Length &&
1136 (NT_SUCCESS(RC) || !StreamOpen)) {
1137 // ...wow! non-zero! try to open!
1138 if(!NT_SUCCESS(RC)) {
1139 AdPrint((" Error opening path component\n"));
1140 // we haven't reached last name part... hm..
1141 // probably, the path specified is invalid..
1142 // or we had a hard error... What else can we do ?
1143 // Only say ..CK OFF !!!!
1144 if(RC == STATUS_OBJECT_NAME_NOT_FOUND)
1145 RC = STATUS_OBJECT_PATH_NOT_FOUND;
1146 try_return(RC);
1147 }
1148
1149 ASSERT_REF(RelatedFileInfo->Fcb->ReferenceCount >= RelatedFileInfo->RefCount);
1150
1151 if(RelatedFileInfo && (TreeLength>1)) {
1152 // it was an internal Open operation. Thus, assume
1153 // RelatedFileInfo's Fcb to be valid
1154 RelatedFileInfo->Fcb->NTRequiredFCB->NtReqFCBFlags |= UDF_NTREQ_FCB_VALID;
1155 RelatedFileInfo->Fcb->FCBFlags |= UDF_FCB_VALID;
1156 }
1157 // check path fragment size
1158 if(CurName.Length > UDF_X_NAME_LEN * sizeof(WCHAR)) {
1159 AdPrint((" Path component is too long\n"));
1160 try_return(RC = STATUS_OBJECT_NAME_INVALID);
1161 }
1162 // ...and now release previously acquired objects,
1163 if(Res1) UDFReleaseResource(Res1);
1164 if(Res2) {
1165 UDFReleaseResource(Res2);
1166 Res2 = NULL;
1167 }
1168 // acquire new _parent_ directory & try to open what
1169 // we want.
1170
1171 UDF_CHECK_PAGING_IO_RESOURCE(RelatedFileInfo->Fcb->NTRequiredFCB);
1172 UDFAcquireResourceExclusive(Res1 = &(RelatedFileInfo->Fcb->NTRequiredFCB->MainResource),TRUE);
1173
1174 // check traverse rights
1175 RC = UDFCheckAccessRights(NULL, NULL, RelatedFileInfo->Fcb, PtrRelatedCCB, FILE_TRAVERSE, 0);
1176 if(!NT_SUCCESS(RC)) {
1177 NewFileInfo = NULL;
1178 AdPrint((" Traverse check failed\n"));
1179 goto Skip_open_attempt;
1180 }
1181 // check if we should open normal File/Dir or SDir
1182 if(CurName.Buffer[0] != ':') {
1183 // standard open, nothing interesting....
1184 RC = UDFOpenFile__(Vcb,
1185 IgnoreCase,TRUE,&CurName,
1186 RelatedFileInfo,&NewFileInfo,NULL);
1187 if(RC == STATUS_FILE_DELETED) {
1188 // file has gone, but system still remembers it...
1189 NewFileInfo = NULL;
1190 AdPrint((" File deleted\n"));
1191 RC = STATUS_ACCESS_DENIED;
1192 #ifdef UDF_DBG
1193 } else
1194 if(RC == STATUS_NOT_A_DIRECTORY) {
1195 AdPrint((" Not a directory\n"));
1196 #endif // UDF_DBG
1197 } else
1198 if(RC == STATUS_SHARING_PAUSED) {
1199 AdPrint((" Dloc is being initialized\n"));
1200 BrutePoint();
1201 RC = STATUS_SHARING_VIOLATION;
1202 }
1203 } else {
1204 // And here we should open Stream Dir (if any, of cource)
1205 RC = UDFOpenStreamDir__(Vcb, RelatedFileInfo, &NewFileInfo);
1206 if(NT_SUCCESS(RC)) {
1207 SuccessOpen_SDir:
1208 // this indicates that we needn't Stream Dir creation
1209 StreamExists = TRUE;
1210 StreamName.Buffer++;
1211 StreamName.Length-=sizeof(WCHAR);
1212 // update TailName
1213 TailName = StreamName;
1214 } else
1215 if(RC == STATUS_NOT_FOUND) {
1216 #ifndef UDF_READ_ONLY_BUILD
1217 // Stream Dir doesn't exist, but caller wants it to be
1218 // created. Lets try to help him...
1219 if((RequestedDisposition == FILE_CREATE) ||
1220 (RequestedDisposition == FILE_OPEN_IF) ||
1221 (RequestedDisposition == FILE_OVERWRITE_IF) ||
1222 OpenTargetDirectory ) {
1223 RC = UDFCreateStreamDir__(Vcb, RelatedFileInfo, &NewFileInfo);
1224 if(NT_SUCCESS(RC))
1225 goto SuccessOpen_SDir;
1226 }
1227 #endif //UDF_READ_ONLY_BUILD
1228 }
1229 /* } else {
1230 AdPrint((" File deleted (2)\n"));
1231 RC = STATUS_ACCESS_DENIED;*/
1232 }
1233 #if 0
1234 CollectStatistics(Vcb, MetaDataReads);
1235 #endif
1236
1237 Skip_open_attempt:
1238
1239 // check if we have successfully opened path component
1240 if(NT_SUCCESS(RC)) {
1241 // Yesss !!!
1242 if (!(PtrNewFcb = NewFileInfo->Fcb)) {
1243 // It is a first open operation
1244 // Allocate new FCB
1245 // Here we set FileObject pointer to NULL to avoid
1246 // new CCB allocation
1247 RC = UDFFirstOpenFile(Vcb,
1248 NULL, &PtrNewFcb, RelatedFileInfo, NewFileInfo,
1249 &LocalPath, &CurName);
1250
1251 if(!NT_SUCCESS(RC)) {
1252 BrutePoint();
1253 AdPrint((" Can't perform FirstOpen\n"));
1254 UDFCloseFile__(Vcb, NewFileInfo);
1255 if(PtrNewFcb) UDFCleanUpFCB(PtrNewFcb);
1256 PtrNewFcb = NULL;
1257 NewFileInfo->Fcb = NULL;
1258 if(UDFCleanUpFile__(Vcb, NewFileInfo)) {
1259 MyFreePool__(NewFileInfo);
1260 NewFileInfo = NULL;
1261 }
1262 try_return(RC);
1263 }
1264 } else {
1265 // It is not a first open operation
1266 // Validate Fcb. It is possible to get
1267 // not completly initialized Fcb here.
1268 if(!(PtrNewFcb->FCBFlags & UDF_FCB_VALID)) {
1269 BrutePoint();
1270 AdPrint((" Fcb not valid\n"));
1271 UDFCloseFile__(Vcb, NewFileInfo);
1272 PtrNewFcb = NULL;
1273 if(UDFCleanUpFile__(Vcb, NewFileInfo)) {
1274 MyFreePool__(NewFileInfo);
1275 NewFileInfo = NULL;
1276 }
1277 try_return(RC = STATUS_ACCESS_DENIED);
1278 }
1279 }
1280 // Acquire newly opened File...
1281 Res2 = Res1;
1282 UDF_CHECK_PAGING_IO_RESOURCE(NewFileInfo->Fcb->NTRequiredFCB);
1283 UDFAcquireResourceExclusive(Res1 = &(NewFileInfo->Fcb->NTRequiredFCB->MainResource),TRUE);
1284 // ...and reference it
1285 UDFInterlockedIncrement((PLONG)&(PtrNewFcb->ReferenceCount));
1286 UDFInterlockedIncrement((PLONG)&(PtrNewFcb->NTRequiredFCB->CommonRefCount));
1287
1288 ASSERT_REF(PtrNewFcb->ReferenceCount >= NewFileInfo->RefCount);
1289 // update unwind information
1290 LastGoodFileInfo = NewFileInfo;
1291 LastGoodName = CurName;
1292 TreeLength++;
1293 // update current path
1294 if(!StreamOpen ||
1295 ((CurName.Buffer[0] != L':') &&
1296 (!LocalPath.Length || (LocalPath.Buffer[LocalPath.Length/sizeof(WCHAR)-1] != L':'))) ) {
1297 // we should not insert '\' before or after ':'
1298 ASSERT(!LocalPath.Length ||
1299 (LocalPath.Buffer[LocalPath.Length/2-1] != L'\\'));
1300 RC = MyAppendUnicodeToString(&LocalPath, L"\\");
1301 if(!NT_SUCCESS(RC)) try_return(RC);
1302 }
1303 RC = MyAppendUnicodeStringToStringTag(&LocalPath, &CurName, MEM_USLOC_TAG);
1304 if(!NT_SUCCESS(RC))
1305 try_return(RC);
1306 // DbgPrint("UDF: Open/Create File %ws : ReferenceCount %x\n",CurName.Buffer,PtrNewFcb->ReferenceCount);
1307 } else {
1308 AdPrint((" Can't open file\n"));
1309 // We have failed durring last Open attempt
1310 // Roll back to last good state
1311 PtrUDFNTRequiredFCB NtReqFcb = NULL;
1312 // Cleanup FileInfo if any
1313 if(NewFileInfo) {
1314 PtrNewFcb = NewFileInfo->Fcb;
1315 // acquire appropriate resource if possible
1316 if(PtrNewFcb &&
1317 PtrNewFcb->NTRequiredFCB) {
1318 NtReqFcb = PtrNewFcb->NTRequiredFCB;
1319 Res2 = Res1;
1320 UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
1321 UDFAcquireResourceExclusive(Res1 = &(NtReqFcb->MainResource),TRUE);
1322 }
1323 // cleanup pointer to Fcb in FileInfo to allow
1324 // UDF_INFO package release FileInfo if there are
1325 // no more references
1326 if(PtrNewFcb &&
1327 !PtrNewFcb->ReferenceCount &&
1328 !PtrNewFcb->OpenHandleCount) {
1329 NewFileInfo->Fcb = NULL;
1330 }
1331 // cleanup pointer to CommonFcb in Dloc to allow
1332 // UDF_INFO package release Dloc if there are
1333 // no more references
1334 if(NewFileInfo->Dloc &&
1335 !NewFileInfo->Dloc->LinkRefCount &&
1336 (!PtrNewFcb || !PtrNewFcb->ReferenceCount)) {
1337 NewFileInfo->Dloc->CommonFcb = NULL;
1338 }
1339 // try to release FileInfo
1340 if(UDFCleanUpFile__(Vcb, NewFileInfo)) {
1341 ASSERT(!PtrNewFcb);
1342 if(PtrNewFcb) {
1343 BrutePoint();
1344 UDFCleanUpFCB(PtrNewFcb);
1345 }
1346 MyFreePool__(NewFileInfo);
1347 } else {
1348 // if we can't release FileInfo
1349 // restore pointers to Fcb & CommonFcb in
1350 // FileInfo & Dloc
1351 NewFileInfo->Fcb = PtrNewFcb;
1352 if(NtReqFcb)
1353 NewFileInfo->Dloc->CommonFcb = NtReqFcb;
1354 }
1355 // forget about last FileInfo & Fcb,
1356 // further unwind staff needs only last good
1357 // structures
1358 PtrNewFcb = NULL;
1359 NewFileInfo = NULL;
1360 }
1361 }
1362
1363 // should return error if 'delete in progress'
1364 if(LastGoodFileInfo->Fcb->FCBFlags & (UDF_FCB_DELETE_ON_CLOSE |
1365 UDF_FCB_DELETED |
1366 UDF_FCB_POSTED_RENAME)) {
1367 AdPrint((" Return DeletePending (no err)\n"));
1368 try_return(RC = STATUS_DELETE_PENDING);
1369 }
1370 // update last good state information...
1371 OldRelatedFileInfo = RelatedFileInfo;
1372 RelatedFileInfo = NewFileInfo;
1373 // ...and go to the next open cycle
1374 } else {
1375 // ************
1376 if(StreamOpen && (RC == STATUS_NOT_FOUND))
1377 // handle SDir return code
1378 RC = STATUS_OBJECT_NAME_NOT_FOUND;
1379 if(RC == STATUS_OBJECT_NAME_NOT_FOUND) {
1380 // good path, but no such file.... Amen
1381 // break open loop and continue with Create
1382 break;
1383 }
1384 if (!NT_SUCCESS(RC)) {
1385 // Hard error or damaged data structures ...
1386 #ifdef UDF_DBG
1387 if((RC != STATUS_OBJECT_PATH_NOT_FOUND) &&
1388 (RC != STATUS_ACCESS_DENIED) &&
1389 (RC != STATUS_NOT_A_DIRECTORY)) {
1390 AdPrint((" Hard error or damaged data structures\n"));
1391 }
1392 #endif // UDF_DBG
1393 // ... and exit with error
1394 try_return(RC);
1395 }
1396 // discard changes for last successfully opened file
1397 UDFInterlockedDecrement((PLONG)&(PtrNewFcb->ReferenceCount));
1398 UDFInterlockedDecrement((PLONG)&(PtrNewFcb->NTRequiredFCB->CommonRefCount));
1399 RC = STATUS_SUCCESS;
1400 ASSERT(!OpenTargetDirectory);
1401 // break open loop and continue with Open
1402 // (Create will be skipped)
1403 break;
1404 }
1405 } // end of while(TRUE)
1406
1407 // ****************
1408 // If "open target directory" was specified
1409 // ****************
1410 if(OpenTargetDirectory) {
1411
1412 if(!UDFIsADirectory(LastGoodFileInfo)) {
1413 AdPrint((" Not a directory (2)\n"));
1414 RC = STATUS_NOT_A_DIRECTORY;
1415 }
1416 if(!NT_SUCCESS(RC) ||
1417 TailName.Length) {
1418 AdPrint((" Target name should not contain (back)slashes\n"));
1419 NewFileInfo = NULL;
1420 try_return(RC = STATUS_OBJECT_NAME_INVALID);
1421 }
1422
1423 NewFileInfo = LastGoodFileInfo;
1424 RtlCopyUnicodeString(&(PtrNewFileObject->FileName), &CurName);
1425
1426 // now we have to check if last component exists...
1427 if(NT_SUCCESS(RC = UDFFindFile__(Vcb, IgnoreCase,
1428 &CurName, RelatedFileInfo))) {
1429 // file exists, set this information in the Information field
1430 ReturnedInformation = FILE_EXISTS;
1431 AdPrint((" Open Target: FILE_EXISTS\n"));
1432 } else
1433 if(RC == STATUS_OBJECT_NAME_NOT_FOUND) {
1434 #ifdef UDF_DBG
1435 // check name. If there are '\\'s in TailName, some
1436 // directories in path specified do not exist
1437 for(TmpBuffer = LastGoodTail.Buffer; *TmpBuffer; TmpBuffer++) {
1438 if((*TmpBuffer) == L'\\') {
1439 ASSERT(FALSE);
1440 AdPrint((" Target name should not contain (back)slashes\n"));
1441 try_return(RC = STATUS_OBJECT_NAME_INVALID);
1442 }
1443 }
1444 #endif // UDF_DBG
1445 // Tell the I/O Manager that file does not exit
1446 ReturnedInformation = FILE_DOES_NOT_EXIST;
1447 AdPrint((" Open Target: FILE_DOES_NOT_EXIST\n"));
1448 RC = STATUS_SUCCESS; // is already set here
1449 } else {
1450 AdPrint((" Open Target: unexpected error\n"));
1451 NewFileInfo = NULL;
1452 try_return(RC = STATUS_OBJECT_NAME_INVALID);
1453 }
1454
1455 // RC = STATUS_SUCCESS; // is already set here
1456
1457 // Update the file object FsContext and FsContext2 fields
1458 // to reflect the fact that the parent directory of the
1459 // target has been opened
1460 PtrNewFcb = NewFileInfo->Fcb;
1461 UDFInterlockedDecrement((PLONG)&(PtrNewFcb->ReferenceCount));
1462 UDFInterlockedDecrement((PLONG)&(PtrNewFcb->NTRequiredFCB->CommonRefCount));
1463 RC = UDFOpenFile(Vcb, PtrNewFileObject, PtrNewFcb);
1464 ASSERT_REF(PtrNewFcb->ReferenceCount >= NewFileInfo->RefCount);
1465 if (!NT_SUCCESS(RC)) {
1466 AdPrint((" Can't perform OpenFile operation for target\n"));
1467 try_return(RC);
1468 }
1469 PtrNewCcb = (PtrUDFCCB)(PtrNewFileObject->FsContext2);
1470
1471 ASSERT(Res1);
1472 RC = UDFCheckAccessRights(PtrNewFileObject, AccessState, PtrNewFcb, PtrNewCcb, DesiredAccess, ShareAccess);
1473 if(!NT_SUCCESS(RC)) {
1474 AdPrint((" Access/Share access check failed (Open Target)\n"));
1475 }
1476
1477 try_return(RC);
1478 }
1479
1480 // ****************
1481 // should we CREATE a new file ?
1482 // ****************
1483 if (!NT_SUCCESS(RC)) {
1484 if (RC == STATUS_OBJECT_NAME_NOT_FOUND ||
1485 RC == STATUS_OBJECT_PATH_NOT_FOUND) {
1486 if( ((RequestedDisposition == FILE_OPEN) ||
1487 (RequestedDisposition == FILE_OVERWRITE)) /*&&
1488 (!StreamOpen || !StreamExists)*/ ){
1489 ReturnedInformation = FILE_DOES_NOT_EXIST;
1490 AdPrint((" File doesn't exist\n"));
1491 try_return(RC);
1492 }
1493 } else {
1494 // Any other operation return STATUS_ACCESS_DENIED.
1495 AdPrint((" Can't create due to unexpected error\n"));
1496 try_return(RC);
1497 }
1498 // Object was not found, create if requested
1499 if ((RequestedDisposition != FILE_CREATE) && (RequestedDisposition != FILE_OPEN_IF) &&
1500 (RequestedDisposition != FILE_OVERWRITE_IF) && (RequestedDisposition != FILE_SUPERSEDE)) {
1501 AdPrint((" File doesn't exist (2)\n"));
1502 try_return(RC);
1503 }
1504 // Check Volume ReadOnly attr
1505 #ifndef UDF_READ_ONLY_BUILD
1506 if((Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_READ_ONLY)) {
1507 #endif //UDF_READ_ONLY_BUILD
1508 ReturnedInformation = 0;
1509 AdPrint((" Write protected\n"));
1510 try_return(RC = STATUS_MEDIA_WRITE_PROTECTED);
1511 #ifndef UDF_READ_ONLY_BUILD
1512 }
1513 // Check r/o + delete on close
1514 if(DeleteOnCloseSpecified &&
1515 (FileAttributes & FILE_ATTRIBUTE_READONLY)) {
1516 AdPrint((" Can't create r/o file marked for deletion\n"));
1517 try_return(RC = STATUS_CANNOT_DELETE);
1518 }
1519
1520 // Create a new file/directory here ...
1521 if(StreamOpen)
1522 StreamName.Buffer[StreamName.Length/sizeof(WCHAR)] = 0;
1523 for(TmpBuffer = LastGoodTail.Buffer; *TmpBuffer; TmpBuffer++) {
1524 if((*TmpBuffer) == L'\\') {
1525 AdPrint((" Target name should not contain (back)slashes\n"));
1526 try_return(RC = STATUS_OBJECT_NAME_INVALID);
1527 }
1528 }
1529 if( DirectoryOnlyRequested &&
1530 ((IrpSp->Parameters.Create.FileAttributes & FILE_ATTRIBUTE_TEMPORARY) ||
1531 StreamOpen || FALSE)) {
1532 AdPrint((" Creation of _temporary_ directory not permited\n"));
1533 try_return(RC = STATUS_INVALID_PARAMETER);
1534 }
1535 // check access rights
1536 ASSERT(Res1);
1537 RC = UDFCheckAccessRights(NULL, NULL, OldRelatedFileInfo->Fcb, PtrRelatedCCB, DirectoryOnlyRequested ? FILE_ADD_SUBDIRECTORY : FILE_ADD_FILE, 0);
1538 if(!NT_SUCCESS(RC)) {
1539 AdPrint((" Creation of File/Dir not permitted\n"));
1540 try_return(RC);
1541 }
1542 // Note that a FCB structure will be allocated at this time
1543 // and so will a CCB structure. Assume that these are called
1544 // PtrNewFcb and PtrNewCcb respectively.
1545 // Further, note that since the file is being created, no other
1546 // thread can have the file stream open at this time.
1547 RelatedFileInfo = OldRelatedFileInfo;
1548
1549 RC = UDFCreateFile__(Vcb, IgnoreCase, &LastGoodTail, 0, 0,
1550 Vcb->UseExtendedFE || (StreamOpen && !StreamExists),
1551 (RequestedDisposition == FILE_CREATE), RelatedFileInfo, &NewFileInfo);
1552 if(!NT_SUCCESS(RC)) {
1553 AdPrint((" Creation error\n"));
1554 Creation_Err_1:
1555 if(NewFileInfo) {
1556 PtrNewFcb = NewFileInfo->Fcb;
1557 ASSERT(!PtrNewFcb);
1558 if(PtrNewFcb &&
1559 !PtrNewFcb->ReferenceCount &&
1560 !PtrNewFcb->OpenHandleCount) {
1561 NewFileInfo->Fcb = NULL;
1562 }
1563 if(NewFileInfo->Dloc &&
1564 !NewFileInfo->Dloc->LinkRefCount) {
1565 NewFileInfo->Dloc->CommonFcb = NULL;
1566 }
1567 if(UDFCleanUpFile__(Vcb, NewFileInfo)) {
1568 if(PtrNewFcb) {
1569 BrutePoint();
1570 UDFCleanUpFCB(PtrNewFcb);
1571 }
1572 MyFreePool__(NewFileInfo);
1573 PtrNewFcb = PtrNewFcb;
1574 } else {
1575 NewFileInfo->Fcb = PtrNewFcb;
1576 }
1577 PtrNewFcb = NULL;
1578 }
1579 try_return(RC);
1580 }
1581 // Update parent object
1582 if((Vcb->CompatFlags & UDF_VCB_IC_UPDATE_DIR_WRITE) &&
1583 PtrRelatedFCB &&
1584 PtrRelatedFileObject &&
1585 (PtrRelatedFCB->FileInfo == NewFileInfo->ParentFile)) {
1586 PtrRelatedFileObject->Flags |= (FO_FILE_MODIFIED | FO_FILE_SIZE_CHANGED);
1587 }
1588 #if 0
1589 CollectStatistics(Vcb, MetaDataWrites);
1590 #endif
1591
1592 if(DirectoryOnlyRequested) {
1593 // user wants the directory to be created
1594 RC = UDFRecordDirectory__(Vcb, NewFileInfo);
1595 if(!NT_SUCCESS(RC)) {
1596 AdPrint((" Can't transform to directory\n"));
1597 Undo_Create_1:
1598 if((RC != STATUS_FILE_IS_A_DIRECTORY) &&
1599 (RC != STATUS_NOT_A_DIRECTORY) &&
1600 (RC != STATUS_ACCESS_DENIED)) {
1601 UDFFlushFile__(Vcb, NewFileInfo);
1602 UDFUnlinkFile__(Vcb, NewFileInfo, TRUE);
1603 }
1604 UDFCloseFile__(Vcb, NewFileInfo);
1605 BrutePoint();
1606 goto Creation_Err_1;
1607 }
1608 #if 0
1609 CollectStatistics(Vcb, MetaDataWrites);
1610 #endif
1611 } else if(AllocationSize) {
1612 // set initial file size
1613 /* if(!NT_SUCCESS(RC = UDFResizeFile__(Vcb, NewFileInfo, AllocationSize))) {
1614 AdPrint((" Can't set initial file size\n"));
1615 goto Undo_Create_1;
1616 }
1617 CollectStatistics(Vcb, MetaDataWrites);*/
1618 }
1619
1620 if(StreamOpen && !StreamExists) {
1621
1622 // PHASE 0
1623
1624 // Open the newly created object (file)
1625 if (!(PtrNewFcb = NewFileInfo->Fcb)) {
1626 // It is a first open operation
1627 // Allocate new FCB
1628 // Here we set FileObject pointer to NULL to avoid
1629 // new CCB allocation
1630 RC = UDFFirstOpenFile(Vcb,
1631 NULL, &PtrNewFcb, RelatedFileInfo, NewFileInfo,
1632 &LocalPath, &LastGoodTail);
1633 if(!NT_SUCCESS(RC)) {
1634 AdPrint((" Can't perform FirstOpenFile operation for file to contain stream\n"));
1635 BrutePoint();
1636 UDFCleanUpFCB(NewFileInfo->Fcb);
1637 NewFileInfo->Fcb = NULL;
1638 goto Creation_Err_1;
1639 }
1640 } else {
1641 BrutePoint();
1642 }
1643
1644 // Update unwind information
1645 TreeLength++;
1646 LastGoodFileInfo = NewFileInfo;
1647 // update FCB tree
1648 RC = MyAppendUnicodeToString(&LocalPath, L"\\");
1649 if(!NT_SUCCESS(RC)) try_return(RC);
1650 RC = MyAppendUnicodeStringToStringTag(&LocalPath, &LastGoodTail, MEM_USLOC_TAG);
1651 if(!NT_SUCCESS(RC))
1652 goto Creation_Err_1;
1653 UDFInterlockedIncrement((PLONG)&(PtrNewFcb->ReferenceCount));
1654 UDFInterlockedIncrement((PLONG)&(PtrNewFcb->NTRequiredFCB->CommonRefCount));
1655 ASSERT_REF(PtrNewFcb->ReferenceCount >= NewFileInfo->RefCount);
1656 PtrNewFcb->NTRequiredFCB->NtReqFCBFlags |= UDF_NTREQ_FCB_VALID;
1657 PtrNewFcb->FCBFlags |= UDF_FCB_VALID;
1658
1659 UDFNotifyFullReportChange( Vcb, NewFileInfo,
1660 UDFIsADirectory(NewFileInfo) ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME,
1661 FILE_ACTION_ADDED);
1662
1663 // PHASE 1
1664
1665 // we need to create Stream Dir
1666 RelatedFileInfo = NewFileInfo;
1667 RC = UDFCreateStreamDir__(Vcb, RelatedFileInfo, &NewFileInfo);
1668 if(!NT_SUCCESS(RC)) {
1669 AdPrint((" Can't create SDir\n"));
1670 BrutePoint();
1671 goto Creation_Err_1;
1672 }
1673 #if 0
1674 CollectStatistics(Vcb, MetaDataWrites);
1675 #endif
1676
1677 // normalize stream name
1678 StreamName.Buffer++;
1679 StreamName.Length-=sizeof(WCHAR);
1680 // Open the newly created object
1681 if (!(PtrNewFcb = NewFileInfo->Fcb)) {
1682 // It is a first open operation
1683 // Allocate new FCB
1684 // Here we set FileObject pointer to NULL to avoid
1685 // new CCB allocation
1686 RC = UDFFirstOpenFile(Vcb,
1687 NULL, &PtrNewFcb, RelatedFileInfo, NewFileInfo,
1688 &LocalPath, &(UDFGlobalData.UnicodeStrSDir));
1689 } else {
1690 BrutePoint();
1691 }
1692 if(!NT_SUCCESS(RC)) {
1693 AdPrint((" Can't perform OpenFile operation for SDir\n"));
1694 BrutePoint();
1695 goto Creation_Err_1;
1696 }
1697
1698 // Update unwind information
1699 TreeLength++;
1700 LastGoodFileInfo = NewFileInfo;
1701 // update FCB tree
1702 RC = MyAppendUnicodeStringToStringTag(&LocalPath, &(UDFGlobalData.UnicodeStrSDir), MEM_USLOC_TAG);
1703 if(!NT_SUCCESS(RC)) {
1704 AdPrint((" Can't append UNC str\n"));
1705 BrutePoint();
1706 goto Creation_Err_1;
1707 }
1708 UDFInterlockedIncrement((PLONG)&(PtrNewFcb->ReferenceCount));
1709 UDFInterlockedIncrement((PLONG)&(PtrNewFcb->NTRequiredFCB->CommonRefCount));
1710 ASSERT_REF(PtrNewFcb->ReferenceCount >= NewFileInfo->RefCount);
1711 PtrNewFcb->NTRequiredFCB->NtReqFCBFlags |= UDF_NTREQ_FCB_VALID;
1712 PtrNewFcb->FCBFlags |= UDF_FCB_VALID;
1713
1714 // PHASE 2
1715
1716 // create stream
1717 RelatedFileInfo = NewFileInfo;
1718 RC = UDFCreateFile__(Vcb, IgnoreCase, &StreamName, 0, 0,
1719 Vcb->UseExtendedFE, (RequestedDisposition == FILE_CREATE),
1720 RelatedFileInfo, &NewFileInfo);
1721 if(!NT_SUCCESS(RC)) {
1722 AdPrint((" Can't create Stream\n"));
1723 BrutePoint();
1724 goto Creation_Err_1;
1725 }
1726 #if 0
1727 CollectStatistics(Vcb, MetaDataWrites);
1728 #endif
1729
1730 // Update unwind information
1731 LastGoodTail = StreamName;
1732 }
1733 // NT wants ARCHIVE bit to be set on Files
1734 if(!DirectoryOnlyRequested)
1735 FileAttributes |= FILE_ATTRIBUTE_ARCHIVE;
1736 // Open the newly created object
1737 if (!(PtrNewFcb = NewFileInfo->Fcb)) {
1738 // It is a first open operation
1739 #ifndef IFS_40
1740 // Set attributes for the file ...
1741 UDFAttributesToUDF(UDFDirIndex(UDFGetDirIndexByFileInfo(NewFileInfo),NewFileInfo->Index),
1742 NewFileInfo->Dloc->FileEntry, FileAttributes);
1743 #endif //IFS_40
1744 // Allocate new FCB
1745 // Here we set FileObject pointer to NULL to avoid
1746 // new CCB allocation
1747 RC = UDFFirstOpenFile(Vcb,
1748 PtrNewFileObject, &PtrNewFcb, RelatedFileInfo, NewFileInfo,
1749 &LocalPath, &LastGoodTail);
1750 } else {
1751 BrutePoint();
1752 }
1753
1754 if(!NT_SUCCESS(RC)) {
1755 AdPrint((" Can't perform OpenFile operation for file or stream\n"));
1756 BrutePoint();
1757 goto Undo_Create_1;
1758 }
1759
1760 PtrNewFcb->NTRequiredFCB->CommonFCBHeader.FileSize.QuadPart =
1761 PtrNewFcb->NTRequiredFCB->CommonFCBHeader.ValidDataLength.QuadPart = 0;
1762 if(AllocationSize) {
1763 // inform NT about size changes
1764 PtrNewFcb->NTRequiredFCB->CommonFCBHeader.AllocationSize.QuadPart = AllocationSize;
1765 MmPrint((" CcIsFileCached()\n"));
1766 if(CcIsFileCached(PtrNewFileObject)) {
1767 MmPrint((" CcSetFileSizes()\n"));
1768 BrutePoint();
1769 CcSetFileSizes(PtrNewFileObject, (PCC_FILE_SIZES)&(PtrNewFcb->NTRequiredFCB->CommonFCBHeader.AllocationSize));
1770 PtrNewFcb->NTRequiredFCB->NtReqFCBFlags |= UDF_NTREQ_FCB_MODIFIED;
1771 }
1772 }
1773
1774 // Update unwind information
1775 TreeLength++;
1776 LastGoodFileInfo = NewFileInfo;
1777
1778 // Set the Share Access for the file stream.
1779 // The FCBShareAccess field will be set by the I/O Manager.
1780 PtrNewCcb = (PtrUDFCCB)(PtrNewFileObject->FsContext2);
1781 RC = UDFSetAccessRights(PtrNewFileObject, AccessState, PtrNewFcb, PtrNewCcb, DesiredAccess, ShareAccess);
1782
1783 if(!NT_SUCCESS(RC)) {
1784 AdPrint((" Can't set Access Rights on Create\n"));
1785 BrutePoint();
1786 UDFFlushFile__(Vcb, NewFileInfo);
1787 UDFUnlinkFile__(Vcb, NewFileInfo, TRUE);
1788 try_return(RC);
1789 }
1790
1791 #ifdef IFS_40
1792 // Set attributes for the file ...
1793 UDFAttributesToUDF(UDFDirIndex(UDFGetDirIndexByFileInfo(NewFileInfo),NewFileInfo->Index),
1794 NewFileInfo->Dloc->FileEntry, FileAttributes);
1795 // It is rather strange for me, but NT requires us to allow
1796 // Create operation for r/o + WriteAccess, but denies all
1797 // the rest operations in this case. Thus, we should update
1798 // r/o flag in Fcb _after_ Access check :-/
1799 if(FileAttributes & FILE_ATTRIBUTE_READONLY)
1800 PtrNewFcb->FCBFlags |= UDF_FCB_READ_ONLY;
1801 #endif //IFS_40
1802 // We call the notify package to report that the
1803 // we have added a stream.
1804 if(UDFIsAStream(NewFileInfo)) {
1805 UDFNotifyFullReportChange( Vcb, NewFileInfo,
1806 FILE_NOTIFY_CHANGE_STREAM_NAME,
1807 FILE_ACTION_ADDED_STREAM );
1808 } else {
1809 UDFNotifyFullReportChange( Vcb, NewFileInfo,
1810 UDFIsADirectory(NewFileInfo) ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME,
1811 FILE_ACTION_ADDED);
1812 }
1813 /*#ifdef UDF_DBG
1814 {
1815 ULONG i;
1816 PDIR_INDEX_HDR hDirIndex = NewFileInfo->ParentFile->Dloc->DirIndex;
1817
1818 for(i=0;DirIndex[i].FName.Buffer;i++) {
1819 AdPrint(("%ws\n", DirIndex[i].FName.Buffer));
1820 }
1821 }
1822 #endif*/
1823 ReturnedInformation = FILE_CREATED;
1824
1825 try_return(RC);
1826 #endif //UDF_READ_ONLY_BUILD
1827
1828 }
1829
1830 AlreadyOpened:
1831
1832 // ****************
1833 // we have always STATUS_SUCCESS here
1834 // ****************
1835
1836 ASSERT(NewFileInfo != OldRelatedFileInfo);
1837 // A new CCB will be allocated.
1838 // Assume that this structure named PtrNewCcb
1839 RC = UDFOpenFile(Vcb, PtrNewFileObject, PtrNewFcb);
1840 if (!NT_SUCCESS(RC)) try_return(RC);
1841 PtrNewCcb = (PtrUDFCCB)(PtrNewFileObject->FsContext2);
1842
1843 if(RequestedDisposition == FILE_CREATE) {
1844 ReturnedInformation = FILE_EXISTS;
1845 AdPrint((" Object name collision\n"));
1846 try_return(RC = STATUS_OBJECT_NAME_COLLISION);
1847 }
1848
1849 NtReqFcb = PtrNewFcb->NTRequiredFCB;
1850 NtReqFcb->CommonFCBHeader.IsFastIoPossible = UDFIsFastIoPossible(PtrNewFcb);
1851
1852 // Check if caller wanted a directory only and target object
1853 // is not a directory, or caller wanted a file only and target
1854 // object is not a file ...
1855 if((PtrNewFcb->FCBFlags & UDF_FCB_DIRECTORY) && ((RequestedDisposition == FILE_SUPERSEDE) ||
1856 (RequestedDisposition == FILE_OVERWRITE) || (RequestedDisposition == FILE_OVERWRITE_IF) ||
1857 FileOnlyRequested)) {
1858 if(FileOnlyRequested) {
1859 AdPrint((" Can't open directory as a plain file\n"));
1860 } else {
1861 AdPrint((" Can't supersede directory\n"));
1862 }
1863 RC = STATUS_FILE_IS_A_DIRECTORY;
1864 try_return(RC);
1865 }
1866
1867 if(DirectoryOnlyRequested && !(PtrNewFcb->FCBFlags & UDF_FCB_DIRECTORY)) {
1868 AdPrint((" This is not a directory\n"));
1869 RC = STATUS_NOT_A_DIRECTORY;
1870 try_return(RC);
1871 }
1872
1873 if(DeleteOnCloseSpecified && (PtrNewFcb->FCBFlags & UDF_FCB_READ_ONLY)) {
1874 AdPrint((" Can't delete Read-Only file\n"));
1875 RC = STATUS_CANNOT_DELETE;
1876 try_return(RC);
1877 }
1878 // Check share access and fail if the share conflicts with an existing
1879 // open.
1880 ASSERT(Res1 != NULL);
1881 ASSERT(Res2 != NULL);
1882 RC = UDFCheckAccessRights(PtrNewFileObject, AccessState, PtrNewFcb, PtrNewCcb, DesiredAccess, ShareAccess);
1883 if(!NT_SUCCESS(RC)) {
1884 AdPrint((" Access/Share access check failed\n"));
1885 try_return(RC);
1886 }
1887
1888 RestoreShareAccess = TRUE;
1889
1890 if(FileOnlyRequested) {
1891 // If the user wants 'write access' access to the file make sure there
1892 // is not a process mapping this file as an image. Any attempt to
1893 // delete the file will be stopped in fileinfo.cpp
1894 //
1895 // If the user wants to delete on close, we must check at this
1896 // point though.
1897 if( (DesiredAccess & FILE_WRITE_DATA) || DeleteOnCloseSpecified ) {
1898 MmPrint((" MmFlushImageSection();\n"));
1899 NtReqFcb->AcqFlushCount++;
1900 if(!MmFlushImageSection( &(NtReqFcb->SectionObject),
1901 MmFlushForWrite )) {
1902
1903 NtReqFcb->AcqFlushCount--;
1904 RC = DeleteOnCloseSpecified ? STATUS_CANNOT_DELETE :
1905 STATUS_SHARING_VIOLATION;
1906 AdPrint((" File is mapped or deletion in progress\n"));
1907 try_return (RC);
1908 }
1909 NtReqFcb->AcqFlushCount--;
1910 }
1911 if( NoBufferingSpecified &&
1912 /* (PtrNewFileObject->Flags & FO_NO_INTERMEDIATE_BUFFERING) &&*/
1913 !(PtrNewFcb->CachedOpenHandleCount) &&
1914 (NtReqFcb->SectionObject.DataSectionObject) ) {
1915 // If this is a non-cached open, and there are no open cached
1916 // handles, but there is still a data section, attempt a flush
1917 // and purge operation to avoid cache coherency overhead later.
1918 // We ignore any I/O errors from the flush.
1919 MmPrint((" CcFlushCache()\n"));
1920 CcFlushCache( &(NtReqFcb->SectionObject), NULL, 0, NULL );
1921 MmPrint((" CcPurgeCacheSection()\n"));
1922 CcPurgeCacheSection( &(NtReqFcb->SectionObject), NULL, 0, FALSE );
1923 }
1924 }
1925
1926 if(DeleteOnCloseSpecified && UDFIsADirectory(NewFileInfo) && !UDFIsDirEmpty__(NewFileInfo)) {
1927 AdPrint((" Directory in not empry\n"));
1928 try_return (RC = STATUS_DIRECTORY_NOT_EMPTY);
1929 }
1930
1931 // Get attributes for the file ...
1932 TmpFileAttributes =
1933 (USHORT)UDFAttributesToNT(UDFDirIndex(UDFGetDirIndexByFileInfo(NewFileInfo), NewFileInfo->Index),
1934 NewFileInfo->Dloc->FileEntry);
1935
1936 if(DeleteOnCloseSpecified &&
1937 (TmpFileAttributes & FILE_ATTRIBUTE_READONLY)) {
1938 ASSERT(Res1 != NULL);
1939 ASSERT(Res2 != NULL);
1940 RC = UDFCheckAccessRights(NULL, NULL, OldRelatedFileInfo->Fcb, PtrRelatedCCB, FILE_DELETE_CHILD, 0);
1941 if(!NT_SUCCESS(RC)) {
1942 AdPrint((" Read-only. DeleteOnClose attempt failed\n"));
1943 try_return (RC = STATUS_CANNOT_DELETE);
1944 }
1945 }
1946
1947 // If a supersede or overwrite was requested, do so now ...
1948 if((RequestedDisposition == FILE_SUPERSEDE) ||
1949 (RequestedDisposition == FILE_OVERWRITE) ||
1950 (RequestedDisposition == FILE_OVERWRITE_IF)) {
1951 // Attempt the operation here ...
1952
1953 #ifndef UDF_READ_ONLY_BUILD
1954 ASSERT(!UDFIsADirectory(NewFileInfo));
1955
1956 if(RequestedDisposition == FILE_SUPERSEDE) {
1957 BOOLEAN RestoreRO = FALSE;
1958
1959 ASSERT(Res1 != NULL);
1960 ASSERT(Res2 != NULL);
1961 // NT wants us to allow Supersede on RO files
1962 if(PtrNewFcb->FCBFlags & UDF_FCB_READ_ONLY) {
1963 // Imagine, that file is not RO and check other permissions
1964 RestoreRO = TRUE;
1965 PtrNewFcb->FCBFlags &= ~UDF_FCB_READ_ONLY;
1966 }
1967 RC = UDFCheckAccessRights(NULL, NULL, PtrNewFcb, PtrNewCcb, DELETE, 0);
1968 if(RestoreRO) {
1969 // Restore RO state if changed
1970 PtrNewFcb->FCBFlags |= UDF_FCB_READ_ONLY;
1971 }
1972 if(!NT_SUCCESS(RC)) {
1973 AdPrint((" Can't supersede. DELETE permission required\n"));
1974 try_return (RC);
1975 }
1976 } else {
1977 ASSERT(Res1 != NULL);
1978 ASSERT(Res2 != NULL);
1979 RC = UDFCheckAccessRights(NULL, NULL, PtrNewFcb, PtrNewCcb,
1980 FILE_WRITE_DATA | FILE_WRITE_EA | FILE_WRITE_ATTRIBUTES, 0);
1981 if(!NT_SUCCESS(RC)) {
1982 AdPrint((" Can't overwrite. Permission denied\n"));
1983 try_return (RC);
1984 }
1985 }
1986 // Existing & requested System and Hidden bits must match
1987 if( (TmpFileAttributes & (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM)) &
1988 (FileAttributes ^ (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM)) ) {
1989 AdPrint((" The Hidden and/or System bits do not match\n"));
1990 try_return(RC = STATUS_ACCESS_DENIED);
1991 }
1992
1993 // Before we actually truncate, check to see if the purge
1994 // is going to fail.
1995 MmPrint((" MmCanFileBeTruncated()\n"));
1996 if (!MmCanFileBeTruncated( &NtReqFcb->SectionObject,
1997 &(UDFGlobalData.UDFLargeZero) )) {
1998 AdPrint((" Can't truncate. File is mapped\n"));
1999 try_return(RC = STATUS_USER_MAPPED_FILE);
2000 }
2001
2002 ASSERT(Res1 != NULL);
2003 ASSERT(Res2 != NULL);
2004
2005 #if 0
2006 CollectStatistics(Vcb, MetaDataWrites);
2007 #endif
2008 // Synchronize with PagingIo
2009 UDFAcquireResourceExclusive(PagingIoRes = &(NtReqFcb->PagingIoResource),TRUE);
2010 // Set file sizes
2011 if(!NT_SUCCESS(RC = UDFResizeFile__(Vcb, NewFileInfo, 0))) {
2012 AdPrint((" Error during resize operation\n"));
2013 try_return(RC);
2014 }
2015 /* if(AllocationSize) {
2016 if(!NT_SUCCESS(RC = UDFResizeFile__(Vcb, NewFileInfo, AllocationSize))) {
2017 AdPrint((" Error during resize operation (2)\n"));
2018 try_return(RC);
2019 }
2020 }*/
2021 NtReqFcb->CommonFCBHeader.AllocationSize.QuadPart = UDFSysGetAllocSize(Vcb, AllocationSize);
2022 NtReqFcb->CommonFCBHeader.FileSize.QuadPart =
2023 NtReqFcb->CommonFCBHeader.ValidDataLength.QuadPart = 0 /*AllocationSize*/;
2024 PtrNewFcb->FCBFlags &= ~UDF_FCB_DELAY_CLOSE;
2025 MmPrint((" CcSetFileSizes()\n"));
2026 CcSetFileSizes(PtrNewFileObject, (PCC_FILE_SIZES)&(NtReqFcb->CommonFCBHeader.AllocationSize));
2027 NtReqFcb->NtReqFCBFlags |= UDF_NTREQ_FCB_MODIFIED;
2028 // Release PagingIoResource
2029 UDFReleaseResource(PagingIoRes);
2030 PagingIoRes = NULL;
2031
2032 if(NT_SUCCESS(RC)) {
2033 FileAttributes |= FILE_ATTRIBUTE_ARCHIVE;
2034 if (RequestedDisposition == FILE_SUPERSEDE) {
2035 // Set attributes for the file ...
2036 UDFAttributesToUDF(UDFDirIndex(UDFGetDirIndexByFileInfo(NewFileInfo), NewFileInfo->Index),
2037 NewFileInfo->Dloc->FileEntry, FileAttributes);
2038 ReturnedInformation = FILE_SUPERSEDED;
2039 } else {
2040 // Get attributes for the file ...
2041 FileAttributes |= TmpFileAttributes;
2042 // Set attributes for the file ...
2043 UDFAttributesToUDF(UDFDirIndex(UDFGetDirIndexByFileInfo(NewFileInfo), NewFileInfo->Index),
2044 NewFileInfo->Dloc->FileEntry, FileAttributes);
2045 ReturnedInformation = FILE_OVERWRITTEN;
2046 }
2047 }
2048 // notify changes
2049 UDFNotifyFullReportChange( Vcb, NewFileInfo,
2050 FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_SIZE,
2051 FILE_ACTION_MODIFIED);
2052
2053 // Update parent object
2054 if((Vcb->CompatFlags & UDF_VCB_IC_UPDATE_DIR_WRITE) &&
2055 PtrRelatedFCB &&
2056 PtrRelatedFileObject &&
2057 (PtrRelatedFCB->FileInfo == NewFileInfo->ParentFile)) {
2058 PtrRelatedFileObject->Flags |= (FO_FILE_MODIFIED | FO_FILE_SIZE_CHANGED);
2059 }
2060 #else //UDF_READ_ONLY_BUILD
2061 try_return(RC = STATUS_ACCESS_DENIED);
2062 #endif //UDF_READ_ONLY_BUILD
2063 } else {
2064 ReturnedInformation = FILE_OPENED;
2065 }
2066
2067 // Update parent object
2068 if((Vcb->CompatFlags & UDF_VCB_IC_UPDATE_DIR_READ) &&
2069 PtrRelatedFCB &&
2070 PtrRelatedFileObject &&
2071 (PtrRelatedFCB->FileInfo == NewFileInfo->ParentFile)) {
2072 PtrRelatedFileObject->Flags |= FO_FILE_FAST_IO_READ;
2073 }
2074
2075 try_exit: NOTHING;
2076
2077 } _SEH2_FINALLY {
2078 // Complete the request unless we are here as part of unwinding
2079 // when an exception condition was encountered, OR
2080 // if the request has been deferred (i.e. posted for later handling)
2081
2082 if(RestoreVCBOpenCounter) {
2083 UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount));
2084 RestoreVCBOpenCounter = FALSE;
2085 }
2086
2087 if (RC != STATUS_PENDING) {
2088 // If any intermediate (directory) open operations were performed,
2089 // implement the corresponding close (do *not* however close
2090 // the target we have opened on behalf of the caller ...).
2091
2092 #if 0
2093 if(NT_SUCCESS(RC)) {
2094 CollectStatistics2(Vcb, SuccessfulCreates);
2095 } else {
2096 CollectStatistics2(Vcb, FailedCreates);
2097 }
2098 #endif
2099
2100 if (NT_SUCCESS(RC) && PtrNewFcb) {
2101 // Update the file object such that:
2102 // (a) the FsContext field points to the NTRequiredFCB field
2103 // in the FCB
2104 // (b) the FsContext2 field points to the CCB created as a
2105 // result of the open operation
2106
2107 // If write-through was requested, then mark the file object
2108 // appropriately
2109
2110 // directories are not cached
2111 // so we should prevent flush attepmts on cleanup
2112 if(!(PtrNewFcb->FCBFlags & UDF_FCB_DIRECTORY)) {
2113 #ifndef UDF_READ_ONLY_BUILD
2114 if(WriteThroughRequested) {
2115 PtrNewFileObject->Flags |= FO_WRITE_THROUGH;
2116 PtrNewFcb->FCBFlags |= UDF_FCB_WRITE_THROUGH;
2117 MmPrint((" FO_WRITE_THROUGH\n"));
2118 }
2119 #endif //UDF_READ_ONLY_BUILD
2120 if(SequentialIoRequested &&
2121 !(Vcb->CompatFlags & UDF_VCB_IC_IGNORE_SEQUENTIAL_IO)) {
2122 PtrNewFileObject->Flags |= FO_SEQUENTIAL_ONLY;
2123 MmPrint((" FO_SEQUENTIAL_ONLY\n"));
2124 #ifndef UDF_READ_ONLY_BUILD
2125 if(Vcb->TargetDeviceObject->Characteristics & FILE_REMOVABLE_MEDIA) {
2126 PtrNewFileObject->Flags &= ~FO_WRITE_THROUGH;
2127 PtrNewFcb->FCBFlags &= ~UDF_FCB_WRITE_THROUGH;
2128 MmPrint((" FILE_REMOVABLE_MEDIA + FO_SEQUENTIAL_ONLY => ~FO_WRITE_THROUGH\n"));
2129 }
2130 #endif //UDF_READ_ONLY_BUILD
2131 if(PtrNewFcb->FileInfo) {
2132 UDFSetFileAllocMode__(PtrNewFcb->FileInfo, EXTENT_FLAG_ALLOC_SEQUENTIAL);
2133 }
2134 }
2135 if(NoBufferingSpecified) {
2136 PtrNewFileObject->Flags |= FO_NO_INTERMEDIATE_BUFFERING;
2137 MmPrint((" FO_NO_INTERMEDIATE_BUFFERING\n"));
2138 } else {
2139 PtrNewFileObject->Flags |= FO_CACHE_SUPPORTED;
2140 MmPrint((" FO_CACHE_SUPPORTED\n"));
2141 }
2142 }
2143
2144 if((DesiredAccess & FILE_EXECUTE) /*&&
2145 !(PtrNewFcb->FCBFlags & UDF_FCB_DIRECTORY)*/) {
2146 MmPrint((" FO_FILE_FAST_IO_READ\n"));
2147 PtrNewFileObject->Flags |= FO_FILE_FAST_IO_READ;
2148 }
2149 // All right. Now we can safely increment OpenHandleCount
2150 UDFInterlockedIncrement((PLONG)&(Vcb->VCBHandleCount));
2151 UDFInterlockedIncrement((PLONG)&(PtrNewFcb->OpenHandleCount));
2152
2153 if(PtrNewFileObject->Flags & FO_CACHE_SUPPORTED)
2154 UDFInterlockedIncrement((PLONG)&(PtrNewFcb->CachedOpenHandleCount));
2155 // Store some flags in CCB
2156 if(PtrNewCcb) {
2157 PtrNewCcb->TreeLength = TreeLength;
2158 // delete on close
2159 #ifndef UDF_READ_ONLY_BUILD
2160 if(DeleteOnCloseSpecified) {
2161 ASSERT(!(PtrNewFcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY));
2162 PtrNewCcb->CCBFlags |= UDF_CCB_DELETE_ON_CLOSE;
2163 }
2164 #endif //UDF_READ_ONLY_BUILD
2165 // case sensetivity
2166 if(!IgnoreCase) {
2167 // remember this for possible Rename/Move operation
2168 PtrNewCcb->CCBFlags |= UDF_CCB_CASE_SENSETIVE;
2169 PtrNewFileObject->Flags |= FO_OPENED_CASE_SENSITIVE;
2170 }
2171 if(IsFileObjectReadOnly(PtrNewFileObject)) {
2172 UDFInterlockedIncrement((PLONG)&(Vcb->VCBOpenCountRO));
2173 PtrNewCcb->CCBFlags |= UDF_CCB_READ_ONLY;
2174 }
2175 } else {
2176 BrutePoint();
2177 }
2178 // it was a stream...
2179 if(StreamOpen)
2180 PtrNewFileObject->Flags |= FO_STREAM_FILE;
2181 // PtrNewCcb->CCBFlags |= UDF_CCB_VALID;
2182 // increment the number of outstanding open operations on this
2183 // logical volume (i.e. volume cannot be dismounted)
2184 UDFInterlockedIncrement((PLONG)&(Vcb->VCBOpenCount));
2185 PtrNewFcb->NTRequiredFCB->NtReqFCBFlags |= UDF_NTREQ_FCB_VALID;
2186 PtrNewFcb->FCBFlags |= UDF_FCB_VALID;
2187 #ifdef UDF_DBG
2188 // We have no FileInfo for Volume
2189 if(PtrNewFcb->FileInfo) {
2190 ASSERT_REF(PtrNewFcb->ReferenceCount >= PtrNewFcb->FileInfo->RefCount);
2191 }
2192 #endif // UDF_DBG
2193 AdPrint((" FCB %x, CCB %x, FO %x, Flags %x\n", PtrNewFcb, PtrNewCcb, PtrNewFileObject, PtrNewFcb->FCBFlags));
2194
2195 UDFReleaseResFromCreate(&PagingIoRes, &Res1, &Res2);
2196
2197 } else if(!NT_SUCCESS(RC)) {
2198 // Perform failure related post-processing now
2199 if(RestoreShareAccess && NtReqFcb && PtrNewFileObject) {
2200 IoRemoveShareAccess(PtrNewFileObject, &(NtReqFcb->FCBShareAccess));
2201 }
2202 UDFCleanUpCCB(PtrNewCcb);
2203 if(PtrNewFileObject) {
2204 PtrNewFileObject->FsContext2 = NULL;
2205 }
2206 // We have successfully opened LastGoodFileInfo,
2207 // so mark it as VALID to avoid future troubles...
2208 if(LastGoodFileInfo && LastGoodFileInfo->Fcb) {
2209 LastGoodFileInfo->Fcb->FCBFlags |= UDF_FCB_VALID;
2210 if(LastGoodFileInfo->Fcb->NTRequiredFCB) {
2211 LastGoodFileInfo->Fcb->NTRequiredFCB->NtReqFCBFlags |= UDF_NTREQ_FCB_VALID;
2212 }
2213 }
2214 // Release resources...
2215 UDFReleaseResFromCreate(&PagingIoRes, &Res1, &Res2);
2216 ASSERT(AcquiredVcb);
2217 // close the chain
2218 UDFCloseFileInfoChain(Vcb, LastGoodFileInfo, TreeLength, TRUE);
2219 // cleanup FCBs (if any)
2220 if( Vcb && (PtrNewFcb != Vcb->RootDirFCB) &&
2221 LastGoodFileInfo ) {
2222 UDFCleanUpFcbChain(Vcb, LastGoodFileInfo, TreeLength, TRUE);
2223 } else {
2224 ASSERT(!LastGoodFileInfo);
2225 }
2226 } else {
2227 UDFReleaseResFromCreate(&PagingIoRes, &Res1, &Res2);
2228 }
2229 // As long as this unwinding is not being performed as a result of
2230 // an exception condition, complete the IRP ...
2231 if (!_SEH2_AbnormalTermination()) {
2232 Irp->IoStatus.Status = RC;
2233 Irp->IoStatus.Information = ReturnedInformation;
2234
2235 // complete the IRP
2236 IoCompleteRequest(Irp, IO_DISK_INCREMENT);
2237 // Free up the Irp Context
2238 UDFReleaseIrpContext(PtrIrpContext);
2239 }
2240 } else {
2241 UDFReleaseResFromCreate(&PagingIoRes, &Res1, &Res2);
2242 }
2243
2244 if(AcquiredVcb) {
2245 UDFReleaseResource(&(Vcb->VCBResource));
2246 }
2247 // free allocated tmp buffers (if any)
2248 if(AbsolutePathName.Buffer)
2249 MyFreePool__(AbsolutePathName.Buffer);
2250 if(LocalPath.Buffer)
2251 MyFreePool__(LocalPath.Buffer);
2252 if(TailNameBuffer)
2253 MyFreePool__(TailNameBuffer);
2254 } _SEH2_END;
2255
2256 return(RC);
2257 } // end UDFCommonCreate()
2258
2259 /*************************************************************************
2260 *
2261 * Function: UDFFirstOpenFile()
2262 *
2263 * Description:
2264 * Perform first Open/Create initialization.
2265 *
2266 * Expected Interrupt Level (for execution) :
2267 *
2268 * IRQL_PASSIVE_LEVEL
2269 *
2270 * Return Value: STATUS_SUCCESS/Error
2271 *
2272 *************************************************************************/
2273 NTSTATUS
2274 UDFFirstOpenFile(
2275 IN PVCB Vcb, // volume control block
2276 IN PFILE_OBJECT PtrNewFileObject, // I/O Mgr. created file object
2277 OUT PtrUDFFCB* PtrNewFcb,
2278 IN PUDF_FILE_INFO RelatedFileInfo,
2279 IN PUDF_FILE_INFO NewFileInfo,
2280 IN PUNICODE_STRING LocalPath,
2281 IN PUNICODE_STRING CurName
2282 )
2283 {
2284 // DIR_INDEX NewFileIndex;
2285 PtrUDFObjectName NewFCBName;
2286 PtrUDFNTRequiredFCB NtReqFcb;
2287 NTSTATUS RC;
2288 BOOLEAN Linked = TRUE;
2289 PDIR_INDEX_HDR hDirIndex;
2290 PDIR_INDEX_ITEM DirIndex;
2291
2292 AdPrint(("UDFFirstOpenFile\n"));
2293
2294 if(!((*PtrNewFcb) = UDFAllocateFCB())) {
2295 AdPrint(("Can't allocate FCB\n"));
2296 return STATUS_INSUFFICIENT_RESOURCES;
2297 }
2298
2299 // Allocate and set new FCB unique name (equal to absolute path name)
2300 if(!(NewFCBName = UDFAllocateObjectName())) return STATUS_INSUFFICIENT_RESOURCES;
2301
2302 if(RelatedFileInfo && RelatedFileInfo->Fcb &&
2303 !(RelatedFileInfo->Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY)) {
2304 RC = MyCloneUnicodeString(&(NewFCBName->ObjectName), &(RelatedFileInfo->Fcb->FCBName->ObjectName));
2305 } else {
2306 RC = MyInitUnicodeString(&(NewFCBName->ObjectName), L"");
2307 }
2308 if(!NT_SUCCESS(RC))
2309 return STATUS_INSUFFICIENT_RESOURCES;
2310 if( (CurName->Buffer[0] != L':') &&
2311 (!LocalPath->Length ||
2312 ((LocalPath->Buffer[LocalPath->Length/sizeof(WCHAR)-1] != L':') /*&&
2313 (LocalPath->Buffer[LocalPath->Length/sizeof(WCHAR)-1] != L'\\')*/) )) {
2314 RC = MyAppendUnicodeToString(&(NewFCBName->ObjectName), L"\\");
2315 if(!NT_SUCCESS(RC)) return STATUS_INSUFFICIENT_RESOURCES;
2316 }
2317
2318 // Make link between Fcb and FileInfo
2319 (*PtrNewFcb)->FileInfo = NewFileInfo;
2320 NewFileInfo->Fcb = (*PtrNewFcb);
2321 (*PtrNewFcb)->ParentFcb = RelatedFileInfo->Fcb;
2322
2323 if(!((*PtrNewFcb)->NTRequiredFCB = NewFileInfo->Dloc->CommonFcb)) {
2324 if(!((*PtrNewFcb)->NTRequiredFCB =
2325 (PtrUDFNTRequiredFCB)MyAllocatePool__(NonPagedPool, UDFQuadAlign(sizeof(UDFNTRequiredFCB))) ) )
2326 return STATUS_INSUFFICIENT_RESOURCES;
2327
2328 UDFPrint(("UDFAllocateNtReqFCB: %x\n", (*PtrNewFcb)->NTRequiredFCB));
2329 RtlZeroMemory((*PtrNewFcb)->NTRequiredFCB, UDFQuadAlign(sizeof(UDFNTRequiredFCB)));
2330 (*PtrNewFcb)->FileInfo->Dloc->CommonFcb = (*PtrNewFcb)->NTRequiredFCB;
2331 Linked = FALSE;
2332 } else {
2333 if(!(NewFileInfo->Dloc->CommonFcb->NtReqFCBFlags & UDF_NTREQ_FCB_VALID)) {
2334 (*PtrNewFcb)->NTRequiredFCB = NULL;
2335 BrutePoint();
2336 return STATUS_ACCESS_DENIED;
2337 }
2338 }
2339
2340 NtReqFcb = (*PtrNewFcb)->NTRequiredFCB;
2341 // Set times
2342 if(!Linked) {
2343 UDFGetFileXTime((*PtrNewFcb)->FileInfo,
2344 &(NtReqFcb->CreationTime.QuadPart),
2345 &(NtReqFcb->LastAccessTime.QuadPart),
2346 &(NtReqFcb->ChangeTime.QuadPart),
2347 &(NtReqFcb->LastWriteTime.QuadPart) );
2348
2349 // Set the allocation size for the object is specified
2350 NtReqFcb->CommonFCBHeader.AllocationSize.QuadPart =
2351 UDFSysGetAllocSize(Vcb, NewFileInfo->Dloc->DataLoc.Length);
2352 // NtReqFcb->CommonFCBHeader.AllocationSize.QuadPart = UDFGetFileAllocationSize(Vcb, NewFileInfo);
2353 NtReqFcb->CommonFCBHeader.FileSize.QuadPart =
2354 NtReqFcb->CommonFCBHeader.ValidDataLength.QuadPart = NewFileInfo->Dloc->DataLoc.Length;
2355 }
2356 // begin transaction
2357 UDFAcquireResourceExclusive(&(Vcb->FcbListResource), TRUE);
2358
2359 RC = UDFInitializeFCB(*PtrNewFcb, Vcb, NewFCBName,
2360 UDFIsADirectory(NewFileInfo) ? UDF_FCB_DIRECTORY : 0, PtrNewFileObject);
2361 if(!NT_SUCCESS(RC)) {
2362 if(!Linked) {
2363 MyFreePool__((*PtrNewFcb)->NTRequiredFCB);
2364 (*PtrNewFcb)->NTRequiredFCB = NULL;
2365 }
2366 UDFReleaseResource(&(Vcb->FcbListResource));
2367 return RC;
2368 }
2369 // set Read-only attribute
2370 if(!UDFIsAStreamDir(NewFileInfo)) {
2371 hDirIndex = UDFGetDirIndexByFileInfo(NewFileInfo);
2372 #ifdef UDF_DBG
2373 if(!hDirIndex) {
2374 BrutePoint();
2375 } else {
2376 #endif // UDF_DBG
2377 if(UDFAttributesToNT(DirIndex = UDFDirIndex(hDirIndex, NewFileInfo->Index),NULL) & FILE_ATTRIBUTE_READONLY) {
2378 (*PtrNewFcb)->FCBFlags |= UDF_FCB_READ_ONLY;
2379 }
2380 MyAppendUnicodeStringToStringTag(&(NewFCBName->ObjectName), &(DirIndex->FName), MEM_USOBJ_TAG);
2381 #ifdef UDF_DBG
2382 }
2383 #endif // UDF_DBG
2384 } else if (RelatedFileInfo->ParentFile) {
2385 hDirIndex = UDFGetDirIndexByFileInfo(RelatedFileInfo);
2386 if(UDFAttributesToNT(DirIndex = UDFDirIndex(hDirIndex, RelatedFileInfo->Index),NULL) & FILE_ATTRIBUTE_READONLY) {
2387 (*PtrNewFcb)->FCBFlags |= UDF_FCB_READ_ONLY;
2388 }
2389 RC = MyAppendUnicodeStringToStringTag(&(NewFCBName->ObjectName), CurName, MEM_USOBJ_TAG);
2390 // } else {
2391 // BrutePoint();
2392 }
2393 // do not allocate CCB if it is internal Create/Open
2394 if(NT_SUCCESS(RC)) {
2395 if(PtrNewFileObject) {
2396 RC = UDFOpenFile(Vcb, PtrNewFileObject, *PtrNewFcb);
2397 } else {
2398 RC = STATUS_SUCCESS;
2399 }
2400 }
2401 UDFReleaseResource(&(Vcb->FcbListResource));
2402 // end transaction
2403
2404 // if(!NT_SUCCESS(RC)) return RC;
2405
2406 return RC;
2407 } // end UDFFirstOpenFile()
2408
2409 /*************************************************************************
2410 *
2411 * Function: UDFOpenFile()
2412 *
2413 * Description:
2414 * Open a file/dir for the caller.
2415 *
2416 * Expected Interrupt Level (for execution) :
2417 *
2418 * IRQL_PASSIVE_LEVEL
2419 *
2420 * Return Value: STATUS_SUCCESS/Error
2421 *
2422 *************************************************************************/
2423 NTSTATUS
2424 UDFOpenFile(
2425 PVCB Vcb, // volume control block
2426 PFILE_OBJECT PtrNewFileObject, // I/O Mgr. created file object
2427 PtrUDFFCB PtrNewFcb
2428 )
2429 {
2430 NTSTATUS RC = STATUS_SUCCESS;
2431 PtrUDFCCB Ccb = NULL;
2432 PtrUDFNTRequiredFCB NtReqFcb;
2433
2434 AdPrint(("UDFOpenFile\n"));
2435 ASSERT((PtrNewFcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_FCB)
2436 ||(PtrNewFcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB));
2437
2438 _SEH2_TRY {
2439
2440 #if 0
2441 CollectStatistics2(Vcb, CreateHits);
2442 #endif
2443 // create a new CCB structure
2444 if (!(Ccb = UDFAllocateCCB())) {
2445 AdPrint(("Can't allocate CCB\n"));
2446 PtrNewFileObject->FsContext2 = NULL;
2447 //
2448 UDFInterlockedIncrement((PLONG)&(PtrNewFcb->ReferenceCount));
2449 UDFInterlockedIncrement((PLONG)&(PtrNewFcb->NTRequiredFCB->CommonRefCount));
2450 RC = STATUS_INSUFFICIENT_RESOURCES;
2451 try_return(RC);
2452 }
2453 // initialize the CCB
2454 Ccb->Fcb = PtrNewFcb;
2455 // initialize the CCB to point to the file object
2456 Ccb->FileObject = PtrNewFileObject;
2457
2458 // initialize the file object appropriately
2459 PtrNewFileObject->FsContext2 = (PVOID)(Ccb);
2460 PtrNewFileObject->Vpb = Vcb->Vpb;
2461 PtrNewFileObject->FsContext = (PVOID)(NtReqFcb = PtrNewFcb->NTRequiredFCB);
2462 PtrNewFileObject->SectionObjectPointer = &(NtReqFcb->SectionObject);
2463 #ifdef DBG
2464 // NtReqFcb ->FileObject = PtrNewFileObject;
2465 #endif //DBG
2466
2467 #ifdef UDF_DELAYED_CLOSE
2468 PtrNewFcb->FCBFlags &= ~UDF_FCB_DELAY_CLOSE;
2469 #endif //UDF_DELAYED_CLOSE
2470
2471 UDFAcquireResourceExclusive(&(PtrNewFcb->CcbListResource),TRUE);
2472 // insert CCB into linked list of open file object to Fcb or
2473 // to Vcb and do other intialization
2474 InsertTailList(&(PtrNewFcb->NextCCB), &(Ccb->NextCCB));
2475 UDFInterlockedIncrement((PLONG)&(PtrNewFcb->ReferenceCount));
2476 UDFInterlockedIncrement((PLONG)&(PtrNewFcb->NTRequiredFCB->CommonRefCount));
2477 UDFReleaseResource(&(PtrNewFcb->CcbListResource));
2478
2479 try_exit: NOTHING;
2480 } _SEH2_FINALLY {
2481 NOTHING;
2482 } _SEH2_END;
2483
2484 return(RC);
2485 } // end UDFOpenFile()
2486
2487
2488 /*************************************************************************
2489 *
2490 * Function: UDFInitializeFCB()
2491 *
2492 * Description:
2493 * Initialize a new FCB structure and also the sent-in file object
2494 * (if supplied)
2495 *
2496 * Expected Interrupt Level (for execution) :
2497 *
2498 * IRQL_PASSIVE_LEVEL
2499 *
2500 * Return Value: None
2501 *
2502 *************************************************************************/
2503 NTSTATUS
2504 UDFInitializeFCB(
2505 IN PtrUDFFCB PtrNewFcb, // FCB structure to be initialized
2506 IN PVCB Vcb, // logical volume (VCB) pointer
2507 IN PtrUDFObjectName PtrObjectName, // name of the object
2508 IN ULONG Flags, // is this a file/directory, etc.
2509 IN PFILE_OBJECT FileObject) // optional file object to be initialized
2510 {
2511 AdPrint(("UDFInitializeFCB\n"));
2512 NTSTATUS status;
2513 BOOLEAN Linked = TRUE;
2514
2515 if(!PtrNewFcb->NTRequiredFCB->CommonFCBHeader.Resource) {
2516 // record signature
2517 PtrNewFcb->NTRequiredFCB->CommonFCBHeader.NodeTypeCode = UDF_NODE_TYPE_NT_REQ_FCB;
2518 PtrNewFcb->NTRequiredFCB->CommonFCBHeader.NodeByteSize = sizeof(UDFNTRequiredFCB);
2519 // Initialize the ERESOURCE objects
2520 if(!NT_SUCCESS(status = UDFInitializeResourceLite(&(PtrNewFcb->NTRequiredFCB->MainResource)))) {
2521 AdPrint((" Can't init resource\n"));
2522 return status;
2523 }
2524 if(!NT_SUCCESS(status = UDFInitializeResourceLite(&(PtrNewFcb->NTRequiredFCB->PagingIoResource)))) {
2525 AdPrint((" Can't init resource (2)\n"));
2526 UDFDeleteResource(&(PtrNewFcb->NTRequiredFCB->MainResource));
2527 return status;
2528 }
2529 // Fill NT required Fcb part
2530 PtrNewFcb->NTRequiredFCB->CommonFCBHeader.Resource = &(PtrNewFcb->NTRequiredFCB->MainResource);
2531 PtrNewFcb->NTRequiredFCB->CommonFCBHeader.PagingIoResource = &(PtrNewFcb->NTRequiredFCB->PagingIoResource);
2532 // Itialize byte-range locks support structure
2533 FsRtlInitializeFileLock(&(PtrNewFcb->NTRequiredFCB->FileLock),NULL,NULL);
2534 // Init reference counter
2535 PtrNewFcb->NTRequiredFCB->CommonRefCount = 0;
2536 Linked = FALSE;
2537 } else {
2538 ASSERT(PtrNewFcb->NTRequiredFCB->CommonFCBHeader.NodeTypeCode == UDF_NODE_TYPE_NT_REQ_FCB);
2539 }
2540 if(!NT_SUCCESS(status = UDFInitializeResourceLite(&(PtrNewFcb->CcbListResource)))) {
2541 AdPrint((" Can't init resource (3)\n"));
2542 BrutePoint();
2543 if(!Linked) {
2544 UDFDeleteResource(&(PtrNewFcb->NTRequiredFCB->PagingIoResource));
2545 UDFDeleteResource(&(PtrNewFcb->NTRequiredFCB->MainResource));
2546 PtrNewFcb->NTRequiredFCB->CommonFCBHeader.Resource =
2547 PtrNewFcb->NTRequiredFCB->CommonFCBHeader.PagingIoResource = NULL;
2548 FsRtlUninitializeFileLock(&(PtrNewFcb->NTRequiredFCB->FileLock));
2549 }
2550 return status;
2551 }
2552
2553 // caller MUST ensure that VCB has been acquired exclusively
2554 InsertTailList(&(Vcb->NextFCB), &(PtrNewFcb->NextFCB));
2555
2556 // initialize the various list heads
2557 InitializeListHead(&(PtrNewFcb->NextCCB));
2558
2559 PtrNewFcb->ReferenceCount = 0;
2560 PtrNewFcb->OpenHandleCount = 0;
2561
2562 PtrNewFcb->FCBFlags = Flags | UDF_FCB_INITIALIZED_CCB_LIST_RESOURCE;
2563
2564 PtrNewFcb->FCBName = PtrObjectName;
2565
2566 PtrNewFcb->Vcb = Vcb;
2567
2568 return STATUS_SUCCESS;
2569 } // end UDFInitializeFCB()
2570
A free Windows-compatible Operating System