nis/nis_table.c

   1 /* Copyright (c) 1997-1999, 2003, 2004, 2005, 2006, 2007, 2011
   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 }