?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Change gfx.hidd API -:
[AROS.git] / workbench / fs / ntfs / ntfs.c
blobfe0682e1404c327d802f371589a015a4e2d8c0f5
1 /*
2 * ntfs.handler - New Technology FileSystem handler
3 *
4 * Copyright © 2012 The AROS Development Team
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the same terms as AROS itself.
8 *
9 * $Id $
10 */
11
12 #include <aros/macros.h>
13 #include <exec/errors.h>
14 #include <exec/types.h>
15 #include <dos/dos.h>
16 #include <dos/dosextens.h>
17 #include <dos/filehandler.h>
18
19 #include <proto/exec.h>
20 #include <proto/dos.h>
21 #include <proto/utility.h>
22 #include <proto/uuid.h>
23 #include <proto/codesets.h>
24
25 #include <clib/macros.h>
26
27 #include <string.h>
28 #include <ctype.h>
29
30 #include "ntfs_fs.h"
31 #include "ntfs_protos.h"
32
33 //#define DEBUG_MFT
34 #include "debug.h"
35
36 extern struct Globals *glob;
37
38 ULONG PostProcessMFTRecord(struct FSData *fs_data, struct MFTRecordEntry *record, int len, UBYTE *magic)
39 {
40 UWORD seqarray_len, seqnum;
41 UBYTE *seqarray, *buf;
42
43 buf = (UBYTE *)record;
44
45 D(bug("[NTFS]: %s(%.4s)\n", __PRETTY_FUNCTION__, magic));
46
47 /* Perform post-read MST fixup by applying the sequence array to acquired blocks */
48
49 D(bug("[NTFS] %s: FSData @ 0x%p\n", __PRETTY_FUNCTION__, fs_data));
50 D(bug("[NTFS] %s: MFTRecordEntry @ 0x%p\n", __PRETTY_FUNCTION__, record));
51
52 if (memcmp(record->header.magic, magic, 4))
53 {
54 D(
55 bug("[NTFS] %s: record magic mismatch (got '%.4s')\n", __PRETTY_FUNCTION__, record->header.magic);
56 )
57 return ERROR_OBJECT_WRONG_TYPE ;
58 }
59
60 seqarray_len = AROS_LE2WORD(record->header.usa_count) - 1;
61
62 if (seqarray_len != len)
63 {
64 D(bug("[NTFS] %s: fixup error - sequence array size != record size\n", __PRETTY_FUNCTION__));
65 return ERROR_NOT_IMPLEMENTED;
66 }
67
68 seqarray = (char *)record + AROS_LE2WORD(record->header.usa_offset);
69 seqnum = AROS_LE2WORD(*((UWORD*)seqarray));
70
71 D(bug("[NTFS] %s: update sequence = %u (usa_offset %u)\n", __PRETTY_FUNCTION__, seqnum, AROS_LE2WORD(record->header.usa_offset)));
72
73 while (seqarray_len > 0)
74 {
75 buf += fs_data->sectorsize;
76 seqarray += 2;
77 if (AROS_LE2WORD(*((UWORD*)(buf - 2))) != seqnum)
78 {
79 D(bug("[NTFS] %s: update sequence mismatch @ 0x%p (%u != %u)\n", __PRETTY_FUNCTION__, buf, AROS_LE2WORD(*((UWORD*)buf)), seqnum));
80 return ERROR_NOT_IMPLEMENTED;
81 }
82
83 *((UWORD*)(buf - 2)) = *((UWORD*)seqarray);
84 seqarray_len--;
85 }
86
87 D(bug("[NTFS] %s: record fixup complete\n", __PRETTY_FUNCTION__));
88
89 return 0;
90 }
91
92 ULONG PreProcessMFTRecord(struct FSData *fs_data, struct MFTRecordEntry *record, int len)
93 {
94 D(bug("[NTFS]: %s(MFTRecordEntry @ 0x%p)\n", __PRETTY_FUNCTION__, record));
95
96 /* Perform pre-write MST fixup. set the sequence numbers of blocks */
97
98 return 0;
99 }
100
101 struct MFTAttr *GetMappingPairPos(UBYTE *mappos, int nn, UQUAD *val, int sig)
102 {
103 UQUAD pos = 0;
104 UQUAD mask = 1;
105
106 D(bug("[NTFS]: %s()\n", __PRETTY_FUNCTION__));
107
108 while (nn--)
109 {
110 pos += mask * (*mappos);
111 mappos += 1;
112 mask <<= 8;
113 }
114
115 if ((sig) && (pos & (mask >> 1)))
116 pos -= mask;
117
118 *val = pos;
119 return (struct MFTAttr *)mappos;
120 }
121
122 IPTR ReadNTFSRunList(struct NTFSRunLstEntry * rle)
123 {
124 int len, offs;
125 UQUAD val;
126 struct MFTAttr *mappos = (struct MFTAttr *)rle->mappingpair;
127
128 D(bug("[NTFS]: %s(mappos @ 0x%p)\n", __PRETTY_FUNCTION__, mappos));
129
130 retry:
131 len = (*(UBYTE *)mappos & 0xF);
132 offs = (*(UBYTE *)mappos >> 4);
133
134 D(bug("[NTFS] %s: len = %u\n", __PRETTY_FUNCTION__, len));
135 D(bug("[NTFS] %s: offs = %u\n", __PRETTY_FUNCTION__, offs));
136
137 if (!len)
138 {
139 D(bug("[NTFS] %s: !len\n", __PRETTY_FUNCTION__));
140 if ((rle->attr) && (rle->attr->flags & AF_ALST))
141 {
142 D(bug("[NTFS] %s: AF_ALST\n", __PRETTY_FUNCTION__));
143
144 mappos = FindMFTAttrib(rle->attr, *(UBYTE *)rle->attr->attr_cur);
145
146 if (mappos)
147 {
148 D(bug("[NTFS] %s: 'RUN'\n", __PRETTY_FUNCTION__));
149 if (mappos->residentflag == ATTR_RESIDENT_FORM)
150 {
151 D(bug("[NTFS] %s: $DATA should be non-resident\n", __PRETTY_FUNCTION__));
152 return ~0;
153 }
154
155 mappos = (struct MFTAttr *)(IPTR)((IPTR)mappos + AROS_LE2WORD(mappos->data.non_resident.mapping_pairs_offset));
156 rle->curr_lcn = 0;
157 goto retry;
158 }
159 }
160 D(bug("[NTFS] %s: run list overflow\n", __PRETTY_FUNCTION__));
161 return ~0;
162 }
163 // current VCN length
164 mappos = GetMappingPairPos((UBYTE *)mappos + 1, len, &val, 0);
165 rle->curr_vcn = rle->next_vcn;
166 rle->next_vcn = rle->next_vcn + val;
167
168 D(bug("[NTFS] %s: curr_vcn = %u, next_vcn = %u, val = %u\n", __PRETTY_FUNCTION__, (unsigned int)rle->curr_vcn, (unsigned int)rle->next_vcn, (unsigned int)val));
169
170 // previous LCN offset
171 mappos = GetMappingPairPos((UBYTE *)mappos, offs, &val, 1);
172 rle->curr_lcn = rle->curr_lcn + val;
173
174 D(bug("[NTFS] %s: curr_lcn = %u\n", __PRETTY_FUNCTION__, (unsigned int)rle->curr_lcn));
175
176 if (val == 0)
177 rle->flags |= RLEFLAG_SPARSE;
178 else
179 rle->flags &= ~RLEFLAG_SPARSE;
180
181 rle->mappingpair = (UBYTE *)mappos;
182
183 return 0;
184 }
185
186 void FreeMFTAttrib(struct NTFSMFTAttr *at)
187 {
188 D(bug("[NTFS]: %s(NTFSMFTAttr @ 0x%p)\n", __PRETTY_FUNCTION__, at));
189
190 FreeVec(at->edat_buf);
191 at->edat_buf = NULL;
192 if (at->emft_buf)
193 {
194 FreeMem(at->emft_buf, at->mft->data->mft_size << SECTORSIZE_SHIFT);
195 at->emft_buf = NULL;
196 }
197 if (at->sbuf)
198 {
199 FreeMem(at->sbuf, COM_LEN);
200 at->sbuf = NULL;
201 }
202 }
203
204 IPTR ReadMFTAttribData(struct NTFSMFTAttr *at, struct MFTAttr *attrentry, UBYTE *dest, UQUAD ofs, ULONG len, int cached)
205 {
206 D(UQUAD vcn);
207 struct NTFSRunLstEntry runlist_entry, *rle;
208
209 D(
210 bug("[NTFS]: %s(ofs = %u; len = %u)\n", __PRETTY_FUNCTION__, (IPTR)ofs, len);
211
212 bug("[NTFS] %s: NTFSMFTAttr @ 0x%p\n", __PRETTY_FUNCTION__, at);
213 bug("[NTFS] %s: MFTAttr @ 0x%p, dest @ 0x%p\n", __PRETTY_FUNCTION__, attrentry, dest);
214 )
215
216 if (len == 0)
217 return 0;
218
219 memset (&runlist_entry, 0, sizeof(struct NTFSRunLstEntry));
220 rle = &runlist_entry;
221 rle->attr = at;
222
223 if (AROS_LE2LONG(attrentry->data.resident.value_offset) > AROS_LE2LONG(attrentry->length))
224 {
225 D(bug("[NTFS] %s: error - corrupt attribute\n", __PRETTY_FUNCTION__));
226 return ~0;
227 }
228
229 if (attrentry->residentflag == ATTR_RESIDENT_FORM)
230 {
231 D(bug("[NTFS] %s: ATTR_RESIDENT_FORM\n", __PRETTY_FUNCTION__));
232
233 if ((ofs + len) > AROS_LE2LONG(attrentry->data.resident.value_length))
234 {
235 D(bug("[NTFS] %s: error - read out of range\n", __PRETTY_FUNCTION__));
236 return ~0;
237 }
238 CopyMem(attrentry + AROS_LE2LONG(attrentry->data.resident.value_offset) + ofs, dest, len);
239 return 0;
240 }
241
242 if (AROS_LE2WORD(attrentry->attrflags) & FLAG_COMPRESSED)
243 {
244 rle->flags |= RLEFLAG_COMPR;
245 }
246 else
247 {
248 rle->flags &= ~RLEFLAG_COMPR;
249 }
250 rle->mappingpair = (UBYTE *)(IPTR)((IPTR)attrentry + AROS_LE2WORD(attrentry->data.non_resident.mapping_pairs_offset));
251
252 D(bug("[NTFS] %s: mappingpair @ 0x%p\n", __PRETTY_FUNCTION__, rle->mappingpair));
253
254 if (rle->flags & RLEFLAG_COMPR)
255 {
256 D(bug("[NTFS] %s: ## Compressed\n", __PRETTY_FUNCTION__));
257 if (!cached)
258 {
259 D(bug("[NTFS] %s: error - attribute cannot be compressed\n", __PRETTY_FUNCTION__));
260 return ~0;
261 }
262
263 if (at->sbuf)
264 {
265 if ((ofs & (~(COM_LEN - 1))) == at->save_pos)
266 {
267 UQUAD n;
268
269 n = COM_LEN - (ofs - at->save_pos);
270 if (n > len)
271 n = len;
272
273 CopyMem(at->sbuf + ofs - at->save_pos, dest, n);
274 if (n == len)
275 return 0;
276
277 dest += n;
278 len -= n;
279 ofs += n;
280 }
281 }
282 else
283 {
284 at->sbuf = AllocMem(COM_LEN, MEMF_ANY);
285 if (at->sbuf == NULL)
286 {
287 D(bug("[NTFS] %s: error - failed to allocate sbuf\n", __PRETTY_FUNCTION__));
288 return ERROR_NO_FREE_STORE;
289 }
290 at->save_pos = 1;
291 }
292
293 D(vcn =) rle->target_vcn = (ofs >> COM_LOG_LEN) * (COM_SEC / at->mft->data->cluster_sectors);
294 rle->target_vcn &= ~0xF;
295 }
296 else
297 {
298 rle->target_vcn = (ofs >> SECTORSIZE_SHIFT) / at->mft->data->cluster_sectors;
299 D(vcn = rle->target_vcn);
300 }
301
302 rle->next_vcn = AROS_LE2QUAD(attrentry->data.non_resident.lowest_vcn);
303 rle->curr_lcn = 0;
304
305 D(bug("[NTFS] %s: vcn = %u\n", __PRETTY_FUNCTION__, vcn));
306
307 while (rle->next_vcn <= rle->target_vcn)
308 {
309 D(bug("[NTFS] %s: next_vcn = %u, target_vcn = %u\n", __PRETTY_FUNCTION__, (IPTR)rle->next_vcn, (IPTR)rle->target_vcn));
310 if (ReadNTFSRunList(rle))
311 {
312 D(bug("[NTFS] %s: read_run_list failed\n", __PRETTY_FUNCTION__));
313 return ~0;
314 }
315 }
316
317 D(bug("[NTFS] %s: next_vcn = %u\n", __PRETTY_FUNCTION__, (IPTR)rle->next_vcn));
318
319 if (at->flags & AF_GPOS)
320 {
321 UQUAD st0, st1, m;
322
323 D(bug("[NTFS] %s: AF_GPOS\n", __PRETTY_FUNCTION__));
324
325 m = (ofs >> SECTORSIZE_SHIFT) % at->mft->data->cluster_sectors;
326
327 st0 =
328 (rle->target_vcn - rle->curr_vcn + rle->curr_lcn) * at->mft->data->cluster_sectors + m;
329 st1 = st0 + 1;
330
331 if (st1 ==
332 (rle->next_vcn - rle->curr_vcn + rle->curr_lcn) * at->mft->data->cluster_sectors)
333 {
334 if (ReadNTFSRunList(rle))
335 {
336 D(bug("[NTFS] %s: read_run_list failed\n", __PRETTY_FUNCTION__));
337 return ~0;
338 }
339 st1 = rle->curr_lcn * at->mft->data->cluster_sectors;
340 }
341 *((ULONG *)dest) = AROS_LONG2LE(st0);
342 *((ULONG *)(dest + 4)) = AROS_LONG2LE(st1);
343 return 0;
344 }
345
346 if (!(rle->flags & RLEFLAG_COMPR))
347 {
348 D(bug("[NTFS] %s: ## Uncompressed\n", __PRETTY_FUNCTION__));
349
350 if (!(at->mft->data->cluster_sectors & 0x1))
351 {
352 unsigned int sectbits_shift = ilog2(at->mft->data->cluster_sectors);
353 ULONG blocksize = 1 << (sectbits_shift + SECTORSIZE_SHIFT);
354 UBYTE *buf = dest;
355
356 UQUAD i, blockcnt = ((len + ofs) + blocksize - 1) >> (sectbits_shift + SECTORSIZE_SHIFT);
357
358 D(
359 bug("[NTFS] %s: blockcnt = %u\n", __PRETTY_FUNCTION__, (IPTR)blockcnt);
360 bug("[NTFS] %s: blocksize = %u\n", __PRETTY_FUNCTION__, blocksize);
361 )
362
363 for (i = ofs >> (sectbits_shift + SECTORSIZE_SHIFT); i < blockcnt; i++)
364 {
365 UQUAD blockstart;
366 UQUAD blockoff = ofs & (blocksize - 1);
367 UQUAD blockend = blocksize;
368 UQUAD skipfirst = 0;
369
370 D(
371 bug("[NTFS] %s: blockoff = %u\n", __PRETTY_FUNCTION__, (IPTR)blockoff);
372 bug("[NTFS] %s: blockend = %u\n", __PRETTY_FUNCTION__, (IPTR)blockend);
373 )
374
375 if (i >= rle->next_vcn)
376 {
377 if (ReadNTFSRunList(rle))
378 {
379 D(bug("[NTFS] %s: failed to read run list!\n", __PRETTY_FUNCTION__));
380 return -1;
381 }
382
383 blockstart = rle->curr_lcn;
384 }
385 else
386 {
387 blockstart = (rle->flags & RLEFLAG_SPARSE) ? 0 : (i - rle->curr_vcn + rle->curr_lcn);
388 }
389
390 blockstart = blockstart << sectbits_shift;
391
392 /* Last block. */
393 if (i == (blockcnt - 1))
394 {
395 D(bug("[NTFS] %s: last block.. \n", __PRETTY_FUNCTION__));
396
397 blockend = (len + ofs) & (blocksize - 1);
398
399 /* The last portion is exactly blocksize. */
400 if (! blockend)
401 blockend = blocksize;
402 }
403
404 /* First block. */
405 if (i == (ofs >> (sectbits_shift + SECTORSIZE_SHIFT)))
406 {
407 D(bug("[NTFS] %s: first block.. \n", __PRETTY_FUNCTION__));
408
409 skipfirst = blockoff;
410 blockend -= skipfirst;
411 }
412
413 /* If the block number is 0 this block is not stored on disk but is zero filled instead. */
414
415 D(
416 bug("[NTFS] %s: blockstart = %u\n", __PRETTY_FUNCTION__, (IPTR)blockstart);
417 bug("[NTFS] %s: blockend = %u\n", __PRETTY_FUNCTION__, (IPTR)blockend);
418 bug("[NTFS] %s: skipfirst = %u\n", __PRETTY_FUNCTION__, (IPTR)skipfirst);
419 )
420
421 if (blockstart)
422 {
423 UQUAD blocknr, skipblocks = skipfirst >> SECTORSIZE_SHIFT, lastblock = ((blockend + skipfirst) >> SECTORSIZE_SHIFT);
424 APTR blockbuf, bufstart = buf;
425 IPTR copysize;
426
427 if (lastblock == 0)
428 lastblock = 1;
429
430 for (blocknr = skipblocks; blocknr < lastblock; blocknr++)
431 {
432 D(bug("[NTFS] %s: block %u\n", __PRETTY_FUNCTION__, (IPTR)blocknr));
433 if (blocknr >= (skipfirst >> SECTORSIZE_SHIFT))
434 {
435 D(bug("[NTFS] %s: reading ..\n", __PRETTY_FUNCTION__));
436
437 if ((at->mft->cblock = Cache_GetBlock(at->mft->data->cache, at->mft->data->first_device_sector + blockstart + blocknr, &at->mft->cbuf)) == NULL)
438 {
439 D(bug("[NTFS] %s: read failed\n", __PRETTY_FUNCTION__));
440 return IoErr();
441 }
442
443 D(bug("[NTFS] %s: cbuf @ 0x%p\n", __PRETTY_FUNCTION__, at->mft->cbuf));
444
445 if (blocknr == (lastblock - 1) && (blockend & (at->mft->data->sectorsize - 1)))
446 copysize = (blockend & (at->mft->data->sectorsize - 1));
447 else
448 copysize = at->mft->data->sectorsize;
449
450 if ((blocknr << SECTORSIZE_SHIFT) < skipfirst)
451 {
452 blockbuf = at->mft->cbuf + (skipfirst & (at->mft->data->sectorsize - 1));
453
454 copysize -= (skipfirst & (at->mft->data->sectorsize - 1));
455 }
456 else
457 {
458 blockbuf = at->mft->cbuf;
459 }
460
461 if (copysize > 0)
462 {
463 D(bug("[NTFS] %s: copying %u bytes from 0x%p -> 0x%p\n", __PRETTY_FUNCTION__, copysize, blockbuf, bufstart));
464 CopyMem(blockbuf, bufstart, copysize);
465 }
466 bufstart +=copysize;
467
468 Cache_FreeBlock(at->mft->data->cache, at->mft->cblock);
469 at->mft->cblock = NULL;
470 }
471 }
472 }
473 else
474 memset (buf, 0, blockend);
475
476 buf += blocksize - skipfirst;
477 }
478
479 }
480 return 0;
481 }
482
483 /* Warning : TODO - decompress block */
484 D(bug("[NTFS] %s: cannot decompress\n", __PRETTY_FUNCTION__));
485 return ~0;
486 }
487
488 IPTR ReadMFTAttrib(struct NTFSMFTAttr *at, UBYTE *dest, UQUAD ofs, ULONG len, int cached)
489 {
490 struct MFTAttr *save_cur;
491 UBYTE attr;
492 struct MFTAttr *attrentry;
493 IPTR ret;
494
495 D(bug("[NTFS]: %s(NTFSMFTAttr @ 0x%p; ofs = %d; len = %d)\n", __PRETTY_FUNCTION__, at, (IPTR)ofs, len));
496
497 save_cur = at->attr_cur;
498 at->attr_nxt = at->attr_cur;
499 attr = *(UBYTE *)at->attr_nxt;
500 if (at->flags & AF_ALST)
501 {
502 UQUAD vcn;
503
504 D(bug("[NTFS] %s: AF_ALST\n", __PRETTY_FUNCTION__));
505
506 vcn = ofs / (at->mft->data->cluster_sectors << SECTORSIZE_SHIFT);
507 attrentry = (struct MFTAttr *)((IPTR)at->attr_nxt + AROS_LE2WORD(at->attr_nxt->length));
508 while (attrentry < at->attr_end)
509 {
510 if (*(UBYTE *)attrentry != attr)
511 break;
512 if (AROS_LE2LONG(*((ULONG *)(attrentry + 8))) > vcn)
513 break;
514 at->attr_nxt = attrentry;
515 attrentry = (struct MFTAttr *)((IPTR)attrentry + AROS_LE2WORD(attrentry->length));
516 }
517 }
518 attrentry = FindMFTAttrib(at, attr);
519 if (attrentry)
520 ret = ReadMFTAttribData(at, attrentry, dest, ofs, len, cached);
521 else
522 {
523 D(bug("[NTFS] %s: attribute %u not found\n", __PRETTY_FUNCTION__, attr));
524 ret = ~0;
525 }
526 at->attr_cur = save_cur;
527 return ret;
528 }
529
530 static IPTR ReadMFTRecord(struct NTFSMFTEntry *mft, UBYTE *buf, ULONG mft_id)
531 {
532 D(bug("[NTFS]: %s(%d)\n", __PRETTY_FUNCTION__, mft_id));
533
534 if (ReadMFTAttrib
535 (&mft->data->mft.attr, buf, mft_id * ((UQUAD) mft->data->mft_size << SECTORSIZE_SHIFT),
536 mft->data->mft_size << SECTORSIZE_SHIFT, 0))
537 {
538 D(bug("[NTFS] %s: failed to read MFT #%d\n", __PRETTY_FUNCTION__, mft_id));
539 return ~0;
540 }
541 #if defined(DEBUG_MFT)
542 D(
543 int dumpx;
544
545 bug("[NTFS] %s: MFTRecord #%d Dump -:\n", __PRETTY_FUNCTION__, mft_id);
546 bug("[NTFS] %s: MFTRecord #%d buf @ 0x%p, size %d x %d", __PRETTY_FUNCTION__, mft_id, buf, mft->data->mft_size, mft->data->sectorsize);
547
548 for (dumpx = 0; dumpx < (mft->data->mft_size * mft->data->sectorsize) ; dumpx ++)
549 {
550 if ((dumpx%16) == 0)
551 {
552 bug("\n[NTFS] %s:\t%03x:", __PRETTY_FUNCTION__, dumpx);
553 }
554 bug(" %02x", ((UBYTE*)buf)[dumpx]);
555 }
556 bug("\n");
557 )
558 #endif
559 return PostProcessMFTRecord (mft->data, (struct MFTRecordEntry *)buf, mft->data->mft_size, "FILE");
560 }
561
562 struct MFTAttr *FindMFTAttrib(struct NTFSMFTAttr *at, UBYTE attr)
563 {
564 D(bug("[NTFS]: %s(%u)\n", __PRETTY_FUNCTION__, attr));
565
566 if (at->flags & AF_ALST)
567 {
568 D(bug("[NTFS] %s: AF_ALST\n", __PRETTY_FUNCTION__));
569 retry:
570 while (at->attr_nxt < at->attr_end)
571 {
572 at->attr_cur = at->attr_nxt;
573 at->attr_nxt = (struct MFTAttr *)((IPTR)at->attr_nxt + AROS_LE2WORD(at->attr_cur->length));
574
575 D(bug("[NTFS] %s: attr_cur @ 0x%p, attr_nxt @ 0x%p\n", __PRETTY_FUNCTION__, at->attr_cur, at->attr_nxt ));
576
577 if ((*(UBYTE *)at->attr_cur == attr) || (attr == 0))
578 {
579 UBYTE *new_pos;
580
581 D(bug("[NTFS] %s: attr %u found @ 0x%p\n", __PRETTY_FUNCTION__, attr, at->attr_cur));
582
583 if (at->flags & AF_MMFT)
584 {
585 D(bug("[NTFS] %s: AF_MMFT\n", __PRETTY_FUNCTION__));
586
587 if ((at->mft->cblock = Cache_GetBlock(at->mft->data->cache, at->mft->data->first_device_sector + AROS_LE2LONG(*((ULONG *)(at->attr_cur + 0x10))), &at->mft->cbuf)) == NULL)
588 {
589 D(bug("[NTFS] %s: read failed\n", __PRETTY_FUNCTION__));
590 return NULL;
591 }
592 CopyMem(at->mft->cbuf, at->emft_buf, at->mft->data->sectorsize);
593 Cache_FreeBlock(at->mft->data->cache, at->mft->cblock);
594 at->mft->cblock = NULL;
595
596 if ((at->mft->cblock = Cache_GetBlock(at->mft->data->cache, at->mft->data->first_device_sector + AROS_LE2LONG(*((ULONG *)(at->attr_cur + 0x14))), &at->mft->cbuf)) == NULL)
597 {
598 D(bug("[NTFS] %s: read failed\n", __PRETTY_FUNCTION__));
599 return NULL;
600 }
601 CopyMem(at->mft->cbuf, at->emft_buf + at->mft->data->sectorsize, at->mft->data->sectorsize);
602 Cache_FreeBlock(at->mft->data->cache, at->mft->cblock);
603 at->mft->cblock = NULL;
604
605 if (PostProcessMFTRecord
606 (at->mft->data, (struct MFTRecordEntry *)at->emft_buf, at->mft->data->mft_size,
607 "FILE"))
608 return NULL;
609 }
610 else
611 {
612 D(bug("[NTFS] %s: !AF_MMFT\n", __PRETTY_FUNCTION__));
613
614 if (ReadMFTRecord(at->mft, (UBYTE *)at->emft_buf,
615 AROS_LE2LONG(at->attr_cur->data.resident.value_length)))
616 return NULL;
617 }
618
619 new_pos = &((UBYTE *)at->emft_buf)[AROS_LE2WORD(at->emft_buf->data.resident.value_offset)];
620 while ((UBYTE) *new_pos != 0xFF)
621 {
622 if ((*new_pos ==
623 *(UBYTE *)at->attr_cur)
624 && (AROS_LE2WORD(*((UWORD *)(new_pos + 0xE))) == AROS_LE2WORD(*((UWORD *)(at->attr_cur + 0x18)))))
625 {
626 return (struct MFTAttr *)new_pos;
627 }
628 new_pos += AROS_LE2WORD(*((UWORD *)(new_pos + 4)));
629 }
630 D(bug("[NTFS] %s: %u not found in attribute list!\n", __PRETTY_FUNCTION__, at->attr_cur));
631 return NULL;
632 }
633 }
634 return NULL;
635 }
636
637 at->attr_cur = at->attr_nxt;
638
639 while (*(UBYTE *)at->attr_cur != 0xFF)
640 {
641 at->attr_nxt = (struct MFTAttr *)((IPTR)at->attr_nxt + AROS_LE2WORD(at->attr_cur->length));
642
643 D(bug("[NTFS] %s: attr_cur @ 0x%p, attr_nxt @ 0x%p (offset %u) \n", __PRETTY_FUNCTION__, at->attr_cur, at->attr_nxt, AROS_LE2WORD(at->attr_cur->length)));
644
645 if (*(UBYTE *)at->attr_cur == AT_ATTRIBUTE_LIST)
646 at->attr_end = at->attr_cur;
647 if ((*(UBYTE *)at->attr_cur == attr) || (attr == 0))
648 {
649 D(bug("[NTFS] %s: returning attr_cur @ 0x%p\n", __PRETTY_FUNCTION__, at->attr_cur));
650 return at->attr_cur;
651 }
652 at->attr_cur = at->attr_nxt;
653 }
654 if (at->attr_end)
655 {
656 struct MFTAttr *attrentry;
657
658 D(bug("[NTFS] %s: attr_end @ 0x%p\n", __PRETTY_FUNCTION__, at->attr_end));
659
660 at->emft_buf = AllocMem(at->mft->data->mft_size << SECTORSIZE_SHIFT, MEMF_ANY);
661 if (at->emft_buf == NULL)
662 return NULL;
663
664 D(bug("[NTFS] %s: emft_buf allocated @ 0x%p\n", __PRETTY_FUNCTION__, at->emft_buf));
665
666 attrentry = at->attr_end;
667
668 if (attrentry->residentflag == ATTR_NONRESIDENT_FORM)
669 {
670 int n;
671
672 n = ((AROS_LE2QUAD(attrentry->data.non_resident.data_size) + (512 - 1)) & (~(512 - 1)));
673 at->attr_cur = at->attr_end;
674 at->edat_buf = AllocVec(n, MEMF_ANY);
675 if (!at->edat_buf)
676 return NULL;
677
678 D(bug("[NTFS] %s: edat_buf allocated @ 0x%p\n", __PRETTY_FUNCTION__, at->edat_buf));
679
680 if (ReadMFTAttribData(at, attrentry, (UBYTE *)at->edat_buf, 0, n, 0))
681 {
682 D(bug("[NTFS] %s: failed to read non-resident attribute list!\n", __PRETTY_FUNCTION__));
683 }
684 at->attr_nxt = at->edat_buf;
685 /* Note: The extra '(IPTR)' cast here shuts up
686 * gcc warnings on 32-bit architectures
687 * (converting a QUAD to a 32-bit pointer
688 */
689 at->attr_end = (struct MFTAttr *)(IPTR)((IPTR)at->edat_buf + AROS_LE2QUAD(attrentry->data.non_resident.data_size));
690 }
691 else
692 {
693 at->attr_nxt = (struct MFTAttr *)((IPTR)at->attr_end + AROS_LE2WORD(attrentry->data.resident.value_offset));
694 at->attr_end = (struct MFTAttr *)((IPTR)at->attr_end + AROS_LE2LONG(attrentry->length));
695 D(bug("[NTFS] %s: attr_nxt @ 0x%p, attr_end @ 0x%p\n", __PRETTY_FUNCTION__, at->attr_nxt, at->attr_end));
696 }
697 at->flags |= AF_ALST;
698 while (at->attr_nxt < at->attr_end)
699 {
700 if ((*(UBYTE *)at->attr_nxt == attr) || (attr == 0))
701 break;
702 at->attr_nxt = (struct MFTAttr *)((IPTR)at->attr_nxt + AROS_LE2WORD(at->attr_nxt->length));
703 }
704 if (at->attr_nxt >= at->attr_end)
705 return NULL;
706
707 if ((at->flags & AF_MMFT) && (attr == AT_DATA))
708 {
709 D(bug("[NTFS] %s: AT_DATA && AF_MMFT\n", __PRETTY_FUNCTION__));
710
711 at->flags |= AF_GPOS;
712 at->attr_cur = at->attr_nxt;
713 attrentry = at->attr_cur;
714 attrentry->data.resident.value_length = AROS_LONG2LE(at->mft->data->mft_start);
715 attrentry->data.resident.value_offset = AROS_WORD2LE(at->mft->data->mft_start + 1);
716 attrentry = (struct MFTAttr *)((IPTR)at->attr_nxt + AROS_LE2WORD(attrentry->length));
717 while (attrentry < at->attr_end)
718 {
719 if (*(UBYTE *)attrentry != attr)
720 break;
721 if (ReadMFTAttrib
722 (at, (UBYTE *)(attrentry + 0x10),
723 AROS_LE2LONG(attrentry->data.resident.value_length) * (at->mft->data->mft_size << SECTORSIZE_SHIFT),
724 at->mft->data->mft_size << SECTORSIZE_SHIFT, 0))
725 return NULL;
726 attrentry = (struct MFTAttr *)((IPTR)attrentry + AROS_LE2WORD(attrentry->length));
727 }
728 at->attr_nxt = at->attr_cur;
729 at->flags &= ~AF_GPOS;
730 }
731 goto retry;
732 }
733 return NULL;
734 }
735
736 struct MFTAttr *MapMFTAttrib(struct NTFSMFTAttr *at, struct NTFSMFTEntry *mft, UBYTE attr)
737 {
738 struct MFTAttr *attrentry;
739
740 D(bug("[NTFS]: %s(%ld)\n", __PRETTY_FUNCTION__, attr));
741
742 INIT_MFTATTRIB(at, mft);
743 if ((attrentry = FindMFTAttrib(at, attr)) == NULL)
744 return NULL;
745
746 if ((at->flags & AF_ALST) == 0)
747 {
748 while (1)
749 {
750 if ((attrentry = FindMFTAttrib(at, attr)) == NULL)
751 break;
752 if (at->flags & AF_ALST)
753 return attrentry;
754 }
755 FreeMFTAttrib(at);
756 INIT_MFTATTRIB(at, mft);
757 attrentry = FindMFTAttrib(at, attr);
758 }
759 return attrentry;
760 }
761
762 IPTR InitMFTEntry(struct NTFSMFTEntry *mft, ULONG mft_id)
763 {
764 struct MFTRecordEntry *record;
765 unsigned short flag;
766
767 D(bug("[NTFS]: %s(%ld)\n", __PRETTY_FUNCTION__, mft_id));
768
769 mft->buf_filled = 1;
770
771 if (mft->buf != NULL)
772 {
773 D(bug("[NTFS] %s: NTFSMFTEntry @ 0x%p in use? (mft->buf != NULL)\n", __PRETTY_FUNCTION__, mft));
774 return ~0;
775 }
776
777 mft->buf = AllocMem(mft->data->mft_size << SECTORSIZE_SHIFT, MEMF_ANY);
778 if ((record = (struct MFTRecordEntry *)mft->buf) == NULL)
779 {
780 return ERROR_NO_FREE_STORE;
781 }
782
783 if (ReadMFTRecord(mft, mft->buf, mft_id))
784 {
785 D(bug("[NTFS] %s: failed to read MFT #%d\n", __PRETTY_FUNCTION__, mft_id));
786 return ~0;
787 }
788
789 flag = AROS_LE2WORD(record->flags);
790 if ((flag & FILERECORD_SEGMENT_IN_USE) == 0)
791 {
792 D(bug("[NTFS] %s: MFT not in use!\n", __PRETTY_FUNCTION__));
793 return ~0;
794 }
795
796 if ((flag & FILERECORD_NAME_INDEX_PRESENT) == 0)
797 {
798 struct MFTAttr *attrentry;
799
800 attrentry = MapMFTAttrib(&mft->attr, mft, AT_DATA);
801 if (attrentry == NULL)
802 {
803 D(bug("[NTFS] %s: No $DATA in MFT #%d\n", __PRETTY_FUNCTION__, mft_id));
804 return ~0;
805 }
806
807 if (attrentry->residentflag == ATTR_RESIDENT_FORM)
808 {
809 mft->size = AROS_LE2LONG(*(ULONG *)((IPTR)attrentry + 0x10));
810 }
811 else
812 {
813 mft->size = AROS_LE2QUAD(*(UQUAD *)((IPTR)attrentry + 0x30));
814 }
815
816 if ((mft->attr.flags & AF_ALST) == 0)
817 mft->attr.attr_end = 0; /* Don't jump to attribute list */
818 }
819 else
820 {
821 INIT_MFTATTRIB(&mft->attr, mft);
822 }
823
824 return 0;
825 }
826
827 LONG
828 ProcessFSEntry(struct NTFSMFTEntry *diro, struct DirEntry *de, ULONG **countptr)
829 {
830 ULONG *count = NULL;
831 UBYTE *np;
832 int ns_len;
833
834 D(bug("[NTFS]: %s(NTFSMFTEntry @ 0x%p)\n", __PRETTY_FUNCTION__, diro));
835
836 if (countptr)
837 {
838 count = *countptr;
839 D(bug("[NTFS] %s: counter @ 0x%p, val = %d\n", __PRETTY_FUNCTION__, count, *count));
840 }
841
842 while (1)
843 {
844 UBYTE ns_type;
845
846 D(bug("[NTFS] %s: pos = 0x%p\n", __PRETTY_FUNCTION__, de->key->pos));
847
848
849 if (de->key->pos >= de->key->indx + (diro->data->idx_size << SECTORSIZE_SHIFT))
850 {
851 D(bug("[NTFS] %s: reached index record buffer end\n", __PRETTY_FUNCTION__));
852 de->key->pos = 0;
853 return 0;
854 }
855
856 if (de->key->pos[0xC] & INDEX_ENTRY_END) /* end of index signature */
857 {
858 D(bug("[NTFS] %s: reached index-record end signature\n", __PRETTY_FUNCTION__));
859 de->key->pos = 0;
860 return 0;
861 }
862
863 np = de->key->pos + 0x50;
864 ns_len = (UBYTE) *(np++);
865 ns_type = *(np++);
866
867 D(bug("[NTFS] %s: np = 0x%p, ns_len = %d (type = %d)\n", __PRETTY_FUNCTION__, np, ns_len, ns_type));
868
869 /* ignore DOS namespace files (we want Win32 versions) */
870 if ((ns_len) && (ns_type != 2))
871 {
872 int i;
873
874 if (AROS_LE2WORD(*((UWORD *)(de->key->pos + 4))))
875 {
876 D(bug("[NTFS] %s: **skipping** [64bit mft number]\n", __PRETTY_FUNCTION__));
877 return 0;
878 }
879
880 D(bug("[NTFS] %s: type = %d\n", __PRETTY_FUNCTION__, AROS_LE2LONG(*((ULONG *)(de->key->pos + 0x48)))));
881
882 if (de)
883 {
884 FreeVec(de->entryname);
885 de->entryname = NULL;
886 }
887
888 if (de && de->data)
889 {
890 if (count)
891 *count += 1;
892
893 if (!de->entry)
894 de->entry = AllocMem(sizeof (struct NTFSMFTEntry), MEMF_ANY|MEMF_CLEAR);
895
896 if (!de->entry)
897 {
898 D(bug("[NTFS] %s: failed to allocate NTFSMFTEntry\n", __PRETTY_FUNCTION__));
899 return ERROR_NO_FREE_STORE;
900 }
901
902 de->entry->data = diro->data;
903
904 de->entry->mftrec_no = AROS_LE2LONG(*(ULONG *)de->key->pos);
905
906 de->entrytype = AROS_LE2LONG(*((ULONG *)(de->key->pos + 0x48)));
907
908 if ((de->entryname = AllocVec(ns_len + 1, MEMF_ANY)) == NULL)
909 return ERROR_NO_FREE_STORE;
910
911 for (i = 0; i < ns_len; i++)
912 {
913 de->entryname[i] = glob->from_unicode[AROS_LE2WORD(*((UWORD *)(np + (i * 2))))];
914 }
915 de->entryname[ns_len] = '\0';
916
917 D(
918 bug("[NTFS] %s: ", __PRETTY_FUNCTION__);
919 if (count)
920 {
921 bug("[#%d]", *count);
922 }
923 bug(" Label '%s'\n", de->entryname);
924 )
925
926 if ((!count) || ((count) && (*count == de->no)))
927 return 1;
928 }
929 }
930 de->key->pos += AROS_LE2WORD(*((UWORD *)(de->key->pos + 8)));
931 }
932 return 0;
933 }
934
935 int bitcount(ULONG n)
936 {
937 register unsigned int tmp;
938 tmp = n - ((n >> 1) & 033333333333)
939 - ((n >> 2) & 011111111111);
940 return ((tmp + (tmp >> 3)) & 030707070707) % 63;
941 }
942
943 LONG ReadBootSector(struct FSData *fs_data )
944 {
945 struct DosEnvec *de = BADDR(glob->fssm->fssm_Environ);
946 LONG err;
947 ULONG bsize = de->de_SizeBlock * 4;
948 struct NTFSBootSector *boot;
949 BOOL invalid = FALSE;
950 int i;
951
952 D(bug("[NTFS]: %s()\n", __PRETTY_FUNCTION__));
953
954 boot = AllocMem(bsize, MEMF_ANY);
955 if (!boot)
956 return ERROR_NO_FREE_STORE;
957
958 /*
959 * Read the boot sector. We go direct because we don't have a cache yet,
960 * and can't create one until we know the sector size, which is held in
961 * the boot sector. In practice it doesn't matter - we're going to use
962 * this once and once only.
963 */
964 fs_data->first_device_sector =
965 de->de_BlocksPerTrack * de->de_Surfaces * de->de_LowCyl;
966
967 D(bug("[NTFS] %s: trying bootsector at sector %ld (%ld bytes)\n", __PRETTY_FUNCTION__, fs_data->first_device_sector, bsize));
968
969 if ((err = AccessDisk(FALSE, fs_data->first_device_sector, 1, bsize, (UBYTE *)boot)) != 0) {
970 D(bug("[NTFS] %s: failed to read boot block (%ld)\n", __PRETTY_FUNCTION__, err));
971 FreeMem(boot, bsize);
972 return err;
973 }
974
975 /* check for NTFS signature */
976 if (boot->oem_name[0] != 'N' || boot->oem_name[1] != 'T' || boot->oem_name[2] != 'F' || boot->oem_name[3] != 'S')
977 invalid = TRUE;
978
979 if (invalid)
980 {
981 D(bug("[NTFS] %s: invalid NTFS bootsector\n", __PRETTY_FUNCTION__));
982 FreeMem(boot, bsize);
983 return ERROR_NOT_A_DOS_DISK;
984 }
985
986 D(bug("[NTFS] %s: NTFSBootsector:\n", __PRETTY_FUNCTION__));
987
988 fs_data->sectorsize = AROS_LE2WORD(boot->bytes_per_sector);
989 fs_data->sectorsize_bits = ilog2(fs_data->sectorsize);
990 D(bug("[NTFS] %s:\tSectorSize = %ld\n", __PRETTY_FUNCTION__, fs_data->sectorsize));
991 D(bug("[NTFS] %s:\tSectorSize Bits = %ld\n", __PRETTY_FUNCTION__, fs_data->sectorsize_bits));
992
993 fs_data->cluster_sectors = boot->sectors_per_cluster;
994 fs_data->clustersize = fs_data->sectorsize * fs_data->cluster_sectors;
995 fs_data->clustersize_bits = ilog2(fs_data->clustersize);
996 fs_data->cluster_sectors_bits = fs_data->clustersize_bits - fs_data->sectorsize_bits;
997
998 D(bug("[NTFS] %s:\tSectorsPerCluster = %ld\n", __PRETTY_FUNCTION__, fs_data->cluster_sectors));
999 D(bug("[NTFS] %s:\tClusterSize = %ld\n", __PRETTY_FUNCTION__, fs_data->clustersize));
1000 D(bug("[NTFS] %s:\tClusterSize Bits = %ld\n", __PRETTY_FUNCTION__, fs_data->clustersize_bits));
1001 D(bug("[NTFS] %s:\tCluster Sectors Bits = %ld\n", __PRETTY_FUNCTION__, fs_data->cluster_sectors_bits));
1002
1003 fs_data->total_sectors = AROS_LE2QUAD(boot->number_of_sectors);
1004
1005 D(bug("[NTFS] %s:\tVolumeSize in sectors = %ld\n", __PRETTY_FUNCTION__, fs_data->total_sectors));
1006 D(bug("[NTFS] %s:\t in bytes = %ld\n", __PRETTY_FUNCTION__, fs_data->total_sectors * fs_data->sectorsize));
1007 #if (0)
1008 /* Warning : TODO - check the volume /drive can be properly accessed */
1009 if ((fs_data->first_device_sector + fs_data->total_sectors - 1 > end) && (glob->readcmd == CMD_READ))
1010 {
1011 D(bug("[NTFS] %s: volume is too large\n", __PRETTY_FUNCTION__));
1012 FreeMem(boot, bsize);
1013 return IOERR_BADADDRESS;
1014 }
1015 #endif
1016
1017 fs_data->cache = Cache_CreateCache(64, 64, fs_data->sectorsize);
1018
1019 D(bug("[NTFS] %s: allocated cache @ 0x%p (64,64,%d)\n", __PRETTY_FUNCTION__, fs_data->cache, fs_data->sectorsize));
1020
1021 if (boot->clusters_per_mft_record > 0)
1022 fs_data->mft_size = fs_data->cluster_sectors * boot->clusters_per_mft_record;
1023 else
1024 fs_data->mft_size = 1 << (-boot->clusters_per_mft_record - SECTORSIZE_SHIFT);
1025
1026 D(bug("[NTFS] %s:\tMFTRecordSize = %ld (%ld clusters per record)\n", __PRETTY_FUNCTION__, fs_data->mft_size, boot->clusters_per_mft_record));
1027
1028 if (boot->clusters_per_index_record > 0)
1029 fs_data->idx_size = fs_data->cluster_sectors * boot->clusters_per_index_record;
1030 else
1031 fs_data->idx_size = 1 << (-boot->clusters_per_index_record - SECTORSIZE_SHIFT);
1032
1033 D(bug("[NTFS] %s:\tIndexRecordSize = %ld (%ld clusters per index)\n", __PRETTY_FUNCTION__, fs_data->idx_size, boot->clusters_per_index_record));
1034
1035 fs_data->mft_start = AROS_LE2QUAD(boot->mft_lcn) * fs_data->cluster_sectors;
1036
1037 D(bug("[NTFS] %s:\tMFTStart = %ld\n", __PRETTY_FUNCTION__, fs_data->mft_start));
1038
1039 fs_data->mft.buf = AllocMem(fs_data->mft_size * fs_data->sectorsize, MEMF_ANY);
1040 if (!fs_data->mft.buf)
1041 {
1042 FreeMem(boot, bsize);
1043 return ERROR_NO_FREE_STORE;
1044 }
1045
1046 /* Warning: todo - UUID stored in LE format- do we need to convert it? */
1047 boot->volume_serial_number = AROS_LE2QUAD(boot->volume_serial_number);
1048 UUID_Copy((const uuid_t *)&boot->volume_serial_number, (uuid_t *)&fs_data->uuid);
1049
1050 D(
1051 char uuid_str[UUID_STRLEN + 1];
1052 uuid_str[UUID_STRLEN] = 0;
1053
1054 /* convert UUID into human-readable format */
1055 UUID_Unparse(&fs_data->uuid, uuid_str);
1056
1057 bug("[NTFS] %s:\tVolumeSerial = %s\n", __PRETTY_FUNCTION__, uuid_str);
1058 )
1059
1060 for (i = 0; i < fs_data->mft_size; i++)
1061 {
1062 if ((fs_data->mft.cblock = Cache_GetBlock(fs_data->cache, fs_data->first_device_sector + fs_data->mft_start + i, &fs_data->mft.cbuf)) == NULL)
1063 {
1064 err = IoErr();
1065 D(bug("[NTFS] %s: failed to read MFT (error:%ld)\n", __PRETTY_FUNCTION__, err));
1066 FreeMem(fs_data->mft.buf, fs_data->mft_size * fs_data->sectorsize);
1067 FreeMem(boot, bsize);
1068 return err;
1069 }
1070 CopyMem(fs_data->mft.cbuf, fs_data->mft.buf + (i * fs_data->sectorsize), fs_data->sectorsize);
1071 Cache_FreeBlock(fs_data->cache, fs_data->mft.cblock);
1072 fs_data->mft.cblock = NULL;
1073 }
1074
1075 #if defined(DEBUG_MFT)
1076 D(
1077 int dumpx;
1078
1079 bug("[NTFS] %s: MFTRecord Dump -:\n", __PRETTY_FUNCTION__);
1080 bug("[NTFS] %s: MFTRecord buf @ 0x%p, size %d x %d", __PRETTY_FUNCTION__, fs_data->mft.buf, fs_data->mft_size, fs_data->sectorsize);
1081
1082 for (dumpx = 0; dumpx < (fs_data->mft_size * fs_data->sectorsize) ; dumpx ++)
1083 {
1084 if ((dumpx%16) == 0)
1085 {
1086 bug("\n[NTFS] %s:\t%03x:", __PRETTY_FUNCTION__, dumpx);
1087 }
1088 bug(" %02x", ((UBYTE*)fs_data->mft.buf)[dumpx]);
1089 }
1090 bug("\n");
1091 )
1092 #endif
1093
1094 fs_data->mft.data = fs_data;
1095 if (PostProcessMFTRecord (fs_data, (struct MFTRecordEntry *)fs_data->mft.buf, fs_data->mft_size, "FILE"))
1096 {
1097 FreeMem(fs_data->mft.buf, fs_data->mft_size * fs_data->sectorsize);
1098 FreeMem(boot, bsize);
1099 return ERROR_NO_FREE_STORE;
1100 }
1101
1102 #if defined(DEBUG_MFT)
1103 D(
1104 bug("[NTFS] %s: MFTRecord Dump (Post Processing) -:\n", __PRETTY_FUNCTION__);
1105 bug("[NTFS] %s: MFTRecord buf @ 0x%p, size %d x %d", __PRETTY_FUNCTION__, fs_data->mft.buf, fs_data->mft_size, fs_data->sectorsize);
1106
1107 for (dumpx = 0; dumpx < (fs_data->mft_size * fs_data->sectorsize) ; dumpx ++)
1108 {
1109 if ((dumpx%16) == 0)
1110 {
1111 bug("\n[NTFS] %s:\t%03x:", __PRETTY_FUNCTION__, dumpx);
1112 }
1113 bug(" %02x", ((UBYTE*)fs_data->mft.buf)[dumpx]);
1114 }
1115 bug("\n");
1116 )
1117 #endif
1118
1119 if (!MapMFTAttrib(&fs_data->mft.attr, &fs_data->mft, AT_DATA))
1120 {
1121 D(bug("[NTFS] %s: no $DATA in MFT\n", __PRETTY_FUNCTION__));
1122 FreeMem(fs_data->mft.buf, fs_data->mft_size * fs_data->sectorsize);
1123 FreeMem(boot, bsize);
1124 return ERROR_NO_FREE_STORE;
1125 }
1126
1127 struct DirHandle dh;
1128 dh.ioh.mft.buf = NULL;
1129 dh.ioh.mft.mftrec_no = FILE_ROOT;
1130 InitDirHandle(fs_data, &dh, FALSE);
1131
1132 struct DirEntry dir_entry;
1133 memset(&dir_entry, 0, sizeof(struct DirEntry));
1134 dir_entry.data = fs_data;
1135 while ((err = GetDirEntry(&dh, dh.cur_no + 1, &dir_entry)) == 0)
1136 {
1137 struct MFTAttr *attrentry;
1138
1139 if (strcmp(dir_entry.entryname, "$MFT") == 0)
1140 {
1141 D(bug("[NTFS] %s: ## found $MFT entry\n", __PRETTY_FUNCTION__));
1142
1143 INIT_MFTATTRIB(&dir_entry.entry->attr, dir_entry.entry);
1144 attrentry = FindMFTAttrib(&dir_entry.entry->attr, AT_STANDARD_INFORMATION);
1145 if ((attrentry) && (attrentry->residentflag == ATTR_RESIDENT_FORM) && (AROS_LE2LONG(attrentry->data.resident.value_length) > 0))
1146 {
1147 attrentry = (struct MFTAttr *)((IPTR)attrentry + AROS_LE2WORD(attrentry->data.resident.value_offset));
1148
1149 D(bug("[NTFS] %s: nfstime = %d\n", __PRETTY_FUNCTION__, *(UQUAD *)attrentry));
1150
1151 NTFS2DateStamp((UQUAD *)attrentry, &fs_data->volume.create_time);
1152
1153 D(bug("[NTFS] %s:\tVolumeDate: %ld days, %ld, minutes, %ld ticks \n", __PRETTY_FUNCTION__, fs_data->volume.create_time.ds_Days, fs_data->volume.create_time.ds_Minute, fs_data->volume.create_time.ds_Tick));
1154 }
1155 }
1156 else if (strcmp(dir_entry.entryname, "$Volume") == 0)
1157 {
1158 D(bug("[NTFS] %s: ## found $Volume label entry\n", __PRETTY_FUNCTION__));
1159
1160 INIT_MFTATTRIB(&dir_entry.entry->attr, dir_entry.entry);
1161 attrentry = FindMFTAttrib(&dir_entry.entry->attr, AT_VOLUME_NAME);
1162 if ((attrentry) && (attrentry->residentflag == ATTR_RESIDENT_FORM) && (AROS_LE2LONG(attrentry->data.resident.value_length) > 0))
1163 {
1164 int i;
1165 fs_data->volume.name[0] = (UBYTE)(AROS_LE2LONG(attrentry->data.resident.value_length) / 2) + 1;
1166 attrentry = (struct MFTAttr *)((IPTR)attrentry + AROS_LE2WORD(attrentry->data.resident.value_offset));
1167
1168 if (fs_data->volume.name[0] > 30)
1169 fs_data->volume.name[0] = 30;
1170
1171 for (i = 0; i < fs_data->volume.name[0]; i++)
1172 {
1173 fs_data->volume.name[i + 1] = glob->from_unicode[AROS_LE2WORD(*((UWORD *)((IPTR)attrentry + (i * 2))))];
1174 }
1175 fs_data->volume.name[fs_data->volume.name[0]] = '\0';
1176
1177 D(bug("[NTFS] %s:\tVolumeLabel = '%s'\n", __PRETTY_FUNCTION__, &fs_data->volume.name[1]));
1178 }
1179 }
1180 else if (strcmp(dir_entry.entryname, "$Bitmap") == 0)
1181 {
1182 struct NTFSMFTAttr bitmapatrr;
1183 UBYTE *MFTBitmap;
1184 int i, allocated = 0;
1185
1186 D(bug("[NTFS] %s: ## found $Bitmap entry\n", __PRETTY_FUNCTION__));
1187 D(bug("[NTFS] %s: ## size = %u\n", __PRETTY_FUNCTION__, dir_entry.entry->size));
1188
1189 MFTBitmap = AllocVec(dir_entry.entry->size, MEMF_ANY);
1190
1191 INIT_MFTATTRIB(&bitmapatrr, dir_entry.entry);
1192 if (MapMFTAttrib (&bitmapatrr, dir_entry.entry, AT_DATA))
1193 {
1194 if (ReadMFTAttrib(&bitmapatrr, MFTBitmap, 0, dir_entry.entry->size, 0) == 0)
1195 {
1196 D(bug("[NTFS] %s: read $Bitmap into buffer @ 0x%p\n", __PRETTY_FUNCTION__, MFTBitmap));
1197 for (i = 0; i < (dir_entry.entry->size / 4); i++)
1198 {
1199 allocated += bitcount(*(ULONG *)(MFTBitmap + (i * 4)));
1200 }
1201 D(bug("[NTFS] %s: allocated = %u\n", __PRETTY_FUNCTION__, allocated));
1202 fs_data->used_sectors = allocated * fs_data->cluster_sectors;
1203 }
1204 }
1205 }
1206 }
1207
1208 if (fs_data->volume.name[0] == '\0')
1209 {
1210 char tmp[UUID_STRLEN + 1];
1211 int t = 0;
1212 UUID_Unparse(&fs_data->uuid, tmp);
1213 for (i = 0; i < UUID_STRLEN; i++)
1214 {
1215 if (tmp[i] == '-')
1216 {
1217 tmp[t++] = tmp[i + 1];
1218 i ++;
1219 }
1220 else
1221 t++;
1222 }
1223 CopyMem(tmp, fs_data->volume.name, 30);
1224 fs_data->volume.name[31] = '\0';
1225 }
1226
1227 bug("[NTFS] %s: successfully detected NTFS Filesystem.\n", __PRETTY_FUNCTION__);
1228
1229 FreeMem(boot, bsize);
1230 return 0;
1231 }
1232
1233 void FreeBootSector(struct FSData *fs_data)
1234 {
1235 D(bug("[NTFS]: %s()\n", __PRETTY_FUNCTION__));
1236
1237 D(bug("[NTFS] %s: removing NTFSBootsector from memory\n", __PRETTY_FUNCTION__));
1238
1239 Cache_DestroyCache(fs_data->cache);
1240 }
Mirror of AROS' svn.