path: root/src/portmap.c

/*
 * Copyright 2008,2009 Red Hat, Inc.
 *
 * 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; version 2 of the License.
 *
 * 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.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307 USA
 *
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <sys/types.h>
#include <sys/socket.h>
#include <errno.h>
#include <poll.h>
#include <time.h>

#ifdef HAVE_DIRSRV_SLAPI_PLUGIN_H
#include <nspr.h>
#include <nss.h>
#include <dirsrv/slapi-plugin.h>
#else
#include <slapi-plugin.h>
#endif

#include <rpcsvc/yp_prot.h>
#include <rpc/xdr.h>
#ifdef HAVE_LIBTIRPC
#include <rpc/rpcb_prot.h>
#else
#include <rpc/pmap_prot.h>
#endif

#include "portmap.h"

#ifdef PORTMAP_MAIN
#include <stdarg.h>
#include <stdlib.h>
#include <unistd.h>
int
slapi_log_error(int i, char *f, char *fmt, ...)
{
	va_list va;
	va_start(va, fmt);
	vfprintf(stderr, fmt, va);
	va_end(va);
	return 0;
}
int
main(int argc, char **argv)
{
	int s, ret;
	struct sockaddr_in sin;
	struct sockaddr_un sunaddr;
	s = socket(PF_INET, SOCK_DGRAM, 0);
	memset(&sin, 0, sizeof(sin));
	sin.sin_family = AF_INET;
	if (bindresvport(s, &sin) != 0) {
		printf("error binding to reserved port\n");
	} else {
		printf("bound to reserved port %d\n", ntohs(sin.sin_port));
	}
#ifdef HAVE_LIBTIRPC
	s = socket(AF_LOCAL, SOCK_STREAM, 0);
	memset(&sunaddr, 0, sizeof(sunaddr));
	sunaddr.sun_family = AF_LOCAL;
	strcpy(sunaddr.sun_path, _PATH_RPCBINDSOCK);
	connect(s, (struct sockaddr *) &sunaddr, sizeof(sunaddr));
#endif
	setreuid(2510, 2510);
	portmap_register("portmap", s, YPPROG, YPVERS, AF_INET, IPPROTO_TCP,
			 ntohs(sin.sin_port));
	portmap_register("portmap", s, YPPROG, YPVERS, AF_INET, IPPROTO_UDP,
			 ntohs(sin.sin_port));
	portmap_register("portmap", s, YPPROG, YPVERS, AF_INET6, IPPROTO_TCP,
			 ntohs(sin.sin_port));
	portmap_register("portmap", s, YPPROG, YPVERS, AF_INET6, IPPROTO_UDP,
			 ntohs(sin.sin_port));
	ret = system("rpcinfo | grep ypserv");
	ret = system("rpcinfo -p | grep ypserv");
	portmap_unregister("portmap", s, YPPROG, YPVERS, AF_INET, IPPROTO_TCP);
	portmap_unregister("portmap", s, YPPROG, YPVERS, AF_INET, IPPROTO_UDP);
	portmap_unregister("portmap", s, YPPROG, YPVERS, AF_INET6, IPPROTO_TCP);
	portmap_unregister("portmap", s, YPPROG, YPVERS, AF_INET6, IPPROTO_UDP);
	return 0;
}
#endif

static bool_t
portmap_register_work(const char *module, int resv_sock,
		      int program, int version,
		      int family, int protocol, int port,
		      bool_t create)
{
	char portmap_buf[4000], auth_buf[4000], reply_buf[8000], *log_id;
	int portmap_length, reply_length;
	AUTH *auth;
	XDR portmap_xdrs, auth_xdrs;
	struct rpc_msg msg;
#ifdef HAVE_LIBTIRPC
	char address_buf[32];
	struct rpcb rpcb;
	int fragment_length;
#else
	struct pmap map;
#endif
	int prog, vers, proc;
	bool_t ret = FALSE;
	struct sockaddr addr;
	struct sockaddr_in addr4;
	struct sockaddr_in6 addr6;
	struct sockaddr_un addrun;
	union {
		struct sockaddr_in addr4;
	} client_addr;
	socklen_t client_addrlen;
	struct pollfd pollfd;
	int i;
	static u_long xid;

	log_id = (char *) module;
	memset(&addr, 0, sizeof(addr));
	addr.sa_family = AF_UNSPEC;

	/* Populate the arguments for this request. */
