ldap-automount.c

/* Copyright (C) 2005 Luke Howard.
   This file is part of the nss_ldap library.
   Contributed by Luke Howard, <lukeh@padl.com>, 2005.

   The nss_ldap 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.

   The nss_ldap 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.

   You should have received a copy of the GNU Library General Public
   License along with the nss_ldap 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.

   $Id$
 */


static char rcsId[] = "$Id$";

#include "config.h"

#ifdef HAVE_PORT_BEFORE_H
#include <port_before.h>
#endif

#if defined(HAVE_THREAD_H) && !defined(_AIX)
#include <thread.h>
#elif defined(HAVE_PTHREAD_H)
#include <pthread.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#ifdef HAVE_LBER_H
#include <lber.h>
#endif
#ifdef HAVE_LDAP_H
#include <ldap.h>
#endif

#include "ldap-nss.h"
#include "ldap-automount.h"
#include "util.h"

#ifdef HAVE_PORT_AFTER_H
#include <port_after.h>
#endif

static NSS_STATUS
_nss_ldap_parse_automount (LDAPMessage * e,
			   ldap_state_t * pvt,
			   void *result, char *buffer, size_t buflen)
{
  NSS_STATUS stat;
  char ***keyval = result;

  stat = 
    _nss_ldap_assign_attrval (e, AT (automountKey), keyval[0],
			      &buffer, &buflen);
  if (stat != NSS_SUCCESS)
    return stat;

  stat = 
    _nss_ldap_assign_attrval (e, AT (automountInformation), keyval[1],
			      &buffer, &buflen);
  if (stat != NSS_SUCCESS)
    return stat;

  return NSS_SUCCESS;
}

NSS_STATUS
_nss_ldap_am_context_alloc(ldap_automount_context_t **pContext)
{
  ldap_automount_context_t *context;

  context = (ldap_automount_context_t *)malloc (sizeof(*context));
  if (context == NULL)
    {
      return NSS_TRYAGAIN;
    }

  context->lac_state = NULL;

  context->lac_dn_size = 1;   /* number of slots allocated */
  context->lac_dn_count = 0;  /* number of slots used */
  context->lac_dn_index = 0;  /* enumeration index */

  /* List of DNs, grown on demand */
  context->lac_dn_list = (char **)malloc (context->lac_dn_size *
					  sizeof(char *));
  if (context->lac_dn_list == NULL)
    {
      free (context);
      return NSS_TRYAGAIN;
    }

  if (_nss_ldap_ent_context_init_locked (&context->lac_state) == NULL)
    {
      free (context->lac_dn_list);
      free (context);
      return NSS_UNAVAIL;
    }

  *pContext = context;

  return NSS_SUCCESS;
}

void
_nss_ldap_am_context_free(ldap_automount_context_t **pContext)
{
  ldap_automount_context_t *context;
  size_t i;

  context = *pContext;

  if (context == NULL)
    return;

  if (context->lac_dn_list != NULL)
    {
      for (i = 0; i < context->lac_dn_count; i++)
	{
#ifdef HAVE_LDAP_MEMFREE
	  ldap_memfree (context->lac_dn_list[i]);
#else
	  free (context->lac_dn_list[i]);
#endif /* HAVE_LDAP_MEMFREE */
	}
      free (context->lac_dn_list);
    }

  if (context->lac_state != NULL)
    {
      _nss_ldap_ent_context_release (&(context->lac_state));
    }

  memset (context, 0, sizeof (*context));
  free (context);

  *pContext = NULL;

  return;
}

static NSS_STATUS
am_context_add_dn (LDAPMessage * e,
		   ldap_state_t * pvt,
		   void *result, char *buffer, size_t buflen)
{
  ldap_automount_context_t *context = (ldap_automount_context_t *) result;
  char *dn;

  dn = _nss_ldap_get_dn (e);
  if (dn == NULL)
    {
      return NSS_NOTFOUND;
    }

  if (context->lac_dn_count >= context->lac_dn_size)
    {
      char **new_dns;

      new_dns = (char **)realloc(context->lac_dn_list,
				 2 * context->lac_dn_size * sizeof(char *));
      if (new_dns == NULL)
	{
#ifdef HAVE_LDAP_MEMFREE
	  ldap_memfree (dn);
#else
	  free (dn);
#endif /* HAVE_LDAP_MEMFREE */
	  return NSS_TRYAGAIN;
	}

      context->lac_dn_list = new_dns;
      context->lac_dn_size *= 2;
    }

  context->lac_dn_list[context->lac_dn_count++] = dn;

  return NSS_SUCCESS;
}

