nis/nis_table.c

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