[thirdparty/xfsprogs-dev.git] / libhandle / handle.c

/*
 * Copyright (c) 1995-2001 Silicon Graphics, Inc.  All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2.1 of the GNU Lesser General Public License
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Further, this software is distributed without any warranty that it is
 * free of the rightful claim of any third person regarding infringement
 * or the like.  Any license provided herein, whether implied or
 * otherwise, applies only to this software file.  Patent licenses, if
 * any, provided herein do not apply to combinations of this program with
 * other software, or any other product whatsoever.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not, write the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307,
 * USA.
 *
 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
 * Mountain View, CA  94043, or:
 *
 * http://www.sgi.com
 *
 * For further information regarding this notice, see:
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */

#include <libxfs.h>
#include <sys/stat.h>
#include <sys/ioctl.h>

/* attributes.h (purposefully) unavailable to xfsprogs, make do */
struct attrlist_cursor { __u32 opaque[4]; };

#include <handle.h>

/* just pick a value we know is more than big enough */
#define	MAXHANSIZ	64

/*
 *  The actual content of a handle is supposed to be opaque here.
 *  But, to do handle_to_fshandle, we need to know what it is.  Sigh.
 *  However we can get by with knowing only that the first 8 bytes of
 *  a file handle are the file system ID, and that a file system handle
 *  consists of only those 8 bytes.
 */

#define	FSIDSIZE	8

typedef union {
	int	fd;
	char	*path;
} comarg_t;

int
obj_to_handle (
	int		fsfd,
	unsigned int	opcode,
	comarg_t	obj,
	void		**hanp,
	size_t		*hlen);


/*
 * Filesystem Handle -> Open File Descriptor Cache
 *
 * Maps filesystem handles to a corresponding open file descriptor for that
 * filesystem. We need this because we're doing handle operations via ioctl
 * and we need to remember the open file descriptor for each filesystem.
 */

struct fdhash {
	int	fsfd;
	char	fsh[FSIDSIZE];
	struct fdhash *fnxt;
};

struct fdhash *fdhash_head = NULL;

int
path_to_fshandle (
	char		*path,		/* input,  path to convert */
	void		**hanp,		/* output, pointer to data */
	size_t		*hlen)		/* output, size of returned data */
{
	int		result;
	int		fd;
	comarg_t	obj;
	struct fdhash	*fdhp;

	fd = open(path, O_RDONLY);

	if (fd <  0) {
		perror(path);
		exit(1);
	}

	obj.path = path;

	result = obj_to_handle (fd, XFS_IOC_PATH_TO_FSHANDLE,
				obj, hanp, hlen);

	if (result >= 0) {
		fdhp = malloc(sizeof(struct fdhash));

		if (fdhp == NULL) {
			errno = ENOMEM;
			return -1;
		}

		fdhp->fsfd = fd;
		fdhp->fnxt = NULL;

		memcpy(fdhp->fsh, *hanp, FSIDSIZE);

		if (fdhash_head)
			fdhash_head->fnxt = fdhp;
		else
			fdhash_head       = fdhp;
	}

	return result;
}


int
path_to_handle (
	char		*path,		/* input,  path to convert */
	void		**hanp,		/* output, pointer to data */
	size_t		*hlen)		/* output, size of returned data */
{
	int		fd;
	int		result;
	comarg_t	obj;

	fd = open(path, O_RDONLY);

	if (fd <  0) {
		perror(path);
		exit(1);
	}

	obj.path = path;

	result = obj_to_handle (fd, XFS_IOC_PATH_TO_HANDLE, obj, hanp, hlen);

	close(fd);

	return result;
}


int
fd_to_handle (
	int		fd,		/* input,  file descriptor */
	void		**hanp,		/* output, pointer to data */
	size_t		*hlen)		/* output, size of returned data */
{
	comarg_t	obj;

	obj.fd = fd;

	return obj_to_handle (fd, XFS_IOC_FD_TO_HANDLE, obj, hanp, hlen);
}


