[deb_libnfs.git] / mount / mount.c

/*
   Copyright (C) 2010 by Ronnie Sahlberg <ronniesahlberg@gmail.com>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published by
   the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with this program; if not, see <http://www.gnu.org/licenses/>.
*/

#include <stdio.h>
#include <errno.h>
#include <rpc/rpc.h>
#include <rpc/xdr.h>
#include "libnfs.h"
#include "libnfs-raw.h"
#include "libnfs-private.h"
#include "libnfs-raw-mount.h"


int rpc_mount_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data)
{
	struct rpc_pdu *pdu;

	pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_NULL, cb, private_data, (xdrproc_t)xdr_void, 0);
	if (pdu == NULL) {
		rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for mount/null call");
		return -1;
	}

	if (rpc_queue_pdu(rpc, pdu) != 0) {
		rpc_set_error(rpc, "Out of memory. Failed to queue pdu for mount/null call");
		rpc_free_pdu(rpc, pdu);
		return -1;
	}

	return 0;
}

int rpc_mount_mnt_async(struct rpc_context *rpc, rpc_cb cb, char *export, void *private_data)
{
	struct rpc_pdu *pdu;

	pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_MNT, cb, private_data, (xdrproc_t)xdr_mountres3, sizeof(mountres3));
	if (pdu == NULL) {
		rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for mount/mnt call");
		return -1;
	}

	if (xdr_dirpath(&pdu->xdr, &export) == 0) {
		rpc_set_error(rpc, "XDR error. Failed to encode mount/mnt call");
		rpc_free_pdu(rpc, pdu);
		return -1;
	}

	if (rpc_queue_pdu(rpc, pdu) != 0) {
		rpc_set_error(rpc, "Out of memory. Failed to queue pdu for mount/mnt call");
		rpc_free_pdu(rpc, pdu);
		return -1;
	}

	return 0;
}

int rpc_mount_dump_async(struct rpc_context *rpc, rpc_cb cb, void *private_data)
{
	struct rpc_pdu *pdu;

	pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_DUMP, cb, private_data, (xdrproc_t)xdr_mountlist, sizeof(mountlist));
	if (pdu == NULL) {
		rpc_set_error(rpc, "Failed to allocate pdu for mount/dump");
		return -1;
	}

	if (rpc_queue_pdu(rpc, pdu) != 0) {
		rpc_set_error(rpc, "Failed to queue mount/dump pdu");
		rpc_free_pdu(rpc, pdu);
		return -1;
	}

	return 0;
}

int rpc_mount_umnt_async(struct rpc_context *rpc, rpc_cb cb, char *export, void *private_data)
{
	struct rpc_pdu *pdu;

	pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_UMNT, cb, private_data, (xdrproc_t)xdr_void, 0);
	if (pdu == NULL) {
		rpc_set_error(rpc, "Failed to allocate pdu for mount/umnt");
		return -1;
	}

	if (xdr_dirpath(&pdu->xdr, &export) == 0) {
		rpc_set_error(rpc, "failed to encode dirpath for mount/umnt");
		rpc_free_pdu(rpc, pdu);
		return -1;
	}

	if (rpc_queue_pdu(rpc, pdu) != 0) {
		rpc_set_error(rpc, "Failed to queue mount/umnt pdu");
		rpc_free_pdu(rpc, pdu);
		return -1;
	}

	return 0;
}

int rpc_mount_umntall_async(struct rpc_context *rpc, rpc_cb cb, void *private_data)
{
	struct rpc_pdu *pdu;

	pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_UMNTALL, cb, private_data, (xdrproc_t)xdr_void, 0);
	if (pdu == NULL) {
		rpc_set_error(rpc, "Failed to allocate pdu for mount/umntall");
		return -1;
	}

	if (rpc_queue_pdu(rpc, pdu) != 0) {
		rpc_set_error(rpc, "Failed to queue mount/umntall pdu");
		rpc_free_pdu(rpc, pdu);
		return -1;
	}

	return 0;
}

int rpc_mount_export_async(struct rpc_context *rpc, rpc_cb cb, void *private_data)
{
	struct rpc_pdu *pdu;

	pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_EXPORT, cb, private_data, (xdrproc_t)xdr_exports, sizeof(exports));
	if (pdu == NULL) {
		rpc_set_error(rpc, "Failed to allocate pdu for mount/export");
		return -1;
	}

	if (rpc_queue_pdu(rpc, pdu) != 0) {
		rpc_set_error(rpc, "Failed to queue mount/export pdu");
		rpc_free_pdu(rpc, pdu);
		return -1;
	}

	return 0;
}

