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