0e948addc6730d14b128d02a3a6e52a654c56bac
[reactos.git] / reactos / drivers / filesystems / fastfat / dirwr.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * FILE: drivers/fs/vfat/dirwr.c
5 * PURPOSE: VFAT Filesystem : write in directory
6 *
7 */
8
9 /* INCLUDES *****************************************************************/
10
11 #define NDEBUG
12 #include "vfat.h"
13
14 /*
15 * update an existing FAT entry
16 */
17 NTSTATUS
18 VfatUpdateEntry(
19 IN PVFATFCB pFcb)
20 {
21 PVOID Context;
22 PDIR_ENTRY PinEntry;
23 LARGE_INTEGER Offset;
24 ULONG SizeDirEntry;
25 ULONG dirIndex;
26
27 ASSERT(pFcb);
28
29 if (pFcb->Flags & FCB_IS_FATX_ENTRY)
30 {
31 SizeDirEntry = sizeof(FATX_DIR_ENTRY);
32 dirIndex = pFcb->startIndex;
33 }
34 else
35 {
36 SizeDirEntry = sizeof(FAT_DIR_ENTRY);
37 dirIndex = pFcb->dirIndex;
38 }
39
40 DPRINT("updEntry dirIndex %d, PathName \'%wZ\'\n", dirIndex, &pFcb->PathNameU);
41
42 if (vfatFCBIsRoot(pFcb) || (pFcb->Flags & (FCB_IS_FAT|FCB_IS_VOLUME)))
43 {
44 return STATUS_SUCCESS;
45 }
46
47 ASSERT(pFcb->parentFcb);
48
49 Offset.u.HighPart = 0;
50 Offset.u.LowPart = dirIndex * SizeDirEntry;
51 if (CcPinRead(pFcb->parentFcb->FileObject, &Offset, SizeDirEntry,
52 TRUE, &Context, (PVOID*)&PinEntry))
53 {
54 pFcb->Flags &= ~FCB_IS_DIRTY;
55 RtlCopyMemory(PinEntry, &pFcb->entry, SizeDirEntry);
56 CcSetDirtyPinnedData(Context, NULL);
57 CcUnpinData(Context);
58 return STATUS_SUCCESS;
59 }
60 else
61 {
62 DPRINT1("Failed write to \'%wZ\'.\n", &pFcb->parentFcb->PathNameU);
63 return STATUS_UNSUCCESSFUL;
64 }
65 }
66
67 /*
68 * try to find contiguous entries frees in directory,
69 * extend a directory if is neccesary
70 */
71 BOOLEAN
72 vfatFindDirSpace(
73 IN PDEVICE_EXTENSION DeviceExt,
74 IN PVFATFCB pDirFcb,
75 IN ULONG nbSlots,
76 OUT PULONG start)
77 {
78 LARGE_INTEGER FileOffset;
79 ULONG i, count, size, nbFree = 0;
80 PDIR_ENTRY pFatEntry = NULL;
81 PVOID Context = NULL;
82 NTSTATUS Status;
83 ULONG SizeDirEntry;
84 FileOffset.QuadPart = 0;
85
86 if (DeviceExt->Flags & VCB_IS_FATX)
87 SizeDirEntry = sizeof(FATX_DIR_ENTRY);
88 else
89 SizeDirEntry = sizeof(FAT_DIR_ENTRY);
90
91 count = pDirFcb->RFCB.FileSize.u.LowPart / SizeDirEntry;
92 size = DeviceExt->FatInfo.BytesPerCluster / SizeDirEntry;
93 for (i = 0; i < count; i++, pFatEntry = (PDIR_ENTRY)((ULONG_PTR)pFatEntry + SizeDirEntry))
94 {
95 if (Context == NULL || (i % size) == 0)
96 {
97 if (Context)
98 {
99 CcUnpinData(Context);
100 }
101 /* FIXME: check return value */
102 CcPinRead(pDirFcb->FileObject, &FileOffset, DeviceExt->FatInfo.BytesPerCluster,
103 TRUE, &Context, (PVOID*)&pFatEntry);
104 FileOffset.u.LowPart += DeviceExt->FatInfo.BytesPerCluster;
105 }
106 if (ENTRY_END(DeviceExt, pFatEntry))
107 {
108 break;
109 }
110 if (ENTRY_DELETED(DeviceExt, pFatEntry))
111 {
112 nbFree++;
113 }
114 else
115 {
116 nbFree = 0;
117 }
118 if (nbFree == nbSlots)
119 {
120 break;
121 }
122 }
123 if (Context)
124 {
125 CcUnpinData(Context);
126 Context = NULL;
127 }
128 if (nbFree == nbSlots)
129 {
130 /* found enough contiguous free slots */
131 *start = i - nbSlots + 1;
132 }
133 else
134 {
135 *start = i - nbFree;
136 if (*start + nbSlots > count)
137 {
138 LARGE_INTEGER AllocationSize;
139 /* extend the directory */
140 if (vfatFCBIsRoot(pDirFcb) && DeviceExt->FatInfo.FatType != FAT32)
141 {
142 /* We can't extend a root directory on a FAT12/FAT16/FATX partition */
143 return FALSE;
144 }
145 AllocationSize.QuadPart = pDirFcb->RFCB.FileSize.u.LowPart + DeviceExt->FatInfo.BytesPerCluster;
146 Status = VfatSetAllocationSizeInformation(pDirFcb->FileObject, pDirFcb,
147 DeviceExt, &AllocationSize);
148 if (!NT_SUCCESS(Status))
149 {
150 return FALSE;
151 }
152 /* clear the new dir cluster */
153 FileOffset.u.LowPart = (ULONG)(pDirFcb->RFCB.FileSize.QuadPart -
154 DeviceExt->FatInfo.BytesPerCluster);
155 CcPinRead(pDirFcb->FileObject, &FileOffset, DeviceExt->FatInfo.BytesPerCluster,
156 TRUE, &Context, (PVOID*)&pFatEntry);
157 if (DeviceExt->Flags & VCB_IS_FATX)
158 memset(pFatEntry, 0xff, DeviceExt->FatInfo.BytesPerCluster);
159 else
160 RtlZeroMemory(pFatEntry, DeviceExt->FatInfo.BytesPerCluster);
161 }
162 else if (*start + nbSlots < count)
163 {
164 /* clear the entry after the last new entry */
165 FileOffset.u.LowPart = (*start + nbSlots) * SizeDirEntry;
166 CcPinRead(pDirFcb->FileObject, &FileOffset, SizeDirEntry,
167 TRUE, &Context, (PVOID*)&pFatEntry);
168 if (DeviceExt->Flags & VCB_IS_FATX)
169 memset(pFatEntry, 0xff, SizeDirEntry);
170 else
171 RtlZeroMemory(pFatEntry, SizeDirEntry);
172 }
173 if (Context)
174 {
175 CcSetDirtyPinnedData(Context, NULL);
176 CcUnpinData(Context);
177 }
178 }
179 DPRINT("nbSlots %d nbFree %d, entry number %d\n", nbSlots, nbFree, *start);
180 return TRUE;
181 }
182
183 /*
184 create a new FAT entry
185 */
186 static NTSTATUS
187 FATAddEntry(
188 IN PDEVICE_EXTENSION DeviceExt,
189 IN PUNICODE_STRING NameU,
190 IN PVFATFCB* Fcb,
191 IN PVFATFCB ParentFcb,
192 IN ULONG RequestedOptions,
193 IN UCHAR ReqAttr)
194 {
195 PVOID Context = NULL;
196 PFAT_DIR_ENTRY pFatEntry;
197 slot *pSlots;
198 USHORT nbSlots = 0, j, posCar;
199 PUCHAR Buffer;
200 BOOLEAN needTilde = FALSE, needLong = FALSE;
201 BOOLEAN lCaseBase = FALSE, uCaseBase, lCaseExt = FALSE, uCaseExt;
202 ULONG CurrentCluster;
203 LARGE_INTEGER SystemTime, FileOffset;
204 NTSTATUS Status = STATUS_SUCCESS;
205 ULONG size;
206 long i;
207
208 OEM_STRING NameA;
209 CHAR aName[13];
210 BOOLEAN IsNameLegal;
211 BOOLEAN SpacesFound;
212
213 VFAT_DIRENTRY_CONTEXT DirContext;
214 WCHAR LongNameBuffer[LONGNAME_MAX_LENGTH + 1];
215 WCHAR ShortNameBuffer[13];
216
217 DPRINT("addEntry: Name='%wZ', Dir='%wZ'\n", NameU, &ParentFcb->PathNameU);
218
219 DirContext.LongNameU = *NameU;
220
221 /* nb of entry needed for long name+normal entry */
222 nbSlots = (DirContext.LongNameU.Length / sizeof(WCHAR) + 12) / 13 + 1;
223 DPRINT("NameLen= %d, nbSlots =%d\n", DirContext.LongNameU.Length / sizeof(WCHAR), nbSlots);
224 Buffer = ExAllocatePoolWithTag(NonPagedPool, (nbSlots - 1) * sizeof(FAT_DIR_ENTRY), TAG_VFAT);
225 if (Buffer == NULL)
226 {
227 return STATUS_INSUFFICIENT_RESOURCES;
228 }
229 RtlZeroMemory(Buffer, (nbSlots - 1) * sizeof(FAT_DIR_ENTRY));
230 pSlots = (slot *) Buffer;
231
232 NameA.Buffer = aName;
233 NameA.Length = 0;
234 NameA.MaximumLength = sizeof(aName);
235
236 DirContext.ShortNameU.Buffer = ShortNameBuffer;
237 DirContext.ShortNameU.Length = 0;
238 DirContext.ShortNameU.MaximumLength = sizeof(ShortNameBuffer);
239
240 RtlZeroMemory(&DirContext.DirEntry.Fat, sizeof(FAT_DIR_ENTRY));
241
242 IsNameLegal = RtlIsNameLegalDOS8Dot3(&DirContext.LongNameU, &NameA, &SpacesFound);
243
244 if (!IsNameLegal || SpacesFound)
245 {
246 GENERATE_NAME_CONTEXT NameContext;
247 VFAT_DIRENTRY_CONTEXT SearchContext;
248 WCHAR ShortSearchName[13];
249 needTilde = TRUE;
250 needLong = TRUE;
251 RtlZeroMemory(&NameContext, sizeof(GENERATE_NAME_CONTEXT));
252 SearchContext.LongNameU.Buffer = LongNameBuffer;
253 SearchContext.LongNameU.MaximumLength = sizeof(LongNameBuffer);
254 SearchContext.ShortNameU.Buffer = ShortSearchName;
255 SearchContext.ShortNameU.MaximumLength = sizeof(ShortSearchName);
256
257 for (i = 0; i < 100; i++)
258 {
259 RtlGenerate8dot3Name(&DirContext.LongNameU, FALSE, &NameContext, &DirContext.ShortNameU);
260 DirContext.ShortNameU.Buffer[DirContext.ShortNameU.Length / sizeof(WCHAR)] = 0;
261 SearchContext.DirIndex = 0;
262 Status = FindFile(DeviceExt, ParentFcb, &DirContext.ShortNameU, &SearchContext, TRUE);
263 if (!NT_SUCCESS(Status))
264 {
265 break;
266 }
267 }
268 if (i == 100) /* FIXME : what to do after this ? */
269 {
270 ExFreePoolWithTag(Buffer, TAG_VFAT);
271 return STATUS_UNSUCCESSFUL;
272 }
273 IsNameLegal = RtlIsNameLegalDOS8Dot3(&DirContext.ShortNameU, &NameA, &SpacesFound);
274 aName[NameA.Length]=0;
275 }
276 else
277 {
278 aName[NameA.Length] = 0;
279 for (posCar = 0; posCar < DirContext.LongNameU.Length / sizeof(WCHAR); posCar++)
280 {
281 if (DirContext.LongNameU.Buffer[posCar] == L'.')
282 {
283 break;
284 }
285 }
286 /* check if the name and the extension contains upper case characters */
287 RtlDowncaseUnicodeString(&DirContext.ShortNameU, &DirContext.LongNameU, FALSE);
288 DirContext.ShortNameU.Buffer[DirContext.ShortNameU.Length / sizeof(WCHAR)] = 0;
289 uCaseBase = wcsncmp(DirContext.LongNameU.Buffer,
290 DirContext.ShortNameU.Buffer, posCar) ? TRUE : FALSE;
291 if (posCar < DirContext.LongNameU.Length/sizeof(WCHAR))
292 {
293 i = DirContext.LongNameU.Length / sizeof(WCHAR) - posCar;
294 uCaseExt = wcsncmp(DirContext.LongNameU.Buffer + posCar,
295 DirContext.ShortNameU.Buffer + posCar, i) ? TRUE : FALSE;
296 }
297 else
298 {
299 uCaseExt = FALSE;
300 }
301 /* check if the name and the extension contains lower case characters */
302 RtlUpcaseUnicodeString(&DirContext.ShortNameU, &DirContext.LongNameU, FALSE);
303 DirContext.ShortNameU.Buffer[DirContext.ShortNameU.Length / sizeof(WCHAR)] = 0;
304 lCaseBase = wcsncmp(DirContext.LongNameU.Buffer,
305 DirContext.ShortNameU.Buffer, posCar) ? TRUE : FALSE;
306 if (posCar < DirContext.LongNameU.Length / sizeof(WCHAR))
307 {
308 i = DirContext.LongNameU.Length / sizeof(WCHAR) - posCar;
309 lCaseExt = wcsncmp(DirContext.LongNameU.Buffer + posCar,
310 DirContext.ShortNameU.Buffer + posCar, i) ? TRUE : FALSE;
311 }
312 else
313 {
314 lCaseExt = FALSE;
315 }
316 if ((lCaseBase && uCaseBase) || (lCaseExt && uCaseExt))
317 {
318 needLong = TRUE;
319 }
320 }
321 DPRINT("'%s', '%wZ', needTilde=%d, needLong=%d\n",
322 aName, &DirContext.LongNameU, needTilde, needLong);
323 memset(DirContext.DirEntry.Fat.ShortName, ' ', 11);
324 for (i = 0; i < 8 && aName[i] && aName[i] != '.'; i++)
325 {
326 DirContext.DirEntry.Fat.Filename[i] = aName[i];
327 }
328 if (aName[i] == '.')
329 {
330 i++;
331 for (j = 0; j < 3 && aName[i]; j++, i++)
332 {
333 DirContext.DirEntry.Fat.Ext[j] = aName[i];
334 }
335 }
336 if (DirContext.DirEntry.Fat.Filename[0] == 0xe5)
337 {
338 DirContext.DirEntry.Fat.Filename[0] = 0x05;
339 }
340
341 if (needLong)
342 {
343 RtlCopyMemory(LongNameBuffer, DirContext.LongNameU.Buffer, DirContext.LongNameU.Length);
344 DirContext.LongNameU.Buffer = LongNameBuffer;
345 DirContext.LongNameU.MaximumLength = sizeof(LongNameBuffer);
346 DirContext.LongNameU.Buffer[DirContext.LongNameU.Length / sizeof(WCHAR)] = 0;
347 memset(DirContext.LongNameU.Buffer + DirContext.LongNameU.Length / sizeof(WCHAR) + 1, 0xff,
348 DirContext.LongNameU.MaximumLength - DirContext.LongNameU.Length - sizeof(WCHAR));
349 }
350 else
351 {
352 nbSlots = 1;
353 if (lCaseBase)
354 {
355 DirContext.DirEntry.Fat.lCase |= VFAT_CASE_LOWER_BASE;
356 }
357 if (lCaseExt)
358 {
359 DirContext.DirEntry.Fat.lCase |= VFAT_CASE_LOWER_EXT;
360 }
361 }
362
363 DPRINT ("dos name=%11.11s\n", DirContext.DirEntry.Fat.Filename);
364
365 /* set attributes */
366 DirContext.DirEntry.Fat.Attrib = ReqAttr;
367 if (RequestedOptions & FILE_DIRECTORY_FILE)
368 {
369 DirContext.DirEntry.Fat.Attrib |= FILE_ATTRIBUTE_DIRECTORY;
370 }
371 /* set dates and times */
372 KeQuerySystemTime(&SystemTime);
373 FsdSystemTimeToDosDateTime(DeviceExt, &SystemTime, &DirContext.DirEntry.Fat.CreationDate,
374 &DirContext.DirEntry.Fat.CreationTime);
375 DirContext.DirEntry.Fat.UpdateDate = DirContext.DirEntry.Fat.CreationDate;
376 DirContext.DirEntry.Fat.UpdateTime = DirContext.DirEntry.Fat.CreationTime;
377 DirContext.DirEntry.Fat.AccessDate = DirContext.DirEntry.Fat.CreationDate;
378
379 if (needLong)
380 {
381 /* calculate checksum for 8.3 name */
382 for (pSlots[0].alias_checksum = 0, i = 0; i < 11; i++)
383 {
384 pSlots[0].alias_checksum = (((pSlots[0].alias_checksum & 1) << 7
385 | ((pSlots[0].alias_checksum & 0xfe) >> 1))
386 + DirContext.DirEntry.Fat.ShortName[i]);
387 }
388 /* construct slots and entry */
389 for (i = nbSlots - 2; i >= 0; i--)
390 {
391 DPRINT("construct slot %d\n", i);
392 pSlots[i].attr = 0xf;
393 if (i)
394 {
395 pSlots[i].id = (unsigned char)(nbSlots - i - 1);
396 }
397 else
398 {
399 pSlots[i].id = (unsigned char)(nbSlots - i - 1 + 0x40);
400 }
401 pSlots[i].alias_checksum = pSlots[0].alias_checksum;
402 RtlCopyMemory(pSlots[i].name0_4, DirContext.LongNameU.Buffer + (nbSlots - i - 2) * 13, 10);
403 RtlCopyMemory(pSlots[i].name5_10, DirContext.LongNameU.Buffer + (nbSlots - i - 2) * 13 + 5, 12);
404 RtlCopyMemory(pSlots[i].name11_12, DirContext.LongNameU.Buffer + (nbSlots - i - 2) * 13 + 11, 4);
405 }
406 }
407 /* try to find nbSlots contiguous entries frees in directory */
408 if (!vfatFindDirSpace(DeviceExt, ParentFcb, nbSlots, &DirContext.StartIndex))
409 {
410 ExFreePoolWithTag(Buffer, TAG_VFAT);
411 return STATUS_DISK_FULL;
412 }
413 DirContext.DirIndex = DirContext.StartIndex + nbSlots - 1;
414 if (RequestedOptions & FILE_DIRECTORY_FILE)
415 {
416 CurrentCluster = 0;
417 Status = NextCluster(DeviceExt, 0, &CurrentCluster, TRUE);
418 if (CurrentCluster == 0xffffffff || !NT_SUCCESS(Status))
419 {
420 ExFreePoolWithTag(Buffer, TAG_VFAT);
421 if (!NT_SUCCESS(Status))
422 {
423 return Status;
424 }
425 return STATUS_DISK_FULL;
426 }
427 if (DeviceExt->FatInfo.FatType == FAT32)
428 {
429 DirContext.DirEntry.Fat.FirstClusterHigh = (unsigned short)(CurrentCluster >> 16);
430 }
431 DirContext.DirEntry.Fat.FirstCluster = (unsigned short)CurrentCluster;
432 }
433
434 i = DeviceExt->FatInfo.BytesPerCluster / sizeof(FAT_DIR_ENTRY);
435 FileOffset.u.HighPart = 0;
436 FileOffset.u.LowPart = DirContext.StartIndex * sizeof(FAT_DIR_ENTRY);
437 if (DirContext.StartIndex / i == DirContext.DirIndex / i)
438 {
439 /* one cluster */
440 CcPinRead(ParentFcb->FileObject, &FileOffset, nbSlots * sizeof(FAT_DIR_ENTRY),
441 TRUE, &Context, (PVOID*)&pFatEntry);
442 if (nbSlots > 1)
443 {
444 RtlCopyMemory(pFatEntry, Buffer, (nbSlots - 1) * sizeof(FAT_DIR_ENTRY));
445 }
446 RtlCopyMemory(pFatEntry + (nbSlots - 1), &DirContext.DirEntry.Fat, sizeof(FAT_DIR_ENTRY));
447 }
448 else
449 {
450 /* two clusters */
451 size = DeviceExt->FatInfo.BytesPerCluster -
452 (DirContext.StartIndex * sizeof(FAT_DIR_ENTRY)) % DeviceExt->FatInfo.BytesPerCluster;
453 i = size / sizeof(FAT_DIR_ENTRY);
454 CcPinRead(ParentFcb->FileObject, &FileOffset, size, TRUE,
455 &Context, (PVOID*)&pFatEntry);
456 RtlCopyMemory(pFatEntry, Buffer, size);
457 CcSetDirtyPinnedData(Context, NULL);
458 CcUnpinData(Context);
459 FileOffset.u.LowPart += size;
460 CcPinRead(ParentFcb->FileObject, &FileOffset,
461 nbSlots * sizeof(FAT_DIR_ENTRY) - size,
462 TRUE, &Context, (PVOID*)&pFatEntry);
463 if (nbSlots - 1 > i)
464 {
465 RtlCopyMemory(pFatEntry, (PVOID)(Buffer + size), (nbSlots - 1 - i) * sizeof(FAT_DIR_ENTRY));
466 }
467 RtlCopyMemory(pFatEntry + nbSlots - 1 - i, &DirContext.DirEntry.Fat, sizeof(FAT_DIR_ENTRY));
468 }
469 CcSetDirtyPinnedData(Context, NULL);
470 CcUnpinData(Context);
471
472 Status = vfatMakeFCBFromDirEntry(DeviceExt, ParentFcb, &DirContext, Fcb);
473 if (!NT_SUCCESS(Status))
474 {
475 ExFreePoolWithTag(Buffer, TAG_VFAT);
476 return Status;
477 }
478
479 DPRINT("new : entry=%11.11s\n", (*Fcb)->entry.Fat.Filename);
480 DPRINT("new : entry=%11.11s\n", DirContext.DirEntry.Fat.Filename);
481
482 if (RequestedOptions & FILE_DIRECTORY_FILE)
483 {
484 FileOffset.QuadPart = 0;
485 CcPinRead((*Fcb)->FileObject, &FileOffset, DeviceExt->FatInfo.BytesPerCluster, TRUE,
486 &Context, (PVOID*)&pFatEntry);
487 /* clear the new directory cluster */
488 RtlZeroMemory(pFatEntry, DeviceExt->FatInfo.BytesPerCluster);
489 /* create '.' and '..' */
490 RtlCopyMemory(&pFatEntry[0].Attrib, &DirContext.DirEntry.Fat.Attrib, sizeof(FAT_DIR_ENTRY) - 11);
491 RtlCopyMemory(pFatEntry[0].ShortName, ". ", 11);
492 RtlCopyMemory(&pFatEntry[1].Attrib, &DirContext.DirEntry.Fat.Attrib, sizeof(FAT_DIR_ENTRY) - 11);
493 RtlCopyMemory(pFatEntry[1].ShortName, ".. ", 11);
494 pFatEntry[1].FirstCluster = ParentFcb->entry.Fat.FirstCluster;
495 pFatEntry[1].FirstClusterHigh = ParentFcb->entry.Fat.FirstClusterHigh;
496 if (vfatFCBIsRoot(ParentFcb))
497 {
498 pFatEntry[1].FirstCluster = 0;
499 pFatEntry[1].FirstClusterHigh = 0;
500 }
501 CcSetDirtyPinnedData(Context, NULL);
502 CcUnpinData(Context);
503 }
504 ExFreePoolWithTag(Buffer, TAG_VFAT);
505 DPRINT("addentry ok\n");
506 return STATUS_SUCCESS;
507 }
508
509 /*
510 create a new FAT entry
511 */
512 static NTSTATUS
513 FATXAddEntry(
514 IN PDEVICE_EXTENSION DeviceExt,
515 IN PUNICODE_STRING NameU,
516 IN PVFATFCB* Fcb,
517 IN PVFATFCB ParentFcb,
518 IN ULONG RequestedOptions,
519 IN UCHAR ReqAttr)
520 {
521 PVOID Context = NULL;
522 LARGE_INTEGER SystemTime, FileOffset;
523 OEM_STRING NameA;
524 VFAT_DIRENTRY_CONTEXT DirContext;
525 PFATX_DIR_ENTRY pFatXDirEntry;
526 ULONG Index;
527
528 DPRINT("addEntry: Name='%wZ', Dir='%wZ'\n", NameU, &ParentFcb->PathNameU);
529
530 DirContext.LongNameU = *NameU;
531
532 if (DirContext.LongNameU.Length / sizeof(WCHAR) > 42)
533 {
534 /* name too long */
535 return STATUS_NAME_TOO_LONG;
536 }
537
538 /* try to find 1 entry free in directory */
539 if (!vfatFindDirSpace(DeviceExt, ParentFcb, 1, &DirContext.StartIndex))
540 {
541 return STATUS_DISK_FULL;
542 }
543 Index = DirContext.DirIndex = DirContext.StartIndex;
544 if (!vfatFCBIsRoot(ParentFcb))
545 {
546 DirContext.DirIndex += 2;
547 DirContext.StartIndex += 2;
548 }
549
550 DirContext.ShortNameU.Buffer = 0;
551 DirContext.ShortNameU.Length = 0;
552 DirContext.ShortNameU.MaximumLength = 0;
553 RtlZeroMemory(&DirContext.DirEntry.FatX, sizeof(FATX_DIR_ENTRY));
554 memset(DirContext.DirEntry.FatX.Filename, 0xff, 42);
555 DirContext.DirEntry.FatX.FirstCluster = 0;
556 DirContext.DirEntry.FatX.FileSize = 0;
557
558 /* set file name */
559 NameA.Buffer = (PCHAR)DirContext.DirEntry.FatX.Filename;
560 NameA.Length = 0;
561 NameA.MaximumLength = 42;
562 RtlUnicodeStringToOemString(&NameA, &DirContext.LongNameU, FALSE);
563 DirContext.DirEntry.FatX.FilenameLength = (unsigned char)NameA.Length;
564
565 /* set attributes */
566 DirContext.DirEntry.FatX.Attrib = ReqAttr;
567 if (RequestedOptions & FILE_DIRECTORY_FILE)
568 {
569 DirContext.DirEntry.FatX.Attrib |= FILE_ATTRIBUTE_DIRECTORY;
570 }
571
572 /* set dates and times */
573 KeQuerySystemTime(&SystemTime);
574 FsdSystemTimeToDosDateTime(DeviceExt, &SystemTime, &DirContext.DirEntry.FatX.CreationDate,
575 &DirContext.DirEntry.FatX.CreationTime);
576 DirContext.DirEntry.FatX.UpdateDate = DirContext.DirEntry.FatX.CreationDate;
577 DirContext.DirEntry.FatX.UpdateTime = DirContext.DirEntry.FatX.CreationTime;
578 DirContext.DirEntry.FatX.AccessDate = DirContext.DirEntry.FatX.CreationDate;
579 DirContext.DirEntry.FatX.AccessTime = DirContext.DirEntry.FatX.CreationTime;
580
581 /* add entry into parent directory */
582 FileOffset.u.HighPart = 0;
583 FileOffset.u.LowPart = Index * sizeof(FATX_DIR_ENTRY);
584 CcPinRead(ParentFcb->FileObject, &FileOffset, sizeof(FATX_DIR_ENTRY),
585 TRUE, &Context, (PVOID*)&pFatXDirEntry);
586 RtlCopyMemory(pFatXDirEntry, &DirContext.DirEntry.FatX, sizeof(FATX_DIR_ENTRY));
587 CcSetDirtyPinnedData(Context, NULL);
588 CcUnpinData(Context);
589
590 /* FIXME: check status */
591 vfatMakeFCBFromDirEntry(DeviceExt, ParentFcb, &DirContext, Fcb);
592
593 DPRINT("addentry ok\n");
594 return STATUS_SUCCESS;
595 }
596
597 NTSTATUS
598 VfatAddEntry(
599 IN PDEVICE_EXTENSION DeviceExt,
600 IN PUNICODE_STRING NameU,
601 IN PVFATFCB *Fcb,
602 IN PVFATFCB ParentFcb,
603 IN ULONG RequestedOptions,
604 IN UCHAR ReqAttr)
605 {
606 if (DeviceExt->Flags & VCB_IS_FATX)
607 return FATXAddEntry(DeviceExt, NameU, Fcb, ParentFcb, RequestedOptions, ReqAttr);
608 else
609 return FATAddEntry(DeviceExt, NameU, Fcb, ParentFcb, RequestedOptions, ReqAttr);
610 }
611
612 /*
613 * deleting an existing FAT entry
614 */
615 static NTSTATUS
616 FATDelEntry(
617 IN PDEVICE_EXTENSION DeviceExt,
618 IN PVFATFCB pFcb)
619 {
620 ULONG CurrentCluster = 0, NextCluster, i;
621 PVOID Context = NULL;
622 LARGE_INTEGER Offset;
623 PFAT_DIR_ENTRY pDirEntry = NULL;
624
625 ASSERT(pFcb);
626 ASSERT(pFcb->parentFcb);
627
628 DPRINT("delEntry PathName \'%wZ\'\n", &pFcb->PathNameU);
629 DPRINT("delete entry: %d to %d\n", pFcb->startIndex, pFcb->dirIndex);
630 Offset.u.HighPart = 0;
631 for (i = pFcb->startIndex; i <= pFcb->dirIndex; i++)
632 {
633 if (Context == NULL || ((i * sizeof(FAT_DIR_ENTRY)) % PAGE_SIZE) == 0)
634 {
635 if (Context)
636 {
637 CcSetDirtyPinnedData(Context, NULL);
638 CcUnpinData(Context);
639 }
640 Offset.u.LowPart = (i * sizeof(FAT_DIR_ENTRY) / PAGE_SIZE) * PAGE_SIZE;
641 CcPinRead(pFcb->parentFcb->FileObject, &Offset, sizeof(FAT_DIR_ENTRY), TRUE,
642 &Context, (PVOID*)&pDirEntry);
643 }
644 pDirEntry[i % (PAGE_SIZE / sizeof(FAT_DIR_ENTRY))].Filename[0] = 0xe5;
645 if (i == pFcb->dirIndex)
646 {
647 CurrentCluster =
648 vfatDirEntryGetFirstCluster(DeviceExt,
649 (PDIR_ENTRY)&pDirEntry[i % (PAGE_SIZE / sizeof(FAT_DIR_ENTRY))]);
650 }
651 }
652 if (Context)
653 {
654 CcSetDirtyPinnedData(Context, NULL);
655 CcUnpinData(Context);
656 }
657
658 while (CurrentCluster && CurrentCluster != 0xffffffff)
659 {
660 GetNextCluster(DeviceExt, CurrentCluster, &NextCluster);
661 /* FIXME: check status */
662 WriteCluster(DeviceExt, CurrentCluster, 0);
663 CurrentCluster = NextCluster;
664 }
665 return STATUS_SUCCESS;
666 }
667
668 /*
669 * deleting an existing FAT entry
670 */
671 static NTSTATUS
672 FATXDelEntry(
673 IN PDEVICE_EXTENSION DeviceExt,
674 IN PVFATFCB pFcb)
675 {
676 ULONG CurrentCluster = 0, NextCluster;
677 PVOID Context = NULL;
678 LARGE_INTEGER Offset;
679 PFATX_DIR_ENTRY pDirEntry;
680 ULONG StartIndex;
681
682 ASSERT(pFcb);
683 ASSERT(pFcb->parentFcb);
684 ASSERT(pFcb->Flags & FCB_IS_FATX_ENTRY);
685
686 StartIndex = pFcb->startIndex;
687
688 DPRINT("delEntry PathName \'%wZ\'\n", &pFcb->PathNameU);
689 DPRINT("delete entry: %d\n", StartIndex);
690 Offset.u.HighPart = 0;
691 Offset.u.LowPart = (StartIndex * sizeof(FATX_DIR_ENTRY) / PAGE_SIZE) * PAGE_SIZE;
692 if (!CcPinRead(pFcb->parentFcb->FileObject, &Offset, sizeof(FATX_DIR_ENTRY), TRUE,
693 &Context, (PVOID*)&pDirEntry))
694 {
695 DPRINT1("CcPinRead(Offset %x:%x, Length %d) failed\n", Offset.u.HighPart, Offset.u.LowPart, PAGE_SIZE);
696 return STATUS_UNSUCCESSFUL;
697 }
698 pDirEntry = &pDirEntry[StartIndex % (PAGE_SIZE / sizeof(FATX_DIR_ENTRY))];
699 pDirEntry->FilenameLength = 0xe5;
700 CurrentCluster = vfatDirEntryGetFirstCluster(DeviceExt,
701 (PDIR_ENTRY)pDirEntry);
702 CcSetDirtyPinnedData(Context, NULL);
703 CcUnpinData(Context);
704
705 while (CurrentCluster && CurrentCluster != 0xffffffff)
706 {
707 GetNextCluster(DeviceExt, CurrentCluster, &NextCluster);
708 /* FIXME: check status */
709 WriteCluster(DeviceExt, CurrentCluster, 0);
710 CurrentCluster = NextCluster;
711 }
712 return STATUS_SUCCESS;
713 }
714
715 NTSTATUS
716 VfatDelEntry(
717 IN PDEVICE_EXTENSION DeviceExt,
718 IN PVFATFCB pFcb)
719 {
720 if (DeviceExt->Flags & VCB_IS_FATX)
721 return FATXDelEntry(DeviceExt, pFcb);
722 else
723 return FATDelEntry(DeviceExt, pFcb);
724 }
725
726 /* EOF */