/usr/src/gnu/usr.sbin/mkhybrid/mkhybrid/../src/libhfs

Bug Summary

File:	src/gnu/usr.sbin/mkhybrid/mkhybrid/../src/libhfs_iso/hfs.c
Warning:	line 317, column 5 Use of memory after it is freed
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name hfs.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.sbin/mkhybrid/mkhybrid/obj -resource-dir /usr/local/lib/clang/13.0.0 -D SYSTEM_ID_DEFAULT="OpenBSD" -D APPLE_HYB -D VANILLA_AUTOCONF -I /usr/src/gnu/usr.sbin/mkhybrid/mkhybrid/../src -I /usr/src/gnu/usr.sbin/mkhybrid/mkhybrid/../src/include -I /usr/src/gnu/usr.sbin/mkhybrid/mkhybrid/../src/libhfs_iso -I /usr/src/gnu/usr.sbin/mkhybrid/mkhybrid/../src/libfile -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.sbin/mkhybrid/mkhybrid/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.sbin/mkhybrid/mkhybrid/../src/libhfs_iso/hfs.c
1/*
* hfsutils - tools for reading and writing Macintosh HFS volumes
* Copyright (C) 1996, 1997 Robert Leslie
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

20/* APPLE_HYB James Pearson j.pearson@ps.ucl.ac.uk 16/7/97 */

22# include <stdlib.h>
23# include <unistd.h>
24# include <fcntl.h>
25# include <errno(*__errno()).h>
26# include <string.h>
27# include <time.h>
28# include <ctype.h>
29# include <sys/stat.h>

31# include "internal.h"
32# include "data.h"
33# include "block.h"
34# include "low.h"
35# include "file.h"
36# include "btree.h"
37# include "node.h"
38# include "record.h"
39# include "volume.h"

41char *hfs_error = "no error";	/* static error string */

43hfsvol *hfs_mounts;		/* linked list of mounted volumes */
44hfsvol *hfs_curvol;		/* current volume */

46/* High-Level Volume Routines ============================================== */

48/*
* NAME:	hfs->mount()
* DESCRIPTION:	open an HFS volume; return volume descriptor or 0 (error)
*/
52#ifdef APPLE_HYB1
53hfsvol *hfs_mount(hce_mem *hce, int pnum, int flags)
54#else
55hfsvol *hfs_mount(char *path, int pnum, int flags)
56#endif /* APPLE_HYB */
57{
hfsvol *vol = 0;

60#ifndef APPLE_HYB1

struct stat dev;
/* see if the volume is already mounted */

if (stat(path, &dev) >= 0)
  {
    struct stat mdev;
    hfsvol *check;

    for (check = hfs_mounts; check; check = check->next)
{
 if (fstat(check->fd, &mdev) >= 0 &&
     mdev.st_dev == dev.st_dev &&
     mdev.st_ino == dev.st_ino &&
     (check->pnum == 0 || check->pnum == pnum))
   {
     /* verify compatible read/write mode */

     if (((check->flags & HFS_READONLY0x01) &&
   ! (flags & O_WRONLY0x0001)) ||
  (! (check->flags & HFS_READONLY0x01) &&
   (flags & (O_WRONLY0x0001 | O_RDWR0x0002))))
{
  vol = check;
  break;
}
   }
}
  }
90#endif /* APPLE_HYB */
if (vol == 0)
  {
    vol = ALLOC(hfsvol, 1)((hfsvol *) malloc(((size_t) (sizeof(hfsvol) * (1)))));
    if (vol == 0)
{
 ERROR(ENOMEM, 0)(hfs_error = (0), (*__errno()) = (12));
 return 0;
}

    vol->flags  = 0;
    vol->pnum   = pnum;
    vol->vstart = 0;
    vol->vlen   = 0;
    vol->lpa    = 0;
    vol->vbm    = 0;
    vol->cwd    = HFS_CNID_ROOTDIR2;

    vol->refs   = 0;
    vol->files  = 0;
    vol->dirs   = 0;
    vol->prev   = 0;
    vol->next   = 0;

    vol->ext.map     = 0;
    vol->ext.mapsz   = 0;
    vol->ext.flags   = 0;
    vol->ext.compare = r_compareextkeys;

    vol->cat.map     = 0;
    vol->cat.mapsz   = 0;
    vol->cat.flags   = 0;
    vol->cat.compare = r_comparecatkeys;

    /* open and lock the device */

126#ifdef APPLE_HYB1
    vol->fd = 3;			/* any +ve number will do? */
    vol->hce = hce;			/* store the extra with the vol info */
129#else
    if (flags & (O_WRONLY0x0001 | O_RDWR0x0002))
{
 vol->fd = open(path, O_RDWR0x0002);
 if (vol->fd >= 0 && l_lockvol(vol) < 0)
   {
     close(vol->fd);
     vol->fd = -2;
   }
}

    if (! (flags & (O_WRONLY0x0001 | O_RDWR0x0002)) ||
 (vol->fd < 0 &&
  (errno(*__errno()) == EROFS30 || errno(*__errno()) == EACCES13 || errno(*__errno()) == EAGAIN35) &&
  (flags & O_RDWR0x0002)))
{
 vol->flags |= HFS_READONLY0x01;
 vol->fd = open(path, O_RDONLY0x0000);
 if (vol->fd >= 0 && l_lockvol(vol) < 0)
   {
     close(vol->fd);
     vol->fd = -2;
   }
}

    if (vol->fd < 0)
{
 if (vol->fd != -2)
   ERROR(errno, "error opening device")(hfs_error = ("error opening device"), (*__errno()) = ((*__errno
())));

 v_destruct(vol);

 return 0;
}
163#endif /* APPLE_HYB */

    /* find out what kind of media this is and read the MDB */

    if (l_readblock0(vol) < 0 ||
 l_readmdb(vol) < 0)
{
170#ifndef APPLE_HYB1
 close(vol->fd);
 v_destruct(vol);
173#endif /* APPLE_HYB */
 return 0;
}

    /* verify this is an HFS volume */

    if (vol->mdb.drSigWord != 0x4244)
{
181#ifndef APPLE_HYB1
 close(vol->fd);
183#endif /* APPLE_HYB */
 v_destruct(vol);

 ERROR(EINVAL, "not a Macintosh HFS volume")(hfs_error = ("not a Macintosh HFS volume"), (*__errno()) = (
22));
 return 0;
}

    /* do minimal consistency checks */

    if (vol->mdb.drAlBlkSiz % HFS_BLOCKSZ512 != 0)
{
194#ifndef APPLE_HYB1
 close(vol->fd);
196#endif /* APPLE_HYB */
 v_destruct(vol);

 ERROR(EINVAL, "bad volume allocation block size")(hfs_error = ("bad volume allocation block size"), (*__errno(
)) = (22));
 return 0;
}

    if (vol->vlen == 0)
vol->vlen = vol->mdb.drAlBlSt +
 vol->mdb.drNmAlBlks * (vol->mdb.drAlBlkSiz / HFS_BLOCKSZ512) + 2;

    /* read the volume bitmap and extents/catalog B*-tree headers */

    if (l_readvbm(vol) < 0 ||
 bt_readhdr(&vol->ext) < 0 ||
 bt_readhdr(&vol->cat) < 0)
{
213#ifndef APPLE_HYB1
 close(vol->fd);
215#endif /* APPLE_HYB */
 v_destruct(vol);
 return 0;
}

    if (! (vol->mdb.drAtrb & HFS_ATRB_UMOUNTED(1 << 8)))
{
 /* volume was not cleanly unmounted; scavenge free-space */

 if (v_scavenge(vol) < 0)
   {
226#ifndef APPLE_HYB1
     close(vol->fd);
228#endif /* APPLE_HYB */
     v_destruct(vol);
     return 0;
   }
}

    if (vol->flags & HFS_READONLY0x01)
vol->mdb.drAtrb |= HFS_ATRB_HLOCKED(1 << 7);
    else
vol->mdb.drAtrb &= ~HFS_ATRB_HLOCKED(1 << 7);

    vol->prev = 0;
    vol->next = hfs_mounts;

    if (hfs_mounts)
hfs_mounts->prev = vol;

    hfs_mounts = vol;
  }

++vol->refs;

return hfs_curvol = vol;
251}

