Chameleon

Chameleon Svn Source Tree

Root/branches/Bungo/i386/libsaio/hfs.c

1/*␊
2 * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved.␊
3 *␊
4 * @APPLE_LICENSE_HEADER_START@␊
5 *␊
6 * The contents of this file constitute Original Code as defined in and␊
7 * are subject to the Apple Public Source License Version 2.0 (the␊
8 * "License"). You may not use this file except in compliance with the␊
9 * License. Please obtain a copy of the License at␊
10 * http://www.apple.com/publicsource and read it before using this file.␊
11 * ␊
12 * This Original Code and all software distributed under the License are␊
13 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER␊
14 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,␊
15 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,␊
16 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the␊
17 * License for the specific language governing rights and limitations␊
18 * under the License.␊
19 *␊
20 * @APPLE_LICENSE_HEADER_END@␊
21 *␊
22 *␊
23 * hfs.c - File System Module for HFS and HFS+.␊
24 *␊
25 * Copyright (c) 1999-2002 Apple Computer, Inc.␊
26 *␊
27 * DRI: Josh de Cesare␊
28 */␊
29␊
30#include <sl.h>␊
31#include <hfs/hfs_format.h>␊
32␊
33#include "hfs.h"␊
34␊
35#define kBlockSize (0x200)␊
36␊
37#define kMDBBaseOffset (2 * kBlockSize)␊
38␊
39#define kBTreeCatalog (0)␊
40#define kBTreeExtents (1)␊
41␊
42#ifdef __i386__␊
43␊
44static CICell gCurrentIH;␊
45static long long gAllocationOffset;␊
46static long gIsHFSPlus;␊
47static long gCaseSensitive;␊
48static u_int32_t gBlockSize;␊
49static u_int32_t gCacheBlockSize;␊
50static char *gBTreeHeaderBuffer;␊
51static BTHeaderRec *gBTHeaders[2];␊
52static char *gHFSMdbVib;␊
53static HFSMasterDirectoryBlock *gHFSMDB;␊
54static char *gHFSPlusHeader;␊
55static HFSPlusVolumeHeader *gHFSPlus;␊
56static char *gLinkTemp;␊
57static long long gVolID;␊
58static char *gTempStr;␊
59␊
60#else /* !__i386__ */␊
61␊
62static CICell␉␉␉gCurrentIH;␊
63static long long␉␉gAllocationOffset;␊
64static long␉␉␉gIsHFSPlus;␊
65static long␉␉␉gCaseSensitive;␊
66static u_int32_t␉␉gBlockSize;␊
67static u_int32_t␉␉gCacheBlockSize;␊
68static char␉␉␉gBTreeHeaderBuffer[512];␊
69static BTHeaderRec␉␉*gBTHeaders[2];␊
70static char␉␉␉gHFSMdbVib[kBlockSize];␊
71static HFSMasterDirectoryBlock␉*gHFSMDB =(HFSMasterDirectoryBlock*)gHFSMdbVib;␊
72static char␉␉␉gHFSPlusHeader[kBlockSize];␊
73static HFSPlusVolumeHeader␉*gHFSPlus =(HFSPlusVolumeHeader*)gHFSPlusHeader;␊
74static char␉␉␉gLinkTemp[64];␊
75static long long␉␉gVolID;␊
76␊
77#endif /* !__i386__ */␊
78␊
79static long ReadFile(void *file, u_int64_t *length, void *base, u_int64_t offset);␊
80static long GetCatalogEntryInfo(void *entry, long *flags, u_int32_t *time,␊
81 FinderInfo *finderInfo, long *infoValid);␊
82static long ResolvePathToCatalogEntry(char *filePath, long *flags,␊
83 void *entry, u_int32_t dirID, long long *dirIndex);␊
84␊
85static long GetCatalogEntry(long long *dirIndex, char **name,␊
86 long *flags, u_int32_t *time,␊
87 FinderInfo *finderInfo, long *infoValid);␊
88static long ReadCatalogEntry(char *fileName, u_int32_t dirID, void *entry,␊
89 long long *dirIndex);␊
90static long ReadExtentsEntry(u_int32_t fileID, long startBlock, void *entry);␊
91␊
92static long ReadBTreeEntry(long btree, void *key, char *entry, long long *dirIndex);␊
93static void GetBTreeRecord(u_int16_t index, char *nodeBuffer, u_int16_t nodeSize,␊
94 char **key, char **data);␊
95␊
96static long ReadExtent(char *extent, u_int64_t extentSize, u_int32_t extentFile,␊
97 u_int64_t offset, u_int64_t size, void *buffer, long cache);␊
98␊
99static u_int32_t GetExtentStart(void *extents, u_int32_t index);␊
100static u_int32_t GetExtentSize(void *extents, u_int32_t index);␊
101␊
102static long CompareHFSCatalogKeys(void *key, void *testKey);␊
103static long CompareHFSPlusCatalogKeys(void *key, void *testKey);␊
104static long CompareHFSExtentsKeys(void *key, void *testKey);␊
105static long CompareHFSPlusExtentsKeys(void *key, void *testKey);␊
106␊
107extern long FastRelString(u_int8_t *str1, u_int8_t *str2);␊
108extern long BinaryUnicodeCompare(u_int16_t *uniStr1, u_int32_t len1,␊
109 u_int16_t *uniStr2, u_int32_t len2);␊
110␊
111//==============================================================================␊
112␊
113static void SwapFinderInfo(FndrFileInfo *dst, FndrFileInfo *src)␊
114{␊
115␉dst->fdType = SWAP_BE32(src->fdType);␊
116␉dst->fdCreator = SWAP_BE32(src->fdCreator);␊
117␉dst->fdFlags = SWAP_BE16(src->fdFlags);␊
118␉// Don't bother with location␊
119}␊
120␊
121//==============================================================================␊
122␊
123void HFSFree(CICell ih)␊
124{␊
125␉if(gCurrentIH == ih)␊
126␉{␊
127␉␉gCurrentIH = 0;␊
128␉}␊
129␉free(ih);␊
130}␊
131␊
132//==============================================================================␊
133␊
134bool HFSProbe (const void *buf)␊
135{␊
136␉const HFSMasterDirectoryBlock *mdb;␊
137␉const HFSPlusVolumeHeader *header;␊
138␉mdb = (const HFSMasterDirectoryBlock *)(((const char*)buf)+kMDBBaseOffset);␊
139␉header = (const HFSPlusVolumeHeader *)(((const char*)buf)+kMDBBaseOffset);␊
140␉␊
141␉if ( SWAP_BE16(mdb->drSigWord) == kHFSSigWord ) {␊
142␉␉return true;␊
143␉}␊
144␊
145␉if (SWAP_BE16(header->signature) != kHFSPlusSigWord && SWAP_BE16(header->signature) != kHFSXSigWord) {␊
146␉␉return false;␊
147␉}␊
148␉return true;␊
149}␊
150␊
151//==============================================================================␊
152␊
153long HFSInitPartition(CICell ih)␊
154{␊
155␉u_int64_t extentSize;␊
156␉void *extent;␊
157␉u_int32_t extentFile;␊
158␉u_int16_t nodeSize;␊
159␊
160␉if (ih == gCurrentIH)␊
161␉{␊
162#ifdef __i386__␊
163␉␉CacheInit(ih, gCacheBlockSize);␊
164#endif␊
165␉return 0;␊
166␉}␊
167␊
168#ifdef __i386__␊
169␉if (!gTempStr)␊
170␉{␊
171␉␉gTempStr = (char *)malloc(4096);␊
172␉}␊
173␉if (!gLinkTemp)␊
174␉{␊
175␉␉gLinkTemp = (char *)malloc(64);␊
176␉}␊
177␉if (!gBTreeHeaderBuffer)␊
178␉{␊
179␉␉gBTreeHeaderBuffer = (char *)malloc(512);␊
180␉}␊
181␉if (!gHFSMdbVib)␊
182␉{␊
183␉␉gHFSMdbVib = (char *)malloc(kBlockSize);␊
184␉␉gHFSMDB = (HFSMasterDirectoryBlock *)gHFSMdbVib;␊
185␉}␊
186␉if (!gHFSPlusHeader)␊
187␉{␊
188␉␉gHFSPlusHeader = (char *)malloc(kBlockSize);␊
189␉␉gHFSPlus = (HFSPlusVolumeHeader *)gHFSPlusHeader;␊
190␉}␊
191␉if (!gTempStr || !gLinkTemp || !gBTreeHeaderBuffer || !gHFSMdbVib || !gHFSPlusHeader)␊
192␉{␊
193␉␉return -1;␊
194␉}␊
195#endif /* __i386__ */␊
196␊
197␉gAllocationOffset = 0;␊
198␉gIsHFSPlus = 0;␊
199␉gCaseSensitive = 0;␊
200␉gBTHeaders[0] = 0;␊
201␉gBTHeaders[1] = 0;␊
202␊
203␉// Look for the HFS MDB␊
204␉Seek(ih, kMDBBaseOffset);␊
205␉Read(ih, (long)gHFSMdbVib, kBlockSize);␊
206␊
207␉if (SWAP_BE16(gHFSMDB->drSigWord) == kHFSSigWord)␊
208␉{␊
209␉␉gAllocationOffset = SWAP_BE16(gHFSMDB->drAlBlSt) * kBlockSize;␊
210␊
211␉␉// See if it is HFSPlus␊
212␉␉if (SWAP_BE16(gHFSMDB->drEmbedSigWord) != kHFSPlusSigWord)␊
213␉␉{␊
214␉␉␉// Normal HFS;␊
215␉␉␉gCacheBlockSize = gBlockSize = SWAP_BE32(gHFSMDB->drAlBlkSiz);␊
216␉␉␉CacheInit(ih, gCacheBlockSize);␊
217␉␉␉gCurrentIH = ih;␊
218␊
219␉␉␉// grab the 64 bit volume ID␊
220␉␉␉bcopy(&gHFSMDB->drFndrInfo[6], &gVolID, 8);␊
221␊
222␉␉␉// Get the Catalog BTree node size.␊
223␉␉␉extent = (HFSExtentDescriptor *)&gHFSMDB->drCTExtRec;␊
224␉␉␉extentSize = SWAP_BE32(gHFSMDB->drCTFlSize);␊
225␉␉␉extentFile = kHFSCatalogFileID;␊
226␉␉␉ReadExtent(extent, extentSize, extentFile, 0, 256, gBTreeHeaderBuffer + kBTreeCatalog * 256, 0);␊
227␊
228␉␉␉nodeSize = SWAP_BE16(((BTHeaderRec *)(gBTreeHeaderBuffer + kBTreeCatalog * 256 + sizeof(BTNodeDescriptor)))->nodeSize);␊
229␊
230␉␉␉// If the BTree node size is larger than the block size, reset the cache.␊
231␉␉␉if (nodeSize > gBlockSize)␊
232␉␉␉{␊
233␉␉␉␉gCacheBlockSize = nodeSize;␊
234␉␉␉␉CacheInit(ih, gCacheBlockSize);␊
235␉␉␉}␊
236␊
237␉␉return 0;␊
238␉␉}␊
239␊
240␉␉// Calculate the offset to the embeded HFSPlus volume.␊
241␉␉gAllocationOffset += (long long)SWAP_BE16(gHFSMDB->drEmbedExtent.startBlock) *␊
242 SWAP_BE32(gHFSMDB->drAlBlkSiz);␊
243␉}␊
244␊
245␉// Look for the HFSPlus Header␊
246␉Seek(ih, gAllocationOffset + kMDBBaseOffset);␊
247␉Read(ih, (long)gHFSPlusHeader, kBlockSize);␊
248␊
249␉// Not a HFS+ or HFSX volume.␊
250␉if (SWAP_BE16(gHFSPlus->signature) != kHFSPlusSigWord && SWAP_BE16(gHFSPlus->signature) != kHFSXSigWord)␊
251␉{␊
252␉␉verbose("HFS signature was not present.\n");␊
253␉␉gCurrentIH = 0;␊
254␉␉return -1;␊
255␉}␊
256␊
257␉gIsHFSPlus = 1;␊
258␉gCacheBlockSize = gBlockSize = SWAP_BE32(gHFSPlus->blockSize);␊
259␉CacheInit(ih, gCacheBlockSize);␊
260␉gCurrentIH = ih;␊
261␊
262␉ih->modTime = SWAP_BE32(gHFSPlus->modifyDate) - 2082844800;␊
263␊
264␉// grab the 64 bit volume ID␊
265␉bcopy(&gHFSPlus->finderInfo[24], &gVolID, 8);␊
266␊
267␉// Get the Catalog BTree node size.␊
268␉extent = &gHFSPlus->catalogFile.extents;␊
269␉extentSize = SWAP_BE64(gHFSPlus->catalogFile.logicalSize);␊
270␉extentFile = kHFSCatalogFileID;␊
271␊
272␉ReadExtent(extent, extentSize, extentFile, 0, 256, gBTreeHeaderBuffer + kBTreeCatalog * 256, 0);␊
273␊
274␉nodeSize = SWAP_BE16(((BTHeaderRec *)(gBTreeHeaderBuffer + kBTreeCatalog * 256 + sizeof(BTNodeDescriptor)))->nodeSize);␊
275␊
276␉// If the BTree node size is larger than the block size, reset the cache.␊
277␉if (nodeSize > gBlockSize)␊
278␉{␊
279␉␉gCacheBlockSize = nodeSize;␊
280␉␉CacheInit(ih, gCacheBlockSize);␊
281␉}␊
282␊
283␉return 0;␊
284}␊
285␊
286//==============================================================================␊
287␊
288long HFSLoadFile(CICell ih, char * filePath)␊
289{␊
290␉return HFSReadFile(ih, filePath, (void *)gFSLoadAddress, 0, 0);␊
291}␊
292␊
293long HFSReadFile(CICell ih, char *filePath, void *base, u_int64_t offset, u_int64_t length)␊
294{␊
295␉char entry[512];␊
296␉char devStr[12];␊
297␉u_int32_t dirID;␊
298␉long result, flags;␊
299␊
300␉if (HFSInitPartition(ih) == -1)␊
301␉{␊
302␉␉return -1;␊
303␉}␊
304␊
305␉dirID = kHFSRootFolderID;␊
306␉// Skip a lead '/'. Start in the system folder if there are two.␊
307␉if (filePath[0] == '/')␊
308␉{␊
309␉␉if (filePath[1] == '/')␊
310␉␉{␊
311␉␉␉if (gIsHFSPlus)␊
312␉␉␉{␊
313␉␉␉␉dirID = SWAP_BE32(((long *)gHFSPlus->finderInfo)[5]);␊
314␉␉␉}␊
315␉␉␉else␊
316␉␉␉{␊
317␉␉␉␉dirID = SWAP_BE32(gHFSMDB->drFndrInfo[5]);␊
318␉␉␉}␊
319␊
320␉␉␉if (dirID == 0)␊
321␉␉␉{␊
322␉␉␉␉return -1;␊
323␉␉␉}␊
324␊
325␉␉␉filePath++;␊
326␉␉}␊
327␊
328␉␉filePath++;␊
329␉}␊
330␊
331␉result = ResolvePathToCatalogEntry(filePath, &flags, entry, dirID, 0);␊
332␊
333␉if ((result == -1) || ((flags & kFileTypeMask) != kFileTypeFlat))␊
334␉{␊
335␉␉return -1;␊
336␉}␊
337␊
338#if UNUSED␊
339␉// Not yet for Intel. System.config/Default.table will fail this check.␊
340␉// Check file owner and permissions.␊
341␉if (flags & (kOwnerNotRoot | kPermGroupWrite | kPermOtherWrite))␊
342␉{␊
343␉␉return -1;␊
344␉}␊
345#endif␊
346␊
347␉result = ReadFile(entry, &length, base, offset);␊
348␉if (result == -1)␊
349␉{␊
350␉␉return -1;␊
351␉}␊
352␊
353␉getDeviceDescription(ih, devStr);␊
354␊
355␉verbose("Read HFS%s file: [%s/%s] %d bytes.\n",␉(gIsHFSPlus ? "+" : ""), devStr, filePath, (uint32_t)length);␊
356␊
357␉return length;␊
358}␊
359␊
360long HFSGetDirEntry(CICell ih, char * dirPath, long long * dirIndex, char ** name, long * flags, u_int32_t * time, FinderInfo * finderInfo, long * infoValid)␊
361{␊
362␉char entry[512];␊
363␉u_int32_t dirID;␊
364␉long dirFlags;␊
365␊
366␉if (HFSInitPartition(ih) == -1)␊
367␉{␊
368␉␉return -1;␊
369␉}␊
370␊
371␉if (*dirIndex == -1)␊
372␉{␊
373␉␉return -1;␊
374␉}␊
375␊
376␉dirID = kHFSRootFolderID;␊
377␊
378␉// Skip a lead '/'. Start in the system folder if there are two.␊
379␉if (dirPath[0] == '/')␊
380␉{␊
381␉␉if (dirPath[1] == '/')␊
382␉␉{␊
383␉␉␉if (gIsHFSPlus)␊
384␉␉␉{␊
385␉␉␉␉dirID = SWAP_BE32(((long *)gHFSPlus->finderInfo)[5]);␊
386␉␉␉}␊
387␉␉␉else␊
388␉␉␉{␊
389␉␉␉␉dirID = SWAP_BE32(gHFSMDB->drFndrInfo[5]);␊
390␉␉␉}␊
391␊
392␉␉␉if (dirID == 0)␊
393␉␉␉{␊
394␉␉␉␉return -1;␊
395␉␉␉}␊
396␊
397␉␉␉dirPath++;␊
398␉␉}␊
399␊
400␉␉dirPath++;␊
401␉}␊
402␊
403␉if (*dirIndex == 0)␊
404␉{␊
405␉␉ResolvePathToCatalogEntry(dirPath, &dirFlags, entry, dirID, dirIndex);␊
406␊
407␉␉if (*dirIndex == 0)␊
408␉␉{␊
409␉␉␉*dirIndex = -1;␊
410␉␉}␊
411␊
412␉␉if ((dirFlags & kFileTypeMask) != kFileTypeUnknown)␊
413␉␉{␊
414␉␉␉return -1;␊
415␉␉}␊
416␉}␊
417␊
418␉GetCatalogEntry(dirIndex, name, flags, time, finderInfo, infoValid);␊
419␊
420␉if (*dirIndex == 0)␊
421␉{␊
422␉␉*dirIndex = -1;␊
423␉}␊
424␊
425␉if ((*flags & kFileTypeMask) == kFileTypeUnknown)␊
426␉{␊
427␉␉return -1;␊
428␉}␊
429␊
430␉return 0;␊
431}␊
432␊
433//==============================================================================␊
434␊
435void HFSGetDescription(CICell ih, char *str, long strMaxLen)␊
436{␊
437␉long long dirIndex = 0;␊
438␉char *name;␊
439␉long flags;␊
440␉u_int32_t firstLeafNode;␊
441␉u_int32_t time;␊
442␉u_int16_t nodeSize;␊
443␊
444␉if (HFSInitPartition(ih) == -1)␊
445␉{␊
446 verbose("HFSGetDescription: Init partition failed");␊
447␉␉return;␊
448␉}␊
449␊
450␉/* Fill some crucial data structures by side effect. */␊
451␉HFSGetDirEntry(ih, "/", &dirIndex, &name, &flags, &time, 0, 0);␊
452␊
453␉/* Now we can loook up the volume name node. */␊
454␉nodeSize = SWAP_BE16(gBTHeaders[kBTreeCatalog]->nodeSize);␊
455␉firstLeafNode = SWAP_BE32(gBTHeaders[kBTreeCatalog]->firstLeafNode);␊
456␊
457␉dirIndex = (long long)firstLeafNode * nodeSize;␊
458␊
459␉GetCatalogEntry(&dirIndex, &name, &flags, &time, 0, 0);␊
460␊
461␉strncpy(str, name, strMaxLen);␊
462␉str[strMaxLen] = '\0';␊
463 //verbose("HFS: label=%s\n", str);␊
464}␊
465␊
466//==============================================================================␊
467␊
468long HFSGetFileBlock(CICell ih, char *filePath, u_int64_t *firstBlock)␊
469{␊
470␉char entry[512];␊
471␉long result, flags;␊
472␉u_int32_t dirID;␊
473␉void *extents;␊
474␉HFSCatalogFile *hfsFile = (void *)entry;␊
475␉HFSPlusCatalogFile *hfsPlusFile = (void *)entry;␊
476␊
477␉if (HFSInitPartition(ih) == -1)␊
478␉{␊
479␉␉return -1;␊
480␉}␊
481␊
482␉dirID = kHFSRootFolderID;␊
483␉// Skip a lead '/'. Start in the system folder if there are two.␊
484␉if (filePath[0] == '/')␊
485␉{␊
486␉␉if (filePath[1] == '/')␊
487␉␉{␊
488␉␉␉if (gIsHFSPlus)␊
489␉␉␉{␊
490␉␉␉␉dirID = SWAP_BE32(((long *) gHFSPlus->finderInfo)[5]);␊
491␉␉␉}␊
492␉␉␉else␊
493␉␉␉{␊
494␉␉␉␉dirID = SWAP_BE32(gHFSMDB->drFndrInfo[5]);␊
495␉␉␉}␊
496␊
497␉␉␉if (dirID == 0)␊
498␉␉␉{␊
499␉␉␉␉return -1;␊
500␉␉␉}␊
501␉␉␉filePath++;␊
502␉␉}␊
503␉␉filePath++;␊
504␉}␊
505␊
506␉result = ResolvePathToCatalogEntry(filePath, &flags, entry, dirID, 0);␊
507␊
508␉if ((result == -1) || ((flags & kFileTypeMask) != kFileTypeFlat))␊
509␉{␊
510␉␉verbose("HFSGetFileBlock: Resolve path '%s' failed\n", filePath);␊
511␉␉return -1;␊
512␉}␊
513␊
514␉if (gIsHFSPlus) {␊
515␉␉extents = &hfsPlusFile->dataFork.extents;␊
516␉} else {␊
517␉␉extents = &hfsFile->dataExtents;␊
518␉}␊
519␊
520#if DEBUG␊
521␉printf("extent start 0x%x\n", GetExtentStart(extents, 0));␊
522␉printf("block size 0x%x\n", gBlockSize);␊
523␉printf("Allocation offset 0x%x\n", (unsigned long)gAllocationOffset);␊
524#endif␊
525␉*firstBlock = ((u_int64_t) GetExtentStart(extents, 0) * (u_int64_t) gBlockSize + gAllocationOffset) / 512ULL;␊
526␉return 0;␊
527}␊
528␊
529␊
530//==============================================================================␊
531␊
532long HFSGetUUID(CICell ih, char *uuidStr)␊
533{␊
534␉if (HFSInitPartition(ih) == -1)␊
535␉{␊
536␉␉return -1;␊
537␉}␊
538␊
539␉if (gVolID == 0LL)␊
540␉{␊
541␉␉return -1;␊
542␉}␊
543␊
544␉return CreateUUIDString((uint8_t*)(&gVolID), sizeof(gVolID), uuidStr);␊
545}␊
546␊
547//==============================================================================␊
548// Private Functions␊
549␊
550static long ReadFile(void * file, u_int64_t * length, void * base, u_int64_t offset)␊
551{␊
552␉u_int64_t fileLength;␊
553␉void *extents;␊
554␉HFSCatalogFile *hfsFile = file;␊
555␉HFSPlusCatalogFile *hfsPlusFile = file;␊
556␉u_int32_t fileID;␊
557␊
558␉if (gIsHFSPlus)␊
559␉{␊
560␉␉fileID = SWAP_BE32(hfsPlusFile->fileID);␊
561␉␉fileLength = (uint64_t)SWAP_BE64(hfsPlusFile->dataFork.logicalSize);␊
562␉␉extents = &hfsPlusFile->dataFork.extents;␊
563␉}␊
564␉else␊
565␉{␊
566␉␉fileID = SWAP_BE32(hfsFile->fileID);␊
567␉␉fileLength = SWAP_BE32(hfsFile->dataLogicalSize);␊
568␉␉extents = &hfsFile->dataExtents;␊
569␉}␊
570␊
571␉if (offset > fileLength)␊
572␉{␊
573␉␉verbose("ReadFile(HFS%c): Offset is too large.\n", gIsHFSPlus ? "+" : "");␊
574␊
575␉␉return -1;␊
576␉}␊
577␊
578␉if ((*length == 0) || ((offset + *length) > fileLength))␊
579␉{␊
580␉␉*length = fileLength - offset;␊
581␉}␊
582␊
583/*␊
584␉if (*length > kLoadSize)␊
585␉{␊
586␉␉printf("File is too large.\n");␊
587␉␉return -1;␊
588␉}␊
589*/␊
590␊
591␉*length = ReadExtent((char *)extents, fileLength, fileID, offset, *length, (char *)base, 0);␊
592␊
593␉return 0;␊
594}␊
595␊
596//==============================================================================␊
597␊
598static long GetCatalogEntryInfo(void * entry, long * flags, u_int32_t * time, FinderInfo * finderInfo, long * infoValid)␊
599{␊
600␉u_int32_t tmpTime = 0;␊
601␉long valid = 0;␊
602␊
603␉// Get information about the file.␊
604 ␊
605␉switch ( SWAP_BE16(*(short *)entry) )␊
606␉{␊
607␉case kHFSFolderRecord :␊
608␉␉*flags = kFileTypeDirectory;␊
609␉␉tmpTime = SWAP_BE32(((HFSCatalogFolder *)entry)->modifyDate);␊
610␉␉break;␊
611␊
612␉case kHFSPlusFolderRecord :␊
613␉␉*flags = kFileTypeDirectory | (SWAP_BE16(((HFSPlusCatalogFolder *)entry)->bsdInfo.fileMode) & kPermMask);␊
614␉␉if (SWAP_BE32(((HFSPlusCatalogFolder *)entry)->bsdInfo.ownerID) != 0)␊
615␉␉{␊
616␉␉␉*flags |= kOwnerNotRoot;␊
617␉␉}␊
618␉␉tmpTime = SWAP_BE32(((HFSPlusCatalogFolder *)entry)->contentModDate);␊
619␉␉break;␊
620␊
621␉case kHFSFileRecord :␊
622␉␉*flags = kFileTypeFlat;␊
623␉␉tmpTime = SWAP_BE32(((HFSCatalogFile *)entry)->modifyDate);␊
624␉␉if (finderInfo)␊
625␉␉{␊
626␉␉␉SwapFinderInfo((FndrFileInfo *)finderInfo, &((HFSCatalogFile *)entry)->userInfo);␊
627␉␉␉valid = 1;␊
628␉␉}␊
629␉␉break;␊
630␊
631␉case kHFSPlusFileRecord :␊
632␉␉*flags = kFileTypeFlat | (SWAP_BE16(((HFSPlusCatalogFile *)entry)->bsdInfo.fileMode) & kPermMask);␊
633␉␉if (SWAP_BE32(((HFSPlusCatalogFile *)entry)->bsdInfo.ownerID) != 0)␊
634␉␉{␊
635␉␉␉*flags |= kOwnerNotRoot;␊
636␉␉}␊
637␉␉tmpTime = SWAP_BE32(((HFSPlusCatalogFile *)entry)->contentModDate);␊
638␉␉if (finderInfo)␊
639␉␉{␊
640␉␉␉SwapFinderInfo((FndrFileInfo *)finderInfo, &((HFSPlusCatalogFile *)entry)->userInfo);␊
641␉␉␉valid = 1;␊
642␉␉}␊
643␉␉break;␊
644␊
645␉case kHFSFileThreadRecord :␊
646␉case kHFSPlusFileThreadRecord :␊
647␉case kHFSFolderThreadRecord :␊
648␉case kHFSPlusFolderThreadRecord :␊
649␉␉*flags = kFileTypeUnknown;␊
650␉␉tmpTime = 0;␊
651␉␉break;␊
652␉}␊
653␊
654␉if (time != 0)␊
655␉{␊
656␉␉// Convert base time from 1904 to 1970.␊
657␉␉*time = tmpTime - 2082844800;␊
658␉}␊
659␊
660␉if (infoValid)␊
661␉{␊
662␉␉*infoValid = valid;␊
663␉}␊
664␊
665␉return 0;␊
666}␊
667␊
668//==============================================================================␊
669␊
670static long ResolvePathToCatalogEntry(char * filePath, long * flags, void * entry, u_int32_t dirID, long long * dirIndex)␊
671{␊
672␉char␉␉␉*restPath;␊
673␉long␉␉␉result, cnt;␊
674␉u_int32_t␉␉subFolderID = 0;␊
675␉long long␉␉tmpDirIndex;␊
676␉HFSPlusCatalogFile␉*hfsPlusFile;␊
677␊
678␉// Copy the file name to gTempStr␊
679␉cnt = 0;␊
680␉while ((filePath[cnt] != '/') && (filePath[cnt] != '\0'))␊
681␉{␊
682␉␉cnt++;␊
683␉}␊
684␊
685␉strlcpy(gTempStr, filePath, cnt+1);␊
686␊
687␉// Move restPath to the right place.␊
688␉if (filePath[cnt] != '\0')␊
689␉{␊
690␉␉cnt++;␊
691␉}␊
692␊
693␉restPath = filePath + cnt;␊
694␊
695␉// gTempStr is a name in the current Dir.␊
696␉// restPath is the rest of the path if any.␊
697␊
698␉result = ReadCatalogEntry(gTempStr, dirID, entry, dirIndex);␊
699␊
700␉if (result == -1)␊
701␉{␊
702␉␉return -1;␊
703␉}␊
704␊
705␉GetCatalogEntryInfo(entry, flags, 0, 0, 0);␊
706␊
707␉if ((*flags & kFileTypeMask) == kFileTypeDirectory)␊
708␉{␊
709␉␉if (gIsHFSPlus)␊
710␉␉{␊
711␉␉␉subFolderID = SWAP_BE32(((HFSPlusCatalogFolder *)entry)->folderID);␊
712␉␉}␊
713␉␉else␊
714␉␉{␊
715␉␉␉subFolderID = SWAP_BE32(((HFSCatalogFolder *)entry)->folderID);␊
716␉␉}␊
717␉}␊
718␊
719␉if ((*flags & kFileTypeMask) == kFileTypeDirectory)␊
720␉{␊
721␉␉result = ResolvePathToCatalogEntry(restPath, flags, entry, subFolderID, dirIndex);␊
722␉}␊
723␊
724␉if (gIsHFSPlus && ((*flags & kFileTypeMask) == kFileTypeFlat))␊
725␉{␊
726␉␉hfsPlusFile = (HFSPlusCatalogFile *)entry;␊
727␊
728␉␉if ((SWAP_BE32(hfsPlusFile->userInfo.fdType) == kHardLinkFileType) && (SWAP_BE32(hfsPlusFile->userInfo.fdCreator) == kHFSPlusCreator))␊
729␉␉{␊
730␉␉␉sprintf(gLinkTemp, "%s/%s%ld", HFSPLUSMETADATAFOLDER, HFS_INODE_PREFIX, SWAP_BE32(hfsPlusFile->bsdInfo.special.iNodeNum));␊
731␉␉␉result = ResolvePathToCatalogEntry(gLinkTemp, flags, entry, kHFSRootFolderID, &tmpDirIndex);␊
732␉␉}␊
733␉}␊
734␊
735␉return result;␊
736}␊
737␊
738//==============================================================================␊
739␊
740static long GetCatalogEntry(long long * dirIndex, char ** name, long * flags, u_int32_t * time, FinderInfo * finderInfo, long * infoValid)␊
741{␊
742␉u_int64_t extentSize;␊
743␉void *extent;␊
744␉char *nodeBuf, *testKey, *entry;␊
745␉BTNodeDescriptor *node;␊
746␉u_int32_t curNode;␊
747␉u_int16_t nodeSize, index;␊
748␊
749␉if (gIsHFSPlus)␊
750␉{␊
751␉␉extent = &gHFSPlus->catalogFile.extents;␊
752␉␉extentSize = SWAP_BE64(gHFSPlus->catalogFile.logicalSize);␊
753␉}␊
754␉else␊
755␉{␊
756␉␉extent = (HFSExtentDescriptor *)&gHFSMDB->drCTExtRec;␊
757␉␉extentSize = SWAP_BE32(gHFSMDB->drCTFlSize);␊
758␉}␊
759␊
760␉nodeSize = SWAP_BE16(gBTHeaders[kBTreeCatalog]->nodeSize);␊
761␉nodeBuf = (char *)malloc(nodeSize);␊
762␉node = (BTNodeDescriptor *)nodeBuf;␊
763␊
764␉index = (u_int16_t) (*dirIndex % nodeSize);␊
765␉curNode = (u_int32_t) (*dirIndex / nodeSize);␊
766␊
767␉// Read the BTree node and get the record for index.␊
768␉ReadExtent(extent, extentSize, kHFSCatalogFileID, (long long) curNode * nodeSize, nodeSize, nodeBuf, 1);␊
769␊
770␉GetBTreeRecord(index, nodeBuf, nodeSize, &testKey, &entry);␊
771␊
772␉GetCatalogEntryInfo(entry, flags, time, finderInfo, infoValid);␊
773␊
774␉// Get the file name.␊
775␉if (gIsHFSPlus)␊
776␉{␊
777␉␉utf_encodestr(((HFSPlusCatalogKey *)testKey)->nodeName.unicode,␊
778 SWAP_BE16(((HFSPlusCatalogKey *)testKey)->nodeName.length),␊
779 (u_int8_t *)gTempStr, 256, OSBigEndian);␊
780␉}␊
781␉else␊
782␉{␊
783␉␉strncpy(gTempStr, (const char *)&((HFSCatalogKey *)testKey)->nodeName[1], ((HFSCatalogKey *)testKey)->nodeName[0]);␊
784␊
785␉␉gTempStr[((HFSCatalogKey *)testKey)->nodeName[0]] = '\0';␊
786␉}␊
787␉*name = gTempStr;␊
788␊
789␉// Update dirIndex.␊
790␉index++;␊
791␊
792␉if (index == SWAP_BE16(node->numRecords))␊
793␉{␊
794␉␉index = 0;␊
795␉␉curNode = SWAP_BE32(node->fLink);␊
796␉}␊
797␉*dirIndex = (long long) curNode * nodeSize + index;␊
798␊
799␉free(nodeBuf);␊
800␊
801␉return 0;␊
802}␊
803␊
804//==============================================================================␊
805␊
806static long ReadCatalogEntry(char * fileName, u_int32_t dirID, void * entry, long long * dirIndex)␊
807{␊
808␉long length = strlen(fileName);␊
809␉char key[sizeof(HFSPlusCatalogKey)];␊
810␉HFSCatalogKey *hfsKey = (HFSCatalogKey *)key;␊
811␉HFSPlusCatalogKey *hfsPlusKey = (HFSPlusCatalogKey *)key;␊
812␊
813␉// Make the catalog key.␊
814␉if ( gIsHFSPlus )␊
815␉{␊
816␉␉if (length > kHFSPlusMaxFileNameChars)␊
817␉␉{␊
818␉␉␉length = kHFSPlusMaxFileNameChars;␊
819␉␉}␊
820␊
821␉␉hfsPlusKey->parentID = SWAP_BE32(dirID);␊
822␊
823␉␉utf_decodestr((u_int8_t *)fileName, hfsPlusKey->nodeName.unicode, &(hfsPlusKey->nodeName.length), 512, OSBigEndian);␊
824␉}␊
825␉else␊
826␉{␊
827␉␉if (length > kHFSMaxFileNameChars)␊
828␉␉{␊
829␉␉␉length = kHFSMaxFileNameChars;␊
830␉␉}␊
831␊
832␉␉hfsKey->parentID = SWAP_BE32(dirID);␊
833␊
834␉␉hfsKey->nodeName[0] = length;␊
835␉␉strncpy((char *)(hfsKey->nodeName + 1), fileName, length);␊
836␉}␊
837␊
838␉return ReadBTreeEntry(kBTreeCatalog, &key, entry, dirIndex);␊
839}␊
840␊
841//==============================================================================␊
842␊
843static long ReadExtentsEntry(u_int32_t fileID, long startBlock, void * entry)␊
844{␊
845␉char key[sizeof(HFSPlusExtentKey)];␊
846␉HFSExtentKey *hfsKey = (HFSExtentKey *)key;␊
847␉HFSPlusExtentKey *hfsPlusKey = (HFSPlusExtentKey *)key;␊
848␊
849␉// Make the extents key.␊
850␉if (gIsHFSPlus)␊
851␉{␊
852␉␉hfsPlusKey->forkType = 0;␊
853␉␉hfsPlusKey->fileID = SWAP_BE32(fileID);␊
854␉␉hfsPlusKey->startBlock = SWAP_BE32(startBlock);␊
855␉}␊
856␉else␊
857␉{␊
858␉␉hfsKey->forkType = 0;␊
859␉␉hfsKey->fileID = SWAP_BE32(fileID);␊
860␉␉hfsKey->startBlock = SWAP_BE16(startBlock);␊
861␉}␊
862␊
863␉return ReadBTreeEntry(kBTreeExtents, &key, entry, 0);␊
864}␊
865␊
866//==============================================================================␊
867␊
868static long ReadBTreeEntry(long btree, void * key, char * entry, long long * dirIndex)␊
869{␊
870␉u_int64_t extentSize;␊
871␉void *extent;␊
872␉u_int16_t extentFile;␊
873␉char *nodeBuf;␊
874␉BTNodeDescriptor *node;␊
875␉long result = 0, entrySize = 0;␊
876␉u_int32_t curNode;␊
877␉char *testKey, *recordData;␊
878␉u_int16_t nodeSize, index = 0, lowerBound, upperBound;␊
879␊
880␉// Figure out which tree is being looked at.␊
881␉if (btree == kBTreeCatalog)␊
882␉{␊
883␉␉if (gIsHFSPlus) ␊
884␉␉{␊
885␉␉␉extent = &gHFSPlus->catalogFile.extents;␊
886␉␉␉extentSize = SWAP_BE64(gHFSPlus->catalogFile.logicalSize);␊
887␉␉}␊
888␉␉else␊
889␉␉{␊
890␉␉␉extent = (HFSExtentDescriptor *)&gHFSMDB->drCTExtRec;␊
891␉␉␉extentSize = SWAP_BE32(gHFSMDB->drCTFlSize);␊
892␉␉}␊
893␉␉extentFile = kHFSCatalogFileID;␊
894␉}␊
895␉else␊
896␉{␊
897␉␉if (gIsHFSPlus)␊
898␉␉{␊
899␉␉␉extent = &gHFSPlus->extentsFile.extents;␊
900␉␉␉extentSize = SWAP_BE64(gHFSPlus->extentsFile.logicalSize);␊
901␉␉}␊
902␉␉else␊
903␉␉{␊
904␉␉␉extent = (HFSExtentDescriptor *)&gHFSMDB->drXTExtRec;␊
905␉␉␉extentSize = SWAP_BE32(gHFSMDB->drXTFlSize);␊
906␉␉}␊
907␉␉extentFile = kHFSExtentsFileID;␊
908␉}␊
909␊
910␉// Read the BTree Header if needed.␊
911␉if (gBTHeaders[btree] == 0)␊
912␉{␊
913␉␉ReadExtent(extent, extentSize, extentFile, 0, 256, gBTreeHeaderBuffer + btree * 256, 0);␊
914␉␉gBTHeaders[btree] = (BTHeaderRec *)(gBTreeHeaderBuffer + btree * 256 + sizeof(BTNodeDescriptor));␊
915␊
916␉␉if ((gIsHFSPlus && btree == kBTreeCatalog) && (gBTHeaders[btree]->keyCompareType == kHFSBinaryCompare))␊
917␉␉{␊
918␉␉␉gCaseSensitive = 1;␊
919␉␉}␊
920␉}␊
921␊
922␉curNode = SWAP_BE32(gBTHeaders[btree]->rootNode);␊
923␉nodeSize = SWAP_BE16(gBTHeaders[btree]->nodeSize);␊
924␉nodeBuf = (char *)malloc(nodeSize);␊
925␉node = (BTNodeDescriptor *)nodeBuf;␊
926␊
927␉while (1)␊
928␉{␊
929␉␉// Read the current node.␊
930 ␉ReadExtent(extent, extentSize, extentFile, (long long) curNode * nodeSize, nodeSize, nodeBuf, 1);␊
931␊
932␉␉// Find the matching key.␊
933␉␉lowerBound = 0;␊
934␉␉upperBound = SWAP_BE16(node->numRecords) - 1;␊
935␊
936␉␉while (lowerBound <= upperBound)␊
937␉␉{␊
938␉␉␉index = (lowerBound + upperBound) / 2;␊
939␊
940␉␉␉GetBTreeRecord(index, nodeBuf, nodeSize, &testKey, &recordData);␊
941␊
942␉␉␉if (gIsHFSPlus)␊
943␉␉␉{␊
944␉␉␉␉if (btree == kBTreeCatalog)␊
945␉␉␉␉{␊
946␉␉␉␉␉result = CompareHFSPlusCatalogKeys(key, testKey);␊
947␉␉␉␉}␊
948␉␉␉␉else␊
949␉␉␉␉{␊
950␉␉␉␉␉result = CompareHFSPlusExtentsKeys(key, testKey);␊
951␉␉␉␉}␊
952␉␉␉}␊
953␉␉␉else␊
954␉␉␉{␊
955␉␉␉␉if (btree == kBTreeCatalog)␊
956␉␉␉␉{␊
957␉␉␉␉␉result = CompareHFSCatalogKeys(key, testKey);␊
958␉␉␉␉}␊
959␉␉␉␉else␊
960␉␉␉␉{␊
961␉␉␉␉␉result = CompareHFSExtentsKeys(key, testKey);␊
962␉␉␉␉}␊
963␉␉␉}␊
964␊
965␉␉␉if (result < 0)␊
966␉␉␉{␊
967␉␉␉␉upperBound = index - 1;␉// search < trial␊
968␉␉␉}␊
969␉␉␉else if (result > 0)␊
970␉␉␉{␊
971␉␉␉␉lowerBound = index + 1;␉// search > trial␊
972␉␉␉}␊
973␉␉␉else␊
974␉␉␉{␊
975␉␉␉␉break;␉␉␉// search = trial␊
976␉␉␉}␊
977␉␉}␊
978␊
979␉␉if (result < 0)␊
980␉␉{␊
981␉␉␉index = upperBound;␊
982␉␉␉GetBTreeRecord(index, nodeBuf, nodeSize, &testKey, &recordData);␊
983␉␉}␊
984 ␊
985␉␉// Found the closest key... Recurse on it if this is an index node.␊
986␉␉if (node->kind == kBTIndexNode)␊
987␉␉{␊
988␉␉␉curNode = SWAP_BE32( *((long *)recordData) );␊
989␉␉}␊
990␉␉else␊
991␉␉{␊
992␉␉␉break;␊
993␉␉}␊
994␉}␊
995␊
996␉// Return error if the file was not found.␊
997␉if (result != 0)␊
998␉{␊
999␉␉free(nodeBuf);␊
1000␉␉return -1;␊
1001␉}␊
1002␊
1003␉if (btree == kBTreeCatalog)␊
1004␉{␊
1005␉␉switch (SWAP_BE16(*(short *)recordData))␊
1006␉␉{␊
1007␉␉␉case kHFSFolderRecord : entrySize = 70;␊
1008␉␉␉␉break;␊
1009␉␉␉case kHFSFileRecord : entrySize = 102;␊
1010␉␉␉␉break;␊
1011␉␉␉case kHFSFolderThreadRecord : entrySize = 46;␊
1012␉␉␉␉break;␊
1013␉␉␉case kHFSFileThreadRecord : entrySize = 46;␊
1014␉␉␉␉break;␊
1015␉␉␉case kHFSPlusFolderRecord : entrySize = 88;␊
1016␉␉␉␉break;␊
1017␉␉␉case kHFSPlusFileRecord : entrySize = 248;␊
1018␉␉␉␉break;␊
1019␉␉␉case kHFSPlusFolderThreadRecord : entrySize = 264;␊
1020␉␉␉␉break;␊
1021␉␉␉case kHFSPlusFileThreadRecord : entrySize = 264;␊
1022␉␉␉␉break;␊
1023␉␉}␊
1024␉}␊
1025␉else␊
1026␉{␊
1027␉␉if (gIsHFSPlus)␊
1028␉␉{␊
1029␉␉␉entrySize = sizeof(HFSPlusExtentRecord);␊
1030␉␉}␊
1031␉␉else␊
1032␉␉{␊
1033␉␉␉entrySize = sizeof(HFSExtentRecord);␊
1034␉␉}␊
1035␉}␊
1036␊
1037␉bcopy(recordData, entry, entrySize);␊
1038␊
1039␉// Update dirIndex.␊
1040␉if (dirIndex != 0)␊
1041␉{␊
1042␉␉index++;␊
1043␉␉if (index == SWAP_BE16(node->numRecords))␊
1044␉␉{␊
1045␉␉␉index = 0;␊
1046␉␉␉curNode = SWAP_BE32(node->fLink);␊
1047␉␉}␊
1048␉␉*dirIndex = (long long) curNode * nodeSize + index;␊
1049␉}␊
1050␊
1051␉free(nodeBuf);␊
1052␊
1053␉return 0;␊
1054}␊
1055␊
1056//==============================================================================␊
1057␊
1058static void GetBTreeRecord(u_int16_t index, char * nodeBuffer, u_int16_t nodeSize, char ** key, char ** data)␊
1059{␊
1060␉u_int16_t recordOffset, keySize;␊
1061␊
1062␉recordOffset = SWAP_BE16(*((u_int16_t *)(nodeBuffer + (nodeSize - 2 * index - 2))));␊
1063␉*key = nodeBuffer + recordOffset;␊
1064␊
1065␉if (gIsHFSPlus)␊
1066␉{␊
1067␉␉keySize = SWAP_BE16(*(u_int16_t *)*key);␊
1068␉␉*data = *key + 2 + keySize;␊
1069␉}␊
1070␉else␊
1071␉{␊
1072␉␉keySize = **key;␊
1073␉␉*data = *key + 2 + keySize - (keySize & 1);␊
1074␉}␊
1075}␊
1076␊
1077//==============================================================================␊
1078␊
1079static long ReadExtent(char * extent, u_int64_t extentSize, u_int32_t extentFile, u_int64_t offset, u_int64_t size, void * buffer, long cache)␊
1080{␊
1081␉u_int64_t lastOffset;␊
1082␉u_int64_t blockNumber, countedBlocks = 0;␊
1083␉u_int64_t nextExtent = 0, sizeRead = 0, readSize;␊
1084␉u_int64_t nextExtentBlock, currentExtentBlock = 0;␊
1085␉u_int64_t readOffset;␊
1086␉u_int64_t extentDensity, sizeofExtent, currentExtentSize;␊
1087␉char *currentExtent, *extentBuffer = 0, *bufferPos = buffer;␊
1088␊
1089␉if (offset >= extentSize)␊
1090␉{␊
1091␉␉return 0;␊
1092␉}␊
1093␊
1094␉if (gIsHFSPlus)␊
1095␉{␊
1096␉␉extentDensity = kHFSPlusExtentDensity;␊
1097␉␉sizeofExtent = sizeof(HFSPlusExtentDescriptor);␊
1098␉}␊
1099␉else␊
1100␉{␊
1101␉␉extentDensity = kHFSExtentDensity;␊
1102␉␉sizeofExtent = sizeof(HFSExtentDescriptor);␊
1103␉}␊
1104␊
1105␉lastOffset = offset + size;␊
1106␊
1107␉while (offset < lastOffset)␊
1108␉{␊
1109␉␉blockNumber = offset / gBlockSize;␊
1110␊
1111␉␉// Find the extent for the offset.␊
1112␉␉for (; ; nextExtent++)␊
1113␉␉{␊
1114␉␉␉if (nextExtent < extentDensity)␊
1115␉␉␉{␊
1116␉␉␉␉if ((countedBlocks + GetExtentSize(extent, nextExtent) -1) < blockNumber)␊
1117␉␉␉␉{␊
1118␉␉␉␉␉countedBlocks += GetExtentSize(extent, nextExtent);␊
1119␉␉␉␉␉continue;␊
1120␉␉␉␉}␊
1121␊
1122␉␉␉␉currentExtent = extent + nextExtent * sizeofExtent;␊
1123␉␉␉␉break;␊
1124␉␉␉}␊
1125␊
1126␉␉␉if (extentBuffer == 0)␊
1127␉␉␉{␊
1128␉␉␉␉extentBuffer = malloc(sizeofExtent * extentDensity);␊
1129␊
1130␉␉␉␉if (extentBuffer == 0)␊
1131␉␉␉␉{␊
1132␉␉␉␉␉return -1;␊
1133␉␉␉␉}␊
1134␉␉␉}␊
1135␊
1136␉␉␉nextExtentBlock = nextExtent / extentDensity;␊
1137␊
1138␉␉␉if (currentExtentBlock != nextExtentBlock)␊
1139␉␉␉{␊
1140␉␉␉␉ReadExtentsEntry(extentFile, countedBlocks, extentBuffer);␊
1141␉␉␉␉currentExtentBlock = nextExtentBlock;␊
1142␉␉␉}␊
1143␊
1144␉␉␉currentExtentSize = GetExtentSize(extentBuffer, nextExtent % extentDensity);␊
1145␊
1146␉␉␉if ((countedBlocks + currentExtentSize - 1) >= blockNumber)␊
1147␉␉␉{␊
1148␉␉␉␉currentExtent = extentBuffer + sizeofExtent * (nextExtent % extentDensity);␊
1149␉␉␉␉break;␊
1150␉␉␉}␊
1151␊
1152␉␉␉countedBlocks += currentExtentSize;␊
1153␉␉}␊
1154␊
1155␉␉readOffset = ((blockNumber - countedBlocks) * gBlockSize) + (offset % gBlockSize);␊
1156␊
1157␉␉// MacWen: fix overflow in multiplication by forcing 64bit multiplication␊
1158␉␉readSize = (long long)GetExtentSize(currentExtent, 0) * gBlockSize - readOffset;␊
1159␊
1160␉␉if (readSize > (size - sizeRead))␊
1161␉␉{␊
1162␉␉␉readSize = size - sizeRead;␊
1163␉␉}␊
1164␊
1165␉␉readOffset += (long long)GetExtentStart(currentExtent, 0) * gBlockSize;␊
1166␊
1167␉␉CacheRead(gCurrentIH, bufferPos, gAllocationOffset + readOffset, readSize, cache);␊
1168␊
1169␉␉sizeRead += readSize;␊
1170␉␉offset += readSize;␊
1171␉␉bufferPos += readSize;␊
1172␉}␊
1173␊
1174␉if (extentBuffer)␊
1175␉{␊
1176␉␉free(extentBuffer);␊
1177␉}␊
1178␊
1179␉return sizeRead;␊
1180}␊
1181␊
1182//==============================================================================␊
1183␊
1184static u_int32_t GetExtentStart(void * extents, u_int32_t index)␊
1185{␊
1186␉u_int32_t start;␊
1187␊
1188␉HFSExtentDescriptor␉␉*hfsExtents␉␉= extents;␊
1189␉HFSPlusExtentDescriptor␉*hfsPlusExtents␉= extents;␊
1190␊
1191␉if (gIsHFSPlus)␊
1192␉{␊
1193␉␉start = SWAP_BE32(hfsPlusExtents[index].startBlock);␊
1194␉}␊
1195␉else␊
1196␉{␊
1197␉␉start = SWAP_BE16(hfsExtents[index].startBlock);␊
1198␉}␊
1199␊
1200␉return start;␊
1201}␊
1202␊
1203//==============================================================================␊
1204␊
1205static u_int32_t GetExtentSize(void * extents, u_int32_t index)␊
1206{␊
1207␉u_int32_t size = 0;␊
1208␊
1209␉HFSExtentDescriptor *hfsExtents = extents;␊
1210␉HFSPlusExtentDescriptor *hfsPlusExtents = extents;␊
1211␊
1212␉if (gIsHFSPlus)␊
1213␉{␊
1214␉␉size = SWAP_BE32(hfsPlusExtents[index].blockCount);␊
1215␉}␊
1216␉else␊
1217␉{␊
1218␉␉size = SWAP_BE16(hfsExtents[index].blockCount);␊
1219␉}␊
1220␊
1221␉return size;␊
1222}␊
1223␊
1224//==============================================================================␊
1225␊
1226static long CompareHFSCatalogKeys(void * key, void * testKey)␊
1227{␊
1228␉HFSCatalogKey *searchKey, *trialKey;␊
1229␉long result, searchParentID, trialParentID;␊
1230␊
1231␉searchKey = key;␊
1232␉trialKey = testKey;␊
1233␊
1234␉searchParentID = SWAP_BE32(searchKey->parentID);␊
1235␉trialParentID = SWAP_BE32(trialKey->parentID);␊
1236␊
1237␉// parent dirID is unsigned␊
1238␉if (searchParentID > trialParentID)␊
1239␉{␊
1240␉␉result = 1;␊
1241␉}␊
1242␉else if (searchParentID < trialParentID)␊
1243␉{␊
1244␉␉result = -1;␊
1245␉}␊
1246␉else␊
1247␉{␊
1248␉␉// parent dirID's are equal, compare names␊
1249␉␉result = FastRelString(searchKey->nodeName, trialKey->nodeName);␊
1250␉}␊
1251␊
1252␉return result;␊
1253}␊
1254␊
1255//==============================================================================␊
1256␊
1257static long CompareHFSPlusCatalogKeys(void * key, void * testKey)␊
1258{␊
1259␉HFSPlusCatalogKey *searchKey, *trialKey;␊
1260␉long result, searchParentID, trialParentID;␊
1261␊
1262␉searchKey = key;␊
1263␉trialKey = testKey;␊
1264␊
1265␉searchParentID = SWAP_BE32(searchKey->parentID);␊
1266␉trialParentID = SWAP_BE32(trialKey->parentID);␊
1267␊
1268␉// parent dirID is unsigned␊
1269␉if (searchParentID > trialParentID)␊
1270␉{␊
1271␉␉result = 1;␊
1272␉}␊
1273␉else if (searchParentID < trialParentID) ␊
1274␉{␊
1275␉␉result = -1;␊
1276␉}␊
1277␉else␊
1278␉{␊
1279␉␉// parent dirID's are equal, compare names␊
1280␉␉if ((searchKey->nodeName.length == 0) || (trialKey->nodeName.length == 0))␊
1281␉␉{␊
1282␉␉␉result = searchKey->nodeName.length - trialKey->nodeName.length;␊
1283␉␉}␊
1284␉␉else if (gCaseSensitive)␊
1285␉␉{␊
1286␉␉␉result = BinaryUnicodeCompare(&searchKey->nodeName.unicode[0],␊
1287 SWAP_BE16(searchKey->nodeName.length),␊
1288 &trialKey->nodeName.unicode[0],␊
1289 SWAP_BE16(trialKey->nodeName.length));␊
1290␉␉}␊
1291␉␉else␊
1292␉␉{␊
1293␉␉␉result = FastUnicodeCompare(&searchKey->nodeName.unicode[0],␊
1294 SWAP_BE16(searchKey->nodeName.length),␊
1295 &trialKey->nodeName.unicode[0],␊
1296 SWAP_BE16(trialKey->nodeName.length), OSBigEndian);␊
1297␉␉}␊
1298␉}␊
1299␊
1300␉return result;␊
1301}␊
1302␊
1303//==============================================================================␊
1304␊
1305static long CompareHFSExtentsKeys(void * key, void * testKey)␊
1306{␊
1307␉HFSExtentKey *searchKey, *trialKey;␊
1308␉long result;␊
1309␊
1310␉searchKey = key;␊
1311␉trialKey = testKey;␊
1312␊
1313␉// assume searchKey < trialKey␊
1314␉result = -1; ␊
1315␊
1316␉if (searchKey->fileID == trialKey->fileID)␊
1317␉{␊
1318␉␉// FileNum's are equal; compare fork types␊
1319␉␉if (searchKey->forkType == trialKey->forkType)␊
1320␉␉{␊
1321␉␉␉// Fork types are equal; compare allocation block number␊
1322␉␉␉if (searchKey->startBlock == trialKey->startBlock)␊
1323␉␉␉{␊
1324␉␉␉␉// Everything is equal␊
1325␉␉␉␉result = 0;␊
1326␉␉␉}␊
1327␉␉␉else␊
1328␉␉␉{␊
1329␉␉␉␉// Allocation block numbers differ; determine sign␊
1330␉␉␉␉if (SWAP_BE16(searchKey->startBlock) > SWAP_BE16(trialKey->startBlock))␊
1331␉␉␉␉{␊
1332␉␉␉␉␉result = 1;␊
1333␉␉␉␉}␊
1334␉␉␉}␊
1335 ␉}␊
1336␉␉else␊
1337␉␉{␊
1338␉␉␉// Fork types differ; determine sign␊
1339␉␉␉if (searchKey->forkType > trialKey->forkType)␊
1340␉␉␉{␊
1341␉␉␉␉result = 1;␊
1342␉␉␉}␊
1343␉␉}␊
1344␉}␊
1345␉else␊
1346␉{␊
1347␉␉// FileNums differ; determine sign␊
1348␉␉if (SWAP_BE32(searchKey->fileID) > SWAP_BE32(trialKey->fileID))␊
1349␉␉{␊
1350␉␉␉result = 1;␊
1351␉␉}␊
1352␉}␊
1353␊
1354␉return result;␊
1355}␊
1356␊
1357␊
1358//==============================================================================␊
1359␊
1360static long CompareHFSPlusExtentsKeys(void * key, void * testKey)␊
1361{␊
1362␉HFSPlusExtentKey␉*searchKey, *trialKey;␊
1363␊
1364␉long␉␉␉result;␊
1365␊
1366␉searchKey = key;␊
1367␉trialKey = testKey;␊
1368␊
1369␉// assume searchKey < trialKey␊
1370␉result = -1;␊
1371␊
1372␉if (searchKey->fileID == trialKey->fileID)␊
1373␉{␊
1374␉␉// FileNum's are equal; compare fork types␊
1375␉␉if (searchKey->forkType == trialKey->forkType)␊
1376␉␉{␊
1377␉␉␉// Fork types are equal; compare allocation block number␊
1378␉␉␉if (searchKey->startBlock == trialKey->startBlock)␊
1379␉␉␉{␊
1380␉␉␉␉// Everything is equal␊
1381␉␉␉␉result = 0;␊
1382␉␉␉}␊
1383␉␉␉else␊
1384␉␉␉{␊
1385␉␉␉␉// Allocation block numbers differ; determine sign␊
1386␉␉␉␉if (SWAP_BE32(searchKey->startBlock) > SWAP_BE32(trialKey->startBlock))␊
1387␉␉␉␉{␊
1388␉␉␉␉␉result = 1;␊
1389␉␉␉␉}␊
1390␉␉␉}␊
1391␉␉}␊
1392␉␉else␊
1393␉␉{␊
1394␉␉␉// Fork types differ; determine sign␊
1395␉␉␉if (searchKey->forkType > trialKey->forkType)␊
1396␉␉␉{␊
1397␉␉␉␉result = 1;␊
1398␉␉␉}␊
1399␉␉}␊
1400␉}␊
1401␉else␊
1402␉{␊
1403␉␉// FileNums differ; determine sign␊
1404␉␉if (SWAP_BE32(searchKey->fileID) > SWAP_BE32(trialKey->fileID))␊
1405␉␉{␊
1406␉␉␉result = 1;␊
1407␉␉}␊
1408␉}␊
1409␊
1410 return result;␊
1411}␊
1412␊
1413

Archive Download this file

Revision: 2531