![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hfs_fs.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 / hfs|
Return to hfs_fs.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / hfs |
1.1 root 1: /*
2: * Creation Date: <2001/05/06 22:47:23 samuel>
3: * Time-stamp: <2004/01/12 10:24:35 samuel>
4: *
5: * /packages/hfs-files
6: *
7: * HFS world interface
8: *
9: * Copyright (C) 2001-2004 Samuel Rydh ([email protected])
10: * Copyright (C) 2010 Mark Cave-Ayland ([email protected])
11: *
12: * This program is free software; you can redistribute it and/or
13: * modify it under the terms of the GNU General Public License
14: * as published by the Free Software Foundation
15: *
16: */
17:
18: #include "config.h"
19: #include "libopenbios/bindings.h"
20: #include "fs/fs.h"
21: #include "libc/vsprintf.h"
22: #include "libc/diskio.h"
23: #include "libhfs.h"
24:
25: #define MAC_OS_ROM_CREATOR 0x63687270 /* 'chrp' */
26: #define MAC_OS_ROM_TYPE 0x74627869 /* 'tbxi' */
27: #define MAC_OS_ROM_NAME "Mac OS ROM"
28:
29: #define FINDER_TYPE 0x464E4452 /* 'FNDR' */
30: #define FINDER_CREATOR 0x4D414353 /* 'MACS' */
31: #define SYSTEM_TYPE 0x7A737973 /* 'zsys' */
32: #define SYSTEM_CREATOR 0x4D414353 /* 'MACS' */
33:
34: #define VOLNAME_SIZE 64
35:
36: extern void hfs_init( void );
37:
38: typedef struct {
39: enum { FILE, DIR } type;
40: union {
41: hfsdir *dir;
42: hfsfile *file;
43: };
44: } hfscommon;
45:
46: typedef struct {
47: hfsvol *vol;
48: hfscommon *common;
49: } hfs_info_t;
50:
51: DECLARE_NODE( hfs, 0, sizeof(hfs_info_t), "+/packages/hfs-files" );
52:
53: /************************************************************************/
54: /* Search Functions */
55: /************************************************************************/
56:
57: static int
58: _find_file( hfsvol *vol, const char *path, unsigned long type, unsigned long creator )
59: {
60: hfsdirent ent;
61: hfsdir *dir;
62: int ret=1;
63:
64: if( !(dir=hfs_opendir(vol, path)) )
65: return 1;
66:
67: while( ret && !hfs_readdir(dir, &ent) ) {
68: if( ent.flags & HFS_ISDIR )
69: continue;
70: ret = !(*(unsigned long*)ent.u.file.type == type && *(unsigned long*)ent.u.file.creator == creator );
71: }
72:
73: hfs_closedir( dir );
74: return ret;
75: }
76:
77:
78: /* ret: 0=success, 1=not_found, 2=not_a_dir */
79: static int
80: _search( hfsvol *vol, const char *path, const char *sname, hfsfile **ret_fd )
81: {
82: hfsdir *dir;
83: hfsdirent ent;
84: int topdir=0, status = 1;
85: char *p, buf[256];
86:
87: strncpy( buf, path, sizeof(buf) );
88: if( buf[strlen(buf)-1] != ':' )
89: strncat( buf, ":", sizeof(buf) );
90: buf[sizeof(buf)-1] = 0;
91: p = buf + strlen( buf );
92:
93: if( !(dir=hfs_opendir(vol, path)) )
94: return 2;
95:
96: /* printk("DIRECTORY: %s\n", path ); */
97:
98: while( status && !hfs_readdir(dir, &ent) ) {
99: unsigned long type, creator;
100:
101: *p = 0;
102: topdir = 0;
103:
104: strncat( buf, ent.name, sizeof(buf) );
105: if( (status=_search(vol, buf, sname, ret_fd)) != 2 )
106: continue;
107: topdir = 1;
108:
109: /* name search? */
110: if( sname ) {
111: status = strcasecmp( ent.name, sname );
112: continue;
113: }
114:
115: type = *(unsigned long*)ent.u.file.type;
116: creator = *(unsigned long*)ent.u.file.creator;
117:
118: /* look for Mac OS ROM, System and Finder in the same directory */
119: if( type == MAC_OS_ROM_TYPE && creator == MAC_OS_ROM_CREATOR ) {
120: if( strcasecmp(ent.name, MAC_OS_ROM_NAME) )
121: continue;
122:
123: status = _find_file( vol, path, FINDER_TYPE, FINDER_CREATOR )
124: || _find_file( vol, path, SYSTEM_TYPE, SYSTEM_CREATOR );
125: }
126: }
127: if( !status && topdir && ret_fd && !(*ret_fd=hfs_open(vol, buf)) ) {
128: printk("Unexpected error: failed to open matched ROM\n");
129: status = 1;
130: }
131:
132: hfs_closedir( dir );
133: return status;
134: }
135:
136: static hfsfile *
137: _do_search( hfs_info_t *mi, const char *sname )
138: {
139: hfsvol *vol = hfs_getvol( NULL );
140:
141: mi->common->type = FILE;
142: (void)_search( vol, ":", sname, &mi->common->file );
143:
144: return mi->common->file;
145: }
146:
147:
148: static const int days_month[12] =
149: { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
150: static const int days_month_leap[12] =
151: { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
152:
153: static inline int is_leap(int year)
154: {
155: return ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
156: }
157:
158: static void
159: print_date(time_t sec)
160: {
161: unsigned int second, minute, hour, month, day, year;
162: int current;
163: const int *days;
164:
165: second = sec % 60;
166: sec /= 60;
167:
168: minute = sec % 60;
169: sec /= 60;
170:
171: hour = sec % 24;
172: sec /= 24;
173:
174: year = sec * 100 / 36525;
175: sec -= year * 36525 / 100;
176: year += 1970;
177:
178: days = is_leap(year) ? days_month_leap : days_month;
179:
180: current = 0;
181: month = 0;
182: while (month < 12) {
183: if (sec <= current + days[month]) {
184: break;
185: }
186: current += days[month];
187: month++;
188: }
189: month++;
190:
191: day = sec - current + 1;
192:
193: forth_printf("%d-%02d-%02d %02d:%02d:%02d ",
194: year, month, day, hour, minute, second);
195: }
196:
197: /*
198: static void
199: dir_fs( file_desc_t *fd )
200: {
201: hfscommon *common = (hfscommon*)fd;
202: hfsdirent ent;
203:
204: if (common->type != DIR)
205: return;
206:
207: forth_printf("\n");
208: while( !hfs_readdir(common->dir, &ent) ) {
209: forth_printf("% 10d ", ent.u.file.dsize);
210: print_date(ent.mddate);
211: if( ent.flags & HFS_ISDIR )
212: forth_printf("%s\\\n", ent.name);
213: else
214: forth_printf("%s\n", ent.name);
215: }
216: }
217: */
218:
219: /************************************************************************/
220: /* Standard package methods */
221: /************************************************************************/
222:
223: /* ( -- success? ) */
224: static void
225: hfs_files_open( hfs_info_t *mi )
226: {
227: int fd;
228: char *path = my_args_copy();
229:
230: const char *s;
231: char buf[256];
232:
233: fd = open_ih( my_parent() );
234: if ( fd == -1 ) {
235: free( path );
236: RET( 0 );
237: }
238:
239: mi->vol = hfs_mount(fd, 0);
240: if (!mi->vol) {
241: RET( 0 );
242: }
243:
244: if( !strncmp(path, "\\\\", 2) ) {
245: hfsvolent ent;
246:
247: /* \\ is an alias for the (blessed) system folder */
248: if( hfs_vstat(mi->vol, &ent) < 0 || hfs_setcwd(mi->vol, ent.blessed) ) {
249: free(path);
250: RET( -1 );
251: }
252: path += 2;
253: } else {
254: hfs_chdir( mi->vol, ":" );
255: }
256:
257: mi->common = malloc(sizeof(hfscommon));
258: if (!mi->common) {
259: free(path);
260: RET( 0 );
261: }
262:
263: if (strcmp(path, "\\") == 0) {
264: /* root directory is in fact ":" */
265: mi->common->dir = hfs_opendir(mi->vol, ":");
266: mi->common->type = DIR;
267: free(path);
268: RET( -1 );
269: }
270:
271: if (path[strlen(path) - 1] == '\\') {
272: path[strlen(path) - 1] = 0;
273: }
274:
275: for( path-- ;; ) {
276: int n;
277:
278: s = ++path;
279: path = strchr(s, '\\');
280: if( !path || !path[1])
281: break;
282: n = MIN( sizeof(buf)-1, (path-s) );
283: if( !n )
284: continue;
285:
286: strncpy( buf, s, n );
287: buf[n] = 0;
288: if( hfs_chdir(mi->vol, buf) ) {
289: free(mi->common);
290: free(path);
291: RET( 0 );
292: }
293: }
294:
295: /* support the ':filetype' syntax */
296: if( *s == ':' ) {
297: unsigned long id, oldid = hfs_getcwd(mi->vol);
298: hfsdirent ent;
299: hfsdir *dir;
300:
301: s++;
302: id = oldid;
303: hfs_dirinfo( mi->vol, &id, buf );
304: hfs_setcwd( mi->vol, id );
305:
306: if( !(dir=hfs_opendir(mi->vol, buf)) ) {
307: free(mi->common);
308: free(path);
309: RET( 0 );
310: }
311: hfs_setcwd( mi->vol, oldid );
312:
313: while( !hfs_readdir(dir, &ent) ) {
314: if( ent.flags & HFS_ISDIR )
315: continue;
316: if( !strncmp(s, ent.u.file.type, 4) ) {
317: mi->common->type = FILE;
318: mi->common->file = hfs_open( mi->vol, ent.name );
319: break;
320: }
321: }
322: hfs_closedir( dir );
323: free(path);
324: RET( -1 );
325: }
326:
327: mi->common->dir = hfs_opendir(mi->vol, s);
328: if (!mi->common->dir) {
329: mi->common->file = hfs_open( mi->vol, s );
330: if (mi->common->file == NULL) {
331: free(mi->common);
332: free(path);
333: RET( 0 );
334: }
335: mi->common->type = FILE;
336: free(path);
337: RET( -1 );
338: }
339: mi->common->type = DIR;
340: free(path);
341:
342: RET( -1 );
343: }
344:
345: /* ( -- ) */
346: static void
347: hfs_files_close( hfs_info_t *mi )
348: {
349: hfscommon *common = mi->common;
350: if (common->type == FILE)
351: hfs_close( common->file );
352: else if (common->type == DIR)
353: hfs_closedir( common->dir );
354: free(common);
355: }
356:
357: /* ( buf len -- actlen ) */
358: static void
359: hfs_files_read( hfs_info_t *mi )
360: {
361: int count = POP();
362: char *buf = (char *)cell2pointer(POP());
363:
364: hfscommon *common = mi->common;
365: if (common->type != FILE)
366: RET( -1 );
367:
368: RET ( hfs_read( common->file, buf, count ) );
369: }
370:
371: /* ( pos.d -- status ) */
372: static void
373: hfs_files_seek( hfs_info_t *mi )
374: {
375: long long pos = DPOP();
376: int offs = (int)pos;
377: int whence = SEEK_SET;
378: int ret;
379: hfscommon *common = mi->common;
380:
381: if (common->type != FILE)
382: RET( -1 );
383:
384: switch( whence ) {
385: case SEEK_END:
386: whence = HFS_SEEK_END;
387: break;
388: default:
389: case SEEK_SET:
390: whence = HFS_SEEK_SET;
391: break;
392: }
393:
394: ret = hfs_seek( common->file, offs, whence );
395: if (ret != -1)
396: RET( 0 );
397: else
398: RET( -1 );
399: }
400:
401: /* ( addr -- size ) */
402: static void
403: hfs_files_load( hfs_info_t *mi )
404: {
405: char *buf = (char *)cell2pointer(POP());
406: int count;
407:
408: hfscommon *common = mi->common;
409: if (common->type != FILE)
410: RET( -1 );
411:
412: /* Seek to the end in order to get the file size */
413: hfs_seek(common->file, 0, HFS_SEEK_END);
414: count = common->file->pos;
415: hfs_seek(common->file, 0, HFS_SEEK_SET);
416:
417: RET ( hfs_read( common->file, buf, count ) );
418: }
419:
420: /* ( -- success? ) */
421: static void
422: hfs_files_open_nwrom( hfs_info_t *mi )
423: {
424: /* Switch to an existing ROM image file on the fs! */
425: if ( _do_search( mi, NULL ) )
426: RET( -1 );
427:
428: RET( 0 );
429: }
430:
431: /* ( -- cstr ) */
432: static void
433: hfs_files_get_path( hfs_info_t *mi )
434: {
435: char buf[256], buf2[256];
436: hfscommon *common = mi->common;
437: hfsvol *vol = hfs_getvol( NULL );
438: hfsdirent ent;
439: int start, ns;
440: unsigned long id;
441:
442: if (common->type != FILE)
443: RET( 0 );
444:
445: hfs_fstat( common->file, &ent );
446: start = sizeof(buf) - strlen(ent.name) - 1;
447: if( start <= 0 )
448: RET ( 0 );
449: strcpy( buf+start, ent.name );
450: buf[--start] = '\\';
451:
452: ns = start;
453: for( id=ent.parid ; !hfs_dirinfo(vol, &id, buf2) ; ) {
454: start = ns;
455: ns -= strlen(buf2);
456: if( ns <= 0 )
457: RET( 0 );
458: strcpy( buf+ns, buf2 );
459: buf[--ns] = buf[start] = '\\';
460: }
461: if( strlen(buf) >= sizeof(buf) )
462: RET( 0 );
463:
464: RET( pointer2cell(strdup(buf+start)) );
465: }
466:
467: /* ( -- cstr ) */
468: static void
469: hfs_files_get_fstype( hfs_info_t *mi )
470: {
471: PUSH( pointer2cell(strdup("HFS")) );
472: }
473:
474: /* ( -- cstr|0 ) */
475: static void
476: hfs_files_volume_name( hfs_info_t *mi )
477: {
478: int fd;
479: char *volname = malloc(VOLNAME_SIZE);
480:
481: fd = open_ih(my_self());
482: if (fd >= 0) {
483: get_hfs_vol_name(fd, volname, VOLNAME_SIZE);
484: close_io(fd);
485: } else {
486: volname[0] = '\0';
487: }
488:
489: PUSH(pointer2cell(volname));
490: }
491:
492: /* static method, ( pathstr len ihandle -- ) */
493: static void
494: hfs_files_dir( hfs_info_t *dummy )
495: {
496: hfsvol *volume;
497: hfscommon *common;
498: hfsdirent ent;
499: int i;
500: int fd;
501:
502: ihandle_t ih = POP();
503: char *path = pop_fstr_copy();
504:
505: fd = open_ih( ih );
506: if ( fd == -1 ) {
507: free( path );
508: return;
509: }
510:
511: volume = hfs_mount(fd, 0);
512: if (!volume) {
513: return;
514: }
515:
516: common = malloc(sizeof(hfscommon));
517:
518: /* HFS paths are colon separated, not backslash separated */
519: for (i = 0; i < strlen(path); i++)
520: if (path[i] == '\\')
521: path[i] = ':';
522:
523: common->dir = hfs_opendir(volume, path);
524:
525: forth_printf("\n");
526: while( !hfs_readdir(common->dir, &ent) ) {
527: forth_printf("% 10ld ", ent.u.file.dsize);
528: print_date(ent.mddate);
529: if( ent.flags & HFS_ISDIR )
530: forth_printf("%s\\\n", ent.name);
531: else
532: forth_printf("%s\n", ent.name);
533: }
534:
535: hfs_closedir( common->dir );
536: hfs_umount( volume );
537:
538: close_io( fd );
539:
540: free( common );
541: free( path );
542: }
543:
544: /* static method, ( pos.d ih -- flag? ) */
545: static void
546: hfs_files_probe( hfs_info_t *dummy )
547: {
548: ihandle_t ih = POP_ih();
549: long long offs = DPOP();
550: int fd, ret = 0;
551:
552: fd = open_ih(ih);
553: if (fd >= 0) {
554: if (hfs_probe(fd, offs)) {
555: ret = -1;
556: }
557: close_io(fd);
558: } else {
559: ret = -1;
560: }
561:
562: RET (ret);
563: }
564:
565: static void
566: hfs_initializer( hfs_info_t *dummy )
567: {
568: fword("register-fs-package");
569: }
570:
571: NODE_METHODS( hfs ) = {
572: { "probe", hfs_files_probe },
573: { "open", hfs_files_open },
574: { "close", hfs_files_close },
575: { "read", hfs_files_read },
576: { "seek", hfs_files_seek },
577: { "load", hfs_files_load },
578: { "dir", hfs_files_dir },
579:
580: /* special */
581: { "open-nwrom", hfs_files_open_nwrom },
582: { "get-path", hfs_files_get_path },
583: { "get-fstype", hfs_files_get_fstype },
584: { "volume-name", hfs_files_volume_name },
585:
586: { NULL, hfs_initializer },
587: };
588:
589: void
590: hfs_init( void )
591: {
592: REGISTER_NODE( hfs );
593: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.