Change everything to store error code through provided pointer and not
[kopensolaris-gnu/glibc.git] / nis / nss_nisplus / nisplus-ethers.c
index 4dcda76..76805f1 100644 (file)
@@ -1,5 +1,4 @@
 /* Copyright (C) 1997 Free Software Foundation, Inc.
-
    This file is part of the GNU C Library.
    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1997.
 
 #include <errno.h>
 #include <ctype.h>
 #include <string.h>
-#include <libc-lock.h>
+#include <bits/libc-lock.h>
 #include <netdb.h>
 #include <netinet/ether.h>
 #include <rpcsvc/nis.h>
-#include <rpcsvc/nislib.h>
 #include <netinet/if_ether.h>
 
 #include "nss-nisplus.h"
@@ -34,7 +32,8 @@
 __libc_lock_define_initialized (static, lock)
 
 static nis_result *result = NULL;
-static nis_name *names = NULL;
+static nis_name tablename_val = NULL;
+static u_long tablename_len = 0;
 
 /* Because the `ethers' lookup does not fit so well in the scheme so
    we define a dummy struct here which helps us to use the available
@@ -46,32 +45,6 @@ struct etherent
 };
 struct etherent_data {};
 
-#define ENTNAME         etherent
-#define DATABASE        "ethers"
-#include "../../nss/nss_files/files-parse.c"
-LINE_PARSER
-("#",
- /* Read the ethernet address: 6 x 8bit hexadecimal number.  */
- {
-   size_t cnt;
-
-   for (cnt = 0; cnt < 6; ++cnt)
-     {
-       unsigned int number;
-
-       if (cnt < 5)
-         INT_FIELD (number, ISCOLON , 0, 16, (unsigned int))
-       else
-         INT_FIELD (number, isspace, 0, 16, (unsigned int))
-
-       if (number > 0xff)
-         return 0;
-       result->e_addr.ether_addr_octet[cnt] = number;
-     }
- };
- STRING_FIELD (result->e_name, isspace, 1);
- )
-
 #define NISENTRYVAL(idx,col,res) \
         ((res)->objects.objects_val[(idx)].zo_data.objdata_u.en_data.en_cols.en_cols_val[(col)].ec_value.ec_value_val)
 
@@ -80,59 +53,75 @@ LINE_PARSER
 
 static int
 _nss_nisplus_parse_etherent (nis_result *result, struct etherent *ether,
-                          char *buffer, size_t buflen)
+                          char *buffer, size_t buflen, int *errnop)
 {
   char *p = buffer;
   size_t room_left = buflen;
-  struct parser_data *data = (void *) buffer;
 
   if (result == NULL)
-    return -1;
-
-  if ((result->status != NIS_SUCCESS && result->status != NIS_S_SUCCESS) ||
-      result->objects.objects_len != 1 ||
-      result->objects.objects_val[0].zo_data.zo_type != ENTRY_OBJ ||
-      strcmp(result->objects.objects_val[0].zo_data.objdata_u.en_data.en_type,
-             "ethers_tbl") != 0 ||
-      result->objects.objects_val[0].zo_data.objdata_u.en_data.en_cols.en_cols_len < 2)
-    return -1;
-
-  memset (p, '\0', room_left);
-  
+    return 0;
+
+  if ((result->status != NIS_SUCCESS && result->status != NIS_S_SUCCESS)
+      || result->objects.objects_len != 1
+      || __type_of (NIS_RES_OBJECT (result)) != NIS_ENTRY_OBJ
+      || strcmp (NIS_RES_OBJECT (result)->EN_data.en_type,
+                "ethers_tbl") != 0
+      || NIS_RES_OBJECT (result)->EN_data.en_cols.en_cols_len < 2)
+    return 0;
+
   /* Generate the ether entry format and use the normal parser */
   if (NISENTRYLEN (0, 0, result) +1 > room_left)
     {
-      __set_errno (ERANGE);
+      *errnop = ERANGE;
       return -1;
     }
   strncpy (p, NISENTRYVAL (0, 0, result), NISENTRYLEN (0, 0, result));
   room_left -= (NISENTRYLEN (0, 0, result) +1);
+  ether->e_name = p;
+
+  ether->e_addr = *ether_aton (NISENTRYVAL (0, 1, result));
 
-  if (NISENTRYLEN (0, 1, result) +1 > room_left)
+  return 1;
+}
+
+static enum nss_status
+_nss_create_tablename (int *errnop)
+{
+  if (tablename_val == NULL)
     {
-      __set_errno (ERANGE);
-      return -1;
+      char buf [40 + strlen (nis_local_directory ())];
+      char *p;
+
+      p = __stpcpy (buf, "ethers.org_dir.");
+      p = __stpcpy (p, nis_local_directory ());
+      tablename_val = __strdup (buf);
+      if (tablename_val == NULL)
+       {
+         *errnop = errno;
+         return NSS_STATUS_TRYAGAIN;
+       }
+      tablename_len = strlen (tablename_val);
     }
-  strcat (p, "\t");
-  strncat (p, NISENTRYVAL (0, 1, result), NISENTRYLEN (0, 1, result));
-  room_left -= (NISENTRYLEN (0, 1, result) + 1); 
-  
-  return _nss_files_parse_etherent (p,ether, data, buflen);
+  return NSS_STATUS_SUCCESS;
 }
 
