initial import of NetBSD tree

4 files changed, 1540 insertions, 0 deletions

diff --git a/lib/libc/yp/Makefile.inc b/lib/libc/yp/Makefile.inc
new file mode 100644
index 00000000000..8ab81a555ee
--- /dev/null
+++ b/lib/libc/yp/Makefile.inc
@@ -0,0 +1,12 @@
+#	$NetBSD: Makefile.inc,v 1.9 1995/09/12 19:40:27 thorpej Exp $
+
+# yp sources
+.PATH: ${.CURDIR}/arch/${MACHINE_ARCH}/yp ${.CURDIR}/yp
+
+SRCS+=	xdryp.c yplib.c
+MAN+=	ypclnt.3
+
+MLINKS+=ypclnt.3 yp_all.3 ypclnt.3 yp_bind.3 ypclnt.3 yp_first.3 \
+	ypclnt.3 yp_get_default_domain.3 ypclnt.3 yp_master.3 \
+	ypclnt.3 yp_match.3 ypclnt.3 yp_next.3 ypclnt.3 yp_order.3 \
+	ypclnt.3 yp_unbind.3 ypclnt.3 yperr_string.3 ypclnt.3 ypprot_err.3
diff --git a/lib/libc/yp/xdryp.c b/lib/libc/yp/xdryp.c
new file mode 100644
index 00000000000..72cfb836ea4
--- /dev/null
+++ b/lib/libc/yp/xdryp.c
@@ -0,0 +1,348 @@
+/*	$NetBSD: xdryp.c,v 1.9 1995/07/14 21:04:17 christos Exp $	*/
+
+/*
+ * Copyright (c) 1992, 1993 Theo de Raadt <deraadt@fsa.ca>
+ * 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 Theo de Raadt.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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.
+ */
+
+#ifndef LINT
+static char *rcsid = "$NetBSD: xdryp.c,v 1.9 1995/07/14 21:04:17 christos Exp $";
+#endif
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <rpc/rpc.h>
+#include <rpc/xdr.h>
+#include <rpcsvc/yp_prot.h>
+#include <rpcsvc/ypclnt.h>
+
+extern int (*ypresp_allfn) __P((u_long, char *, int, char *, int, void *));
+extern void *ypresp_data;
+
+bool_t
+xdr_domainname(xdrs, objp)
+XDR *xdrs;
+char *objp;
+{
+	return xdr_string(xdrs, &objp, YPMAXDOMAIN);
+}
+
+bool_t
+xdr_peername(xdrs, objp)
+XDR *xdrs;
+char *objp;
+{
+	return xdr_string(xdrs, &objp, YPMAXPEER);
+}
+
+bool_t
+xdr_datum(xdrs, objp)
+XDR *xdrs;
+datum *objp;
+{
+	return xdr_bytes(xdrs, (char **)&objp->dptr,
+			 (u_int *)&objp->dsize, YPMAXRECORD);
+}
+
+bool_t
+xdr_mapname(xdrs, objp)
+XDR *xdrs;
+char *objp;
+{
+	return xdr_string(xdrs, &objp, YPMAXMAP);
+}
+
+bool_t
+xdr_ypreq_key(xdrs, objp)
+XDR *xdrs;
+struct ypreq_key *objp;
+{
+	if (!xdr_domainname(xdrs, (char *)objp->domain)) {
+		return FALSE;
+	}
+	if (!xdr_mapname(xdrs, (char *)objp->map)) {
+		return FALSE;
+	}
+	return xdr_datum(xdrs, &objp->keydat);
+}
+
+bool_t
+xdr_ypreq_nokey(xdrs, objp)
+XDR *xdrs;
+struct ypreq_nokey *objp;
+{
+	if (!xdr_domainname(xdrs, (char *)objp->domain)) {
+		return FALSE;
+	}
+	return xdr_mapname(xdrs, (char *)objp->map);
+}
+
+bool_t
+xdr_yp_inaddr(xdrs, objp)
+XDR *xdrs;
+struct in_addr *objp;
+{
+	return xdr_opaque(xdrs, (caddr_t)&objp->s_addr, sizeof objp->s_addr);
+}
+
+bool_t
+xdr_ypbind_binding(xdrs, objp)
+XDR *xdrs;
+struct ypbind_binding *objp;
+{
+	if (!xdr_yp_inaddr(xdrs, &objp->ypbind_binding_addr)) {
+		return FALSE;
+	}
+	return xdr_opaque(xdrs, (void *)&objp->ypbind_binding_port,
+	    sizeof objp->ypbind_binding_port);
+}
+
+bool_t
+xdr_ypbind_resptype(xdrs, objp)
+XDR *xdrs;
+enum ypbind_resptype *objp;
+{
+	return xdr_enum(xdrs, (enum_t *)objp);
+}
+
+bool_t
+xdr_ypstat(xdrs, objp)
+XDR *xdrs;
+enum ypbind_resptype *objp;
+{
+	return xdr_enum(xdrs, (enum_t *)objp);
+}
+
+bool_t
+xdr_ypbind_resp(xdrs, objp)
+XDR *xdrs;
+struct ypbind_resp *objp;
+{
+	if (!xdr_ypbind_resptype(xdrs, &objp->ypbind_status)) {
+		return FALSE;
+	}
+
+	switch (objp->ypbind_status) {
+	case YPBIND_FAIL_VAL:
+		return xdr_u_int(xdrs,
+				 (u_int *)&objp->ypbind_respbody.ypbind_error);
+	case YPBIND_SUCC_VAL:
+		return xdr_ypbind_binding(xdrs, 
+				 &objp->ypbind_respbody.ypbind_bindinfo);
+	default:
+		return FALSE;
+	}
+	/* NOTREACHED */
+}
+
+bool_t
+xdr_ypresp_val(xdrs, objp)
+XDR *xdrs;
+struct ypresp_val *objp;
+{
+	if (!xdr_ypstat(xdrs, (enum ypbind_resptype *)&objp->status)) {
+		return FALSE;
+	}
+	return xdr_datum(xdrs, &objp->valdat);
+}
+
+bool_t
+xdr_ypbind_setdom(xdrs, objp)
+XDR *xdrs;
+struct ypbind_setdom *objp;
+{
+	if (!xdr_domainname(xdrs, objp->ypsetdom_domain)) {
+		return FALSE;
+	}
+	if (!xdr_ypbind_binding(xdrs, &objp->ypsetdom_binding)) {
+		return FALSE;
+	}
+	return xdr_u_short(xdrs, &objp->ypsetdom_vers);
+}
+
+bool_t
+xdr_ypresp_key_val(xdrs, objp)
+XDR *xdrs;
+struct ypresp_key_val *objp;
+{
+	if (!xdr_ypstat(xdrs, (enum ypbind_resptype *)&objp->status)) {
+		return FALSE;
+	}
+	if (!xdr_datum(xdrs, &objp->valdat)) {
+		return FALSE;
+	}
+	return xdr_datum(xdrs, &objp->keydat);
+}
+
+bool_t
+xdr_ypresp_all(xdrs, objp)
+XDR *xdrs;
+struct ypresp_all *objp;
+{
+	if (!xdr_bool(xdrs, &objp->more)) {
+		return FALSE;
+	}
+	switch (objp->more) {
+	case TRUE:
+		return xdr_ypresp_key_val(xdrs, &objp->ypresp_all_u.val);
+	case FALSE:
+		return (TRUE);
+	default:
+		return FALSE;
+	}
+	/* NOTREACHED */
+}
+
+bool_t
+xdr_ypresp_all_seq(xdrs, objp)
+XDR *xdrs;
+u_long *objp;
+{
+	struct ypresp_all out;
+	u_long status;
+	char *key, *val;
+	int size;
+	int r;
+
+	memset(&out, 0, sizeof out);
+	while(1) {
+		if( !xdr_ypresp_all(xdrs, &out)) {
+			xdr_free(xdr_ypresp_all, (char *)&out);
+			*objp = YP_YPERR;
+			return FALSE;
+		}
+		if(out.more == 0) {
+			xdr_free(xdr_ypresp_all, (char *)&out);
+			return FALSE;
+		}
+		status = out.ypresp_all_u.val.status;
+		switch(status) {
+		case YP_TRUE:
+			size = out.ypresp_all_u.val.keydat.dsize;
+			if ((key = malloc(size + 1)) != NULL) {
+				(void)memcpy(key,
+					     out.ypresp_all_u.val.keydat.dptr,
+					     size);
+				key[size] = '\0';
+			}
+			size = out.ypresp_all_u.val.valdat.dsize;
+			if ((val = malloc(size + 1)) != NULL) {
+				(void)memcpy(val,
+					     out.ypresp_all_u.val.valdat.dptr,
+					     size);
+				val[size] = '\0';
+			}
+			else {
+				free(key);
+				key = NULL;
+			}
+			xdr_free(xdr_ypresp_all, (char *)&out);
+
+			if (key == NULL || val == NULL)
+				return FALSE;
+
+			r = (*ypresp_allfn)(status,
+				key, out.ypresp_all_u.val.keydat.dsize,
+				val, out.ypresp_all_u.val.valdat.dsize,
+				ypresp_data);
+			*objp = status;
+			free(key);
+			free(val);
+			if(r)
+				return TRUE;
+			break;
+		case YP_NOMORE:
+			xdr_free(xdr_ypresp_all, (char *)&out);
+			return TRUE;
+		default:
+			xdr_free(xdr_ypresp_all, (char *)&out);
+			*objp = status;
+			return TRUE;
+		}
+	}
+}
+
+bool_t
+xdr_ypresp_master(xdrs, objp)
+XDR *xdrs;
+struct ypresp_master *objp;
+{
+	if (!xdr_ypstat(xdrs, (enum ypbind_resptype *)&objp->status)) {
+		return FALSE;
+	}
+	return xdr_string(xdrs, &objp->master, YPMAXPEER);
+}
+
+bool_t
+xdr_ypmaplist_str(xdrs, objp)
+XDR *xdrs;
+char *objp;
+{
+	return xdr_string(xdrs, &objp, YPMAXMAP+1);
+}
+
+bool_t
+xdr_ypmaplist(xdrs, objp)
+XDR *xdrs;
+struct ypmaplist *objp;
+{
+	if (!xdr_ypmaplist_str(xdrs, objp->ypml_name)) {
+		return FALSE;
+	}
+	return xdr_pointer(xdrs, (caddr_t *)&objp->ypml_next,
+	    sizeof(struct ypmaplist), xdr_ypmaplist);
+}
+
+bool_t
+xdr_ypresp_maplist(xdrs, objp)
+XDR *xdrs;
+struct ypresp_maplist *objp;
+{
+	if (!xdr_ypstat(xdrs, (enum ypbind_resptype *)&objp->status)) {
+		return FALSE;
+	}
+	return xdr_pointer(xdrs, (caddr_t *)&objp->list,
+	    sizeof(struct ypmaplist), xdr_ypmaplist);
+}
+
+bool_t
+xdr_ypresp_order(xdrs, objp)
+XDR *xdrs;
+struct ypresp_order *objp;
+{
+	if (!xdr_ypstat(xdrs, (enum ypbind_resptype *)&objp->status)) {
+		return FALSE;
+	}
+	return xdr_u_long(xdrs, &objp->ordernum);
+}
diff --git a/lib/libc/yp/ypclnt.3 b/lib/libc/yp/ypclnt.3
new file mode 100644
index 00000000000..4a632e64874
--- /dev/null
+++ b/lib/libc/yp/ypclnt.3
@@ -0,0 +1,337 @@
+.\"	$NetBSD: ypclnt.3,v 1.4 1995/09/12 19:33:03 thorpej Exp $
+.\"
+.\" Copyright (c) 1994 Jason R. Thorpe
+.\" 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 Jason Thorpe.
+.\" 4. Neither the name of the author nor the names of its contributors
+.\"    may be used to endorse or promote products derived from this software
+.\"    without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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.
+.\"
+.Dd October 26, 1994
+.Dt YPCLNT 3
+.Os
+.Sh NAME
+.Nm yp_all ,
+.Nm yp_bind ,
+.Nm yp_first ,
+.Nm yp_get_default_domain ,
+.Nm yp_master ,
+.Nm yp_match ,
+.Nm yp_next ,
+.Nm yp_order ,
+.Nm yp_unbind ,
+.Nm yperr_string ,
+.Nm ypprot_err
+.Nd Interface to the YP subsystem
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <rpcsvc/ypclnt.h>
+.Fd #include <rpcsvc/yp_prot.h>
+.Ft int
+.Fn yp_all "char *indomain" "char *inmap" "struct ypall_callback *incallback"
+.Ft int
+.Fn yp_bind "char *dom"
+.Ft int
+.Fn yp_first "char *indomain" "char *inmap" "char **outkey" "int *outkeylen" "char **outval" "int *outvallen"
+.Ft int
+.Fn yp_get_default_domain "char **domp"
+.Ft int
+.Fn yp_master "char *indomain" "char *inmap" "char **outname"
+.Ft int
+.Fn yp_match "char *indomain" "char *inmap" "const char *inkey" "int inkeylen" "char **outval" "int *outvallen"
+.Ft int
+.Fn yp_next "char *indomain" "char *inmap" "char *inkey" "int inkeylen" "char **outkey" "int *outkeylen" "char **outval" "int *outvallen"
+.Ft int
+.Fn yp_order "char *indomain" "char *inmap" "char *outorder"
+.Ft void
+.Fn yp_unbind "char *dom"
+.Ft char *
+.Fn yperr_string "int incode"
+.Ft int
+.Fn ypprot_err "unsigned int incode"
+.Sh DESCRIPTION
+The
+.Nm ypclnt
+suite provides an interface to the YP subsystem.  For a general description
+of the YP subsystem, see
+.Xr yp 8 .
+.Pp
+For all functions, input values begin with
+.Pa in
+and output values begin with
+.Pa out .
+Any output values of type
+.Em char **
+should be the addresses of uninitialized character pointers.  Memory will be
+allocated by the YP client routines using
+.Fn malloc .
+This memory can later be freed by the user if there is no additional need for
+the data stored there.  For
+.Pa outkey
+and
+.Pa outval ,
+two extra bytes of memory are allocated for a
+.Ql \en
+and
+.Ql \e0 ,
+which are not
+reflected in the values of
+.Pa outkeylen
+or
+.Pa outvallen .
+All occurrences of
+.Pa indomain
+and
+.Pa inmap
+must be non-null, null-terminated strings.  All input strings which also have
+a corresponding length parameter cannot be null unless the corresponding
+length value is zero.  Such strings need not be null-terminated.
+.Pp
+All YP lookup calls (the functions
+.Fn yp_all ,
+.Fn yp_first ,
+.Fn yp_master ,
+.Fn yp_match ,
+.Fn yp_next ,
+.Fn yp_order )
+require a YP domain name and a YP map name.  The default domain name may be 
+obtained by calling
+.Fn yp_get_default_domain ,
+and should thus be used before all other YP calls in a client program.
+The value it places
+.Pa outdomain
+is suitable for use as the
+.Pa indomain
+parameter to all subsequent YP calls.
+.Pp
+In order for YP lookup calls to succeed, the client process must be bound
+to a YP server process.  The client process need not explicitly bind to
+the server, as it happens automatically whenever a lookup occurs.
+The function
+.Fn yp_bind
+is provided for a backup strategy, e.g. a local file, when a YP server process
+is not available.  Each binding uses one socket descriptor on the client
+process, which may be explicitly freed using
+.Fn yp_unbind ,
+which frees all per-process and per-node resources to bind the domain and
+marks the domain unbound.
+.Pp
+If, during a YP lookup, an RPC failure occurs, the domain used in the lookup
+is automatically marked unbound and the
+.Nm ypclnt
+layer retries the lookup as long as
+.Xr ypbind 8
+is running and either the client process cannot bind to a server for the domain
+specified in the lookup, or RPC requests to the YP server process fail.
+If an error is not RPC-related, one of the YP error codes described below
+is returned and control given back to the user code.
+.Pp
+The
+.Nm ypclnt
+suite provides the following functionality:
+.Bl -tag -width Fn yp_match
+.It Fn yp_match
+Provides the value associated with the given key.
+.It Fn yp_first
+Provides the first key-value pair from the given map in the named domain.
+.It Fn yp_next
+Provides the next key-value pair in the given map.  To obtain the second pair,
+the
+.Pa inkey
+value should be the
+.Pa outkey
+value provided by the initial call to
+.Fn yp_first .
+In the general case, the next key-value pair may be obtained by using the
+.Pa outkey
+value from the previous call to
+.Fn yp_next
+as the value for
+.Pa inkey .
+.Pp
+Of course, the notions of ``first'' and ``next'' are particular to the
+type of YP map being accessed, and thus there is no guarantee of lexical
+order.  The only guarantees provided with
+.Fn yp_first
+and
+.Fn yp_next ,
+providing that the same map on the same server is polled repeatedly
+until
+.Fn yp_next
+returns YPERR_NOMORE, are that all key-value pairs in that map will be accessed
+exactly once, and if the entire procedure is repeated, the order will be
+the same.
+.Pp
+If the server is heaviliy loaded or the server fails for some reason, the
+domain being used may become unbound.  If this happens, and the client process
+re-binds, the retrieval rules will break: some entries may be seen twice, and
+others not at all.  For this reason, the function
+.Fn yp_all
+provides a better solution for reading all of the entries in a particular
+map.
+.It Fn yp_all
+This function provides a way to transfer an entire an entire map from
+the server to the client process with a single request.  This transfer
+uses TCP, unlike all other functions in the
+.Nm ypclnt
+suite, which use UDP.  The entire transaction occurs in a single RPC
+request-response.  The third argument to this function provides a way
+to supply the name of a function to process each key-value pair in the
+map.
+.Fn Yp_all
+returns after the entire transaction is complete, or the
+.Pa foreach
+function decides that it does not want any more key-value pairs.  The third
+argument to
+.Fn yp_all
+is:
+.Bd -literal -offset indent
+struct ypall_callback *incallback {
+	int (*foreach)();
+	char *data;
+};
+.Ed
+.Pp
+The
+.Em char *data
+argument is an opaque pointer for use by the callback function.  The
+.Pa foreach
+function should return non-zero when it no longer wishes to process
+key-value pairs, at which time
+.Fn yp_all
+returns a value of 0, and is called with the following arguments:
+.Pp
+.Bd -literal -offset indent
+int foreach (
+	int instatus,
+	char *inkey,
+	int inkeylen,
+	char *inval,
+	int invallen,
+	char *indata
+);
+.Ed
+.Pp
+Where:
+.Bl -tag -width "inkey, inval"
+.It Fa instatus
+Holds one of the return status values described in
+.Nm <rpcsvc/yp_prot.h> :
+see
+.Fn ypprot_err
+below for a function that will translate YP protocol errors into a
+.Nm ypclnt
+layer error code as described in
+.Nm <rpcsvc/ypclnt.h> .
+.It Fa inkey, inval
+The key and value arguments are somewhat different here than described
+above.  In this case, the memory pointed to by
+.Fa inkey
+and
+.Fa inval
+is private to
+.Fn yp_all ,
+and is overwritten with each subsequent key-value pair, thus the
+.Pa foreach
+function should do something useful with the contents of that memory during
+each iteration.  If the key-value pairs are not terminated with either
+.Ql \en
+or
+.Ql \e0
+in the map, then they will not be terminated as such when given to the
+.Pa foreach
+function, either.
+.It Fa indata
+This is the contents of the
+.Pa incallback->data
+element of the callback structure.  It is provided as a means to share
+state between the
+.Pa foreach
+function and the user code.  Its use is completely optional: cast it to
+something useful or simply ignore it.
+.El
+.It Fn yp_order
+Returns the order number for a map.
+.It Fn yp_master
+Returns the hostname for the machine on which the master YP server process for
+a map is running.
+.It Fn yperr_string
+Returns a pointer to a null-terminated error string that does not contain a
+.Ql \&.
+or
+.Ql \en .
+.It Fn ypprot_err
+Converts a YP protocol error code to a
+.Nm ypclnt
+error code suitable for
+.Fn yperr_string .
+.El
+.Sh RETURN VALUES
+All functions in the
+.Nm ypclnt
+suite which are of type
+.Em int
+return 0 upon success or one of the following error codes upon failure:
+.Bl -tag -width "YPERR_BADARGS   "
+.It Bq Er YPERR_BADARGS
+The passed arguments to the function are invalid
+.It Bq Er YPERR_BADDB
+The YP map that was polled is defective.
+.It Bq Er YPERR_DOMAIN
+Client process cannot bind to server on this YP domain.
+.It Bq Er YPERR_KEY
+The key passed does not exist.
+.It Bq Er YPERR_MAP
+There is no such map in the server's domain.
+.It Bq Er YPERR_DOM
+The local YP domain is not set.
+.It Bq Er YPERR_NOMORE
+There are no more records in the queried map.
+.It Bq Er YPERR_PMAP
+Cannot communicate with portmap.
+.It Bq Er YPERR_RESRC
+A resource allocation failure occurred.
+.It Bq Er YPERR_RPC
+An RPC failure has occurred.  The domain has been marked unbound.
+.It Bq Er YPERR_VERS
+Client/server version mismatch.  If the server is running version 1
+of the YP protocol,
+.Fn yp_all
+functionality does not exist.
+.It Bq Er YPERR_BIND
+Cannot communicate with
+.Xr ypbind 8 .
+.It Bq Er YPERR_YPERR
+An internal server or client error has occurred.
+.It Bq Er YPERR_YPSERV
+The client cannot communicate with the YP server process.
+.El
+.Sh SEE ALSO
+.Xr malloc 3 ,
+.Xr ypbind 8 ,
+.Xr yp 8
+.Sh AUTHOR
+Theo De Raadt
diff --git a/lib/libc/yp/yplib.c b/lib/libc/yp/yplib.c
new file mode 100644
index 00000000000..720c02a794b
--- /dev/null
+++ b/lib/libc/yp/yplib.c
@@ -0,0 +1,843 @@
+/*	$NetBSD: yplib.c,v 1.16 1995/07/14 21:04:24 christos Exp $	 */
+
+/*
+ * Copyright (c) 1992, 1993 Theo de Raadt <deraadt@fsa.ca>
+ * 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 Theo de Raadt.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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.
+ */
+
+#ifndef LINT
+static char rcsid[] = "$NetBSD: yplib.c,v 1.16 1995/07/14 21:04:24 christos Exp $";
+#endif
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/file.h>
+#include <sys/uio.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <rpc/rpc.h>
+#include <rpc/xdr.h>
+#include <rpcsvc/yp_prot.h>
+#include <rpcsvc/ypclnt.h>
+
+#define BINDINGDIR	"/var/yp/binding"
+#define YPBINDLOCK	"/var/run/ypbind.lock"
+#define YPMATCHCACHE
+
+int (*ypresp_allfn) __P((u_long, char *, int, char *, int, void *));
+void *ypresp_data;
+
+struct dom_binding *_ypbindlist;
+static char _yp_domain[MAXHOSTNAMELEN];
+int _yplib_timeout = 10;
+
+static bool_t ypmatch_add __P((const char *, const char *, int, char *, int));
+static bool_t ypmatch_find __P((const char *, const char *, int, const char **,
+				int *));
+static void _yp_unbind __P((struct dom_binding *));
+
+#ifdef YPMATCHCACHE
+int _yplib_cache = 5;
+
+static struct ypmatch_ent {
+	struct ypmatch_ent 	*next;
+	char     		*map, *key;
+	char           		*val;
+	int             	 keylen, vallen;
+	time_t          	 expire_t;
+} *ypmc;
+
+static bool_t
+ypmatch_add(map, key, keylen, val, vallen)
+	const char     *map;
+	const char     *key;
+	int             keylen;
+	char           *val;
+	int             vallen;
+{
+	struct ypmatch_ent *ep;
+	time_t t;
+
+	(void)time(&t);
+
+	for (ep = ypmc; ep; ep = ep->next)
+		if (ep->expire_t < t)
+			break;
+	if (ep == NULL) {
+		if ((ep = malloc(sizeof *ep)) == NULL)
+			return 0;
+		(void)memset(ep, 0, sizeof *ep);
+		if (ypmc)
+			ep->next = ypmc;
+		ypmc = ep;
+	}
+
+	if (ep->key) {
+		free(ep->key);
+		ep->key = NULL;
+	}
+	if (ep->val) {
+		free(ep->val);
+		ep->val = NULL;
+	}
+
+	if ((ep->key = malloc(keylen)) == NULL)
+		return 0;
+
+	if ((ep->val = malloc(vallen)) == NULL) {
+		free(ep->key);
+		ep->key = NULL;
+		return 0;
+	}
+
+	ep->keylen = keylen;
+	ep->vallen = vallen;
+
+	(void)memcpy(ep->key, key, ep->keylen);
+	(void)memcpy(ep->val, val, ep->vallen);
+
+	if (ep->map) {
+		if (strcmp(ep->map, map)) {
+			free(ep->map);
+			if ((ep->map = strdup(map)) == NULL)
+				return 0;
+		}
+	} else {
+		if ((ep->map = strdup(map)) == NULL)
+			return 0;
+	}
+
+	ep->expire_t = t + _yplib_cache;
+	return 1;
+}
+
+static bool_t
+ypmatch_find(map, key, keylen, val, vallen)
+	const char     *map;
+	const char     *key;
+	int             keylen;
+	const char    **val;
+	int            *vallen;
+{
+	struct ypmatch_ent *ep;
+	time_t          t;
+
+	if (ypmc == NULL)
+		return 0;
+
+	(void) time(&t);
+
+	for (ep = ypmc; ep; ep = ep->next) {
+		if (ep->keylen != keylen)
+			continue;
+		if (strcmp(ep->map, map))
+			continue;
+		if (memcmp(ep->key, key, keylen))
+			continue;
+		if (t > ep->expire_t)
+			continue;
+
+		*val = ep->val;
+		*vallen = ep->vallen;
+		return 1;
+	}
+	return 0;
+}
+#endif
+
+int
+_yp_dobind(dom, ypdb)
+	const char     *dom;
+	struct dom_binding **ypdb;
+{
+	static int      pid = -1;
+	char            path[MAXPATHLEN];
+	struct dom_binding *ysd, *ysd2;
+	struct ypbind_resp ypbr;
+	struct timeval  tv;
+	struct sockaddr_in clnt_sin;
+	int             clnt_sock, fd, gpid;
+	CLIENT         *client;
+	int             new = 0, r;
+	int             count = 0;
+
+	/*
+	 * test if YP is running or not
+	 */
+	if ((fd = open(YPBINDLOCK, O_RDONLY)) == -1)
+		return YPERR_YPBIND;
+	if (!(flock(fd, LOCK_EX | LOCK_NB) == -1 && errno == EWOULDBLOCK)) {
+		(void)close(fd);
+		return YPERR_YPBIND;
+	}
+	(void)close(fd);
+
+	gpid = getpid();
+	if (!(pid == -1 || pid == gpid)) {
+		ysd = _ypbindlist;
+		while (ysd) {
+			if (ysd->dom_client)
+				clnt_destroy(ysd->dom_client);
+			ysd2 = ysd->dom_pnext;
+			free(ysd);
+			ysd = ysd2;
+		}
+		_ypbindlist = NULL;
+	}
+	pid = gpid;
+
+	if (ypdb != NULL)
+		*ypdb = NULL;
+
+	if (dom == NULL || strlen(dom) == 0)
+		return YPERR_BADARGS;
+
+	for (ysd = _ypbindlist; ysd; ysd = ysd->dom_pnext)
+		if (strcmp(dom, ysd->dom_domain) == 0)
+			break;
+	if (ysd == NULL) {
+		if ((ysd = malloc(sizeof *ysd)) == NULL)
+			return YPERR_YPERR;
+		(void)memset(ysd, 0, sizeof *ysd);
+		ysd->dom_socket = -1;
+		ysd->dom_vers = 0;
+		new = 1;
+	}
+again:
+	if (ysd->dom_vers == 0) {
+		(void) snprintf(path, sizeof(path), "%s/%s.%d",
+				BINDINGDIR, dom, 2);
+		if ((fd = open(path, O_RDONLY)) == -1) {
+			/*
+			 * no binding file, YP is dead, or not yet fully
+			 * alive.
+			 */
+			goto trynet;
+		}
+		if (flock(fd, LOCK_EX | LOCK_NB) == -1 &&
+		    errno == EWOULDBLOCK) {
+			struct iovec    iov[2];
+			struct ypbind_resp ybr;
+			u_short         ypb_port;
+			struct ypbind_binding *bn;
+
+			iov[0].iov_base = (caddr_t) & ypb_port;
+			iov[0].iov_len = sizeof ypb_port;
+			iov[1].iov_base = (caddr_t) & ybr;
+			iov[1].iov_len = sizeof ybr;
+
+			r = readv(fd, iov, 2);
+			if (r != iov[0].iov_len + iov[1].iov_len) {
+				(void)close(fd);
+				ysd->dom_vers = -1;
+				goto again;
+			}
+			(void)memset(&ysd->dom_server_addr, 0,
+				     sizeof ysd->dom_server_addr);
+			ysd->dom_server_addr.sin_len =
+				sizeof(struct sockaddr_in);
+			ysd->dom_server_addr.sin_family = AF_INET;
+			bn = &ybr.ypbind_respbody.ypbind_bindinfo;
+			ysd->dom_server_addr.sin_port =
+				bn->ypbind_binding_port;
+				
+			ysd->dom_server_addr.sin_addr =
+				bn->ypbind_binding_addr;
+
+			ysd->dom_server_port = ysd->dom_server_addr.sin_port;
+			(void)close(fd);
+			goto gotit;
+		} else {
+			/* no lock on binding file, YP is dead. */
+			(void)close(fd);
+			if (new)
+				free(ysd);
+			return YPERR_YPBIND;
+		}
+	}
+trynet:
+	if (ysd->dom_vers == -1 || ysd->dom_vers == 0) {
+		struct ypbind_binding *bn;
+		(void)memset(&clnt_sin, 0, sizeof clnt_sin);
+		clnt_sin.sin_len = sizeof(struct sockaddr_in);
+		clnt_sin.sin_family = AF_INET;
+		clnt_sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+
+		clnt_sock = RPC_ANYSOCK;
+		client = clnttcp_create(&clnt_sin, YPBINDPROG, YPBINDVERS,
+					&clnt_sock, 0, 0);
+		if (client == NULL) {
+			clnt_pcreateerror("clnttcp_create");
+			if (new)
+				free(ysd);
+			return YPERR_YPBIND;
+		}
+		tv.tv_sec = _yplib_timeout;
+		tv.tv_usec = 0;
+		r = clnt_call(client, YPBINDPROC_DOMAIN, xdr_domainname,
+			      dom, xdr_ypbind_resp, &ypbr, tv);
+		if (r != RPC_SUCCESS) {
+			if (new == 0 || count)
+				fprintf(stderr,
+		    "YP server for domain %s not responding, still trying\n",
+					dom);
+			count++;
+			clnt_destroy(client);
+			ysd->dom_vers = -1;
+			goto again;
+		}
+		clnt_destroy(client);
+
+		(void)memset(&ysd->dom_server_addr, 0, 
+			     sizeof ysd->dom_server_addr);
+		ysd->dom_server_addr.sin_len = sizeof(struct sockaddr_in);
+		ysd->dom_server_addr.sin_family = AF_INET;
+		bn = &ypbr.ypbind_respbody.ypbind_bindinfo;
+		ysd->dom_server_addr.sin_port =
+			bn->ypbind_binding_port;
+		ysd->dom_server_addr.sin_addr.s_addr =
+			bn->ypbind_binding_addr.s_addr;
+		ysd->dom_server_port =
+			bn->ypbind_binding_port;
+gotit:
+		ysd->dom_vers = YPVERS;
+		(void)strcpy(ysd->dom_domain, dom);
+	}
+	tv.tv_sec = _yplib_timeout / 2;
+	tv.tv_usec = 0;
+	if (ysd->dom_client)
+		clnt_destroy(ysd->dom_client);
+	ysd->dom_socket = RPC_ANYSOCK;
+	ysd->dom_client = clntudp_create(&ysd->dom_server_addr,
+				      YPPROG, YPVERS, tv, &ysd->dom_socket);
+	if (ysd->dom_client == NULL) {
+		clnt_pcreateerror("clntudp_create");
+		ysd->dom_vers = -1;
+		goto again;
+	}
+	if (fcntl(ysd->dom_socket, F_SETFD, 1) == -1)
+		perror("fcntl: F_SETFD");
+
+	if (new) {
+		ysd->dom_pnext = _ypbindlist;
+		_ypbindlist = ysd;
+	}
+	if (ypdb != NULL)
+		*ypdb = ysd;
+	return 0;
+}
+
+static void
+_yp_unbind(ypb)
+	struct dom_binding *ypb;
+{
+	clnt_destroy(ypb->dom_client);
+	ypb->dom_client = NULL;
+	ypb->dom_socket = -1;
+}
+
+int
+yp_bind(dom)
+	const char     *dom;
+{
+	return _yp_dobind(dom, NULL);
+}
+
+void
+yp_unbind(dom)
+	const char     *dom;
+{
+	struct dom_binding *ypb, *ypbp;
+
+	ypbp = NULL;
+	for (ypb = _ypbindlist; ypb; ypb = ypb->dom_pnext) {
+		if (strcmp(dom, ypb->dom_domain) == 0) {
+			clnt_destroy(ypb->dom_client);
+			if (ypbp)
+				ypbp->dom_pnext = ypb->dom_pnext;
+			else
+				_ypbindlist = ypb->dom_pnext;
+			free(ypb);
+			return;
+		}
+		ypbp = ypb;
+	}
+	return;
+}
+
+int
+yp_match(indomain, inmap, inkey, inkeylen, outval, outvallen)
+	const char     *indomain;
+	const char     *inmap;
+	const char     *inkey;
+	int             inkeylen;
+	char          **outval;
+	int            *outvallen;
+{
+	struct dom_binding *ysd;
+	struct ypresp_val yprv;
+	struct timeval  tv;
+	struct ypreq_key yprk;
+	int             r;
+
+	*outval = NULL;
+	*outvallen = 0;
+
+again:
+	if (_yp_dobind(indomain, &ysd) != 0)
+		return YPERR_DOMAIN;
+
+#ifdef YPMATCHCACHE
+	if (!strcmp(_yp_domain, indomain) && ypmatch_find(inmap, inkey,
+			 inkeylen, &yprv.valdat.dptr, &yprv.valdat.dsize)) {
+		*outvallen = yprv.valdat.dsize;
+		if ((*outval = malloc(*outvallen + 1)) == NULL)
+			return YPERR_YPERR;
+		(void)memcpy(*outval, yprv.valdat.dptr, *outvallen);
+		(*outval)[*outvallen] = '\0';
+		return 0;
+	}
+#endif
+
+	tv.tv_sec = _yplib_timeout;
+	tv.tv_usec = 0;
+
+	yprk.domain = indomain;
+	yprk.map = inmap;
+	yprk.keydat.dptr = (char *) inkey;
+	yprk.keydat.dsize = inkeylen;
+
+	memset(&yprv, 0, sizeof yprv);
+
+	r = clnt_call(ysd->dom_client, YPPROC_MATCH,
+		      xdr_ypreq_key, &yprk, xdr_ypresp_val, &yprv, tv);
+	if (r != RPC_SUCCESS) {
+		clnt_perror(ysd->dom_client, "yp_match: clnt_call");
+		ysd->dom_vers = -1;
+		goto again;
+	}
+	if (!(r = ypprot_err(yprv.status))) {
+		*outvallen = yprv.valdat.dsize;
+		if ((*outval = malloc(*outvallen + 1)) == NULL)
+			return YPERR_YPERR;
+		(void)memcpy(*outval, yprv.valdat.dptr, *outvallen);
+		(*outval)[*outvallen] = '\0';
+#ifdef YPMATCHCACHE
+		if (strcmp(_yp_domain, indomain) == 0)
+			if (!ypmatch_add(inmap, inkey, inkeylen,
+					 *outval, *outvallen))
+				r = RPC_SYSTEMERROR;
+#endif
+	}
+	xdr_free(xdr_ypresp_val, (char *) &yprv);
+	_yp_unbind(ysd);
+	return r;
+}
+
+int
+yp_get_default_domain(domp)
+	char          **domp;
+{
+	*domp = NULL;
+	if (_yp_domain[0] == '\0')
+		if (getdomainname(_yp_domain, sizeof _yp_domain))
+			return YPERR_NODOM;
+	*domp = _yp_domain;
+	return 0;
+}
+
+int
+yp_first(indomain, inmap, outkey, outkeylen, outval, outvallen)
+	const char     *indomain;
+	const char     *inmap;
+	char          **outkey;
+	int            *outkeylen;
+	char          **outval;
+	int            *outvallen;
+{
+	struct ypresp_key_val yprkv;
+	struct ypreq_nokey yprnk;
+	struct dom_binding *ysd;
+	struct timeval  tv;
+	int             r;
+
+	*outkey = *outval = NULL;
+	*outkeylen = *outvallen = 0;
+
+again:
+	if (_yp_dobind(indomain, &ysd) != 0)
+		return YPERR_DOMAIN;
+
+	tv.tv_sec = _yplib_timeout;
+	tv.tv_usec = 0;
+
+	yprnk.domain = indomain;
+	yprnk.map = inmap;
+	(void)memset(&yprkv, 0, sizeof yprkv);
+
+	r = clnt_call(ysd->dom_client, YPPROC_FIRST,
+		   xdr_ypreq_nokey, &yprnk, xdr_ypresp_key_val, &yprkv, tv);
+	if (r != RPC_SUCCESS) {
+		clnt_perror(ysd->dom_client, "yp_first: clnt_call");
+		ysd->dom_vers = -1;
+		goto again;
+	}
+	if (!(r = ypprot_err(yprkv.status))) {
+		*outkeylen = yprkv.keydat.dsize;
+		if ((*outkey = malloc(*outkeylen + 1)) == NULL)
+			r = RPC_SYSTEMERROR;
+		else {
+			(void)memcpy(*outkey, yprkv.keydat.dptr, *outkeylen);
+			(*outkey)[*outkeylen] = '\0';
+		}
+		*outvallen = yprkv.valdat.dsize;
+		if ((*outval = malloc(*outvallen + 1)) == NULL)
+			r = RPC_SYSTEMERROR;
+		else {
+			(void)memcpy(*outval, yprkv.valdat.dptr, *outvallen);
+			(*outval)[*outvallen] = '\0';
+		}
+	}
+	xdr_free(xdr_ypresp_key_val, (char *) &yprkv);
+	_yp_unbind(ysd);
+	return r;
+}
+
+int
+yp_next(indomain, inmap, inkey, inkeylen, outkey, outkeylen, outval, outvallen)
+	const char     *indomain;
+	const char     *inmap;
+	const char     *inkey;
+	int             inkeylen;
+	char          **outkey;
+	int            *outkeylen;
+	char          **outval;
+	int            *outvallen;
+{
+	struct ypresp_key_val yprkv;
+	struct ypreq_key yprk;
+	struct dom_binding *ysd;
+	struct timeval  tv;
+	int             r;
+
+	*outkey = *outval = NULL;
+	*outkeylen = *outvallen = 0;
+
+again:
+	if (_yp_dobind(indomain, &ysd) != 0)
+		return YPERR_DOMAIN;
+
+	tv.tv_sec = _yplib_timeout;
+	tv.tv_usec = 0;
+
+	yprk.domain = indomain;
+	yprk.map = inmap;
+	yprk.keydat.dptr = inkey;
+	yprk.keydat.dsize = inkeylen;
+	(void)memset(&yprkv, 0, sizeof yprkv);
+
+	r = clnt_call(ysd->dom_client, YPPROC_NEXT,
+		      xdr_ypreq_key, &yprk, xdr_ypresp_key_val, &yprkv, tv);
+	if (r != RPC_SUCCESS) {
+		clnt_perror(ysd->dom_client, "yp_next: clnt_call");
+		ysd->dom_vers = -1;
+		goto again;
+	}
+	if (!(r = ypprot_err(yprkv.status))) {
+		*outkeylen = yprkv.keydat.dsize;
+		if ((*outkey = malloc(*outkeylen + 1)) == NULL)
+			r = RPC_SYSTEMERROR;
+		else {
+			(void)memcpy(*outkey, yprkv.keydat.dptr, *outkeylen);
+			(*outkey)[*outkeylen] = '\0';
+		}
+		*outvallen = yprkv.valdat.dsize;
+		if ((*outval = malloc(*outvallen + 1)) == NULL)
+			r = RPC_SYSTEMERROR;
+		else {
+			(void)memcpy(*outval, yprkv.valdat.dptr, *outvallen);
+			(*outval)[*outvallen] = '\0';
+		}
+	}
+	xdr_free(xdr_ypresp_key_val, (char *) &yprkv);
+	_yp_unbind(ysd);
+	return r;
+}
+
+int
+yp_all(indomain, inmap, incallback)
+	const char     *indomain;
+	const char     *inmap;
+	struct ypall_callback *incallback;
+{
+	struct ypreq_nokey yprnk;
+	struct dom_binding *ysd;
+	struct timeval  tv;
+	struct sockaddr_in clnt_sin;
+	CLIENT         *clnt;
+	u_long          status;
+	int             clnt_sock;
+
+	if (_yp_dobind(indomain, &ysd) != 0)
+		return YPERR_DOMAIN;
+
+	tv.tv_sec = _yplib_timeout;
+	tv.tv_usec = 0;
+	clnt_sock = RPC_ANYSOCK;
+	clnt_sin = ysd->dom_server_addr;
+	clnt_sin.sin_port = 0;
+	clnt = clnttcp_create(&clnt_sin, YPPROG, YPVERS, &clnt_sock, 0, 0);
+	if (clnt == NULL) {
+		printf("clnttcp_create failed\n");
+		return YPERR_PMAP;
+	}
+	yprnk.domain = indomain;
+	yprnk.map = inmap;
+	ypresp_allfn = incallback->foreach;
+	ypresp_data = (void *) incallback->data;
+
+	(void) clnt_call(clnt, YPPROC_ALL,
+		  xdr_ypreq_nokey, &yprnk, xdr_ypresp_all_seq, &status, tv);
+	clnt_destroy(clnt);
+	/* not really needed... */
+	xdr_free(xdr_ypresp_all_seq, (char *) &status);
+	_yp_unbind(ysd);
+
+	if (status != YP_FALSE)
+		return ypprot_err(status);
+	return 0;
+}
+
+int
+yp_order(indomain, inmap, outorder)
+	const char     *indomain;
+	const char     *inmap;
+	int            *outorder;
+{
+	struct dom_binding *ysd;
+	struct ypresp_order ypro;
+	struct ypreq_nokey yprnk;
+	struct timeval  tv;
+	int             r;
+
+again:
+	if (_yp_dobind(indomain, &ysd) != 0)
+		return YPERR_DOMAIN;
+
+	tv.tv_sec = _yplib_timeout;
+	tv.tv_usec = 0;
+
+	yprnk.domain = indomain;
+	yprnk.map = inmap;
+
+	(void)memset(&ypro, 0, sizeof ypro);
+
+	r = clnt_call(ysd->dom_client, YPPROC_ORDER,
+		      xdr_ypreq_nokey, &yprnk, xdr_ypresp_order, &ypro, tv);
+	if (r != RPC_SUCCESS) {
+		clnt_perror(ysd->dom_client, "yp_order: clnt_call");
+		ysd->dom_vers = -1;
+		goto again;
+	}
+	*outorder = ypro.ordernum;
+	xdr_free(xdr_ypresp_order, (char *) &ypro);
+	_yp_unbind(ysd);
+	return ypprot_err(ypro.status);
+}
+
+int
+yp_master(indomain, inmap, outname)
+	const char     *indomain;
+	const char     *inmap;
+	char          **outname;
+{
+	struct dom_binding *ysd;
+	struct ypresp_master yprm;
+	struct ypreq_nokey yprnk;
+	struct timeval  tv;
+	int             r;
+
+again:
+	if (_yp_dobind(indomain, &ysd) != 0)
+		return YPERR_DOMAIN;
+
+	tv.tv_sec = _yplib_timeout;
+	tv.tv_usec = 0;
+
+	yprnk.domain = indomain;
+	yprnk.map = inmap;
+
+	(void)memset(&yprm, 0, sizeof yprm);
+
+	r = clnt_call(ysd->dom_client, YPPROC_MASTER,
+		      xdr_ypreq_nokey, &yprnk, xdr_ypresp_master, &yprm, tv);
+	if (r != RPC_SUCCESS) {
+		clnt_perror(ysd->dom_client, "yp_master: clnt_call");
+		ysd->dom_vers = -1;
+		goto again;
+	}
+	if (!(r = ypprot_err(yprm.status))) {
+		if ((*outname = strdup(yprm.master)) == NULL)
+			r = RPC_SYSTEMERROR;
+	}
+	xdr_free(xdr_ypresp_master, (char *) &yprm);
+	_yp_unbind(ysd);
+	return r;
+}
+
+int
+yp_maplist(indomain, outmaplist)
+	const char     *indomain;
+	struct ypmaplist **outmaplist;
+{
+	struct dom_binding *ysd;
+	struct ypresp_maplist ypml;
+	struct timeval  tv;
+	int             r;
+
+again:
+	if (_yp_dobind(indomain, &ysd) != 0)
+		return YPERR_DOMAIN;
+
+	tv.tv_sec = _yplib_timeout;
+	tv.tv_usec = 0;
+
+	memset(&ypml, 0, sizeof ypml);
+
+	r = clnt_call(ysd->dom_client, YPPROC_MAPLIST,
+		   xdr_domainname, indomain, xdr_ypresp_maplist, &ypml, tv);
+	if (r != RPC_SUCCESS) {
+		clnt_perror(ysd->dom_client, "yp_maplist: clnt_call");
+		ysd->dom_vers = -1;
+		goto again;
+	}
+	*outmaplist = ypml.list;
+	/* NO: xdr_free(xdr_ypresp_maplist, &ypml); */
+	_yp_unbind(ysd);
+	return ypprot_err(ypml.status);
+}
+
+char *
+yperr_string(incode)
+	int             incode;
+{
+	static char     err[80];
+
+	switch (incode) {
+	case 0:
+		return "Success";
+	case YPERR_BADARGS:
+		return "Request arguments bad";
+	case YPERR_RPC:
+		return "RPC failure";
+	case YPERR_DOMAIN:
+		return "Can't bind to server which serves this domain";
+	case YPERR_MAP:
+		return "No such map in server's domain";
+	case YPERR_KEY:
+		return "No such key in map";
+	case YPERR_YPERR:
+		return "YP server error";
+	case YPERR_RESRC:
+		return "Local resource allocation failure";
+	case YPERR_NOMORE:
+		return "No more records in map database";
+	case YPERR_PMAP:
+		return "Can't communicate with portmapper";
+	case YPERR_YPBIND:
+		return "Can't communicate with ypbind";
+	case YPERR_YPSERV:
+		return "Can't communicate with ypserv";
+	case YPERR_NODOM:
+		return "Local domain name not set";
+	case YPERR_BADDB:
+		return "Server data base is bad";
+	case YPERR_VERS:
+		return "YP server version mismatch - server can't supply service.";
+	case YPERR_ACCESS:
+		return "Access violation";
+	case YPERR_BUSY:
+		return "Database is busy";
+	}
+	(void) snprintf(err, sizeof(err), "YP unknown error %d\n", incode);
+	return err;
+}
+
+int
+ypprot_err(incode)
+	unsigned int    incode;
+{
+	switch (incode) {
+	case YP_TRUE:
+		return 0;
+	case YP_FALSE:
+		return YPERR_YPBIND;
+	case YP_NOMORE:
+		return YPERR_NOMORE;
+	case YP_NOMAP:
+		return YPERR_MAP;
+	case YP_NODOM:
+		return YPERR_NODOM;
+	case YP_NOKEY:
+		return YPERR_KEY;
+	case YP_BADOP:
+		return YPERR_YPERR;
+	case YP_BADDB:
+		return YPERR_BADDB;
+	case YP_YPERR:
+		return YPERR_YPERR;
+	case YP_BADARGS:
+		return YPERR_BADARGS;
+	case YP_VERS:
+		return YPERR_VERS;
+	}
+	return YPERR_YPERR;
+}
+
+int
+_yp_check(dom)
+	char          **dom;
+{
+	char           *unused;
+
+	if (_yp_domain[0] == '\0')
+		if (yp_get_default_domain(&unused))
+			return 0;
+
+	if (dom)
+		*dom = _yp_domain;
+
+	if (yp_bind(_yp_domain) == 0)
+		return 1;
+	return 0;
+}