?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import of openhackware-0.4.1
[openhackware.git] / src / libfs / hfs.c
blobb2420ebe8afd392ee893ba81c6b84d9eb1fcf1f8
1 /*
2 * <hfs.c>
3 *
4 * Open Hack'Ware BIOS HFS file system management
5 *
6 * Copyright (c) 2004-2005 Jocelyn Mayer
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License V2
10 * as published by the Free Software Foundation
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * Major rework and debug by Thayne Harbaugh <thayne@realmsys.com>
22 */
23
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include "bios.h"
27 #include "libfs.h"
28
29 //#define DEBUG_HFS 1
30
31 /* HFS / HFSplus */
32 #if defined (DEBUG_HFS)
33 #define HFS_DPRINTF(fmt, args...) \
34 do { dprintf("%s: " fmt, __func__ , ##args); } while (0)
35 #else
36 #define HFS_DPRINTF(fmt, args...) \
37 do { } while (0)
38 #endif
39 #define HFS_ERROR(fmt, args...) \
40 do { dprintf("HFS ERROR in %s: " fmt, __func__ , ##args); } while (0)
41
42 /* HFS/HFS+ common definitions */
43 #define HFS_SECTOR_SIZE 512
44 #define HFS_VOLHEAD_SECTOR 2
45 #define HFS_NODE_SIZE 0x200
46
47 /* HFS signature */
48 #define HFS_VOLHEAD_SIG 0x4244
49 /* HFS+ signature */
50 #define HFSPLUS_VOLHEAD_SIG 0x482b
51
52 /* HFS+ filesystem support */
53 /* Files CNID */
54 enum {
55 HFS_ROOT_PARENT = 1, /* Parent of root folder */
56 HFS_ROOT_FOLDER = 2, /* root folder */
57 HFS_EXTENT_FILE = 3, /* file extents file */
58 HFS_CATALOG_FILE = 4, /* catalog file */
59 HFS_BBLOCS_FILE = 5, /* badblocks file */
60 HFS_ALLOC_FILE = 6, /* allocation file (HFSplus) */
61 HFS_STARTUP_FILE = 7, /* startup file (HFSplus) */
62 HFS_ATTR_FILE = 8, /* attribute file (HFSplus) */
63 HFS_BEXTENT_FILE = 15, /* file extents temporary file */
64 HFS_FIRST_USERID = 16,
65 };
66
67 typedef uint32_t HFS_cnid_t;
68
69 static inline HFS_cnid_t HFS_get_cnid (HFS_cnid_t *cnidp)
70 {
71 return get_be32(cnidp);
72 }
73
74 typedef uint16_t HFSP_unichr_t;
75
76 static inline HFSP_unichr_t HFSP_get_unichr (HFSP_unichr_t *chrp)
77 {
78 return get_be16(chrp);
79 }
80
81 /* A single contiguous area of a file */
82 typedef struct HFSP_extent_t HFSP_extent_t;
83 struct HFSP_extent_t {
84 uint32_t start_block;
85 uint32_t block_count;
86 } __attribute__ ((packed));
87
88 static inline HFSP_extent_t *HFSP_get_extent (HFSP_extent_t *extp)
89 {
90 extp->start_block = get_be32(&extp->start_block);
91 extp->block_count = get_be32(&extp->block_count);
92
93 return extp;
94 }
95
96 /* Information for a "Fork" in a file */
97 typedef struct HFSP_fork_t HFSP_fork_t;
98 struct HFSP_fork_t {
99 /* 0x00 */
100 uint64_t total_size;
101 uint32_t clump_size;
102 uint32_t total_blocks;
103 /* 0x10 */
104 HFSP_extent_t extents[8];
105 /* 0x50 */
106 } __attribute__ ((packed));
107
108 static inline HFSP_fork_t *HFSP_get_fork (HFSP_fork_t *forkp)
109 {
110 int i;
111
112 forkp->total_size = get_be64(&forkp->total_size);
113 forkp->clump_size = get_be32(&forkp->clump_size);
114 forkp->total_blocks = get_be32(&forkp->total_blocks);
115 for (i = 0; i < 8; i++) {
116 HFSP_get_extent(&forkp->extents[i]);
117 }
118
119 return forkp;
120 }
121
122 /* HFS+ Volume Header */
123 typedef struct HFSP_vh_t HFSP_vh_t;
124 struct HFSP_vh_t {
125 /* 0x000 */
126 uint16_t signature;
127 uint16_t version;
128 uint32_t attributes;
129 uint32_t last_mount_vers;
130 uint32_t reserved;
131
132 /* 0x010 */
133 uint32_t create_date;
134 uint32_t modify_date;
135 uint32_t backup_date;
136 uint32_t checked_date;
137
138 /* 0x020 */
139 uint32_t file_count;
140 uint32_t folder_count;
141 uint32_t blocksize;
142 uint32_t total_blocks;
143
144 /* 0x030 */
145 uint32_t free_blocks;
146 uint32_t next_alloc;
147 uint32_t rsrc_clump_sz;
148 uint32_t data_clump_sz;
149
150 /* 0x040 */
151 HFS_cnid_t next_cnid;
152 uint32_t write_count;
153 uint64_t encodings_bmp;
154
155 /* 0x050 */
156 uint32_t finder_info[8];
157
158 /* 0x070 */
159 HFSP_fork_t alloc_file;
160 /* 0x0C0 */
161 HFSP_fork_t ext_file;
162 /* 0x110 */
163 HFSP_fork_t cat_file;
164 /* 0x160 */
165 HFSP_fork_t attr_file;
166 /* 0x1B0 */
167 HFSP_fork_t start_file;
168 /* 0x1F0 */
169 uint8_t pad[16];
170 } __attribute__ ((packed));
171
172 static HFSP_vh_t *HFSP_read_volhead (part_t *part, uint32_t bloc,
173 uint32_t offset, void *buffer, int size)
174 {
175 HFSP_vh_t *vh;
176 int i;
177
178 if (part_seek(part, bloc, offset) == -1)
179 return NULL;
180 if (part_read(part, buffer, size) < 0)
181 return NULL;
182 vh = buffer;
183 vh->signature = get_be16(&vh->signature);
184 vh->version = get_be16(&vh->version);
185 vh->attributes = get_be32(&vh->attributes);
186 vh->last_mount_vers = get_be32(&vh->last_mount_vers);
187 vh->create_date = get_be32(&vh->create_date);
188 vh->modify_date = get_be32(&vh->modify_date);
189 vh->backup_date = get_be32(&vh->backup_date);
190 vh->checked_date = get_be32(&vh->checked_date);
191 vh->file_count = get_be32(&vh->file_count);
192 vh->folder_count = get_be32(&vh->folder_count);
193 vh->blocksize = get_be32(&vh->blocksize);
194 vh->total_blocks = get_be32(&vh->total_blocks);
195 vh->free_blocks = get_be32(&vh->free_blocks);
196 vh->next_alloc = get_be32(&vh->next_alloc);
197 vh->rsrc_clump_sz = get_be32(&vh->rsrc_clump_sz);
198 vh->data_clump_sz = get_be32(&vh->data_clump_sz);
199 HFS_get_cnid(&vh->next_cnid);
200 vh->write_count = get_be32(&vh->write_count);
201 vh->encodings_bmp = get_be32(&vh->encodings_bmp);
202 for (i = 0; i < 8; i++) {
203 vh->finder_info[i] = get_be32(&vh->finder_info[i]);
204 }
205 HFSP_get_fork(&vh->alloc_file);
206 HFSP_get_fork(&vh->ext_file);
207 HFSP_get_fork(&vh->cat_file);
208 HFSP_get_fork(&vh->attr_file);
209 HFSP_get_fork(&vh->start_file);
210
211 return vh;
212 }
213
214 /* HFS support */
215 /* A single contiguous area of a file */
216 typedef struct HFS_extent_t HFS_extent_t;
217 struct HFS_extent_t {
218 uint16_t start_block;
219 uint16_t block_count;
220 } __attribute__ ((packed));
221
222 static inline HFS_extent_t *HFS_get_extent (HFS_extent_t *extp)
223 {
224 extp->start_block = get_be16(&extp->start_block);
225 extp->block_count = get_be16(&extp->block_count);
226
227 return extp;
228 }
229
230 /* HFS Volume Header */
231 typedef struct HFS_vh_t HFS_vh_t;
232 struct HFS_vh_t {
233 /* 0x000 */
234 uint16_t signature;
235 uint32_t create_date;
236 uint32_t modify_date;
237 uint16_t attributes;
238 uint16_t root_file_count;
239 uint16_t bitmap_start;
240
241 /* 0x010 */
242 uint16_t alloc_ptr;
243 uint16_t alloc_blocs;
244 uint32_t alloc_size;
245
246 /* 0x018 */
247 uint32_t clump_size;
248 uint16_t alloc_start;
249 HFS_cnid_t next_cnid;
250 uint16_t free_blocs;
251
252 /* 0x024 */
253 uint8_t label[28];
254
255 /* 0x040 */
256 uint32_t backup_tmsp;
257 uint16_t backup_seq;
258 uint32_t write_count;
259
260 /* 0x04A */
261 uint32_t ext_clump_size;
262 /* 0x04E */
263 uint32_t cat_clump_size;
264
265 /* 0x052 */
266 uint16_t root_dir_cnt;
267 /* 0x054 */
268 uint32_t file_cnt;
269 uint32_t dir_cnt;
270 /* 0x05C */
271 uint32_t finder_info[8];
272
273 /* 0x07C */
274 uint16_t embed_sig;
275 HFS_extent_t embed_ext;
276
277 /* 0x082 */
278 uint32_t ext_size;
279 HFS_extent_t ext_rec[3];
280
281 /* 0x092 */
282 uint32_t cat_size;
283 HFS_extent_t cat_rec[3];
284
285 /* 0x0A2 */
286 } __attribute__(( __packed__ ));
287
288 static HFS_vh_t *HFS_read_volhead (part_t *part, uint32_t bloc,
289 uint32_t offset, void *buffer, int size)
290 {
291 HFS_vh_t *vh;
292 int i;
293
294 if (part_seek(part, bloc, offset) == -1)
295 return NULL;
296 if (part_read(part, buffer, size) < 0)
297 return NULL;
298 vh = buffer;
299 vh->signature = get_be16(&vh->signature);
300 vh->create_date = get_be32(&vh->create_date);
301 vh->modify_date = get_be32(&vh->modify_date);
302 vh->attributes = get_be16(&vh->attributes);
303 vh->root_file_count = get_be16(&vh->root_file_count);
304 vh->bitmap_start = get_be16(&vh->bitmap_start);
305 vh->alloc_ptr = get_be16(&vh->alloc_ptr);
306 vh->alloc_blocs = get_be16(&vh->alloc_blocs);
307 vh->alloc_size = get_be32(&vh->alloc_size);
308 vh->clump_size = get_be32(&vh->clump_size);
309 vh->alloc_start = get_be16(&vh->alloc_start);
310 HFS_get_cnid(&vh->next_cnid);
311 vh->free_blocs = get_be16(&vh->free_blocs);
312 vh->backup_tmsp = get_be32(&vh->backup_tmsp);
313 vh->backup_seq = get_be16(&vh->backup_seq);
314 vh->write_count = get_be32(&vh->write_count);
315 vh->ext_clump_size = get_be32(&vh->ext_clump_size);
316 vh->cat_clump_size = get_be32(&vh->cat_clump_size);
317 vh->root_dir_cnt = get_be16(&vh->root_dir_cnt);
318 vh->file_cnt = get_be32(&vh->file_cnt);
319 vh->dir_cnt = get_be32(&vh->dir_cnt);
320 for (i = 0; i < 8; i++) {
321 vh->finder_info[i] = get_be32(&vh->finder_info[i]);
322 }
323 vh->embed_sig = get_be16(&vh->embed_sig);
324 HFS_get_extent(&vh->embed_ext);
325 vh->ext_size = get_be16(&vh->ext_size);
326 for (i = 0; i < 3; i++) {
327 HFS_get_extent(&vh->ext_rec[i]);
328 }
329 vh->cat_size = get_be16(&vh->cat_size);
330 for (i = 0; i < 3; i++) {
331 HFS_get_extent(&vh->cat_rec[i]);
332 }
333
334 return vh;
335 }
336
337 enum {
338 HFS_NODE_LEAF = 0xFF,
339 HFS_NODE_IDX = 0x00,
340 HFS_NODE_HEAD = 0x01,
341 HFS_NODE_MAP = 0x02,
342 };
343
344 /* HFS B-tree structures */
345 typedef struct HFS_bnode_t HFS_bnode_t;
346 struct HFS_bnode_t {
347 uint32_t next;
348 uint32_t prev;
349 uint8_t type;
350 uint8_t height;
351 uint16_t nrecs;
352 uint16_t pad;
353 } __attribute__ ((packed));
354
355 static HFS_bnode_t *HFS_read_Hnode (part_t *part, uint32_t bloc,
356 uint32_t offset, void *buffer, int nsize)
357 {
358 HFS_bnode_t *Hnode;
359
360 if (part_seek(part, bloc, offset) == -1) {
361 HFS_DPRINTF("seek failed\n");
362 return NULL;
363 }
364 if (part_read(part, buffer, nsize) < 0) {
365 HFS_DPRINTF("read failed\n");
366 return NULL;
367 }
368 Hnode = (void *)buffer;
369 Hnode->next = get_be32(&Hnode->next);
370 Hnode->prev = get_be32(&Hnode->prev);
371 Hnode->nrecs = get_be16(&Hnode->nrecs);
372
373 return Hnode;
374 }
375
376 typedef struct HFS_headrec_t HFS_headrec_t;
377 struct HFS_headrec_t {
378 /* 0x00 */
379 uint16_t depth;
380 uint32_t rootnode;
381 /* 0x06 */
382 uint32_t nbleaves;
383 uint32_t firstleaf;
384 /* 0x0E */
385 uint32_t lastleaf;
386 uint16_t nodesize;
387 /* 0x14 */
388 uint16_t maxkeylen;
389 uint32_t nbnodes;
390 /* 0x18 */
391 uint32_t freenodes;
392 uint16_t pad0;
393 /* 0x1E */
394 uint32_t clump_size;
395 uint8_t type;
396 uint8_t pad1;
397 /* 0x24 */
398 uint32_t attr;
399 /* 0x28 */
400 uint32_t pad2[16];
401 /* 0x68 */
402 } __attribute__ ((packed));
403
404 static HFS_headrec_t *HFS_get_headrec (void *pos)
405 {
406 HFS_headrec_t *head = pos;
407
408 head->depth = get_be16(&head->depth);
409 head->rootnode = get_be32(&head->rootnode);
410 head->nbleaves = get_be32(&head->nbleaves);
411 head->firstleaf = get_be32(&head->firstleaf);
412 head->lastleaf = get_be32(&head->lastleaf);
413 head->maxkeylen = get_be16(&head->maxkeylen);
414 head->nbnodes = get_be32(&head->nbnodes);
415 head->freenodes = get_be32(&head->freenodes);
416 head->clump_size = get_be32(&head->clump_size);
417 head->attr = get_be32(&head->attr);
418
419 return head;
420 }
421
422 typedef struct HFS_catkey_t HFS_catkey_t;
423 struct HFS_catkey_t {
424 uint8_t len;
425 uint8_t pad;
426 HFS_cnid_t pID;
427 uint8_t nlen;
428 unsigned char name[0x1F];
429 } __attribute__ ((packed));
430
431 typedef struct HFSP_catkey_t HFSP_catkey_t;
432 struct HFSP_catkey_t {
433 uint16_t len;
434 HFS_cnid_t pID;
435 uint16_t nlen;
436 HFSP_unichr_t uniname[255];
437 } __attribute__ ((packed));
438
439 enum {
440 HFS_CAT_FOLDER = 0x0100,
441 HFS_CAT_FILE = 0x0200,
442 HFS_CAT_FOLDTH = 0x0300,
443 HFS_CAT_FILETH = 0x0400,
444 HFSP_CAT_FOLDER = 0x0001,
445 HFSP_CAT_FILE = 0x0002,
446 HFSP_CAT_FOLDTH = 0x0003,
447 HFSP_CAT_FILETH = 0x0004,
448 };
449
450 typedef struct HFS_win_t HFS_win_t;
451 struct HFS_win_t {
452 uint16_t top;
453 uint16_t left;
454 uint16_t bot;
455 uint16_t right;
456 } __attribute__ ((packed));
457
458 typedef struct HFS_pos_t HFS_pos_t;
459 struct HFS_pos_t {
460 uint16_t y;
461 uint16_t x;
462 } __attribute__ ((packed));
463
464 typedef struct HFS_fdir_info_t HFS_fdir_info_t;
465 struct HFS_fdir_info_t {
466 HFS_win_t win;
467 uint16_t flags;
468 HFS_pos_t pos;
469 uint16_t pad;
470 } __attribute__ ((packed));
471
472 typedef struct HFS_file_info_t HFS_file_info_t;
473 struct HFS_file_info_t {
474 uint32_t ftype;
475 uint32_t owner;
476 uint16_t flags;
477 HFS_pos_t pos;
478 uint16_t pad;
479 } __attribute__ ((packed));
480
481 typedef struct HFSP_BSD_info_t HFSP_BSD_info_t;
482 struct HFSP_BSD_info_t {
483 uint32_t owner;
484 uint32_t group;
485 uint8_t aflags;
486 uint8_t oflags;
487 uint16_t mode;
488 union {
489 uint32_t inum;
490 uint32_t lcount;
491 uint32_t device;
492 } u;
493 } __attribute__ ((packed));
494
495 typedef struct HFS_fold_t HFS_fold_t;
496 struct HFS_fold_t {
497 uint16_t type;
498 uint16_t flags;
499 uint16_t valence;
500 HFS_cnid_t ID;
501 uint32_t created;
502 uint32_t modifd;
503 uint32_t backupd;
504 HFS_fdir_info_t finder_dir;
505 uint8_t finder_pad[16];
506 uint32_t pad[4];
507 } __attribute__ ((packed));
508
509 typedef struct HFSP_fold_t HFSP_fold_t;
510 struct HFSP_fold_t {
511 uint16_t type;
512 uint16_t flags;
513 uint32_t valence;
514 HFS_cnid_t ID;
515 uint32_t created;
516 uint32_t modifd;
517 uint32_t attrd;
518 uint32_t accessd;
519 uint32_t attrmd;
520 HFSP_BSD_info_t BSD_infos;
521 HFS_fdir_info_t finder_dir;
522 uint8_t finder_pad[16];
523 uint32_t encoding;
524 uint32_t pad;
525 } __attribute__ ((packed));
526
527 typedef struct HFS_file_t HFS_file_t;
528 struct HFS_file_t {
529 /* 0x00 */
530 uint16_t type;
531 uint8_t flags;
532 uint8_t ftype;
533 /* 0x04 */
534 HFS_file_info_t finder_file;
535 /* 0x14 */
536 HFS_cnid_t ID;
537 /* 0x18 */
538 uint16_t dstart;
539 uint32_t dlsize;
540 uint32_t dpsize;
541 uint16_t rstart;
542 /* 0x24 */
543 uint32_t rlsize;
544 uint32_t rpsize;
545 /* 0x2C */
546 uint32_t created;
547 /* 0x30 */
548 uint32_t modifd;
549 uint32_t backupd;
550 /* 0x38 */
551 uint8_t finder_pad[16];
552 /* 0x48 */
553 uint16_t clump_size;
554 /* 0x4C */
555 HFS_extent_t extents[3];
556 /* 0x54 */
557 } __attribute__ ((packed));
558
559 typedef struct HFSP_file_t HFSP_file_t;
560 struct HFSP_file_t {
561 /* 0x00 */
562 uint16_t type;
563 uint16_t flags;
564 uint32_t pad;
565 /* 0x08 */
566 HFS_cnid_t ID;
567 uint32_t created;
568 /* 0x10 */
569 uint32_t modifd;
570 uint32_t attrd;
571 uint32_t accessd;
572 uint32_t backupd;
573 /* 0x20 */
574 HFSP_BSD_info_t BSD_infos;
575 /* 0x30 */
576 HFS_file_info_t finder_file;
577 /* 0x40 */
578 uint8_t finder_pad[16];
579 /* 0x50 */
580 uint32_t encoding;
581 uint32_t pad1[3];
582 HFSP_fork_t data;
583 HFSP_fork_t ressources;
584 } __attribute__ ((packed));
585
586 typedef struct HFS_thread_t HFS_thread_t;
587 struct HFS_thread_t {
588 uint16_t type;
589 uint32_t pad[2];
590 HFS_cnid_t pid;
591 uint8_t pad0;
592 unsigned char name[32];
593 } __attribute__ ((packed));
594
595 typedef struct HFSP_thread_t HFSP_thread_t;
596 struct HFSP_thread_t {
597 uint16_t type;
598 uint16_t pad;
599 HFS_cnid_t pid;
600 uint16_t nlen;
601 HFSP_unichr_t uniname[255];
602 } __attribute__ ((packed));
603
604 /* in memory structures */
605 typedef struct hfs_vol_t hfs_vol_t;
606 typedef struct hfs_btree_t hfs_btree_t;
607 typedef struct hfs_rec_t hfs_rec_t;
608
609 /* Volume/file structures */
610 typedef struct hfs_extent_t {
611 uint32_t start;
612 uint32_t count;
613 } hfs_extent_t;
614
615 typedef struct hfs_fork_t {
616 hfs_vol_t *volume;
617 uint32_t nb_blocs;
618 hfs_extent_t extents[8];
619 hfs_rec_t *catrec;
620 hfs_rec_t *extrec;
621 } hfs_fork_t;
622
623 struct hfs_vol_t {
624 part_t *part;
625 int type;
626 HFS_cnid_t boot_id;
627 uint32_t embed_offset;
628 uint32_t start_offset;
629 uint32_t bsize;
630 hfs_fork_t alloc_file;
631 hfs_fork_t cat_file;
632 hfs_fork_t ext_file;
633 hfs_fork_t *boot_file;
634 hfs_btree_t *cat_tree;
635 hfs_btree_t *ext_tree;
636 };
637
638 /* Btree structures */
639 /* Btree node */
640 typedef struct hfs_bnode_t {
641 hfs_btree_t *tree;
642 uint32_t prev;
643 uint32_t next;
644 int type;
645 uint32_t nrecs;
646 hfs_rec_t *recs;
647 } hfs_bnode_t;
648
649 /* Cached Btree node */
650 typedef struct hfs_cbnode_t hfs_cbnode_t;
651 struct hfs_cbnode_t {
652 uint32_t location;
653 hfs_cbnode_t *next;
654 hfs_bnode_t bnode;
655 };
656
657 /* Bnode records */
658 enum {
659 RECORD_HEAD = 0,
660 RECORD_IDX,
661 RECORD_CAT,
662 RECORD_EXT,
663 };
664
665 /* Header record */
666 typedef struct hfs_headrec_t {
667 uint32_t rootnode;
668 uint32_t firstleaf;
669 uint32_t lastleaf;
670 uint32_t nodesize;
671 } hfs_headrec_t;
672
673 /* Index record */
674 typedef struct hfs_idxrec_t {
675 HFS_cnid_t pid;
676 HFS_cnid_t uid;
677 unsigned char name[0x20];
678 } hfs_idxrec_t;
679
680 /* File extent records */
681 /* TODO */
682 typedef struct hfs_extrec_t {
683 HFS_cnid_t ID;
684 } hfs_extrec_t;
685
686 /* Catalog records */
687 typedef struct hfs_catrec_t {
688 HFS_cnid_t ID;
689 HFS_cnid_t pid;
690 int type;
691 unsigned char name[0x20];
692 unsigned char finfo[9];
693 hfs_fork_t fork;
694 } hfs_catrec_t;
695
696 /* Generic record */
697 struct hfs_rec_t {
698 hfs_bnode_t *node;
699 int type;
700 int num;
701 union {
702 hfs_headrec_t headrec;
703 hfs_idxrec_t idxrec;
704 hfs_catrec_t catrec;
705 hfs_extrec_t extrec;
706 } u;
707 };
708
709 struct hfs_btree_t {
710 hfs_fork_t *file;
711 hfs_cbnode_t *cache;
712 hfs_rec_t *head_rec;
713 hfs_bnode_t *root_node;
714 hfs_rec_t *root_catrec;
715 hfs_rec_t *root_extrec;
716 uint32_t nodesize;
717 unsigned char *buf;
718 int type;
719 int (*compare)(int type, HFS_cnid_t cnid,
720 const void *more, hfs_rec_t *rec, int rectype);
721 };
722
723 /* Unicode to ISO-8859-15, stolen from Linux nls */
724 static unsigned char page00[256] = {
725 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, /* 0x00-0x07 */
726 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, /* 0x08-0x0f */
727 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, /* 0x10-0x17 */
728 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, /* 0x18-0x1f */
729 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, /* 0x20-0x27 */
730 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, /* 0x28-0x2f */
731 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, /* 0x30-0x37 */
732 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, /* 0x38-0x3f */
733 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, /* 0x40-0x47 */
734 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, /* 0x48-0x4f */
735 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, /* 0x50-0x57 */
736 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, /* 0x58-0x5f */
737 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, /* 0x60-0x67 */
738 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, /* 0x68-0x6f */
739 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, /* 0x70-0x77 */
740 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, /* 0x78-0x7f */
741
742 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x80-0x87 */
743 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x88-0x8f */
744 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x90-0x97 */
745 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x98-0x9f */
746 0xa0, 0xa1, 0xa2, 0xa3, 0x00, 0xa5, 0x00, 0xa7, /* 0xa0-0xa7 */
747 0x00, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, /* 0xa8-0xaf */
748 0xb0, 0xb1, 0xb2, 0xb3, 0x00, 0xb5, 0xb6, 0xb7, /* 0xb0-0xb7 */
749 0x00, 0xb9, 0xba, 0xbb, 0x00, 0x00, 0x00, 0xbf, /* 0xb8-0xbf */
750 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, /* 0xc0-0xc7 */
751 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, /* 0xc8-0xcf */
752 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, /* 0xd0-0xd7 */
753 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, /* 0xd8-0xdf */
754 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, /* 0xe0-0xe7 */
755 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, /* 0xe8-0xef */
756 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, /* 0xf0-0xf7 */
757 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, /* 0xf8-0xff */
758 };
759
760 static unsigned char page01[256] = {
761 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00-0x07 */
762 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x08-0x0f */
763 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x10-0x17 */
764 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x18-0x1f */
765 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x20-0x27 */
766 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x28-0x2f */
767 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x30-0x37 */
768 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x38-0x3f */
769 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x40-0x47 */
770 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x48-0x4f */
771 0x00, 0x00, 0xbc, 0xbd, 0x00, 0x00, 0x00, 0x00, /* 0x50-0x57 */
772 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x58-0x5f */
773 0xa6, 0xa8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x60-0x67 */
774 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x68-0x6f */
775 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x70-0x77 */
776 0xbe, 0x00, 0x00, 0x00, 0x00, 0xb4, 0xb8, 0x00, /* 0x78-0x7f */
777 };
778
779 static unsigned char page20[256] = {
780 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00-0x07 */
781 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x08-0x0f */
782 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x10-0x17 */
783 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x18-0x1f */
784 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x20-0x27 */
785 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x28-0x2f */
786 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x30-0x37 */
787 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x38-0x3f */
788 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x40-0x47 */
789 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x48-0x4f */
790 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x50-0x57 */
791 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x58-0x5f */
792 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x60-0x67 */
793 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x68-0x6f */
794 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x70-0x77 */
795 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x78-0x7f */
796
797 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x80-0x87 */
798 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x88-0x8f */
799 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x90-0x97 */
800 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x98-0x9f */
801 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xa0-0xa7 */
802 0x00, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, /* 0xa8-0xaf */
803 };
804
805 static unsigned char *page_uni2charset[256] = {
806 page00, page01, NULL, NULL, NULL, NULL, NULL, NULL,
807 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
808
809 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
810 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
811
812 page20, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
813 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
814 };
815
816 static int uni2char (uint16_t uni, unsigned char *out)
817 {
818 unsigned char *uni2charset;
819 unsigned char cl = uni & 0x00ff;
820 unsigned char ch = (uni & 0xff00) >> 8;
821
822 uni2charset = page_uni2charset[ch];
823 if (uni2charset && uni2charset[cl])
824 *out = uni2charset[cl];
825 else
826 return -1;
827
828 return 0;
829 }
830
831 static void hfs_get_str (unsigned char *out, int len, uint16_t *hfs_str)
832 {
833 int i;
834 char c;
835
836 for (i = 0; i < len; i++) {
837 if (uni2char(*hfs_str++, &c) < 0)
838 c = '?';
839 out[i] = c;
840 }
841 out[i] = '\0';
842 }
843
844 /* Locate a bloc in the partition given a file and an offset */
845 static uint32_t hfs_get_bloc (hfs_fork_t *file, uint32_t bloc)
846 {
847 hfs_vol_t *volume;
848 hfs_extent_t *extent;
849 uint32_t abloc, aoffset;
850 int i;
851
852 volume = file->volume;
853 abloc = bloc / volume->bsize;
854 aoffset = bloc - (abloc * volume->bsize);
855 extent = file->extents;
856 #if 0
857 HFS_DPRINTF("Look for bloc %08x => %08x %08x (%08x)\n",
858 bloc, abloc, aoffset, volume->bsize);
859 #endif
860 for (i = 0; i < 8; i++) {
861 #if 0
862 HFS_DPRINTF("Check extent %d %08x %08x (%08x)\n",
863 i, extent->start, extent->count, abloc);
864 #endif
865 if (extent->count == 0)
866 break;
867 if (abloc < extent->count) {
868 return volume->start_offset + /*volume->embed_offset +*/
869 ((extent->start + abloc) * volume->bsize) + aoffset;
870 }
871 abloc -= extent->count;
872 extent++;
873 }
874 HFS_ERROR("Block %d not found\n", bloc);
875
876 return -1;
877 }
878
879 /* Convert HFS/HFS plus extent/fork records to memory structure */
880 static inline void hfs_get_extent (hfs_extent_t *dst, HFS_extent_t *src)
881 {
882 dst->start = src->start_block;
883 dst->count = src->block_count;
884 }
885
886 static void hfs_get_fork (hfs_fork_t *dst, uint32_t blocs,
887 HFS_extent_t *extents)
888 {
889 int i;
890
891 dst->nb_blocs = blocs;
892 for (i = 0; i < 3; i++) {
893 hfs_get_extent(&dst->extents[i], &extents[i]);
894 }
895 memset(&dst->extents[3], 0, 5 * sizeof(hfs_extent_t));
896 }
897
898 static inline void hfsp_get_extent (hfs_extent_t *dst, HFSP_extent_t *src)
899 {
900 dst->start = src->start_block;
901 dst->count = src->block_count;
902 }
903
904 static void hfsp_get_fork (hfs_fork_t *dst, uint32_t blocs,
905 HFSP_extent_t *extents)
906 {
907 int i;
908
909 dst->nb_blocs = blocs;
910 for (i = 0; i < 8; i++) {
911 hfsp_get_extent(&dst->extents[i], &extents[i]);
912 }
913 }
914
915 static void hfs_dump_fork (hfs_fork_t *fork)
916 {
917 int i;
918
919 HFS_DPRINTF("Nb blocs: %d\n", fork->nb_blocs);
920 for (i = 0; i < 8; i++) {
921 if (fork->extents[i].count == 0)
922 break;
923 HFS_DPRINTF(" extent %d: start: %08x count: %08x\n",
924 i, fork->extents[i].start, fork->extents[i].count);
925 }
926 }
927
928 /* Btree nodes cache */
929 static inline void *hfs_brec_get (HFS_bnode_t *node, uint32_t nodesize, int nb)
930 {
931 uint16_t *off;
932
933 if (nb < 1 || nb > node->nrecs) {
934 HFS_ERROR("nb=%d nrec=%d\n", nb, node->nrecs);
935 return NULL;
936 }
937 off = (void *)((char *)node + nodesize);
938 off -= nb;
939 HFS_DPRINTF("%d => %02x node %p off %p %p %d\n",
940 nb, *off, node, off, (char *)node + nodesize, nodesize);
941
942 return (char *)node + *off;
943 }
944
945 static hfs_bnode_t *hfs_bnode_get (hfs_btree_t *tree, uint32_t location)
946 {
947 unsigned char *buffer, tmpbuf[HFS_NODE_SIZE];
948 void *HFS_recp;
949 HFS_bnode_t *Hnode;
950 HFS_headrec_t *Hhead;
951 HFSP_catkey_t *HPkey = NULL;
952 HFS_catkey_t *Hkey = NULL;
953 HFSP_thread_t *HPthread;
954 HFS_thread_t *Hthread;
955 HFSP_fold_t *HPdir;
956 HFS_fold_t *Hdir;
957 HFSP_file_t *HPfile;
958 HFS_file_t *Hfile;
959 hfs_headrec_t *head;
960 hfs_cbnode_t **cur;
961 hfs_bnode_t *node;
962 hfs_rec_t *rec;
963 uint32_t bloc, offset, bsize, *upID, nsize;
964 uint16_t *ptype;
965 int i, j, is_hfs;
966
967 #if 1
968 for (cur = &tree->cache; *cur != NULL; cur = &((*cur)->next)) {
969 if ((*cur)->location == location) {
970 HFS_DPRINTF("found node %08x in cache (%08x %08x)\n",
971 location, (*cur)->bnode.prev, (*cur)->bnode.next);
972 return &(*cur)->bnode;
973 }
974 }
975 #endif
976 /* Not found in cache, get it from disk */
977 head = &tree->head_rec->u.headrec;
978 if (tree->nodesize != 0) {
979 nsize = tree->nodesize;
980 buffer = tree->buf;
981 } else {
982 nsize = HFS_NODE_SIZE;
983 buffer = tmpbuf;
984 }
985 bsize = part_blocsize(tree->file->volume->part);
986 bloc = location * nsize / 512;
987 HFS_DPRINTF("Get node from %08x %08x %p\n",
988 bloc, nsize, tree->file->volume->part);
989 bloc = hfs_get_bloc(tree->file, bloc);
990 if (bloc == (uint32_t)-1)
991 return NULL;
992 HFS_DPRINTF(" => %08x\n", bloc);
993 #if 0
994 offset = bloc % bsize;
995 bloc /= bsize;
996 #else
997 offset = 0;
998 #endif
999 HFS_DPRINTF(" => %08x %08x (%d)\n", bloc, offset, bsize);
1000 Hnode = HFS_read_Hnode(tree->file->volume->part,
1001 bloc, offset, buffer, nsize);
1002 if (Hnode == NULL) {
1003 HFS_DPRINTF("No Hnode !\n");
1004 return NULL;
1005 }
1006 *cur = malloc(sizeof(hfs_cbnode_t) + (Hnode->nrecs * sizeof(hfs_rec_t)));
1007 if (*cur == NULL)
1008 return NULL;
1009 memset(*cur, 0, sizeof(hfs_cbnode_t) + (Hnode->nrecs * sizeof(hfs_rec_t)));
1010 (*cur)->location = location;
1011 node = &(*cur)->bnode;
1012 node->tree = tree;
1013 node->prev = Hnode->prev;
1014 node->next = Hnode->next;
1015 node->type = Hnode->type;
1016 node->nrecs = Hnode->nrecs;
1017 node->recs = (void *)(node + 1);
1018 if (tree->nodesize == 0 && node->type != HFS_NODE_HEAD) {
1019 HFS_ERROR("first node should be a header !\n");
1020 return NULL;
1021 }
1022 if (node->type == HFS_NODE_HEAD) {
1023 Hhead = HFS_get_headrec(Hnode + 1);
1024 nsize = Hhead->nodesize;
1025 if (nsize == 0)
1026 nsize = HFS_NODE_SIZE;
1027 HFS_DPRINTF("Set node size to %d\n", nsize);
1028 tree->nodesize = nsize;
1029 tree->buf = malloc(nsize);
1030 if (tree->buf == NULL)
1031 return NULL;
1032 memset(tree->buf, 0, nsize);
1033 buffer = tree->buf;
1034 Hnode = HFS_read_Hnode(tree->file->volume->part,
1035 bloc, offset, buffer, nsize);
1036 if (Hnode == NULL)
1037 return NULL;
1038 }
1039 HFS_DPRINTF("New node %08x prev: %08x next: %08x type: %d nrecs: %d\n",
1040 location, node->prev, node->next, node->type, node->nrecs);
1041 is_hfs = tree->file->volume->type == FS_TYPE_HFS;
1042 for (i = 0; i < (int)node->nrecs; i++) {
1043 rec = &node->recs[i];
1044 rec->node = node;
1045 rec->num = i + 1;
1046 HFS_recp = hfs_brec_get(Hnode, nsize, i + 1);
1047 if (HFS_recp == NULL) {
1048 HFS_ERROR("can't get record %d\n", i + 1);
1049 continue;
1050 }
1051 if (is_hfs) {
1052 Hkey = HFS_recp;
1053 #if 0
1054 upID = (void *)(((uint32_t)Hkey + 2 + Hkey->len));
1055 #else
1056 upID = (void *)(((uint32_t)Hkey + 2 + Hkey->len) & ~1);
1057 #endif
1058 } else {
1059 HPkey = HFS_recp;
1060 upID = (void *)(((uint32_t)HPkey + 2 + HPkey->len) & ~1);
1061 }
1062 switch (node->type) {
1063 case HFS_NODE_LEAF:
1064 HFS_DPRINTF("record %d: leaf %p %p %d\n", i + 1, upID, HFS_recp,
1065 (char *)upID - (char *)HFS_recp);
1066 rec->type = tree->type;
1067 switch (rec->type) {
1068 case RECORD_CAT:
1069 ptype = (void *)upID;
1070 if (is_hfs) {
1071 memcpy(rec->u.catrec.name, Hkey->name, Hkey->nlen);
1072 rec->u.catrec.name[Hkey->nlen] = '\0';
1073 rec->u.catrec.pid = Hkey->pID;
1074 } else {
1075 hfs_get_str(rec->u.catrec.name,
1076 HPkey->nlen, HPkey->uniname);
1077 rec->u.catrec.pid = HPkey->pID;
1078 }
1079 rec->u.catrec.type = *ptype;
1080 rec->u.catrec.fork.volume = tree->file->volume;
1081 rec->u.catrec.fork.catrec = rec;
1082 switch (*ptype) {
1083 case HFS_CAT_FOLDER:
1084 Hdir = (void *)ptype;
1085 rec->u.catrec.ID = Hdir->ID;
1086 HFS_DPRINTF("HFS Catalog folder ID: %08x name '%s' %08x\n",
1087 rec->u.catrec.ID, rec->u.catrec.name,
1088 rec->u.catrec.pid);
1089 break;
1090 case HFS_CAT_FILE:
1091 Hfile = (void *)ptype;
1092 rec->u.catrec.ID = Hfile->ID;
1093 memcpy(rec->u.catrec.finfo, &Hfile->finder_file, 8);
1094 rec->u.catrec.finfo[8] = '\0';
1095 for (j = 0; j < 3; j++) {
1096 hfs_get_extent(&rec->u.catrec.fork.extents[j],
1097 &Hfile->extents[j]);
1098 #if 0
1099 HFS_DPRINTF("Extent %04x %04x => %08x %08x\n",
1100 Hfile->extents[j].start_block,
1101 Hfile->extents[j].block_count,
1102 rec->u.catrec.fork.extents[j].start,
1103 rec->u.catrec.fork.extents[j].count);
1104 #endif
1105 }
1106 memset(&rec->u.catrec.fork.extents[3], 0,
1107 5 * sizeof(hfs_extent_t));
1108 HFS_DPRINTF("HFS Catalog file ID: %08x name '%s' '%s' %08x\n",
1109 rec->u.catrec.ID, rec->u.catrec.name,
1110 rec->u.catrec.finfo, rec->u.catrec.pid);
1111 #if 0
1112 HFS_DPRINTF("Extent %08x %08x\n",
1113 rec->u.catrec.fork.extents[0].start,
1114 rec->u.catrec.fork.extents[0].count);
1115 #endif
1116 break;
1117 case HFS_CAT_FOLDTH:
1118 Hthread = (void *)ptype;
1119 strcpy(rec->u.catrec.name, Hthread->name);
1120 rec->u.catrec.ID = rec->u.catrec.pid;
1121 rec->u.catrec.pid = Hthread->pid;
1122 HFS_DPRINTF("HFS Catalog folder thread '%s' %08x %08x\n",
1123 rec->u.catrec.name, rec->u.catrec.ID,
1124 rec->u.catrec.pid);
1125 continue;
1126 case HFS_CAT_FILETH:
1127 Hthread = (void *)ptype;
1128 strcpy(rec->u.catrec.name, Hthread->name);
1129 rec->u.catrec.ID = rec->u.catrec.pid;
1130 rec->u.catrec.pid = Hthread->pid;
1131 HFS_DPRINTF("HFS Catalog file thread '%s' %08x %08x\n",
1132 rec->u.catrec.name, rec->u.catrec.ID,
1133 rec->u.catrec.pid);
1134 continue;
1135 case HFSP_CAT_FOLDER:
1136 HPdir = (void *)ptype;
1137 rec->u.catrec.ID = HPdir->ID;
1138 HFS_DPRINTF("HFSplus Catalog folder ID: %08x name '%s'\n",
1139 rec->u.catrec.ID, rec->u.catrec.name);
1140 break;
1141 case HFSP_CAT_FILE:
1142 HPfile = (void *)ptype;
1143 rec->u.catrec.ID = HPfile->ID;
1144 memcpy(rec->u.catrec.finfo, &HPfile->finder_file, 8);
1145 rec->u.catrec.finfo[8] = '\0';
1146 memcpy(&rec->u.catrec.fork, &HPfile->data,
1147 sizeof(HFSP_fork_t));
1148 HFS_DPRINTF("HFSPlus Catalog file ID: %08x name '%s' '%s'\n",
1149 rec->u.catrec.ID, rec->u.catrec.name,
1150 rec->u.catrec.finfo);
1151 HFS_DPRINTF("Extent %08x %08x\n",
1152 rec->u.catrec.fork.extents[0].start,
1153 rec->u.catrec.fork.extents[0].count);
1154 break;
1155 case HFSP_CAT_FOLDTH:
1156 HPthread = (void *)ptype;
1157 rec->u.catrec.ID = rec->u.catrec.pid;
1158 rec->u.catrec.pid = HPthread->pid;
1159 hfs_get_str(rec->u.catrec.name,
1160 HPthread->nlen, HPthread->uniname);
1161 HFS_DPRINTF("HFSplus Catalog folder thread '%s'...\n",
1162 rec->u.catrec.name);
1163 break;
1164 case HFSP_CAT_FILETH:
1165 HPthread = (void *)ptype;
1166 hfs_get_str(rec->u.catrec.name,
1167 HPthread->nlen, HPthread->uniname);
1168 rec->u.catrec.ID = rec->u.catrec.pid;
1169 rec->u.catrec.pid = HPthread->pid;
1170 HFS_DPRINTF("HFSplus Catalog file thread '%s'...\n",
1171 rec->u.catrec.name);
1172 break;
1173 default:
1174 printf("Unknown catalog entry %d %d '%s' %d\n", rec->type,
1175 *ptype, rec->u.catrec.name, (char *)ptype - (char *)Hkey);
1176 continue;
1177 }
1178 break;
1179 case RECORD_EXT:
1180 /* TODO */
1181 HFS_DPRINTF("Extent file entry\n");
1182 continue;
1183 default:
1184 HFS_ERROR("Unknown entry\n");
1185 continue;
1186 }
1187 break;
1188 case HFS_NODE_IDX:
1189 rec->type = RECORD_IDX;
1190 rec->u.idxrec.uid = *upID;
1191 if (is_hfs) {
1192 rec->u.idxrec.pid = Hkey->pID;
1193 memcpy(rec->u.idxrec.name, Hkey->name, Hkey->nlen);
1194 rec->u.idxrec.name[Hkey->nlen] = '\0';
1195 HFS_DPRINTF("HFS IDX record %d parent: %08x up: %08x name '%s'\n",
1196 i + 1, rec->u.idxrec.pid, rec->u.idxrec.uid,
1197 rec->u.idxrec.name);
1198 HFS_DPRINTF("uidp : %d %d\n", (char *)upID - (char *)Hkey,
1199 (char *)(Hkey + 1) - (char *)Hkey);
1200 } else {
1201 rec->u.idxrec.pid = HPkey->pID;
1202 hfs_get_str(rec->u.idxrec.name,
1203 HPkey->nlen, HPkey->uniname);
1204 HFS_DPRINTF("HFSplus IDX record %d parent: %08x up: %08x "
1205 "name '%s'\n", i + 1, rec->u.idxrec.pid,
1206 rec->u.idxrec.uid, rec->u.idxrec.name);
1207 }
1208 break;
1209 case HFS_NODE_HEAD:
1210 Hhead = HFS_get_headrec(HFS_recp);
1211 rec->type = RECORD_HEAD;
1212 rec->u.headrec.rootnode = Hhead->rootnode;
1213 rec->u.headrec.firstleaf = Hhead->firstleaf;
1214 rec->u.headrec.lastleaf = Hhead->lastleaf;
1215 rec->u.headrec.nodesize = Hhead->nodesize;
1216 HFS_DPRINTF("Header record %d root: %08x first: %08x last: %08x "
1217 "size: %08x\n", i + 1, rec->u.headrec.rootnode,
1218 rec->u.headrec.firstleaf, rec->u.headrec.lastleaf,
1219 rec->u.headrec.nodesize);
1220 node->nrecs = 1;
1221 goto out;
1222 case HFS_NODE_MAP:
1223 /* TODO */
1224 default:
1225 continue;
1226 }
1227 }
1228
1229 out:
1230 return node;
1231 }
1232
1233 static inline hfs_rec_t *hfs_rec_get (hfs_bnode_t *node, int nb)
1234 {
1235 if (nb < 1 || nb > (int)node->nrecs) {
1236 HFS_ERROR("nb: %d min: %d max: %d\n", nb, 1, node->nrecs);
1237 return NULL;
1238 }
1239
1240 return &node->recs[nb - 1];
1241 }
1242
1243 static inline hfs_bnode_t *hfs_bnode_prev (hfs_bnode_t *cur)
1244 {
1245 if (cur->prev == 0x00000000)
1246 return NULL;
1247
1248 return hfs_bnode_get(cur->tree, cur->prev);
1249 }
1250
1251 static inline hfs_bnode_t *hfs_bnode_next (hfs_bnode_t *cur)
1252 {
1253 if (cur->next == 0x00000000)
1254 return NULL;
1255
1256 return hfs_bnode_get(cur->tree, cur->next);
1257 }
1258
1259 unused static hfs_rec_t *hfs_rec_prev (hfs_rec_t *cur)
1260 {
1261 hfs_bnode_t *curn;
1262 int num;
1263
1264 num = cur->num;
1265 curn = cur->node;
1266 if (num == 1) {
1267 curn = hfs_bnode_prev(curn);
1268 if (curn == NULL)
1269 return NULL;
1270 num = curn->nrecs + 1;
1271 }
1272
1273 return hfs_rec_get(curn, num - 1);
1274 }
1275
1276 unused static hfs_rec_t *hfs_rec_next (hfs_rec_t *cur)
1277 {
1278 hfs_bnode_t *curn;
1279 int num;
1280
1281 num = cur->num;
1282 curn = cur->node;
1283 if (num == (int)curn->nrecs) {
1284 curn = hfs_bnode_next(curn);
1285 if (curn == NULL)
1286 return NULL;
1287 num = 1;
1288 }
1289
1290 return hfs_rec_get(curn, num - 1);
1291 }
1292
1293 static int hfs_cat_compare (int type, HFS_cnid_t cnid,
1294 const void *more, hfs_rec_t *rec, int rectype);
1295
1296 /* Simplified Btree recurse function from Linux */
1297 static hfs_rec_t *hfs_rec_find (hfs_btree_t *tree,
1298 HFS_cnid_t cnid, const char *name, int rectype)
1299 {
1300 hfs_bnode_t *curn;
1301 hfs_rec_t *cur;
1302 unsigned int i;
1303 int ret;
1304
1305 /*
1306 * This is an ugly scattering of #if, but it's wonderful for debugging
1307 * hfs_rec_find(). If you set this to 1, then the loop will traverse
1308 * and show all of the records in a node before descending the correct
1309 * record.
1310 */
1311 #define DEBUG_HFS_REC_FIND 0
1312 #if DEBUG_HFS_REC_FIND
1313 hfs_rec_t *idx_cur;
1314 unsigned int idx;
1315 int idx_ret;
1316 #endif /* DEBUG_HFS_REC_FIND */
1317
1318 HFS_DPRINTF("look for ID: %08x '%s'\n", cnid, name);
1319 cur = NULL;
1320 ret = -1;
1321 i = 0;
1322 for (curn = tree->root_node; curn != NULL;) {
1323 #if DEBUG_HFS_REC_FIND
1324 idx = 0;
1325 idx_ret = 0;
1326 idx_cur = NULL;
1327 #endif /* DEBUG_HFS_REC_FIND */
1328 for (i = curn->nrecs; i != 0; i--) {
1329 cur = hfs_rec_get(curn, i);
1330 if (cur == NULL) {
1331 HFS_ERROR("Cannot get record %d\n", i);
1332 return NULL;
1333 }
1334 HFS_DPRINTF("Check record %d %d %p %p %p\n", i, cur->type, cur,
1335 curn->tree->compare, &hfs_cat_compare);
1336 ret = (*curn->tree->compare)(cur->type, cnid, name, cur, rectype);
1337 HFS_DPRINTF("\t%u:%d\n", i, ret);
1338 if (ret >= 0) {
1339 #if !DEBUG_HFS_REC_FIND
1340 break;
1341 #else
1342 if (!idx) {
1343 idx = i;
1344 idx_ret = ret;
1345 idx_cur = cur;
1346 }
1347 #endif /* DEBUG_HFS_REC_FIND */
1348 }
1349 }
1350 #if DEBUG_HFS_REC_FIND
1351 if (idx) {
1352 i = idx;
1353 ret = idx_ret;
1354 cur = idx_cur;
1355 }
1356 #endif /* DEBUG_HFS_REC_FIND */
1357 HFS_DPRINTF("ret=%d HFS_NODE=%02x RECORD=%02x\n",
1358 ret, curn->type, cur->type);
1359 if (i == 0 || /* exhausted all the records */
1360 curn->type == HFS_NODE_LEAF) { /* Can't descend any lower */
1361 break;
1362 }
1363 HFS_DPRINTF("Recurse to record: %d %08x => %08x\n",
1364 i, cnid, cur->u.idxrec.uid);
1365 curn = hfs_bnode_get(curn->tree, cur->u.idxrec.uid);
1366 }
1367 if (ret != 0 || curn == NULL) {
1368 /* We won't find what we're looking for... */
1369 HFS_DPRINTF("NOT FOUND\n");
1370 return NULL;
1371 }
1372 #if 0
1373 if (ret != 0 && cur->u.catrec.ID != cnid) {
1374 HFS_ERROR("%d %d\n", cur->u.catrec.ID, cnid);
1375 return NULL;
1376 }
1377 #endif
1378 HFS_DPRINTF("found %p %p %d %p\n", cur, curn, i, hfs_rec_get(curn, i));
1379
1380 return cur;
1381 }
1382
1383 static inline hfs_rec_t *hfs_get_dir (hfs_btree_t *tree, HFS_cnid_t cnid,
1384 const unsigned char *name)
1385 {
1386 return hfs_rec_find(tree, cnid, name, 1);
1387 }
1388
1389 static hfs_rec_t *hfs_get_dirfile (hfs_rec_t *dir, HFS_cnid_t cnid,
1390 const unsigned char *name,
1391 const unsigned char *info)
1392 {
1393 hfs_btree_t *tree;
1394 hfs_bnode_t *cur;
1395 hfs_rec_t *rec;
1396 hfs_catrec_t *frec;
1397 int idx;
1398
1399 cur = dir->node;
1400 tree = cur->tree;
1401 for (idx = dir->num + 1;; idx++) {
1402 if (idx > (int)cur->nrecs) {
1403 HFS_DPRINTF("Go to next node %08x\n", cur->next);
1404 cur = hfs_bnode_next(cur);
1405 if (cur == NULL) {
1406 HFS_ERROR("Node %08x not found\n", cur->next);
1407 break;
1408 }
1409 idx = 1;
1410 }
1411 rec = hfs_rec_get(cur, idx);
1412 if (rec == NULL) {
1413 HFS_ERROR("Cannot get record %d\n", idx);
1414 return NULL;
1415 }
1416 HFS_DPRINTF("Check record %d '%s' '%s' '%s' '%s'\n",
1417 idx, rec->u.catrec.name, rec->u.catrec.finfo, name, info);
1418 if (rec->type == RECORD_IDX) {
1419 continue;
1420 }
1421 frec = &rec->u.catrec;
1422 if (frec->type != HFS_CAT_FILE && frec->type != HFS_CAT_FILETH &&
1423 frec->type != HFSP_CAT_FILE && frec->type != HFSP_CAT_FILETH)
1424 continue;
1425 if (frec->pid != cnid) {
1426 HFS_ERROR("Out of directory %08x %08x\n", cnid, frec->pid);
1427 break;
1428 }
1429 if (info != NULL && memcmp(frec->finfo, info, strlen(info)) != 0)
1430 continue;
1431 /* Beware: HFS is case insensitive ! */
1432 if (name != NULL && strcasecmp(frec->name, name) != 0)
1433 continue;
1434 return rec;
1435 }
1436
1437 return NULL;
1438 }
1439
1440 static hfs_btree_t *hfs_btree_open (hfs_fork_t *fork, int type,
1441 int (*compare)(int type,
1442 HFS_cnid_t cnid,
1443 const void *more,
1444 hfs_rec_t *rec,
1445 int rectype))
1446 {
1447 hfs_bnode_t *node;
1448 hfs_rec_t *rec;
1449 hfs_headrec_t *head;
1450 hfs_btree_t *newt;
1451 uint32_t bloc;
1452
1453 bloc = hfs_get_bloc(fork, 0);
1454 if (bloc == (uint32_t)-1)
1455 return NULL;
1456 HFS_DPRINTF("Open btree: bloc=%08x\n", bloc);
1457 /* Allocate tree */
1458 newt = malloc(sizeof(hfs_btree_t));
1459 if (newt == NULL)
1460 return NULL;
1461 memset(newt, 0, sizeof(hfs_btree_t));
1462 newt->file = fork;
1463 newt->cache = NULL;
1464 newt->type = type;
1465 newt->compare = compare;
1466 /* Get tree header */
1467 HFS_DPRINTF("Get first node\n");
1468 node = hfs_bnode_get(newt, 0);
1469 if (node == NULL) {
1470 HFS_ERROR("Cannot get tree head\n");
1471 return NULL;
1472 }
1473 HFS_DPRINTF("Get first record\n");
1474 rec = hfs_rec_get(node, 1);
1475 if (rec == NULL) {
1476 HFS_ERROR("Cannot get first record\n");
1477 return NULL;
1478 }
1479 if (rec->type != RECORD_HEAD) {
1480 HFS_ERROR("Not an header record !\n");
1481 return NULL;
1482 }
1483 head = &rec->u.headrec;
1484 newt->head_rec = rec;
1485 /* Get root node */
1486 HFS_DPRINTF("Get root entry node: %08x\n", head->rootnode);
1487 newt->root_node = hfs_bnode_get(newt, head->rootnode);
1488 if (newt->root_node == NULL)
1489 return NULL;
1490 /* Get root directory record */
1491 HFS_DPRINTF("Get root folder record\n");
1492 newt->root_catrec = hfs_get_dir(newt, HFS_ROOT_FOLDER, "");
1493 HFS_DPRINTF("Found root folder record: %p\n", newt->root_catrec);
1494 if (newt->root_catrec == NULL)
1495 return NULL;
1496
1497 return newt;
1498 }
1499
1500 static int hfs_cat_compare (int type, HFS_cnid_t cnid,
1501 const void *more, hfs_rec_t *rec, int rectype)
1502 {
1503 hfs_idxrec_t *idxrec;
1504 hfs_catrec_t *catrec;
1505 const unsigned char *name;
1506 HFS_cnid_t id;
1507 int ret;
1508
1509 if (type == RECORD_IDX) {
1510 idxrec = &rec->u.idxrec;
1511 id = idxrec->pid;
1512 name = idxrec->name;
1513 catrec = NULL;
1514 } else {
1515 catrec = &rec->u.catrec;
1516 name = catrec->name;
1517 if (type != RECORD_IDX &&
1518 (catrec->type == HFS_CAT_FOLDTH ||
1519 catrec->type == HFS_CAT_FILETH ||
1520 catrec->type == HFSP_CAT_FOLDTH ||
1521 catrec->type == HFSP_CAT_FILETH)) {
1522 HFS_DPRINTF("CHECK FOLDER %08x %08x!\n", catrec->ID, catrec->pid);
1523 id = catrec->ID;
1524 } else {
1525 id = catrec->pid;
1526 }
1527 }
1528 HFS_DPRINTF("Compare cnid (%08x '%s') vs (%08x '%s') %08x %d\n",
1529 cnid, (char *)more, id, name, catrec->type, rectype);
1530
1531 /*
1532 * Always diff Record_IDXs, but diff RECORDS_CATs iff they match the type
1533 * being looked for: THREAD vs NON-THREAD (rectype).
1534 */
1535 ret = cnid - id;
1536
1537 if (ret == 0 && type != RECORD_IDX) {
1538 /* out on a leaf - don't compare different types */
1539 if (rectype &&
1540 (catrec->type == HFS_CAT_FILE ||
1541 catrec->type == HFS_CAT_FOLDER ||
1542 catrec->type == HFSP_CAT_FILE ||
1543 catrec->type == HFSP_CAT_FOLDER)) {
1544 /* looking for thread and this is a file/folder - keep looking */
1545 ret = -1;
1546 } else if (!rectype &&
1547 (catrec->type == HFS_CAT_FILETH ||
1548 catrec->type == HFS_CAT_FOLDTH ||
1549 catrec->type == HFSP_CAT_FILETH ||
1550 catrec->type == HFSP_CAT_FOLDTH)) {
1551 /* looking for file/folder and this is a thread - keep looking */
1552 ret = -1;
1553 }
1554 }
1555
1556 if (ret == 0 &&
1557 /* Apparently there is still a match - further constrain it by
1558 * checking if the name matches. Name matchs should be
1559 * skipped if we're looking for a thread and we've reached a
1560 * leaf record (that case will match solely on the record
1561 * type and the cnid which has already been done).
1562 */
1563 (type == RECORD_IDX ||
1564 (!rectype &&
1565 (catrec->type == HFS_CAT_FILE ||
1566 catrec->type == HFS_CAT_FOLDER ||
1567 catrec->type == HFSP_CAT_FILE ||
1568 catrec->type == HFSP_CAT_FOLDER)))) {
1569 /* HFS is case insensitive - HFSP *can* be case sensitive */
1570 ret = strcasecmp(more, name);
1571 }
1572
1573 HFS_DPRINTF("ret %d catrec %p catrec->type %08x\n",
1574 ret, catrec, catrec ? catrec->type : 0);
1575 return ret;
1576 }
1577
1578 static hfs_btree_t *hfs_cat_open (hfs_vol_t *volume)
1579 {
1580 HFS_DPRINTF("Open HFS catalog\n");
1581 return hfs_btree_open(&volume->cat_file, RECORD_CAT, &hfs_cat_compare);
1582 }
1583
1584 unused static int hfs_ext_compare (unused int type, unused HFS_cnid_t cnid,
1585 unused const void *more,
1586 unused hfs_rec_t *rec)
1587 {
1588 /* TODO */
1589 return -1;
1590 }
1591
1592 static hfs_btree_t *hfs_ext_open (unused hfs_vol_t *volume)
1593 {
1594 HFS_DPRINTF("Open HFS extents file\n");
1595 #if 0
1596 return hfs_btree_open(&volume->ext_file, RECORD_EXT, &hfs_ext_compare);
1597 #else
1598 return NULL;
1599 #endif
1600 }
1601
1602 static void hfs_map_boot_file (part_t *part, hfs_vol_t *volume,
1603 uint32_t *boot_start, uint32_t *boot_offset,
1604 uint32_t *boot_size)
1605 {
1606 uint32_t bloc, size;
1607
1608 /* Now, patch the partition to register the boot file
1609 * XXX: we "know" that only one extent is used...
1610 * this may not be true if booting from a hard drive...
1611 */
1612 volume->boot_file->volume = volume;
1613 bloc = hfs_get_bloc(volume->boot_file, 0);
1614 if (bloc == (uint32_t)(-1)) {
1615 printf("Cannot get boot file start bloc\n");
1616 return;
1617 }
1618 size = volume->boot_file->extents[0].count * volume->bsize;
1619 // printf("Map boot file bloc 0 to %08x\n", bloc);
1620 part_set_boot_file(part, bloc, 0, size);
1621 *boot_start = bloc;
1622 *boot_size = size;
1623 *boot_offset = 0;
1624 }
1625
1626 static inode_t *fs_hfs_get_inode (inode_t *parent, const unsigned char *name)
1627 {
1628 inode_t *new;
1629 hfs_fork_t *pfile, *file;
1630 hfs_rec_t *catrec, *extrec;
1631 uint32_t size;
1632 int i;
1633
1634 pfile = parent->private;
1635 HFS_DPRINTF("Get inode '%s' %p %p %p %08x\n", name, pfile, pfile->catrec,
1636 pfile->catrec->node->tree, pfile->catrec->u.catrec.pid);
1637 catrec = hfs_rec_find(pfile->catrec->node->tree,
1638 pfile->catrec->u.catrec.ID, name, 0);
1639 #if 0
1640 extrec = hfs_rec_find(pfile->extrec->node->tree,
1641 pfile->extrec->u.extrec.pid, name, 0);
1642 #else
1643 extrec = NULL;
1644 #endif
1645 if (catrec == NULL /* || extrec == NULL */)
1646 return NULL;
1647 new = malloc(sizeof(inode_t));
1648 if (new == NULL)
1649 return NULL;
1650 memset(new, 0, sizeof(inode_t));
1651 new->flags = 0;
1652 file = &catrec->u.catrec.fork;
1653 new->private = file;
1654 size = 0;
1655 for (i = 0; i < 8; i++) {
1656 if (file->extents[i].count == 0)
1657 break;
1658 size += file->extents[i].count;
1659 }
1660 size *= file->volume->bsize;
1661 new->size.bloc = size;
1662 new->size.offset = 0;
1663 HFS_DPRINTF("File: '%s'\n", name);
1664 hfs_dump_fork(new->private);
1665
1666 return new;
1667 }
1668
1669 static void fs_hfs_put_inode (unused inode_t *inode)
1670 {
1671 }
1672
1673 static uint32_t fs_hfs_map_bloc (inode_t *inode, uint32_t bloc)
1674 {
1675 return hfs_get_bloc(inode->private, bloc);
1676 }
1677
1678 static inode_t *fs_hfs_get_special_inode (fs_t *fs, int type)
1679 {
1680 hfs_vol_t *volume;
1681 inode_t *bfile, *bdir, *cur;
1682 hfs_rec_t *drec, *rec;
1683 hfs_fork_t *fork;
1684 uint32_t boot_start, boot_size, boot_offset;
1685 HFS_cnid_t id;
1686
1687 volume = fs->private;
1688 switch (type) {
1689 case FILE_ROOT:
1690 if (fs->root == NULL) {
1691 volume->cat_tree = hfs_cat_open(volume);
1692 volume->ext_tree = hfs_ext_open(volume);
1693 if (volume->cat_tree == NULL /*|| volume->ext_tree == NULL*/) {
1694 HFS_ERROR("Can't open volume catalog/extent files\n");
1695 return NULL;
1696 }
1697 cur = malloc(sizeof(inode_t));
1698 if (cur == NULL)
1699 return NULL;
1700 memset(cur, 0, sizeof(inode_t));
1701 cur->flags = INODE_TYPE_DIR;
1702 cur->private = &volume->cat_tree->root_catrec->u.catrec.fork;
1703 cur->parent = NULL;
1704 } else {
1705 cur = fs->root;
1706 }
1707 return cur;
1708 case FILE_BOOT:
1709 if (fs->bootfile != NULL)
1710 return fs->bootfile;
1711 break;
1712 case FILE_BOOTDIR:
1713 if (fs->bootdir != NULL)
1714 return fs->bootdir;
1715 if (volume->boot_file != NULL) {
1716 bfile = malloc(sizeof(inode_t));
1717 if (bfile == NULL)
1718 return NULL;
1719 memset(bfile, 0, sizeof(inode_t));
1720 fs->bootfile = bfile;
1721 rec = volume->boot_file->catrec;
1722 bfile->name = strdup(rec->u.catrec.name);
1723 if (bfile->name == NULL) {
1724 free(bfile);
1725 fs->bootfile = NULL;
1726 return NULL;
1727 }
1728 bfile->private = volume->boot_file;
1729 bfile->flags = INODE_TYPE_FILE | INODE_FLAG_EXEC | INODE_FLAG_BOOT;
1730 fs->bootdir = fs->root;
1731 hfs_map_boot_file(fs->part, volume,
1732 &boot_start, &boot_offset, &boot_size);
1733 }
1734 break;
1735 default:
1736 return NULL;
1737 }
1738 HFS_DPRINTF("Look for boot file (%d)\n", volume->boot_id);
1739 if (volume->boot_file == NULL ||
1740 volume->boot_file->extents[0].count == 0) {
1741 if (volume->boot_id != 0x00000000) {
1742 /* Try to find regular MacOS bootfile */
1743 drec = hfs_get_dir(volume->cat_tree, volume->boot_id, "");
1744 if (drec == NULL) {
1745 HFS_ERROR("Didn't find boot directory %d\n", volume->boot_id);
1746 return NULL;
1747 }
1748 HFS_DPRINTF("Found boot directory '%s'\n", drec->u.catrec.name);
1749 rec = hfs_get_dirfile(drec, volume->boot_id, NULL, "tbxi");
1750 } else {
1751 /* Try NetBSD boot */
1752 drec = hfs_get_dir(volume->cat_tree, HFS_ROOT_FOLDER, "");
1753 if (drec == NULL)
1754 return NULL;
1755 rec = hfs_get_dirfile(drec, HFS_ROOT_FOLDER, "ofwboot", NULL);
1756 if (rec == NULL) {
1757 rec = hfs_get_dirfile(drec, HFS_ROOT_FOLDER,
1758 "ofwboot.xcf", NULL);
1759 if (rec == NULL) {
1760 rec = hfs_get_dirfile(drec, HFS_ROOT_FOLDER,
1761 "ofwboot.elf", NULL);
1762 }
1763 }
1764 if (rec != NULL) {
1765 volume->boot_id = rec->u.catrec.pid;
1766 drec = hfs_get_dir(volume->cat_tree, volume->boot_id, "");
1767 }
1768 }
1769 if (rec == NULL) {
1770 HFS_ERROR("Didn't find boot file\n");
1771 return NULL;
1772 }
1773 volume->boot_file = &rec->u.catrec.fork;
1774 hfs_map_boot_file(fs->part, volume,
1775 &boot_start, &boot_offset, &boot_size);
1776 HFS_DPRINTF("boot file mapped: %08x-%08x %08x\n",
1777 boot_start, boot_offset, boot_size);
1778 #if 0
1779 hfs_treat_boot_file(fs->part, volume,
1780 &boot_start, &boot_offset, &boot_size);
1781 #endif
1782 HFS_DPRINTF("Dump boot file\n");
1783 hfs_dump_fork(volume->boot_file);
1784 HFS_DPRINTF("boot file mapped: %08x-%08x %08x\n",
1785 boot_start, boot_offset, boot_size);
1786 } else {
1787 drec = hfs_get_dir(volume->cat_tree, HFS_ROOT_FOLDER, "");
1788 if (drec == NULL)
1789 return NULL;
1790 }
1791 rec = volume->boot_file->catrec;
1792 fork = volume->boot_file;
1793 HFS_DPRINTF("boot file: %p '%s' boot dir: %p '%s'\n",
1794 rec, rec->u.catrec.name, drec, drec->u.catrec.name);
1795 bfile = malloc(sizeof(inode_t));
1796 if (bfile == NULL)
1797 return NULL;
1798 memset(bfile, 0, sizeof(inode_t));
1799 fs->bootfile = bfile;
1800 bfile->name = strdup(rec->u.catrec.name);
1801 if (bfile->name == NULL) {
1802 free(bfile);
1803 return NULL;
1804 }
1805 bfile->private = fork;
1806 bfile->flags = INODE_TYPE_FILE | INODE_FLAG_EXEC | INODE_FLAG_BOOT;
1807 bfile->size.bloc = boot_size / part_blocsize(volume->part);
1808 bfile->size.offset = boot_size % part_blocsize(volume->part);
1809 HFS_DPRINTF("%s: look for parent ID: %08x\n", __func__, volume->boot_id);
1810 bdir = NULL;
1811 cur = NULL;
1812 if (type == FILE_BOOT) {
1813 cur = bfile;
1814 }
1815 for (id = volume->boot_id; id != HFS_ROOT_FOLDER;
1816 id = drec->u.catrec.pid) {
1817 drec = hfs_get_dir(volume->cat_tree, id, "");
1818 if (drec == NULL)
1819 return NULL;
1820 bdir = malloc(sizeof(inode_t));
1821 if (bdir == NULL)
1822 return NULL;
1823 memset(bdir, 0, sizeof(inode_t));
1824 if (id == volume->boot_id) {
1825 if (type == FILE_BOOTDIR)
1826 cur = bdir;
1827 fs->bootdir = bdir;
1828 }
1829 bdir->name = strdup(drec->u.catrec.name);
1830 if (bdir->name == NULL) {
1831 free(bdir);
1832 return NULL;
1833 }
1834 bdir->private = &drec->u.catrec.fork;
1835 bdir->flags = INODE_TYPE_DIR;
1836 bfile->parent = bdir;
1837 HFS_DPRINTF("%s: cache '%s' into '%s'\n",
1838 __func__, bfile->name, bdir->name);
1839 fs_cache_add_inode(bdir, bfile);
1840 bfile = bdir;
1841 }
1842 bfile->parent = fs->root;
1843 HFS_DPRINTF("%s: cache '%s' into root dir\n", __func__, bfile->name);
1844 fs_cache_add_inode(fs->root, bfile);
1845 if (bdir == NULL) {
1846 bdir = fs->root;
1847 fs->bootdir = bdir;
1848 if (type == FILE_BOOTDIR)
1849 cur = bdir;
1850 }
1851 cur->fs = fs;
1852 HFS_DPRINTF("boot file: %p '%s' boot dir: %p '%s'\n",
1853 fs->bootfile, fs->bootfile->name,
1854 fs->bootdir, fs->bootdir->name);
1855 HFS_DPRINTF("boot fork %p rec %p %p %08x\n",
1856 bfile->private, rec, rec->u.catrec.fork.catrec,
1857 rec->u.catrec.ID);
1858 HFS_DPRINTF("boot dir fork %p rec %p %p %08x %08x\n",
1859 bdir->private, drec, drec->u.catrec.fork.catrec,
1860 drec->u.catrec.ID, volume->boot_id);
1861 HFS_DPRINTF("FS cat tree: %p\n", volume->cat_tree);
1862
1863 return cur;
1864 }
1865
1866 static fs_ops_t hfs_fs_ops = {
1867 &fs_hfs_get_inode,
1868 &fs_hfs_put_inode,
1869 &fs_hfs_map_bloc,
1870 &fs_hfs_get_special_inode,
1871 };
1872
1873 int fs_hfs_probe (part_t *part, uint32_t *size,
1874 fs_ops_t **fs_ops, unsigned char **name,
1875 void **private)
1876 {
1877 unsigned char buffer[512];
1878 HFSP_vh_t *hfsp_vh;
1879 HFS_vh_t *hfs_vh;
1880 hfs_vol_t *volume;
1881 uint32_t embed_offset = 0, boot_id;
1882 int type;
1883
1884 hfs_vh = HFS_read_volhead(part, HFS_VOLHEAD_SECTOR, 0, buffer, 512);
1885 hfsp_vh = NULL;
1886 if (hfs_vh == NULL) {
1887 DPRINTF("Can't read HFS volume header\n");
1888 return -1;
1889 }
1890 type = -1;
1891 if (hfs_vh->signature == HFS_VOLHEAD_SIG) {
1892 /* HFS volume */
1893 printf("HFS volume\n");
1894 if (hfs_vh->embed_sig == HFSPLUS_VOLHEAD_SIG) {
1895 embed_offset = hfs_vh->embed_ext.start_block *
1896 hfs_vh->alloc_size / HFS_SECTOR_SIZE;
1897 embed_offset += hfs_vh->alloc_start;
1898 printf("HFSplus embedded volume offset=%08x\n", embed_offset);
1899 hfsp_vh = HFSP_read_volhead(part,
1900 HFS_VOLHEAD_SECTOR + embed_offset,
1901 0, buffer, 512);
1902 goto handle_hfsp;
1903 }
1904 boot_id = hfs_vh->finder_info[0];
1905 DPRINTF("HFS boot id : %d %04x\n", boot_id, boot_id);
1906 volume = malloc(sizeof(hfs_vol_t));
1907 if (volume == NULL)
1908 return -1;
1909 memset(volume, 0, sizeof(hfs_vol_t));
1910 HFS_DPRINTF("sig: %x %x %x\n", hfs_vh->signature,
1911 hfs_vh->embed_sig, HFSPLUS_VOLHEAD_SIG);
1912 HFS_DPRINTF("cr: %08x mod: %08x attr: %04x count: %04x\n",
1913 hfs_vh->create_date, hfs_vh->modify_date,
1914 hfs_vh->attributes, hfs_vh->root_file_count);
1915 HFS_DPRINTF("alloc ptr: %04x blocs: %04x size: %08x bmap %04x\n",
1916 hfs_vh->alloc_ptr, hfs_vh->alloc_blocs, hfs_vh->alloc_size,
1917 hfs_vh->bitmap_start);
1918 volume->bsize = hfs_vh->alloc_size / HFS_SECTOR_SIZE;
1919 volume->start_offset = hfs_vh->alloc_start;
1920 /* Alloc file */
1921 volume->alloc_file.volume = volume;
1922 volume->alloc_file.nb_blocs = hfs_vh->alloc_size * volume->bsize;
1923 volume->alloc_file.extents[0].start = 0;
1924 volume->alloc_file.extents[0].count = hfs_vh->alloc_size;
1925 /* Catalog file */
1926 volume->cat_file.volume = volume;
1927 hfs_get_fork(&volume->cat_file, hfs_vh->cat_size, hfs_vh->cat_rec);
1928 /* Extents file */
1929 volume->ext_file.volume = volume;
1930 hfs_get_fork(&volume->ext_file, hfs_vh->ext_size, hfs_vh->ext_rec);
1931 *size = hfs_vh->alloc_blocs * volume->bsize;
1932 *name = strdup(hfs_vh->label);
1933 if (*name == NULL)
1934 return -1;
1935 type = FS_TYPE_HFS;
1936 } else {
1937 hfsp_vh = HFSP_read_volhead(part, HFS_VOLHEAD_SECTOR, 0, buffer, 512);
1938 handle_hfsp:
1939 if (hfsp_vh == NULL) {
1940 DPRINTF("Can't read HFS+ volume header\n");
1941 return -1;
1942 }
1943 if (hfsp_vh->signature != HFSPLUS_VOLHEAD_SIG) {
1944 DPRINTF("Bad HFS+ signature %02x %02x\n",
1945 hfsp_vh->signature, HFSPLUS_VOLHEAD_SIG);
1946 return -1;
1947 }
1948 /* HFS+ volume */
1949 printf("HFSplus volume\n");
1950 volume = malloc(sizeof(hfs_vol_t));
1951 if (volume == NULL)
1952 return -1;
1953 memset(volume, 0, sizeof(hfs_vol_t));
1954 volume->embed_offset = embed_offset;
1955 volume->start_offset = embed_offset;
1956 volume->bsize = hfsp_vh->blocksize / HFS_SECTOR_SIZE;
1957 // volume->bsize = 2048;
1958 /* Boot file */
1959 HFS_DPRINTF("Boot file: %d %d\n",
1960 hfsp_vh->start_file.total_blocks,
1961 hfsp_vh->start_file.extents[0].block_count);
1962 if (hfsp_vh->start_file.total_blocks != 0) {
1963 volume->boot_file = malloc(sizeof(hfs_fork_t));
1964 memset(volume->boot_file, 0, sizeof(hfs_fork_t));
1965 volume->boot_file->volume = volume;
1966 hfsp_get_fork(volume->boot_file,
1967 hfsp_vh->start_file.total_blocks,
1968 hfsp_vh->start_file.extents);
1969 boot_id = 2;
1970 } else {
1971 boot_id = hfsp_vh->finder_info[0];
1972 }
1973 DPRINTF("HFS+ boot id : %d %04x %d\n", boot_id, boot_id,
1974 hfsp_vh->start_file.total_blocks);
1975 /* Catalog file */
1976 volume->cat_file.volume = volume;
1977 hfsp_get_fork(&volume->cat_file,
1978 hfsp_vh->cat_file.total_blocks,
1979 hfsp_vh->cat_file.extents);
1980 /* Extents file */
1981 volume->ext_file.volume = volume;
1982 hfsp_get_fork(&volume->ext_file,
1983 hfsp_vh->ext_file.total_blocks,
1984 hfsp_vh->ext_file.extents);
1985 *size = hfsp_vh->total_blocks * volume->bsize;
1986 type = FS_TYPE_HFSP;
1987 }
1988 volume->boot_id = boot_id;
1989 volume->type = type;
1990 HFS_DPRINTF("%s volume: type: %d bsize: %d start_offset: %d\n",
1991 type == FS_TYPE_HFS ? "HFS" : "HFSplus",
1992 volume->type, volume->bsize, volume->start_offset);
1993 HFS_DPRINTF("Catalog file:\n");
1994 hfs_dump_fork(&volume->cat_file);
1995 HFS_DPRINTF("Extents file:\n");
1996 hfs_dump_fork(&volume->ext_file);
1997 if (volume->boot_file != NULL) {
1998 HFS_DPRINTF("Boot file:\n");
1999 hfs_dump_fork(volume->boot_file);
2000 }
2001 *fs_ops = &hfs_fs_ops;
2002 HFS_DPRINTF("Set part to %p\n", part);
2003 volume->part = part;
2004 *private = volume;
2005
2006 return type;
2007 }
OpenHack'Ware, an OpenFirmware compatible firmware for QEMU