int
handle_to_fshandle (
	void		*hanp,
	size_t		hlen,
	void		**fshanp,
	size_t		*fshlen)
{
	if (hlen < FSIDSIZE)
		return EINVAL;

	*fshanp = malloc (FSIDSIZE);

	if (*fshanp == NULL)
		return ENOMEM;

	*fshlen = FSIDSIZE;

	memcpy(*fshanp, hanp, FSIDSIZE);

	return 0;
}


int
handle_to_fsfd(void *hanp)
{
	struct fdhash	*fdhp;

	for (fdhp = fdhash_head; fdhp != NULL; fdhp = fdhp->fnxt) {
		if (memcmp(fdhp->fsh, hanp, FSIDSIZE) == 0)
			return fdhp->fsfd;
	}
	return -1;
}


int
obj_to_handle (
	int		fsfd,
	unsigned int	opcode,
	comarg_t	obj,
	void		**hanp,
	size_t		*hlen)
{
	char		hbuf [MAXHANSIZ];
	int		ret;
	xfs_fsop_handlereq_t hreq;

	if (opcode == XFS_IOC_FD_TO_HANDLE) {
		hreq.fd      = obj.fd;
		hreq.path    = NULL;
	} else {
		hreq.fd      = 0;
		hreq.path    = obj.path;
	}

	hreq.oflags   = O_LARGEFILE;
	hreq.ihandle  = NULL;
	hreq.ihandlen = 0;
	hreq.ohandle  = hbuf;
	hreq.ohandlen = (__u32 *)hlen;

	ret = (int) ioctl(fsfd, opcode, &hreq);

	if (ret)
		return ret;

	*hanp = malloc(*hlen);	

	if (*hanp == NULL) {
		errno = ENOMEM;
		return -1;
	}

	memcpy(*hanp, hbuf, (int) *hlen);

	return 0;
}


int
open_by_handle (
	void		*hanp,
	size_t		hlen,
	int		rw)
{
	int		fd;
	int		result;
	xfs_fsop_handlereq_t hreq;

	if ((fd = handle_to_fsfd(hanp)) < 0) {
		errno = EBADF;
		return -1;
	}

	hreq.fd       = 0;
	hreq.path     = NULL;
	hreq.oflags   = rw | O_LARGEFILE;
	hreq.ihandle  = hanp;
	hreq.ihandlen = hlen;
	hreq.ohandle  = NULL;
	hreq.ohandlen = NULL;

	result = ioctl(fd, XFS_IOC_OPEN_BY_HANDLE, &hreq);

	return result;
}

int
readlink_by_handle (
	void		*hanp,
	size_t		hlen,
	void		*buf,
	size_t		bufsiz)
{
	int		fd;
	xfs_fsop_handlereq_t hreq;


	if ((fd = handle_to_fsfd(hanp)) < 0) {
		errno = EBADF;
		return -1;
	}

	hreq.fd       = 0;
	hreq.path     = NULL;
	hreq.oflags   = O_LARGEFILE;
	hreq.ihandle  = hanp;
	hreq.ihandlen = hlen;
	hreq.ohandle  = buf;
	hreq.ohandlen = (__u32 *)&bufsiz;

	return (int) ioctl(fd, XFS_IOC_READLINK_BY_HANDLE, &hreq);
}

int
attr_multi_by_handle(
	void		*hanp,
	size_t		hlen,
	void		*buf,
	int		rtrvcnt,
	int		flags)
{
	int		fd;
	xfs_fsop_attrmulti_handlereq_t amhreq;

	if ((fd = handle_to_fsfd(hanp)) < 0) {
		errno = EBADF;
		return -1;
	}

	amhreq.hreq.fd       = 0;
	amhreq.hreq.path     = NULL;
	amhreq.hreq.oflags   = O_LARGEFILE;
	amhreq.hreq.ihandle  = hanp;
	amhreq.hreq.ihandlen = hlen;
	amhreq.hreq.ohandle  = NULL;
	amhreq.hreq.ohandlen = NULL;

	amhreq.opcount = rtrvcnt;
	amhreq.ops = buf;

	return (int) ioctl(fd, XFS_IOC_ATTRMULTI_BY_HANDLE, &amhreq);
}

