(getspnam_plususer): Return NSS_STATUS_SUCCESS if entry was found.
[kopensolaris-gnu/glibc.git] / nis / nis_call.c
index ff9e768..d65b1dd 100644 (file)
@@ -1,25 +1,26 @@
-/* Copyright (C) 1997, 1998 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>
@@ -60,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)
     {
@@ -69,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;
 
@@ -93,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;
@@ -108,8 +106,7 @@ __bind_next (dir_binding *bind)
   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;
@@ -118,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;
@@ -158,11 +153,11 @@ __bind_connect (dir_binding *dbp)
   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)
     {
-      if (serv->key_type == NIS_PK_DH && key_secretkey_is_set ())
+      if (serv->key_type == NIS_PK_DH)
        {
          char netname[MAXNETNAMELEN+1];
          char *p;
@@ -182,38 +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,
-              cache2_info *cinfo)
+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;
@@ -233,93 +207,27 @@ __bind_create (const nis_server *serv_val, u_int serv_len, u_long flags,
   /* 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 (cinfo != NULL && cinfo->server_used >= 0)
-    {
-      dbp->server_used = cinfo->server_used;
-      dbp->current_ep = cinfo->current_ep;
-      dbp->class = cinfo->class;
-    }
-  else if (__nis_findfastest (dbp) < 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, nis_cb *cb, cache2_info *cinfo)
+__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;
 
-  dbp = __bind_create (server, server_len, flags, cinfo);
   if (dbp == NULL)
     return NIS_NAMEUNREACHABLE;
-  while (__bind_connect (dbp) != NIS_SUCCESS)
-    {
-      if (__bind_next (dbp) != NIS_SUCCESS)
-       {
-         __bind_destroy (dbp);
-         return NIS_NAMEUNREACHABLE;
-       }
-    }
 
   do
     {
@@ -327,10 +235,7 @@ __do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
       result = clnt_call (dbp->clnt, prog, xargs, req, xres, resp, RPCTIMEOUT);
 
       if (result != RPC_SUCCESS)
-       {
-         __bind_destroy (dbp);
-         retcode = NIS_RPCERROR;
-       }
+       retcode = NIS_RPCERROR;
       else
        {
          switch (prog)
@@ -342,8 +247,8 @@ __do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
                  __nis_do_callback(dbp, &((nis_result *)resp)->cookie, cb);
                  break;
                }
-             /* Yes, this is correct. If we doesn't have to start
-                a callback, look if we have to search another server */
+             /* 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:
@@ -353,19 +258,16 @@ __do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
            case NIS_IBREMOVE:
            case NIS_IBFIRST:
            case NIS_IBNEXT:
-             if ((((nis_result *)resp)->status == NIS_NOTFOUND) ||
+             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)
+                 if (__nisbind_next (dbp) == NIS_SUCCESS)
                    {
-                     while (__bind_connect (dbp) != NIS_SUCCESS)
+                     while (__nisbind_connect (dbp) != NIS_SUCCESS)
                        {
-                         if (__bind_next (dbp) != NIS_SUCCESS)
-                           {
-                             __bind_destroy (dbp);
+                         if (__nisbind_next (dbp) != NIS_SUCCESS)
                              return NIS_SUCCESS;
-                           }
                        }
                    }
                  else
@@ -374,19 +276,16 @@ __do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
                }
              break;
            case NIS_FINDDIRECTORY:
-             if ((((fd_result *)resp)->status == NIS_NOTFOUND) ||
+             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)
+                 if (__nisbind_next (dbp) == NIS_SUCCESS)
                    {
-                     while (__bind_connect (dbp) != NIS_SUCCESS)
+                     while (__nisbind_connect (dbp) != NIS_SUCCESS)
                        {
-                         if (__bind_next (dbp) != NIS_SUCCESS)
-                           {
-                             __bind_destroy (dbp);
-                             return NIS_SUCCESS;
-                           }
+                         if (__nisbind_next (dbp) != NIS_SUCCESS)
+                           return NIS_SUCCESS;
                        }
                    }
                  else
@@ -396,19 +295,16 @@ __do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
              break;
            case NIS_DUMPLOG: /* log_result */
            case NIS_DUMP:
