/* $NetBSD: hfs_vnops.c,v 1.40 2022/08/06 18:26:42 andvar Exp $ */

/* $NetBSD: hfs_vnops.c,v 1.40 2022/08/06 18:26:42 andvar Exp $ */

/*-
* Copyright (c) 2005, 2007 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Yevgeny Binder and Dieter Baron.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

/*
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This code is derived from software donated to Berkeley by
* Jan-Simon Pendry.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

/*
* Copyright (c) 1982, 1986, 1989, 1993, 1995
* The Regents of the University of California. All rights reserved.
* (c) UNIX System Laboratories, Inc.
* All or some portions of this file are derived from material licensed
* to the University of California by American Telephone and Telegraph
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
* the permission of UNIX System Laboratories, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

/*
* Apple HFS+ filesystem
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: hfs_vnops.c,v 1.40 2022/08/06 18:26:42 andvar Exp $");

#ifdef _KERNEL_OPT
#include "opt_ipsec.h"
#endif

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/vmmeter.h>
#include <sys/time.h>
#include <sys/proc.h>
#include <sys/vnode.h>
#include <sys/malloc.h>
#include <sys/pool.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/mount.h>
#include <sys/namei.h>
#include <sys/buf.h>
#include <sys/dirent.h>
#include <sys/msgbuf.h>

#include <miscfs/fifofs/fifo.h>
#include <miscfs/specfs/specdev.h>

#include <fs/hfs/hfs.h>
#include <fs/hfs/unicode.h>

#include <miscfs/genfs/genfs.h>

int hfs_vop_parsepath(void *);
int hfs_vop_lookup(void *);
int hfs_vop_open(void *);
int hfs_vop_close(void *);
int hfs_vop_access(void *);
int hfs_vop_getattr(void *);
int hfs_vop_setattr(void *);
int hfs_vop_bmap(void *);
int hfs_vop_read(void *);
int hfs_vop_readdir(void *);
int hfs_vop_readlink(void *);
int hfs_vop_reclaim(void *);
int hfs_vop_print(void *);

#ifdef HFS_DEBUG
#define DPRINTF(a) printf a
#else
#define DPRINTF(a)
#endif

int (**hfs_vnodeop_p) (void *);
const struct vnodeopv_entry_desc hfs_vnodeop_entries[] = {
{ &vop_default_desc, vn_default_error },
{ &vop_parsepath_desc, genfs_parsepath }, /* parsepath */
{ &vop_lookup_desc, hfs_vop_lookup }, /* lookup */
{ &vop_create_desc, genfs_eopnotsupp }, /* create */
{ &vop_whiteout_desc, genfs_eopnotsupp }, /* whiteout */
{ &vop_mknod_desc, genfs_eopnotsupp }, /* mknod */
{ &vop_open_desc, hfs_vop_open }, /* open */
{ &vop_close_desc, hfs_vop_close }, /* close */
{ &vop_access_desc, hfs_vop_access }, /* access */
{ &vop_accessx_desc, genfs_accessx }, /* accessx */
{ &vop_getattr_desc, hfs_vop_getattr }, /* getattr */
{ &vop_setattr_desc, hfs_vop_setattr }, /* setattr */
{ &vop_read_desc, hfs_vop_read }, /* read */
{ &vop_write_desc, genfs_eopnotsupp }, /* write */
{ &vop_fallocate_desc, genfs_eopnotsupp }, /* fallocate */
{ &vop_fdiscard_desc, genfs_eopnotsupp }, /* fdiscard */
{ &vop_ioctl_desc, genfs_eopnotsupp }, /* ioctl */
{ &vop_fcntl_desc, genfs_fcntl }, /* fcntl */
{ &vop_poll_desc, genfs_eopnotsupp }, /* poll */
{ &vop_kqfilter_desc, genfs_kqfilter }, /* kqfilter */
{ &vop_revoke_desc, genfs_eopnotsupp }, /* revoke */
{ &vop_mmap_desc, genfs_mmap }, /* mmap */
{ &vop_fsync_desc, genfs_nullop }, /* fsync */
{ &vop_seek_desc, genfs_seek }, /* seek */
{ &vop_remove_desc, genfs_eopnotsupp }, /* remove */
{ &vop_link_desc, genfs_eopnotsupp }, /* link */
{ &vop_rename_desc, genfs_eopnotsupp }, /* rename */
{ &vop_mkdir_desc, genfs_eopnotsupp }, /* mkdir */
{ &vop_rmdir_desc, genfs_eopnotsupp }, /* rmdir */
{ &vop_symlink_desc, genfs_eopnotsupp }, /* symlink */
{ &vop_readdir_desc, hfs_vop_readdir }, /* readdir */
{ &vop_readlink_desc, hfs_vop_readlink }, /* readlink */
{ &vop_abortop_desc, genfs_abortop }, /* abortop */
{ &vop_inactive_desc, genfs_eopnotsupp }, /* inactive */
{ &vop_reclaim_desc, hfs_vop_reclaim }, /* reclaim */
{ &vop_lock_desc, genfs_lock }, /* lock */
{ &vop_unlock_desc, genfs_unlock }, /* unlock */
{ &vop_bmap_desc, hfs_vop_bmap }, /* bmap */
{ &vop_strategy_desc, genfs_eopnotsupp }, /* strategy */
{ &vop_print_desc, hfs_vop_print }, /* print */
{ &vop_islocked_desc, genfs_islocked }, /* islocked */
{ &vop_pathconf_desc, genfs_eopnotsupp }, /* pathconf */
{ &vop_advlock_desc, genfs_eopnotsupp }, /* advlock */
{ &vop_bwrite_desc, genfs_eopnotsupp }, /* bwrite */
{ &vop_getpages_desc, genfs_getpages }, /* getpages */
{ &vop_putpages_desc, genfs_putpages }, /* putpages */
{ &vop_openextattr_desc, genfs_eopnotsupp }, /* openextattr */
{ &vop_closeextattr_desc, genfs_eopnotsupp }, /* closeextattr */
{ &vop_getextattr_desc, genfs_eopnotsupp }, /* getextattr */
{ &vop_setextattr_desc, genfs_eopnotsupp }, /* setextattr */
{ &vop_listextattr_desc, genfs_eopnotsupp }, /* listextattr */
{ &vop_deleteextattr_desc, genfs_eopnotsupp }, /* deleteextattr */
{ NULL, NULL }
};
const struct vnodeopv_desc hfs_vnodeop_opv_desc =
{ &hfs_vnodeop_p, hfs_vnodeop_entries };

