about summary refs log tree commit diff
path: root/nis
diff options
context:
space:
mode:
Diffstat (limited to 'nis')
-rw-r--r--nis/Banner2
-rw-r--r--nis/Makefile2
-rw-r--r--nis/nis_cache.c275
3 files changed, 271 insertions, 8 deletions
diff --git a/nis/Banner b/nis/Banner
index 77ab77e8d2..3a1729c3b0 100644
--- a/nis/Banner
+++ b/nis/Banner
@@ -1 +1 @@
-NIS(YP)/NIS+ NSS modules 0.12 by Thorsten Kukuk
+NIS(YP)/NIS+ NSS modules 0.13 by Thorsten Kukuk
diff --git a/nis/Makefile b/nis/Makefile
index 7c70c9c2a8..e7dd50c1d9 100644
--- a/nis/Makefile
+++ b/nis/Makefile
@@ -21,7 +21,7 @@
 #
 subdir	:= nis
 
-headers			:= $(wildcard rpcsvc/*.[hx]) bits/nislib.h
+headers			:= $(wildcard rpcsvc/*.[hx])
 distribute		:= nss-nis.h nss-nisplus.h nis_intern.h Banner \
 			nisplus-parser.h
 
diff --git a/nis/nis_cache.c b/nis/nis_cache.c
index 8e1d583003..4c0ea7b186 100644
--- a/nis/nis_cache.c
+++ b/nis/nis_cache.c
@@ -20,25 +20,288 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include <syslog.h>
+#include <string.h>
 #include <sys/stat.h>
 #include <sys/mman.h>
 #include <rpcsvc/nis.h>
-#include <rpcsvc/nislib.h>
 #include <rpcsvc/nis_cache.h>
 #include <bits/libc-lock.h>
 
 #include "nis_intern.h"
 
-/* XXX Only dummy functions in the moment. The real implementation
-       will follow, if we have a working nis_cachemgr */
+static struct timeval TIMEOUT = {10, 0};
+
+#define HEADER_MAGIC  0x07021971
+#define SPACER_MAGIC  0x07654321
+
+#define CACHE_VERSION 0x00000001
+
+struct cache_header
+{
+  u_long magic;               /* Magic number */
+  u_long vers;                /* Cache file format version */
+  u_short tcp_port;           /* tcp port of nis_cachemgr */
+  u_short udp_port;           /* udp port of nis_cachemgr */
+  u_long entries;             /* Number of cached objs. */
+  off_t used;                 /* How many space are used ? */
+};
+typedef struct cache_header cache_header;
+
+struct cache_spacer
+{
+  u_long magic;                /* Magic number */
+  u_long hashval;
+  time_t ctime;                /* time we have created this object */
+  time_t ttl;                  /* time to life of this object */
+  off_t next_offset;
+};
+typedef struct cache_spacer cache_spacer;
+
+static int cache_fd = -1;
+static int clnt_sock;
+static caddr_t maddr = NULL;
+static size_t msize;
+static CLIENT *cache_clnt = NULL;
+
+/* If there is no cachemgr, we shouldn't use NIS_SHARED_DIRCACHE, if
+   there is no NIS_SHARED_DIRCACHE, we couldn't use nis_cachemgr.
+   So, if the clnt_call to nis_cachemgr fails, we also close the cache file.
+   But another thread could read the cache => lock the cache_fd and cache_clnt
+   variables with the same lock */
+__libc_lock_define_initialized (static, mgrlock)
+
+/* close file handles and nis_cachemgr connection */
+static void
+__cache_close (void)
+{
+  if (cache_fd != -1)
+    {
+      close (cache_fd);
+      cache_fd = -1;
+    }
+  if (cache_clnt != NULL)
+    {
+      clnt_destroy (cache_clnt);
+      close (clnt_sock);
+      cache_clnt = NULL;
+    }
+}
+
+/* open the cache file and connect to nis_cachemgr */
+static bool_t
+__cache_open (void)
+{
+  struct sockaddr_in sin;
+  cache_header hptr;
+
+  if ((cache_fd = open (CACHEFILE, O_RDONLY)) == -1)
+    return FALSE;
+
+  if (read (cache_fd, &hptr, sizeof (cache_header)) == -1
+      || lseek (cache_fd, 0, SEEK_SET) < 0)
+    {
+      close (cache_fd);
+      cache_fd = -1;
+      return FALSE;
+    }
+  if (hptr.magic != HEADER_MAGIC)
+    {
+      close (cache_fd);
+      cache_fd = -1;
+      syslog (LOG_ERR, _("NIS+: cache file is corrupt!"));
+      return FALSE;
+    }
+
+  memset (&sin, '\0', sizeof (sin));
+  sin.sin_family = AF_INET;
+  clnt_sock = RPC_ANYSOCK;
+  sin.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+  sin.sin_port = htons (hptr.tcp_port);
+  cache_clnt = clnttcp_create (&sin, CACHEPROG, CACHE_VER_1, &clnt_sock, 0, 0);
+  if (cache_clnt == NULL)
+    {
+      close (cache_fd);
+      cache_fd = -1;
+      return FALSE;
+    }
+  /* If the program exists, close the socket */
+  if (fcntl (clnt_sock, F_SETFD, FD_CLOEXEC) == -1)
+    perror (_("fcntl: F_SETFD"));
+  return TRUE;
+}
+
+/* Ask the cache manager to update directory 'name'
+   for us (because the ttl has expired). */
+static nis_error
+__cache_refresh (nis_name name)
+{
+  char clnt_res = 0;
+  nis_error result = NIS_SUCCESS;
+
+  __libc_lock_lock (mgrlock);
+
+  if (cache_clnt == NULL)
+    result = NIS_FAIL;
+  else if (clnt_call (cache_clnt, NIS_CACHE_REFRESH_ENTRY,
+		      (xdrproc_t) xdr_wrapstring, (caddr_t) name,
+		      (xdrproc_t) xdr_void, &clnt_res, TIMEOUT)
+	   != RPC_SUCCESS)
+    {
+      __cache_close ();
+      result = NIS_FAIL;
+    }
+
+  __libc_lock_unlock (mgrlock);
+
+  return result;
+}
+
+static nis_error
+__cache_find (const_nis_name name, directory_obj **obj)
+{
+  unsigned long hash;
+  struct cache_header *hptr;
+  struct cache_spacer *cs;
+  struct directory_obj *dir;
+  XDR xdrs;
+  caddr_t addr, ptr;
+  time_t now = time (NULL);
+
+  if (maddr == NULL)
+    return NIS_FAIL;
+
+  hash = __nis_hash (name, strlen(name));
+  hptr = (cache_header *)maddr;
+  if ((hptr->magic != HEADER_MAGIC) || (hptr->vers != CACHE_VERSION))
+    {
+      syslog (LOG_ERR, _("NIS+: cache file is corrupt!"));
+      return NIS_SYSTEMERROR;
+    }
+  cs = (cache_spacer *)(maddr + sizeof (cache_header));
+  while (cs->next_offset)
+    {
+      if (cs->magic != SPACER_MAGIC)
+	{
+	  syslog (LOG_ERR, _("NIS+: cache file is corrupt!"));
+	  return NIS_SYSTEMERROR;
+	}
+      if (cs->hashval == hash)
+	{
+	  if ((now - cs->ctime) > cs->ttl)
+	    return NIS_CACHEEXPIRED;
+	  dir = calloc (1, sizeof (directory_obj));
+	  addr = (caddr_t)cs + sizeof (cache_spacer);
+	  xdrmem_create (&xdrs, addr, cs->next_offset, XDR_DECODE);
+	  xdr_directory_obj (&xdrs, dir);
+	  xdr_destroy (&xdrs);
+	  *obj = dir;
+	  return NIS_SUCCESS;
+	}
+      ptr = (caddr_t)cs;
+      ptr += cs->next_offset + sizeof (struct cache_spacer);
+      cs = (struct cache_spacer *)ptr;
+    }
+  return NIS_NOTFOUND;
+}
+
+static directory_obj *
+internal_cache_search (const_nis_name name)
+{
+  directory_obj *dir;
+  nis_error res;
+  int second_refresh = 0;
+  struct stat s;
+
+  if (cache_fd == -1)
+    if (__cache_open () == FALSE)
+      return NULL;
+
+ again:
+  /* This lock is for nis_cachemgr, so it couldn't write a new cache
+     file if we reading it */
+  if (__nis_lock_cache () == -1)
+    return NULL;
+
+  if (maddr != NULL)
+    munmap (maddr, msize);
+  if (fstat (cache_fd, &s) < 0)
+    maddr = MAP_FAILED;
+  else
+    {
+      msize = s.st_size;
+      maddr = mmap (0, msize, PROT_READ, MAP_SHARED, cache_fd, 0);
+    }
+  if (maddr == MAP_FAILED)
+    {
+      __nis_unlock_cache ();
+      return NULL;
+    }
+
+  res = __cache_find (name, &dir);
+
+  munmap (maddr, msize);
+  maddr = NULL;
+  /* Allow nis_cachemgr to write a new cachefile */
+  __nis_unlock_cache ();
+
+  switch(res)
+    {
+    case NIS_CACHEEXPIRED:
+      if (second_refresh)
+	{
+	  __cache_close ();
+	  syslog (LOG_WARNING,
+		  _("NIS+: nis_cachemgr failed to refresh object for us"));
+	  return NULL;
+	}
+      ++second_refresh;
+      if (__cache_refresh ((char *) name) != NIS_SUCCESS)
+	return NULL;
+      goto again;
+      break;
+    case NIS_SUCCESS:
+      return dir;
+    default:
+      return NULL;
+    }
+}
+
 directory_obj *
 __cache_search (const_nis_name name)
 {
-  return NULL;
+  directory_obj *dir;
+
+  __libc_lock_lock (mgrlock);
+
+  dir = internal_cache_search (name);
+
+  __libc_lock_unlock (mgrlock);
+
+  return dir;
 }
 
-nis_error 
+nis_error
 __cache_add (fd_result *fd)
 {
-  return NIS_FAIL;
+  char clnt_res = 0;
+  nis_error result = NIS_SUCCESS;
+
+  __libc_lock_lock (mgrlock);
+
+  if (cache_clnt == NULL)
+    if (__cache_open () == FALSE)
+      result = NIS_FAIL;
+
+  if (cache_clnt != NULL &&
+      (clnt_call (cache_clnt, NIS_CACHE_ADD_ENTRY, (xdrproc_t) xdr_fd_result,
+		  (caddr_t)fd, (xdrproc_t) xdr_void, &clnt_res, TIMEOUT)
+       != RPC_SUCCESS))
+    {
+      __cache_close ();
+      result = NIS_RPCERROR;
+    }
+
+  __libc_lock_unlock (mgrlock);
+
+  return result;
 }