Return to hfs.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / hfs

Annotation of qemu/roms/openbios/fs/hfs/hfs.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * libhfs - library for reading and writing Macintosh HFS volumes
        !             3:  * Copyright (C) 1996-1998 Robert Leslie
        !             4:  *
        !             5:  * This program is free software; you can redistribute it and/or modify
        !             6:  * it under the terms of the GNU General Public License as published by
        !             7:  * the Free Software Foundation; either version 2 of the License, or
        !             8:  * (at your option) any later version.
        !             9:  *
        !            10:  * This program is distributed in the hope that it will be useful,
        !            11:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            12:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            13:  * GNU General Public License for more details.
        !            14:  *
        !            15:  * You should have received a copy of the GNU General Public License
        !            16:  * along with this program; if not, write to the Free Software
        !            17:  * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
        !            18:  * MA 02110-1301, USA.
        !            19:  *
        !            20:  * $Id: hfs.c,v 1.15 1998/11/02 22:09:00 rob Exp $
        !            21:  */
        !            22: 
        !            23: #include "config.h"
        !            24: #include "libhfs.h"
        !            25: #include "data.h"
        !            26: #include "block.h"
        !            27: #include "medium.h"
        !            28: #include "file.h"
        !            29: #include "btree.h"
        !            30: #include "node.h"
        !            31: #include "record.h"
        !            32: #include "volume.h"
        !            33: 
        !            34: const char *hfs_error = "no error";    /* static error string */
        !            35: 
        !            36: hfsvol *hfs_mounts;                    /* linked list of mounted volumes */
        !            37: 
        !            38: static
        !            39: hfsvol *curvol;                                /* current volume */
        !            40: 
        !            41: 
        !            42: /*
        !            43:  * NAME:       getvol()
        !            44:  * DESCRIPTION:        validate a volume reference
        !            45:  */
        !            46: static
        !            47: int getvol(hfsvol **vol)
        !            48: {
        !            49:   if (*vol == NULL)
        !            50:     {
        !            51:       if (curvol == NULL)
        !            52:        ERROR(EINVAL, "no volume is current");
        !            53: 
        !            54:       *vol = curvol;
        !            55:     }
        !            56: 
        !            57:   return 0;
        !            58: 
        !            59: fail:
        !            60:   return -1;
        !            61: }
        !            62: 
        !            63: /* High-Level Volume Routines ============================================== */
        !            64: 
        !            65: /*
        !            66:  * NAME:       hfs->mount()
        !            67:  * DESCRIPTION:        open an HFS volume; return volume descriptor or 0 (error)
        !            68:  */
        !            69: hfsvol *hfs_mount( int os_fd, int pnum)
        !            70: {
        !            71:   hfsvol *vol, *check;
        !            72:   int mode = HFS_MODE_RDONLY;
        !            73: 
        !            74:   /* see if the volume is already mounted */
        !            75:   for (check = hfs_mounts; check; check = check->next)
        !            76:     {
        !            77:       if (check->pnum == pnum && v_same(check, os_fd) == 1)
        !            78:        {
        !            79:            vol = check;
        !            80:            goto done;
        !            81:        }
        !            82:     }
        !            83: 
        !            84:   vol = ALLOC(hfsvol, 1);
        !            85:   if (vol == NULL)
        !            86:     ERROR(ENOMEM, NULL);
        !            87: 
        !            88:   v_init(vol, mode);
        !            89: 
        !            90:   vol->flags |= HFS_VOL_READONLY;
        !            91:   if( v_open(vol, os_fd) == -1 )
        !            92:          goto fail;
        !            93: 
        !            94:   /* mount the volume */
        !            95: 
        !            96:   if (v_geometry(vol, pnum) == -1 ||
        !            97:       v_mount(vol) == -1)
        !            98:     goto fail;
        !            99: 
        !           100:   /* add to linked list of volumes */
        !           101: 
        !           102:   vol->prev = NULL;
        !           103:   vol->next = hfs_mounts;
        !           104: 
        !           105:   if (hfs_mounts)
        !           106:     hfs_mounts->prev = vol;
        !           107: 
        !           108:   hfs_mounts = vol;
        !           109: 
        !           110: done:
        !           111:   ++vol->refs;
        !           112:   curvol = vol;
        !           113: 
        !           114:   return vol;
        !           115: 
        !           116: fail:
        !           117:   if (vol)
        !           118:     {
        !           119:       v_close(vol);
        !           120:       FREE(vol);
        !           121:     }
        !           122: 
        !           123:   return NULL;
        !           124: }
        !           125: 
        !           126: 
        !           127: /*
        !           128:  * NAME:       hfs->umount()
        !           129:  * DESCRIPTION:        close an HFS volume
        !           130:  */
        !           131: int hfs_umount(hfsvol *vol)
        !           132: {
        !           133:   int result = 0;
        !           134: 
        !           135:   if (getvol(&vol) == -1)
        !           136:     goto fail;
        !           137: 
        !           138:   if (--vol->refs)
        !           139:     {
        !           140:       goto done;
        !           141:     }
        !           142: 
        !           143:   /* close all open files and directories */
        !           144: 
        !           145:   while (vol->files)
        !           146:     {
        !           147:       if (hfs_close(vol->files) == -1)
        !           148:        result = -1;
        !           149:     }
        !           150: 
        !           151:   while (vol->dirs)
        !           152:     {
        !           153:       if (hfs_closedir(vol->dirs) == -1)
        !           154:        result = -1;
        !           155:     }
        !           156: 
        !           157:   /* close medium */
        !           158: 
        !           159:   if (v_close(vol) == -1)
        !           160:     result = -1;
        !           161: 
        !           162:   /* remove from linked list of volumes */
        !           163: 
        !           164:   if (vol->prev)
        !           165:     vol->prev->next = vol->next;
        !           166:   if (vol->next)
        !           167:     vol->next->prev = vol->prev;
        !           168: 
        !           169:   if (vol == hfs_mounts)
        !           170:     hfs_mounts = vol->next;
        !           171:   if (vol == curvol)
        !           172:     curvol = NULL;
        !           173: 
        !           174:   FREE(vol);
        !           175: 
        !           176: done:
        !           177:   return result;
        !           178: 
        !           179: fail:
        !           180:   return -1;
        !           181: }
        !           182: 
        !           183: /*
        !           184:  * NAME:       hfs->umountall()
        !           185:  * DESCRIPTION:        unmount all mounted volumes
        !           186:  */
        !           187: void hfs_umountall(void)
        !           188: {
        !           189:   while (hfs_mounts)
        !           190:     hfs_umount(hfs_mounts);
        !           191: }
        !           192: 
        !           193: /*
        !           194:  * NAME:       hfs->getvol()
        !           195:  * DESCRIPTION:        return a pointer to a mounted volume
        !           196:  */
        !           197: hfsvol *hfs_getvol(const char *name)
        !           198: {
        !           199:   hfsvol *vol;
        !           200: 
        !           201:   if (name == NULL)
        !           202:     return curvol;
        !           203: 
        !           204:   for (vol = hfs_mounts; vol; vol = vol->next)
        !           205:     {
        !           206:       if (d_relstring(name, vol->mdb.drVN) == 0)
        !           207:        return vol;
        !           208:     }
        !           209: 
        !           210:   return NULL;
        !           211: }
        !           212: 
        !           213: /*
        !           214:  * NAME:       hfs->setvol()
        !           215:  * DESCRIPTION:        change the current volume
        !           216:  */
        !           217: void hfs_setvol(hfsvol *vol)
        !           218: {
        !           219:   curvol = vol;
        !           220: }
        !           221: 
        !           222: /*
        !           223:  * NAME:       hfs->vstat()
        !           224:  * DESCRIPTION:        return volume statistics
        !           225:  */
        !           226: int hfs_vstat(hfsvol *vol, hfsvolent *ent)
        !           227: {
        !           228:   if (getvol(&vol) == -1)
        !           229:     goto fail;
        !           230: 
        !           231:   strcpy(ent->name, vol->mdb.drVN);
        !           232: 
        !           233:   ent->flags     = (vol->flags & HFS_VOL_READONLY) ? HFS_ISLOCKED : 0;
        !           234: 
        !           235:   ent->totbytes  = vol->mdb.drNmAlBlks * vol->mdb.drAlBlkSiz;
        !           236:   ent->freebytes = vol->mdb.drFreeBks  * vol->mdb.drAlBlkSiz;
        !           237: 
        !           238:   ent->alblocksz = vol->mdb.drAlBlkSiz;
        !           239:   ent->clumpsz   = vol->mdb.drClpSiz;
        !           240: 
        !           241:   ent->numfiles  = vol->mdb.drFilCnt;
        !           242:   ent->numdirs   = vol->mdb.drDirCnt;
        !           243: 
        !           244:   ent->crdate    = d_ltime(vol->mdb.drCrDate);
        !           245:   ent->mddate    = d_ltime(vol->mdb.drLsMod);
        !           246:   ent->bkdate    = d_ltime(vol->mdb.drVolBkUp);
        !           247: 
        !           248:   ent->blessed   = vol->mdb.drFndrInfo[0];
        !           249: 
        !           250:   return 0;
        !           251: 
        !           252: fail:
        !           253:   return -1;
        !           254: }
        !           255: 
        !           256: 
        !           257: /* High-Level Directory Routines =========================================== */
        !           258: 
        !           259: /*
        !           260:  * NAME:       hfs->chdir()
        !           261:  * DESCRIPTION:        change current HFS directory
        !           262:  */
        !           263: int hfs_chdir(hfsvol *vol, const char *path)
        !           264: {
        !           265:   CatDataRec data;
        !           266: 
        !           267:   if (getvol(&vol) == -1 ||
        !           268:       v_resolve(&vol, path, &data, NULL, NULL, NULL) <= 0)
        !           269:     goto fail;
        !           270: 
        !           271:   if (data.cdrType != cdrDirRec)
        !           272:     ERROR(ENOTDIR, NULL);
        !           273: 
        !           274:   vol->cwd = data.u.dir.dirDirID;
        !           275: 
        !           276:   return 0;
        !           277: 
        !           278: fail:
        !           279:   return -1;
        !           280: }
        !           281: 
        !           282: /*
        !           283:  * NAME:       hfs->getcwd()
        !           284:  * DESCRIPTION:        return the current working directory ID
        !           285:  */
        !           286: unsigned long hfs_getcwd(hfsvol *vol)
        !           287: {
        !           288:   if (getvol(&vol) == -1)
        !           289:     return 0;
        !           290: 
        !           291:   return vol->cwd;
        !           292: }
        !           293: 
        !           294: /*
        !           295:  * NAME:       hfs->setcwd()
        !           296:  * DESCRIPTION:        set the current working directory ID
        !           297:  */
        !           298: int hfs_setcwd(hfsvol *vol, unsigned long id)
        !           299: {
        !           300:   if (getvol(&vol) == -1)
        !           301:     goto fail;
        !           302: 
        !           303:   if (id == vol->cwd)
        !           304:     goto done;
        !           305: 
        !           306:   /* make sure the directory exists */
        !           307: 
        !           308:   if (v_getdthread(vol, id, NULL, NULL) <= 0)
        !           309:     goto fail;
        !           310: 
        !           311:   vol->cwd = id;
        !           312: 
        !           313: done:
        !           314:   return 0;
        !           315: 
        !           316: fail:
        !           317:   return -1;
        !           318: }
        !           319: 
        !           320: /*
        !           321:  * NAME:       hfs->dirinfo()
        !           322:  * DESCRIPTION:        given a directory ID, return its (name and) parent ID
        !           323:  */
        !           324: int hfs_dirinfo(hfsvol *vol, unsigned long *id, char *name)
        !           325: {
        !           326:   CatDataRec thread;
        !           327: 
        !           328:   if (getvol(&vol) == -1 ||
        !           329:       v_getdthread(vol, *id, &thread, NULL) <= 0)
        !           330:     goto fail;
        !           331: 
        !           332:   *id = thread.u.dthd.thdParID;
        !           333: 
        !           334:   if (name)
        !           335:     strcpy(name, thread.u.dthd.thdCName);
        !           336: 
        !           337:   return 0;
        !           338: 
        !           339: fail:
        !           340:   return -1;
        !           341: }
        !           342: 
        !           343: /*
        !           344:  * NAME:       hfs->opendir()
        !           345:  * DESCRIPTION:        prepare to read the contents of a directory
        !           346:  */
        !           347: hfsdir *hfs_opendir(hfsvol *vol, const char *path)
        !           348: {
        !           349:   hfsdir *dir = NULL;
        !           350:   CatKeyRec key;
        !           351:   CatDataRec data;
        !           352:   byte pkey[HFS_CATKEYLEN];
        !           353: 
        !           354:   if (getvol(&vol) == -1)
        !           355:     goto fail;
        !           356: 
        !           357:   dir = ALLOC(hfsdir, 1);
        !           358:   if (dir == NULL)
        !           359:     ERROR(ENOMEM, NULL);
        !           360: 
        !           361:   dir->vol = vol;
        !           362: 
        !           363:   if (*path == 0)
        !           364:     {
        !           365:       /* meta-directory containing root dirs from all mounted volumes */
        !           366: 
        !           367:       dir->dirid = 0;
        !           368:       dir->vptr  = hfs_mounts;
        !           369:     }
        !           370:   else
        !           371:     {
        !           372:       if (v_resolve(&vol, path, &data, NULL, NULL, NULL) <= 0)
        !           373:        goto fail;
        !           374: 
        !           375:       if (data.cdrType != cdrDirRec)
        !           376:         ERROR(ENOTDIR, NULL);
        !           377: 
        !           378:       dir->dirid = data.u.dir.dirDirID;
        !           379:       dir->vptr  = NULL;
        !           380: 
        !           381:       r_makecatkey(&key, dir->dirid, "");
        !           382:       r_packcatkey(&key, pkey, NULL);
        !           383: 
        !           384:       if (bt_search(&vol->cat, pkey, &dir->n) <= 0)
        !           385:        goto fail;
        !           386:     }
        !           387: 
        !           388:   dir->prev = NULL;
        !           389:   dir->next = vol->dirs;
        !           390: 
        !           391:   if (vol->dirs)
        !           392:     vol->dirs->prev = dir;
        !           393: 
        !           394:   vol->dirs = dir;
        !           395: 
        !           396:   return dir;
        !           397: 
        !           398: fail:
        !           399:   FREE(dir);
        !           400:   return NULL;
        !           401: }
        !           402: 
        !           403: /*
        !           404:  * NAME:       hfs->readdir()
        !           405:  * DESCRIPTION:        return the next entry in the directory
        !           406:  */
        !           407: int hfs_readdir(hfsdir *dir, hfsdirent *ent)
        !           408: {
        !           409:   CatKeyRec key;
        !           410:   CatDataRec data;
        !           411:   const byte *ptr;
        !           412: 
        !           413:   if (dir->dirid == 0)
        !           414:     {
        !           415:       hfsvol *vol;
        !           416:       char cname[HFS_MAX_FLEN + 1];
        !           417: 
        !           418:       for (vol = hfs_mounts; vol; vol = vol->next)
        !           419:        {
        !           420:          if (vol == dir->vptr)
        !           421:            break;
        !           422:        }
        !           423: 
        !           424:       if (vol == NULL)
        !           425:        ERROR(ENOENT, "no more entries");
        !           426: 
        !           427:       if (v_getdthread(vol, HFS_CNID_ROOTDIR, &data, NULL) <= 0 ||
        !           428:          v_catsearch(vol, HFS_CNID_ROOTPAR, data.u.dthd.thdCName,
        !           429:                       &data, cname, NULL) <= 0)
        !           430:        goto fail;
        !           431: 
        !           432:       r_unpackdirent(HFS_CNID_ROOTPAR, cname, &data, ent);
        !           433: 
        !           434:       dir->vptr = vol->next;
        !           435: 
        !           436:       goto done;
        !           437:     }
        !           438: 
        !           439:   if (dir->n.rnum == -1)
        !           440:     ERROR(ENOENT, "no more entries");
        !           441: 
        !           442:   while (1)
        !           443:     {
        !           444:       ++dir->n.rnum;
        !           445: 
        !           446:       while (dir->n.rnum >= dir->n.nd.ndNRecs)
        !           447:        {
        !           448:          if (dir->n.nd.ndFLink == 0)
        !           449:            {
        !           450:              dir->n.rnum = -1;
        !           451:              ERROR(ENOENT, "no more entries");
        !           452:            }
        !           453: 
        !           454:          if (bt_getnode(&dir->n, dir->n.bt, dir->n.nd.ndFLink) == -1)
        !           455:            {
        !           456:              dir->n.rnum = -1;
        !           457:              goto fail;
        !           458:            }
        !           459: 
        !           460:          dir->n.rnum = 0;
        !           461:        }
        !           462: 
        !           463:       ptr = HFS_NODEREC(dir->n, dir->n.rnum);
        !           464: 
        !           465:       r_unpackcatkey(ptr, &key);
        !           466: 
        !           467:       if (key.ckrParID != dir->dirid)
        !           468:        {
        !           469:          dir->n.rnum = -1;
        !           470:          ERROR(ENOENT, "no more entries");
        !           471:        }
        !           472: 
        !           473:       r_unpackcatdata(HFS_RECDATA(ptr), &data);
        !           474: 
        !           475:       switch (data.cdrType)
        !           476:        {
        !           477:        case cdrDirRec:
        !           478:        case cdrFilRec:
        !           479:          r_unpackdirent(key.ckrParID, key.ckrCName, &data, ent);
        !           480:          goto done;
        !           481: 
        !           482:        case cdrThdRec:
        !           483:        case cdrFThdRec:
        !           484:          break;
        !           485: 
        !           486:        default:
        !           487:          dir->n.rnum = -1;
        !           488:          ERROR(EIO, "unexpected directory entry found");
        !           489:        }
        !           490:     }
        !           491: 
        !           492: done:
        !           493:   return 0;
        !           494: 
        !           495: fail:
        !           496:   return -1;
        !           497: }
        !           498: 
        !           499: /*
        !           500:  * NAME:       hfs->closedir()
        !           501:  * DESCRIPTION:        stop reading a directory
        !           502:  */
        !           503: int hfs_closedir(hfsdir *dir)
        !           504: {
        !           505:   hfsvol *vol = dir->vol;
        !           506: 
        !           507:   if (dir->prev)
        !           508:     dir->prev->next = dir->next;
        !           509:   if (dir->next)
        !           510:     dir->next->prev = dir->prev;
        !           511:   if (dir == vol->dirs)
        !           512:     vol->dirs = dir->next;
        !           513: 
        !           514:   FREE(dir);
        !           515: 
        !           516:   return 0;
        !           517: }
        !           518: 
        !           519: /* High-Level File Routines ================================================ */
        !           520: 
        !           521: /*
        !           522:  * NAME:       hfs->open()
        !           523:  * DESCRIPTION:        prepare a file for I/O
        !           524:  */
        !           525: hfsfile *hfs_open(hfsvol *vol, const char *path)
        !           526: {
        !           527:   hfsfile *file = NULL;
        !           528: 
        !           529:   if (getvol(&vol) == -1)
        !           530:     goto fail;
        !           531: 
        !           532:   file = ALLOC(hfsfile, 1);
        !           533:   if (file == NULL)
        !           534:     ERROR(ENOMEM, NULL);
        !           535: 
        !           536:   if (v_resolve(&vol, path, &file->cat, &file->parid, file->name, NULL) <= 0)
        !           537:     goto fail;
        !           538: 
        !           539:   if (file->cat.cdrType != cdrFilRec)
        !           540:     ERROR(EISDIR, NULL);
        !           541: 
        !           542:   /* package file handle for user */
        !           543: 
        !           544:   file->vol   = vol;
        !           545:   file->flags = 0;
        !           546: 
        !           547:   f_selectfork(file, fkData);
        !           548: 
        !           549:   file->prev = NULL;
        !           550:   file->next = vol->files;
        !           551: 
        !           552:   if (vol->files)
        !           553:     vol->files->prev = file;
        !           554: 
        !           555:   vol->files = file;
        !           556: 
        !           557:   return file;
        !           558: 
        !           559: fail:
        !           560:   FREE(file);
        !           561:   return NULL;
        !           562: }
        !           563: 
        !           564: /*
        !           565:  * NAME:       hfs->setfork()
        !           566:  * DESCRIPTION:        select file fork for I/O operations
        !           567:  */
        !           568: int hfs_setfork(hfsfile *file, int fork)
        !           569: {
        !           570:   int result = 0;
        !           571: 
        !           572:   f_selectfork(file, fork ? fkRsrc : fkData);
        !           573: 
        !           574:   return result;
        !           575: }
        !           576: 
        !           577: /*
        !           578:  * NAME:       hfs->getfork()
        !           579:  * DESCRIPTION:        return the current fork for I/O operations
        !           580:  */
        !           581: int hfs_getfork(hfsfile *file)
        !           582: {
        !           583:   return file->fork != fkData;
        !           584: }
        !           585: 
        !           586: /*
        !           587:  * NAME:       hfs->read()
        !           588:  * DESCRIPTION:        read from an open file
        !           589:  */
        !           590: unsigned long hfs_read(hfsfile *file, void *buf, unsigned long len)
        !           591: {
        !           592:   unsigned long *lglen, count;
        !           593:   byte *ptr = buf;
        !           594: 
        !           595:   f_getptrs(file, NULL, &lglen, NULL);
        !           596: 
        !           597:   if (file->pos + len > *lglen)
        !           598:     len = *lglen - file->pos;
        !           599: 
        !           600:   count = len;
        !           601:   while (count)
        !           602:     {
        !           603:       unsigned long bnum, offs, chunk;
        !           604: 
        !           605:       bnum  = file->pos >> HFS_BLOCKSZ_BITS;
        !           606:       offs  = file->pos & (HFS_BLOCKSZ - 1);
        !           607: 
        !           608:       chunk = HFS_BLOCKSZ - offs;
        !           609:       if (chunk > count)
        !           610:        chunk = count;
        !           611: 
        !           612:       if (offs == 0 && chunk == HFS_BLOCKSZ)
        !           613:        {
        !           614:          if (f_getblock(file, bnum, (block *) ptr) == -1)
        !           615:            goto fail;
        !           616:        }
        !           617:       else
        !           618:        {
        !           619:          block b;
        !           620: 
        !           621:          if (f_getblock(file, bnum, &b) == -1)
        !           622:            goto fail;
        !           623: 
        !           624:          memcpy(ptr, b + offs, chunk);
        !           625:        }
        !           626: 
        !           627:       ptr += chunk;
        !           628: 
        !           629:       file->pos += chunk;
        !           630:       count     -= chunk;
        !           631:     }
        !           632: 
        !           633:   return len;
        !           634: 
        !           635: fail:
        !           636:   return -1;
        !           637: }
        !           638: 
        !           639: /*
        !           640:  * NAME:       hfs->seek()
        !           641:  * DESCRIPTION:        change file seek pointer
        !           642:  */
        !           643: unsigned long hfs_seek(hfsfile *file, long offset, int from)
        !           644: {
        !           645:   unsigned long *lglen, newpos;
        !           646: 
        !           647:   f_getptrs(file, NULL, &lglen, NULL);
        !           648: 
        !           649:   switch (from)
        !           650:     {
        !           651:     case HFS_SEEK_SET:
        !           652:       newpos = (offset < 0) ? 0 : offset;
        !           653:       break;
        !           654: 
        !           655:     case HFS_SEEK_CUR:
        !           656:       if (offset < 0 && (unsigned long) -offset > file->pos)
        !           657:        newpos = 0;
        !           658:       else
        !           659:        newpos = file->pos + offset;
        !           660:       break;
        !           661: 
        !           662:     case HFS_SEEK_END:
        !           663:       if (offset < 0 && (unsigned long) -offset > *lglen)
        !           664:        newpos = 0;
        !           665:       else
        !           666:        newpos = *lglen + offset;
        !           667:       break;
        !           668: 
        !           669:     default:
        !           670:       ERROR(EINVAL, NULL);
        !           671:     }
        !           672: 
        !           673:   if (newpos > *lglen)
        !           674:     newpos = *lglen;
        !           675: 
        !           676:   file->pos = newpos;
        !           677: 
        !           678:   return newpos;
        !           679: 
        !           680: fail:
        !           681:   return -1;
        !           682: }
        !           683: 
        !           684: /*
        !           685:  * NAME:       hfs->close()
        !           686:  * DESCRIPTION:        close a file
        !           687:  */
        !           688: int hfs_close(hfsfile *file)
        !           689: {
        !           690:   hfsvol *vol = file->vol;
        !           691:   int result = 0;
        !           692: 
        !           693:   if (file->prev)
        !           694:     file->prev->next = file->next;
        !           695:   if (file->next)
        !           696:     file->next->prev = file->prev;
        !           697:   if (file == vol->files)
        !           698:     vol->files = file->next;
        !           699: 
        !           700:   FREE(file);
        !           701: 
        !           702:   return result;
        !           703: }
        !           704: 
        !           705: /* High-Level Catalog Routines ============================================= */
        !           706: 
        !           707: /*
        !           708:  * NAME:       hfs->stat()
        !           709:  * DESCRIPTION:        return catalog information for an arbitrary path
        !           710:  */
        !           711: int hfs_stat(hfsvol *vol, const char *path, hfsdirent *ent)
        !           712: {
        !           713:   CatDataRec data;
        !           714:   unsigned long parid;
        !           715:   char name[HFS_MAX_FLEN + 1];
        !           716: 
        !           717:   if (getvol(&vol) == -1 ||
        !           718:       v_resolve(&vol, path, &data, &parid, name, NULL) <= 0)
        !           719:     goto fail;
        !           720: 
        !           721:   r_unpackdirent(parid, name, &data, ent);
        !           722: 
        !           723:   return 0;
        !           724: 
        !           725: fail:
        !           726:   return -1;
        !           727: }
        !           728: 
        !           729: /*
        !           730:  * NAME:       hfs->fstat()
        !           731:  * DESCRIPTION:        return catalog information for an open file
        !           732:  */
        !           733: int hfs_fstat(hfsfile *file, hfsdirent *ent)
        !           734: {
        !           735:   r_unpackdirent(file->parid, file->name, &file->cat, ent);
        !           736: 
        !           737:   return 0;
        !           738: }
        !           739: 
        !           740: /*
        !           741:  * NAME:       hfs->probe()
        !           742:  * DESCRIPTION:        return whether a HFS filesystem is present at the given offset
        !           743:  */
        !           744: int hfs_probe(int fd, long long offset)
        !           745: {
        !           746:   return v_probe(fd, offset);
        !           747: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.