(getspnam_plususer): Return NSS_STATUS_SUCCESS if entry was found.
[kopensolaris-gnu/glibc.git] / nis / nis_call.c
index 6727550..d65b1dd 100644 (file)
@@ -1,33 +1,41 @@
-/* Copyright (C) 1997 Free Software Foundation, Inc.
+/* Copyright (C) 1997, 1998, 2001 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1997.
 
    The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
 
    The GNU C Library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
+   Lesser General Public License for more details.
 
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
 
+#include <errno.h>
 #include <fcntl.h>
 #include <string.h>
+#include <libintl.h>
 #include <rpc/rpc.h>
 #include <rpc/auth.h>
 #include <rpcsvc/nis.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
+
+#include "nis_xdr.h"
 #include "nis_intern.h"
 
-static struct timeval TIMEOUT = {10, 0};
+static struct timeval RPCTIMEOUT = {10, 0};
+static struct timeval UDPTIMEOUT = {5, 0};
+
+extern u_short __pmap_getnisport (struct sockaddr_in *address, u_long program,
+                                 u_long version, u_int protocol);
 
 unsigned long
 inetstr2int (const char *str)
@@ -53,8 +61,8 @@ inetstr2int (const char *str)
   return inet_addr (buffer);
 }
 
-static void
-__bind_destroy (dir_binding *bind)
+void
+__nisbind_destroy (dir_binding *bind)
 {
   if (bind->clnt != NULL)
     {
@@ -62,12 +70,10 @@ __bind_destroy (dir_binding *bind)
        auth_destroy (bind->clnt->cl_auth);
       clnt_destroy (bind->clnt);
     }
-  free (bind->server_val);
-  free (bind);
 }
 
-static nis_error
-__bind_next (dir_binding *bind)
+nis_error
+__nisbind_next (dir_binding *bind)
 {
   u_int j;
 
@@ -86,8 +92,7 @@ __bind_next (dir_binding *bind)
        j < bind->server_val[bind->server_used].ep.ep_len; ++j)
     if (strcmp (bind->server_val[bind->server_used].ep.ep_val[j].family,
                "inet") == 0)
-      if (strcmp (bind->server_val[bind->server_used].ep.ep_val[j].proto,
-                 "-") == 0)
+      if (bind->server_val[bind->server_used].ep.ep_val[j].proto[0] == '-')
        {
          bind->current_ep = j;
          return NIS_SUCCESS;
@@ -98,12 +103,10 @@ __bind_next (dir_binding *bind)
   if (bind->server_used >= bind->server_len)
     bind->server_used = 0;
 
-  for (j = bind->current_ep + 1;
-       j < bind->server_val[bind->server_used].ep.ep_len; ++j)
+  for (j = 0; j < bind->server_val[bind->server_used].ep.ep_len; ++j)
     if (strcmp (bind->server_val[bind->server_used].ep.ep_val[j].family,
                "inet") == 0)
-      if (strcmp (bind->server_val[bind->server_used].ep.ep_val[j].proto,
-                 "-") == 0)
+      if (bind->server_val[bind->server_used].ep.ep_val[j].proto[0] == '-')
        {
          bind->current_ep = j;
          return NIS_SUCCESS;
@@ -112,12 +115,10 @@ __bind_next (dir_binding *bind)
   return NIS_FAIL;
 }
 
-static nis_error
-__bind_connect (dir_binding *dbp)
+nis_error
+__nisbind_connect (dir_binding *dbp)
 {
-  struct sockaddr_in check;
   nis_server *serv;
-  int checklen;
 
   if (dbp == NULL)
     return NIS_FAIL;
@@ -133,10 +134,15 @@ __bind_connect (dir_binding *dbp)
   if (dbp->addr.sin_addr.s_addr == 0)
     return NIS_FAIL;
 
+  /* Check, if the host is online and rpc.nisd is running. Much faster
+     then the clnt*_create functions: */
+  if (__pmap_getnisport (&dbp->addr, NIS_PROG, NIS_VERSION, IPPROTO_UDP) == 0)
+    return NIS_RPCERROR;
+
   dbp->socket = RPC_ANYSOCK;
   if (dbp->use_udp)
     dbp->clnt = clntudp_create (&dbp->addr, NIS_PROG, NIS_VERSION,
-                                TIMEOUT, &dbp->socket);
+                                UDPTIMEOUT, &dbp->socket);
   else
     dbp->clnt = clnttcp_create (&dbp->addr, NIS_PROG, NIS_VERSION,
                                 &dbp->socket, 0, 0);
