![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hfsp_volume.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / hfsplus|
Return to hfsp_volume.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / hfsplus |
1.1 root 1: /*
2: * libhfs - library for reading and writing Macintosh HFS volumes
3: *
4: * Code to acces the basic volume information of a HFS+ volume.
5: *
6: * Copyright (C) 2000 Klaus Halfmann <[email protected]>
7: * Original work by 1996-1998 Robert Leslie <[email protected]>
8: * other work 2000 from Brad Boyer ([email protected])
9: *
10: * This program is free software; you can redistribute it and/or modify
11: * it under the terms of the GNU General Public License as published by
12: * the Free Software Foundation; either version 2 of the License, or
13: * (at your option) any later version.
14: *
15: * This program is distributed in the hope that it will be useful,
16: * but WITHOUT ANY WARRANTY; without even the implied warranty of
17: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18: * GNU General Public License for more details.
19: *
20: * You should have received a copy of the GNU General Public License
21: * along with this program; if not, write to the Free Software
22: * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23: * MA 02110-1301, USA.
24: *
25: * $Id: volume.c,v 1.21 2000/10/25 05:43:04 hasi Exp $
26: */
27:
28: #include "config.h"
29: #include "libhfsp.h"
30: #include "volume.h"
31: #include "record.h"
32: #include "btree.h"
33: #include "blockiter.h"
34: #include "os.h"
35: #include "swab.h"
36: #include "hfstime.h"
37:
38:
39: /* Fill a given buffer with the given block in volume.
40: */
41: int
42: volume_readinbuf(volume * vol,void* buf, long block)
43: {
44: UInt16 blksize_bits;
45: ASSERT( block < vol->maxblocks);
46:
47: blksize_bits = vol->blksize_bits;
48: block += vol->startblock;
49: if( os_seek(vol->os_fd, block, blksize_bits) == block)
50: if( 1 == os_read(vol->os_fd, buf, 1, blksize_bits))
51: return 0;
52: return -1;
53: }
54:
55: /* read multiple blocks into given memory.
56: *
57: * returns given pinter or NULL on failure.
58: */
59: void*
60: volume_readfromfork(volume* vol, void* buf,
61: hfsp_fork_raw* f, UInt32 block,
62: UInt32 count, UInt8 forktype, UInt32 fileId)
63: {
64: blockiter iter;
65: char *cbuf = buf;
66:
67: blockiter_init(&iter, vol, f, forktype, fileId);
68: if( blockiter_skip(&iter, block))
69: return NULL;
70:
71: while( count > 0) {
72: --count;
73: if( volume_readinbuf(vol, cbuf, blockiter_curr(&iter)))
74: return NULL;
75: cbuf += vol->blksize;
76: if( count > 0 && blockiter_next(&iter))
77: return NULL;
78: }
79: return buf;
80: }
81:
82:
83: /* Read a raw hfsp_extent_rec from memory.
84: *
85: * return pointer right after the structure.
86: */
87: void*
88: volume_readextent(void *p, hfsp_extent_rec er)
89: {
90: int i;
91: hfsp_extent *e;
92:
93: for( i=0; i < 8; i++) {
94: e = &er[i];
95: e->start_block = bswabU32_inc(p);
96: e->block_count = bswabU32_inc(p);
97: }
98: return p;
99: }
100:
101: /* Read a raw hfsp_fork from memory.
102: *
103: * return pointer right after the structure.
104: */
105: void*
106: volume_readfork(void *p, hfsp_fork_raw* f)
107: {
108: f->total_size = bswabU64_inc(p);
109: f->clump_size = bswabU32_inc(p);
110: f->total_blocks = bswabU32_inc(p);
111:
112: return volume_readextent(p, f->extents);
113: }
114:
115: /* Read the volume from the given buffer and swap the bytes.
116: *
117: * ToDo: add more consitency checks.
118: */
119: static int
120: volume_readbuf(hfsp_vh* vh, char * p)
121: {
122: if( (vh->signature = bswabU16_inc(p)) != HFSP_VOLHEAD_SIG)
123: HFSP_ERROR(-1, "This is not a HFS+ volume");
124:
125: vh->version = bswabU16_inc(p);
126: vh->attributes = bswabU32_inc(p);
127: vh->last_mount_vers = bswabU32_inc(p);
128: vh->reserved = bswabU32_inc(p);
129: vh->create_date = bswabU32_inc(p);
130: vh->modify_date = bswabU32_inc(p);
131: vh->backup_date = bswabU32_inc(p);
132: vh->checked_date = bswabU32_inc(p);
133: vh->file_count = bswabU32_inc(p);
134: vh->folder_count = bswabU32_inc(p);
135: vh->blocksize = bswabU32_inc(p);
136: vh->total_blocks = bswabU32_inc(p);
137: vh->free_blocks = bswabU32_inc(p);
138: vh->next_alloc = bswabU32_inc(p);
139: vh->rsrc_clump_sz = bswabU32_inc(p);
140: vh->data_clump_sz = bswabU32_inc(p);
141: vh->next_cnid = bswabU32_inc(p);
142: vh->write_count = bswabU32_inc(p);
143: vh->encodings_bmp = bswabU64_inc(p);
144: memcpy(vh->finder_info, p, 32);
145: p += 32; // So finderinfo must be swapped later, ***
146: p = volume_readfork(p, &vh->alloc_file );
147: p = volume_readfork(p, &vh->ext_file );
148: p = volume_readfork(p, &vh->cat_file );
149: p = volume_readfork(p, &vh->attr_file );
150: volume_readfork(p, &vh->start_file );
151: return 0;
152: fail:
153: return -1;
154: }
155:
156: /* Read the volume from the given block */
157: static int
158: volume_read(volume * vol, hfsp_vh* vh, UInt32 block)
159: {
160: char buf[vol->blksize];
161:
162: if( volume_readinbuf(vol, buf, block))
163: return -1;
164: return volume_readbuf(vh, buf);
165: }
166:
167: /* Find out wether the volume is wrapped and unwrap it eventually */
168: static int
169: volume_read_wrapper(volume * vol, hfsp_vh* vh)
170: {
171: UInt16 signature;
172: char buf[vol->blksize];
173: char *p = buf;
174:
175: if( volume_readinbuf(vol, buf, 2) ) // Wrapper or volume header starts here
176: return -1;
177:
178: signature = bswabU16_inc(p);
179: if( signature == HFS_VOLHEAD_SIG) { /* Wrapper */
180: UInt32 drAlBlkSiz; /* size (in bytes) of allocation blocks */
181: UInt32 sect_per_block; /* how may block build an hfs sector */
182: UInt16 drAlBlSt; /* first allocation block in volume */
183: UInt16 embeds, embedl; /* Start/lenght of embedded area in blocks */
184:
185: p += 0x12; /* skip unneded HFS vol fields */
186: drAlBlkSiz = bswabU32_inc(p); /* offset 0x14 */
187: p += 0x4; /* skip unneded HFS vol fields */
188: drAlBlSt = bswabU16_inc(p); /* offset 0x1C */
189:
190: p += 0x5E; /* skip unneded HFS vol fields */
191: signature = bswabU16_inc(p); /* offset 0x7C, drEmbedSigWord */
192: if( signature != HFSP_VOLHEAD_SIG)
193: HFSP_ERROR(-1, "This looks like a normal HFS volume");
194: embeds = bswabU16_inc(p);
195: embedl = bswabU16_inc(p);
196: sect_per_block = (drAlBlkSiz / HFSP_BLOCKSZ);
197: // end is absolute (not relative to HFS+ start)
198: vol->maxblocks = embedl * sect_per_block;
199: vol->startblock = drAlBlSt + embeds * sect_per_block;
200: /* Now we can try to read the embedded HFS+ volume header */
201: return volume_read(vol,vh,2);
202: }
203: else if( signature == HFSP_VOLHEAD_SIG) { /* Native HFS+ volume */
204: p = buf; // Restore to begin of block
205: return volume_readbuf(vh, p);
206: } else
207: HFSP_ERROR(-1, "Neither Wrapper nor native HFS+ volume header found");
208: fail:
209: return -1;
210: }
211:
212:
213: /* Open the device, read and verify the volume header
214: (and its backup) */
215: int
216: volume_open( volume* vol, int os_fd )
217: {
218: hfsp_vh backup; /* backup volume found at second to last block */
219: long sect_per_block;
220: int shift;
221:
222: vol->blksize_bits = HFSP_BLOCKSZ_BITS;
223: vol->blksize = HFSP_BLOCKSZ;
224: vol->startblock = 0;
225: vol->maxblocks = 3;
226: /* this should be enough until we find the volume descriptor */
227: vol->extents = NULL; /* Thanks to Jeremias Sauceda */
228:
229: btree_reset(&vol->catalog);
230: vol->os_fd = os_fd;
231:
232: // vol->maxblocks = os_seek(vol->os_fd, -1, HFSP_BLOCKSZ_BITS);
233: // This wont work for /dev/... but we do not really need it
234:
235: if( volume_read_wrapper(vol, &vol->vol))
236: return -1;
237: if( volume_read(vol, &backup, vol->maxblocks - 2))
238: return -1;
239:
240: /* Now switch blksize from HFSP_BLOCKSZ (512) to value given in header
241: and adjust depend values accordingly, after that a block always
242: means a HFS+ allocation size */
243:
244: /* Usually 4096 / 512 == 8 */
245: sect_per_block = vol->vol.blocksize / HFSP_BLOCKSZ;
246: shift = 0;
247: if( sect_per_block > 1) {
248: shift = 1;
249: while( sect_per_block > 2) {
250: sect_per_block >>=1;
251: shift++;
252: } /* shift = 3 */
253: }
254: vol -> blksize_bits += shift;
255: vol -> blksize = 1 << vol->blksize_bits;
256: vol -> startblock >>= shift;
257: vol -> maxblocks = vol->vol.total_blocks; /* cant calculate via shift ? */
258:
259: if( btree_init_cat(&vol->catalog, vol, &vol->vol.cat_file))
260: return -1;
261:
262: return 0;
263: }
264:
265: /* Write back all data eventually cached and close the device */
266: int
267: volume_close(volume* vol)
268: {
269: btree_close(&vol->catalog);
270: if( vol->extents) {
271: btree_close(vol->extents);
272: FREE(vol->extents);
273: }
274: return 0;
275: }
276:
277: /* internal fucntion used to create the extents btree,
278: is called by inline function when needed */
279: void
280: volume_create_extents_tree(volume* vol)
281: {
282: btree* result = (btree*) ALLOC(btree*, sizeof(btree));
283: if( !result)
284: HFSP_ERROR(ENOMEM, "No memory for extents btree");
285: if( !btree_init_extent(result, vol, &vol->vol.ext_file)) {
286: vol->extents = result;
287: return;
288: }
289: fail:
290: vol->extents = NULL;
291: }
292:
293: /* Determine whether the volume is a HFS-plus volume */
294: int
295: volume_probe(int fd, long long offset)
296: {
297: UInt16 *vol;
298: int ret = 0;
299:
300: vol = (UInt16 *)malloc(2 * 1 << HFSP_BLOCKSZ_BITS);
301: os_seek_offset( fd, 2 * (1 << HFSP_BLOCKSZ_BITS) + offset );
302: os_read(fd, vol, 2, HFSP_BLOCKSZ_BITS);
303:
304: if (__be16_to_cpu(vol[0]) == HFS_VOLHEAD_SIG &&
305: __be16_to_cpu(vol[0x7c]) == HFSP_VOLHEAD_SIG) {
306: ret = -1;
307: } else if (__be16_to_cpu(vol[0]) == HFSP_VOLHEAD_SIG) {
308: ret = -1;
309: }
310:
311: free(vol);
312: return ret;
313: }
314:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.