[deb_libnfs.git] / portmap / portmap.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/>.
*/
#ifdef WIN32
#include "win32_compat.h"
#endif/*WIN32*/

#include <stdio.h>
#include "libnfs-zdr.h"
#include "libnfs.h"
#include "libnfs-raw.h"
#include "libnfs-private.h"
#include "libnfs-raw-portmap.h"


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

	pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V2, PMAP_NULL, cb, private_data, (zdrproc_t)zdr_void, 0);
	if (pdu == NULL) {
		rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for portmap/null call");
		return -1;
	}

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

	return 0;
}

int rpc_pmap_getport_async(struct rpc_context *rpc, int program, int version, int protocol, rpc_cb cb, void *private_data)
{
	struct rpc_pdu *pdu;
	struct pmap_mapping m;

	pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V2, PMAP_GETPORT, cb, private_data, (zdrproc_t)zdr_int, sizeof(uint32_t));
	if (pdu == NULL) {
		rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for portmap/getport call");
		return -1;
	}

	m.prog = program;
	m.vers = version;
	m.prot = protocol;
	m.port = 0;
	if (zdr_pmap_mapping(&pdu->zdr, &m) == 0) {
		rpc_set_error(rpc, "ZDR error: Failed to encode data for portmap/getport call");
		rpc_free_pdu(rpc, pdu);
		return -1;
	}

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

	return 0;
}

int rpc_pmap_set_async(struct rpc_context *rpc, int program, int version, int protocol, int port, rpc_cb cb, void *private_data)
{
	struct rpc_pdu *pdu;
	struct pmap_mapping m;

	pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V2, PMAP_SET, cb, private_data, (zdrproc_t)zdr_int, sizeof(uint32_t));
	if (pdu == NULL) {
		rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for portmap/set call");
		return -1;
	}

	m.prog = program;
	m.vers = version;
	m.prot = protocol;
	m.port = port;
	if (zdr_pmap_mapping(&pdu->zdr, &m) == 0) {
		rpc_set_error(rpc, "ZDR error: Failed to encode data for portmap/set call");
		rpc_free_pdu(rpc, pdu);
		return -1;
	}

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

	return 0;
}

int rpc_pmap_unset_async(struct rpc_context *rpc, int program, int version, int protocol, int port, rpc_cb cb, void *private_data)
{
	struct rpc_pdu *pdu;
	struct pmap_mapping m;

	pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V2, PMAP_UNSET, cb, private_data, (zdrproc_t)zdr_int, sizeof(uint32_t));
	if (pdu == NULL) {
		rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for portmap/unset call");
		return -1;
	}

	m.prog = program;
	m.vers = version;
	m.prot = protocol;
	m.port = port;
	if (zdr_pmap_mapping(&pdu->zdr, &m) == 0) {
		rpc_set_error(rpc, "ZDR error: Failed to encode data for portmap/unset call");
		rpc_free_pdu(rpc, pdu);
		return -1;
	}

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

	return 0;
}