@@ -144,10 +150,10 @@ __bind_connect (dir_binding *dbp)
   if (dbp->clnt == NULL)
     return NIS_RPCERROR;
 
-  clnt_control (dbp->clnt, CLSET_TIMEOUT, (caddr_t)&TIMEOUT);
+  clnt_control (dbp->clnt, CLSET_TIMEOUT, (caddr_t)&RPCTIMEOUT);
   /* If the program exists, close the socket */
   if (fcntl (dbp->socket, F_SETFD, 1) == -1)
-    perror (_("fcntl: F_SETFD"));
+    perror ("fcntl: F_SETFD");
 
   if (dbp->use_auth)
     {
@@ -171,37 +177,17 @@ __bind_connect (dir_binding *dbp)
       dbp->use_auth = TRUE;
     }
 
-  /* Get port for sanity checks later */
-  checklen = sizeof (struct sockaddr_in);
-  memset (&check, 0, checklen);
-  if (dbp->use_udp)
-    bind (dbp->socket, (struct sockaddr *)&check, checklen);
-  check.sin_family = AF_INET;
-  if (!getsockname (dbp->socket, (struct sockaddr *)&check, &checklen))
-    dbp->port = check.sin_port;
-
-  dbp->create = time (NULL);
-
   return NIS_SUCCESS;
 }
 
-static dir_binding *
-__bind_create (const nis_server *serv_val, u_int serv_len, u_long flags)
+nis_error
+__nisbind_create (dir_binding *dbp, const nis_server *serv_val,
+                 unsigned int serv_len, unsigned int flags)
 {
-  dir_binding *dbp;
-  u_int i;
-
-  dbp = calloc (1, sizeof (dir_binding));
-  if (dbp == NULL)
-    return NULL;
+  dbp->clnt = NULL;
 
   dbp->server_len = serv_len;
-  dbp->server_val = calloc (1, sizeof (nis_server) * serv_len);
-  if (dbp->server_val == NULL)
-    {
-      free (dbp);
-      return NULL;
-    }
+  dbp->server_val = (nis_server *)serv_val;
 
   if (flags & USE_DGRAM)
     dbp->use_udp = TRUE;
@@ -218,167 +204,117 @@ __bind_create (const nis_server *serv_val, u_int serv_len, u_long flags)
   else
     dbp->master_only = FALSE;
 
+  /* We try the first server */
   dbp->trys = 1;
 
-  for (i = 0; i < serv_len; ++i)
-    {
-      if (serv_val[i].name != NULL)
-       dbp->server_val[i].name = strdup (serv_val[i].name);
-
-      dbp->server_val[i].ep.ep_len = serv_val[i].ep.ep_len;
-      if (dbp->server_val[i].ep.ep_len > 0)
-       {
-         unsigned long j;
-
-         dbp->server_val[i].ep.ep_val =
-           malloc (serv_val[i].ep.ep_len * sizeof (endpoint));
-         for (j = 0; j < dbp->server_val[i].ep.ep_len; ++j)
-           {
-             if (serv_val[i].ep.ep_val[j].uaddr)
-               dbp->server_val[i].ep.ep_val[j].uaddr =
-                 strdup (serv_val[i].ep.ep_val[j].uaddr);
-             else
-               dbp->server_val[i].ep.ep_val[j].uaddr = NULL;
-             if (serv_val[i].ep.ep_val[j].family)
-               dbp->server_val[i].ep.ep_val[j].family =
-                 strdup (serv_val[i].ep.ep_val[j].family);
-             else
-               dbp->server_val[i].ep.ep_val[j].family = NULL;
-             if (serv_val[i].ep.ep_val[j].proto)
-               dbp->server_val[i].ep.ep_val[j].proto =
-                 strdup (serv_val[i].ep.ep_val[j].proto);
-             else
-               dbp->server_val[i].ep.ep_val[j].proto = NULL;
-           }
-       }
-      else
-       dbp->server_val[i].ep.ep_val = NULL;
-      dbp->server_val[i].key_type = serv_val[i].key_type;
-      dbp->server_val[i].pkey.n_len = serv_val[i].pkey.n_len;
-      if (serv_val[i].pkey.n_len > 0)
-       {
-         dbp->server_val[i].pkey.n_bytes =
-           malloc (serv_val[i].pkey.n_len);
-         if (dbp->server_val[i].pkey.n_bytes == NULL)
-           return NULL;
-         memcpy (dbp->server_val[i].pkey.n_bytes, serv_val[i].pkey.n_bytes,
-                 serv_val[i].pkey.n_len);
-       }
-      else
-       dbp->server_val[i].pkey.n_bytes = NULL;
-    }
-
+  dbp->class = -1;
   if (__nis_findfastest (dbp) < 1)
     {
-      __bind_destroy (dbp);
-      return NULL;
+      __nisbind_destroy (dbp);
+      return NIS_NAMEUNREACHABLE;
     }
 
-  return dbp;
+  return NIS_SUCCESS;
 }
 