int
attr_list_by_handle(
	void		*hanp,
	size_t		hlen,
	void		*buf,
	size_t		bufsize,
	int		flags,
	struct attrlist_cursor *cursor)
{
	int		fd;
	xfs_fsop_attrlist_handlereq_t alhreq;

	if ((fd = handle_to_fsfd(hanp)) < 0) {
		errno = EBADF;
		return -1;
	}

	alhreq.hreq.fd       = 0;
	alhreq.hreq.path     = NULL;
	alhreq.hreq.oflags   = O_LARGEFILE;
	alhreq.hreq.ihandle  = hanp;
	alhreq.hreq.ihandlen = hlen;
	alhreq.hreq.ohandle  = NULL;
	alhreq.hreq.ohandlen = NULL;

	memcpy(&alhreq.pos, cursor, sizeof(alhreq.pos));
	alhreq.flags = flags;
	alhreq.buflen = bufsize;
	alhreq.buffer = buf;

	return (int) ioctl(fd, XFS_IOC_ATTRLIST_BY_HANDLE, &alhreq);
}

int
fssetdm_by_handle (
	void		*hanp,
	size_t		hlen,
	struct fsdmidata *fsdmidata)
{
	int		fd;
	xfs_fsop_setdm_handlereq_t dmhreq;


	if ((fd = handle_to_fsfd(hanp)) < 0) {
		errno = EBADF;
		return -1;
	}

	dmhreq.hreq.fd       = 0;
	dmhreq.hreq.path     = NULL;
	dmhreq.hreq.oflags   = O_LARGEFILE;
	dmhreq.hreq.ihandle  = hanp;
	dmhreq.hreq.ihandlen = hlen;
	dmhreq.hreq.ohandle  = NULL;
	dmhreq.hreq.ohandlen = NULL;

	dmhreq.data = fsdmidata;

	return (int) ioctl(fd, XFS_IOC_FSSETDM_BY_HANDLE, &dmhreq);
}

/*ARGSUSED*/
void
free_handle (
	void		*hanp,
	size_t		hlen)
{
	free (hanp);
}
Commit	Line	Data
e9688c1d	1	/*
9911e5dc	2	* Copyright (c) 1995-2001 Silicon Graphics, Inc. All Rights Reserved.
7c49c48b	3	*
e9688c1d	4	* This program is free software; you can redistribute it and/or modify it
7c49c48b DR	5	* under the terms of version 2.1 of the GNU Lesser General Public License
	6	* as published by the Free Software Foundation.
	7	*
e9688c1d NS	8	* This program is distributed in the hope that it would be useful, but
	9	* WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
7c49c48b	11	*
e9688c1d NS	12	* Further, this software is distributed without any warranty that it is
	13	* free of the rightful claim of any third person regarding infringement
	14	* or the like. Any license provided herein, whether implied or
	15	* otherwise, applies only to this software file. Patent licenses, if
	16	* any, provided herein do not apply to combinations of this program with
	17	* other software, or any other product whatsoever.
7c49c48b DR	18	*
	19	* You should have received a copy of the GNU Lesser General Public
	20	* License along with this program; if not, write the Free Software
	21	* Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307,
	22	* USA.
	23	*
e9688c1d NS	24	* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
e9688c1d NS	25	* Mountain View, CA 94043, or:
7c49c48b DR	26	*
	27	* http://www.sgi.com
	28	*
	29	* For further information regarding this notice, see:
	30	*
e9688c1d NS	31	* http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
	32	*/
	33
f91dde66	34	#include <libxfs.h>
e9688c1d	35	#include <sys/stat.h>
e9688c1d	36	#include <sys/ioctl.h>
14290264 NS	37
	38	/* attributes.h (purposefully) unavailable to xfsprogs, make do */
	39	struct attrlist_cursor { __u32 opaque[4]; };
	40
	41	#include <handle.h>
