text: /*
   * Copyright (c) 1995
   *	Bill Paul <wpaul@ctr.columbia.edu>.  All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in the
   *    documentation and/or other materials provided with the distribution.
   * 3. All advertising materials mentioning features or use of this software
   *    must display the following acknowledgement:
   *	This product includes software developed by Bill Paul.
   * 4. Neither the name of the author nor the names of any co-contributors
   *    may be used to endorse or promote products derived from this software
   *    without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR CONTRIBUTORS BE LIABLE
   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   *
   * $FreeBSD: src/usr.sbin/ypserv/yp_server.c,v 1.40 2006/06/09 14:01:07 maxim Exp $
   */
  
  #include "yp.h"
  #include "yp_extern.h"
  #include <dirent.h>
  #include <errno.h>
  #include <stdlib.h>
  #include <sys/stat.h>
  #include <sys/param.h>
  #include <sys/types.h>
  #include <sys/socket.h>
  #include <netinet/in.h>
  #include <arpa/inet.h>
  #include <rpc/rpc.h>
  
  int children = 0;
  
  #define	MASTER_STRING	"YP_MASTER_NAME"
  #define	MASTER_SZ	sizeof(MASTER_STRING) - 1
  #define	ORDER_STRING	"YP_LAST_MODIFIED"
  #define	ORDER_SZ	sizeof(ORDER_STRING) - 1
  
  static pid_t
  yp_fork(void)
  {
  	if (yp_pid != getpid()) {
  		yp_error("child %d trying to fork!", getpid());
  		errno = EEXIST;
  		return(-1);
  	}
  
  	return(fork());
  }
  
  /*
   * NIS v2 support. This is where most of the action happens.
   */
  
  void *
  ypproc_null_2_svc(void *argp, struct svc_req *rqstp)
  {
  	static char * result;
  	static char rval = 0;
  
  #ifdef DB_CACHE
  	if (yp_access(NULL, NULL, (struct svc_req *)rqstp))
  #else
  	if (yp_access(NULL, (struct svc_req *)rqstp))
  #endif
  		return(NULL);
  
  	result = &rval;
  
  	return((void *) &result);
  }
  
  bool_t *
  ypproc_domain_2_svc(domainname *argp, struct svc_req *rqstp)
  {
  	static bool_t  result;
  
  #ifdef DB_CACHE
  	if (yp_access(NULL, NULL, (struct svc_req *)rqstp)) {
  #else
  	if (yp_access(NULL, (struct svc_req *)rqstp)) {
  #endif
  		result = FALSE;
  		return (&result);
  	}
  
  	if (argp == NULL || yp_validdomain(*argp))
  		result = FALSE;
  	else
  		result = TRUE;
  
  	return (&result);
  }
  
  bool_t *
  ypproc_domain_nonack_2_svc(domainname *argp, struct svc_req *rqstp)
  {
  	static bool_t  result;
  
  #ifdef DB_CACHE
  	if (yp_access(NULL, NULL, (struct svc_req *)rqstp))
  #else
  	if (yp_access(NULL, (struct svc_req *)rqstp))
  #endif
  		return (NULL);
  
  	if (argp == NULL || yp_validdomain(*argp))
  		return (NULL);
  	else
  		result = TRUE;
  
  	return (&result);
  }
  
  ypresp_val *
  ypproc_match_2_svc(ypreq_key *argp, struct svc_req *rqstp)
  {
  	static ypresp_val  result;
  
  	result.val.valdat_val = "";
  	result.val.valdat_len = 0;
  
  #ifdef DB_CACHE
  	if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
  #else
  	if (yp_access(argp->map, (struct svc_req *)rqstp)) {
  #endif
  		result.stat = YP_YPERR;
  		return (&result);
  	}
  
  	if (argp->domain == NULL || argp->map == NULL) {
  		result.stat = YP_BADARGS;
  		return (&result);
  	}
  
  	if (yp_select_map(argp->map, argp->domain, NULL, 1) != YP_TRUE) {
  		result.stat = yp_errno;
  		return(&result);
  	}
  
  	result.stat = yp_getbykey(&argp->key, &result.val);
  
  	/*
  	 * Do DNS lookups for hosts maps if database lookup failed.
  	 */
  
  #ifdef DB_CACHE
  	if (do_dns && result.stat != YP_TRUE &&
  	    (yp_testflag(argp->map, argp->domain, YP_INTERDOMAIN) ||
  	    (strstr(argp->map, "hosts") || strstr(argp->map, "ipnodes")))) {
  #else
  	if (do_dns && result.stat != YP_TRUE &&
  	    (strstr(argp->map, "hosts") || strstr(argp->map, "ipnodes"))) {
  #endif
  		char			nbuf[YPMAXRECORD];
  
  		/* NUL terminate! NUL terminate!! NUL TERMINATE!!! */
  		bcopy(argp->key.keydat_val, nbuf, argp->key.keydat_len);
  		nbuf[argp->key.keydat_len] = '\0';
  
  		if (debug)
  			yp_error("doing DNS lookup of %s", nbuf);
  
  		if (!strcmp(argp->map, "hosts.byname"))
  			result.stat = yp_async_lookup_name(rqstp, nbuf,
  			    AF_INET);
  		else if (!strcmp(argp->map, "hosts.byaddr"))
  			result.stat = yp_async_lookup_addr(rqstp, nbuf,
  			    AF_INET);
  		else if (!strcmp(argp->map, "ipnodes.byname"))
  			result.stat = yp_async_lookup_name(rqstp, nbuf,
  			    AF_INET6);
  		else if (!strcmp(argp->map, "ipnodes.byaddr"))
  			result.stat = yp_async_lookup_addr(rqstp, nbuf,
  			    AF_INET6);
  
  		if (result.stat == YP_TRUE)
  			return(NULL);
  	}
  
  	return (&result);
  }
  
  ypresp_key_val *
  ypproc_first_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
  {
  	static ypresp_key_val  result;
  
  	result.val.valdat_val = result.key.keydat_val = "";
  	result.val.valdat_len = result.key.keydat_len = 0;
  
  #ifdef DB_CACHE
  	if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
  #else
  	if (yp_access(argp->map, (struct svc_req *)rqstp)) {
  #endif
  		result.stat = YP_YPERR;
  		return (&result);
  	}
  
  	if (argp->domain == NULL) {
  		result.stat = YP_BADARGS;
  		return (&result);
  	}
  
  	if (yp_select_map(argp->map, argp->domain, NULL, 0) != YP_TRUE) {
  		result.stat = yp_errno;
  		return(&result);
  	}
  
  	result.stat = yp_firstbykey(&result.key, &result.val);
  
  	return (&result);
  }
  
  ypresp_key_val *
  ypproc_next_2_svc(ypreq_key *argp, struct svc_req *rqstp)
  {
  	static ypresp_key_val  result;
  
  	result.val.valdat_val = result.key.keydat_val = "";
  	result.val.valdat_len = result.key.keydat_len = 0;
  
  #ifdef DB_CACHE
  	if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
  #else
  	if (yp_access(argp->map, (struct svc_req *)rqstp)) {
  #endif
  		result.stat = YP_YPERR;
  		return (&result);
  	}
  
  	if (argp->domain == NULL || argp->map == NULL) {
  		result.stat = YP_BADARGS;
  		return (&result);
  	}
  
  	if (yp_select_map(argp->map, argp->domain, &argp->key, 0) != YP_TRUE) {
  		result.stat = yp_errno;
  		return(&result);
  	}
  
  	result.key.keydat_len = argp->key.keydat_len;
  	result.key.keydat_val = argp->key.keydat_val;
  
  	result.stat = yp_nextbykey(&result.key, &result.val);
  
  	return (&result);
  }
  
  static void
  ypxfr_callback(ypxfrstat rval, struct sockaddr_in *addr, unsigned int transid,
  	       unsigned int prognum, unsigned long port)
  {
  	CLIENT *clnt;
  	int sock = RPC_ANYSOCK;
  	struct timeval timeout;
  	yppushresp_xfr ypxfr_resp;
  	struct rpc_err err;
  
  	timeout.tv_sec = 5;
  	timeout.tv_usec = 0;
  	addr->sin_port = htons(port);
  
  	if ((clnt = clntudp_create(addr,prognum,1,timeout,&sock)) == NULL) {
  		yp_error("%s: %s", inet_ntoa(addr->sin_addr),
  		  clnt_spcreateerror("failed to establish callback handle"));
  		return;
  	}
  
  	ypxfr_resp.status = rval;
  	ypxfr_resp.transid = transid;
  
  	/* Turn the timeout off -- we don't want to block. */
  	timeout.tv_sec = 0;
  	if (clnt_control(clnt, CLSET_TIMEOUT, &timeout) == FALSE)
  		yp_error("failed to set timeout on ypproc_xfr callback");
  
  	if (yppushproc_xfrresp_1(&ypxfr_resp, clnt) == NULL) {
  		clnt_geterr(clnt, &err);
  		if (err.re_status != RPC_SUCCESS &&
  		    err.re_status != RPC_TIMEDOUT)
  			yp_error("%s", clnt_sperror(clnt,
  				"ypxfr callback failed"));
  	}
  
  	clnt_destroy(clnt);
  	return;
  }
  
  #define YPXFR_RETURN(CODE) 						\
  	/* Order is important: send regular RPC reply, then callback */	\
  	result.xfrstat = CODE; 						\
  	svc_sendreply(rqstp->rq_xprt, (xdrproc_t)xdr_ypresp_xfr, &result); \
  	ypxfr_callback(CODE,rqhost,argp->transid, 			\
  					argp->prog,argp->port); 	\
  	return(NULL);
  
  ypresp_xfr *
  ypproc_xfr_2_svc(ypreq_xfr *argp, struct svc_req *rqstp)
  {
  	static ypresp_xfr  result;
  	struct sockaddr_in *rqhost;
  	ypresp_master *mres;
  	ypreq_nokey mreq;
  
  	result.transid = argp->transid;
  	rqhost = svc_getcaller(rqstp->rq_xprt);
  
  #ifdef DB_CACHE
  	if (yp_access(argp->map_parms.map,
  			argp->map_parms.domain, (struct svc_req *)rqstp)) {
  #else
  	if (yp_access(argp->map_parms.map, (struct svc_req *)rqstp)) {
  #endif
  		YPXFR_RETURN(YPXFR_REFUSED)
  	}
  
  
  	if (argp->map_parms.domain == NULL) {
  		YPXFR_RETURN(YPXFR_BADARGS)
  	}
  
  	if (yp_validdomain(argp->map_parms.domain)) {
  		YPXFR_RETURN(YPXFR_NODOM)
  	}
  
  	/*
  	 * Determine the master host ourselves. The caller may
  	 * be up to no good. This has the side effect of verifying
  	 * that the requested map and domain actually exist.
  	 */
  
  	mreq.domain = argp->map_parms.domain;
  	mreq.map = argp->map_parms.map;
  
  	mres = ypproc_master_2_svc(&mreq, rqstp);
  
  	if (mres->stat != YP_TRUE) {
  		yp_error("couldn't find master for map %s@%s",
  						argp->map_parms.map,
  						argp->map_parms.domain);
  		yp_error("host at %s (%s) may be pulling my leg",
  						argp->map_parms.peer,
  						inet_ntoa(rqhost->sin_addr));
  		YPXFR_RETURN(YPXFR_REFUSED)
  	}
  
  	switch (yp_fork()) {
  	case 0:
  	{
  		char g[11], t[11], p[11];
  		char ypxfr_command[MAXPATHLEN + 2];
  
  		snprintf (ypxfr_command, sizeof(ypxfr_command), "%sypxfr", _PATH_LIBEXEC);
  		snprintf (t, sizeof(t), "%u", argp->transid);
  		snprintf (g, sizeof(g), "%u", argp->prog);
  		snprintf (p, sizeof(p), "%u", argp->port);
  		if (debug) {
  			close(0); close(1); close(2);
  		}
  		if (strcmp(yp_dir, _PATH_YP)) {
  			execl(ypxfr_command, "ypxfr",
  			"-d", argp->map_parms.domain,
  		      	"-h", mres->peer,
  			"-p", yp_dir, "-C", t,
  		      	g, inet_ntoa(rqhost->sin_addr),
  			p, argp->map_parms.map,
  		      	NULL);
  		} else {
  			execl(ypxfr_command, "ypxfr",
  			"-d", argp->map_parms.domain,
  		      	"-h", mres->peer,
  			"-C", t,
  		      	g, inet_ntoa(rqhost->sin_addr),
  			p, argp->map_parms.map,
  		      	NULL);
  		}
  		yp_error("ypxfr execl(%s): %s", ypxfr_command, strerror(errno));
  		YPXFR_RETURN(YPXFR_XFRERR)
  		/*
  		 * Just to safe, prevent PR #10970 from biting us in
  		 * the unlikely case that execing ypxfr fails. We don't
  		 * want to have any child processes spawned from this
  		 * child process.
  		 */
  		_exit(0);
  		break;
  	}
  	case -1:
  		yp_error("ypxfr fork(): %s", strerror(errno));
  		YPXFR_RETURN(YPXFR_XFRERR)
  		break;
  	default:
  		result.xfrstat = YPXFR_SUCC;
  		children++;
  		break;
  	}
  
  	return (&result);
  }
  #undef YPXFR_RETURN
  
  void *
  ypproc_clear_2_svc(void *argp, struct svc_req *rqstp)
  {
  	static char * result;
  	static char rval = 0;
  
  #ifdef DB_CACHE
  	if (yp_access(NULL, NULL, (struct svc_req *)rqstp))
  #else
  	if (yp_access(NULL, (struct svc_req *)rqstp))
  #endif
  		return (NULL);
  #ifdef DB_CACHE
  	/* clear out the database cache */
  	yp_flush_all();
  #endif
  	/* Re-read the securenets database for the hell of it. */
  	load_securenets();
  
  	result = &rval;
  	return((void *) &result);
  }
  
  /*
   * For ypproc_all, we have to send a stream of ypresp_all structures
   * via TCP, but the XDR filter generated from the yp.x protocol
   * definition file only serializes one such structure. This means that
   * to send the whole stream, you need a wrapper which feeds all the
   * records into the underlying XDR routine until it hits an 'EOF.'
   * But to use the wrapper, you have to violate the boundaries between
   * RPC layers by calling svc_sendreply() directly from the ypproc_all
   * service routine instead of letting the RPC dispatcher do it.
   *
   * Bleah.
   */
  
  /*
   * Custom XDR routine for serialzing results of ypproc_all: keep
   * reading from the database and spew until we run out of records
   * or encounter an error.
   */
  static bool_t
  xdr_my_ypresp_all(XDR *xdrs, ypresp_all *objp)
  {
  	while (1) {
  		/* Get a record. */
  		if ((objp->ypresp_all_u.val.stat =
  			yp_nextbykey(&objp->ypresp_all_u.val.key,
  				     &objp->ypresp_all_u.val.val)) == YP_TRUE) {
  			objp->more = TRUE;
  		} else {
  			objp->more = FALSE;
  		}
  
  		/* Serialize. */
  		if (!xdr_ypresp_all(xdrs, objp))
  			return(FALSE);
  		if (objp->more == FALSE)
  			return(TRUE);
  	}
  }
  
  ypresp_all *
  ypproc_all_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
  {
  	static ypresp_all  result;
  
  	/*
  	 * Set this here so that the client will be forced to make
  	 * at least one attempt to read from us even if all we're
  	 * doing is returning an error.
  	 */
  	result.more = TRUE;
  	result.ypresp_all_u.val.key.keydat_len = 0;
  	result.ypresp_all_u.val.key.keydat_val = "";
  
  #ifdef DB_CACHE
  	if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
  #else
  	if (yp_access(argp->map, (struct svc_req *)rqstp)) {
  #endif
  		result.ypresp_all_u.val.stat = YP_YPERR;
  		return (&result);
  	}
  
  	if (argp->domain == NULL || argp->map == NULL) {
  		result.ypresp_all_u.val.stat = YP_BADARGS;
  		return (&result);
  	}
  
  	/*
  	 * XXX If we hit the child limit, fail the request.
  	 * If we don't, and the map is large, we could block for
  	 * a long time in the parent.
  	 */
  	if (children >= MAX_CHILDREN) {
  		result.ypresp_all_u.val.stat = YP_YPERR;
  		return(&result);
  	}
  
  	/*
  	 * The ypproc_all procedure can take a while to complete.
  	 * Best to handle it in a subprocess so the parent doesn't
  	 * block. (Is there a better way to do this? Maybe with
  	 * async socket I/O?)
  	 */
  	if (!debug) {
  		switch (yp_fork()) {
  		case 0:
  			break;
  		case -1:
  			yp_error("ypall fork(): %s", strerror(errno));
  			result.ypresp_all_u.val.stat = YP_YPERR;
  			return(&result);
  			break;
  		default:
  			children++;
  			return (NULL);
  			break;
  		}
  	}
  
  	/*
  	 * Fix for PR #10971: don't let the child ypserv share
  	 * DB handles with the parent process.
  	 */
  #ifdef DB_CACHE
  	yp_flush_all();
  #endif
  
  	if (yp_select_map(argp->map, argp->domain,
  				&result.ypresp_all_u.val.key, 0) != YP_TRUE) {
  		result.ypresp_all_u.val.stat = yp_errno;
  		return(&result);
  	}
  
  	/* Kick off the actual data transfer. */
  	svc_sendreply(rqstp->rq_xprt, (xdrproc_t)xdr_my_ypresp_all, &result);
  
  	/*
  	 * Proper fix for PR #10970: exit here so that we don't risk
  	 * having a child spawned from this sub-process.
  	 */
  	_exit(0);
  }
  
  ypresp_master *
  ypproc_master_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
  {
  	static ypresp_master  result;
  	static char ypvalbuf[YPMAXRECORD];
  	keydat key = { MASTER_SZ, MASTER_STRING };
  	valdat val;
  
  	result.peer = "";
  
  #ifdef DB_CACHE
  	if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
  #else
  	if (yp_access(argp->map, (struct svc_req *)rqstp)) {
  #endif
  		result.stat = YP_YPERR;
  		return(&result);
  	}
  
  	if (argp->domain == NULL) {
  		result.stat = YP_BADARGS;
  		return (&result);
  	}
  
  	if (yp_select_map(argp->map, argp->domain, &key, 1) != YP_TRUE) {
  		result.stat = yp_errno;
  		return(&result);
  	}
  
  	/*
  	 * Note that we copy the data retrieved from the database to
  	 * a private buffer and NUL terminate the buffer rather than
  	 * terminating the data in place. We do this because by stuffing
  	 * a '\0' into data.data, we will actually be corrupting memory
  	 * allocated by the DB package. This is a bad thing now that we
  	 * cache DB handles rather than closing the database immediately.
  	 */
  	result.stat = yp_getbykey(&key, &val);
  	if (result.stat == YP_TRUE) {
  		bcopy(val.valdat_val, &ypvalbuf, val.valdat_len);
  		ypvalbuf[val.valdat_len] = '\0';
  		result.peer = ypvalbuf;
  	} else
  		result.peer = "";
  
  	return (&result);
  }
  
  ypresp_order *
  ypproc_order_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
  {
  	static ypresp_order  result;
  	keydat key = { ORDER_SZ, ORDER_STRING };
  	valdat val;
  
  	result.ordernum = 0;
  
  #ifdef DB_CACHE
  	if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
  #else
  	if (yp_access(argp->map, (struct svc_req *)rqstp)) {
  #endif
  		result.stat = YP_YPERR;
  		return(&result);
  	}
  
  	if (argp->domain == NULL) {
  		result.stat = YP_BADARGS;
  		return (&result);
  	}
  
  	/*
  	 * We could just check the timestamp on the map file,
  	 * but that's a hack: we'll only know the last time the file
  	 * was touched, not the last time the database contents were
  	 * updated.
  	 */
  
  	if (yp_select_map(argp->map, argp->domain, &key, 1) != YP_TRUE) {
  		result.stat = yp_errno;
  		return(&result);
  	}
  
  	result.stat = yp_getbykey(&key, &val);
  
  	if (result.stat == YP_TRUE)
  		result.ordernum = atoi(val.valdat_val);
  	else
  		result.ordernum = 0;
  
  	return (&result);
  }
  
  static void
  yp_maplist_free(struct ypmaplist *yp_maplist)
  {
  	struct ypmaplist *next;
  
  	while (yp_maplist) {
  		next = yp_maplist->next;
  		free(yp_maplist->map);
  		free(yp_maplist);
  		yp_maplist = next;
  	}
  	return;
  }
  
  static struct ypmaplist *
  yp_maplist_create(const char *domain)
  {
  	char yp_mapdir[MAXPATHLEN + 2];
  	char yp_mapname[MAXPATHLEN + 2];
  	struct ypmaplist *cur = NULL;
  	struct ypmaplist *yp_maplist = NULL;
  	DIR *dird;
  	struct dirent *dirp;
  	struct stat statbuf;
  
  	snprintf(yp_mapdir, sizeof(yp_mapdir), "%s/%s", yp_dir, domain);
  
  	if ((dird = opendir(yp_mapdir)) == NULL) {
  		yp_error("opendir(%s) failed: %s", yp_mapdir, strerror(errno));
  		return(NULL);
  	}
  
  	while ((dirp = readdir(dird)) != NULL) {
  		if (strcmp(dirp->d_name, ".") && strcmp(dirp->d_name, "..")) {
  			snprintf(yp_mapname, sizeof(yp_mapname), "%s/%s",
  							yp_mapdir,dirp->d_name);
  			if (stat(yp_mapname, &statbuf) < 0 ||
  						!S_ISREG(statbuf.st_mode))
  				continue;
  			if ((cur = (struct ypmaplist *)
  				malloc(sizeof(struct ypmaplist))) == NULL) {
  				yp_error("malloc() failed");
  				closedir(dird);
  				yp_maplist_free(yp_maplist);
  				return(NULL);
  			}
  			if ((cur->map = strdup(dirp->d_name)) == NULL) {
  				yp_error("strdup() failed: %s",strerror(errno));
  				closedir(dird);
  				yp_maplist_free(yp_maplist);
  				free(cur);
  				return(NULL);
  			}
  			cur->next = yp_maplist;
  			yp_maplist = cur;
  			if (debug)
  				yp_error("map: %s", yp_maplist->map);
  		}
  
  	}
  	closedir(dird);
  	return(yp_maplist);
  }
  
  ypresp_maplist *
  ypproc_maplist_2_svc(domainname *argp, struct svc_req *rqstp)
  {
  	static ypresp_maplist  result = { 0, NULL };
  
  #ifdef DB_CACHE
  	if (yp_access(NULL, NULL, (struct svc_req *)rqstp)) {
  #else
  	if (yp_access(NULL, (struct svc_req *)rqstp)) {
  #endif
  		result.stat = YP_YPERR;
  		return(&result);
  	}
  
  	if (argp == NULL) {
  		result.stat = YP_BADARGS;
  		return (&result);
  	}
  
  	if (yp_validdomain(*argp)) {
  		result.stat = YP_NODOM;
  		return (&result);
  	}
  
  	/*
  	 * We have to construct a linked list for the ypproc_maplist
  	 * procedure using dynamically allocated memory. Since the XDR
  	 * layer won't free this list for us, we have to deal with it
  	 * ourselves. We call yp_maplist_free() first to free any
  	 * previously allocated data we may have accumulated to insure
  	 * that we have only one linked list in memory at any given
  	 * time.
  	 */
  
  	yp_maplist_free(result.maps);
  
  	if ((result.maps = yp_maplist_create(*argp)) == NULL) {
  		yp_error("yp_maplist_create failed");
  		result.stat = YP_YPERR;
  		return(&result);
  	} else
  		result.stat = YP_TRUE;
  
  	return (&result);
  }
  
  /*
   * NIS v1 support. The nullproc, domain and domain_nonack
   * functions from v1 are identical to those in v2, so all
   * we have to do is hand off to them.
   *
   * The other functions are mostly just wrappers around their v2
   * counterparts. For example, for the v1 'match' procedure, we
   * crack open the argument structure, make a request to the v2
   * 'match' function, repackage the data into a v1 response and
   * then send it on its way.
   *
   * Note that we don't support the pull, push and get procedures.
   * There's little documentation available to show what they
   * do, and I suspect they're meant largely for map transfers
   * between master and slave servers.
   */
  
  void *
  ypoldproc_null_1_svc(void *argp, struct svc_req *rqstp)
  {
  	return(ypproc_null_2_svc(argp, rqstp));
  }
  
  bool_t *
  ypoldproc_domain_1_svc(domainname *argp, struct svc_req *rqstp)
  {
  	return(ypproc_domain_2_svc(argp, rqstp));
  }
  
  bool_t *
  ypoldproc_domain_nonack_1_svc(domainname *argp, struct svc_req *rqstp)
  {
  	return (ypproc_domain_nonack_2_svc(argp, rqstp));
  }
  
  /*
   * the 'match' procedure sends a response of type YPRESP_VAL
   */
  ypresponse *
  ypoldproc_match_1_svc(yprequest *argp, struct svc_req *rqstp)
  {
  	static ypresponse  result;
  	ypresp_val *v2_result;
  
  	result.yp_resptype = YPRESP_VAL;
  	result.ypresponse_u.yp_resp_valtype.val.valdat_val = "";
  	result.ypresponse_u.yp_resp_valtype.val.valdat_len = 0;
  
  	if (argp->yp_reqtype != YPREQ_KEY) {
  		result.ypresponse_u.yp_resp_valtype.stat = YP_BADARGS;
  		return(&result);
  	}
  
  	v2_result = ypproc_match_2_svc(&argp->yprequest_u.yp_req_keytype,rqstp);
  	if (v2_result == NULL)
  		return(NULL);
  
  	bcopy(v2_result, &result.ypresponse_u.yp_resp_valtype,
  	      sizeof(ypresp_val));
  
  	return (&result);
  }
  
  /*
   * the 'first' procedure sends a response of type YPRESP_KEY_VAL
   */
  ypresponse *
  ypoldproc_first_1_svc(yprequest *argp, struct svc_req *rqstp)
  {
  	static ypresponse  result;
  	ypresp_key_val *v2_result;
  
  	result.yp_resptype = YPRESP_KEY_VAL;
  	result.ypresponse_u.yp_resp_key_valtype.val.valdat_val =
  	result.ypresponse_u.yp_resp_key_valtype.key.keydat_val = "";
  	result.ypresponse_u.yp_resp_key_valtype.val.valdat_len =
  	result.ypresponse_u.yp_resp_key_valtype.key.keydat_len = 0;
  
  	if (argp->yp_reqtype != YPREQ_NOKEY) {
  		result.ypresponse_u.yp_resp_key_valtype.stat = YP_BADARGS;
  		return(&result);
  	}
  
  	v2_result = ypproc_first_2_svc(&argp->yprequest_u.yp_req_nokeytype,
  									rqstp);
  	if (v2_result == NULL)
  		return(NULL);
  
  	bcopy(v2_result, &result.ypresponse_u.yp_resp_key_valtype,
  	      sizeof(ypresp_key_val));
  
  	return (&result);
  }
  
  /*
   * the 'next' procedure sends a response of type YPRESP_KEY_VAL
   */
  ypresponse *
  ypoldproc_next_1_svc(yprequest *argp, struct svc_req *rqstp)
  {
  	static ypresponse  result;
  	ypresp_key_val *v2_result;
  
  	result.yp_resptype = YPRESP_KEY_VAL;
  	result.ypresponse_u.yp_resp_key_valtype.val.valdat_val =
  	result.ypresponse_u.yp_resp_key_valtype.key.keydat_val = "";
  	result.ypresponse_u.yp_resp_key_valtype.val.valdat_len =
  	result.ypresponse_u.yp_resp_key_valtype.key.keydat_len = 0;
  
  	if (argp->yp_reqtype != YPREQ_KEY) {
  		result.ypresponse_u.yp_resp_key_valtype.stat = YP_BADARGS;
  		return(&result);
  	}
  
  	v2_result = ypproc_next_2_svc(&argp->yprequest_u.yp_req_keytype,rqstp);
  	if (v2_result == NULL)
  		return(NULL);
  
  	bcopy(v2_result, &result.ypresponse_u.yp_resp_key_valtype,
  	      sizeof(ypresp_key_val));
  
  	return (&result);
  }
  
  /*
   * the 'poll' procedure sends a response of type YPRESP_MAP_PARMS
   */
  ypresponse *
  ypoldproc_poll_1_svc(yprequest *argp, struct svc_req *rqstp)
  {
  	static ypresponse  result;
  	ypresp_master *v2_result1;
  	ypresp_order *v2_result2;
  
  	result.yp_resptype = YPRESP_MAP_PARMS;
  	result.ypresponse_u.yp_resp_map_parmstype.domain =
  		argp->yprequest_u.yp_req_nokeytype.domain;
  	result.ypresponse_u.yp_resp_map_parmstype.map =
  		argp->yprequest_u.yp_req_nokeytype.map;
  	/*
  	 * Hmm... there is no 'status' value in the
  	 * yp_resp_map_parmstype structure, so I have to
  	 * guess at what to do to indicate a failure.
  	 * I hope this is right.
  	 */
  	result.ypresponse_u.yp_resp_map_parmstype.ordernum = 0;
  	result.ypresponse_u.yp_resp_map_parmstype.peer = "";
  
  	if (argp->yp_reqtype != YPREQ_MAP_PARMS) {
  		return(&result);
  	}
  
  	v2_result1 = ypproc_master_2_svc(&argp->yprequest_u.yp_req_nokeytype,
  									rqstp);
  	if (v2_result1 == NULL)
  		return(NULL);
  
  	if (v2_result1->stat != YP_TRUE) {
  		return(&result);
  	}
  
  	v2_result2 = ypproc_order_2_svc(&argp->yprequest_u.yp_req_nokeytype,
  									rqstp);
  	if (v2_result2 == NULL)
  		return(NULL);
  
  	if (v2_result2->stat != YP_TRUE) {
  		return(&result);
  	}
  
  	result.ypresponse_u.yp_resp_map_parmstype.peer =
  		v2_result1->peer;
  	result.ypresponse_u.yp_resp_map_parmstype.ordernum =
  		v2_result2->ordernum;
  
  	return (&result);
  }
  
  ypresponse *
  ypoldproc_push_1_svc(yprequest *argp, struct svc_req *rqstp)
  {
  	static ypresponse  result;
  
  	/*
  	 * Not implemented.
  	 */
  
  	return (&result);
  }
  
  ypresponse *
  ypoldproc_pull_1_svc(yprequest *argp, struct svc_req *rqstp)
  {
  	static ypresponse  result;
  
  	/*
  	 * Not implemented.
  	 */
  
  	return (&result);
  }
  
  ypresponse *
  ypoldproc_get_1_svc(yprequest *argp, struct svc_req *rqstp)
  {
  	static ypresponse  result;
  
  	/*
  	 * Not implemented.
  	 */
  
  	return (&result);
  }
  