/*
 * Copyright (c) 1989 Jan-Simon Pendry
 * Copyright (c) 1989 Imperial College of Science, Technology & Medicine
 * Copyright (c) 1989 The Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Jan-Simon Pendry at Imperial College, London.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by the University of
 *      California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	%W% (Berkeley) %G%
 *
 * $Id: info_nis.c,v 5.2.2.1 1992/02/09 15:08:32 jsp beta $
 *
 */

/*
 * Get info from NIS map
 */

#include "am.h"

/* if the machine has nisplus maps, it also supports NIS */
#ifdef HAS_NISPLUS

#ifndef HAS_NISPLUS_MAPS
#define HAS_NISPLUS_MAPS
#endif

#endif

#ifndef HAS_NISPLUS_MAPS

#ifdef HAS_NIS_MAPS
#include <rpcsvc/yp_prot.h>
#include <rpcsvc/ypclnt.h>

/*
 * Figure out the nis domain name
 */
static int determine_nis_domain(P_void)
{
static	int nis_not_running = 0;

	char default_domain[YPMAXDOMAIN];

	if (nis_not_running)
		return ENOENT;

	if (getdomainname(default_domain, sizeof(default_domain)) < 0) {
		nis_not_running = 1;
		plog(XLOG_ERROR, "getdomainname: %m");
		return EIO;
	}

	if (!*default_domain) {
		nis_not_running = 1;
		plog(XLOG_WARNING, "NIS domain name is not set.  NIS ignored.");
		return ENOENT;
	}

	domain = strdup(default_domain);

	return 0;
}


#ifdef HAS_NIS_RELOAD
struct nis_callback_data {
	mnt_map *ncd_m;
	char *ncd_map;
	void (*ncd_fn)();
};

/*
 * Callback from yp_all
 */
static int callback(status, key, kl, val, vl, data)
int status;
char *key;
int kl;
char *val;
int vl;
struct nis_callback_data *data;
{
	if (status == YP_TRUE) {
		/*
		 * Add to list of maps
		 */
		char *kp = strnsave(key, kl);
		char *vp = strnsave(val, vl);
		(*data->ncd_fn)(data->ncd_m, kp, vp);

		/*
		 * We want more ...
		 */
		return FALSE;
	} else {
		/*
		 * NOMORE means end of map - otherwise log error
		 */
		if (status != YP_NOMORE) {
			/*
			 * Check what went wrong
			 */
			int e = ypprot_err(status);

#ifdef DEBUG
			plog(XLOG_ERROR, "yp enumeration of %s: %s, status=%d, e=%d",
					data->ncd_map, yperr_string(e), status, e);
#else
			plog(XLOG_ERROR, "yp enumeration of %s: %s", data->ncd_map, yperr_string(e));
#endif
		}

		return TRUE;
	}
}

#ifdef BROKEN_YP_ALL
static int yp_all_fixed P((char *, char *, struct ypall_callback *));
static int yp_all_fixed(indomain, inmap, incallback)
     char *indomain;
     char *inmap;
     struct ypall_callback *incallback;
{ int i, j;
  char *outkey, *outval;
  int outkeylen, outvallen;
  char *outkey_old;
  int outkeylen_old;

  i = yp_first(indomain, inmap, &outkey, &outkeylen, &outval, &outvallen);
  if (i) {
    plog(XLOG_ERROR, "yp_first() returned error: %s\n", yperr_string(i));
  }
  do {
    j = (incallback->foreach)(YP_TRUE, outkey, outkeylen, outval, outvallen,
			      incallback->data);
    if (j != FALSE)			/* terminate loop */
      break;
    outkey_old = outkey;
    outkeylen_old = outkeylen;
    i = yp_next(indomain, inmap, outkey_old, outkeylen_old,
		 &outkey, &outkeylen, &outval, &outvallen);
    
  } while (!i);
#ifdef DEBUG
  if (i) {
    dlog("yp_next() returned error: %s\n", yperr_string(i));
  }
#endif /* DEBUG */
  if (i == YPERR_NOMORE)
    return 0;
  return i;
}
#endif /* BROKEN_YP_ALL */

int nis_reload P((mnt_map *m, char *map, void (*fn)()));
int nis_reload(m, map, fn)
mnt_map *m;
char *map;
void (*fn)();
{
	struct ypall_callback cbinfo;
	int error;
	struct nis_callback_data data;

	if (!domain) {
		error = determine_nis_domain();
		if (error)
			return error;
	}

	data.ncd_m = m;
	data.ncd_map = map;
	data.ncd_fn = fn;
	cbinfo.data = (voidp) &data;
	cbinfo.foreach = callback;

#ifdef BROKEN_YP_ALL
	/*
	 * If you are using NIS and your yp_all function is "broken", use
	 * an alternate code which avoids a bug in yp_all().  The bug in
	 * yp_all() is that it does not close a TCP connection to ypserv,
	 * and this ypserv runs out of open filedescriptors, getting into an
	 * infinite loop, thus all YP clients enevtually unbind and hang
	 * too.
	 * 	-Erez Zadok <ezk@cs.columbia.edu>
	 * 	-James Tanis <jtt@cs.columbia.edu>
	 */

	error = yp_all_fixed(domain, map, &cbinfo);
#else
	error = yp_all(domain, map, &cbinfo);
#endif /* BROKEN_YP_ALL */

	if (error)
		plog(XLOG_ERROR, "error grabbing nis map of %s: %s", map, yperr_string(ypprot_err(error)));

	return error;
}
#endif /* HAS_NIS_RELOAD */

/*
 * Try to locate a key using NIS.
 */
int nis_search P((mnt_map *m, char *map, char *key, char **val, time_t *tp));
int nis_search(m, map, key, val, tp)
mnt_map *m;
char *map;
char *key;
char **val;
time_t *tp;
{
	int outlen;
	int res;
#if defined( __svr4__) && defined(sun)
	u_long order;
#else
	int order;
#endif /* defined( __svr4__) && defined(sun) */

	/*
	 * Make sure domain initialised
	 */
	if (!domain) {
		int error = determine_nis_domain();
		if (error)
			return error;
	}

	/*
	 * Check if map has changed
	 */
	if (yp_order(domain, map, &order))
		return EIO;
	if ((time_t) order > *tp) {
		*tp = (time_t) order;
		return -1;
	}

	/*
	 * Lookup key
	 */
	res = yp_match(domain, map, key, strlen(key), val, &outlen);

	/*
	 * Do something interesting with the return code
	 */
	switch (res) {
	case 0:
		return 0;

	case YPERR_KEY:
		return ENOENT;

	default:
		plog(XLOG_ERROR, "%s: %s", map, yperr_string(res));
		return EIO;
	}
}

int nis_init P((char *map, time_t *tp));
int nis_init(map, tp)
char *map;
time_t *tp;
{
#if defined( __svr4__) && defined(sun)
	u_long order;
#else
	int order;
#endif /* defined( __svr4__) && defined(sun) */

	if (!domain) {
		int error = determine_nis_domain();
		if (error)
			return error;
	}

	/*
	 * To see if the map exists, try to find
	 * a master for it.
	 */
	if (yp_order(domain, map, &order))
		return ENOENT;
	*tp = (time_t) order;
#ifdef DEBUG
	dlog("NIS master for %s@%s has order %d", map, domain, order);
#endif
	return 0;
}
#endif /* HAS_NIS_MAPS */

#endif /* !HAS_NISPLUS */