253/*
* NAME:	hfs->flush()
* DESCRIPTION:	flush all pending changes to an HFS volume
*/
257int hfs_flush(hfsvol *vol)
258{
hfsfile *file;

if (v_getvol(&vol) < 0)
  return -1;

for (file = vol->files; file; file = file->next)
  {
    if (f_flush(file) < 0)
return -1;
  }

if (v_flush(vol, 0) < 0)
  return -1;

return 0;
274}

276/*
* NAME:	hfs->flushall()
* DESCRIPTION:	flush all pending changes to all mounted HFS volumes
*/
280void hfs_flushall(void)
281{
hfsvol *vol;

for (vol = hfs_mounts; vol; vol = vol->next)
  hfs_flush(vol);
286}

288/*
* NAME:	hfs->umount()
* DESCRIPTION:	close an HFS volume
*/
292#ifdef APPLE_HYB1
293/* extra argument used to alter the position of the extents/catalog files */
294int hfs_umount(hfsvol *vol, long end)
295#else
296int hfs_umount(hfsvol *vol)
297#endif /* APPLE_HYB */
298{
int result = 0;

if (v_getvol(&vol) < 0)
1
Assuming the condition is false→
2
←
Taking false branch→
  return -1;

if (--vol->refs)
3
←
Assuming the condition is false→
4
←
Taking false branch→
  return v_flush(vol, 0);

/* close all open files and directories */

while (vol->files)
5
←
Loop condition is false. Execution continues on line 316→
310#ifdef APPLE_HYB1
  hfs_close(vol->files, 0, 0);
312#else
  hfs_close(vol->files);
314#endif /* APPLE_HYB */

while (vol->dirs)
6
←
Loop condition is true.  Entering loop body→
17
←
Loop condition is true.  Entering loop body→
  hfs_closedir(vol->dirs);
7
←
Calling 'hfs_closedir'→
16
←
Returning; memory was released via 1st parameter→
18
←
Use of memory after it is freed

319#ifdef APPLE_HYB1
if (end)
{
/*  move extents and catalog to end of volume ... */
	long vbmsz = (vol->vlen / vol->lpa + 4095) / 4096;

/* we are adding this "files" to the end of the ISO volume,
  so calculate this address in HFS speak ... */
327/*	end -= vol->mdb.drAlBlSt; */
end -= (vol->mdb.drAlBlSt + vol->hce->hfs_map_size);
end /= vol->lpa;

/* catalog file ... */
vol->ext.f.cat.u.fil.filExtRec[0].xdrStABN = end;
vol->mdb.drXTExtRec[0].xdrStABN = end;

/* move postition to start of extents file */
end += vol->cat.f.cat.u.fil.filExtRec[0].xdrStABN;

/* extents file ... */
vol->cat.f.cat.u.fil.filExtRec[0].xdrStABN = end;
vol->mdb.drCTExtRec[0].xdrStABN = end;

/* the volume bitmap is wrong as we have "moved" files
  about - simple just set the whole lot (it's a readonly volume
  anyway!) */
memset(vol->vbm, 0xff, vbmsz*HFS_BLOCKSZ512);

/* set the free blocks to zero */
vol->mdb.drFreeBks = 0;

/* flag changes for flushing later */
vol->flags |= HFS_UPDATE_VBM0x40;
vol->flags |= HFS_UPDATE_MDB0x10;
vol->mdb.drAtrb |= HFS_ATRB_HLOCKED(1 << 7);
vol->ext.flags |= HFS_UPDATE_BTHDR0x01;
vol->cat.flags |= HFS_UPDATE_BTHDR0x01;
}
357#endif /* APPLE_HYB */

if (v_flush(vol, 1) < 0)
  result = -1;

362#ifndef APPLE_HYB1
if (close(vol->fd) < 0 && result == 0)
  {
    ERROR(errno, "error closing device")(hfs_error = ("error closing device"), (*__errno()) = ((*__errno
())));
    result = -1;
  }
368#endif /* APPLE_HYB */

if (vol->prev)
  vol->prev->next = vol->next;
if (vol->next)
  vol->next->prev = vol->prev;

if (vol == hfs_mounts)
  hfs_mounts = vol->next;
if (vol == hfs_curvol)
  hfs_curvol = 0;

v_destruct(vol);

return result;
383}

385/*
* NAME:	hfs->umountall()
* DESCRIPTION:	unmount all mounted volumes
*/
389void hfs_umountall(void)
390{
while (hfs_mounts)
392#ifdef APPLE_HYB1
  continue;
394#else
  hfs_umount(hfs_mounts);
396#endif /* APPLE_HYB */
397}

399/*
* NAME:	hfs->getvol()
* DESCRIPTION:	return a pointer to a mounted volume
*/
403hfsvol *hfs_getvol(char *name)
404{
hfsvol *vol;

if (name == 0)
  return hfs_curvol;

for (vol = hfs_mounts; vol; vol = vol->next)
  {
    if (d_relstring(name, vol->mdb.drVN) == 0)
return vol;
  }

return 0;
417}

419/*
* NAME:	hfs->setvol()
* DESCRIPTION:	change the current volume
*/
423void hfs_setvol(hfsvol *vol)
424{
hfs_curvol = vol;
426}

428/*
* NAME:	hfs->vstat()
* DESCRIPTION:	return volume statistics
*/
432int hfs_vstat(hfsvol *vol, hfsvolent *ent)
433{
if (v_getvol(&vol) < 0)
  return -1;

strcpy(ent->name, vol->mdb.drVN);

ent->flags     = (vol->flags & HFS_READONLY0x01) ? HFS_ISLOCKED0x02 : 0;
ent->totbytes  = vol->mdb.drNmAlBlks * vol->mdb.drAlBlkSiz;
ent->freebytes = vol->mdb.drFreeBks  * vol->mdb.drAlBlkSiz;
ent->crdate    = d_toutime(vol->mdb.drCrDate);
ent->mddate    = d_toutime(vol->mdb.drLsMod);

return 0;
446}