int (**hfs_specop_p) (void *);
const struct vnodeopv_entry_desc hfs_specop_entries[] = {
{ &vop_default_desc, vn_default_error },
GENFS_SPECOP_ENTRIES,
{ &vop_close_desc, spec_close }, /* close */
{ &vop_access_desc, hfs_vop_access }, /* access */
{ &vop_accessx_desc, genfs_accessx }, /* accessx */
{ &vop_getattr_desc, hfs_vop_getattr }, /* getattr */
{ &vop_setattr_desc, hfs_vop_setattr }, /* setattr */
{ &vop_read_desc, spec_read }, /* read */
{ &vop_write_desc, spec_write }, /* write */
{ &vop_fcntl_desc, genfs_fcntl }, /* fcntl */
{ &vop_fsync_desc, spec_fsync }, /* fsync */
{ &vop_inactive_desc, genfs_eopnotsupp }, /* inactive */
{ &vop_reclaim_desc, hfs_vop_reclaim }, /* reclaim */
{ &vop_lock_desc, genfs_lock }, /* lock */
{ &vop_unlock_desc, genfs_unlock }, /* unlock */
{ &vop_print_desc, hfs_vop_print }, /* print */
{ &vop_islocked_desc, genfs_islocked }, /* islocked */
{ &vop_bwrite_desc, vn_bwrite }, /* bwrite */
#if 0
{ &vop_openextattr_desc, hfs_openextattr }, /* openextattr */
{ &vop_closeextattr_desc, hfs_closeextattr }, /* closeextattr */
{ &vop_getextattr_desc, hfs_getextattr }, /* getextattr */
{ &vop_setextattr_desc, hfs_setextattr }, /* setextattr */
{ &vop_listextattr_desc, hfs_listextattr }, /* listextattr */
{ &vop_deleteextattr_desc, hfs_deleteextattr }, /* deleteextattr */
#endif
{ NULL, NULL }
};
const struct vnodeopv_desc hfs_specop_opv_desc =
{ &hfs_specop_p, hfs_specop_entries };