char *mountstat3_to_str(int st)
{
	enum mountstat3 stat = st;

	char *str = "unknown mount stat";
	switch (stat) {
	case MNT3_OK:		  str="MNT3_OK"; break;
	case MNT3ERR_PERM:	  str="MNT3ERR_PERM"; break;
	case MNT3ERR_NOENT:	  str="MNT3ERR_NOENT"; break;
	case MNT3ERR_IO:	  str="MNT3ERR_IO"; break;
	case MNT3ERR_ACCES:	  str="MNT3ERR_ACCES"; break;
	case MNT3ERR_NOTDIR:	  str="MNT3ERR_NOTDIR"; break;
	case MNT3ERR_INVAL:	  str="MNT3ERR_INVAL"; break;
	case MNT3ERR_NAMETOOLONG: str="MNT3ERR_NAMETOOLONG"; break;
	case MNT3ERR_NOTSUPP:	  str="MNT3ERR_NOTSUPP"; break;
	case MNT3ERR_SERVERFAULT: str="MNT3ERR_SERVERFAULT"; break;
	}
	return str;
}


int mountstat3_to_errno(int st)
{
	enum mountstat3 stat = st;

	switch (stat) {
	case MNT3_OK:		  return 0; break;
	case MNT3ERR_PERM:	  return -EPERM; break;
	case MNT3ERR_NOENT:	  return -EPERM; break;
	case MNT3ERR_IO:	  return -EIO; break;
	case MNT3ERR_ACCES:	  return -EACCES; break;
	case MNT3ERR_NOTDIR:	  return -ENOTDIR; break;
	case MNT3ERR_INVAL:	  return -EINVAL; break;
	case MNT3ERR_NAMETOOLONG: return -E2BIG; break;
	case MNT3ERR_NOTSUPP:	  return -EINVAL; break;
	case MNT3ERR_SERVERFAULT: return -EIO; break;
	}
	return -ERANGE;
}
Commit	Line	Data
84004dbf RS	1	/*
	2	Copyright (C) 2010 by Ronnie Sahlberg <ronniesahlberg@gmail.com>
	3
	4	This program is free software; you can redistribute it and/or modify
	5	it under the terms of the GNU Lesser General Public License as published by
	6	the Free Software Foundation; either version 2.1 of the License, or
	7	(at your option) any later version.
	8
	9	This program is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	GNU Lesser General Public License for more details.
	13
	14	You should have received a copy of the GNU Lesser General Public License
	15	along with this program; if not, see <http://www.gnu.org/licenses/>.
	16	*/
	17
	18	#include <stdio.h>
	19	#include <errno.h>