448/*
* NAME:	hfs->format()
* DESCRIPTION:	write a new filesystem
*/
452#ifdef APPLE_HYB1
453int hfs_format(hce_mem *hce, int pnum, char *vname)
454#else
455int hfs_format(char *path, int pnum, char *vname)
456#endif /* APPLE_HYB */
457{
hfsvol vol;
btree *ext = &vol.ext;
btree *cat = &vol.cat;
unsigned int vbmsz;
int i, result = 0;
block vbm[16];
char *map;

if (strchr(vname, ':'))
  {
    ERROR(EINVAL, "volume name may not contain colons")(hfs_error = ("volume name may not contain colons"), (*__errno
()) = (22));
    return -1;
  }

i = strlen(vname);
if (i < 1 || i > HFS_MAX_VLEN27)
  {
    ERROR(EINVAL, "volume name must be 1-27 chars")(hfs_error = ("volume name must be 1-27 chars"), (*__errno())
 = (22));
    return -1;
  }

vol.flags  = 0;
vol.pnum   = pnum;
vol.vstart = 0;
vol.vlen   = 0;
vol.lpa    = 0;
vol.vbm    = vbm;
vol.cwd    = HFS_CNID_ROOTDIR2;

vol.refs   = 0;
vol.files  = 0;
vol.dirs   = 0;
vol.prev   = 0;
vol.next   = 0;

493#ifndef APPLE_HYB1
vol.fd = open(path, O_RDWR0x0002);
if (vol.fd < 0)
  {
    ERROR(errno, "error opening device for writing")(hfs_error = ("error opening device for writing"), (*__errno(
)) = ((*__errno())));
    return -1;
  }

if (l_lockvol(&vol) < 0)
  {
    close(vol.fd);
    return -1;
  }
506#endif /* APPLE_HYB */
if (pnum > 0)
  {
    if (l_readpm(&vol) < 0)
{
 close(vol.fd);
 return -1;
}
  }
else  /* determine size of entire device */
  {
517#ifdef APPLE_HYB1
    vol.vlen = hce->hfs_vol_size/HFS_BLOCKSZ512;
519#else
    unsigned long low, high, mid;
    block b;

    for (low = 0, high = 2879; b_readlb(&vol, high, &b) >= 0; high *= 2)
low = high;

    while (low < high - 1)
{
 mid = (low + high) / 2;

 if (b_readlb(&vol, mid, &b) < 0)
   high = mid;
 else
   low = mid;
}

    vol.vlen = low + 1;
537#endif /* APPLE_HYB */
  }

if (vol.vlen < 800 * 1024 / HFS_BLOCKSZ512)
  {
542#ifndef APPLE_HYB1
    close(vol.fd);
544#endif /* APPLE_HYB */

    ERROR(EINVAL, "volume size must be >= 800K")(hfs_error = ("volume size must be >= 800K"), (*__errno())
 = (22));
    return -1;
  }

/* initialize volume geometry */

552#ifdef APPLE_HYB1
/* force lpa to be a multiple of 4 (i.e. 2048/512) - as calculated 
   earlier */
vol.lpa = hce->Csize/HFS_BLOCKSZ512;
556#else
vol.lpa = 1 + vol.vlen / 65536;
558#endif /* APPLE_HYB */

vbmsz = (vol.vlen / vol.lpa + 4095) / 4096;

vol.mdb.drSigWord  = 0x4244;
vol.mdb.drCrDate   = d_tomtime(time(0));
vol.mdb.drLsMod    = vol.mdb.drCrDate;
vol.mdb.drAtrb     = 0;
vol.mdb.drNmFls    = 0;
vol.mdb.drVBMSt    = 3;
vol.mdb.drAllocPtr = 0;
vol.mdb.drNmAlBlks = (vol.vlen - 5 - vbmsz) / vol.lpa;
vol.mdb.drAlBlkSiz = vol.lpa * HFS_BLOCKSZ512;
vol.mdb.drClpSiz   = vol.mdb.drAlBlkSiz * 4;
vol.mdb.drAlBlSt   = 3 + vbmsz;
573#ifdef APPLE_HYB1
/* round up start block to a muliple of lpa - important later */
575/*vol.mdb.drAlBlSt   = ((vol.mdb.drAlBlSt + vol.lpa -  1) / vol.lpa) * vol.lpa; 
576*/
/* take in accout alignment of files wrt HFS volume start i.e we want
   drAlBlSt plus hfs_map_size to me a multiple of lpa */
vol.mdb.drAlBlSt   = ((vol.mdb.drAlBlSt + hce->hfs_map_size + vol.lpa -  1) / vol.lpa) * vol.lpa; 
vol.mdb.drAlBlSt   -= hce->hfs_map_size;
581#endif /* APPLE_HYB */
vol.mdb.drNxtCNID  = HFS_CNID_ROOTDIR2;  /* modified later */
vol.mdb.drFreeBks  = vol.mdb.drNmAlBlks;

strcpy(vol.mdb.drVN, vname);

vol.mdb.drVolBkUp  = 0;
vol.mdb.drVSeqNum  = 0;
vol.mdb.drWrCnt    = 0;
vol.mdb.drXTClpSiz = vol.mdb.drNmAlBlks / 128 * vol.mdb.drAlBlkSiz;
591#ifdef APPLE_HYB1
/* adjust size of extents/catalog upwards as we may have rounded up
   allocation size */
i = 1 + vol.vlen / 65536;

vol.mdb.drXTClpSiz = (vol.mdb.drXTClpSiz * vol.lpa) / i;

/* round up to lpa size */
vol.mdb.drXTClpSiz = ((vol.mdb.drXTClpSiz + vol.mdb.drAlBlkSiz - 1) /
		vol.mdb.drAlBlkSiz) * vol.mdb.drAlBlkSiz;

/* ignore above, use what we have already calculated ... */
vol.mdb.drXTClpSiz = hce->XTCsize;

/* make Catalog file CTC (default twice) as big - prevents further allocation
   later which we don't want - this seems to work OK ... */
607/*vol.mdb.drCTClpSiz = vol.mdb.drXTClpSiz * CTC; */
vol.mdb.drCTClpSiz = vol.mdb.drXTClpSiz * hce->ctc_size;

/* we want to put things at the end of the volume later, so we'll
   cheat here ... shouldn't matter, as we only need the volume read
   only anyway (we won't be adding files later!) - leave some extra
   space for the alternative MDB (in the last allocation block) */

vol.mdb.drNmAlBlks = vol.mdb.drFreeBks = vol.vlen / vol.lpa - 1;
616#else
vol.mdb.drCTClpSiz = vol.mdb.drXTClpSiz;
618#endif /* APPLE_HYB */
vol.mdb.drNmRtDirs = 0;
vol.mdb.drFilCnt   = 0;
vol.mdb.drDirCnt   = -1;  /* incremented when root folder is created */

for (i = 0; i < 8; ++i)
  vol.mdb.drFndrInfo[i] = 0;

vol.mdb.drVCSize   = 0;
vol.mdb.drVBMCSize = 0;
vol.mdb.drCtlCSize = 0;

vol.mdb.drXTFlSize = 0;
vol.mdb.drCTFlSize = 0;

for (i = 0; i < 3; ++i)
  {
    vol.mdb.drXTExtRec[i].xdrStABN    = 0;
    vol.mdb.drXTExtRec[i].xdrNumABlks = 0;

    vol.mdb.drCTExtRec[i].xdrStABN    = 0;
    vol.mdb.drCTExtRec[i].xdrNumABlks = 0;
  }

/* initialize volume bitmap */

memset(vol.vbm, 0, sizeof(vbm));

646#ifdef APPLE_HYB1
/* We don't want to write anything out at the moment, so we allocate
   memory to hold the HFS "header" info and extents/catalog files.
   Any reads/writes from/to these parts of the volume are trapped and
   stored in memory. */

/* blocks up to the first unallocated block == HFS "header" info
   This will be placed in the first 32kb of the ISO volume later */
hce->hfs_hdr_size = vol.mdb.drAlBlSt;

/* size of the extents and catalog files. This will be added
   to the end of the ISO volume later */
hce->hfs_ce_size =  vol.mdb.drXTClpSiz + vol.mdb.drCTClpSiz;

/* we also allocate space for the Desktop file and the alternative
   MDB while we're here */
FREE(hce->hfs_ce)((hce->hfs_ce) ? (void) free((void *) hce->hfs_ce) : (void
) 0);
hce->hfs_ce = ALLOC(unsigned char, (hce->hfs_ce_size + vol.mdb.drClpSiz((unsigned char *) malloc(((size_t) (sizeof(unsigned char) * (
(hce->hfs_ce_size + vol.mdb.drClpSiz + vol.mdb.drAlBlkSiz)
)))))
			+ vol.mdb.drAlBlkSiz))((unsigned char *) malloc(((size_t) (sizeof(unsigned char) * (
(hce->hfs_ce_size + vol.mdb.drClpSiz + vol.mdb.drAlBlkSiz)
)))));

/* allocate memory for the map and hdr */
FREE(hce->hfs_map)((hce->hfs_map) ? (void) free((void *) hce->hfs_map) : (
void) 0);
hce->hfs_map = ALLOC(unsigned char, ((hce->hfs_hdr_size + hce->hfs_map_size)((unsigned char *) malloc(((size_t) (sizeof(unsigned char) * (
((hce->hfs_hdr_size + hce->hfs_map_size) *512))))))
	*HFS_BLOCKSZ))((unsigned char *) malloc(((size_t) (sizeof(unsigned char) * (
((hce->hfs_hdr_size + hce->hfs_map_size) *512))))));

if (hce->hfs_ce == 0 || hce->hfs_map == 0)
  {
    ERROR(ENOMEM, 0)(hfs_error = (0), (*__errno()) = (12));
    result = -1;
  }

/* hfs_hdr is immediately after the hfs_map */
hce->hfs_hdr = hce->hfs_map + hce->hfs_map_size*HFS_BLOCKSZ512;

/* size needed in HFS_BLOCKSZ blocks for later use */
hce->hfs_ce_size /= HFS_BLOCKSZ512;

/* note size of Desktop file */
hce->hfs_dt_size = vol.mdb.drClpSiz/HFS_BLOCKSZ512;

/* total size of catalog/extents and desktop */
hce->hfs_tot_size = hce->hfs_ce_size + hce->hfs_dt_size;

/* alternative MDB in the last alocation block */
hce->hfs_alt_mdb = hce->hfs_ce + hce->hfs_tot_size*HFS_BLOCKSZ512;

/* add the MDB to the total size */
hce->hfs_tot_size += vol.lpa;

/* store this info in the volume info */
vol.hce = hce;

698#endif /* APPLE_HYB */

/* create extents overflow file */

ext->f.vol   = &vol;
ext->f.parid = 0;
strcpy(ext->f.name, "extents overflow");

ext->f.cat.cdrType          = cdrFilRec;
/* ext->f.cat.cdrResrv2 */
ext->f.cat.u.fil.filFlags   = 0;
ext->f.cat.u.fil.filTyp     = 0;
/* ext->f.cat.u.fil.filUsrWds */
ext->f.cat.u.fil.filFlNum   = HFS_CNID_EXT3;
ext->f.cat.u.fil.filStBlk   = 0;
ext->f.cat.u.fil.filLgLen   = 0;
ext->f.cat.u.fil.filPyLen   = 0;
ext->f.cat.u.fil.filRStBlk  = 0;
ext->f.cat.u.fil.filRLgLen  = 0;
ext->f.cat.u.fil.filRPyLen  = 0;
ext->f.cat.u.fil.filCrDat   = vol.mdb.drCrDate;
ext->f.cat.u.fil.filMdDat   = vol.mdb.drLsMod;
ext->f.cat.u.fil.filBkDat   = 0;
/* ext->f.cat.u.fil.filFndrInfo */
ext->f.cat.u.fil.filClpSize = 0;

for (i = 0; i < 3; ++i)
  {
    ext->f.cat.u.fil.filExtRec[i].xdrStABN     = 0;
    ext->f.cat.u.fil.filExtRec[i].xdrNumABlks  = 0;

    ext->f.cat.u.fil.filRExtRec[i].xdrStABN    = 0;
    ext->f.cat.u.fil.filRExtRec[i].xdrNumABlks = 0;
  }
/* ext->f.cat.u.fil.filResrv */
f_selectfork(&ext->f, 0);

ext->f.clump = vol.mdb.drXTClpSiz;
ext->f.flags = 0;

ext->f.prev = ext->f.next = 0;

n_init(&ext->hdrnd, ext, ndHdrNode, 0);

ext->hdrnd.nnum       = 0;
ext->hdrnd.nd.ndNRecs = 3;
ext->hdrnd.roff[1]    = 0x078;
ext->hdrnd.roff[2]    = 0x0f8;
ext->hdrnd.roff[3]    = 0x1f8;

memset(HFS_NODEREC(ext->hdrnd, 1)((ext->hdrnd).data + (ext->hdrnd).roff[1]), 0, 128);

ext->hdr.bthDepth    = 0;
ext->hdr.bthRoot     = 0;
ext->hdr.bthNRecs    = 0;
ext->hdr.bthFNode    = 0;
ext->hdr.bthLNode    = 0;
ext->hdr.bthNodeSize = HFS_BLOCKSZ512;
ext->hdr.bthKeyLen   = 0x07;
ext->hdr.bthNNodes   = 0;
ext->hdr.bthFree     = 0;
for (i = 0; i < 76; ++i)
  ext->hdr.bthResv[i] = 0;

map = ALLOC(char, HFS_MAP1SZ)((char *) malloc(((size_t) (sizeof(char) * (256)))));
if (map == 0)
  {
    if (result == 0)
{
 ERROR(ENOMEM, 0)(hfs_error = (0), (*__errno()) = (12));
 result = -1;
}
  }
else
  {
    memset(map, 0, HFS_MAP1SZ256);
    BMSET(map, 0)(((char *) (map))[(0) >> 3] |= (0x80 >> ((0) &
 0x07)));
  }

ext->map     = map;
ext->mapsz   = HFS_MAP1SZ256;
ext->flags   = HFS_UPDATE_BTHDR0x01;
ext->compare = r_compareextkeys;

if (result == 0 && bt_space(ext, 1) < 0)
  result = -1;

--ext->hdr.bthFree;

/* create catalog file */

cat->f.vol   = &vol;
cat->f.parid = 0;
strcpy(cat->f.name, "catalog");

cat->f.cat.cdrType          = cdrFilRec;
/* cat->f.cat.cdrResrv2 */
cat->f.cat.u.fil.filFlags   = 0;
cat->f.cat.u.fil.filTyp     = 0;
/* cat->f.cat.u.fil.filUsrWds */
cat->f.cat.u.fil.filFlNum   = HFS_CNID_CAT4;
cat->f.cat.u.fil.filStBlk   = 0;
cat->f.cat.u.fil.filLgLen   = 0;
cat->f.cat.u.fil.filPyLen   = 0;
cat->f.cat.u.fil.filRStBlk  = 0;
cat->f.cat.u.fil.filRLgLen  = 0;
cat->f.cat.u.fil.filRPyLen  = 0;
cat->f.cat.u.fil.filCrDat   = vol.mdb.drCrDate;
cat->f.cat.u.fil.filMdDat   = vol.mdb.drLsMod;
cat->f.cat.u.fil.filBkDat   = 0;
/* cat->f.cat.u.fil.filFndrInfo */
cat->f.cat.u.fil.filClpSize = 0;

for (i = 0; i < 3; ++i)
  {
    cat->f.cat.u.fil.filExtRec[i].xdrStABN     = 0;
    cat->f.cat.u.fil.filExtRec[i].xdrNumABlks  = 0;

    cat->f.cat.u.fil.filRExtRec[i].xdrStABN    = 0;
    cat->f.cat.u.fil.filRExtRec[i].xdrNumABlks = 0;
  }
/* cat->f.cat.u.fil.filResrv */
f_selectfork(&cat->f, 0);

cat->f.clump = vol.mdb.drCTClpSiz;
cat->f.flags = 0;

cat->f.prev = cat->f.next = 0;

n_init(&cat->hdrnd, cat, ndHdrNode, 0);

cat->hdrnd.nnum       = 0;
cat->hdrnd.nd.ndNRecs = 3;
cat->hdrnd.roff[1]    = 0x078;
cat->hdrnd.roff[2]    = 0x0f8;
cat->hdrnd.roff[3]    = 0x1f8;

memset(HFS_NODEREC(cat->hdrnd, 1)((cat->hdrnd).data + (cat->hdrnd).roff[1]), 0, 128);

cat->hdr.bthDepth    = 0;
cat->hdr.bthRoot     = 0;
cat->hdr.bthNRecs    = 0;
cat->hdr.bthFNode    = 0;
cat->hdr.bthLNode    = 0;
cat->hdr.bthNodeSize = HFS_BLOCKSZ512;
cat->hdr.bthKeyLen   = 0x25;
cat->hdr.bthNNodes   = 0;
cat->hdr.bthFree     = 0;
for (i = 0; i < 76; ++i)
  cat->hdr.bthResv[i] = 0;

map = ALLOC(char, HFS_MAP1SZ)((char *) malloc(((size_t) (sizeof(char) * (256)))));
if (map == 0)
  {
    if (result == 0)
{
 ERROR(ENOMEM, 0)(hfs_error = (0), (*__errno()) = (12));
 result = -1;
}
  }
else
  {
    memset(map, 0, HFS_MAP1SZ256);
    BMSET(map, 0)(((char *) (map))[(0) >> 3] |= (0x80 >> ((0) &
 0x07)));
  }

cat->map     = map;
cat->mapsz   = HFS_MAP1SZ256;
cat->flags   = HFS_UPDATE_BTHDR0x01;
cat->compare = r_comparecatkeys;

if (result == 0 && bt_space(cat, 1) < 0)
  result = -1;

--cat->hdr.bthFree;

/* create root folder */

if (result == 0 && v_newfolder(&vol, HFS_CNID_ROOTPAR1, vname) < 0)
  result = -1;

vol.mdb.drNxtCNID = 16;

/* finish up */

if (result == 0)
  {
    block b;

    /* write boot blocks */

    memset(&b, 0, sizeof(b));
    b_writelb(&vol, 0, &b);
    b_writelb(&vol, 1, &b);

    /* flush other disk state */

    vol.flags |= HFS_UPDATE_MDB0x10 | HFS_UPDATE_ALTMDB0x20 | HFS_UPDATE_VBM0x40;

    if (v_flush(&vol, 1) < 0)
result = -1;
  }
900#ifndef APPLE_HYB1
if (close(vol.fd) < 0 && result == 0)
  {
    ERROR(errno, "error closing device")(hfs_error = ("error closing device"), (*__errno()) = ((*__errno
())));
    result = -1;
  }
906#endif /* APPLE_HYB */
FREE(vol.ext.map)((vol.ext.map) ? (void) free((void *) vol.ext.map) : (void) 0
);
FREE(vol.cat.map)((vol.cat.map) ? (void) free((void *) vol.cat.map) : (void) 0
);

return result;
911}

