aboutsummaryrefslogtreecommitdiff
path: root/nis/ypclnt.c
diff options
context:
space:
mode:
authorUlrich Drepper <drepper@redhat.com>1996-12-11 01:40:39 +0000
committerUlrich Drepper <drepper@redhat.com>1996-12-11 01:40:39 +0000
commit6259ec0d78fd301572fcb616fdfa0500b828a824 (patch)
treeb1a008ed66281799defcaf56a92d3b592ca1f34a /nis/ypclnt.c
parentaee321f468f9214700b24e7aef39ef27bda4c42c (diff)
downloadglibc-6259ec0d78fd301572fcb616fdfa0500b828a824.tar
glibc-6259ec0d78fd301572fcb616fdfa0500b828a824.tar.gz
glibc-6259ec0d78fd301572fcb616fdfa0500b828a824.tar.bz2
glibc-6259ec0d78fd301572fcb616fdfa0500b828a824.zip
update from main arcive 961210cvs/libc-961211
Wed Dec 11 01:04:30 1996 Ulrich Drepper <drepper@cygnus.com> Add NIS NSS implementation. * shlib-versions: Add versions for NIS libraries. * sysdeps/unix/inet/Subdirs: Add nis. * nis/Banner: New file. * nis/Makefile: New file. * nis/nss-nis.h: New file. * nis/yp_xdr.h: New file. * nis/ypclnt.h: New file. * nis/ypupdate_xdr.c: New file. * nis/nss_compat/compat-grp.c: New file. * nis/nss_compat/compat-pwd.c: New file. * nis/nss_compat/compat-spwd.c: New file. * nis/nss_nis/nis-alias.c: New file. * nis/nss_nis/nis-ethers.c: New file. * nis/nss_nis/nis-grp.c: New file. * nis/nss_nis/nis-hosts.c: New file. * nis/nss_nis/nis-netgrp.c: New file. * nis/nss_nis/nis-network.c: New file. * nis/nss_nis/nis-proto.c: New file. * nis/nss_nis/nis-publickey.c: New file. * nis/nss_nis/nis-pwd.c: New file. * nis/nss_nis/nis-rpc.c: New file. * nis/nss_nis/nis-service.c: New file. * nis/nss_nis/nis-spwd.c: New file. * nis/rpcsvc/yp.h: New file. * nis/rpcsvc/yp.x: New file. * nis/rpcsvc/yp_prot.h: New file. * nis/rpcsvc/ypclnt.h: New file. * nis/rpcsvc/ypupd.h: New file. * libio/_G_config.h: Define _G_HAVE_SYS_WAIT and _G_HAVE_PRINTF_FP. * locale/C-numeric.c: Update copyright. * locale/Makefile: Add rules to build libBrokenLocale. * locale/broken_cur_max.c: New file. * locale/mb_cur_max.c: Update copyright. (__ctype_get_mb_cur_max): Make function weak. * new-malloc/malloc.c: Correct copyright. * new-malloc/thread-m.h: Correct key handling. * shadow/lckpwdf.c: Update copyright. (PWD_LOCKFILE): Change to /etc/.pwd.lock. * stdlib/strtod.c: Add another assertion. * stdlib/tst-strtod.c: Add another test case. * sysdeps/generic/paths.h: Add _PATH_PRESERVE. Needed by nvi. * sysdeps/unix/sysv/linux/paths.h: Likewise. * sysdeps/gnu/utmpbits.h: Rename ut_addr field to ut_addr_v6. ut_addr names a single element in ut_addr_v6. * sysdeps/mach/hurd/xmknod.c: Remove alias from __mknod to mknod. Patch by Thomas Bushnell, n/BSG. Tue Dec 10 11:35:28 1996 Richard Henderson <rth@tamu.edu> * sysdeps/alpha/strncmp.S: Fix aligned short truncated compare corner condition. * sysdeps/alpha/memchr.S: Don't read ahead, even if the load did fit nicely into that delay slot (patch from David Mosberger-Tang). Mon Dec 9 23:53:43 1996 Thomas Bushnell, n/BSG <thomas@gnu.ai.mit.edu> * sysdeps/mach/hurd/ttyname_r.c (__ttyname_r): Renamed from `ttyname_r'. (ttyname_r): New alias. * stdio-common/printf_fp.c (__guess_grouping): Fix off by one
Diffstat (limited to 'nis/ypclnt.c')
-rw-r--r--nis/ypclnt.c868
1 files changed, 868 insertions, 0 deletions
diff --git a/nis/ypclnt.c b/nis/ypclnt.c
new file mode 100644
index 0000000000..3e05cf984c
--- /dev/null
+++ b/nis/ypclnt.c
@@ -0,0 +1,868 @@
+/* Copyright (C) 1996 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1996.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <libc-lock.h>
+#include <rpcsvc/yp.h>
+#include <rpcsvc/ypclnt.h>
+#include <rpcsvc/ypupd.h>
+
+struct dom_binding
+ {
+ struct dom_binding *dom_pnext;
+ char dom_domain[YPMAXDOMAIN + 1];
+ struct sockaddr_in dom_server_addr;
+ int dom_socket;
+ CLIENT *dom_client;
+ long int dom_vers;
+ };
+typedef struct dom_binding dom_binding;
+
+static struct timeval TIMEOUT = {25, 0};
+static int const MAXTRIES = 5;
+static char __ypdomainname[MAXHOSTNAMELEN + 1] = "\0";
+__libc_lock_define_initialized (static, ypbindlist_lock)
+static dom_binding *__ypbindlist = NULL;
+
+static int
+__yp_bind (char *domain, dom_binding ** ypdb)
+{
+ struct sockaddr_in clnt_saddr;
+ struct ypbind_resp ypbr;
+ dom_binding *ysd;
+ int clnt_sock;
+ CLIENT *client;
+ int is_new = 0;
+ int try;
+
+ if (ypdb != NULL)
+ *ypdb = NULL;
+
+ if ((domain == NULL) || (strlen (domain) == 0))
+ return YPERR_BADARGS;
+
+ ysd = __ypbindlist;
+ while (ysd != NULL)
+ {
+ if (strcmp (domain, ysd->dom_domain) == 0)
+ break;
+ ysd = ysd->dom_pnext;
+ }
+
+ if (ysd == NULL)
+ {
+ is_new = 1;
+ ysd = (dom_binding *) malloc (sizeof *ysd);
+ memset (ysd, '\0', sizeof *ysd);
+ ysd->dom_socket = -1;
+ ysd->dom_vers = -1;
+ }
+
+ try = 0;
+
+ do
+ {
+ try++;
+ if (try > MAXTRIES)
+ {
+ if (is_new)
+ free (ysd);
+ return YPERR_YPBIND;
+ }
+
+ if (ysd->dom_vers == -1)
+ {
+ if(ysd->dom_client)
+ {
+ clnt_destroy(ysd->dom_client);
+ ysd->dom_client = NULL;
+ ysd->dom_socket = -1;
+ }
+ memset (&clnt_saddr, '\0', sizeof clnt_saddr);
+ clnt_saddr.sin_family = AF_INET;
+ clnt_saddr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+ clnt_sock = RPC_ANYSOCK;
+ client = clnttcp_create (&clnt_saddr, YPBINDPROG, YPBINDVERS,
+ &clnt_sock, 0, 0);
+ if (client == NULL)
+ {
+ if (is_new)
+ free (ysd);
+ return YPERR_YPBIND;
+ }
+ /*
+ ** Check the port number -- should be < IPPORT_RESERVED.
+ ** If not, it's possible someone has registered a bogus
+ ** ypbind with the portmapper and is trying to trick us.
+ */
+ if (ntohs(clnt_saddr.sin_port) >= IPPORT_RESERVED)
+ {
+ clnt_destroy(client);
+ if (is_new)
+ free(ysd);
+ return(YPERR_YPBIND);
+ }
+
+ if (clnt_call (client, YPBINDPROC_DOMAIN,
+ (xdrproc_t) xdr_domainname, &domain,
+ (xdrproc_t) xdr_ypbind_resp,
+ &ypbr, TIMEOUT) != RPC_SUCCESS)
+ {
+ clnt_destroy (client);
+ if (is_new)
+ free (ysd);
+ return YPERR_YPBIND;
+ }
+
+ clnt_destroy (client);
+ if (ypbr.ypbind_status != YPBIND_SUCC_VAL)
+ {
+ switch (ypbr.ypbind_resp_u.ypbind_error)
+ {
+ case YPBIND_ERR_ERR:
+ fputs (_("YPBINDPROC_DOMAIN: Internal error\n"), stderr);
+ break;
+ case YPBIND_ERR_NOSERV:
+ fprintf (stderr,
+ _("YPBINDPROC_DOMAIN: No server for domain %s\n"),
+ domain);
+ break;
+ case YPBIND_ERR_RESC:
+ fputs (_("YPBINDPROC_DOMAIN: Resource allocation failure\n"),
+ stderr);
+ break;
+ default:
+ fputs (_("YPBINDPROC_DOMAIN: Unknown error\n"), stderr);
+ break;
+ }
+ if (is_new)
+ free (ysd);
+ return YPERR_DOMAIN;
+ }
+ memset (&ysd->dom_server_addr, '\0', sizeof ysd->dom_server_addr);
+ ysd->dom_server_addr.sin_family = AF_INET;
+ memcpy (&ysd->dom_server_addr.sin_port,
+ ypbr.ypbind_resp_u.ypbind_bindinfo.ypbind_binding_port,
+ sizeof (ysd->dom_server_addr.sin_port));
+ memcpy (&ysd->dom_server_addr.sin_addr.s_addr,
+ ypbr.ypbind_resp_u.ypbind_bindinfo.ypbind_binding_addr,
+ sizeof (ysd->dom_server_addr.sin_addr.s_addr));
+ ysd->dom_vers = YPVERS;
+ strcpy (ysd->dom_domain, domain);
+ }
+
+ 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,
+ TIMEOUT, &ysd->dom_socket);
+ if (ysd->dom_client == NULL)
+ ysd->dom_vers = -1;
+
+ }
+ while (ysd->dom_client == NULL);
+
+ /* If the program exists, close the socket */
+ if (fcntl (ysd->dom_socket, F_SETFD, 1) == -1)
+ perror (_("fcntl: F_SETFD"));
+
+ if (is_new)
+ {
+ ysd->dom_pnext = __ypbindlist;
+ __ypbindlist = ysd;
+ }
+
+ if (NULL != ypdb)
+ *ypdb = ysd;
+
+ return YPERR_SUCCESS;
+}
+
+static void
+__yp_unbind (dom_binding *ydb)
+{
+ clnt_destroy (ydb->dom_client);
+ ydb->dom_client = NULL;
+ ydb->dom_socket = -1;
+}
+
+static int
+do_ypcall (const char *domain, u_long prog, xdrproc_t xargs,
+ caddr_t req, xdrproc_t xres, caddr_t resp)
+{
+ dom_binding *ydb = NULL;
+ int try, result;
+
+ try = 0;
+ result = YPERR_YPERR;
+
+ while (try < MAXTRIES && result != RPC_SUCCESS)
+ {
+ __libc_lock_lock (ypbindlist_lock);
+
+ if (__yp_bind (domain, &ydb) != 0)
+ {
+ __libc_lock_unlock (ypbindlist_lock);
+ return YPERR_DOMAIN;
+ }
+
+ result = clnt_call (ydb->dom_client, prog,
+ xargs, req, xres, resp, TIMEOUT);
+
+ if (result != RPC_SUCCESS)
+ {
+ clnt_perror (ydb->dom_client, "do_ypcall: clnt_call");
+ ydb->dom_vers = -1;
+ __yp_unbind (ydb);
+ result = YPERR_RPC;
+ }
+
+ __libc_lock_unlock (ypbindlist_lock);
+
+ try++;
+ }
+
+ return result;
+}
+
+int
+yp_bind (const char *indomain)
+{
+ int status;
+
+ __libc_lock_lock (ypbindlist_lock);
+
+ status = __yp_bind (indomain, NULL);
+
+ __libc_lock_unlock (ypbindlist_lock);
+
+ return status;
+}
+
+void
+yp_unbind (const char *indomain)
+{
+ dom_binding *ydbptr, *ydbptr2;
+
+ __libc_lock_lock (ypbindlist_lock);
+
+ ydbptr2 = NULL;
+ ydbptr = __ypbindlist;
+ while (ydbptr != NULL)
+ {
+ if (strcmp (ydbptr->dom_domain, indomain) == 0)
+ {
+ dom_binding *work;
+
+ work = ydbptr;
+ if (ydbptr2 == NULL)
+ __ypbindlist = __ypbindlist->dom_pnext;
+ else
+ ydbptr2 = ydbptr->dom_pnext;
+ __yp_unbind (work);
+ free (work);
+ break;
+ }
+ ydbptr2 = ydbptr;
+ ydbptr = ydbptr->dom_pnext;
+ }
+
+ __libc_lock_unlock (ypbindlist_lock);
+
+ return;
+}
+
+__libc_lock_define_initialized (static, domainname_lock)
+
+int
+yp_get_default_domain (char **outdomain)
+{
+ int result = YPERR_SUCCESS;;
+ *outdomain = NULL;
+
+ __libc_lock_lock (domainname_lock);
+
+ if (__ypdomainname[0] == '\0')
+ {
+ if (getdomainname (__ypdomainname, MAXHOSTNAMELEN))
+ result = YPERR_NODOM;
+ else
+ *outdomain = __ypdomainname;
+ }
+ else
+ *outdomain = __ypdomainname;
+
+ __libc_lock_unlock (domainname_lock);
+
+ return result;
+}
+
+int
+__yp_check (char **domain)
+{
+ char *unused;
+
+ if (__ypdomainname[0] == '\0')
+ if (yp_get_default_domain (&unused))
+ return 0;
+ else if (strcmp (__ypdomainname, "(none)") == 0)
+ return 0;
+
+ if (domain)
+ *domain = __ypdomainname;
+
+ if (yp_bind (__ypdomainname) == 0)
+ return 1;
+ return 0;
+}
+
+int
+yp_match (const char *indomain, const char *inmap, const char *inkey,
+ const int inkeylen, char **outval, int *outvallen)
+{
+ ypreq_key req;
+ ypresp_val resp;
+ int result;
+
+ if (indomain == NULL || indomain[0] == '\0' ||
+ inmap == NULL || inmap[0] == '\0' ||
+ inkey == NULL || inkey[0] == '\0' || inkeylen <= 0)
+ return YPERR_BADARGS;
+
+ req.domain = indomain;
+ req.map = inmap;
+ req.key.keydat_val = inkey;
+ req.key.keydat_len = inkeylen;
+
+ *outval = NULL;
+ *outvallen = 0;
+ memset (&resp, '\0', sizeof (resp));
+
+ result = do_ypcall (indomain, YPPROC_MATCH, (xdrproc_t) xdr_ypreq_key,
+ (caddr_t) & req, (xdrproc_t) xdr_ypresp_val,
+ (caddr_t) & resp);
+
+ if (result != RPC_SUCCESS)
+ return result;
+ if (resp.stat != YP_TRUE)
+ return ypprot_err (resp.stat);
+
+ *outvallen = resp.val.valdat_len;
+ *outval = malloc (*outvallen + 1);
+ memcpy (*outval, resp.val.valdat_val, *outvallen);
+ (*outval)[*outvallen] = '\0';
+
+ xdr_free ((xdrproc_t) xdr_ypresp_val, (char *) &resp);
+
+ return YPERR_SUCCESS;
+}
+
+int
+yp_first (const char *indomain, const char *inmap, char **outkey,
+ int *outkeylen, char **outval, int *outvallen)
+{
+ ypreq_nokey req;
+ ypresp_key_val resp;
+ int result;
+
+ if (indomain == NULL || indomain[0] == '\0' ||
+ inmap == NULL || inmap[0] == '\0')
+ return YPERR_BADARGS;
+
+ req.domain = indomain;
+ req.map = inmap;
+
+ *outkey = *outval = NULL;
+ *outkeylen = *outvallen = 0;
+ memset (&resp, '\0', sizeof (resp));
+
+ result = do_ypcall (indomain, YPPROC_FIRST, (xdrproc_t) xdr_ypreq_nokey,
+ (caddr_t) & req, (xdrproc_t) xdr_ypresp_key_val,
+ (caddr_t) & resp);
+
+ if (result != RPC_SUCCESS)
+ return result;
+ if (resp.stat != YP_TRUE)
+ return ypprot_err (resp.stat);
+
+ *outkeylen = resp.key.keydat_len;
+ *outkey = malloc (*outkeylen + 1);
+ memcpy (*outkey, resp.key.keydat_val, *outkeylen);
+ (*outkey)[*outkeylen] = '\0';
+ *outvallen = resp.val.valdat_len;
+ *outval = malloc (*outvallen + 1);
+ memcpy (*outval, resp.val.valdat_val, *outvallen);
+ (*outval)[*outvallen] = '\0';
+
+ xdr_free ((xdrproc_t) xdr_ypresp_key_val, (char *) &resp);
+
+ return YPERR_SUCCESS;
+}
+
+int
+yp_next (const char *indomain, const char *inmap, const char *inkey,
+ const int inkeylen, char **outkey, int *outkeylen, char **outval,
+ int *outvallen)
+{
+ ypreq_key req;
+ ypresp_key_val resp;
+ int result;
+
+ if (indomain == NULL || indomain[0] == '\0' ||
+ inmap == NULL || inmap[0] == '\0' ||
+ inkeylen <= 0 || inkey == NULL || inkey[0] == '\0')
+ return YPERR_BADARGS;
+
+ req.domain = indomain;
+ req.map = inmap;
+ req.key.keydat_val = inkey;
+ req.key.keydat_len = inkeylen;
+
+ *outkey = *outval = NULL;
+ *outkeylen = *outvallen = 0;
+ memset (&resp, '\0', sizeof (resp));
+
+ result = do_ypcall (indomain, YPPROC_NEXT, (xdrproc_t) xdr_ypreq_key,
+ (caddr_t) & req, (xdrproc_t) xdr_ypresp_key_val,
+ (caddr_t) & resp);
+
+ if (result != RPC_SUCCESS)
+ return result;
+ if (resp.stat != YP_TRUE)
+ return ypprot_err (resp.stat);
+
+ *outkeylen = resp.key.keydat_len;
+ *outkey = malloc (*outkeylen + 1);
+ memcpy (*outkey, resp.key.keydat_val, *outkeylen);
+ (*outkey)[*outkeylen] = '\0';
+ *outvallen = resp.val.valdat_len;
+ *outval = malloc (*outvallen + 1);
+ memcpy (*outval, resp.val.valdat_val, *outvallen);
+ (*outval)[*outvallen] = '\0';
+
+ xdr_free ((xdrproc_t) xdr_ypresp_key_val, (char *) &resp);
+
+ return YPERR_SUCCESS;
+}
+
+int
+yp_master (const char *indomain, const char *inmap, char **outname)
+{
+ ypreq_nokey req;
+ ypresp_master resp;
+ int result;
+
+ if (indomain == NULL || indomain[0] == '\0' ||
+ inmap == NULL || inmap[0] == '\0')
+ return YPERR_BADARGS;
+
+ req.domain = indomain;
+ req.map = inmap;
+
+ memset (&resp, '\0', sizeof (ypresp_master));
+
+ result = do_ypcall (indomain, YPPROC_MASTER, (xdrproc_t) xdr_ypreq_nokey,
+ (caddr_t) & req, (xdrproc_t) xdr_ypresp_master, (caddr_t) & resp);
+
+ if (result != RPC_SUCCESS)
+ return result;
+ if (resp.stat != YP_TRUE)
+ return ypprot_err (resp.stat);
+
+ *outname = strdup (resp.peer);
+ xdr_free ((xdrproc_t) xdr_ypresp_master, (char *) &resp);
+
+ return YPERR_SUCCESS;
+}
+
+int
+yp_order (const char *indomain, const char *inmap, unsigned int *outorder)
+{
+ struct ypreq_nokey req;
+ struct ypresp_order resp;
+ int result;
+
+ if (indomain == NULL || indomain[0] == '\0' ||
+ inmap == NULL || inmap == '\0')
+ return YPERR_BADARGS;
+
+ req.domain = indomain;
+ req.map = inmap;
+
+ memset (&resp, '\0', sizeof (resp));
+
+ result = do_ypcall (indomain, YPPROC_ORDER, (xdrproc_t) xdr_ypreq_nokey,
+ (caddr_t) & req, (xdrproc_t) xdr_ypresp_order, (caddr_t) & resp);
+
+ if (result != RPC_SUCCESS)
+ return result;
+ if (resp.stat != YP_TRUE)
+ return ypprot_err (resp.stat);
+
+ *outorder = resp.ordernum;
+ xdr_free ((xdrproc_t) xdr_ypresp_order, (char *) &resp);
+
+ return YPERR_SUCCESS;
+}
+
+static void *ypall_data;
+static int (*ypall_foreach) ();
+
+static bool_t
+__xdr_ypresp_all (XDR * xdrs, u_long * objp)
+{
+ while (1)
+ {
+ struct ypresp_all resp;
+
+ memset (&resp, '\0', sizeof (struct ypresp_all));
+ if (!xdr_ypresp_all (xdrs, &resp))
+ {
+ xdr_free ((xdrproc_t) xdr_ypresp_all, (char *) &resp);
+ *objp = YP_YPERR;
+ return (FALSE);
+ }
+ if (resp.more == 0)
+ {
+ xdr_free ((xdrproc_t) xdr_ypresp_all, (char *) &resp);
+ *objp = YP_NOMORE;
+ return (FALSE);
+ }
+
+ switch (resp.ypresp_all_u.val.stat)
+ {
+ case YP_TRUE:
+ {
+ char key[resp.ypresp_all_u.val.key.keydat_len + 1];
+ char val[resp.ypresp_all_u.val.val.valdat_len + 1];
+ int keylen = resp.ypresp_all_u.val.key.keydat_len;
+ int vallen = resp.ypresp_all_u.val.val.valdat_len;
+
+ *objp = YP_TRUE;
+ memcpy (key, resp.ypresp_all_u.val.key.keydat_val, keylen);
+ key[keylen] = '\0';
+ memcpy (val, resp.ypresp_all_u.val.val.valdat_val, vallen);
+ val[vallen] = '\0';
+ xdr_free ((xdrproc_t) xdr_ypresp_all, (char *) &resp);
+ if ((*ypall_foreach) (*objp, key, keylen,
+ val, vallen, ypall_data))
+ return TRUE;
+ }
+ break;
+ case YP_NOMORE:
+ *objp = YP_NOMORE;
+ xdr_free ((xdrproc_t) xdr_ypresp_all, (char *) &resp);
+ return TRUE;
+ break;
+ default:
+ *objp = resp.ypresp_all_u.val.stat;
+ xdr_free ((xdrproc_t) xdr_ypresp_all, (char *) &resp);
+ return TRUE;
+ }
+ }
+}
+
+int
+yp_all (const char *indomain, const char *inmap,
+ const struct ypall_callback *incallback)
+{
+ struct ypreq_nokey req;
+ dom_binding *ydb;
+ int try, result;
+ struct sockaddr_in clnt_sin;
+ CLIENT *clnt;
+ unsigned long status;
+ int clnt_sock;
+
+ if (indomain == NULL || indomain[0] == '\0' ||
+ inmap == NULL || inmap == '\0')
+ return YPERR_BADARGS;
+
+ try = 0;
+ result = YPERR_YPERR;
+
+ while (try < MAXTRIES && result != RPC_SUCCESS)
+ {
+ __libc_lock_lock (ypbindlist_lock);
+
+ if (__yp_bind (indomain, &ydb) != 0)
+ {
+ __libc_lock_unlock (ypbindlist_lock);
+ return YPERR_DOMAIN;
+ }
+
+ /* YPPROC_ALL get its own TCP channel to ypserv */
+ clnt_sock = RPC_ANYSOCK;
+ clnt_sin = ydb->dom_server_addr;
+ clnt_sin.sin_port = 0;
+ clnt = clnttcp_create (&clnt_sin, YPPROG, YPVERS, &clnt_sock, 0, 0);
+ if (clnt == NULL)
+ {
+ puts ("yp_all: clnttcp_create failed");
+ __libc_lock_unlock (ypbindlist_lock);
+ return YPERR_PMAP;
+ }
+ req.domain = indomain;
+ req.map = inmap;
+
+ ypall_foreach = incallback->foreach;
+ ypall_data = (void *) incallback->data;
+
+ result = clnt_call (clnt, YPPROC_ALL, (xdrproc_t) xdr_ypreq_nokey, &req,
+ (xdrproc_t) __xdr_ypresp_all, &status, TIMEOUT);
+
+ if (result != RPC_SUCCESS)
+ {
+ clnt_perror (ydb->dom_client, "yp_all: clnt_call");
+ clnt_destroy (clnt);
+ __yp_unbind (ydb);
+ result = YPERR_RPC;
+ }
+ else
+ {
+ clnt_destroy (clnt);
+ result = YPERR_SUCCESS;
+ }
+
+ __libc_lock_unlock (ypbindlist_lock);
+
+ if (status != YP_NOMORE)
+ return ypprot_err (status);
+ try++;
+ }
+
+ return result;
+}
+
+int
+yp_maplist (const char *indomain, struct ypmaplist **outmaplist)
+{
+ struct ypresp_maplist resp;
+ int result;
+
+ if (indomain == NULL || indomain[0] == '\0')
+ return YPERR_BADARGS;
+
+ memset (&resp, '\0', sizeof (resp));
+
+ result = do_ypcall (indomain, YPPROC_MAPLIST, (xdrproc_t) xdr_domainname,
+ (caddr_t) & indomain, (xdrproc_t) xdr_ypresp_maplist, (caddr_t) & resp);
+
+ if (result != RPC_SUCCESS)
+ return result;
+ if (resp.stat != YP_TRUE)
+ return ypprot_err (resp.stat);
+
+ *outmaplist = resp.maps;
+ /* We give the list not free, this will be done by ypserv
+ xdr_free((xdrproc_t)xdr_ypresp_maplist, (char *)&resp); */
+
+ return YPERR_SUCCESS;
+}
+
+const char *
+yperr_string (const int error)
+{
+ switch (error)
+ {
+ case YPERR_SUCCESS:
+ return _("Success");
+ case YPERR_BADARGS:
+ return _("Request arguments bad");
+ case YPERR_RPC:
+ return _("RPC failure on NIS operation");
+ 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 _("Internal NIS 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 _("NIS map data base is bad");
+ case YPERR_VERS:
+ return _("NIS client/server version mismatch - can't supply service");
+ case YPERR_ACCESS:
+ return _("Permission denied");
+ case YPERR_BUSY:
+ return _("Database is busy");
+ }
+ return _("Unknown NIS error code");
+}
+
+int
+ypprot_err (const int code)
+{
+ switch (code)
+ {
+ case YP_TRUE:
+ return YPERR_SUCCESS;
+ case YP_NOMORE:
+ return YPERR_NOMORE;
+ case YP_FALSE:
+ return YPERR_YPERR;
+ case YP_NOMAP:
+ return YPERR_MAP;
+ case YP_NODOM:
+ return YPERR_DOMAIN;
+ 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;
+}
+
+const char *
+ypbinderr_string (const int error)
+{
+ switch (error)
+ {
+ case 0:
+ return _("Success");
+ case YPBIND_ERR_ERR:
+ return _("Internal ypbind error");
+ case YPBIND_ERR_NOSERV:
+ return _("Domain not bound");
+ case YPBIND_ERR_RESC:
+ return _("System resource allocation failure");
+ default:
+ return _("Unknown ypbind error");
+ }
+}
+
+
+#define WINDOW 60
+
+int
+yp_update (char *domain, char *map, unsigned ypop,
+ char *key, int keylen, char *data, int datalen)
+{
+#if 0
+ union
+ {
+ ypupdate_args update_args;
+ ypdelete_args delete_args;
+ }
+ args;
+ xdrproc_t xdr_argument;
+ unsigned res = 0;
+ CLIENT *clnt;
+ char *master;
+ struct sockaddr saddr;
+ char servername[MAXNETNAMELEN + 1];
+ int r;
+
+ if (!domain || !map || !key || (ypop != YPOP_DELETE && !data))
+ return YPERR_BADARGS;
+
+ args.update_args.mapname = map;
+ args.update_args.key.yp_buf_len = keylen;
+ args.update_args.key.yp_buf_val = key;
+ args.update_args.datum.yp_buf_len = datalen;
+ args.update_args.datum.yp_buf_val = data;
+
+ if ((r = yp_master (domain, map, &master)) != 0)
+ return r;
+
+ if (!host2netname (servername, master, domain))
+ {
+ fputs (_("yp_update: cannot convert host to netname\n"), stderr);
+ return YPERR_YPERR;
+ }
+
+ if ((clnt = clnt_create (master, YPU_PROG, YPU_VERS, "tcp")) == NULL)
+ {
+ clnt_pcreateerror ("yp_update: clnt_create");
+ return YPERR_RPC;
+ }
+
+ if (!clnt_control (clnt, CLGET_SERVER_ADDR, (char *) &saddr))
+ {
+ fputs (_("yp_update: cannot get server address\n"), stderr);
+ return YPERR_RPC;
+ }
+
+ switch (ypop)
+ {
+ case YPOP_CHANGE:
+ case YPOP_INSERT:
+ case YPOP_STORE:
+ xdr_argument = (xdrproc_t) xdr_ypupdate_args;
+ break;
+ case YPOP_DELETE:
+ xdr_argument = (xdrproc_t) xdr_ypdelete_args;
+ break;
+ default:
+ return YPERR_BADARGS;
+ break;
+ }
+
+ clnt->cl_auth = authdes_create (servername, WINDOW, &saddr, NULL);
+
+ if (clnt->cl_auth == NULL)
+ clnt->cl_auth = authunix_create_default ();
+
+again:
+ r = clnt_call (clnt, ypop, xdr_argument, &args,
+ (xdrproc_t) xdr_u_int, &res, TIMEOUT);
+
+ if (r == RPC_AUTHERROR)
+ {
+ if (clnt->cl_auth->ah_cred.oa_flavor == AUTH_DES)
+ {
+ clnt->cl_auth = authunix_create_default ();
+ goto again;
+ }
+ else
+ return YPERR_ACCESS;
+ }
+ if (r != RPC_SUCCESS)
+ {
+ clnt_perror (clnt, "yp_update: clnt_call");
+ return YPERR_RPC;
+ }
+ return res;
+#else
+ return YPERR_YPERR;
+#endif
+}