#ifdef HAVE_LIBTIRPC
	rpcb.r_prog = program;
	rpcb.r_vers = version;
	rpcb.r_owner = module;
	switch (family) {
	case AF_INET:
		snprintf(address_buf, sizeof(address_buf), "0.0.0.0.%d.%d",
			 (port >> 8) & 0xff, port & 0xff);
		switch (protocol) {
		case IPPROTO_TCP:
			rpcb.r_netid = "tcp";
			rpcb.r_addr = address_buf;
			break;
		case IPPROTO_UDP:
			rpcb.r_netid = "udp";
			rpcb.r_addr = address_buf;
			break;
		default:
			rpcb.r_netid = NULL;
			rpcb.r_addr = NULL;
			break;
		}
		break;
	case AF_INET6:
		snprintf(address_buf, sizeof(address_buf), "::.%d.%d",
			 (port >> 8) & 0xff, port & 0xff);
		switch (protocol) {
		case IPPROTO_TCP:
			rpcb.r_netid = "tcp6";
			rpcb.r_addr = address_buf;
			break;
		case IPPROTO_UDP:
			rpcb.r_netid = "udp6";
			rpcb.r_addr = address_buf;
			break;
		default:
			rpcb.r_netid = NULL;
			rpcb.r_addr = NULL;
			break;
		}
		break;
	default:
		rpcb.r_netid = NULL;
		rpcb.r_addr = NULL;
		break;
	}
	prog = RPCBPROG;
	vers = RPCBVERS;
	proc = create ? RPCBPROC_SET : RPCBPROC_UNSET;
#else
	map.pm_prog = program;
	map.pm_vers = version;
	map.pm_prot = protocol;
	map.pm_port = port;
	prog = PMAPPROG;
	vers = PMAPVERS;
	proc = create ? PMAPPROC_SET : PMAPPROC_UNSET;
#endif

	/* Build the RPC header. */
	memset(&msg, 0, sizeof(msg));
	msg.rm_xid = xid = (time(NULL) ^ port ^ protocol ^ proc);
	msg.rm_direction = CALL;
	msg.rm_call.cb_rpcvers = 2;
	msg.rm_call.cb_prog = prog;
	msg.rm_call.cb_vers = vers;
	msg.rm_call.cb_proc = proc;

	/* Build an authenticator. */
	xdrmem_create(&auth_xdrs, auth_buf, sizeof(auth_buf), XDR_ENCODE);
	auth = authnone_create();
	auth_marshall(auth, &auth_xdrs);
	msg.rm_call.cb_cred = auth->ah_cred;
	msg.rm_call.cb_verf = auth->ah_verf;

	/* Encode the header and the arguments, then clean up temporaries. */
#ifdef HAVE_LIBTIRPC
	xdrmem_create(&portmap_xdrs, portmap_buf + 4, sizeof(portmap_buf) - 4,
		      XDR_ENCODE);
#else
	xdrmem_create(&portmap_xdrs, portmap_buf, sizeof(portmap_buf),
		      XDR_ENCODE);
#endif
	xdr_callmsg(&portmap_xdrs, &msg);
#ifdef HAVE_LIBTIRPC
	xdr_rpcb(&portmap_xdrs, &rpcb);
#else
	xdr_pmap(&portmap_xdrs, &map);
#endif
	portmap_length = xdr_getpos(&portmap_xdrs);
	auth_destroy(auth);
	xdr_destroy(&auth_xdrs);
	xdr_destroy(&portmap_xdrs);
	memset(&portmap_xdrs, 0, sizeof(portmap_xdrs));

#ifdef HAVE_LIBTIRPC
	/* Compute the message length and prepend it. */
	fragment_length = portmap_length;
	fragment_length |= 0x80000000;
	portmap_buf[0] = (fragment_length >> 24) & 0xff;
	portmap_buf[1] = (fragment_length >> 16) & 0xff;
	portmap_buf[2] = (fragment_length >>  8) & 0xff;
	portmap_buf[3] = (fragment_length >>  0) & 0xff;
	portmap_length += 4;
#else
	/* "Connect" to the local portmapper. */
	memset(&addr4, 0, sizeof(addr4));
	addr4.sin_family = AF_INET;
	addr4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
	addr4.sin_port = htons(PMAPPORT);
	i = connect(resv_sock, (struct sockaddr*) &addr4, sizeof(addr4));
	if (i != 0) {
		slapi_log_error(SLAPI_LOG_PLUGIN, log_id,
				"error targeting portmap with sock %d: %s\n",
				resv_sock, strerror(errno));
		return FALSE;
	}