913/* High-Level Directory Routines =========================================== */

915/*
* NAME:	hfs->chdir()
* DESCRIPTION:	change current HFS directory
*/
919int hfs_chdir(hfsvol *vol, char *path)
920{
CatDataRec data;

if (v_getvol(&vol) < 0 ||
    v_resolve(&vol, path, &data, 0, 0, 0) <= 0)
  return -1;

if (data.cdrType != cdrDirRec)
  {
    ERROR(ENOTDIR, 0)(hfs_error = (0), (*__errno()) = (20));
    return -1;
  }

vol->cwd = data.u.dir.dirDirID;

return 0;
936}

938/*
* NAME:	hfs->getcwd()
* DESCRIPTION:	return the current working directory ID
*/
942long hfs_getcwd(hfsvol *vol)
943{
if (v_getvol(&vol) < 0)
  return 0;

return vol->cwd;
948}

950/*
* NAME:	hfs->setcwd()
* DESCRIPTION:	set the current working directory ID
*/
954int hfs_setcwd(hfsvol *vol, long id)
955{
if (v_getvol(&vol) < 0)
  return -1;

if (id == vol->cwd)
  return 0;

/* make sure the directory exists */

if (v_getdthread(vol, id, 0, 0)v_getthread(vol, id, 0, 0, cdrThdRec) <= 0)
  return -1;

vol->cwd = id;

return 0;
970}