int rpc_pmap_callit_async(struct rpc_context *rpc, int program, int version, int procedure, char *data, int datalen, rpc_cb cb, void *private_data)
{
	struct rpc_pdu *pdu;
	struct pmap_call_args ca;

	pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V2, PMAP_CALLIT, cb, private_data, (zdrproc_t)zdr_pmap_call_result, sizeof(pmap_call_result));
	if (pdu == NULL) {
		rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for portmap/callit call");
		return -1;
	}

	ca.prog = program;
	ca.vers = version;
	ca.proc = procedure;
	ca.args.args_len = datalen;
	ca.args.args_val = data;

	if (zdr_pmap_call_args(&pdu->zdr, &ca) == 0) {
		rpc_set_error(rpc, "ZDR error: Failed to encode data for portmap/callit call");
		rpc_free_pdu(rpc, pdu);
		return -1;
	}

	if (rpc_queue_pdu(rpc, pdu) != 0) {
		rpc_set_error(rpc, "Failed to queue portmap/callit pdu: %s", rpc_get_error(rpc));
		return -1;
	}

	return 0;
}
Commit	Line	Data
	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	#ifdef WIN32
	18	#include "win32_compat.h"
	19	#endif/WIN32/
	20
	21	#include <stdio.h>
	22	#include "libnfs-zdr.h"
	23	#include "libnfs.h"
	24	#include "libnfs-raw.h"
	25	#include "libnfs-private.h"
	26	#include "libnfs-raw-portmap.h"
	27
	28
	29	int rpc_pmap_null_async(struct rpc_context rpc, rpc_cb cb, void private_data)
	30	{
	31	struct rpc_pdu *pdu;
	32
	33	pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V2, PMAP_NULL, cb, private_data, (zdrproc_t)zdr_void, 0);
	34	if (pdu == NULL) {
	35	rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for portmap/null call");
	36	return -1;
	37	}
	38
	39	if (rpc_queue_pdu(rpc, pdu) != 0) {
	40	rpc_set_error(rpc, "Out of memory. Failed to queue pdu for portmap/null call");
	41	rpc_free_pdu(rpc, pdu);
	42	return -1;
	43	}
	44
	45	return 0;
	46	}
	47
	48	int rpc_pmap_getport_async(struct rpc_context rpc, int program, int version, int protocol, rpc_cb cb, void private_data)
	49	{
	50	struct rpc_pdu *pdu;
	51	struct pmap_mapping m;
	52
	53	pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V2, PMAP_GETPORT, cb, private_data, (zdrproc_t)zdr_int, sizeof(uint32_t));
	54	if (pdu == NULL) {
	55	rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for portmap/getport call");
	56	return -1;
	57	}
	58
	59	m.prog = program;
	60	m.vers = version;
	61	m.prot = protocol;
	62	m.port = 0;
	63	if (zdr_pmap_mapping(&pdu->zdr, &m) == 0) {
	64	rpc_set_error(rpc, "ZDR error: Failed to encode data for portmap/getport call");
	65	rpc_free_pdu(rpc, pdu);
	66	return -1;
	67	}
	68
	69	if (rpc_queue_pdu(rpc, pdu) != 0) {
	70	rpc_set_error(rpc, "Failed to queue portmap/getport pdu");
	71	rpc_free_pdu(rpc, pdu);
	72	return -1;
	73	}
	74
	75	return 0;
	76	}
	77
	78	int rpc_pmap_set_async(struct rpc_context rpc, int program, int version, int protocol, int port, rpc_cb cb, void private_data)
	79	{
	80	struct rpc_pdu *pdu;
	81	struct pmap_mapping m;
	82
	83	pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V2, PMAP_SET, cb, private_data, (zdrproc_t)zdr_int, sizeof(uint32_t));
	84	if (pdu == NULL) {
	85	rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for portmap/set call");
	86	return -1;
	87	}
	88
	89	m.prog = program;
	90	m.vers = version;
	91	m.prot = protocol;
	92	m.port = port;
	93	if (zdr_pmap_mapping(&pdu->zdr, &m) == 0) {
	94	rpc_set_error(rpc, "ZDR error: Failed to encode data for portmap/set call");
	95	rpc_free_pdu(rpc, pdu);
	96	return -1;
	97	}
	98
	99	if (rpc_queue_pdu(rpc, pdu) != 0) {
	100	rpc_set_error(rpc, "Failed to queue portmap/set pdu");
	101	rpc_free_pdu(rpc, pdu);
	102	return -1;
	103	}
	104
	105	return 0;
	106	}
	107
	108	int rpc_pmap_unset_async(struct rpc_context rpc, int program, int version, int protocol, int port, rpc_cb cb, void private_data)
	109	{
	110	struct rpc_pdu *pdu;
	111	struct pmap_mapping m;
	112
	113	pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V2, PMAP_UNSET, cb, private_data, (zdrproc_t)zdr_int, sizeof(uint32_t));
	114	if (pdu == NULL) {
	115	rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for portmap/unset call");
	116	return -1;
	117	}
	118
	119	m.prog = program;
	120	m.vers = version;
	121	m.prot = protocol;
	122	m.port = port;
	123	if (zdr_pmap_mapping(&pdu->zdr, &m) == 0) {
	124	rpc_set_error(rpc, "ZDR error: Failed to encode data for portmap/unset call");
	125	rpc_free_pdu(rpc, pdu);
	126	return -1;
	127	}
	128
	129	if (rpc_queue_pdu(rpc, pdu) != 0) {
	130	rpc_set_error(rpc, "Failed to queue portmap/unset pdu");
	131	rpc_free_pdu(rpc, pdu);
	132	return -1;
	133	}
	134
	135	return 0;
	136	}
	137
	138	int rpc_pmap_callit_async(struct rpc_context rpc, int program, int version, int procedure, char data, int datalen, rpc_cb cb, void *private_data)
	139	{
	140	struct rpc_pdu *pdu;
	141	struct pmap_call_args ca;
	142
	143	pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V2, PMAP_CALLIT, cb, private_data, (zdrproc_t)zdr_pmap_call_result, sizeof(pmap_call_result));
	144	if (pdu == NULL) {
	145	rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for portmap/callit call");
	146	return -1;
	147	}
	148
	149	ca.prog = program;
	150	ca.vers = version;
	151	ca.proc = procedure;
	152	ca.args.args_len = datalen;
	153	ca.args.args_val = data;
	154
	155	if (zdr_pmap_call_args(&pdu->zdr, &ca) == 0) {
	156	rpc_set_error(rpc, "ZDR error: Failed to encode data for portmap/callit call");
	157	rpc_free_pdu(rpc, pdu);
	158	return -1;
	159	}
	160
	161	if (rpc_queue_pdu(rpc, pdu) != 0) {
	162	rpc_set_error(rpc, "Failed to queue portmap/callit pdu: %s", rpc_get_error(rpc));
	163	return -1;
	164	}
	165
	166	return 0;
	167	}