/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2015 Gary Mills
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * DESCRIPTION: Contains utilities relating to TTL calculation.
 */
#include <unistd.h>
#include <syslog.h>
#include <errno.h>
#include <strings.h>
#include <ndbm.h>
#include "ypsym.h"
#include "ypdefs.h"
#include "shim.h"
#include "yptol.h"
#include "../ldap_util.h"

/*
 * Constants used in time calculations
 */
#define	MILLION 1000000

/*
 * Decs
 */
suc_code is_greater_timeval(struct timeval *, struct timeval *);
suc_code add_to_timeval(struct timeval *, int);

/*
 * FUNCTION:	has_entry_expired()
 *
 * DESCRIPTION:	Determines if an individual entry has expired.
 *
 * INPUTS:	Map control structure for an open map
 *		Entry key
 *
 * OUTPUTS:	TRUE =  Entry has expired or cannot be found this will cause
 *			missing entries to be pulled out of the DIT.
 *		FALSE = Entry has not expired
 *
 */
bool_t
has_entry_expired(map_ctrl *map, datum *key)
{
	datum ttl;
	struct timeval	now;
	struct timeval	old_time;
	char	*key_name;
	char *myself = "has_entry_expired";

	if ((map == NULL) || (map->ttl == NULL))
		return (FALSE);

	/* Get expiry time entry for key */
	ttl = dbm_fetch(map->ttl, *key);

	if (NULL == ttl.dptr) {
		/*
		 * If we failed to get a map expiry key, which must always be
		 * present, then something is seriously wrong. Try to recreate
		 * the map.
		 */
		if ((key->dsize == strlen(MAP_EXPIRY_KEY)) &&
			(0 == strncmp(key->dptr, MAP_EXPIRY_KEY, key->dsize))) {
			logmsg(MSG_NOTIMECHECK, LOG_ERR, "Cannot find %s TTL "
				"for map %s. Will attempt to recreate map",
				MAP_EXPIRY_KEY, map->map_name);
			return (TRUE);
		}

		/*
		 * Not a problem just no TTL entry for this entry. Maybe it has
		 * not yet been downloaded. Maybe it will be handled by a
		 * service other than NIS. Check if the entire map has expired.
		 * This prevents repeated LDAP reads when requests are made for
		 * nonexistant entries.
		 */
		if (has_map_expired(map)) {
			/* Kick of a map update */
			update_map_if_required(map, FALSE);
		}

		/* Don't update the entry */
		return (FALSE);
	}

	if (ttl.dsize != sizeof (struct timeval)) {
		/*
		 * Need to malloc some memory before can syslog the key name
		 * but this may fail. Solution log a simple message first THEn
		 * a more detailed one if it works.
		 */
		logmsg(MSG_NOTIMECHECK, LOG_ERR,
			"Invalid TTL key in map %s. error %d",
					map->map_name, dbm_error(map->ttl));

		/* Log the key name */
		key_name = (char *)am(myself, key->dsize + 1);
		if (NULL == key_name) {
			logmsg(MSG_NOMEM, LOG_ERR,
					"Could not alloc memory for keyname");
		} else {
			strncpy(key_name, key->dptr, key->dsize);
			key_name[key->dsize] = '\0';
			logmsg(MSG_NOTIMECHECK, LOG_ERR,
						"Key name was %s", key_name);
			sfree(key_name);
		}
		/* Update it Anyway */
		return (TRUE);
	}

	/* Get current time */
	gettimeofday(&now, NULL);

	/*
	 * Because dptr may not be int aligned need to build an int
	 * out of what it points to or will get a bus error
	 */
	bcopy(ttl.dptr, &old_time, sizeof (struct timeval));

	return (is_greater_timeval(&now, &old_time));
}

/*
 * FUNCTION:	has_map_expired()
 *
 * DESCRIPTION:	Determines if an entire map has expire
 *
 * INPUTS:	Map control structure for an open map
 *
 * OUTPUTS:	TRUE = Map has expired
 *		FALSE  Map has not expired
 *
 */
bool_t
has_map_expired(map_ctrl *map)
{
	datum key;

	/* Set up datum with magic expiry key */
	key.dsize = strlen(MAP_EXPIRY_KEY);
	key.dptr = MAP_EXPIRY_KEY;

	/* Call has_entry_expired() with magic map expiry key */
	return (has_entry_expired(map, &key));
}