972/*
* NAME:	hfs->dirinfo()
* DESCRIPTION:	given a directory ID, return its (name and) parent ID
*/
976int hfs_dirinfo(hfsvol *vol, long *id, char *name)
977{
CatDataRec thread;

if (v_getvol(&vol) < 0 ||
    v_getdthread(vol, *id, &thread, 0)v_getthread(vol, *id, &thread, 0, cdrThdRec) <= 0)
  return -1;

*id = thread.u.dthd.thdParID;

if (name)
  strcpy(name, thread.u.dthd.thdCName);

return 0;
990}

992/*
* NAME:	hfs->opendir()
* DESCRIPTION:	prepare to read the contents of a directory
*/
996hfsdir *hfs_opendir(hfsvol *vol, char *path)
997{
hfsdir *dir;
CatKeyRec key;
CatDataRec data;
unsigned char pkey[HFS_CATKEYLENsizeof(CatKeyRec)];

if (v_getvol(&vol) < 0)
  return 0;

dir = ALLOC(hfsdir, 1)((hfsdir *) malloc(((size_t) (sizeof(hfsdir) * (1)))));
if (dir == 0)
  {
    ERROR(ENOMEM, 0)(hfs_error = (0), (*__errno()) = (12));
    return 0;
  }

dir->vol = vol;

if (*path == 0)
  {
    /* meta-directory containing root dirs from all mounted volumes */

    dir->dirid = 0;
    dir->vptr  = hfs_mounts;
  }
else
  {
    if (v_resolve(&vol, path, &data, 0, 0, 0) <= 0)
{
 FREE(dir)((dir) ? (void) free((void *) dir) : (void) 0);
 return 0;
}

    if (data.cdrType != cdrDirRec)
{
 FREE(dir)((dir) ? (void) free((void *) dir) : (void) 0);
 ERROR(ENOTDIR, 0)(hfs_error = (0), (*__errno()) = (20));
 return 0;
}

    dir->dirid = data.u.dir.dirDirID;
    dir->vptr  = 0;

    r_makecatkey(&key, dir->dirid, "");
    r_packcatkey(&key, pkey, 0);

    if (bt_search(&vol->cat, pkey, &dir->n) <= 0)
{
 FREE(dir)((dir) ? (void) free((void *) dir) : (void) 0);
 return 0;
}
  }

dir->prev = 0;
dir->next = vol->dirs;

if (vol->dirs)
  vol->dirs->prev = dir;

vol->dirs = dir;

return dir;
1059}

1061/*
* NAME:	hfs->readdir()
* DESCRIPTION:	return the next entry in the directory
*/
1065int hfs_readdir(hfsdir *dir, hfsdirent *ent)
1066{
CatKeyRec key;
CatDataRec data;
unsigned char *ptr;

if (dir->dirid == 0)
  {
    hfsvol *vol;
    char cname[HFS_MAX_FLEN31 + 1];

    for (vol = hfs_mounts; vol; vol = vol->next)
{
 if (vol == dir->vptr)
   break;
}

    if (vol == 0)
{
 ERROR(ENOENT, "no more entries")(hfs_error = ("no more entries"), (*__errno()) = (2));
 return -1;
}

    if (v_getdthread(vol, HFS_CNID_ROOTDIR, &data, 0)v_getthread(vol, 2, &data, 0, cdrThdRec) <= 0 ||
 v_catsearch(vol, HFS_CNID_ROOTPAR1, data.u.dthd.thdCName,
      &data, cname, 0) < 0)
return -1;

    r_unpackdirent(HFS_CNID_ROOTPAR1, cname, &data, ent);

    dir->vptr = vol->next;

    return 0;
  }

if (dir->n.rnum == -1)
  {
    ERROR(ENOENT, "no more entries")(hfs_error = ("no more entries"), (*__errno()) = (2));
    return -1;
  }

while (1)
  {
    ++dir->n.rnum;

    while (dir->n.rnum >= dir->n.nd.ndNRecs)
{
 dir->n.nnum = dir->n.nd.ndFLink;
 if (dir->n.nnum == 0)
   {
     dir->n.rnum = -1;
     ERROR(ENOENT, "no more entries")(hfs_error = ("no more entries"), (*__errno()) = (2));
     return -1;
   }

 if (bt_getnode(&dir->n) < 0)
   {
     dir->n.rnum = -1;
     return -1;
   }

 dir->n.rnum = 0;
}

    ptr = HFS_NODEREC(dir->n, dir->n.rnum)((dir->n).data + (dir->n).roff[dir->n.rnum]);

    r_unpackcatkey(ptr, &key);

    if (key.ckrParID != dir->dirid)
{
 dir->n.rnum = -1;
 ERROR(ENOENT, "no more entries")(hfs_error = ("no more entries"), (*__errno()) = (2));
 return -1;
}

    r_unpackcatdata(HFS_RECDATA(ptr)((ptr) + ((1 + (*(unsigned char *) (ptr)) + 1) & ~1)), &data);

    switch (data.cdrType)
{
case cdrDirRec:
case cdrFilRec:
 r_unpackdirent(key.ckrParID, key.ckrCName, &data, ent);
 return 0;

case cdrThdRec:
case cdrFThdRec:
 break;

default:
 dir->n.rnum = -1;

 ERROR(EIO, "unexpected directory entry found")(hfs_error = ("unexpected directory entry found"), (*__errno(
)) = (5));
 return -1;
}
  }
1160}

1162/*
* NAME:	hfs->closedir()
* DESCRIPTION:	stop reading a directory
*/
1166int hfs_closedir(hfsdir *dir)
1167{
hfsvol *vol = dir->vol;

if (dir->prev)
8
←
Assuming field 'prev' is null→
9
←
Taking false branch→
  dir->prev->next = dir->next;
if (dir->next)
10
←
Assuming field 'next' is null→
11
←
Taking false branch→
  dir->next->prev = dir->prev;
if (dir == vol->dirs)
12
←
Assuming 'dir' is not equal to field 'dirs'→
13
←
Taking false branch→
  vol->dirs = dir->next;

FREE(dir)((dir) ? (void) free((void *) dir) : (void) 0);
14
←
'?' condition is true→
15
←
Memory is released→

return 0;
1180}

1182/* High-Level File Routines ================================================ */

