- use xdr_string() correctly

2 files changed, 378 insertions, 202 deletions

diff --git a/src/Makefile b/src/Makefile
index ee93e37..826e957 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -1,4 +1,4 @@
-CFLAGS = -g3 -Wall -Wimplicit -Wextra -Wno-unused -fPIC -D_REENTRANT $(shell pkg-config --cflags nspr nss)
+CFLAGS = $(shell pkg-config --cflags nspr nss) -g3 -O0 -Wall -Wimplicit -Wextra -Wno-unused -fPIC -D_REENTRANT
 LDFLAGS = -lnsl -lpthread
 
 all:: plugin.so portmap
diff --git a/src/nis.c b/src/nis.c
index c8be67b..8e59239 100644
--- a/src/nis.c
+++ b/src/nis.c
@@ -4,9 +4,11 @@
 
 #include <sys/types.h>
 #include <sys/socket.h>
+#include <sys/uio.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 #include <unistd.h>
 
 #include <rpc/rpc.h>
@@ -17,74 +19,306 @@
 #include "plugin.h"
 #include "schema.h"
 
+#define DUMMY_KEY "leeroy"
+#define DUMMY_VAL "jimbo:*K*:1234:5678:Leeroy Jenkins:/home/leeroy:/bin/bash"
+
 /* send a reply which _could_ be sent over a datagram */
 static void
-nis_reply(int client, struct sockaddr *client_addr, socklen_t client_addrlen,
-	  struct rpc_msg *reply, XDR *reply_xdrs, unsigned char *reply_buf)
+nis_reply_fragment(int client,
+		   struct sockaddr *client_addr, socklen_t client_addrlen,
+		   struct rpc_msg *reply, XDR *reply_xdrs, char *reply_buf,
+		   bool_t first_fragment, bool_t last_fragment)
 {
 	uint32_t len;
+	struct iovec iov[2];
+	ssize_t i;
 	if (client_addr != NULL) {
 		/* datagram reply */
 		xdr_replymsg(reply_xdrs, reply);
+		slapi_log_error(SLAPI_LOG_PLUGIN,
+				"blah", "datagram reply (%d bytes)\n",
+				xdr_getpos(reply_xdrs));
 		sendto(client, reply_buf, xdr_getpos(reply_xdrs),
 		       0, client_addr, client_addrlen);
 	} else {
 		/* record reply - one fragment */
-		xdr_setpos(reply_xdrs, 4);
-		xdr_replymsg(reply_xdrs, reply);
-		len = htonl((xdr_getpos(&reply_xdrs) - 4) | 0x80000000);
-		memcpy(reply_buf, &len, 4);
-		send(client, reply_buf, xdr_getpos(&reply_xdrs), 0);
+		if (first_fragment) {
+			xdr_replymsg(reply_xdrs, reply);
+		}
+		/* calculate the fragment length bytes */
+		len = htonl(xdr_getpos(reply_xdrs) |
+			    (last_fragment ? 0x80000000 : 0));
+		slapi_log_error(SLAPI_LOG_PLUGIN,
+				"blah", "stream reply (4+%d bytes)\n",
+				xdr_getpos(reply_xdrs));
+		iov[0].iov_base = &len;
+		iov[0].iov_len = 4;
+		iov[1].iov_base = reply_buf;
+		iov[1].iov_len = xdr_getpos(reply_xdrs);
+		i = writev(client, iov, 2);
+		if (i != (4 + xdr_getpos(reply_xdrs))) {
+			slapi_log_error(SLAPI_LOG_PLUGIN,
+					"blah", "error sending stream reply\n");
+		}
 	}
 }
 
+/* send an entire reply datagram or record */
+static void
+nis_reply(int client, struct sockaddr *client_addr, socklen_t client_addrlen,
+	  struct rpc_msg *reply, XDR *reply_xdrs, char *reply_buf)
+{
+	nis_reply_fragment(client, client_addr, client_addrlen,
+			   reply, reply_xdrs, reply_buf, TRUE, TRUE);
+}
+
 /* indicate whether or not we support a specified domain */
 static void