/*
 * FUNCTION:	update_entry_ttl()
 *
 * DESCRIPTION:	Updates the TTL for one map entry
 *
 * INPUTS:	Map control structure for an open map
 *		Entry key
 *		Flag indication if TTL should be max, min or random
 *
 * OUTPUTS:	SUCCESS = TTL updated
 *		FAILURE = TTL not updated
 *
 */

suc_code
update_entry_ttl(map_ctrl *map, datum *key, TTL_TYPE type)
{
	datum expire;
	struct timeval	now;
	int	ttl;

	/* Get current time */
	gettimeofday(&now, NULL);

	/* Get TTL from mapping file */
	ttl = get_ttl_value(map, type);

	if (FAILURE == add_to_timeval(&now, ttl))
		return (FAILURE);

	/* Convert time into a datum */
	expire.dsize = sizeof (struct timeval);
	expire.dptr = (char *)&now;

	/* Set expiry time entry for key */
	errno = 0;
	if (0 > dbm_store(map->ttl, *key, expire, DBM_REPLACE)) {
		logmsg(MSG_NOTIMECHECK, LOG_ERR, "Could not write TTL entry "
						"(errno=%d)", errno);
		return (FAILURE);
	}

	return (SUCCESS);
}

/*
 * FUNCTION:	update_map_ttl()
 *
 * DESCRIPTION:	Updates the TTL for entire map. This can be called either with
 *		the map open (map_ctrl DBM pointer set up) or the map closed
 *		(map_ctrl DBM pointers not set). The latter case will occur
 *		when we have just created a new map.
 *
 *		This function must open the TTL map but, in either case, must
 *		return with the map_ctrl in it's original state.
 *
 * INPUTS:	Map control structure for an open map
 *
 * OUTPUTS:	SUCCESS = TTL updated
 *		FAILURE = TTL not updated
 *
 */
suc_code
update_map_ttl(map_ctrl *map)
{
	datum key;
	bool_t map_was_open = TRUE;
	suc_code ret;

	/* Set up datum with magic expiry key */
	key.dsize = strlen(MAP_EXPIRY_KEY);
	key.dptr = MAP_EXPIRY_KEY;

	/* If TTL not open open it */
	if (NULL == map->ttl) {
		map->ttl = dbm_open(map->ttl_path, O_RDWR, 0644);
		if (NULL == map->ttl)
			return (FAILURE);
		map_was_open = FALSE;
	}

	/* Call update_entry_ttl() with magic map expiry key */
	ret = update_entry_ttl(map, &key, TTL_MIN);

	/* If we had to open TTL file close it */
	if (!map_was_open) {
		dbm_close(map->ttl);
		map->ttl_path = NULL;
	}

	return (ret);
}

/*
 * FUNCTION:	add_to_timeval()
 *
 * DESCRIPTION:	Adds an int to a timeval
 *
 * NOTE :	Seems strange that there is not a library function to do this
 *		if one exists then this function can be removed.
 *
 * NOTE :	Does not handle UNIX clock wrap round but this is a much bigger
 *		problem.
 *
 * INPUTS:	Time value to add to
 *		Time value to add in seconds
 *
 * OUTPUTS:	SUCCESS = Addition successful
 *		FAILURE = Addition failed (probably wrapped)
 *
 */
suc_code
add_to_timeval(struct timeval *t1, int t2)
{
	struct timeval oldval;

	oldval.tv_sec = t1->tv_sec;

	/* Add seconds part */
	t1->tv_sec += t2;

	/* Check for clock wrap */
	if (!(t1->tv_sec >= oldval.tv_sec)) {
		logmsg(MSG_NOTIMECHECK, LOG_ERR,
			"Wrap when adding %d to %d", t2, oldval.tv_sec);
		return (FAILURE);
	}

	return (SUCCESS);
}

/*
 * FUNCTION:	is_greater_timeval()
 *
 * DESCRIPTION:	Compares two timevals
 *
 * NOTE :	Seems strange that there is not a library function to do this
 *		if one exists then this function can be removed.
 *
 * INPUTS:	First time value
 *		Time value to compare it with
 *
 * OUTPUTS:	TRUE t1 > t2
 *		FALSE t1 <= t2
 *
 */
suc_code
is_greater_timeval(struct timeval *t1, struct timeval *t2)
{
	if (t1->tv_sec > t2->tv_sec)
		return (TRUE);

	if (t1->tv_sec == t2->tv_sec) {
		if (t1->tv_usec > t2->tv_usec)
			return (TRUE);
		else
			return (FALSE);
	}

	return (FALSE);
}