1184/*
* NAME:	hfs->open()
* DESCRIPTION:	prepare a file for I/O
*/
1188hfsfile *hfs_open(hfsvol *vol, char *path)
1189{
hfsfile *file;

if (v_getvol(&vol) < 0)
  return 0;

file = ALLOC(hfsfile, 1)((hfsfile *) malloc(((size_t) (sizeof(hfsfile) * (1)))));
if (file == 0)
  {
    ERROR(ENOMEM, 0)(hfs_error = (0), (*__errno()) = (12));
    return 0;
  }

if (v_resolve(&vol, path, &file->cat, &file->parid, file->name, 0) <= 0)
  {
    FREE(file)((file) ? (void) free((void *) file) : (void) 0);
    return 0;
  }

if (file->cat.cdrType != cdrFilRec)
  {
    FREE(file)((file) ? (void) free((void *) file) : (void) 0);
    ERROR(EISDIR, 0)(hfs_error = (0), (*__errno()) = (21));
    return 0;
  }

file->vol   = vol;
file->clump = file->cat.u.fil.filClpSize;
file->flags = 0;

f_selectfork(file, 0);

file->prev = 0;
file->next = vol->files;

if (vol->files)
  vol->files->prev = file;

vol->files = file;

return file;
1230}

1232/*
* NAME:	hfs->setfork()
* DESCRIPTION:	select file fork for I/O operations
*/
1236int hfs_setfork(hfsfile *file, int fork)
1237{
int result = 0;

if (! (file->vol->flags & HFS_READONLY0x01) &&
    f_trunc(file) < 0)
  result = -1;

f_selectfork(file, fork);

return result;
1247}

1249/*
* NAME:	hfs->getfork()
* DESCRIPTION:	return the current fork for I/O operations
*/
1253int hfs_getfork(hfsfile *file)
1254{
return file->fork != fkData;
1256}

1258/*
* NAME:	hfs->read()
* DESCRIPTION:	read from an open file
*/
1262long hfs_read(hfsfile *file, void *buf, unsigned long len)
1263{
unsigned long *lglen, count;
unsigned char *ptr = buf;

f_getptrs(file, &lglen, 0, 0);

if (file->pos + len > *lglen)
  len = *lglen - file->pos;

count = len;
while (count)
  {
    block b;
    unsigned long bnum, offs, chunk;

    bnum  = file->pos / HFS_BLOCKSZ512;
    offs  = file->pos % HFS_BLOCKSZ512;

    chunk = HFS_BLOCKSZ512 - offs;
    if (chunk > count)
chunk = count;

    if (f_getblock(file, bnum, &b)f_doblock(file, bnum, &b, b_readab) < 0)
return -1;

    memcpy(ptr, b + offs, chunk);
    ptr += chunk;

    file->pos += chunk;
    count     -= chunk;
  }

return len;
1296}

1298/*
* NAME:	hfs->write()
* DESCRIPTION:	write to an open file
*/
1302long hfs_write(hfsfile *file, void *buf, unsigned long len)
1303{
unsigned long *lglen, *pylen, count;
unsigned char *ptr = buf;

if (file->vol->flags & HFS_READONLY0x01)
  {
    ERROR(EROFS, 0)(hfs_error = (0), (*__errno()) = (30));
    return -1;
  }

f_getptrs(file, &lglen, &pylen, 0);

count = len;

/* set flag to update (at least) the modification time */

if (count)
  {
    file->cat.u.fil.filMdDat = d_tomtime(time(0));
    file->flags |= HFS_UPDATE_CATREC0x01;
  }

while (count)
  {
    block b;
    unsigned long bnum, offs, chunk;

    bnum  = file->pos / HFS_BLOCKSZ512;
    offs  = file->pos % HFS_BLOCKSZ512;

    chunk = HFS_BLOCKSZ512 - offs;
    if (chunk > count)
chunk = count;

    if (file->pos + chunk > *pylen)
{
 if (bt_space(&file->vol->ext, 1) < 0 ||
     f_alloc(file) < 0)
   return -1;
}
1343#ifndef APPLE_HYB1
    /* Ignore this part as we are always writing new files to an empty disk
i.e. offs will always be 0 */

    if (offs > 0 || chunk < HFS_BLOCKSZ512)
{
 if (f_getblock(file, bnum, &b)f_doblock(file, bnum, &b, b_readab) < 0)
   return -1;
}
1352#endif /* APPLE_HYB */
    memcpy(b + offs, ptr, chunk);
    ptr += chunk;

    if (f_putblock(file, bnum, &b)f_doblock(file, bnum, &b, b_writeab) < 0)
return -1;

    file->pos += chunk;
    count     -= chunk;

    if (file->pos > *lglen)
*lglen = file->pos;
  }

return len;
1367}

1369/*
* NAME:	hfs->truncate()
* DESCRIPTION:	truncate an open file
*/
1373int hfs_truncate(hfsfile *file, unsigned long len)
1374{
unsigned long *lglen;

f_getptrs(file, &lglen, 0, 0);

if (*lglen > len)
  {
    if (file->vol->flags & HFS_READONLY0x01)
{
 ERROR(EROFS, 0)(hfs_error = (0), (*__errno()) = (30));
 return -1;
}

    *lglen = len;

    file->cat.u.fil.filMdDat = d_tomtime(time(0));
    file->flags |= HFS_UPDATE_CATREC0x01;

    if (file->pos > len)
file->pos = len;
  }

return 0;
1397}

1399/*
* NAME:	hfs->lseek()
* DESCRIPTION:	change file seek pointer
*/
1403long hfs_lseek(hfsfile *file, long offset, int from)
1404{
unsigned long *lglen;
long newpos;

f_getptrs(file, &lglen, 0, 0);

switch (from)
  {
  case SEEK_SET0:
    newpos = offset;
    break;

  case SEEK_CUR1:
    newpos = file->pos + offset;
    break;

  case SEEK_END2:
    newpos = *lglen + offset;
    break;

  default:
    ERROR(EINVAL, 0)(hfs_error = (0), (*__errno()) = (22));
    return -1;
  }

if (newpos < 0)
  newpos = 0;
else if (newpos > *lglen)
  newpos = *lglen;

file->pos = newpos;

return newpos;
1437}