int (**hfs_fifoop_p) (void *);
const struct vnodeopv_entry_desc hfs_fifoop_entries[] = {
{ &vop_default_desc, vn_default_error },
GENFS_FIFOOP_ENTRIES,
{ &vop_close_desc, vn_fifo_bypass }, /* close */
{ &vop_access_desc, hfs_vop_access }, /* access */
{ &vop_accessx_desc, genfs_accessx }, /* accessx */
{ &vop_getattr_desc, hfs_vop_getattr }, /* getattr */
{ &vop_setattr_desc, hfs_vop_setattr }, /* setattr */
{ &vop_read_desc, vn_fifo_bypass }, /* read */
{ &vop_write_desc, vn_fifo_bypass }, /* write */
{ &vop_fcntl_desc, genfs_fcntl }, /* fcntl */
{ &vop_fsync_desc, vn_fifo_bypass }, /* fsync */
{ &vop_inactive_desc, genfs_eopnotsupp }, /* inactive */
{ &vop_reclaim_desc, hfs_vop_reclaim }, /* reclaim */
{ &vop_lock_desc, genfs_lock }, /* lock */
{ &vop_unlock_desc, genfs_unlock }, /* unlock */
{ &vop_strategy_desc, vn_fifo_bypass }, /* strategy */
{ &vop_print_desc, hfs_vop_print }, /* print */
{ &vop_islocked_desc, genfs_islocked }, /* islocked */
{ &vop_bwrite_desc, vn_bwrite }, /* bwrite */
#if 0
{ &vop_openextattr_desc, hfs_openextattr }, /* openextattr */
{ &vop_closeextattr_desc, hfs_closeextattr }, /* closeextattr */
{ &vop_getextattr_desc, hfs_getextattr }, /* getextattr */
{ &vop_setextattr_desc, hfs_setextattr }, /* setextattr */
{ &vop_listextattr_desc, hfs_listextattr }, /* listextattr */
{ &vop_deleteextattr_desc, hfs_deleteextattr }, /* deleteextattr */
#endif
{ NULL, NULL }
};
const struct vnodeopv_desc hfs_fifoop_opv_desc =
{ &hfs_fifoop_p, hfs_fifoop_entries };

int
hfs_vop_parsepath(void *v)
{
struct vop_parsepath_args /* {
struct vnode *a_dvp;
const char *a_name;
size_t *a_retval;
} */ *ap = v;
size_t len;
int error;

error = genfs_parsepath(v);
if (error) {
return error;
}

len = *ap->a_retval;
if (!strcmp(ap->a_name + len, "/rsrc")) {
*ap->a_retval += 5;
}
return 0;
}