#endif

	/* Transmit our request.  Retry a few times if it doesn't go through. */
	for (i = 1; i < 32; i *= 2) {
		/* Try to send our request.  If there's any problem,
		 * immediately retry. */
		if (send(resv_sock, &portmap_buf, portmap_length,
			 0) != portmap_length) {
			slapi_log_error(SLAPI_LOG_PLUGIN, log_id,
					"error sending request to portmap\n");
			continue;
		}

		/* Wait for a response. */
		pollfd.fd = resv_sock;
		pollfd.events = POLLIN | POLLERR;
		if ((poll(&pollfd, 1, i * 1000) > 0) &&
		    (pollfd.revents & POLLIN)) {
			/* Read the response. */
			client_addrlen = sizeof(client_addr);
			reply_length = recvfrom(resv_sock,
						reply_buf, sizeof(reply_buf), 0,
						(struct sockaddr *)&client_addr,
						&client_addrlen);
			/* Decode the response. */
			if (reply_length > 0) {
				/* Decode an RPC header and the returned
				 * boolean from the buffer. */
				memset(&msg, 0, sizeof(msg));
#ifdef HAVE_LIBTIRPC
				fragment_length = ((reply_buf[0] << 24) |
						   (reply_buf[1] << 16) |
						   (reply_buf[2] <<  8) |
						   (reply_buf[3] <<  0)) &
						   0x7fffffff;
				if (fragment_length != reply_length - 4) {
					fprintf(stderr, "Bad reply length!\n");
				}
				xdrmem_create(&portmap_xdrs,
					      reply_buf + 4, reply_length - 4,
					      XDR_DECODE);
#else
				xdrmem_create(&portmap_xdrs,
					      reply_buf, reply_length,
					      XDR_DECODE);
#endif
				msg.rm_reply.rp_acpt.ar_results.where =
					(caddr_t) &ret;
				msg.rm_reply.rp_acpt.ar_results.proc =
					(xdrproc_t) xdr_bool;
				if (xdr_replymsg(&portmap_xdrs, &msg)) {
					if ((msg.rm_direction == REPLY) &&
					    (msg.rm_xid == xid)) {
						xdr_destroy(&portmap_xdrs);
						break;
					}
				}
				xdr_destroy(&portmap_xdrs);
				memset(&portmap_xdrs, 0, sizeof(portmap_xdrs));
			}
		}
	}

#ifndef HAVE_LIBTIRPC
	/* Disconnect from the portmapper, but keep our socket around. */
	connect(resv_sock, &addr, sizeof(addr));
	if (i == 32) {
		slapi_log_error(SLAPI_LOG_PLUGIN, log_id,
				"timeout registering with portmap service\n");
		return FALSE;
	}
#endif

	/* Check that the portmapper didn't just reject the request out of
	 * hand. */
	if (msg.rm_reply.rp_stat != MSG_ACCEPTED) {
		slapi_log_error(SLAPI_LOG_PLUGIN, log_id,
				"portmap request not accepted\n");
		switch (msg.rm_reply.rp_rjct.rj_stat) {
		const char *auth_status;
		case AUTH_ERROR:
			switch (msg.rm_reply.rp_rjct.rj_why) {
			case AUTH_OK:
				auth_status = "ok";
				break;
			case AUTH_BADCRED:
				auth_status = "bad credentials";
				break;
			case AUTH_REJECTEDCRED:
				auth_status = "rejected credentials";
				break;
			case AUTH_BADVERF:
				auth_status = "bad verifier";
				break;
			case AUTH_REJECTEDVERF:
				auth_status = "rejected verifier";
				break;
			case AUTH_TOOWEAK:
				auth_status = "too weak";
				break;
			case AUTH_INVALIDRESP:
				auth_status = "invalid response";
				break;
			case AUTH_FAILED:
			default:
				auth_status = "unknown error";
				break;
			}
			slapi_log_error(SLAPI_LOG_PLUGIN, log_id,
					"portmap request rejected: "
					"authentication failed: %s\n",
					auth_status);
			break;
		case RPC_MISMATCH:
			slapi_log_error(SLAPI_LOG_PLUGIN, log_id,
					"portmap request rejected: "
					"RPC mismatch\n");
			break;
		}
		return FALSE;
		xdr_destroy(&portmap_xdrs);
	}

	/* Validate the portmapper's credentials. */
	auth = authunix_create_default();
	if (auth_validate(auth, &msg.rm_reply.rp_acpt.ar_verf)) {
		slapi_log_error(SLAPI_LOG_PLUGIN, log_id,
				"portmap reply authenticated\n");
	} else {
		slapi_log_error(SLAPI_LOG_PLUGIN, log_id,
				"portmap reply failed authentication\n");
	}
	auth_destroy(auth);

	/* Check if we the portmapper gave us a reply argument. */
	if (msg.rm_reply.rp_acpt.ar_stat != SUCCESS) {
		slapi_log_error(SLAPI_LOG_PLUGIN, log_id,
				"portmap request not processed\n");
		xdr_destroy(&portmap_xdrs);
		return FALSE;
	}

	/* Check what happened. */
	if (ret) {
		slapi_log_error(SLAPI_LOG_PLUGIN, log_id,
				"portmap request succeeded\n");
	} else {
		slapi_log_error(SLAPI_LOG_PLUGIN, log_id,
				"portmap request failed\n");
	}

	xdr_destroy(&portmap_xdrs);

	return ret;
}

bool_t
portmap_register(const char *log_id, int resv_sock,
		 int program, int version, int family, int protocol, int port)
{
	return portmap_register_work(log_id, resv_sock, program, version,
				     family, protocol, port, TRUE);
}

bool_t
portmap_unregister(const char *log_id, int resv_sock,
		   int program, int version, int family, int protocol)
{
	return portmap_register_work(log_id, resv_sock, program, version,
				     family, protocol, 0, FALSE);
}