1439/*
* NAME:	hfs->close()
* DESCRIPTION:	close a file
*/
1443#ifdef APPLE_HYB1
1444/* extra args are used to set the start of the forks in the ISO volume */
1445int hfs_close(hfsfile *file, long dext, long rext)
1446{
int offset;
1448#else
1449int hfs_close(hfsfile *file)
1450{
1451#endif /* APPLE_HYB */
hfsvol *vol = file->vol;
int result = 0;

if (f_trunc(file) < 0 ||
    f_flush(file) < 0)
  result = -1;

1459#ifdef APPLE_HYB1
/* "start" of file is relative to the first available block */
offset = vol->hce->hfs_hdr_size + vol->hce->hfs_map_size;
/* update the "real" starting extent and re-flush the file */
if (dext)
  file->cat.u.fil.filExtRec[0].xdrStABN = (dext - offset)/vol->lpa;

if (rext)
  file->cat.u.fil.filRExtRec[0].xdrStABN = (rext - offset)/vol->lpa;

if (dext || rext)
  file->flags |= HFS_UPDATE_CATREC0x01;

if (f_flush(file) < 0)
  result = -1;
1474#endif /*APPLE_HYB */

if (file->prev)
  file->prev->next = file->next;
if (file->next)
  file->next->prev = file->prev;
if (file == vol->files)
  vol->files = file->next;

FREE(file)((file) ? (void) free((void *) file) : (void) 0);

return result;
1486}

1488/* High-Level Catalog Routines ============================================= */

1490/*
* NAME:	hfs->stat()
* DESCRIPTION:	return catalog information for an arbitrary path
*/
1494int hfs_stat(hfsvol *vol, char *path, hfsdirent *ent)
1495{
CatDataRec data;
long parid;
char name[HFS_MAX_FLEN31 + 1];

if (v_getvol(&vol) < 0 ||
    v_resolve(&vol, path, &data, &parid, name, 0) <= 0)
  return -1;

r_unpackdirent(parid, name, &data, ent);

return 0;
1507}

1509/*
* NAME:	hfs->fstat()
* DESCRIPTION:	return catalog information for an open file
*/
1513int hfs_fstat(hfsfile *file, hfsdirent *ent)
1514{
r_unpackdirent(file->parid, file->name, &file->cat, ent);

return 0;
1518}

1520/*
* NAME:	hfs->setattr()
* DESCRIPTION:	change a file's attributes
*/
1524int hfs_setattr(hfsvol *vol, char *path, hfsdirent *ent)
1525{
CatDataRec data;
node n;

if (v_getvol(&vol) < 0 ||
    v_resolve(&vol, path, &data, 0, 0, &n) <= 0)
  return -1;

if (vol->flags & HFS_READONLY0x01)
  {
    ERROR(EROFS, 0)(hfs_error = (0), (*__errno()) = (30));
    return -1;
  }

r_packdirent(&data, ent);

if (v_putcatrec(&data, &n) < 0)
  return -1;

return 0;
1545}

1547/*
* NAME:	hfs->fsetattr()
* DESCRIPTION:	change an open file's attributes
*/
1551int hfs_fsetattr(hfsfile *file, hfsdirent *ent)
1552{
if (file->vol->flags & HFS_READONLY0x01)
  {
    ERROR(EROFS, 0)(hfs_error = (0), (*__errno()) = (30));
    return -1;
  }

r_packdirent(&file->cat, ent);

file->flags |= HFS_UPDATE_CATREC0x01;

return 0;
1564}

1566/*
* NAME:	hfs->mkdir()
* DESCRIPTION:	create a new directory
*/
1570int hfs_mkdir(hfsvol *vol, char *path)
1571{
CatDataRec data;
long parid;
char name[HFS_MAX_FLEN31 + 1];
int found;

if (v_getvol(&vol) < 0)
  return -1;

found = v_resolve(&vol, path, &data, &parid, name, 0);
if (found < 0 || parid == 0)
  return -1;
else if (found)
  {
    ERROR(EEXIST, 0)(hfs_error = (0), (*__errno()) = (17));
    return -1;
  }

if (parid == HFS_CNID_ROOTPAR1)
  {
    ERROR(EINVAL, 0)(hfs_error = (0), (*__errno()) = (22));
    return -1;
  }

if (vol->flags & HFS_READONLY0x01)
  {
    ERROR(EROFS, 0)(hfs_error = (0), (*__errno()) = (30));
    return -1;
  }

if (v_newfolder(vol, parid, name) < 0)
  return -1;

return 0;
1605}

1607/*
* NAME:	hfs->rmdir()
* DESCRIPTION:	delete an empty directory
*/
1611int hfs_rmdir(hfsvol *vol, char *path)
1612{
CatKeyRec key;
CatDataRec data;
long parid;
char name[HFS_MAX_FLEN31 + 1];
unsigned char pkey[HFS_CATKEYLENsizeof(CatKeyRec)];

if (v_getvol(&vol) < 0 ||
    v_resolve(&vol, path, &data, &parid, name, 0) <= 0)
  return -1;

if (data.cdrType != cdrDirRec)
  {
    ERROR(ENOTDIR, 0)(hfs_error = (0), (*__errno()) = (20));
    return -1;
  }

if (data.u.dir.dirVal != 0)
  {
    ERROR(ENOTEMPTY, 0)(hfs_error = (0), (*__errno()) = (66));
    return -1;
  }

if (parid == HFS_CNID_ROOTPAR1)
  {
    ERROR(EINVAL, 0)(hfs_error = (0), (*__errno()) = (22));
    return -1;
  }

if (vol->flags & HFS_READONLY0x01)
  {
    ERROR(EROFS, 0)(hfs_error = (0), (*__errno()) = (30));
    return -1;
  }

/* delete directory record */

r_makecatkey(&key, parid, name);
r_packcatkey(&key, pkey, 0);

if (bt_delete(&vol->cat, pkey) < 0)
  return -1;

/* delete thread record */

r_makecatkey(&key, data.u.dir.dirDirID, "");
r_packcatkey(&key, pkey, 0);

if (bt_delete(&vol->cat, pkey) < 0 ||
    v_adjvalence(vol, parid, 1, -1) < 0)
  return -1;

return 0;
1665}

1667/*
* NAME:	hfs->create()
* DESCRIPTION:	create a new file
*/
1671int hfs_create(hfsvol *vol, char *path, char *type, char *creator)
1672{
CatKeyRec key;
CatDataRec data;
long id, parid;
char name[HFS_MAX_FLEN31 + 1];
unsigned char record[HFS_CATRECMAXLEN(sizeof(CatKeyRec) + sizeof(CatDataRec))];
int found, i, reclen;

if (v_getvol(&vol) < 0)
  return -1;

found = v_resolve(&vol, path, &data, &parid, name, 0);
if (found < 0 || parid == 0)
  return -1;
else if (found)
  {
    ERROR(EEXIST, 0)(hfs_error = (0), (*__errno()) = (17));
    return -1;
  }

if (parid == HFS_CNID_ROOTPAR1)
  {
    ERROR(EINVAL, 0)(hfs_error = (0), (*__errno()) = (22));
    return -1;
  }

if (vol->flags & HFS_READONLY0x01)
  {
    ERROR(EROFS, 0)(hfs_error = (0), (*__errno()) = (30));
    return -1;
  }

/* create file `name' in parent `parid' */

if (bt_space(&vol->cat, 1) < 0)
  return -1;

id = vol->mdb.drNxtCNID++;
vol->flags |= HFS_UPDATE_MDB0x10;

/* create file record */

data.cdrType   = cdrFilRec;
data.cdrResrv2 = 0;

data.u.fil.filFlags = 0;
data.u.fil.filTyp   = 0;

memset(&data.u.fil.filUsrWds, 0, sizeof(data.u.fil.filUsrWds));

data.u.fil.filUsrWds.fdType    = d_getl((unsigned char *) type);
data.u.fil.filUsrWds.fdCreator = d_getl((unsigned char *) creator);

data.u.fil.filFlNum  = id;
data.u.fil.filStBlk  = 0;
data.u.fil.filLgLen  = 0;
data.u.fil.filPyLen  = 0;
data.u.fil.filRStBlk = 0;
data.u.fil.filRLgLen = 0;
data.u.fil.filRPyLen = 0;
data.u.fil.filCrDat  = d_tomtime(time(0));
data.u.fil.filMdDat  = data.u.fil.filCrDat;
data.u.fil.filBkDat  = 0;

memset(&data.u.fil.filFndrInfo, 0, sizeof(data.u.fil.filFndrInfo));

data.u.fil.filClpSize = 0;

for (i = 0; i < 3; ++i)
  {
    data.u.fil.filExtRec[i].xdrStABN     = 0;
    data.u.fil.filExtRec[i].xdrNumABlks  = 0;

    data.u.fil.filRExtRec[i].xdrStABN    = 0;
    data.u.fil.filRExtRec[i].xdrNumABlks = 0;
  }

data.u.fil.filResrv = 0;

r_makecatkey(&key, parid, name);
r_packcatkey(&key, record, &reclen);
r_packcatdata(&data, HFS_RECDATA(record)((record) + ((1 + (*(unsigned char *) (record)) + 1) & ~1
)), &reclen);

if (bt_insert(&vol->cat, record, reclen) < 0 ||
    v_adjvalence(vol, parid, 0, 1) < 0)
  return -1;

return 0;
1760}

1762/*
* NAME:	hfs->delete()
* DESCRIPTION:	remove both forks of a file
*/
1766int hfs_delete(hfsvol *vol, char *path)
1767{
hfsfile file;
CatKeyRec key;
unsigned char pkey[HFS_CATKEYLENsizeof(CatKeyRec)];
int found;

if (v_getvol(&vol) < 0 ||
    v_resolve(&vol, path, &file.cat, &file.parid, file.name, 0) <= 0)
  return -1;

if (file.cat.cdrType != cdrFilRec)
  {
    ERROR(EISDIR, 0)(hfs_error = (0), (*__errno()) = (21));
    return -1;
  }

if (file.parid == HFS_CNID_ROOTPAR1)
  {
    ERROR(EINVAL, 0)(hfs_error = (0), (*__errno()) = (22));
    return -1;
  }

if (vol->flags & HFS_READONLY0x01)
  {
    ERROR(EROFS, 0)(hfs_error = (0), (*__errno()) = (30));
    return -1;
  }

/* free disk blocks */

file.vol   = vol;
file.flags = 0;

file.cat.u.fil.filLgLen  = 0;
file.cat.u.fil.filRLgLen = 0;

f_selectfork(&file, 0);
if (f_trunc(&file) < 0)
  return -1;

f_selectfork(&file, 1);
if (f_trunc(&file) < 0)
  return -1;

/* delete file record */

r_makecatkey(&key, file.parid, file.name);
r_packcatkey(&key, pkey, 0);

if (bt_delete(&vol->cat, pkey) < 0 ||
    v_adjvalence(vol, file.parid, 0, -1) < 0)
  return -1;

/* delete file thread, if any */

found = v_getfthread(vol, file.cat.u.fil.filFlNum, 0, 0)v_getthread(vol, file.cat.u.fil.filFlNum, 0, 0, cdrFThdRec);
if (found < 0)
  return -1;

if (found)
  {
    r_makecatkey(&key, file.cat.u.fil.filFlNum, "");
    r_packcatkey(&key, pkey, 0);

    if (bt_delete(&vol->cat, pkey) < 0)
return -1;
  }

return 0;
1836}

1838/*
* NAME:	hfs->rename()
* DESCRIPTION:	change the name of and/or move a file or directory
*/
1842int hfs_rename(hfsvol *vol, char *srcpath, char *dstpath)
1843{
hfsvol *srcvol;
CatDataRec src, dst;
long srcid, dstid;
CatKeyRec key;
char srcname[HFS_MAX_FLEN31 + 1], dstname[HFS_MAX_FLEN31 + 1];
unsigned char record[HFS_CATRECMAXLEN(sizeof(CatKeyRec) + sizeof(CatDataRec))];
int found, isdir, moving, reclen;
node n;

if (v_getvol(&vol) < 0 ||
    v_resolve(&vol, srcpath, &src, &srcid, srcname, 0) <= 0)
  return -1;

isdir  = (src.cdrType == cdrDirRec);
srcvol = vol;

found = v_resolve(&vol, dstpath, &dst, &dstid, dstname, 0);
if (found < 0)
  return -1;

if (vol != srcvol)
  {
    ERROR(EINVAL, "can't move across volumes")(hfs_error = ("can't move across volumes"), (*__errno()) = (22
));
    return -1;
  }

if (dstid == 0)
  {
    ERROR(ENOENT, "bad destination path")(hfs_error = ("bad destination path"), (*__errno()) = (2));
    return -1;
  }

if (found &&
    dst.cdrType == cdrDirRec &&
    dst.u.dir.dirDirID != src.u.dir.dirDirID)
  {
    dstid = dst.u.dir.dirDirID;
    strcpy(dstname, srcname);

    found = v_catsearch(vol, dstid, dstname, 0, 0, 0);
    if (found < 0)
return -1;
  }

moving = (srcid != dstid);

if (found)
  {
    char *ptr;

    ptr = strrchr(dstpath, ':');
    if (ptr == 0)
ptr = dstpath;
    else
++ptr;

    if (*ptr)
strcpy(dstname, ptr);

    if (! moving && strcmp(srcname, dstname) == 0)
return 0;  /* source and destination are the same */

    if (moving || d_relstring(srcname, dstname))
{
 ERROR(EEXIST, "can't use destination name")(hfs_error = ("can't use destination name"), (*__errno()) = (
17));
 return -1;
}
  }

/* can't move anything into the root directory's parent */

if (moving && dstid == HFS_CNID_ROOTPAR1)
  {
    ERROR(EINVAL, "can't move above root directory")(hfs_error = ("can't move above root directory"), (*__errno()
) = (22));
    return -1;
  }

if (moving && isdir)
  {
    long id;

    /* can't move root directory anywhere */

    if (src.u.dir.dirDirID == HFS_CNID_ROOTDIR2)
{
 ERROR(EINVAL, "can't move root directory")(hfs_error = ("can't move root directory"), (*__errno()) = (22
));
 return -1;
}

    /* make sure we aren't trying to move a directory inside itself */

    for (id = dstid; id != HFS_CNID_ROOTDIR2; id = dst.u.dthd.thdParID)
{
 if (id == src.u.dir.dirDirID)
   {
     ERROR(EINVAL, "can't move directory inside itself")(hfs_error = ("can't move directory inside itself"), (*__errno
()) = (22));
     return -1;
   }

 if (v_getdthread(vol, id, &dst, 0)v_getthread(vol, id, &dst, 0, cdrThdRec) <= 0)
   return -1;
}
  }

if (vol->flags & HFS_READONLY0x01)
  {
    ERROR(EROFS, 0)(hfs_error = (0), (*__errno()) = (30));
    return -1;
  }

/* change volume name */

if (dstid == HFS_CNID_ROOTPAR1)
  {
    if (strlen(dstname) > HFS_MAX_VLEN27)
{
 ERROR(ENAMETOOLONG, 0)(hfs_error = (0), (*__errno()) = (63));
 return -1;
}

    strcpy(vol->mdb.drVN, dstname);
    vol->flags |= HFS_UPDATE_MDB0x10;
  }

/* remove source record */

r_makecatkey(&key, srcid, srcname);
r_packcatkey(&key, record, 0);

if (bt_delete(&vol->cat, record) < 0)
  return -1;

/* insert destination record */

r_makecatkey(&key, dstid, dstname);
r_packcatkey(&key, record, &reclen);
r_packcatdata(&src, HFS_RECDATA(record)((record) + ((1 + (*(unsigned char *) (record)) + 1) & ~1
)), &reclen);

if (bt_insert(&vol->cat, record, reclen) < 0)
  return -1;

/* update thread record */

if (isdir)
  {
    if (v_getdthread(vol, src.u.dir.dirDirID, &dst, &n)v_getthread(vol, src.u.dir.dirDirID, &dst, &n, cdrThdRec
) <= 0)
return -1;

    dst.u.dthd.thdParID = dstid;
    strcpy(dst.u.dthd.thdCName, dstname);

    if (v_putcatrec(&dst, &n) < 0)
return -1;
  }
else
  {
    found = v_getfthread(vol, src.u.fil.filFlNum, &dst, &n)v_getthread(vol, src.u.fil.filFlNum, &dst, &n, cdrFThdRec
);
    if (found < 0)
return -1;

    if (found)
{
 dst.u.fthd.fthdParID = dstid;
 strcpy(dst.u.fthd.fthdCName, dstname);

 if (v_putcatrec(&dst, &n) < 0)
   return -1;
}
  }

/* update directory valences */

if (moving)
  {
    if (v_adjvalence(vol, srcid, isdir, -1) < 0 ||
 v_adjvalence(vol, dstid, isdir,  1) < 0)
return -1;
  }

return 0;
2024}
2025#ifdef APPLE_HYB1
2026/*
* NAME:        hfs->hfs_get_drAllocPtr()
* DESCRIPTION: get the current start of next allocation search 
*/
2030unsigned short
2031hfs_get_drAllocPtr(hfsfile *file)
2032{
return(file->vol->mdb.drAllocPtr);
2034}

2036/*
* NAME:        hfs->hfs_set_drAllocPtr()
* DESCRIPTION: set the current start of next allocation search 
*/
2040int
2041hfs_set_drAllocPtr(hfsfile *file, unsigned short drAllocPtr, int size)
2042{
hfsvol *vol = file->vol;
int result = 0;

/* truncate the current fork */
if (f_trunc(file) < 0 ||
    f_flush(file) < 0)
  result = -1;

/* convert the fork size into allocation blocks */
size = (size + vol->mdb.drAlBlkSiz - 1)/vol->mdb.drAlBlkSiz;

/* set the start of next allocation search to be after this fork */
vol->mdb.drAllocPtr = drAllocPtr + size;

vol->flags |= HFS_UPDATE_MDB0x10;

return result;
2060}

2062/*
* NAME:        hfs->vsetbless()
* DESCRIPTION: set blessed folder
*
* adapted from vsetattr() from v3.2.6
*/
2068void
2069hfs_vsetbless(hfsvol *vol, unsigned long cnid) 
2070{ 
vol->mdb.drFndrInfo[0] = cnid;

vol->flags |= HFS_UPDATE_MDB0x10;
2074}
2075#endif /* APPLE_HYB */