NSS_STATUS
_nss_ldap_am_context_init(const char *mapname, ldap_automount_context_t **pContext)
{
  NSS_STATUS stat;
  ldap_automount_context_t *context = NULL;
  const char *no_attrs[] = { NULL };
  ldap_args_t a;
  ent_context_t *key = NULL;
  int errnop;

  *pContext = NULL;

  stat = _nss_ldap_am_context_alloc (&context);
  if (stat != NSS_SUCCESS)
      return stat;

  LA_INIT (a);
  LA_TYPE (a) = LA_TYPE_STRING;
  LA_STRING (a) = mapname;

  do
    {
      stat = _nss_ldap_getent_ex (&a, &key,
				  (void *)context,
				  NULL, 0, &errnop,
				  _nss_ldap_filt_setautomntent,
				  LM_AUTOMOUNT,
				  no_attrs,
				  am_context_add_dn);
    }
  while (stat == NSS_SUCCESS);

  if (key != NULL)
    {
      _nss_ldap_ent_context_release (&key);
    }

  if (context->lac_dn_count == 0)
    {
      _nss_ldap_am_context_free (&context);
      return NSS_NOTFOUND;
    }
  else if (stat == NSS_NOTFOUND)
    {
      stat = NSS_SUCCESS;
    }

  context->lac_dn_index = 0;

  *pContext = context;
  return NSS_SUCCESS;
}

#ifdef HAVE_NSS_H
NSS_STATUS _nss_ldap_setautomntent(const char *mapname, void **private)
{
  ldap_automount_context_t *context = NULL;
  NSS_STATUS stat;

  debug ("==> _nss_ldap_setautomntent");

  _nss_ldap_enter ();

  stat = _nss_ldap_init ();
  if (stat != NSS_SUCCESS)
    {
      _nss_ldap_leave ();
      debug ("<== _nss_ldap_setautomntent");
      return stat;
    }

  stat = _nss_ldap_am_context_init (mapname, &context);
  if (stat != NSS_SUCCESS)
    {
      _nss_ldap_leave ();
      debug ("<== _nss_ldap_setautomntent");
      return stat;
    }

  *private = (void *)context;
  _nss_ldap_leave ();

  debug ("<== _nss_ldap_setautomntent");

  return stat;
}

NSS_STATUS _nss_ldap_getautomntent_r(void *private, const char **key, const char **value,
				     char *buffer, size_t buflen, int *errnop)
{
  NSS_STATUS stat;
  ldap_automount_context_t *context = (ldap_automount_context_t *)private;
  ldap_args_t a;
  char **keyval[2];

  if (context == NULL)
    return NSS_NOTFOUND;

  debug ("==> _nss_ldap_getautomntent_r");

  keyval[0] = (char **)key;
  keyval[1] = (char **)value;

  _nss_ldap_enter ();

  do
    {
      assert (context->lac_dn_index < context->lac_dn_count);

      LA_INIT (a);
      LA_TYPE (a) = LA_TYPE_NONE;
      LA_BASE (a) = context->lac_dn_list[context->lac_dn_index];

      stat = _nss_ldap_getent_ex (&a, &context->lac_state,
				  (void *)keyval,
				  buffer, buflen, errnop,
				  _nss_ldap_filt_getautomntent,
				  LM_AUTOMOUNT,
				  NULL,
				  _nss_ldap_parse_automount);
      if (stat == NSS_NOTFOUND)
	{
	  if (context->lac_dn_index < context->lac_dn_count - 1)
	    context->lac_dn_index++;
	  else
	    break; /* move along, nothing more to see here */
	}
    }
  while (stat == NSS_NOTFOUND);

  _nss_ldap_leave ();

  debug ("<== _nss_ldap_getautomntent_r");

  return stat;
}

NSS_STATUS _nss_ldap_endautomntent(void **private)
{
  ldap_automount_context_t **pContext = (ldap_automount_context_t **)private;

  debug ("==> _nss_ldap_endautomntent");

  _nss_ldap_enter ();
  _nss_ldap_am_context_free (pContext);
  /* workaround because Linux automounter spawns a lot of processes */
  _nss_ldap_close ();
  _nss_ldap_leave ();

  debug ("<== _nss_ldap_endautomntent");

  return NSS_SUCCESS;
}

NSS_STATUS _nss_ldap_getautomntbyname_r(void *private, const char *key,
					const char **canon_key, const char **value,
					char *buffer, size_t buflen, int *errnop)
{
  NSS_STATUS stat = NSS_NOTFOUND;
  ldap_automount_context_t *context = (ldap_automount_context_t *)private;
  ldap_args_t a;
  char **keyval[2];
  size_t i;

  if (context == NULL)
    return NSS_NOTFOUND;

  debug ("==> _nss_ldap_getautomntbyname_r");

  keyval[0] = (char **)canon_key;
  keyval[1] = (char **)value;

  for (i = 0; i < context->lac_dn_count; i++)
    {
      LA_INIT (a);
      LA_TYPE (a) = LA_TYPE_STRING;
      LA_STRING (a) = key;
      LA_BASE (a) = context->lac_dn_list[i];

      /* we do not acquire lock in this case */
      stat = _nss_ldap_getbyname (&a,
				  (void *)keyval,
				  buffer, buflen, errnop,
				  _nss_ldap_filt_getautomntbyname,
				  LM_AUTOMOUNT,
				  _nss_ldap_parse_automount);

      if (stat != NSS_NOTFOUND)
	{
	  break; /* on success or error other than not found */
	}
    }

  debug ("<== _nss_ldap_getautomntbyname_r");

  return stat;
}

#endif /* HAVE_NSS_H */