+/* __nisbind_connect (dbp) must be run before calling this function !
+   So we could use the same binding twice */
 nis_error
-__do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
-              xdrproc_t xargs, caddr_t req, xdrproc_t xres, caddr_t resp,
-              u_long flags)
+__do_niscall3 (dir_binding *dbp, u_long prog, xdrproc_t xargs, caddr_t req,
+              xdrproc_t xres, caddr_t resp, unsigned int flags, nis_cb *cb)
 {
   enum clnt_stat result;
   nis_error retcode;
-  dir_binding *dbp;
 
-  if (flags & MASTER_ONLY)
-    server_len = 1;
-
-  if ((dbp = __bind_create (server, server_len, flags)) == NULL)
-    return NIS_UNAVAIL;
-  while (__bind_connect (dbp) != NIS_SUCCESS)
-    {
-      if (__bind_next (dbp) != NIS_SUCCESS)
-       {
-         __bind_destroy (dbp);
-         return NIS_NAMEUNREACHABLE;
-       }
-    }
+  if (dbp == NULL)
+    return NIS_NAMEUNREACHABLE;
 
   do
     {
     again:
-      result = clnt_call (dbp->clnt, prog, xargs, req, xres, resp, TIMEOUT);
+      result = clnt_call (dbp->clnt, prog, xargs, req, xres, resp, RPCTIMEOUT);
 
       if (result != RPC_SUCCESS)
-       {
-         clnt_perror (dbp->clnt, "__do_niscall2: clnt_call");
-         __bind_destroy (dbp);
-         retcode = NIS_RPCERROR;
-       }
+       retcode = NIS_RPCERROR;
       else
        {
          switch (prog)
            {
+           case NIS_IBLIST:
+             if ((((nis_result *)resp)->status == NIS_CBRESULTS) &&
+                 (cb != NULL))
+               {
+                 __nis_do_callback(dbp, &((nis_result *)resp)->cookie, cb);
+                 break;
+               }
+             /* Yes, the missing break is correct. If we doesn't have to
+                start a callback, look if we have to search another server */
            case NIS_LOOKUP:
            case NIS_ADD:
            case NIS_MODIFY:
            case NIS_REMOVE:
-           case NIS_IBLIST:
            case NIS_IBADD:
            case NIS_IBMODIFY:
            case NIS_IBREMOVE:
            case NIS_IBFIRST:
            case NIS_IBNEXT:
-             if ((((nis_result *)xres)->status == NIS_NOTFOUND) ||
-                 (((nis_result *)xres)->status == NIS_NOSUCHNAME) ||
-                 (((nis_result *)xres)->status == NIS_NOT_ME))
+             if ((((nis_result *)resp)->status == NIS_SYSTEMERROR) ||
+                 (((nis_result *)resp)->status == NIS_NOSUCHNAME) ||
+                 (((nis_result *)resp)->status == NIS_NOT_ME))
                {
-                 if (__bind_next (dbp) == NIS_SUCCESS)
-                   while (__bind_connect (dbp) != NIS_SUCCESS)
-                     {
-                       if (__bind_next (dbp) != NIS_SUCCESS)
-                         {
-                           __bind_destroy (dbp);
-                           return NIS_SUCCESS;
-                         }
-                     }
+                 if (__nisbind_next (dbp) == NIS_SUCCESS)
+                   {
+                     while (__nisbind_connect (dbp) != NIS_SUCCESS)
+                       {
+                         if (__nisbind_next (dbp) != NIS_SUCCESS)
+                             return NIS_SUCCESS;
+                       }
+                   }
+                 else
+                   break; /* No more servers to search in */
                  goto again;
                }
+             break;
            case NIS_FINDDIRECTORY:
-             if ((((fd_result *)xres)->status == NIS_NOTFOUND) ||
-                 (((fd_result *)xres)->status == NIS_NOSUCHNAME) ||
-                 (((fd_result *)xres)->status == NIS_NOT_ME))
+             if ((((fd_result *)resp)->status == NIS_SYSTEMERROR) ||
+                 (((fd_result *)resp)->status == NIS_NOSUCHNAME) ||
+                 (((fd_result *)resp)->status == NIS_NOT_ME))
                {
-                 if (__bind_next (dbp) == NIS_SUCCESS)
-                   while (__bind_connect (dbp) != NIS_SUCCESS)
-                     {
-                       if (__bind_next (dbp) != NIS_SUCCESS)
-                         {
-                           __bind_destroy (dbp);
+                 if (__nisbind_next (dbp) == NIS_SUCCESS)
+                   {
+                     while (__nisbind_connect (dbp) != NIS_SUCCESS)
+                       {
+                         if (__nisbind_next (dbp) != NIS_SUCCESS)
                            return NIS_SUCCESS;
-                         }
-                     }
+                       }
+                   }
+                 else
+                   break; /* No more servers to search in */
                  goto again;
                }
              break;
            case NIS_DUMPLOG: /* log_result */
            case NIS_DUMP:
-             if ((((log_result *)xres)->lr_status == NIS_NOTFOUND) ||
-                 (((log_result *)xres)->lr_status == NIS_NOSUCHNAME) ||
-                 (((log_result *)xres)->lr_status == NIS_NOT_ME))
+             if ((((log_result *)resp)->lr_status == NIS_SYSTEMERROR) ||
+                 (((log_result *)resp)->lr_status == NIS_NOSUCHNAME) ||
+                 (((log_result *)resp)->lr_status == NIS_NOT_ME))
                {
-                 if (__bind_next (dbp) == NIS_SUCCESS)
-                   while (__bind_connect (dbp) != NIS_SUCCESS)
-                     {
-                       if (__bind_next (dbp) != NIS_SUCCESS)
-                         {
-                           __bind_destroy (dbp);
+                 if (__nisbind_next (dbp) == NIS_SUCCESS)
+                   {
+                     while (__nisbind_connect (dbp) != NIS_SUCCESS)
+                       {
+                         if (__nisbind_next (dbp) != NIS_SUCCESS)
                            return NIS_SUCCESS;
-                         }
-                     }
+                       }
+                   }
+                 else
+                   break; /* No more servers to search in */
                  goto again;
                }
              break;
            default:
              break;
            }
-         __bind_destroy (dbp);
          retcode = NIS_SUCCESS;
        }
     }
@@ -387,37 +323,42 @@ __do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
   return retcode;
 }
 
