nis/ypclnt.c

   1 /* Copyright (C) 1996-2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Thorsten Kukuk <kukuk@suse.de>, 1996.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <errno.h>
  21 #include <fcntl.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24 #include <libintl.h>
  25 #include <rpc/rpc.h>
  26 #include <rpcsvc/nis.h>
  27 #include <rpcsvc/yp.h>
  28 #include <rpcsvc/ypclnt.h>
  29 #include <rpcsvc/ypupd.h>
  30 #include <sys/uio.h>
  31 #include <bits/libc-lock.h>
  32
  33 /* This should only be defined on systems with a BSD compatible ypbind */
  34 #ifndef BINDINGDIR
  35 # define BINDINGDIR "/var/yp/binding"
  36 #endif
  37
  38 struct dom_binding
  39   {
  40     struct dom_binding *dom_pnext;
  41     char dom_domain[YPMAXDOMAIN + 1];
  42     struct sockaddr_in dom_server_addr;
  43     int dom_socket;
  44     CLIENT *dom_client;
  45   };
  46 typedef struct dom_binding dom_binding;
  47
  48 static struct timeval RPCTIMEOUT = {25, 0};
  49 static struct timeval UDPTIMEOUT = {5, 0};
  50 static int const MAXTRIES = 2;
  51 static char __ypdomainname[NIS_MAXNAMELEN + 1] = "\0";
  52 __libc_lock_define_initialized (static, ypbindlist_lock)
  53 static dom_binding *__ypbindlist = NULL;
  54
  55
  56 static void
  57 yp_bind_client_create (const char *domain, dom_binding *ysd,
  58                        struct ypbind_resp *ypbr)
  59 {
  60   ysd->dom_server_addr.sin_family = AF_INET;
  61   memcpy (&ysd->dom_server_addr.sin_port,
  62           ypbr->ypbind_resp_u.ypbind_bindinfo.ypbind_binding_port,
  63           sizeof (ysd->dom_server_addr.sin_port));
  64   memcpy (&ysd->dom_server_addr.sin_addr.s_addr,
  65           ypbr->ypbind_resp_u.ypbind_bindinfo.ypbind_binding_addr,
  66           sizeof (ysd->dom_server_addr.sin_addr.s_addr));
  67   strncpy (ysd->dom_domain, domain, YPMAXDOMAIN);
  68   ysd->dom_domain[YPMAXDOMAIN] = '\0';
  69
  70   ysd->dom_socket = RPC_ANYSOCK;
  71   ysd->dom_client = clntudp_create (&ysd->dom_server_addr, YPPROG, YPVERS,
  72                                     UDPTIMEOUT, &ysd->dom_socket);
  73
  74   if (ysd->dom_client != NULL)
  75     {
  76       /* If the program exits, close the socket */
  77       if (fcntl (ysd->dom_socket, F_SETFD, 1) == -1)
  78         perror ("fcntl: F_SETFD");
  79     }
  80 }
  81
  82 #if USE_BINDINGDIR
  83 static void
  84 yp_bind_file (const char *domain, dom_binding *ysd)
  85 {
  86   struct ypbind_resp ypbr;
  87   char path[sizeof (BINDINGDIR) + strlen (domain) + 10];
  88   struct iovec vec[2];
  89   unsigned short port;
  90   int fd;
  91
  92   sprintf (path, "%s/%s.%d", BINDINGDIR, domain, YPBINDVERS);
  93   fd = open (path, O_RDONLY);
  94   if (fd >= 0)
  95     {
  96       /* We have a binding file and could save a RPC call */
  97       vec[0].iov_base = &port;
  98       vec[0].iov_len = sizeof (port);
  99       vec[1].iov_base = &ypbr;
 100       vec[1].iov_len = sizeof (ypbr);
 101
 102       if (readv (fd, vec, 2) == sizeof (port) + sizeof (ypbr))
 103         yp_bind_client_create (domain, ysd, &ypbr);
 104
 105       close (fd);
 106     }
 107 }
 108 #endif
 109
 110 static int
 111 yp_bind_ypbindprog (const char *domain, dom_binding *ysd)
 112 {
 113   struct sockaddr_in clnt_saddr;
 114   struct ypbind_resp ypbr;
 115   int clnt_sock;
 116   CLIENT *client;
 117
 118   memset (&clnt_saddr, '\0', sizeof clnt_saddr);
 119   clnt_saddr.sin_family = AF_INET;
 120   clnt_saddr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
 121   clnt_sock = RPC_ANYSOCK;
 122   client = clnttcp_create (&clnt_saddr, YPBINDPROG, YPBINDVERS,
 123                            &clnt_sock, 0, 0);
 124   if (client == NULL)
 125     return YPERR_YPBIND;
 126
 127   /* Check the port number -- should be < IPPORT_RESERVED.
 128      If not, it's possible someone has registered a bogus
 129      ypbind with the portmapper and is trying to trick us. */
 130   if (ntohs (clnt_saddr.sin_port) >= IPPORT_RESERVED)
 131     {
 132       clnt_destroy (client);
 133       return YPERR_YPBIND;
 134     }
 135
 136   if (clnt_call (client, YPBINDPROC_DOMAIN,
 137                  (xdrproc_t) xdr_domainname, (caddr_t) &domain,
 138                  (xdrproc_t) xdr_ypbind_resp,
 139                  (caddr_t) &ypbr, RPCTIMEOUT) != RPC_SUCCESS)
 140     {
 141       clnt_destroy (client);
 142       return YPERR_YPBIND;
 143     }
 144
 145   clnt_destroy (client);
 146
 147   if (ypbr.ypbind_status != YPBIND_SUCC_VAL)
 148     {
 149       fprintf (stderr, _("YPBINDPROC_DOMAIN: %s\n"),
 150                ypbinderr_string (ypbr.ypbind_resp_u.ypbind_error));
 151       return YPERR_DOMAIN;
 152     }
 153   memset (&ysd->dom_server_addr, '\0', sizeof ysd->dom_server_addr);
 154
 155   yp_bind_client_create (domain, ysd, &ypbr);
 156
 157   return YPERR_SUCCESS;
 158 }
 159
 160 static int
 161 __yp_bind (const char *domain, dom_binding **ypdb)
 162 {
 163   dom_binding *ysd = NULL;
 164   int is_new = 0;
 165
 166   if (domain == NULL || domain[0] == '\0')
 167     return YPERR_BADARGS;
 168
 169   ysd = *ypdb;
 170   while (ysd != NULL)
 171     {
 172       if (strcmp (domain, ysd->dom_domain) == 0)
 173         break;
 174       ysd = ysd->dom_pnext;
 175     }
 176
 177   if (ysd == NULL)
 178     {
 179       is_new = 1;
 180       ysd = (dom_binding *) calloc (1, sizeof *ysd);
 181       if (__builtin_expect (ysd == NULL, 0))
 182         return YPERR_RESRC;
 183     }
 184
 185 #if USE_BINDINGDIR
 186       /* Try binding dir at first if we have no binding */
 187   if (ysd->dom_client == NULL)
 188         yp_bind_file (domain, ysd);
 189 #endif /* USE_BINDINGDIR */
 190
 191   if (ysd->dom_client == NULL)
 192     {
 193       int retval = yp_bind_ypbindprog (domain, ysd);
 194       if (retval != YPERR_SUCCESS)
 195         {
 196           if (is_new)
 197             free (ysd);
 198           return retval;
 199         }
 200     }
 201
 202   if (ysd->dom_client == NULL)
 203     {
 204       if (is_new)
 205         free (ysd);
 206       return YPERR_YPSERV;
 207     }
 208
 209   if (is_new)
 210     {
 211       ysd->dom_pnext = *ypdb;
 212       *ypdb = ysd;
 213     }
 214
 215   return YPERR_SUCCESS;
 216 }
 217
 218 static void
 219 __yp_unbind (dom_binding *ydb)
 220 {
 221   clnt_destroy (ydb->dom_client);
 222   free (ydb);
 223 }
 224
 225 int
 226 yp_bind (const char *indomain)
 227 {
 228   int status;
 229
 230   __libc_lock_lock (ypbindlist_lock);
 231
 232   status = __yp_bind (indomain, &__ypbindlist);
 233
 234   __libc_lock_unlock (ypbindlist_lock);
 235
 236   return status;
 237 }
 238
 239 static void
 240 yp_unbind_locked (const char *indomain)
 241 {
 242   dom_binding *ydbptr, *ydbptr2;
 243
 244   ydbptr2 = NULL;
 245   ydbptr = __ypbindlist;
 246
 247   while (ydbptr != NULL)
 248     {
 249       if (strcmp (ydbptr->dom_domain, indomain) == 0)
 250         {
 251           dom_binding *work;
 252
 253           work = ydbptr;
 254           if (ydbptr2 == NULL)
 255             __ypbindlist = __ypbindlist->dom_pnext;
 256           else
 257             ydbptr2 = ydbptr->dom_pnext;
 258           __yp_unbind (work);
 259           break;
 260         }
 261       ydbptr2 = ydbptr;
 262       ydbptr = ydbptr->dom_pnext;
 263     }
 264 }
 265
 266 void
 267 yp_unbind (const char *indomain)
 268 {
 269   __libc_lock_lock (ypbindlist_lock);
 270
 271   yp_unbind_locked (indomain);
 272
 273   __libc_lock_unlock (ypbindlist_lock);
 274
 275   return;
 276 }
 277
 278 static int
 279 __ypclnt_call (const char *domain, u_long prog, xdrproc_t xargs,
 280                caddr_t req, xdrproc_t xres, caddr_t resp, dom_binding **ydb,
 281                int print_error)
 282 {
 283   enum clnt_stat result;
 284
 285   result = clnt_call ((*ydb)->dom_client, prog,
 286                       xargs, req, xres, resp, RPCTIMEOUT);
 287
 288   if (result != RPC_SUCCESS)
 289     {
 290       /* We don't print an error message, if we try our old,
 291          cached data. Only print this for data, which should work.  */
 292       if (print_error)
 293         clnt_perror ((*ydb)->dom_client, "do_ypcall: clnt_call");
 294
 295       return YPERR_RPC;
 296     }
 297
 298   return YPERR_SUCCESS;
 299 }
 300
 301 static int
 302 do_ypcall (const char *domain, u_long prog, xdrproc_t xargs,
 303            caddr_t req, xdrproc_t xres, caddr_t resp)
 304 {
 305   dom_binding *ydb;
 306   int status;
 307   int saved_errno = errno;
 308
 309   status = YPERR_YPERR;
 310
 311   __libc_lock_lock (ypbindlist_lock);
 312   if (__ypbindlist != NULL)
 313     {
 314       ydb = __ypbindlist;
 315       while (ydb != NULL)
 316         {
 317           if (strcmp (domain, ydb->dom_domain) == 0)
 318             break;
 319           ydb = ydb->dom_pnext;
 320         }
 321       if (ydb != NULL)
 322         {
 323           if (__yp_bind (domain, &ydb) == 0)
 324             {
 325               /* Call server, print no error message, do not unbind.  */
 326               status = __ypclnt_call (domain, prog, xargs, req, xres,
 327                                       resp, &ydb, 0);
 328               if (status == YPERR_SUCCESS)
 329                 {
 330                   __set_errno (saved_errno);
 331                   return status;
 332                 }
 333             }
 334           /* We use ypbindlist, and the old cached data is
 335              invalid. unbind now and create a new binding */
 336           yp_unbind_locked (domain);
 337         }
 338     }
 339   __libc_lock_unlock (ypbindlist_lock);
 340
 341   /* First try with cached data failed. Now try to get
 342      current data from the system.  */
 343   ydb = NULL;
 344   if (__yp_bind (domain, &ydb) == 0)
 345     {
 346       status = __ypclnt_call (domain, prog, xargs, req, xres,
 347                               resp, &ydb, 1);
 348       __yp_unbind (ydb);
 349     }
 350
 351 #if USE_BINDINGDIR
 352   /* If we support binding dir data, we have a third chance:
 353      Ask ypbind.  */
 354   if (status != YPERR_SUCCESS)
 355     {
 356       ydb = calloc (1, sizeof (dom_binding));
 357       if (yp_bind_ypbindprog (domain, ydb) == YPERR_SUCCESS)
 358         {
 359           status = __ypclnt_call (domain, prog, xargs, req, xres,
 360                                   resp, &ydb, 1);
 361           __yp_unbind (ydb);
 362         }
 363       else
 364         free (ydb);
 365     }
 366 #endif
 367
 368   __set_errno (saved_errno);
 369
 370   return status;
 371 }
 372
 373
 374 __libc_lock_define_initialized (static, domainname_lock)
 375
 376 int
 377 yp_get_default_domain (char **outdomain)
 378 {
 379   int result = YPERR_SUCCESS;;
 380   *outdomain = NULL;
 381
 382   __libc_lock_lock (domainname_lock);
 383
 384   if (__ypdomainname[0] == '\0')
 385     {
 386       if (getdomainname (__ypdomainname, NIS_MAXNAMELEN))
 387         result = YPERR_NODOM;
 388       else if (strcmp (__ypdomainname, "(none)") == 0)
 389         {
 390           /* If domainname is not set, some systems will return "(none)" */
 391           __ypdomainname[0] = '\0';
 392           result = YPERR_NODOM;
 393         }
 394       else
 395         *outdomain = __ypdomainname;
 396     }
 397   else
 398     *outdomain = __ypdomainname;
 399
 400   __libc_lock_unlock (domainname_lock);
 401
 402   return result;
 403 }
 404
 405 int
 406 __yp_check (char **domain)
 407 {
 408   char *unused;
 409
 410   if (__ypdomainname[0] == '\0')
 411     if (yp_get_default_domain (&unused))
 412       return 0;
 413
 414   if (domain)
 415     *domain = __ypdomainname;
 416
 417   if (yp_bind (__ypdomainname) == 0)
 418     return 1;
 419   return 0;
 420 }
 421
 422 int
 423 yp_match (const char *indomain, const char *inmap, const char *inkey,
 424           const int inkeylen, char **outval, int *outvallen)
 425 {
 426   ypreq_key req;
 427   ypresp_val resp;
 428   enum clnt_stat result;
 429
 430   if (indomain == NULL || indomain[0] == '\0' ||
 431       inmap == NULL || inmap[0] == '\0' ||
 432       inkey == NULL || inkey[0] == '\0' || inkeylen <= 0)
 433     return YPERR_BADARGS;
 434
 435   req.domain = (char *) indomain;
 436   req.map = (char *) inmap;
 437   req.key.keydat_val = (char *) inkey;
 438   req.key.keydat_len = inkeylen;
 439
 440   *outval = NULL;
 441   *outvallen = 0;
 442   memset (&resp, '\0', sizeof (resp));
 443
 444   result = do_ypcall (indomain, YPPROC_MATCH, (xdrproc_t) xdr_ypreq_key,
 445                       (caddr_t) & req, (xdrproc_t) xdr_ypresp_val,
 446                       (caddr_t) & resp);
 447
 448   if (result != YPERR_SUCCESS)
 449     return result;
 450   if (resp.stat != YP_TRUE)
 451     return ypprot_err (resp.stat);
 452
 453   *outvallen = resp.val.valdat_len;
 454   *outval = malloc (*outvallen + 1);
 455   if (__builtin_expect (*outval == NULL, 0))
 456     return YPERR_RESRC;
 457   memcpy (*outval, resp.val.valdat_val, *outvallen);
 458   (*outval)[*outvallen] = '\0';
 459
 460   xdr_free ((xdrproc_t) xdr_ypresp_val, (char *) &resp);
 461
 462   return YPERR_SUCCESS;
 463 }
 464
 465 int
 466 yp_first (const char *indomain, const char *inmap, char **outkey,
 467           int *outkeylen, char **outval, int *outvallen)
 468 {
 469   ypreq_nokey req;
 470   ypresp_key_val resp;
 471   enum clnt_stat result;
 472
 473   if (indomain == NULL || indomain[0] == '\0' ||
 474       inmap == NULL || inmap[0] == '\0')
 475     return YPERR_BADARGS;
 476
 477   req.domain = (char *) indomain;
 478   req.map = (char *) inmap;
 479
 480   *outkey = *outval = NULL;
 481   *outkeylen = *outvallen = 0;
 482   memset (&resp, '\0', sizeof (resp));
 483
 484   result = do_ypcall (indomain, YPPROC_FIRST, (xdrproc_t) xdr_ypreq_nokey,
 485                       (caddr_t) & req, (xdrproc_t) xdr_ypresp_key_val,
 486                       (caddr_t) & resp);
 487
 488   if (result != RPC_SUCCESS)
 489     return YPERR_RPC;
 490   if (resp.stat != YP_TRUE)
 491     return ypprot_err (resp.stat);
 492
 493   *outkeylen = resp.key.keydat_len;
 494   *outkey = malloc (*outkeylen + 1);
 495   if (__builtin_expect (*outkey == NULL, 0))
 496     return YPERR_RESRC;
 497   memcpy (*outkey, resp.key.keydat_val, *outkeylen);
 498   (*outkey)[*outkeylen] = '\0';
 499   *outvallen = resp.val.valdat_len;
 500   *outval = malloc (*outvallen + 1);
 501   if (__builtin_expect (*outval == NULL, 0))
 502     return YPERR_RESRC;
 503   memcpy (*outval, resp.val.valdat_val, *outvallen);
 504   (*outval)[*outvallen] = '\0';
 505
 506   xdr_free ((xdrproc_t) xdr_ypresp_key_val, (char *) &resp);
 507
 508   return YPERR_SUCCESS;
 509 }
 510
 511 int
 512 yp_next (const char *indomain, const char *inmap, const char *inkey,
 513          const int inkeylen, char **outkey, int *outkeylen, char **outval,
 514          int *outvallen)
 515 {
 516   ypreq_key req;
 517   ypresp_key_val resp;
 518   enum clnt_stat result;
 519
 520   if (indomain == NULL || indomain[0] == '\0' ||
 521       inmap == NULL || inmap[0] == '\0' ||
 522       inkeylen <= 0 || inkey == NULL || inkey[0] == '\0')
 523     return YPERR_BADARGS;
 524
 525   req.domain = (char *) indomain;
 526   req.map = (char *) inmap;
 527   req.key.keydat_val = (char *) inkey;
 528   req.key.keydat_len = inkeylen;
 529
 530   *outkey = *outval = NULL;
 531   *outkeylen = *outvallen = 0;
 532   memset (&resp, '\0', sizeof (resp));
 533
 534   result = do_ypcall (indomain, YPPROC_NEXT, (xdrproc_t) xdr_ypreq_key,
 535                       (caddr_t) & req, (xdrproc_t) xdr_ypresp_key_val,
 536                       (caddr_t) & resp);
 537
 538   if (result != YPERR_SUCCESS)
 539     return result;
 540   if (resp.stat != YP_TRUE)
 541     return ypprot_err (resp.stat);
 542
 543   *outkeylen = resp.key.keydat_len;
 544   *outkey = malloc (*outkeylen + 1);
 545   if (__builtin_expect (*outkey == NULL, 0))
 546     return YPERR_RESRC;
 547   memcpy (*outkey, resp.key.keydat_val, *outkeylen);
 548   (*outkey)[*outkeylen] = '\0';
 549   *outvallen = resp.val.valdat_len;
 550   *outval = malloc (*outvallen + 1);
 551   if (__builtin_expect (*outval == NULL, 0))
 552     return YPERR_RESRC;
 553   memcpy (*outval, resp.val.valdat_val, *outvallen);
 554   (*outval)[*outvallen] = '\0';
 555
 556   xdr_free ((xdrproc_t) xdr_ypresp_key_val, (char *) &resp);
 557
 558   return YPERR_SUCCESS;
 559 }
 560
 561 int
 562 yp_master (const char *indomain, const char *inmap, char **outname)
 563 {
 564   ypreq_nokey req;
 565   ypresp_master resp;
 566   enum clnt_stat result;
 567
 568   if (indomain == NULL || indomain[0] == '\0' ||
 569       inmap == NULL || inmap[0] == '\0')
 570     return YPERR_BADARGS;
 571
 572   req.domain = (char *) indomain;
 573   req.map = (char *) inmap;
 574
 575   memset (&resp, '\0', sizeof (ypresp_master));
 576
 577   result = do_ypcall (indomain, YPPROC_MASTER, (xdrproc_t) xdr_ypreq_nokey,
 578           (caddr_t) & req, (xdrproc_t) xdr_ypresp_master, (caddr_t) & resp);
 579
 580   if (result != YPERR_SUCCESS)
 581     return result;
 582   if (resp.stat != YP_TRUE)
 583     return ypprot_err (resp.stat);
 584
 585   *outname = strdup (resp.peer);
 586   xdr_free ((xdrproc_t) xdr_ypresp_master, (char *) &resp);
 587
 588   return *outname == NULL ? YPERR_YPERR : YPERR_SUCCESS;
 589 }
 590
 591 int
 592 yp_order (const char *indomain, const char *inmap, unsigned int *outorder)
 593 {
 594   struct ypreq_nokey req;
 595   struct ypresp_order resp;
 596   enum clnt_stat result;
 597
 598   if (indomain == NULL || indomain[0] == '\0' ||
 599       inmap == NULL || inmap == '\0')
 600     return YPERR_BADARGS;
 601
 602   req.domain = (char *) indomain;
 603   req.map = (char *) inmap;
 604
 605   memset (&resp, '\0', sizeof (resp));
 606
 607   result = do_ypcall (indomain, YPPROC_ORDER, (xdrproc_t) xdr_ypreq_nokey,
 608            (caddr_t) & req, (xdrproc_t) xdr_ypresp_order, (caddr_t) & resp);
 609
 610   if (result != YPERR_SUCCESS)
 611     return result;
 612   if (resp.stat != YP_TRUE)
 613     return ypprot_err (resp.stat);
 614
 615   *outorder = resp.ordernum;
 616   xdr_free ((xdrproc_t) xdr_ypresp_order, (char *) &resp);
 617
 618   return YPERR_SUCCESS;
 619 }
 620
 621 struct ypresp_all_data
 622 {
 623   unsigned long status;
 624   void *data;
 625   int (*foreach) (int status, char *key, int keylen,
 626                   char *val, int vallen, char *data);
 627 };
 628
 629 static bool_t
 630 __xdr_ypresp_all (XDR *xdrs, struct ypresp_all_data *objp)
 631 {
 632   while (1)
 633     {
 634       struct ypresp_all resp;
 635
 636       memset (&resp, '\0', sizeof (struct ypresp_all));
 637       if (!xdr_ypresp_all (xdrs, &resp))
 638         {
 639           xdr_free ((xdrproc_t) xdr_ypresp_all, (char *) &resp);
 640           objp->status = YP_YPERR;
 641           return FALSE;
 642         }
 643       if (resp.more == 0)
 644         {
 645           xdr_free ((xdrproc_t) xdr_ypresp_all, (char *) &resp);
 646           objp->status = YP_NOMORE;
 647           return TRUE;
 648         }
 649
 650       switch (resp.ypresp_all_u.val.stat)
 651         {
 652         case YP_TRUE:
 653           {
 654             char key[resp.ypresp_all_u.val.key.keydat_len + 1];
 655             char val[resp.ypresp_all_u.val.val.valdat_len + 1];
 656             int keylen = resp.ypresp_all_u.val.key.keydat_len;
 657             int vallen = resp.ypresp_all_u.val.val.valdat_len;
 658
 659             /* We are not allowed to modify the key and val data.
 660                But we are allowed to add data behind the buffer,
 661                if we don't modify the length. So add an extra NUL
 662                character to avoid trouble with broken code. */
 663             objp->status = YP_TRUE;
 664             memcpy (key, resp.ypresp_all_u.val.key.keydat_val, keylen);
 665             key[keylen] = '\0';
 666             memcpy (val, resp.ypresp_all_u.val.val.valdat_val, vallen);
 667             val[vallen] = '\0';
 668             xdr_free ((xdrproc_t) xdr_ypresp_all, (char *) &resp);
 669             if ((*objp->foreach) (objp->status, key, keylen,
 670                                   val, vallen, objp->data))
 671               return TRUE;
 672           }
 673           break;
 674         default:
 675           objp->status = resp.ypresp_all_u.val.stat;
 676           xdr_free ((xdrproc_t) xdr_ypresp_all, (char *) &resp);
 677           /* Sun says we don't need to make this call, but must return
 678              immediatly. Since Solaris makes this call, we will call
 679              the callback function, too. */
 680           (*objp->foreach) (objp->status, NULL, 0, NULL, 0, objp->data);
 681           return TRUE;
 682         }
 683     }
 684 }
 685
 686 int
 687 yp_all (const char *indomain, const char *inmap,
 688         const struct ypall_callback *incallback)
 689 {
 690   struct ypreq_nokey req;
 691   dom_binding *ydb = NULL;
 692   int try, res;
 693   enum clnt_stat result;
 694   struct sockaddr_in clnt_sin;
 695   CLIENT *clnt;
 696   struct ypresp_all_data data;
 697   int clnt_sock;
 698   int saved_errno = errno;
 699
 700   if (indomain == NULL || indomain[0] == '\0' ||
 701       inmap == NULL || inmap == '\0')
 702     return YPERR_BADARGS;
 703
 704   try = 0;
 705   res = YPERR_YPERR;
 706
 707   while (try < MAXTRIES && res != YPERR_SUCCESS)
 708     {
 709       if (__yp_bind (indomain, &ydb) != 0)
 710         {
 711           __set_errno (saved_errno);
 712           return YPERR_DOMAIN;
 713         }
 714
 715       clnt_sock = RPC_ANYSOCK;
 716       clnt_sin = ydb->dom_server_addr;
 717       clnt_sin.sin_port = 0;
 718
 719       /* We don't need the UDP connection anymore.  */
 720       __yp_unbind (ydb);
 721       ydb = NULL;
 722
 723       clnt = clnttcp_create (&clnt_sin, YPPROG, YPVERS, &clnt_sock, 0, 0);
 724       if (clnt == NULL)
 725         {
 726           __set_errno (saved_errno);
 727           return YPERR_PMAP;
 728         }
 729       req.domain = (char *) indomain;
 730       req.map = (char *) inmap;
 731
 732       data.foreach = incallback->foreach;
 733       data.data = (void *) incallback->data;
 734
 735       result = clnt_call (clnt, YPPROC_ALL, (xdrproc_t) xdr_ypreq_nokey,
 736                           (caddr_t) &req, (xdrproc_t) __xdr_ypresp_all,
 737                           (caddr_t) &data, RPCTIMEOUT);
 738
 739       if (result != RPC_SUCCESS)
 740         {
 741           /* Print the error message only on the last try */
 742           if (try == MAXTRIES - 1)
 743             clnt_perror (clnt, "yp_all: clnt_call");
 744           res = YPERR_RPC;
 745         }
 746       else
 747         res = YPERR_SUCCESS;
 748
 749       clnt_destroy (clnt);
 750
 751       if (res == YPERR_SUCCESS && data.status != YP_NOMORE)
 752         {
 753           __set_errno (saved_errno);
 754           return ypprot_err (data.status);
 755         }
 756       ++try;
 757     }
 758
 759   __set_errno (saved_errno);
 760
 761   return res;
 762 }
 763
 764 int
 765 yp_maplist (const char *indomain, struct ypmaplist **outmaplist)
 766 {
 767   struct ypresp_maplist resp;
 768   enum clnt_stat result;
 769
 770   if (indomain == NULL || indomain[0] == '\0')
 771     return YPERR_BADARGS;
 772
 773   memset (&resp, '\0', sizeof (resp));
 774
 775   result = do_ypcall (indomain, YPPROC_MAPLIST, (xdrproc_t) xdr_domainname,
 776     (caddr_t) & indomain, (xdrproc_t) xdr_ypresp_maplist, (caddr_t) & resp);
 777
 778   if (result != YPERR_SUCCESS)
 779     return result;
 780   if (resp.stat != YP_TRUE)
 781     return ypprot_err (resp.stat);
 782
 783   *outmaplist = resp.maps;
 784   /* We give the list not free, this will be done by ypserv
 785      xdr_free((xdrproc_t)xdr_ypresp_maplist, (char *)&resp); */
 786
 787   return YPERR_SUCCESS;
 788 }
 789
 790 const char *
 791 yperr_string (const int error)
 792 {
 793   switch (error)
 794     {
 795     case YPERR_SUCCESS:
 796       return _("Success");
 797     case YPERR_BADARGS:
 798       return _("Request arguments bad");
 799     case YPERR_RPC:
 800       return _("RPC failure on NIS operation");
 801     case YPERR_DOMAIN:
 802       return _("Can't bind to server which serves this domain");
 803     case YPERR_MAP:
 804       return _("No such map in server's domain");
 805     case YPERR_KEY:
 806       return _("No such key in map");
 807     case YPERR_YPERR:
 808       return _("Internal NIS error");
 809     case YPERR_RESRC:
 810       return _("Local resource allocation failure");
 811     case YPERR_NOMORE:
 812       return _("No more records in map database");
 813     case YPERR_PMAP:
 814       return _("Can't communicate with portmapper");
 815     case YPERR_YPBIND:
 816       return _("Can't communicate with ypbind");
 817     case YPERR_YPSERV:
 818       return _("Can't communicate with ypserv");
 819     case YPERR_NODOM:
 820       return _("Local domain name not set");
 821     case YPERR_BADDB:
 822       return _("NIS map database is bad");
 823     case YPERR_VERS:
 824       return _("NIS client/server version mismatch - can't supply service");
 825     case YPERR_ACCESS:
 826       return _("Permission denied");
 827     case YPERR_BUSY:
 828       return _("Database is busy");
 829     }
 830   return _("Unknown NIS error code");
 831 }
 832
 833 int
 834 ypprot_err (const int code)
 835 {
 836   switch (code)
 837     {
 838     case YP_TRUE:
 839       return YPERR_SUCCESS;
 840     case YP_NOMORE:
 841       return YPERR_NOMORE;
 842     case YP_FALSE:
 843       return YPERR_YPERR;
 844     case YP_NOMAP:
 845       return YPERR_MAP;
 846     case YP_NODOM:
 847       return YPERR_DOMAIN;
 848     case YP_NOKEY:
 849       return YPERR_KEY;
 850     case YP_BADOP:
 851       return YPERR_YPERR;
 852     case YP_BADDB:
 853       return YPERR_BADDB;
 854     case YP_YPERR:
 855       return YPERR_YPERR;
 856     case YP_BADARGS:
 857       return YPERR_BADARGS;
 858     case YP_VERS:
 859       return YPERR_VERS;
 860     }
 861   return YPERR_YPERR;
 862 }
 863
 864 const char *
 865 ypbinderr_string (const int error)
 866 {
 867   switch (error)
 868     {
 869     case 0:
 870       return _("Success");
 871     case YPBIND_ERR_ERR:
 872       return _("Internal ypbind error");
 873     case YPBIND_ERR_NOSERV:
 874       return _("Domain not bound");
 875     case YPBIND_ERR_RESC:
 876       return _("System resource allocation failure");
 877     default:
 878       return _("Unknown ypbind error");
 879     }
 880 }
 881
 882
 883 #define WINDOW 60
 884
 885 int
 886 yp_update (char *domain, char *map, unsigned ypop,
 887            char *key, int keylen, char *data, int datalen)
 888 {
 889   union
 890     {
 891       ypupdate_args update_args;
 892       ypdelete_args delete_args;
 893     }
 894   args;
 895   xdrproc_t xdr_argument;
 896   unsigned res = 0;
 897   CLIENT *clnt;
 898   char *master;
 899   struct sockaddr saddr;
 900   char servername[MAXNETNAMELEN + 1];
 901   int r;
 902
 903   if (!domain || !map || !key || (ypop != YPOP_DELETE && !data))
 904     return YPERR_BADARGS;
 905
 906   args.update_args.mapname = map;
 907   args.update_args.key.yp_buf_len = keylen;
 908   args.update_args.key.yp_buf_val = key;
 909   args.update_args.datum.yp_buf_len = datalen;
 910   args.update_args.datum.yp_buf_val = data;
 911
 912   if ((r = yp_master (domain, map, &master)) != 0)
 913     return r;
 914
 915   if (!host2netname (servername, master, domain))
 916     {
 917       fputs (_("yp_update: cannot convert host to netname\n"), stderr);
 918       return YPERR_YPERR;
 919     }
 920
 921   if ((clnt = clnt_create (master, YPU_PROG, YPU_VERS, "tcp")) == NULL)
 922     {
 923       clnt_pcreateerror ("yp_update: clnt_create");
 924       return YPERR_RPC;
 925     }
 926
 927   if (!clnt_control (clnt, CLGET_SERVER_ADDR, (char *) &saddr))
 928     {
 929       fputs (_("yp_update: cannot get server address\n"), stderr);
 930       return YPERR_RPC;
 931     }
 932
 933   switch (ypop)
 934     {
 935     case YPOP_CHANGE:
 936     case YPOP_INSERT:
 937     case YPOP_STORE:
 938       xdr_argument = (xdrproc_t) xdr_ypupdate_args;
 939       break;
 940     case YPOP_DELETE:
 941       xdr_argument = (xdrproc_t) xdr_ypdelete_args;
 942       break;
 943     default:
 944       return YPERR_BADARGS;
 945       break;
 946     }
 947
 948   clnt->cl_auth = authdes_create (servername, WINDOW, &saddr, NULL);
 949
 950   if (clnt->cl_auth == NULL)
 951     clnt->cl_auth = authunix_create_default ();
 952
 953 again:
 954   r = clnt_call (clnt, ypop, xdr_argument, (caddr_t) &args,
 955                  (xdrproc_t) xdr_u_int, (caddr_t) &res, RPCTIMEOUT);
 956
 957   if (r == RPC_AUTHERROR)
 958     {
 959       if (clnt->cl_auth->ah_cred.oa_flavor == AUTH_DES)
 960         {
 961           clnt->cl_auth = authunix_create_default ();
 962           goto again;
 963         }
 964       else
 965         return YPERR_ACCESS;
 966     }
 967   if (r != RPC_SUCCESS)
 968     {
 969       clnt_perror (clnt, "yp_update: clnt_call");
 970       return YPERR_RPC;
 971     }
 972   return res;
 973 }