e9688c1d	42
e9688c1d NS	43	/* just pick a value we know is more than big enough */
	44	#define MAXHANSIZ 64
	45
	46	/*
	47	* The actual content of a handle is supposed to be opaque here.
	48	* But, to do handle_to_fshandle, we need to know what it is. Sigh.
	49	* However we can get by with knowing only that the first 8 bytes of
	50	* a file handle are the file system ID, and that a file system handle
	51	* consists of only those 8 bytes.
	52	*/
	53
	54	#define FSIDSIZE 8
	55
	56	typedef union {
	57	int fd;
	58	char *path;
	59	} comarg_t;
	60
89184fbc AG	61	int
	62	obj_to_handle (
	63	int fsfd,
5b64e00a	64	unsigned int opcode,
89184fbc AG	65	comarg_t obj,
	66	void **hanp,
	67	size_t *hlen);
	68
	69
	70	/*
	71	* Filesystem Handle -> Open File Descriptor Cache
	72	*
	73	* Maps filesystem handles to a corresponding open file descriptor for that
	74	* filesystem. We need this because we're doing handle operations via ioctl
	75	* and we need to remember the open file descriptor for each filesystem.
	76	*/
e9688c1d NS	77
	78	struct fdhash {
	79	int fsfd;
	80	char fsh[FSIDSIZE];
	81	struct fdhash *fnxt;
	82	};
	83
	84	struct fdhash *fdhash_head = NULL;
	85
	86	int
	87	path_to_fshandle (
	88	char path, / input, path to convert */
	89	void *hanp, / output, pointer to data */
	90	size_t hlen) / output, size of returned data */
	91	{
	92	int result;
	93	int fd;
	94	comarg_t obj;
	95	struct fdhash *fdhp;
	96
	97	fd = open(path, O_RDONLY);
	98
	99	if (fd < 0) {
	100	perror(path);
	101	exit(1);
	102	}
	103
	104	obj.path = path;
	105
	106	result = obj_to_handle (fd, XFS_IOC_PATH_TO_FSHANDLE,
89184fbc	107	obj, hanp, hlen);
e9688c1d NS	108
	109	if (result >= 0) {
	110	fdhp = malloc(sizeof(struct fdhash));
	111
	112	if (fdhp == NULL) {
	113	errno = ENOMEM;
	114	return -1;
	115	}
	116
	117	fdhp->fsfd = fd;
	118	fdhp->fnxt = NULL;
	119
	120	memcpy(fdhp->fsh, *hanp, FSIDSIZE);
	121
	122	if (fdhash_head)
	123	fdhash_head->fnxt = fdhp;
	124	else
	125	fdhash_head = fdhp;
	126	}
	127
	128	return result;
	129	}
	130
	131
	132	int
	133	path_to_handle (
	134	char path, / input, path to convert */
	135	void *hanp, / output, pointer to data */
	136	size_t hlen) / output, size of returned data */
	137	{
	138	int fd;
	139	int result;
	140	comarg_t obj;
	141
	142	fd = open(path, O_RDONLY);
	143
	144	if (fd < 0) {
	145	perror(path);
	146	exit(1);
	147	}
	148
	149	obj.path = path;
	150
	151	result = obj_to_handle (fd, XFS_IOC_PATH_TO_HANDLE, obj, hanp, hlen);
	152
	153	close(fd);
	154
	155	return result;
	156	}
	157
	158
	159	int
	160	fd_to_handle (
	161	int fd, /* input, file descriptor */
	162	void *hanp, / output, pointer to data */
	163	size_t hlen) / output, size of returned data */
	164	{
	165	comarg_t obj;
	166
	167	obj.fd = fd;
	168
	169	return obj_to_handle (fd, XFS_IOC_FD_TO_HANDLE, obj, hanp, hlen);
	170	}
	171