int
hfs_vop_lookup(void *v)
{
struct vop_lookup_v2_args /* {
struct vnode * a_dvp;
struct vnode ** a_vpp;
struct componentname * a_cnp;
} */ *ap = v;
struct componentname *cnp;
struct hfsnode *dp; /* hfsnode for directory being searched */
kauth_cred_t cred;
struct vnode **vpp; /* resultant vnode */
struct vnode *tdp; /* returned by VFS_VGET */
struct vnode *vdp; /* vnode for directory being searched */
hfs_catalog_key_t key; /* hfs+ catalog search key for requested child */
hfs_catalog_keyed_record_t rec; /* catalog record of requested child */
size_t namelen;
int use_resource_fork = 0;
unichar_t* unicn; /* name of component, in Unicode */
const char *pname;
int error;
int flags;
int result; /* result of libhfs operations */

DPRINTF(("VOP = hfs_vop_lookup()\n"));

cnp = ap->a_cnp;
cred = cnp->cn_cred;
vdp = ap->a_dvp;
dp = VTOH(vdp);
error = 0;
pname = cnp->cn_nameptr;
result = 0;
unicn = NULL;
vpp = ap->a_vpp;
*vpp = NULL;

flags = cnp->cn_flags;

/*
* Check accessibility of directory.
*/
if ((error = VOP_ACCESS(vdp, VEXEC, cred)) != 0)
return error;

if ((flags & ISLASTCN) && (vdp->v_mount->mnt_flag & MNT_RDONLY) &&
(cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
return EROFS;

/*
* We now have a segment name to search for, and a directory to search.
*
* Before tediously performing a linear scan of the directory,
* check the name cache to see if the directory/name pair
* we are looking for is known already.
*/
/* XXX Cache disabled until we can make sure it works. */
#if 0
if ((error = cache_lookup(vdp, vpp, cnp)) >= 0)
return error;
#endif

#if 0
if (cnp->cn_namelen == 1 && *pname == '.') {
*vpp = vdp;
vref(vdp);
return 0;
}
#endif

if (flags & ISDOTDOT) {
DPRINTF(("DOTDOT "));
error = hfs_vget_internal(vdp->v_mount, dp->h_parent,
HFS_RSRCFORK, &tdp);
if (error != 0)
goto error;
*vpp = tdp;
#if 0
} else if (dp->h_rec.u.cnid == rec.file.u.cnid) {
#endif
} else if (cnp->cn_namelen == 1 && pname[0] == '.') {
DPRINTF(("DOT "));
vref(vdp); /* we want ourself, ie "." */
*vpp = vdp;
} else {
hfs_callback_args cbargs;
uint8_t len, ni;

hfslib_init_cbargs(&cbargs);

namelen = cnp->cn_namelen;
if (namelen > 5 &&
!strcmp(cnp->cn_nameptr + namelen - 5, "/rsrc")) {
namelen -= 5;
use_resource_fork = 1;
}

/* XXX: when decomposing, string could grow
and we have to handle overflow */
unicn = malloc(namelen * sizeof(unicn[0]), M_TEMP, M_WAITOK);
len = utf8_to_utf16(unicn, namelen,
cnp->cn_nameptr, namelen, 0, NULL);
for (ni = 0; ni < len; ni++)
if (unicn[ni] == (unichar_t)':')
unicn[ni] = (unichar_t)'/';
/* XXX: check conversion errors? */
if (hfslib_make_catalog_key(VTOH(vdp)->h_rec.u.cnid, len, unicn,
&key) == 0) {
DPRINTF(("ERROR in hfslib_make_catalog_key\n"));
error = EINVAL;
goto error;
}

result = hfslib_find_catalog_record_with_key(&dp->h_hmp->hm_vol,
&key, &rec, &cbargs);
if (result > 0) {
error = EINVAL;
goto error;
}
if (result < 0) {
if (cnp->cn_nameiop == CREATE)
error = EROFS;
else
error = ENOENT;
goto error;
}

if (rec.file.user_info.file_type == HFS_HARD_LINK_FILE_TYPE
&& rec.file.user_info.file_creator == HFS_HFSLUS_CREATOR) {
if (hfslib_get_hardlink(&dp->h_hmp->hm_vol,
rec.file.bsd.special.inode_num,
&rec, &cbargs) != 0) {
error = EINVAL;
goto error;
}
}

if (rec.type == HFS_REC_FILE
&& use_resource_fork
&& rec.file.rsrc_fork.logical_size > 0) {
/* advance namei next pointer to end of string */
error = hfs_vget_internal(vdp->v_mount, rec.file.cnid,
HFS_RSRCFORK, &tdp);
} else
error = hfs_vget_internal(vdp->v_mount, rec.file.cnid,
HFS_DATAFORK, &tdp);
if (error != 0)
goto error;
*vpp = tdp;
}
DPRINTF(("\n"));
/*
* Insert name into cache if appropriate.
*/
/* XXX Cache disabled until we can make sure it works. */
#if 0
cache_enter(vdp, *vpp, cnp);
#endif

error = 0;

/* FALLTHROUGH */
error:
if (unicn != NULL)
free(unicn, M_TEMP);

return error;
}

int
hfs_vop_open(void *v)
{
#if 0
struct vop_open_args /* {
struct vnode *a_vp;
int a_mode;
kauth_cred_t a_cred;
} */ *ap = v;
struct hfsnode *hn = VTOH(ap->a_vp);
#endif
DPRINTF(("VOP = hfs_vop_open()\n"));

/*
* XXX This is a good place to read and cache the file's extents to
* XXX avoid doing it upon every read/write. Must however keep the
* XXX cache in sync when the file grows/shrinks. (So would that go
* XXX in vop_truncate?)
*/

return 0;
}

int
hfs_vop_close(void *v)
{
#if 0
struct vop_close_args /* {
struct vnode *a_vp;
int a_fflag;
kauth_cred_t a_cred;
} */ *ap = v;
struct hfsnode *hn = VTOH(ap->a_vp);
#endif
DPRINTF(("VOP = hfs_vop_close()\n"));

/* Release extents cache here. */

return 0;
}

static int
hfs_check_possible(struct vnode *vp, accmode_t accmode)
{

/*
* Disallow writes on files, directories, and symlinks
* since we have no write support yet.
*/

if (accmode & VWRITE) {
switch (vp->v_type) {
case VDIR:
case VLNK:
case VREG:
return EROFS;
default:
break;
}
}

return 0;
}

static int
hfs_check_permitted(vnode_t *vp, struct vattr *va, accmode_t accmode,
kauth_cred_t cred)
{

return kauth_authorize_vnode(cred, KAUTH_ACCESS_ACTION(accmode,
va->va_type, va->va_mode), vp, NULL, genfs_can_access(vp, cred,
va->va_uid, va->va_gid, va->va_mode, NULL, accmode));
}

int
hfs_vop_access(void *v)
{
struct vop_access_args /* {
struct vnode *a_vp;
int a_accmode;
kauth_cred_t a_cred;
} */ *ap = v;
struct vattr va;
int error;

DPRINTF(("VOP = hfs_vop_access()\n"));

error = hfs_check_possible(ap->a_vp, ap->a_accmode);
if (error)
return error;

if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred)) != 0)
return error;