+
 enum nss_status
 _nss_nisplus_setetherent (void)
 {
+  enum nss_status status;
+  int err;
+
+  status = NSS_STATUS_SUCCESS;
+
   __libc_lock_lock (lock);
 
   if (result)
     nis_freeresult (result);
   result = NULL;
-  if (names)
-    {
-      nis_freenames (names);
-      names = NULL;
-    }
+
+  if (_nss_create_tablename (&err) != NSS_STATUS_SUCCESS)
+    status = NSS_STATUS_UNAVAIL;
 
   __libc_lock_unlock (lock);
 
@@ -147,11 +136,6 @@ _nss_nisplus_endetherent (void)
   if (result)
     nis_freeresult (result);
   result = NULL;
-  if (names)
-    {
-      nis_freenames (names);
-      names = NULL;
-    }
 
   __libc_lock_unlock (lock);
 
@@ -159,21 +143,28 @@ _nss_nisplus_endetherent (void)
 }
 
 static enum nss_status
-internal_nisplus_getetherent_r (struct etherent *ether, char *buffer, 
-                               size_t buflen)
+internal_nisplus_getetherent_r (struct etherent *ether, char *buffer,
+                               size_t buflen, int *errnop)
 {
   int parse_res;
-  
+
+  if (tablename_val == NULL)
+    {
+      enum nss_status status = _nss_create_tablename (errnop);
+
+      if (status != NSS_STATUS_SUCCESS)
+       return status;
+    }
+
   /* Get the next entry until we found a correct one. */
   do
     {
+      nis_result *saved_result;
+
       if (result == NULL)
        {
-         names = nis_getnames("ethers.org_dir");
-         if (names == NULL || names[0] == NULL)
-           return NSS_STATUS_UNAVAIL;
-         
-         result = nis_first_entry(names[0]);
+         saved_result = NULL;
+         result = nis_first_entry (tablename_val);
          if (niserr2nss (result->status) != NSS_STATUS_SUCCESS)
            return niserr2nss (result->status);
        }
@@ -181,28 +172,45 @@ internal_nisplus_getetherent_r (struct etherent *ether, char *buffer,
        {
          nis_result *res2;
 
-         res2 = nis_next_entry(names[0], &result->cookie);
-         nis_freeresult (result);
+         res2 = nis_next_entry(tablename_val, &result->cookie);
+         saved_result = result;
          result = res2;
          if (niserr2nss (result->status) != NSS_STATUS_SUCCESS)
-           return niserr2nss (result->status);
+           {
+             nis_freeresult (saved_result);
+             return niserr2nss (result->status);
+           }
        }
-      
-      parse_res = _nss_nisplus_parse_etherent (result, ether, buffer, buflen);
+
+      parse_res = _nss_nisplus_parse_etherent (result, ether, buffer,
+                                              buflen, errnop);
+      if (parse_res == -1)
+       {
+         nis_freeresult (result);
+         *errnop = ERANGE;
+         result = saved_result;
+         return NSS_STATUS_TRYAGAIN;
+       }
+      else
+       {
+         if (saved_result != NULL)
+           nis_freeresult (saved_result);
+       }
+
     } while (!parse_res);
 
   return NSS_STATUS_SUCCESS;
 }
 
 enum nss_status
-_nss_nisplus_getetherent_r (struct etherent *result, char *buffer, 
-                           size_t buflen)
+_nss_nisplus_getetherent_r (struct etherent *result, char *buffer,
+                           size_t buflen, int *errnop)
 {
   int status;
-  
+
   __libc_lock_lock (lock);
 
-  status = internal_nisplus_getetherent_r (result, buffer, buflen);
+  status = internal_nisplus_getetherent_r (result, buffer, buflen, errnop);
 
   __libc_lock_unlock (lock);
 
@@ -210,70 +218,100 @@ _nss_nisplus_getetherent_r (struct etherent *result, char *buffer,
 }
 
 enum nss_status
-_nss_nisplus_gethostton_r (const char *name, struct etherent *eth, 
-                          char *buffer, size_t buflen)
+_nss_nisplus_gethostton_r (const char *name, struct etherent *eth,
+                          char *buffer, size_t buflen, int *errnop)
 {
   int parse_res;
-  
-  if (name == NULL)
-    return NSS_STATUS_NOTFOUND;
-  else
-    {  
+
+  if (tablename_val == NULL)
+    {
+      enum nss_status status = _nss_create_tablename (errnop);
+
+      if (status != NSS_STATUS_SUCCESS)
+       return status;
+    }
+
+  if (name != NULL)
+    {
       nis_result *result;
-      char buf[strlen (name) + 255];
-      
-      sprintf(buf, "[name=%s],ethers.org_dir", name);
-      
-      result = nis_list(buf, EXPAND_NAME, NULL, NULL);
-      
+      char buf[strlen (name) + 40 + tablename_len];
+
+      sprintf (buf, "[name=%s],%s", name, tablename_val);
+
+      result = nis_list (buf, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
+
       if (niserr2nss (result->status) != NSS_STATUS_SUCCESS)
-        return niserr2nss (result->status);
-      
-      parse_res = _nss_nisplus_parse_etherent (result, eth, buffer, buflen);
-      
+       {
+         enum nss_status status = niserr2nss (result->status);
+         nis_freeresult (result);
+         return status;
+       }
+
+      parse_res = _nss_nisplus_parse_etherent (result, eth, buffer,
+                                              buflen, errnop);
+      if (parse_res == -1)
+       {
+         nis_freeresult (result);
+         *errnop = ERANGE;
+         return NSS_STATUS_TRYAGAIN;
+       }
+
       if (parse_res)
         return NSS_STATUS_SUCCESS;
-
-      if (!parse_res && errno == ERANGE)
-        return NSS_STATUS_TRYAGAIN;
-      else
-        return NSS_STATUS_NOTFOUND;
     }
+  return NSS_STATUS_NOTFOUND;
 }
 
 enum nss_status
 _nss_nisplus_getntohost_r (const struct ether_addr *addr,
                           struct etherent *eth,
-                          char *buffer, size_t buflen)
+                          char *buffer, size_t buflen, int *errnop)
 {
-  int parse_res;
-  nis_result *result;
-  char buf[255];
-  
+  if (tablename_val == NULL)
+    {
+      enum nss_status status = _nss_create_tablename (errnop);
+
+      if (status != NSS_STATUS_SUCCESS)
+       return status;
+    }
+
   if (addr == NULL)
     {
-      __set_errno (EINVAL);
+      *errnop = EINVAL;
       return NSS_STATUS_UNAVAIL;
     }
-  
-  memset (&buf, '\0', sizeof (buf));
-  snprintf(buf, sizeof (buf), "[addr=%x:%x:%x:%x:%x:%x],ethers.org_dir",
-          addr->ether_addr_octet[0], addr->ether_addr_octet[1],
-          addr->ether_addr_octet[2], addr->ether_addr_octet[3],
-          addr->ether_addr_octet[4], addr->ether_addr_octet[5]);
-  
-  result = nis_list(buf, EXPAND_NAME, NULL, NULL);
-  
-  if (niserr2nss (result->status) != NSS_STATUS_SUCCESS)
-    return niserr2nss (result->status);
-  
-  parse_res = _nss_nisplus_parse_etherent (result, eth, buffer, buflen);
-  
-  if (parse_res)
-    return NSS_STATUS_SUCCESS;
-  
-  if (!parse_res && errno == ERANGE)
-    return NSS_STATUS_TRYAGAIN;
   else
-    return NSS_STATUS_NOTFOUND;
+    {
+      int parse_res;
+      nis_result *result;
+      char buf[255 + tablename_len];
+
+      memset (&buf, '\0', sizeof (buf));
+      sprintf (buf, "[addr=%x:%x:%x:%x:%x:%x],ethers.org_dir",
+              addr->ether_addr_octet[0], addr->ether_addr_octet[1],
+              addr->ether_addr_octet[2], addr->ether_addr_octet[3],
+              addr->ether_addr_octet[4], addr->ether_addr_octet[5]);
+
+      result = nis_list (buf, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
+
+      if (niserr2nss (result->status) != NSS_STATUS_SUCCESS)
+       {
+         enum nss_status status = niserr2nss (result->status);
+         nis_freeresult (result);
+         return status;
+       }
+
+      parse_res = _nss_nisplus_parse_etherent (result, eth, buffer,
+                                              buflen, errnop);
+      if (parse_res == -1)
+       {
+         nis_freeresult (result);
+         *errnop = ERANGE;
+         return NSS_STATUS_TRYAGAIN;
+       }
+
+      if (parse_res)
+       return NSS_STATUS_SUCCESS;
+    }
+  return NSS_STATUS_NOTFOUND;
 }