172
173	int
174	handle_to_fshandle (
175	void *hanp,
176	size_t hlen,
177	void **fshanp,
178	size_t *fshlen)
179	{
180	if (hlen < FSIDSIZE)
181	return EINVAL;
182
183	*fshanp = malloc (FSIDSIZE);
184
185	if (*fshanp == NULL)
186	return ENOMEM;
187
188	*fshlen = FSIDSIZE;
189
190	memcpy(*fshanp, hanp, FSIDSIZE);
191
192	return 0;
193	}
194
195
89184fbc AG	196	int
	197	handle_to_fsfd(void *hanp)
	198	{
	199	struct fdhash *fdhp;
	200
	201	for (fdhp = fdhash_head; fdhp != NULL; fdhp = fdhp->fnxt) {
	202	if (memcmp(fdhp->fsh, hanp, FSIDSIZE) == 0)
	203	return fdhp->fsfd;
	204	}
	205	return -1;
	206	}
	207
	208
e9688c1d NS	209	int
	210	obj_to_handle (
	211	int fsfd,
5b64e00a	212	unsigned int opcode,
e9688c1d NS	213	comarg_t obj,
	214	void **hanp,
	215	size_t *hlen)
	216	{
	217	char hbuf [MAXHANSIZ];
	218	int ret;
	219	xfs_fsop_handlereq_t hreq;
	220
	221	if (opcode == XFS_IOC_FD_TO_HANDLE) {
	222	hreq.fd = obj.fd;
	223	hreq.path = NULL;
	224	} else {
	225	hreq.fd = 0;
	226	hreq.path = obj.path;
	227	}
	228
489aaf4d	229	hreq.oflags = O_LARGEFILE;
e9688c1d NS	230	hreq.ihandle = NULL;
	231	hreq.ihandlen = 0;
	232	hreq.ohandle = hbuf;
5b64e00a	233	hreq.ohandlen = (__u32 *)hlen;
e9688c1d NS	234
	235	ret = (int) ioctl(fsfd, opcode, &hreq);
	236
	237	if (ret)
	238	return ret;
	239
	240	hanp = malloc(hlen);
	241
	242	if (*hanp == NULL) {
	243	errno = ENOMEM;
	244	return -1;
	245	}
	246
	247	memcpy(hanp, hbuf, (int) hlen);
	248
	249	return 0;
	250	}
	251
	252
89184fbc	253
e9688c1d NS	254	int
	255	open_by_handle (
	256	void *hanp,
	257	size_t hlen,
	258	int rw)
	259	{
	260	int fd;
	261	int result;
e9688c1d NS	262	xfs_fsop_handlereq_t hreq;
e9688c1d NS	263
89184fbc	264	if ((fd = handle_to_fsfd(hanp)) < 0) {
e9688c1d NS	265	errno = EBADF;
	266	return -1;
	267	}
	268
	269	hreq.fd = 0;
	270	hreq.path = NULL;
489aaf4d	271	hreq.oflags = rw \| O_LARGEFILE;
e9688c1d NS	272	hreq.ihandle = hanp;
	273	hreq.ihandlen = hlen;
	274	hreq.ohandle = NULL;
	275	hreq.ohandlen = NULL;
	276
	277	result = ioctl(fd, XFS_IOC_OPEN_BY_HANDLE, &hreq);
	278
	279	return result;
	280	}
	281
	282	int
	283	readlink_by_handle (
	284	void *hanp,
	285	size_t hlen,
	286	void *buf,
	287	size_t bufsiz)
	288	{
	289	int fd;
e9688c1d NS	290	xfs_fsop_handlereq_t hreq;
	291
	292
89184fbc	293	if ((fd = handle_to_fsfd(hanp)) < 0) {
e9688c1d NS	294	errno = EBADF;
	295	return -1;
	296	}
	297
	298	hreq.fd = 0;
	299	hreq.path = NULL;
489aaf4d	300	hreq.oflags = O_LARGEFILE;
e9688c1d NS	301	hreq.ihandle = hanp;
	302	hreq.ihandlen = hlen;
	303	hreq.ohandle = buf;
5b64e00a	304	hreq.ohandlen = (__u32 *)&bufsiz;
e9688c1d NS	305
	306	return (int) ioctl(fd, XFS_IOC_READLINK_BY_HANDLE, &hreq);
	307	}
	308