-             if ((((log_result *)resp)->lr_status == NIS_NOTFOUND) ||
+             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)
+                 if (__nisbind_next (dbp) == NIS_SUCCESS)
                    {
-                     while (__bind_connect (dbp) != NIS_SUCCESS)
+                     while (__nisbind_connect (dbp) != NIS_SUCCESS)
                        {
-                         if (__bind_next (dbp) != NIS_SUCCESS)
-                           {
-                             __bind_destroy (dbp);
-                             return NIS_SUCCESS;
-                           }
+                         if (__nisbind_next (dbp) != NIS_SUCCESS)
+                           return NIS_SUCCESS;
                        }
                    }
                  else
@@ -419,7 +315,6 @@ __do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
            default:
              break;
            }
-         __bind_destroy (dbp);
          retcode = NIS_SUCCESS;
        }
     }
@@ -428,9 +323,37 @@ __do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
   return retcode;
 }
 
+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)
+{
+  dir_binding dbp;
+  nis_error status;
+
+  if (flags & MASTER_ONLY)
+    server_len = 1;
+
+  status = __nisbind_create (&dbp, server, server_len, flags);
+  if (status != NIS_SUCCESS)
+    return status;
+
+  while (__nisbind_connect (&dbp) != NIS_SUCCESS)
+    {
+      if (__nisbind_next (&dbp) != NIS_SUCCESS)
+       return NIS_NAMEUNREACHABLE;
+    }
+
+  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, u_long flags,
-              nis_error *status)
+rec_dirsearch (const_nis_name name, directory_obj *dir, nis_error *status)
 {
   fd_result *fd_res;
   XDR xdrs;
@@ -471,7 +394,7 @@ rec_dirsearch (const_nis_name name, directory_obj *dir, u_long flags,
            /* 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
          {
@@ -484,9 +407,10 @@ rec_dirsearch (const_nis_name name, directory_obj *dir, u_long flags,
     case LOWER_NAME:
       {
        directory_obj *obj;
-       char leaf [strlen (name) + 3];
-       char domain [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;
 
@@ -494,7 +418,7 @@ rec_dirsearch (const_nis_name name, directory_obj *dir, u_long flags,
 
        do
          {
-           if (strlen (domain) == 0)
+           if (domain[0] == '\0')
              {
                nis_free_directory (dir);
                return NULL;
@@ -535,7 +459,7 @@ rec_dirsearch (const_nis_name name, directory_obj *dir, u_long flags,
            /* 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;
@@ -552,7 +476,7 @@ rec_dirsearch (const_nis_name name, directory_obj *dir, 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, u_long flags)
+first_shoot (const_nis_name name, directory_obj *dir)
 {
   directory_obj *obj;
   fd_result *fd_res;
@@ -590,51 +514,57 @@ first_shoot (const_nis_name name, directory_obj *dir, u_long flags)
 }
 
 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,
-             nis_cb *cb)
+__nisfind_server (const_nis_name name, directory_obj **dir)
 {
-  nis_error retcode;
-  directory_obj *dir = NULL;
-  nis_server *server;
-  u_int server_len;
-  cache2_info cinfo = {-1, -1, -1};
-  int saved_errno = errno;
-
   if (name == NULL)
     return NIS_BADNAME;
 
+#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;
       directory_obj *obj;
 
-      dir = readColdStartFile ();
-      if (dir == NULL) /* No /var/nis/NIS_COLD_START->no NIS+ installed */
-       {
-         __set_errno (saved_errno);
-         return NIS_UNAVAIL;
-       }
+      *dir = readColdStartFile ();
+      if (*dir == NULL) /* No /var/nis/NIS_COLD_START->no NIS+ installed */
+       return NIS_UNAVAIL;
 
       /* Try at first, if servers in "dir" know our object */
-      obj = first_shoot (name, dir, flags);
+      obj = first_shoot (name, *dir);
       if (obj == NULL)
        {
-         dir = rec_dirsearch (name, dir, flags, &status);
-         if (dir == NULL)
-           {
-             __set_errno (saved_errno);
-             return status;
-           }
+         *dir = rec_dirsearch (name, *dir, &status);
+         if (*dir == NULL)
+           return status;
        }
       else
-       dir = obj;
+       *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;
@@ -646,9 +576,22 @@ __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, cb, &cinfo);
+      __nisbind_destroy (&bptr);
+    }
 
   nis_free_directory (dir);