error = hfs_check_permitted(ap->a_vp, &va, ap->a_accmode, ap->a_cred);

return error;
}

int
hfs_vop_getattr(void *v)
{
struct vop_getattr_args /* {
struct vnode *a_vp;
struct vattr *a_vap;
struct ucred *a_cred;
} */ *ap = v;
struct vnode *vp;
struct hfsnode *hp;
struct vattr *vap;
hfs_bsd_data_t *bsd;
hfs_fork_t *fork;

DPRINTF(("VOP = hfs_vop_getattr()\n"));

vp = ap->a_vp;
hp = VTOH(vp);
vap = ap->a_vap;

vattr_null(vap);

/*
* XXX Cannot trust permissions/modes/flags stored in an HFS+ catalog
* XXX record those values are not set on files created under Mac OS 9.
*/
vap->va_type = ap->a_vp->v_type;
if (hp->h_rec.u.rec_type == HFS_REC_FILE) {
hfs_file_record_t *f = &hp->h_rec.file;
if (hp->h_fork == HFS_RSRCFORK)
fork = &f->rsrc_fork;
else
fork = &f->data_fork;
vap->va_fileid = f->cnid;
bsd = &f->bsd;
vap->va_bytes = fork->total_blocks * HFS_BLOCKSIZE(vp);
vap->va_size = fork->logical_size;
hfs_time_to_timespec(f->date_created, &vap->va_ctime);
hfs_time_to_timespec(f->date_content_mod, &vap->va_mtime);
hfs_time_to_timespec(f->date_accessed, &vap->va_atime);
vap->va_nlink = 1;
} else if (hp->h_rec.u.rec_type == HFS_REC_FLDR) {
hfs_folder_record_t *f = &hp->h_rec.folder;
vap->va_fileid = hp->h_rec.folder.cnid;
bsd = &f->bsd;
vap->va_size = 512; /* XXX Temporary */
vap->va_bytes = 512; /* XXX Temporary */
hfs_time_to_timespec(f->date_created, &vap->va_ctime);
hfs_time_to_timespec(f->date_content_mod,&vap->va_mtime);
hfs_time_to_timespec(f->date_accessed, &vap->va_atime);
vap->va_nlink = 2; /* XXX */
} else {
DPRINTF(("hfs+: hfs_vop_getattr(): invalid record type %i",
hp->h_rec.u.rec_type));
return EINVAL;
}

if ((bsd->file_mode & S_IFMT) == 0) {
/* no bsd permissions recorded, use default values */
if (hp->h_rec.u.rec_type == HFS_REC_FILE)
vap->va_mode = (S_IFREG | HFS_DEFAULT_FILE_MODE);
else
vap->va_mode = (S_IFDIR | HFS_DEFAULT_DIR_MODE);
vap->va_uid = HFS_DEFAULT_UID;
vap->va_gid = HFS_DEFAULT_GID;
} else {
vap->va_mode = bsd->file_mode;
vap->va_uid = bsd->owner_id;
vap->va_gid = bsd->group_id;
if ((vap->va_mode & S_IFMT) == S_IFCHR
|| (vap->va_mode & S_IFMT) == S_IFBLK) {
vap->va_rdev
= HFS_CONVERT_RDEV(bsd->special.raw_device);
}
else if (bsd->special.link_count != 0) {
/* XXX: only if in metadata directory */
vap->va_nlink = bsd->special.link_count;
}
}

vap->va_fsid = hp->h_dev;
vap->va_blocksize = hp->h_hmp->hm_vol.vh.block_size;
vap->va_gen = 1;
vap->va_flags = 0;

return 0;
}