14290264 NS	309	int
	310	attr_multi_by_handle(
	311	void *hanp,
	312	size_t hlen,
	313	void *buf,
	314	int rtrvcnt,
	315	int flags)
	316	{
	317	int fd;
	318	xfs_fsop_attrmulti_handlereq_t amhreq;
	319
	320	if ((fd = handle_to_fsfd(hanp)) < 0) {
	321	errno = EBADF;
	322	return -1;
	323	}
	324
	325	amhreq.hreq.fd = 0;
	326	amhreq.hreq.path = NULL;
489aaf4d	327	amhreq.hreq.oflags = O_LARGEFILE;
14290264 NS	328	amhreq.hreq.ihandle = hanp;
	329	amhreq.hreq.ihandlen = hlen;
	330	amhreq.hreq.ohandle = NULL;
	331	amhreq.hreq.ohandlen = NULL;
	332
	333	amhreq.opcount = rtrvcnt;
	334	amhreq.ops = buf;
	335
	336	return (int) ioctl(fd, XFS_IOC_ATTRMULTI_BY_HANDLE, &amhreq);
	337	}
	338
	339	int
	340	attr_list_by_handle(
	341	void *hanp,
	342	size_t hlen,
	343	void *buf,
	344	size_t bufsize,
	345	int flags,
	346	struct attrlist_cursor *cursor)
	347	{
	348	int fd;
	349	xfs_fsop_attrlist_handlereq_t alhreq;
	350
	351	if ((fd = handle_to_fsfd(hanp)) < 0) {
	352	errno = EBADF;
	353	return -1;
	354	}
	355
	356	alhreq.hreq.fd = 0;
	357	alhreq.hreq.path = NULL;
489aaf4d	358	alhreq.hreq.oflags = O_LARGEFILE;
14290264 NS	359	alhreq.hreq.ihandle = hanp;
	360	alhreq.hreq.ihandlen = hlen;
	361	alhreq.hreq.ohandle = NULL;
	362	alhreq.hreq.ohandlen = NULL;
	363
	364	memcpy(&alhreq.pos, cursor, sizeof(alhreq.pos));
	365	alhreq.flags = flags;
	366	alhreq.buflen = bufsize;
	367	alhreq.buffer = buf;
	368
	369	return (int) ioctl(fd, XFS_IOC_ATTRLIST_BY_HANDLE, &alhreq);
	370	}
	371
e1864286 DR	372	int
	373	fssetdm_by_handle (
	374	void *hanp,
	375	size_t hlen,
	376	struct fsdmidata *fsdmidata)
	377	{
	378	int fd;
	379	xfs_fsop_setdm_handlereq_t dmhreq;
	380
	381
	382	if ((fd = handle_to_fsfd(hanp)) < 0) {
	383	errno = EBADF;
	384	return -1;
	385	}
	386
	387	dmhreq.hreq.fd = 0;
	388	dmhreq.hreq.path = NULL;
489aaf4d	389	dmhreq.hreq.oflags = O_LARGEFILE;
e1864286 DR	390	dmhreq.hreq.ihandle = hanp;
	391	dmhreq.hreq.ihandlen = hlen;
	392	dmhreq.hreq.ohandle = NULL;
	393	dmhreq.hreq.ohandlen = NULL;
	394
	395	dmhreq.data = fsdmidata;
	396
	397	return (int) ioctl(fd, XFS_IOC_FSSETDM_BY_HANDLE, &dmhreq);
	398	}
	399
e9688c1d NS	400	/ARGSUSED/
	401	void
	402	free_handle (
	403	void *hanp,
	404	size_t hlen)
	405	{
	406	free (hanp);
	407	}