98f5fee8	20	#include <rpc/rpc.h>
84004dbf RS	21	#include <rpc/xdr.h>
	22	#include "libnfs.h"
	23	#include "libnfs-raw.h"
	24	#include "libnfs-private.h"
	25	#include "libnfs-raw-mount.h"
	26
	27
	28	int rpc_mount_null_async(struct rpc_context rpc, rpc_cb cb, void private_data)
	29	{
	30	struct rpc_pdu *pdu;
	31
	32	pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_NULL, cb, private_data, (xdrproc_t)xdr_void, 0);
	33	if (pdu == NULL) {
	34	rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for mount/null call");
	35	return -1;
	36	}
	37
	38	if (rpc_queue_pdu(rpc, pdu) != 0) {
	39	rpc_set_error(rpc, "Out of memory. Failed to queue pdu for mount/null call");
	40	rpc_free_pdu(rpc, pdu);
1896d37b	41	return -1;
84004dbf RS	42	}
	43
	44	return 0;
	45	}
	46
	47	int rpc_mount_mnt_async(struct rpc_context rpc, rpc_cb cb, char export, void *private_data)
	48	{
	49	struct rpc_pdu *pdu;
	50
	51	pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_MNT, cb, private_data, (xdrproc_t)xdr_mountres3, sizeof(mountres3));
	52	if (pdu == NULL) {
	53	rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for mount/mnt call");
	54	return -1;
	55	}
	56
	57	if (xdr_dirpath(&pdu->xdr, &export) == 0) {
	58	rpc_set_error(rpc, "XDR error. Failed to encode mount/mnt call");
	59	rpc_free_pdu(rpc, pdu);
1896d37b	60	return -1;
84004dbf RS	61	}
	62
	63	if (rpc_queue_pdu(rpc, pdu) != 0) {
	64	rpc_set_error(rpc, "Out of memory. Failed to queue pdu for mount/mnt call");
	65	rpc_free_pdu(rpc, pdu);
1896d37b	66	return -1;
84004dbf RS	67	}
	68
	69	return 0;
	70	}
	71
	72	int rpc_mount_dump_async(struct rpc_context rpc, rpc_cb cb, void private_data)
	73	{
	74	struct rpc_pdu *pdu;
	75
	76	pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_DUMP, cb, private_data, (xdrproc_t)xdr_mountlist, sizeof(mountlist));
	77	if (pdu == NULL) {
1896d37b	78	rpc_set_error(rpc, "Failed to allocate pdu for mount/dump");
84004dbf RS	79	return -1;
	80	}
	81
	82	if (rpc_queue_pdu(rpc, pdu) != 0) {
1896d37b	83	rpc_set_error(rpc, "Failed to queue mount/dump pdu");
84004dbf	84	rpc_free_pdu(rpc, pdu);
1896d37b	85	return -1;
84004dbf RS	86	}
	87
	88	return 0;
	89	}
	90
	91	int rpc_mount_umnt_async(struct rpc_context rpc, rpc_cb cb, char export, void *private_data)
	92	{
	93	struct rpc_pdu *pdu;
	94
	95	pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_UMNT, cb, private_data, (xdrproc_t)xdr_void, 0);
	96	if (pdu == NULL) {
1896d37b	97	rpc_set_error(rpc, "Failed to allocate pdu for mount/umnt");
84004dbf RS	98	return -1;
	99	}
	100
	101	if (xdr_dirpath(&pdu->xdr, &export) == 0) {
1896d37b	102	rpc_set_error(rpc, "failed to encode dirpath for mount/umnt");
84004dbf	103	rpc_free_pdu(rpc, pdu);
1896d37b	104	return -1;
84004dbf RS	105	}
	106
	107	if (rpc_queue_pdu(rpc, pdu) != 0) {
1896d37b	108	rpc_set_error(rpc, "Failed to queue mount/umnt pdu");
84004dbf	109	rpc_free_pdu(rpc, pdu);
1896d37b	110	return -1;
84004dbf RS	111	}
	112
	113	return 0;
	114	}
	115
	116	int rpc_mount_umntall_async(struct rpc_context rpc, rpc_cb cb, void private_data)
	117	{
	118	struct rpc_pdu *pdu;
	119
	120	pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_UMNTALL, cb, private_data, (xdrproc_t)xdr_void, 0);
	121	if (pdu == NULL) {
1896d37b	122	rpc_set_error(rpc, "Failed to allocate pdu for mount/umntall");
84004dbf RS	123	return -1;
	124	}
	125
	126	if (rpc_queue_pdu(rpc, pdu) != 0) {
1896d37b	127	rpc_set_error(rpc, "Failed to queue mount/umntall pdu");
84004dbf	128	rpc_free_pdu(rpc, pdu);
1896d37b	129	return -1;
84004dbf RS	130	}
	131
	132	return 0;
	133	}
	134
	135	int rpc_mount_export_async(struct rpc_context rpc, rpc_cb cb, void private_data)
	136	{
	137	struct rpc_pdu *pdu;
	138
	139	pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_EXPORT, cb, private_data, (xdrproc_t)xdr_exports, sizeof(exports));
	140	if (pdu == NULL) {
1896d37b	141	rpc_set_error(rpc, "Failed to allocate pdu for mount/export");
84004dbf RS	142	return -1;
	143	}
	144
	145	if (rpc_queue_pdu(rpc, pdu) != 0) {
1896d37b	146	rpc_set_error(rpc, "Failed to queue mount/export pdu");
84004dbf	147	rpc_free_pdu(rpc, pdu);
1896d37b	148	return -1;
84004dbf RS	149	}
	150
	151	return 0;
	152	}
	153
	154	char *mountstat3_to_str(int st)
	155	{
	156	enum mountstat3 stat = st;
	157
	158	char *str = "unknown mount stat";
	159	switch (stat) {
	160	case MNT3_OK: str="MNT3_OK"; break;
	161	case MNT3ERR_PERM: str="MNT3ERR_PERM"; break;
	162	case MNT3ERR_NOENT: str="MNT3ERR_NOENT"; break;
	163	case MNT3ERR_IO: str="MNT3ERR_IO"; break;
	164	case MNT3ERR_ACCES: str="MNT3ERR_ACCES"; break;
	165	case MNT3ERR_NOTDIR: str="MNT3ERR_NOTDIR"; break;
	166	case MNT3ERR_INVAL: str="MNT3ERR_INVAL"; break;
	167	case MNT3ERR_NAMETOOLONG: str="MNT3ERR_NAMETOOLONG"; break;
	168	case MNT3ERR_NOTSUPP: str="MNT3ERR_NOTSUPP"; break;
	169	case MNT3ERR_SERVERFAULT: str="MNT3ERR_SERVERFAULT"; break;
	170	}
	171	return str;
	172	}
	173
	174
	175	int mountstat3_to_errno(int st)
	176	{
	177	enum mountstat3 stat = st;
	178
	179	switch (stat) {
	180	case MNT3_OK: return 0; break;
	181	case MNT3ERR_PERM: return -EPERM; break;
	182	case MNT3ERR_NOENT: return -EPERM; break;
	183	case MNT3ERR_IO: return -EIO; break;
	184	case MNT3ERR_ACCES: return -EACCES; break;
	185	case MNT3ERR_NOTDIR: return -ENOTDIR; break;
	186	case MNT3ERR_INVAL: return -EINVAL; break;
	187	case MNT3ERR_NAMETOOLONG: return -E2BIG; break;
	188	case MNT3ERR_NOTSUPP: return -EINVAL; break;
	189	case MNT3ERR_SERVERFAULT: return -EIO; break;
	190	}
	191	return -ERANGE;
	192	}