int
hfs_vop_setattr(void *v)
{
struct vop_setattr_args /* {
struct vnode *a_vp;
struct vattr *a_vap;
kauth_cred_t a_cred;
} */ *ap = v;
struct vattr *vap;
struct vnode *vp;

vap = ap->a_vap;
vp = ap->a_vp;

/*
* Check for unsettable attributes.
*/
if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) ||
(vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
(vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) ||
((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) {
return EINVAL;
}

/* XXX: needs revisiting for write support */
if (vap->va_flags != VNOVAL
|| vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL
|| vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL
|| vap->va_birthtime.tv_sec != VNOVAL) {
return EROFS;
}

if (vap->va_size != VNOVAL) {
/*
* Disallow write attempts on read-only file systems;
* unless the file is a socket, fifo, or a block or
* character device resident on the file system.
*/
switch (vp->v_type) {
case VDIR:
return EISDIR;
case VCHR:
case VBLK:
case VFIFO:
break;
case VREG:
return EROFS;
default:
return EOPNOTSUPP;
}
}

return 0;
}

int
hfs_vop_bmap(void *v)
{
struct vop_bmap_args /* {
struct vnode *a_vp;
daddr_t a_bn;
struct vnode **a_vpp;
daddr_t *a_bnp;
int *a_runp;
} */ *ap = v;
struct vnode *vp;
struct hfsnode *hp;
daddr_t lblkno;
hfs_callback_args cbargs;
hfs_libcb_argsread argsread;
hfs_extent_descriptor_t *extents;
uint16_t numextents, i;
int bshift;

vp = ap->a_vp;
hp = VTOH(vp);
lblkno = ap->a_bn;
bshift = vp->v_mount->mnt_fs_bshift;

/*
* Check for underlying vnode requests and ensure that logical
* to physical mapping is requested.
*/
if (ap->a_vpp != NULL)
*ap->a_vpp = hp->h_devvp;
if (ap->a_bnp == NULL)
return 0;

hfslib_init_cbargs(&cbargs);
argsread.cred = NULL;
argsread.l = NULL;
cbargs.read = &argsread;

numextents = hfslib_get_file_extents(&hp->h_hmp->hm_vol,
hp->h_rec.u.cnid, hp->h_fork, &extents, &cbargs);

/* XXX: is this correct for 0-length files? */
if (numextents == 0)
return EBADF;

for (i = 0; i < numextents; i++) {
if (lblkno < extents[i].block_count)
break;
lblkno -= extents[i].block_count;
}

if (i == numextents) {
/* XXX: block number past EOF */
i--;
lblkno += extents[i].block_count;
}

*ap->a_bnp = ((extents[i].start_block + lblkno) << (bshift-DEV_BSHIFT))
+ (hp->h_hmp->hm_vol.offset >> DEV_BSHIFT);

if (ap->a_runp) {
int nblk;

nblk = extents[i].block_count - lblkno - 1;
if (nblk <= 0)
*ap->a_runp = 0;
else if (nblk > MAXBSIZE >> bshift)
*ap->a_runp = (MAXBSIZE >> bshift) - 1;
else
*ap->a_runp = nblk;
}

free(extents, M_TEMP);

return 0;
}

int
hfs_vop_read(void *v)
{
struct vop_read_args /* {
struct vnode *a_vp;
struct uio *a_uio;
int a_ioflag;
kauth_cred_t a_cred;
} */ *ap = v;
struct vnode *vp;
struct hfsnode *hp;
struct uio *uio;
uint64_t fsize; /* logical size of file */
int advice;
int error;

vp = ap->a_vp;
hp = VTOH(vp);
uio = ap->a_uio;
if (hp->h_fork == HFS_RSRCFORK)
fsize = hp->h_rec.file.rsrc_fork.logical_size;
else
fsize = hp->h_rec.file.data_fork.logical_size;
error = 0;
advice = IO_ADV_DECODE(ap->a_ioflag);

if (uio->uio_offset < 0)
return EINVAL;

if (uio->uio_resid == 0 || uio->uio_offset >= fsize)
return 0;

if (vp->v_type != VREG && vp->v_type != VLNK)
return EINVAL;

error = 0;
while (uio->uio_resid > 0 && error == 0) {
vsize_t len;

len = MIN(uio->uio_resid, fsize - uio->uio_offset);
if (len == 0)
break;

error = ubc_uiomove(&vp->v_uobj, uio, len, advice,
UBC_READ | UBC_PARTIALOK | UBC_VNODE_FLAGS(vp));
}

return error;
}

int
hfs_vop_readdir(void *v)
{
struct vop_readdir_args /* {
struct vnode *a_vp;
struct uio *a_uio;
kauth_cred_t a_cred;
int *a_eofflag;
off_t **a_cookies;
int a_*ncookies;
} */ *ap = v;

DPRINTF(("VOP = hfs_vop_readdir()\n"));

struct dirent curent; /* the dirent entry we are constructing */
struct hfsnode *hp;
hfs_catalog_keyed_record_t *children;
hfs_unistr255_t *childnames;
hfs_callback_args cbargs;
hfs_libcb_argsread argsread;
struct uio *uio;
off_t bufoff; /* offset in buffer relative to start of dirents */
uint32_t numchildren;
uint32_t curchild; /* index of child we are stuffing into dirent */
size_t namlen, ni;
int error;
int i; /* dummy variable */

bufoff = 0;
children = NULL;
error = 0;
numchildren = 0;
hp = VTOH(ap->a_vp);
uio = ap->a_uio;

if (uio->uio_offset < 0)
return EINVAL;
if (ap->a_eofflag != NULL)
*ap->a_eofflag = 0;

/* XXX Inform that we don't support NFS, for now. */
#if 0
if(ap->a_eofflag != NULL || ap->a_cookies != NULL ||
ap->a_ncookies != NULL)
return EOPNOTSUPP;
#endif
DPRINTF(("READDIR uio: offset=%td, resid=%zu\n",
uio->uio_offset, uio->uio_resid));
hfslib_init_cbargs(&cbargs);
argsread.cred = ap->a_cred;
argsread.l = NULL;
cbargs.read = &argsread;

/* XXX Should we cache this? */
if (hfslib_get_directory_contents(&hp->h_hmp->hm_vol, hp->h_rec.u.cnid,
&children, &childnames, &numchildren, &cbargs) != 0) {
DPRINTF(("ENOENT\n"));
error = ENOENT;
goto error;
}

DPRINTF(("numchildren = %u\n", numchildren));
for (curchild = 0; curchild < numchildren && uio->uio_resid > 0;
curchild++) {
namlen = utf16_to_utf8(curent.d_name, NAME_MAX,
childnames[curchild].unicode, childnames[curchild].length,
0, NULL);
/* XXX: check conversion errors? */
if (namlen > NAME_MAX) {
/* XXX: how to handle name too long? */
continue;
}
for (ni = 0; ni < namlen; ni++)
if (curent.d_name[ni] == '/')
curent.d_name[ni] = ':';
curent.d_namlen = namlen;
curent.d_reclen = _DIRENT_SIZE(&curent);

/* Skip to desired dirent. */
bufoff += curent.d_reclen;
if (bufoff - curent.d_reclen < uio->uio_offset)
continue;

/* Make sure we don't return partial entries. */
if (uio->uio_resid < curent.d_reclen) {
DPRINTF(("PARTIAL ENTRY\n"));
if (ap->a_eofflag != NULL)
*ap->a_eofflag = 1;
break;
}

curent.d_fileno = children[curchild].file.cnid;
switch (hfs_catalog_keyed_record_vtype(children+curchild)) {
case VREG:
curent.d_type = DT_REG;
break;
case VDIR:
curent.d_type = DT_DIR;
break;
case VBLK:
curent.d_type = DT_BLK;
break;
case VCHR:
curent.d_type = DT_CHR;
break;
case VLNK:
curent.d_type = DT_LNK;
break;
case VSOCK:
curent.d_type = DT_SOCK;
break;
case VFIFO:
curent.d_type = DT_FIFO;
break;
default:
curent.d_type = DT_UNKNOWN;
break;
}
DPRINTF(("curchildname = %s\t\t", curchildname));
/* pad curent.d_name to aligned byte boundary */
for (i = curent.d_namlen;
i < curent.d_reclen - _DIRENT_NAMEOFF(&curent); i++)
curent.d_name[i] = 0;

DPRINTF(("curent.d_name = %s\n", curent.d_name));

if ((error = uiomove(&curent, curent.d_reclen, uio)) != 0)
goto error;
}

/* FALLTHROUGH */

error:
if (numchildren > 0) {
if (children != NULL)
free(children, M_TEMP);
if (childnames != NULL)
free(childnames, M_TEMP);
}

if (error) {
DPRINTF(("ERROR = %i\n", error));
}

return error;
}

int
hfs_vop_readlink(void *v) {
struct vop_readlink_args /* {
struct vnode *a_vp;
struct uio *a_uio;
kauth_cred_t a_cred;
} */ *ap = v;

return VOP_READ(ap->a_vp, ap->a_uio, 0, ap->a_cred);
}

int
hfs_vop_reclaim(void *v)
{
struct vop_reclaim_v2_args /* {
struct vnode *a_vp;
} */ *ap = v;
struct vnode *vp;
struct hfsnode *hp;

VOP_UNLOCK(ap->a_vp);

DPRINTF(("VOP = hfs_vop_reclaim()\n"));

vp = ap->a_vp;
hp = VTOH(vp);

/* Decrement the reference count to the volume's device. */
if (hp->h_devvp) {
vrele(hp->h_devvp);
hp->h_devvp = 0;
}

genfs_node_destroy(vp);
pool_put(&hfs_node_pool, hp);
vp->v_data = NULL;

return 0;
}

int
hfs_vop_print(void *v)
{
struct vop_print_args /* {
struct vnode *a_vp;
} */ *ap = v;
struct vnode *vp;
struct hfsnode *hp;

DPRINTF(("VOP = hfs_vop_print()\n"));

vp = ap->a_vp;
hp = VTOH(vp);

printf("dummy = %X\n", (unsigned)hp->dummy);
printf("\n");

return 0;
}