nis/nis_table.c

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