(optimize_utf8): Add a note on why we test opr.ctx_type.
[kopensolaris-gnu/glibc.git] / nis / nis_table.c
1 /* Copyright (c) 1997-1999, 2003, 2004, 2005, 2006, 2007
2    Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Thorsten Kukuk <kukuk@suse.de>, 1997.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Lesser General Public
8    License as published by the Free Software Foundation; either
9    version 2.1 of the License, or (at your option) any later version.
10
11    The GNU C Library is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with the GNU C Library; if not, write to the Free
18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19    02111-1307 USA.  */
20
21 #include <assert.h>
22 #include <string.h>
23 #include <rpcsvc/nis.h>
24
25 #include "nis_xdr.h"
26 #include "nis_intern.h"
27 #include "libnsl.h"
28
29
30 struct ib_request *
31 __create_ib_request (const_nis_name name, unsigned int flags)
32 {
33   struct ib_request *ibreq = calloc (1, sizeof (struct ib_request));
34   nis_attr *search_val = NULL;
35   size_t search_len = 0;
36   size_t size = 0;
37
38   if (ibreq == NULL)
39     return NULL;
40
41   ibreq->ibr_flags = flags;
42
43   char *cptr = strdupa (name);
44
45   /* Not of "[key=value,key=value,...],foo.." format? */
46   if (cptr[0] != '[')
47     {
48       ibreq->ibr_name = strdup (cptr);
49       if (ibreq->ibr_name == NULL)
50         {
51           free (ibreq);
52           return NULL;
53         }
54       return ibreq;
55     }
56
57   /* "[key=value,...],foo" format */
58   ibreq->ibr_name = strchr (cptr, ']');
59   if (ibreq->ibr_name == NULL || ibreq->ibr_name[1] != ',')
60     {
61       /* The object has not really been built yet so we use free.  */
62       free (ibreq);
63       return NULL;
64     }
65
66   /* Check if we have an entry of "[key=value,],bar".  If, remove the "," */
67   if (ibreq->ibr_name[-1] == ',')
68     ibreq->ibr_name[-1] = '\0';
69   else
70     ibreq->ibr_name[0] = '\0';
71   ibreq->ibr_name += 2;
72   ibreq->ibr_name = strdup (ibreq->ibr_name);
73   if (ibreq->ibr_name == NULL)
74     {
75     free_null:
76       while (search_len-- > 0)
77         {
78           free (search_val[search_len].zattr_ndx);
79           free (search_val[search_len].zattr_val.zattr_val_val);
80         }
81       free (search_val);
82       nis_free_request (ibreq);
83       return NULL;
84     }
85
86   ++cptr; /* Remove "[" */
87
88   while (cptr != NULL && cptr[0] != '\0')
89     {
90       char *key = cptr;
91       char *val = strchr (cptr, '=');
92
93       cptr = strchr (key, ',');
94       if (cptr != NULL)
95         *cptr++ = '\0';
96
97       if (__builtin_expect (val == NULL, 0))
98         {
99           nis_free_request (ibreq);
100           return NULL;
101         }
102       *val++ = '\0';
103       if (search_len + 1 >= size)
104         {
105           size += 1;
106           nis_attr *newp = realloc (search_val, size * sizeof (nis_attr));
107           if (newp == NULL)
108             goto free_null;
109           search_val = newp;
110         }
111       search_val[search_len].zattr_ndx = strdup (key);
112       if (search_val[search_len].zattr_ndx == NULL)
113         goto free_null;
114
115       search_val[search_len].zattr_val.zattr_val_len = strlen (val) + 1;
116       search_val[search_len].zattr_val.zattr_val_val = strdup (val);
117       if (search_val[search_len].zattr_val.zattr_val_val == NULL)
118         {
119           free (search_val[search_len].zattr_ndx);
120           goto free_null;
121         }
122
123       ++search_len;
124     }
125
126   ibreq->ibr_srch.ibr_srch_val = search_val;
127   ibreq->ibr_srch.ibr_srch_len = search_len;
128
129   return ibreq;
130 }
131 libnsl_hidden_def (__create_ib_request)
132
133 static const struct timeval RPCTIMEOUT = {10, 0};
134
135 static char *
136 get_tablepath (char *name, dir_binding *bptr)
137 {
138   enum clnt_stat result;
139   nis_result res;
140   struct ns_request req;
141
142   memset (&res, '\0', sizeof (res));
143
144   req.ns_name = name;
145   req.ns_object.ns_object_len = 0;
146   req.ns_object.ns_object_val = NULL;
147
148   result = clnt_call (bptr->clnt, NIS_LOOKUP, (xdrproc_t) _xdr_ns_request,
149                       (caddr_t) &req, (xdrproc_t) _xdr_nis_result,
150                       (caddr_t) &res, RPCTIMEOUT);
151
152   const char *cptr;
153   if (result == RPC_SUCCESS && NIS_RES_STATUS (&res) == NIS_SUCCESS
154       && __type_of (NIS_RES_OBJECT (&res)) == NIS_TABLE_OBJ)
155     cptr = NIS_RES_OBJECT (&res)->TA_data.ta_path;
156   else
157     cptr = "";
158
159   char *str = strdup (cptr);
160
161   if (result == RPC_SUCCESS)
162     xdr_free ((xdrproc_t) _xdr_nis_result, (char *) &res);
163
164   return str;
165 }
166
167
168 nis_error
169 __follow_path (char **tablepath, char **tableptr, struct ib_request *ibreq,
170                dir_binding *bptr)
171 {
172   if (*tablepath == NULL)
173     {
174       *tablepath = get_tablepath (ibreq->ibr_name, bptr);
175       if (*tablepath == NULL)
176         return NIS_NOMEMORY;
177
178       *tableptr = *tablepath;
179     }
180   if (*tableptr == NULL)
181     return NIS_NOTFOUND;
182
183   char *newname = strsep (tableptr, ":");
184   if (newname[0] == '\0')
185     return NIS_NOTFOUND;
186
187   newname = strdup (newname);
188   if (newname == NULL)
189     return NIS_NOMEMORY;
190
191   free (ibreq->ibr_name);
192   ibreq->ibr_name = newname;
193
194   return NIS_SUCCESS;
195 }
196 libnsl_hidden_def (__follow_path)
197
198
199 nis_result *
200 nis_list (const_nis_name name, unsigned int flags,
201           int (*callback) (const_nis_name name,
202                            const nis_object *object,
203                            const void *userdata),
204           const void *userdata)
205 {
206   nis_result *res = malloc (sizeof (nis_result));
207   ib_request *ibreq;
208   int status;
209   enum clnt_stat clnt_status;
210   int count_links = 0;          /* We will only follow NIS_MAXLINKS links! */
211   int done = 0;
212   nis_name *names;
213   nis_name namebuf[2] = {NULL, NULL};
214   int name_nr = 0;
215   nis_cb *cb = NULL;
216   char *tableptr;
217   char *tablepath = NULL;
218   int first_try = 0; /* Do we try the old binding at first ? */
219   nis_result *allres = NULL;
220
221   if (res == NULL)
222     return NULL;
223
224   if (name == NULL)
225     {
226       status = NIS_BADNAME;
227     err_out:
228       nis_freeresult (allres);
229       memset (res, '\0', sizeof (nis_result));
230       NIS_RES_STATUS (res) = status;
231       return res;
232     }
233
234   ibreq = __create_ib_request (name, flags);
235   if (ibreq == NULL)
236     {
237       status = NIS_BADNAME;
238       goto err_out;
239     }
240
241   if ((flags & EXPAND_NAME)
242       && ibreq->ibr_name[strlen (ibreq->ibr_name) - 1] != '.')
243     {
244       names = nis_getnames (ibreq->ibr_name);
245       free (ibreq->ibr_name);
246       ibreq->ibr_name = NULL;
247       if (names == NULL)
248         {
249           nis_free_request (ibreq);
250           status = NIS_BADNAME;
251           goto err_out;
252         }
253       ibreq->ibr_name = strdup (names[name_nr]);
254       if (ibreq->ibr_name == NULL)
255         {
256           nis_freenames (names);
257           nis_free_request (ibreq);
258           status = NIS_NOMEMORY;
259           goto err_out;
260         }
261     }
262   else
263     {
264       names = namebuf;
265       names[name_nr] = ibreq->ibr_name;
266     }
267
268   cb = NULL;
269
270   while (!done)
271     {
272       dir_binding bptr;
273       directory_obj *dir = NULL;
274
275       memset (res, '\0', sizeof (nis_result));
276
277       status = __nisfind_server (ibreq->ibr_name,
278                                  ibreq->ibr_srch.ibr_srch_val != NULL,
279                                  &dir, &bptr, flags & ~MASTER_ONLY);
280       if (status != NIS_SUCCESS)
281         {
282           NIS_RES_STATUS (res) = status;
283           goto fail3;
284         }
285
286       while (__nisbind_connect (&bptr) != NIS_SUCCESS)
287         if (__builtin_expect (__nisbind_next (&bptr) != NIS_SUCCESS, 0))
288           {
289             NIS_RES_STATUS (res) = NIS_NAMEUNREACHABLE;
290             goto fail;
291           }
292
293       if (callback != NULL)
294         {
295           assert (cb == NULL);
296           cb = __nis_create_callback (callback, userdata, flags);
297           ibreq->ibr_cbhost.ibr_cbhost_len = 1;
298           ibreq->ibr_cbhost.ibr_cbhost_val = cb->serv;
299         }
300
301     again:
302       clnt_status = clnt_call (bptr.clnt, NIS_IBLIST,
303                                (xdrproc_t) _xdr_ib_request, (caddr_t) ibreq,
304                                (xdrproc_t) _xdr_nis_result,
305                                (caddr_t) res, RPCTIMEOUT);
306
307       if (__builtin_expect (clnt_status != RPC_SUCCESS, 0))
308         NIS_RES_STATUS (res) = NIS_RPCERROR;
309       else
310         switch (NIS_RES_STATUS (res))
311           { /* start switch */
312           case NIS_PARTIAL:
313           case NIS_SUCCESS:
314           case NIS_S_SUCCESS:
315             if (__type_of (NIS_RES_OBJECT (res)) == NIS_LINK_OBJ
316                 && (flags & FOLLOW_LINKS))      /* We are following links.  */
317               {
318                 free (ibreq->ibr_name);
319                 ibreq->ibr_name = NULL;
320                 /* If we hit the link limit, bail.  */
321                 if (__builtin_expect (count_links > NIS_MAXLINKS, 0))
322                   {
323                     NIS_RES_STATUS (res) = NIS_LINKNAMEERROR;
324                     ++done;
325                     break;
326                   }
327                 ++count_links;
328                 ibreq->ibr_name =
329                   strdup (NIS_RES_OBJECT (res)->LI_data.li_name);
330                 if (ibreq->ibr_name == NULL)
331                   {
332                     NIS_RES_STATUS (res) = NIS_NOMEMORY;
333                   fail:
334                     __nisbind_destroy (&bptr);
335                     nis_free_directory (dir);
336                   fail3:
337                     free (tablepath);
338                     if (cb)
339                       {
340                         __nis_destroy_callback (cb);
341                         ibreq->ibr_cbhost.ibr_cbhost_len = 0;
342                         ibreq->ibr_cbhost.ibr_cbhost_val = NULL;
343                       }
344                     if (names != namebuf)
345                       nis_freenames (names);
346                     nis_free_request (ibreq);
347                     nis_freeresult (allres);
348                     return res;
349                   }
350                 if (NIS_RES_OBJECT (res)->LI_data.li_attrs.li_attrs_len)
351                   if (ibreq->ibr_srch.ibr_srch_len == 0)
352                     {
353                       ibreq->ibr_srch.ibr_srch_len =
354                         NIS_RES_OBJECT (res)->LI_data.li_attrs.li_attrs_len;
355                       ibreq->ibr_srch.ibr_srch_val =
356                         NIS_RES_OBJECT (res)->LI_data.li_attrs.li_attrs_val;
357                     }
358                 /* The following is a non-obvious optimization.  A
359                    nis_freeresult call would call xdr_free as the
360                    following code.  But it also would unnecessarily
361                    free the result structure.  We avoid this here
362                    along with the necessary tests.  */
363                 xdr_free ((xdrproc_t) _xdr_nis_result, (char *)res);
364                 memset (res, '\0', sizeof (*res));
365                 first_try = 1; /* Try at first the old binding */
366                 goto again;
367               }
368             else if ((flags & FOLLOW_PATH)
369                      && NIS_RES_STATUS (res) == NIS_PARTIAL)
370               {
371                 clnt_status = __follow_path (&tablepath, &tableptr, ibreq,
372                                              &bptr);
373                 if (clnt_status != NIS_SUCCESS)
374                   {
375                     if (clnt_status == NIS_NOMEMORY)
376                       NIS_RES_STATUS (res) = clnt_status;
377                     ++done;
378                   }
379                 else
380                   {
381                     /* The following is a non-obvious optimization.  A
382                        nis_freeresult call would call xdr_free as the
383                        following code.  But it also would unnecessarily
384                        free the result structure.  We avoid this here
385                        along with the necessary tests.  */
386                     xdr_free ((xdrproc_t) _xdr_nis_result, (char *) res);
387                     memset (res, '\0', sizeof (*res));
388                     first_try = 1;
389                     goto again;
390                   }
391               }
392             else if ((flags & (FOLLOW_PATH | ALL_RESULTS))
393                      == (FOLLOW_PATH | ALL_RESULTS))
394               {
395                 if (allres == NULL)
396                   {
397                     allres = res;
398                     res = malloc (sizeof (nis_result));
399                     if (res == NULL)
400                       {
401                         res = allres;
402                         allres = NULL;
403                         NIS_RES_STATUS (res) = NIS_NOMEMORY;
404                         goto fail;
405                       }
406                     NIS_RES_STATUS (res) = NIS_RES_STATUS (allres);
407                   }
408                 else
409                   {
410                     nis_object *objects_val
411                       = realloc (NIS_RES_OBJECT (allres),
412                                  (NIS_RES_NUMOBJ (allres)
413                                   + NIS_RES_NUMOBJ (res))
414                                  * sizeof (nis_object));
415                     if (objects_val == NULL)
416                       {
417                         NIS_RES_STATUS (res) = NIS_NOMEMORY;
418                         goto fail;
419                       }
420                     NIS_RES_OBJECT (allres) = objects_val;
421                     memcpy (NIS_RES_OBJECT (allres) + NIS_RES_NUMOBJ (allres),
422                             NIS_RES_OBJECT (res),
423                             NIS_RES_NUMOBJ (res) * sizeof (nis_object));
424                     NIS_RES_NUMOBJ (allres) += NIS_RES_NUMOBJ (res);
425                     NIS_RES_NUMOBJ (res) = 0;
426                     free (NIS_RES_OBJECT (res));
427                     NIS_RES_OBJECT (res) = NULL;
428                     NIS_RES_STATUS (allres) = NIS_RES_STATUS (res);
429                     xdr_free ((xdrproc_t) _xdr_nis_result, (char *) res);
430                   }
431                 clnt_status = __follow_path (&tablepath, &tableptr, ibreq,
432                                              &bptr);
433                 if (clnt_status != NIS_SUCCESS)
434                   {
435                     /* Prepare for the nis_freeresult call.  */
436                     memset (res, '\0', sizeof (*res));
437
438                     if (clnt_status == NIS_NOMEMORY)
439                       NIS_RES_STATUS (allres) = clnt_status;
440                     ++done;
441                   }
442               }
443             else
444               ++done;
445             break;
446           case NIS_CBRESULTS:
447             if (cb != NULL)
448               {
449                 __nis_do_callback (&bptr, &res->cookie, cb);
450                 NIS_RES_STATUS (res) = cb->result;
451
452                 if (!(flags & ALL_RESULTS))
453                   ++done;
454                 else
455                   {
456                     clnt_status
457                       = __follow_path (&tablepath, &tableptr, ibreq, &bptr);
458                     if (clnt_status != NIS_SUCCESS)
459                       {
460                         if (clnt_status == NIS_NOMEMORY)
461                           NIS_RES_STATUS (res) = clnt_status;
462                         ++done;
463                       }
464                   }
465               }
466             break;
467           case NIS_SYSTEMERROR:
468           case NIS_NOSUCHNAME:
469           case NIS_NOT_ME:
470             /* If we had first tried the old binding, do nothing, but
471                get a new binding */
472             if (!first_try)
473               {
474                 if (__nisbind_next (&bptr) != NIS_SUCCESS)
475                   {
476                     ++done;
477                     break; /* No more servers to search */
478                   }
479                 while (__nisbind_connect (&bptr) != NIS_SUCCESS)
480                   {
481                     if (__nisbind_next (&bptr) != NIS_SUCCESS)
482                       {
483                         ++done;
484                         break; /* No more servers to search */
485                       }
486                   }
487                 goto again;
488               }
489             break;
490           default:
491             if (!first_try)
492               {
493                 /* Try the next domainname if we don't follow a link.  */
494                 free (ibreq->ibr_name);
495                 ibreq->ibr_name = NULL;
496                 if (__builtin_expect (count_links, 0))
497                   {
498                     NIS_RES_STATUS (res) = NIS_LINKNAMEERROR;
499                     ++done;
500                     break;
501                   }
502                 ++name_nr;
503                 if (names[name_nr] == NULL)
504                   {
505                     ++done;
506                     break;
507                   }
508                 ibreq->ibr_name = strdup (names[name_nr]);
509                 if (ibreq->ibr_name == NULL)
510                   {
511                     NIS_RES_STATUS (res) = NIS_NOMEMORY;
512                     goto fail;
513                   }
514                 first_try = 1; /* Try old binding at first */
515                 goto again;
516               }
517             break;
518           }
519       first_try = 0;
520
521       if (cb)
522         {
523           __nis_destroy_callback (cb);
524           ibreq->ibr_cbhost.ibr_cbhost_len = 0;
525           ibreq->ibr_cbhost.ibr_cbhost_val = NULL;
526           cb = NULL;
527         }
528
529       __nisbind_destroy (&bptr);
530       nis_free_directory (dir);
531     }
532
533   free (tablepath);
534
535   if (names != namebuf)
536     nis_freenames (names);
537
538   nis_free_request (ibreq);
539
540   if (allres)
541     {
542       nis_freeresult (res);
543       return allres;
544     }
545
546   return res;
547 }
548 libnsl_hidden_def (nis_list)
549
550 nis_result *
551 nis_add_entry (const_nis_name name, const nis_object *obj2, unsigned int flags)
552 {
553   nis_result *res = calloc (1, sizeof (nis_result));
554   if (res == NULL)
555     return NULL;
556
557   if (name == NULL)
558     {
559       NIS_RES_STATUS (res) = NIS_BADNAME;
560       return res;
561     }
562
563   ib_request *ibreq = __create_ib_request (name, flags);
564   if (ibreq == NULL)
565     {
566       NIS_RES_STATUS (res) = NIS_BADNAME;
567       return res;
568     }
569
570   nis_object obj;
571   memcpy (&obj, obj2, sizeof (nis_object));
572
573   size_t namelen = strlen (name);
574   char buf1[namelen + 20];
575   char buf4[namelen + 20];
576
577   if (obj.zo_name == NULL || strlen (obj.zo_name) == 0)
578     obj.zo_name = nis_leaf_of_r (name, buf1, sizeof (buf1));
579
580   if (obj.zo_owner == NULL || strlen (obj.zo_owner) == 0)
581     obj.zo_owner = nis_local_principal ();
582
583   if (obj.zo_group == NULL || strlen (obj.zo_group) == 0)
584     obj.zo_group = nis_local_group ();
585
586   obj.zo_domain = nis_domain_of_r (name, buf4, sizeof (buf4));
587
588   ibreq->ibr_obj.ibr_obj_val = nis_clone_object (&obj, NULL);
589   if (ibreq->ibr_obj.ibr_obj_val == NULL)
590     {
591       nis_free_request (ibreq);
592       NIS_RES_STATUS (res) = NIS_NOMEMORY;
593       return res;
594     }
595   ibreq->ibr_obj.ibr_obj_len = 1;
596
597   nis_error status = __do_niscall (ibreq->ibr_name, NIS_IBADD,
598                                    (xdrproc_t) _xdr_ib_request,
599                                    (caddr_t) ibreq,
600                                    (xdrproc_t) _xdr_nis_result,
601                                    (caddr_t) res, 0, NULL);
602   if (__builtin_expect (status != NIS_SUCCESS, 0))
603     NIS_RES_STATUS (res) = status;
604
605   nis_free_request (ibreq);
606
607   return res;
608 }
609
610 nis_result *
611 nis_modify_entry (const_nis_name name, const nis_object *obj2,
612                   unsigned int flags)
613 {
614   nis_object obj;
615   nis_result *res;
616   nis_error status;
617   ib_request *ibreq;
618   size_t namelen = strlen (name);
619   char buf1[namelen + 20];
620   char buf4[namelen + 20];
621
622   res = calloc (1, sizeof (nis_result));
623   if (res == NULL)
624     return NULL;
625
626   ibreq = __create_ib_request (name, flags);
627   if (ibreq == NULL)
628     {
629       NIS_RES_STATUS (res) = NIS_BADNAME;
630       return res;
631     }
632
633   memcpy (&obj, obj2, sizeof (nis_object));
634
635   if (obj.zo_name == NULL || strlen (obj.zo_name) == 0)
636     obj.zo_name = nis_leaf_of_r (name, buf1, sizeof (buf1));
637
638   if (obj.zo_owner == NULL || strlen (obj.zo_owner) == 0)
639     obj.zo_owner = nis_local_principal ();
640
641   if (obj.zo_group == NULL || strlen (obj.zo_group) == 0)
642     obj.zo_group = nis_local_group ();
643
644   obj.zo_domain = nis_domain_of_r (name, buf4, sizeof (buf4));
645
646   ibreq->ibr_obj.ibr_obj_val = nis_clone_object (&obj, NULL);
647   if (ibreq->ibr_obj.ibr_obj_val == NULL)
648     {
649       nis_free_request (ibreq);
650       NIS_RES_STATUS (res) = NIS_NOMEMORY;
651       return res;
652     }
653   ibreq->ibr_obj.ibr_obj_len = 1;
654
655   status = __do_niscall (ibreq->ibr_name, NIS_IBMODIFY,
656                          (xdrproc_t) _xdr_ib_request,
657                          (caddr_t) ibreq, (xdrproc_t) _xdr_nis_result,
658                          (caddr_t) res, 0, NULL);
659   if (__builtin_expect (status != NIS_SUCCESS, 0))
660     NIS_RES_STATUS (res) = status;
661
662   nis_free_request (ibreq);
663
664   return res;
665 }
666
667 nis_result *
668 nis_remove_entry (const_nis_name name, const nis_object *obj,
669                   unsigned int flags)
670 {
671   nis_result *res;
672   ib_request *ibreq;
673   nis_error status;
674
675   res = calloc (1, sizeof (nis_result));
676   if (res == NULL)
677     return NULL;
678
679   if (name == NULL)
680     {
681       NIS_RES_STATUS (res) = NIS_BADNAME;
682       return res;
683     }
684
685   ibreq = __create_ib_request (name, flags);
686   if (ibreq == NULL)
687     {
688       NIS_RES_STATUS (res) = NIS_BADNAME;
689       return res;
690     }
691
692   if (obj != NULL)
693     {
694       ibreq->ibr_obj.ibr_obj_val = nis_clone_object (obj, NULL);
695       if (ibreq->ibr_obj.ibr_obj_val == NULL)
696         {
697           nis_free_request (ibreq);
698           NIS_RES_STATUS (res) = NIS_NOMEMORY;
699           return res;
700         }
701       ibreq->ibr_obj.ibr_obj_len = 1;
702     }
703
704   if ((status = __do_niscall (ibreq->ibr_name, NIS_IBREMOVE,
705                               (xdrproc_t) _xdr_ib_request,
706                               (caddr_t) ibreq, (xdrproc_t) _xdr_nis_result,
707                               (caddr_t) res, 0, NULL)) != NIS_SUCCESS)
708     NIS_RES_STATUS (res) = status;
709
710   nis_free_request (ibreq);
711
712   return res;
713 }
714
715 nis_result *
716 nis_first_entry (const_nis_name name)
717 {
718   nis_result *res;
719   ib_request *ibreq;
720   nis_error status;
721
722   res = calloc (1, sizeof (nis_result));
723   if (res == NULL)
724     return NULL;
725
726   if (name == NULL)
727     {
728       NIS_RES_STATUS (res) = NIS_BADNAME;
729       return res;
730     }
731
732   ibreq = __create_ib_request (name, 0);
733   if (ibreq == NULL)
734     {
735       NIS_RES_STATUS (res) = NIS_BADNAME;
736       return res;
737     }
738
739   status = __do_niscall (ibreq->ibr_name, NIS_IBFIRST,
740                          (xdrproc_t) _xdr_ib_request,
741                          (caddr_t) ibreq, (xdrproc_t) _xdr_nis_result,
742                          (caddr_t) res, 0, NULL);
743
744   if (__builtin_expect (status != NIS_SUCCESS, 0))
745     NIS_RES_STATUS (res) = status;
746
747   nis_free_request (ibreq);
748
749   return res;
750 }
751
752 nis_result *
753 nis_next_entry (const_nis_name name, const netobj *cookie)
754 {
755   nis_result *res;
756   ib_request *ibreq;
757   nis_error status;
758
759   res = calloc (1, sizeof (nis_result));
760   if (res == NULL)
761     return NULL;
762
763   if (name == NULL)
764     {
765       NIS_RES_STATUS (res) = NIS_BADNAME;
766       return res;
767     }
768
769   ibreq = __create_ib_request (name, 0);
770   if (ibreq == NULL)
771     {
772       NIS_RES_STATUS (res) = NIS_BADNAME;
773       return res;
774     }
775
776   if (cookie != NULL)
777     {
778       ibreq->ibr_cookie.n_bytes = cookie->n_bytes;
779       ibreq->ibr_cookie.n_len = cookie->n_len;
780     }
781
782   status = __do_niscall (ibreq->ibr_name, NIS_IBNEXT,
783                          (xdrproc_t) _xdr_ib_request,
784                          (caddr_t) ibreq, (xdrproc_t) _xdr_nis_result,
785                          (caddr_t) res, 0, NULL);
786
787   if (__builtin_expect (status != NIS_SUCCESS, 0))
788     NIS_RES_STATUS (res) = status;
789
790   if (cookie != NULL)
791     {
792       /* Don't give cookie free, it is not from us */
793       ibreq->ibr_cookie.n_bytes = NULL;
794       ibreq->ibr_cookie.n_len = 0;
795     }
796
797   nis_free_request (ibreq);
798
799   return res;
800 }