-nis_domain(int client, struct sockaddr *client_addr, socklen_t client_addrlen,
+nis_domain(struct plugin_state *state,
+	   int client, struct sockaddr *client_addr, socklen_t client_addrlen,
 	   XDR *request_xdrs, bool_t reply_on_failure,
-	   struct rpc_msg *reply, XDR *reply_xdrs, unsigned char *reply_buf,
+	   struct rpc_msg *reply, XDR *reply_xdrs, char *reply_buf,
 	   bool_t *reply_bool)
 {
-	char domain[YPMAXDOMAIN + 1], *p;
+	char *domain;
 	*reply_bool = FALSE;
-	if (xdr_string(request_xdrs, &p, sizeof(domainname))) {
-		*reply_bool = schema_supports_domain(p);
+	if (xdr_string(request_xdrs, &domain, YPMAXDOMAIN)) {
+		*reply_bool = schema_supports_domain(domain);
+		if (*reply_bool || reply_on_failure) {
+			slapi_log_error(SLAPI_LOG_PLUGIN,
+					state->plugin_desc->spd_id,
+					"domain(%s) -> %d\n",
+					domain, *reply_bool);
+			nis_reply(client, client_addr, client_addrlen,
+				  reply, reply_xdrs, reply_buf);
+		} else {
+			slapi_log_error(SLAPI_LOG_PLUGIN,
+					state->plugin_desc->spd_id,
+					"domain(%s) -> %d (no reply)\n",
+					domain, *reply_bool);
+		}
+	} else {
+		/* XXX */
+	}
+}
+
+static void
+nis_match(struct plugin_state *state,
+	  int client, struct sockaddr *client_addr, socklen_t client_addrlen,
+	  XDR *request_xdrs,
+	  struct rpc_msg *reply, XDR *reply_xdrs, char *reply_buf,
+	  struct ypresp_val *reply_val)
+{
+	struct ypreq_key req_key;
+	memset(&req_key, 0, sizeof(req_key));
+	if (xdr_ypreq_key(request_xdrs, &req_key)) {
+		reply_val->status = YP_TRUE;
+		reply_val->valdat.valdat_val = DUMMY_VAL;
+		reply_val->valdat.valdat_len = strlen(DUMMY_VAL);
+		slapi_log_error(SLAPI_LOG_PLUGIN,
+				state->plugin_desc->spd_id,
+				"match(%s/%s/%.*s) -> %d\n",
+				req_key.domain,
+				req_key.map,
+				(int) req_key.keydat.keydat_len,
+				req_key.keydat.keydat_val,
+				reply_val->status);
+		nis_reply(client, client_addr, client_addrlen,
+			  reply, reply_xdrs, reply_buf);
+	} else {
+		/* XXX */
 	}
-	if (*reply_bool || reply_on_failure) {
+}
+
+static void
+nis_first(struct plugin_state *state,
+	  int client, struct sockaddr *client_addr, socklen_t client_addrlen,
+	  XDR *request_xdrs,
+	  struct rpc_msg *reply, XDR *reply_xdrs, char *reply_buf,
+	  struct ypresp_key_val *reply_key_val)
+{
+	struct ypreq_nokey req_nokey;
+	memset(&req_nokey, 0, sizeof(req_nokey));
+	if (xdr_ypreq_nokey(request_xdrs, &req_nokey)) {
+		reply_key_val->status = YP_TRUE;
+		reply_key_val->keydat.keydat_val = DUMMY_KEY;
+		reply_key_val->keydat.keydat_len = strlen(DUMMY_KEY);
+		reply_key_val->valdat.valdat_val = DUMMY_VAL;
+		reply_key_val->valdat.valdat_len = strlen(DUMMY_VAL);
 		slapi_log_error(SLAPI_LOG_PLUGIN,
 				state->plugin_desc->spd_id,
-				"domain(%s) -> %d\n", p, *reply_bool);
+				"first(%s/%s) -> %d\n",
+				req_nokey.domain,
+				req_nokey.map,
+				reply_key_val->status);
 		nis_reply(client, client_addr, client_addrlen,
 			  reply, reply_xdrs, reply_buf);
 	} else {
+		/* XXX */
+	}
+}
+
+static void
+nis_next(struct plugin_state *state,
+	 int client, struct sockaddr *client_addr, socklen_t client_addrlen,
+	 XDR *request_xdrs,
+	 struct rpc_msg *reply, XDR *reply_xdrs, char *reply_buf,
+	 struct ypresp_key_val *reply_key_val)
+{
+	struct ypreq_key req_key;
+	memset(&req_key, 0, sizeof(req_key));
+	if (xdr_ypreq_key(request_xdrs, &req_key)) {
+		reply_key_val->status = YP_TRUE;
+		reply_key_val->keydat.keydat_val = DUMMY_KEY;
+		reply_key_val->keydat.keydat_len = strlen(DUMMY_KEY);
+		reply_key_val->valdat.valdat_val = DUMMY_VAL;
+		reply_key_val->valdat.valdat_len = strlen(DUMMY_VAL);
 		slapi_log_error(SLAPI_LOG_PLUGIN,
 				state->plugin_desc->spd_id,
-				"domain(%s) -> %d (no reply)\n",
-				p, *reply_bool);
+				"next(%s/%s/%.*s) -> %d\n",
+				req_key.domain,
+				req_key.map,
+				(int) req_key.keydat.keydat_len,
+				req_key.keydat.keydat_val,
+				reply_key_val->status);
+		nis_reply(client, client_addr, client_addrlen,
+			  reply, reply_xdrs, reply_buf);
+	} else {
+		/* XXX */
+	}
+}
+
+static void
+nis_master(struct plugin_state *state,
+	   int client, struct sockaddr *client_addr, socklen_t client_addrlen,
+	   XDR *request_xdrs,
+	   struct rpc_msg *reply, XDR *reply_xdrs, char *reply_buf,
+	   struct ypresp_master *reply_master)
+{
+	struct ypreq_nokey req_nokey;
+	memset(&req_nokey, 0, sizeof(req_nokey));
+	if (xdr_ypreq_nokey(request_xdrs, &req_nokey)) {
+		reply_master->status = YP_TRUE;
+		reply_master->master = "me, right here"; /* XXX */
+		slapi_log_error(SLAPI_LOG_PLUGIN,
+				state->plugin_desc->spd_id,
+				"master(%s/%s) -> %s\n",
+				req_nokey.domain,
+				req_nokey.map,
+				reply_master->master);
+		nis_reply(client, client_addr, client_addrlen,
+			  reply, reply_xdrs, reply_buf);
+	} else {
+		/* XXX */
+	}
+}
+
+static void
+nis_order(struct plugin_state *state,
+	  int client, struct sockaddr *client_addr, socklen_t client_addrlen,
+	  XDR *request_xdrs,
+	  struct rpc_msg *reply, XDR *reply_xdrs, char *reply_buf,
+	  struct ypresp_order *reply_order)
+{
+	struct ypreq_nokey req_nokey;
+	memset(&req_nokey, 0, sizeof(req_nokey));
+	if (xdr_ypreq_nokey(request_xdrs, &req_nokey)) {
+		reply_order->status = YP_TRUE;
+		reply_order->ordernum = time(NULL); /* XXX */
+		slapi_log_error(SLAPI_LOG_PLUGIN,
+				state->plugin_desc->spd_id,
+				"order(%s/%s) -> %d\n",
+				req_nokey.domain,
+				req_nokey.map,
+				reply_order->ordernum);
+		nis_reply(client, client_addr, client_addrlen,
+			  reply, reply_xdrs, reply_buf);
+	} else {
+		/* XXX */
+	}
+}
+
+static void
+nis_maplist(struct plugin_state *state,
+	    int client, struct sockaddr *client_addr, socklen_t client_addrlen,
+	    XDR *request_xdrs,
+	    struct rpc_msg *reply, XDR *reply_xdrs, char *reply_buf,
+	    struct ypresp_maplist *reply_maplist)
+{
+	char *domain;
+	struct ypmaplist *list;
+	if (xdr_string(request_xdrs, &domain, YPMAXDOMAIN)) {
+		reply_maplist->status = YP_TRUE;
+		reply_maplist->list = NULL; /* XXX */
+		if (reply_maplist->list == NULL) {
+			slapi_log_error(SLAPI_LOG_PLUGIN,
+					state->plugin_desc->spd_id,
+					"maplist(%s) -> (none)\n",
+					domain);
+		} else {
+			for (list = reply_maplist->list;
+			     list != NULL;
+			     list = list->next) {
+				slapi_log_error(SLAPI_LOG_PLUGIN,
+						state->plugin_desc->spd_id,
+						"maplist(%s) -> %s\n",
+						domain, list->map);
+			}
+		}
+		nis_reply(client, client_addr, client_addrlen,
+			  reply, reply_xdrs, reply_buf);
+	} else {
+		/* XXX */
+	}
+}
+
+static void
+nis_all(struct plugin_state *state,
+	int client, struct sockaddr *client_addr, socklen_t client_addrlen,
+	XDR *request_xdrs,
+	struct rpc_msg *reply, XDR *reply_xdrs, char *reply_buf,
+	bool_t *reply_more)
+{
+	char domain[YPMAXDOMAIN + 1], *p;
+	int i;
+	struct ypreq_nokey req_nokey;
+	struct ypresp_key_val reply_key_val;
+
+	memset(&reply_key_val, 0, sizeof(reply_key_val));
+	*reply_more = FALSE;
+	memset(&req_nokey, 0, sizeof(req_nokey));
+	if (xdr_ypreq_nokey(request_xdrs, &req_nokey)) {
+		slapi_log_error(SLAPI_LOG_PLUGIN,
+				state->plugin_desc->spd_id,
+				"all(%s/%s) -> %d\n",
+				req_nokey.domain,
+				req_nokey.map,
+				*reply_more);
+		*reply_more = TRUE;
+		nis_reply_fragment(client, client_addr, client_addrlen,
+				   reply, reply_xdrs, reply_buf, TRUE, FALSE);
+
+		xdr_setpos(reply_xdrs, 0);
+		for (i = 0; i < 3; i++) {
+			memset(&reply_key_val, 0, sizeof(reply_key_val));
+			reply_key_val.status = YP_TRUE;
+			reply_key_val.keydat.keydat_val = DUMMY_KEY;
+			reply_key_val.keydat.keydat_len = strlen(DUMMY_KEY);
+			reply_key_val.valdat.valdat_val = DUMMY_VAL;
+			reply_key_val.valdat.valdat_len = strlen(DUMMY_VAL);
+			xdr_ypresp_key_val(reply_xdrs, &reply_key_val);
+			if (i == 2) {
+				*reply_more = FALSE;
+			}
+			xdr_bool(reply_xdrs, reply_more);
+		}
+		nis_reply_fragment(client, client_addr, client_addrlen,
+				   reply, reply_xdrs, reply_buf, FALSE, TRUE);
+	} else {
+		/* XXX */
 	}
 }
 
-				if (xdr_ypreq_key(&request_xdrs, &req_key)) {
-					slapi_log_error(SLAPI_LOG_PLUGIN,
-							state->plugin_desc->spd_id,
-							"match(%s/%s/%.*s)? ",
-							req_key.domain,
-							req_key.map,
-							(int) req_key.keydat.keydat_len,
-							req_key.keydat.keydat_val);
-					memset(&resp_val, 0, sizeof(resp_val));
-					resp_val.status = YP_TRUE;
-					resp_val.valdat.valdat_val = "jimbo:*K*:1234:5678:Leeroy Jenkins:/home/leeroy:/bin/bash";
-					resp_val.valdat.valdat_len = strlen(resp_val.valdat.valdat_val);
-					reply.rm_reply.rp_stat = MSG_ACCEPTED;
-					reply.rm_reply.rp_acpt.ar_stat = SUCCESS;
-					reply.rm_reply.rp_acpt.ar_results.where = &resp_val;
-					reply.rm_reply.rp_acpt.ar_results.proc = xdr_ypresp_val;
-					slapi_log_error(SLAPI_LOG_PLUGIN,
-							state->plugin_desc->spd_id,
-							"-> %d\n",
-							resp_val.status);
-				}
 void
 nis_process_request(struct plugin_state *state, int client,
 		    struct sockaddr *client_addr, socklen_t client_addrlen,
@@ -95,10 +329,19 @@ nis_process_request(struct plugin_state *state, int client,
 	char reply_buf[64000], auth_buf[64000];
 	struct rpc_msg request, reply;
 	int superuser, send_reply, auth_flavor, auth_len;
+	struct ypresp_val reply_val;
+	struct ypresp_key_val reply_key_val;
+	struct ypresp_master reply_master;
+	struct ypresp_order reply_order;
+	struct ypresp_maplist reply_maplist;
+	struct accepted_reply *accepted;
+	bool_t reply_bool;
+
 	memset(&request_xdrs, 0, sizeof(request_xdrs));
 	memset(&reply_xdrs, 0, sizeof(reply_xdrs));
 	memset(&request, 0, sizeof(request));
 	memset(&reply, 0, sizeof(reply));
+
 	xdrmem_create(&request_xdrs, request_buf, request_buflen, XDR_DECODE);
 	if (xdr_callmsg(&request_xdrs, &request) &&
 	    (request.rm_direction == CALL)) {
@@ -108,6 +351,7 @@ nis_process_request(struct plugin_state *state, int client,
 				request.rm_call.cb_prog,
 				request.rm_call.cb_vers,
 				request.rm_call.cb_proc);
+
 		/* verify the client's creds */
 		auth_flavor = request.rm_call.cb_cred.oa_flavor;
 		switch (auth_flavor) {
@@ -141,6 +385,7 @@ nis_process_request(struct plugin_state *state, int client,
 			superuser = 0;
 		}
 		auth_destroy(request_auth);
+
 		/* setup authentication for our reply */
 		xdrmem_create(&auth_xdrs, auth_buf, sizeof(auth_buf),
 			      XDR_ENCODE);
@@ -157,12 +402,13 @@ nis_process_request(struct plugin_state *state, int client,
 		auth_destroy(reply_auth);
 		auth_len = xdr_getpos(&auth_xdrs);
 		xdr_destroy(&auth_xdrs);
+
 		/* fill out the common fields */
 		reply.rm_xid = request.rm_xid;
 		reply.rm_direction = REPLY;
-		send_reply = 1;
 		xdrmem_create(&reply_xdrs, reply_buf, sizeof(reply_buf),
 			      XDR_ENCODE);
+
 		/* check if the request is meant for us */
 		if ((request.rm_direction != CALL) ||
 		    (request.rm_call.cb_rpcvers != 2) ||
@@ -174,199 +420,129 @@ nis_process_request(struct plugin_state *state, int client,
 		} else {
 			/* default reply - success, no data */
 			reply.rm_reply.rp_stat = MSG_ACCEPTED;
-			reply.rm_reply.rp_acpt.ar_stat = SUCCESS;
-			reply.rm_reply.rp_acpt.ar_results.where = &reply_bool;
-			reply.rm_reply.rp_acpt.ar_results.proc = xdr_void;
+			accepted = &reply.rm_reply.rp_acpt;
+			accepted->ar_stat = SUCCESS;
+			accepted->ar_results.where = NULL;
+			accepted->ar_results.proc = xdr_void;
 			/* call the right function */
 			switch (request.rm_call.cb_proc) {
 			case YPPROC_NULL:
-			case YPPROC_XFR:
-			case YPPROC_CLEAR:
 				/* do nothing */
 				break;
 			case YPPROC_DOMAIN:
 			case YPPROC_DOMAIN_NONACK:
-				/* set reply type to be a boolean */
-				reply.rm_reply.rp_acpt.ar_results.where = &reply_bool;
-				reply.rm_reply.rp_acpt.ar_results.proc = xdr_bool;
-				nis_domain(&request_xdrs,
+				/* change reply type to be a boolean */
+				memset(&reply_bool, 0, sizeof(reply_bool));
+				accepted->ar_results.where = &reply_bool;
+				accepted->ar_results.proc = xdr_bool;
+				nis_domain(state,
+					   client, client_addr, client_addrlen,
+					   &request_xdrs,
 					   request.rm_call.cb_proc == YPPROC_DOMAIN,
-					   &reply,
-					   &reply_bool,
-					   reply_buf);
+					   &reply, &reply_xdrs, reply_buf,
+					   &reply_bool);
 				break;
 			case YPPROC_MATCH:
-				/* set reply type to a resp_val */
-				reply.rm_reply.rp_acpt.ar_results.where = &resp_val;
-				reply.rm_reply.rp_acpt.ar_results.proc = xdr_ypresp_val;
-				nis_match(&request_xdrs,
-					  request.rm_call.cb_proc == YPPROC_DOMAIN,
-					  &reply,
-					  &reply_val,
-					  reply_buf);
+				/* change reply type to a resp_val */
+				memset(&reply_val, 0, sizeof(reply_val));
+				accepted->ar_results.where = &reply_val;
+				accepted->ar_results.proc = xdr_ypresp_val;
+				nis_match(state,
+					  client, client_addr, client_addrlen,
+					  &request_xdrs,
+					  &reply, &reply_xdrs, reply_buf,
+					  &reply_val);
 				break;
 			case YPPROC_FIRST:
-				/* get first key/val */
-				if (xdr_ypreq_nokey(&request_xdrs, &req_nokey)) {
-					slapi_log_error(SLAPI_LOG_PLUGIN,
-							state->plugin_desc->spd_id,
-							"first(%s/%s)? ",
-							req_nokey.domain,
-							req_nokey.map);
-					memset(&resp_val, 0, sizeof(resp_val));
-					resp_key_val.status = YP_TRUE;
-					resp_key_val.keydat.keydat_val = "jimbo";
-					resp_key_val.keydat.keydat_len = strlen(resp_key_val.keydat.keydat_val);
-					resp_key_val.valdat.valdat_val = "jimbo:*K*:1234:5678:Leeroy Jenkins:/home/leeroy:/bin/bash";
-					resp_key_val.valdat.valdat_len = strlen(resp_key_val.valdat.valdat_val);
-					reply.rm_reply.rp_stat = MSG_ACCEPTED;
-					reply.rm_reply.rp_acpt.ar_stat = SUCCESS;
-					reply.rm_reply.rp_acpt.ar_results.where = &resp_key_val;
-					reply.rm_reply.rp_acpt.ar_results.proc = xdr_ypresp_key_val;
-					slapi_log_error(SLAPI_LOG_PLUGIN,
-							state->plugin_desc->spd_id,
-							"-> %d\n",
-							resp_key_val.status);
-				}
+				/* change reply type to a resp_keyval */
+				memset(&reply_key_val, 0,
+				       sizeof(reply_key_val));
+				accepted->ar_results.where = &reply_key_val;
+				accepted->ar_results.proc = xdr_ypresp_key_val;
+				nis_first(state,
+					  client, client_addr, client_addrlen,
+					  &request_xdrs,
+					  &reply, &reply_xdrs, reply_buf,
+					  &reply_key_val);
 				break;
 			case YPPROC_NEXT:
-				/* XXX */
+				/* change reply type to a resp_keyval */
+				memset(&reply_key_val, 0,
+				       sizeof(reply_key_val));
+				accepted->ar_results.where = &reply_key_val;
+				accepted->ar_results.proc = xdr_ypresp_key_val;
+				nis_next(state,
+					 client, client_addr, client_addrlen,
+					 &request_xdrs,
+					 &reply, &reply_xdrs, reply_buf,
+					 &reply_key_val);
+				break;
+			case YPPROC_XFR:
+				/* do nothing */
+				break;
+			case YPPROC_CLEAR:
+				/* do nothing */
 				break;
 			case YPPROC_ALL:
 				/* get all keys/vals */
-				if (xdr_ypreq_nokey(&request_xdrs, &req_nokey)) {
-					slapi_log_error(SLAPI_LOG_PLUGIN,
-							state->plugin_desc->spd_id,
-							"all(%s/%s)? ",
-							req_nokey.domain,
-							req_nokey.map);
-					bool_ret = 1;
-					reply.rm_reply.rp_stat = MSG_ACCEPTED;
-					reply.rm_reply.rp_acpt.ar_stat = SUCCESS;
-					reply.rm_reply.rp_acpt.ar_results.where = NULL;
-					reply.rm_reply.rp_acpt.ar_results.proc = xdr_void;
-					slapi_log_error(SLAPI_LOG_PLUGIN,
-							state->plugin_desc->spd_id,
-							"-> %d\n",
-							bool_ret);
+				memset(&reply_bool, 0, sizeof(reply_bool));
+				accepted->ar_results.where = &reply_bool;
+				accepted->ar_results.proc = xdr_bool;
+				/* sorry, only stream clients need apply */
+				if ((client_addr == NULL) &&
+				    (client_addrlen == 0)) {
+					nis_all(state,
+						client,
+						client_addr, client_addrlen,
+						&request_xdrs,
+						&reply, &reply_xdrs, reply_buf,
+						&reply_bool);
 				}
 				break;
 			case YPPROC_MASTER:
-				/* get the master */
-				if (xdr_ypreq_nokey(&request_xdrs, &req_nokey)) {
-					slapi_log_error(SLAPI_LOG_PLUGIN,
-							state->plugin_desc->spd_id,
-							"master(%s/%s)? ",
-							req_nokey.domain,
-							req_nokey.map);
-					memset(&resp_val, 0, sizeof(resp_val));
-					resp_master.status = YP_TRUE;
-					resp_master.master = "";
-					reply.rm_reply.rp_stat = MSG_ACCEPTED;
-					reply.rm_reply.rp_acpt.ar_stat = SUCCESS;
-					reply.rm_reply.rp_acpt.ar_results.where = &resp_master;
-					reply.rm_reply.rp_acpt.ar_results.proc = xdr_ypresp_master;
-					slapi_log_error(SLAPI_LOG_PLUGIN,
-							state->plugin_desc->spd_id,
-							"-> %d\n",
-							resp_master.status);
-				}
+				/* change reply type to a resp_master */
+				memset(&reply_master, 0, sizeof(reply_master));
+				accepted->ar_results.where = &reply_master;
+				accepted->ar_results.proc = xdr_ypresp_master;
+				nis_master(state,
+					   client, client_addr, client_addrlen,
+					   &request_xdrs,
+					   &reply, &reply_xdrs, reply_buf,
+					   &reply_master);
 				break;
 			case YPPROC_ORDER:
-				/* get the order */
-				if (xdr_ypreq_nokey(&request_xdrs, &req_nokey)) {
-					slapi_log_error(SLAPI_LOG_PLUGIN,
-							state->plugin_desc->spd_id,
-							"all(%s/%s)? ",
-							req_nokey.domain,
-							req_nokey.map);
-					memset(&resp_val, 0, sizeof(resp_val));
-					resp_order.status = YP_TRUE;
-					resp_order.ordernum = 0;
-					reply.rm_reply.rp_stat = MSG_ACCEPTED;
-					reply.rm_reply.rp_acpt.ar_stat = SUCCESS;
-					reply.rm_reply.rp_acpt.ar_results.where = &resp_order;
-					reply.rm_reply.rp_acpt.ar_results.proc = xdr_ypresp_order;
-					slapi_log_error(SLAPI_LOG_PLUGIN,
-							state->plugin_desc->spd_id,
-							"-> %d\n", resp_order.status);
-				}
+				/* change reply type to a resp_order */
+				memset(&reply_order, 0, sizeof(reply_order));
+				accepted->ar_results.where = &reply_order;
+				accepted->ar_results.proc = xdr_ypresp_order;
+				nis_order(state,
+					  client, client_addr, client_addrlen,
+					  &request_xdrs,
+					  &reply, &reply_xdrs, reply_buf,
+					  &reply_order);
 				break;
 			case YPPROC_MAPLIST:
+				/* change reply type to a resp_maplist */
+				memset(&reply_maplist, 0,
+				       sizeof(reply_maplist));
+				accepted->ar_results.where = &reply_maplist;
+				accepted->ar_results.proc = xdr_ypresp_maplist;
+				nis_maplist(state,
+					    client, client_addr, client_addrlen,
+					    &request_xdrs,
+					    &reply, &reply_xdrs, reply_buf,
+					    &reply_maplist);
 				break;
+			case YPPROC_NEWXFR:
+				/* what? XXX */
+				/* fall through */
 			default:
 				reply.rm_reply.rp_stat = MSG_DENIED;
 				reply.rm_reply.rp_rjct.rj_stat = RPC_MISMATCH;
+				nis_reply(client, client_addr, client_addrlen,
+					  &reply, &reply_xdrs, reply_buf);
 				break;
 			}
-			if (send_reply) {
-				if (reply.rm_reply.rp_stat == MSG_ACCEPTED) {
-					struct opaque_auth oa;
-					oa.oa_flavor = auth_flavor;
-					oa.oa_base = auth_buf;
-					oa.oa_length = auth_len;
-					reply.rm_reply.rp_acpt.ar_verf = oa;
-				}
-				slapi_log_error(SLAPI_LOG_PLUGIN,
-						state->plugin_desc->spd_id,
-						"encoding reply\n");
-				if (client_addr != NULL) {
-					xdr_replymsg(&reply_xdrs, &reply);
-					sendto(client,
-					       reply_buf,
-					       xdr_getpos(&reply_xdrs),
-					       0, client_addr, client_addrlen);
-				} else {
-					uint32_t len;
-					if (request.rm_call.cb_proc == YPPROC_ALL) {
-						resp_key_val.status = YP_TRUE;
-						resp_key_val.keydat.keydat_val = "jimbo";
-						resp_key_val.keydat.keydat_len = strlen(resp_key_val.keydat.keydat_val);
-						resp_key_val.valdat.valdat_val = "jimbo:*K*:1234:5678:Leeroy Jenkins:/home/leeroy:/bin/bash";
-						resp_key_val.valdat.valdat_len = strlen(resp_key_val.valdat.valdat_val);
-
-						xdr_setpos(&reply_xdrs, 4);
-						xdr_replymsg(&reply_xdrs, &reply);
-						bool_ret = 1;
-						xdr_bool(&reply_xdrs, &bool_ret);
-						xdr_ypresp_key_val(&reply_xdrs,
-								   &resp_key_val);
-						xdr_bool(&reply_xdrs, &bool_ret);
-						xdr_ypresp_key_val(&reply_xdrs,
-								   &resp_key_val);
-						len = htonl(xdr_getpos(&reply_xdrs) - 4);
-						memcpy(reply_buf, &len, 4);
-						slapi_log_error(SLAPI_LOG_PLUGIN,
-								state->plugin_desc->spd_id,
-								"sending %d bytes\n",
-								xdr_getpos(&reply_xdrs));
-						send(client, reply_buf,
-						     xdr_getpos(&reply_xdrs), 0);
-						xdr_setpos(&reply_xdrs, 4);
-						bool_ret = 1;
-						xdr_bool(&reply_xdrs, &bool_ret);
-						xdr_ypresp_key_val(&reply_xdrs,
-								   &resp_key_val);
-						bool_ret = 0;
-						xdr_bool(&reply_xdrs, &bool_ret);
-						len = htonl((xdr_getpos(&reply_xdrs) - 4) | 0x80000000);
-						memcpy(reply_buf, &len, 4);
-						slapi_log_error(SLAPI_LOG_PLUGIN,
-								state->plugin_desc->spd_id,
-								"sending %d bytes\n",
-								xdr_getpos(&reply_xdrs));
-						send(client, reply_buf,
-						     xdr_getpos(&reply_xdrs), 0);
-					}
-				}
-				slapi_log_error(SLAPI_LOG_PLUGIN,
-						state->plugin_desc->spd_id,
-						"sent reply\n");
-			} else {
-				slapi_log_error(SLAPI_LOG_PLUGIN,
-						state->plugin_desc->spd_id,
-						"suppressed reply\n");
-			}
 		}
 		xdr_destroy(&reply_xdrs);
 	}