-static directory_obj *
-rec_dirsearch (const_nis_name name, directory_obj *dir, u_long flags,
-              nis_error *status)
+nis_error
+__do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
+              xdrproc_t xargs, caddr_t req, xdrproc_t xres, caddr_t resp,
+              unsigned int flags, nis_cb *cb)
 {
-  fd_result *fd_res;
-  XDR xdrs;
-  char domain [strlen (name) + 3];
+  dir_binding dbp;
+  nis_error status;
 
-  nis_domain_of_r (name, domain, sizeof (domain));
-  if (strncmp (domain, "org_dir.", 8) == 0)
-    {
-      char tmp[strlen (name) + 3];
+  if (flags & MASTER_ONLY)
+    server_len = 1;
+
+  status = __nisbind_create (&dbp, server, server_len, flags);
+  if (status != NIS_SUCCESS)
+    return status;
 
-      nis_domain_of_r (domain, tmp, sizeof (tmp));
-      strcpy (domain, tmp);
+  while (__nisbind_connect (&dbp) != NIS_SUCCESS)
+    {
+      if (__nisbind_next (&dbp) != NIS_SUCCESS)
+       return NIS_NAMEUNREACHABLE;
     }
-  else
-    if (strncmp (domain, "groups_dir.", 11) == 0)
-      {
-       char tmp[strlen (name) + 3];
 
-       nis_domain_of_r (domain, tmp, sizeof (tmp));
-       strcpy (domain, tmp);
-      }
-    else
-      {
-       /* We have no grous_dir or org_dir, so try the complete name */
-       strcpy (domain, name);
-      }
+  status = __do_niscall3 (&dbp, prog, xargs, req, xres, resp, flags, cb);
+
+  __nisbind_destroy (&dbp);
+
+  return status;
+
+}
+
+static directory_obj *
+rec_dirsearch (const_nis_name name, directory_obj *dir, nis_error *status)
+{
+  fd_result *fd_res;
+  XDR xdrs;
 
-  switch (nis_dir_cmp (domain, dir->do_name))
+  switch (nis_dir_cmp (name, dir->do_name))
     {
     case SAME_NAME:
       *status = NIS_SUCCESS;
@@ -438,23 +379,22 @@ rec_dirsearch (const_nis_name name, directory_obj *dir, u_long flags,
        *status = fd_res->status;
        if (fd_res->status != NIS_SUCCESS)
          {
-           nis_free_directory (dir);
-           xdr_free((xdrproc_t)xdr_fd_result, (caddr_t)fd_res);
-           return NULL;
+           /* Try the current directory obj, maybe it works */
+           __free_fdresult (fd_res);
+           return dir;
          }
-       __cache_add (fd_res);
        obj = calloc(1, sizeof(directory_obj));
        xdrmem_create(&xdrs, fd_res->dir_data.dir_data_val,
                      fd_res->dir_data.dir_data_len, XDR_DECODE);
-       xdr_directory_obj(&xdrs, obj);
+       _xdr_directory_obj(&xdrs, obj);
        xdr_destroy(&xdrs);
-       xdr_free((xdrproc_t)xdr_fd_result, (caddr_t)fd_res);
+       __free_fdresult (fd_res);
        if (obj != NULL)
          {
            /* We have found a NIS+ server serving ndomain, now
               let us search for "name" */
            nis_free_directory (dir);
-           return rec_dirsearch (name, obj, flags, status);
+           return rec_dirsearch (name, obj, status);
          }
        else
          {
@@ -467,13 +407,18 @@ rec_dirsearch (const_nis_name name, directory_obj *dir, u_long flags,
     case LOWER_NAME:
       {
        directory_obj *obj;
-       char leaf [strlen (name) + 3];
-       char ndomain [strlen (name) + 3];
+       size_t namelen = strlen (name);
+       char leaf [namelen + 3];
+       char domain [namelen + 3];
+       char ndomain [namelen + 3];
        char *cp;
+       u_int run = 0;
+
+       strcpy (domain, name);
 
        do
          {
-           if (strlen (domain) == 0)
+           if (domain[0] == '\0')
              {
                nis_free_directory (dir);
                return NULL;
@@ -481,8 +426,16 @@ rec_dirsearch (const_nis_name name, directory_obj *dir, u_long flags,
            nis_leaf_of_r (domain, leaf, sizeof (leaf));
            nis_domain_of_r (domain, ndomain, sizeof (ndomain));
            strcpy (domain, ndomain);
+           ++run;
          }
        while (nis_dir_cmp (domain, dir->do_name) != SAME_NAME);
+
+       if (run == 1)
+         {
+           /* We have found the directory above. Use it. */
+           return dir;
+         }
+
        cp = strchr (leaf, '\0');
        *cp++ = '.';
        strcpy (cp, domain);
@@ -491,23 +444,22 @@ rec_dirsearch (const_nis_name name, directory_obj *dir, u_long flags,
        *status = fd_res->status;
        if (fd_res->status != NIS_SUCCESS)
          {
-           nis_free_directory (dir);
-           xdr_free((xdrproc_t)xdr_fd_result, (caddr_t)fd_res);
-           return NULL;
+           /* Try the current directory object, maybe it works */
+           __free_fdresult (fd_res);
+           return dir;
          }
-       __cache_add (fd_res);
        obj = calloc(1, sizeof(directory_obj));
        xdrmem_create(&xdrs, fd_res->dir_data.dir_data_val,
                      fd_res->dir_data.dir_data_len, XDR_DECODE);
-       xdr_directory_obj(&xdrs, obj);
+       _xdr_directory_obj(&xdrs, obj);
        xdr_destroy(&xdrs);
-       xdr_free((xdrproc_t)xdr_fd_result, (caddr_t)fd_res);
+       __free_fdresult (fd_res);
        if (obj != NULL)
          {
            /* We have found a NIS+ server serving ndomain, now
               let us search for "name" */
            nis_free_directory (dir);
-           return rec_dirsearch (name, obj, flags, status);
+           return rec_dirsearch (name, obj, status);
          }
       }
     break;
@@ -521,33 +473,98 @@ rec_dirsearch (const_nis_name name, directory_obj *dir, u_long flags,
   return NULL;
 }
 
-nis_error
-__do_niscall (const_nis_name name, u_long prog, xdrproc_t xargs,
-             caddr_t req, xdrproc_t xres, caddr_t resp, u_long flags)
+/* We try to query the current server for the searched object,
+   maybe he know about it ? */
+static directory_obj *
+first_shoot (const_nis_name name, directory_obj *dir)
 {
-  nis_error retcode;
-  directory_obj *dir = NULL;
-  nis_server *server;
-  u_int server_len;
+  directory_obj *obj;
+  fd_result *fd_res;
+  XDR xdrs;
+  char domain [strlen (name) + 3];
+
+  if (nis_dir_cmp (name, dir->do_name) == SAME_NAME)
+    return dir;
+
+  nis_domain_of_r (name, domain, sizeof (domain));
+
+  if (nis_dir_cmp (domain, dir->do_name) == SAME_NAME)
+    return dir;
 
+  fd_res = __nis_finddirectory (dir, domain);
+  if (fd_res->status != NIS_SUCCESS)
+    {
+      __free_fdresult (fd_res);
+      return NULL;
+    }
+  obj = calloc(1, sizeof(directory_obj));
+  if (obj == NULL)
+    return NULL;
+  xdrmem_create(&xdrs, fd_res->dir_data.dir_data_val,
+               fd_res->dir_data.dir_data_len, XDR_DECODE);
+  _xdr_directory_obj (&xdrs, obj);
+  xdr_destroy (&xdrs);
+  __free_fdresult (fd_res);
+  if (obj != NULL)
+    {
+      nis_free_directory (dir);
+      return obj;
+    }
+  return NULL;
+}
+
+nis_error
+__nisfind_server (const_nis_name name, directory_obj **dir)
+{
   if (name == NULL)
     return NIS_BADNAME;
 
-  if ((flags & NO_CACHE) !=  NO_CACHE)
-    dir = __cache_search (name);
+#if 0
+  /* Search in local cache. In the moment, we ignore the fastest server */
+  if (!(flags & NO_CACHE))
+    dir = __nis_cache_search (name, flags, &cinfo);
+#endif
 
-  if (dir == NULL)
+  if (*dir == NULL)
     {
       nis_error status;
-      dir = readColdStartFile ();
-      if (dir == NULL) /* No /var/nis/NIS_COLD_START->no NIS+ installed */
+      directory_obj *obj;
+
+      *dir = readColdStartFile ();
+      if (*dir == NULL) /* No /var/nis/NIS_COLD_START->no NIS+ installed */
        return NIS_UNAVAIL;
 
-      dir = rec_dirsearch (name, dir, flags, &status);
-      if (dir == NULL)
-       return status;
+      /* Try at first, if servers in "dir" know our object */
+      obj = first_shoot (name, *dir);
+      if (obj == NULL)
+       {
+         *dir = rec_dirsearch (name, *dir, &status);
+         if (*dir == NULL)
+           return status;
+       }
+      else
+       *dir = obj;
     }
 
+  return NIS_SUCCESS;
+}
+
+nis_error
+__do_niscall (const_nis_name name, u_long prog, xdrproc_t xargs,
+             caddr_t req, xdrproc_t xres, caddr_t resp, unsigned int flags,
+             nis_cb *cb)
+{
+  nis_error retcode;
+  dir_binding bptr;
+  directory_obj *dir = NULL;
+  nis_server *server;
+  u_int server_len;
+  int saved_errno = errno;
+
+  retcode = __nisfind_server (name, &dir);
+  if (retcode != NIS_SUCCESS)
+    return retcode;
+
   if (flags & MASTER_ONLY)
     {
       server = dir->do_servers.do_servers_val;
@@ -559,11 +576,26 @@ __do_niscall (const_nis_name name, u_long prog, xdrproc_t xargs,
       server_len = dir->do_servers.do_servers_len;
     }
 
+  retcode = __nisbind_create (&bptr, server, server_len, flags);
+  if (retcode == NIS_SUCCESS)
+    {
+      while (__nisbind_connect (&bptr) != NIS_SUCCESS)
+       {
+         if (__nisbind_next (&bptr) != NIS_SUCCESS)
+           {
+             nis_free_directory (dir);
+             __nisbind_destroy (&bptr);
+             return NIS_NAMEUNREACHABLE;
+           }
+       }
+      retcode = __do_niscall3 (&bptr, prog, xargs, req, xres, resp, flags, cb);
 
-  retcode = __do_niscall2 (server, server_len, prog, xargs, req, xres, resp,
-                          flags);
+      __nisbind_destroy (&bptr);
+    }
 
   nis_free_directory (dir);
 
+  __set_errno (saved_errno);
+
   return retcode;
 }