/* ----------------------------------------------------------------------- *

 *   

 *  master.c - master map utility routines.

 *

 *   Copyright 2006 Ian Kent <raven@themaw.net>

 *

 *   This program is free software; you can redistribute it and/or modify

 *   it under the terms of the GNU General Public License as published by

 *   the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139,

 *   USA; either version 2 of the License, or (at your option) any later

 *   version.

 *   

 *   This program 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 General Public License for more details.

 *

 * ----------------------------------------------------------------------- */

#include <stdlib.h>

#include <string.h>

#include <memory.h>

#include <limits.h>

#include <signal.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <ctype.h>

#include "automount.h"

/* The root of the map entry tree */

struct master *master_list = NULL;

extern const char *global_options;

extern long global_negative_timeout;

/* Attribute to create a joinable thread */

extern pthread_attr_t th_attr;

extern struct startup_cond suc;

static struct map_source *

__master_find_map_source(struct master_mapent *,

			 const char *, const char *, int, const char **);

static pthread_mutex_t master_mutex = PTHREAD_MUTEX_INITIALIZER;

static pthread_mutex_t instance_mutex = PTHREAD_MUTEX_INITIALIZER;

void master_mutex_lock(void)

{

	int status = pthread_mutex_lock(&master_mutex);

	if (status)

		fatal(status);

}

void master_mutex_unlock(void)

{

	int status = pthread_mutex_unlock(&master_mutex);

	if (status)

		fatal(status);

}

void master_mutex_lock_cleanup(void *arg)

{

	master_mutex_unlock();

	return;

}

int master_add_autofs_point(struct master_mapent *entry, unsigned logopt,

			    unsigned nobind, unsigned ghost, int submount)

{

	struct autofs_point *ap;

	int status;

	ap = malloc(sizeof(struct autofs_point));

	if (!ap)

		return 0;

	ap->state = ST_INIT;

	ap->state_pipe[0] = -1;

	ap->state_pipe[1] = -1;

	ap->logpri_fifo = -1;

	ap->path = strdup(entry->path);

	if (!ap->path) {

		free(ap);

		return 0;

	}

	ap->pref = NULL;

	ap->entry = entry;

	ap->exp_thread = 0;

	ap->readmap_thread = 0;

	/*

	 * Program command line option overrides config.

	 * We can't use 0 negative timeout so use default.

	 */

	if (global_negative_timeout <= 0)

		ap->negative_timeout = defaults_get_negative_timeout();

	else

		ap->negative_timeout = global_negative_timeout;

	ap->exp_timeout = defaults_get_timeout();

	ap->exp_runfreq = 0;

	ap->flags = MOUNT_FLAG_IGNORE;

	if (ghost)

		ap->flags |= MOUNT_FLAG_GHOST;

	if (nobind)

		ap->flags |= MOUNT_FLAG_NOBIND;

	if (ap->path[1] == '-')

		ap->type = LKP_DIRECT;

	else

		ap->type = LKP_INDIRECT;

	ap->logopt = logopt;

	ap->parent = NULL;

	ap->thid = 0;

	ap->submnt_count = 0;

	ap->submount = submount;

	INIT_LIST_HEAD(&ap->mounts);

	INIT_LIST_HEAD(&ap->submounts);

	INIT_LIST_HEAD(&ap->amdmounts);

	ap->shutdown = 0;

	status = pthread_mutex_init(&ap->mounts_mutex, NULL);

	if (status) {

		free(ap->path);

		free(ap);

		return 0;

	}

	ap->mode = 0;

	entry->ap = ap;

	return 1;

}

void master_free_autofs_point(struct autofs_point *ap)

{

	struct list_head *p, *head;

	int status;

	if (!ap)

		return;

	mounts_mutex_lock(ap);

	head = &ap->amdmounts;

	p = head->next;

	while (p != head) {

		struct amd_entry *entry = list_entry(p, struct amd_entry, entries);

		p = p->next;

		if (!list_empty(&entry->ext_mount))

			ext_mount_remove(&entry->ext_mount, entry->fs);

		if (!list_empty(&entry->entries))

			list_del(&entry->entries);

		free_amd_entry(entry);

	}

	mounts_mutex_unlock(ap);

	status = pthread_mutex_destroy(&ap->mounts_mutex);

	if (status)

		fatal(status);

	if (ap->pref)

		free(ap->pref);

	free(ap->path);

	free(ap);

}

struct map_source *

master_add_map_source(struct master_mapent *entry,

		      char *type, char *format, time_t age,

		      int argc, const char **argv)

{

	struct map_source *source;

	char *ntype, *nformat;

	const char **tmpargv;

	source = malloc(sizeof(struct map_source));

	if (!source)

		return NULL;

	memset(source, 0, sizeof(struct map_source));

	source->ref = 1;

	if (type) {

		ntype = strdup(type);

		if (!ntype) {

			master_free_map_source(source, 0);

			return NULL;

		}

		source->type = ntype;

	}

	if (format) {

		nformat = strdup(format);

		if (!nformat) {

			master_free_map_source(source, 0);

			return NULL;

		}

		source->format = nformat;

		if (!strcmp(nformat, "amd"))

			source->flags |= MAP_FLAG_FORMAT_AMD;

	}

	source->age = age;

	source->stale = 1;

	tmpargv = copy_argv(argc, argv);

	if (!tmpargv) {

		master_free_map_source(source, 0);

		return NULL;

	}

	source->argc = argc;

	source->argv = tmpargv;

	if (source->argv[0])

		source->name = strdup(source->argv[0]);

	master_source_writelock(entry);

	if (!entry->maps) {

		source->mc = cache_init(entry->ap, source);

		if (!source->mc) {

			master_free_map_source(source, 0);

			master_source_unlock(entry);

			return NULL;

		}

		entry->maps = source;

	} else {

		struct map_source *this, *last, *next;

		/* Typically there only a few map sources */

		this = __master_find_map_source(entry, type, format, argc, tmpargv);

		if (this) {

			debug(entry->ap->logopt,

			      "map source used without taking reference");

			this->age = age;

			master_free_map_source(source, 0);

			master_source_unlock(entry);

			return this;

		}

		source->mc = cache_init(entry->ap, source);

		if (!source->mc) {

			master_free_map_source(source, 0);

			master_source_unlock(entry);

			return NULL;

		}

		last = NULL;

		next = entry->maps;

		while (next) {

			last = next;

			next = next->next;

		}

		if (last)

			last->next = source;

		else

			entry->maps = source;

	}

	master_source_unlock(entry);

	return source;

}

static int compare_source_type_and_format(struct map_source *map, const char *type, const char *format)

{

	int res = 0;

	if (type) {

		if (!map->type)

			goto done;

		if (strcmp(map->type, type))

			goto done;

	} else if (map->type)

		goto done;

	if (format) {

		if (!map->format)

			goto done;

		if (strcmp(map->format, format))

			goto done;

	} else if (map->format)

		goto done;

	res = 1;

done:

	return res;

}

static struct map_source *

__master_find_map_source(struct master_mapent *entry,

			 const char *type, const char *format,

			 int argc, const char **argv)

{

	struct map_source *map;

	struct map_source *source = NULL;

	int res;

	map = entry->maps;

	while (map) {

		res = compare_source_type_and_format(map, type, format);

		if (!res)

			goto next;

		res = compare_argv(map->argc, map->argv, argc, argv);

		if (!res)

			goto next;

		source = map;

		break;

next:

		map = map->next;

	}

	return source;

}

struct map_source *master_find_map_source(struct master_mapent *entry,

				const char *type, const char *format,

				int argc, const char **argv)

{

	struct map_source *source = NULL;

	master_source_readlock(entry);

	source = __master_find_map_source(entry, type, format, argc, argv);

	master_source_unlock(entry);

	return source;

}

struct map_source *

master_get_map_source(struct master_mapent *entry,

		      const char *type, const char *format,

		      int argc, const char **argv)

{

	struct map_source *source = NULL;

	master_source_readlock(entry);

	source = __master_find_map_source(entry, type, format, argc, argv);

	if (source)

		source->ref++;

	master_source_unlock(entry);

	return source;

}

static void __master_free_map_source(struct map_source *source, unsigned int free_cache)

{

	/* instance map sources are not ref counted */

	if (source->ref && --source->ref)

		return;

	if (source->type)

		free(source->type);

	if (source->format)

		free(source->format);

	if (source->name)

		free(source->name);

	if (free_cache && source->mc)

		cache_release(source);

	if (source->lookup) {

		struct map_source *instance;

		instance = source->instance;

		while (instance) {

			if (instance->lookup)

				close_lookup(instance->lookup);

			instance = instance->next;

		}

		close_lookup(source->lookup);

	}

	if (source->argv)

		free_argv(source->argc, source->argv);

	if (source->instance) {

		struct map_source *instance, *next;

		instance = source->instance;

		while (instance) {

			next = instance->next;

			__master_free_map_source(instance, 0);

			instance = next;

		}

	}

	free(source);

	return;

}

void master_free_map_source(struct map_source *source, unsigned int free_cache)

{

	int status;

	status = pthread_mutex_lock(&instance_mutex);

	if (status)

		fatal(status);

	__master_free_map_source(source, free_cache);

	status = pthread_mutex_unlock(&instance_mutex);

	if (status)

		fatal(status);

}

struct map_source *master_find_source_instance(struct map_source *source, const char *type, const char *format, int argc, const char **argv)

{

	struct map_source *map;

	struct map_source *instance = NULL;

	int status, res;

	status = pthread_mutex_lock(&instance_mutex);

	if (status)

		fatal(status);

	map = source->instance;

	while (map) {

		res = compare_source_type_and_format(map, type, format);

		if (!res)

			goto next;

		if (!argv) {

			instance = map;

			break;

		}

		res = compare_argv(map->argc, map->argv, argc, argv);

		if (!res)

			goto next;

		instance = map;

		break;

next:

		map = map->next;

	}

	status = pthread_mutex_unlock(&instance_mutex);

	if (status)

		fatal(status);

	return instance;

}

struct map_source *

master_add_source_instance(struct map_source *source, const char *type, const char *format, time_t age, int argc, const char **argv)

{

	struct map_source *instance;

	struct map_source *new;

	char *ntype, *nformat;

	const char **tmpargv;

	int status;

	instance = master_find_source_instance(source, type, format, argc, argv);

	if (instance)

		return instance;

	new = malloc(sizeof(struct map_source));

	if (!new)

		return NULL;

	memset(new, 0, sizeof(struct map_source));

	if (type) {

		ntype = strdup(type);

		if (!ntype) {

			master_free_map_source(new, 0);

			return NULL;

		}

		new->type = ntype;

	}

	if (format) {

		nformat = strdup(format);

		if (!nformat) {

			master_free_map_source(new, 0);

			return NULL;

		}

		new->format = nformat;

		if (!strcmp(nformat, "amd"))

			new->flags |= MAP_FLAG_FORMAT_AMD;

	}

	new->age = age;

	new->master_line = 0;

	new->mc = source->mc;

	new->exp_timeout = source->exp_timeout;

	new->stale = 1;

	tmpargv = copy_argv(argc, argv);

	if (!tmpargv) {

		master_free_map_source(new, 0);

		return NULL;

	}

	new->argc = argc;

	new->argv = tmpargv;

	if (source->name)

		new->name = strdup(source->name);

	status = pthread_mutex_lock(&instance_mutex);

	if (status)

		fatal(status);

	if (!source->instance)

		source->instance = new;

	else {

		/*

		 * We know there's no other instance of this

		 * type so just add to head of list

		 */

		new->next = source->instance;

		source->instance = new;

	}

	status = pthread_mutex_unlock(&instance_mutex);

	if (status)

		fatal(status);

	return new;

}

int check_stale_instances(struct map_source *source)

{

	struct map_source *map;

	if (!source)

		return 0;

	map = source->instance;

	while (map) {

		if (map->stale)

			return 1;

		if (check_stale_instances(map))

			return 1;

		map = map->next;

	}

	return 0;

}

void clear_stale_instances(struct map_source *source)

{

	struct map_source *map;

	if (!source)

		return;

	map = source->instance;

	while (map) {

		clear_stale_instances(map);

		if (map->stale)

			map->stale = 0;

		map = map->next;

	}

	return;

}

void send_map_update_request(struct autofs_point *ap)

{

	struct map_source *map;

	int status, need_update = 0;

	status = pthread_mutex_lock(&instance_mutex);

	if (status)

		fatal(status);

	map = ap->entry->maps;

	while (map) {

		if (check_stale_instances(map))

			map->stale = 1;

		if (map->stale) {

			need_update = 1;

			break;

		}

		map = map->next;

	}

	status = pthread_mutex_unlock(&instance_mutex);

	if (status)

		fatal(status);

	if (!need_update)

		return;

	st_add_task(ap, ST_READMAP);

	return;

}

void master_source_writelock(struct master_mapent *entry)

{

	int status;

	status = pthread_rwlock_wrlock(&entry->source_lock);

	if (status) {

		logmsg("master_mapent source write lock failed");

		fatal(status);

	}

	return;

}

void master_source_readlock(struct master_mapent *entry)

{

	int retries = 25;

	int status;

	while (retries--) {

		status = pthread_rwlock_rdlock(&entry->source_lock);

		if (status != EAGAIN && status != EBUSY)

			break;

		else {

                	struct timespec t = { 0, 200000000 };

	                struct timespec r;

			if (status == EAGAIN)

				logmsg("master_mapent source too many readers");

			else

				logmsg("master_mapent source write lock held");

                	while (nanosleep(&t, &r) == -1 && errno == EINTR)

                        	memcpy(&t, &r, sizeof(struct timespec));

		}

	}

	if (status) {

		logmsg("master_mapent source read lock failed");

		fatal(status);

	}

	return;

}

void master_source_unlock(struct master_mapent *entry)

{

	int status;

	status = pthread_rwlock_unlock(&entry->source_lock);

	if (status) {

		logmsg("master_mapent source unlock failed");

		fatal(status);

	}

	return;

}

void master_source_lock_cleanup(void *arg)

{

	struct master_mapent *entry = (struct master_mapent *) arg;

	master_source_unlock(entry);

	return;

}

void master_source_current_wait(struct master_mapent *entry)

{

	int status;

	status = pthread_mutex_lock(&entry->current_mutex);

	if (status) {

		logmsg("entry current source lock failed");

		fatal(status);

	}

	while (entry->current != NULL) {

		status = pthread_cond_wait(

				&entry->current_cond, &entry->current_mutex);

		if (status) {

			logmsg("entry current source condition wait failed");

			fatal(status);

		}

	}

	return;

}

void master_source_current_signal(struct master_mapent *entry)

{

	int status;

	status = pthread_cond_signal(&entry->current_cond);

	if (status) {

		logmsg("entry current source condition signal failed");

		fatal(status);

	}

	status = pthread_mutex_unlock(&entry->current_mutex);

	if (status) {

		logmsg("entry current source unlock failed");

		fatal(status);

	}

	return;

}

struct master_mapent *master_find_mapent(struct master *master, const char *path)

{

	struct list_head *head, *p;

	head = &master->mounts;

	list_for_each(p, head) {

		struct master_mapent *entry;

		entry = list_entry(p, struct master_mapent, list);

		if (!strcmp(entry->path, path))

			return entry;

	}

	return NULL;

}

unsigned int master_partial_match_mapent(struct master *master, const char *path)

{

	struct list_head *head, *p;

	size_t path_len = strlen(path);

	int ret = 0;

	head = &master->mounts;

	list_for_each(p, head) {

		struct master_mapent *entry;

		size_t entry_len;

		size_t cmp_len;

		entry = list_entry(p, struct master_mapent, list);

		entry_len = strlen(entry->path);

		cmp_len = min(entry_len, path_len);

		if (!strncmp(entry->path, path, cmp_len)) {

			/* paths are equal, matching master map entry ? */

			if (entry_len == path_len) {

				if (entry->maps &&

				    entry->maps->flags & MAP_FLAG_FORMAT_AMD)

					ret = 1;

				else

					ret = -1;

				break;

			}

			/* amd mount conflicts with entry mount */

			if (entry_len > path_len &&

			    *(entry->path + path_len) == '/') {

				ret = -1;

				break;

			}

			/* entry mount conflicts with amd mount */

			if (entry_len < path_len &&

			    *(path + entry_len) == '/') {

				ret = -1;

				break;

			}

		}

	}

	return ret;

}

struct autofs_point *__master_find_submount(struct autofs_point *ap, const char *path)

{

	struct list_head *head, *p;

	head = &ap->submounts;

	list_for_each(p, head) {

		struct autofs_point *submount;

		submount = list_entry(p, struct autofs_point, mounts);

		if (!strcmp(submount->path, path))

			return submount;

	}

	return NULL;

}

struct autofs_point *master_find_submount(struct autofs_point *ap, const char *path)

{

	struct autofs_point *submount;

	mounts_mutex_lock(ap);

	submount = __master_find_submount(ap, path);

	mounts_mutex_unlock(ap);

	return submount;

}

struct amd_entry *__master_find_amdmount(struct autofs_point *ap, const char *path)

{

	struct list_head *head, *p;

	head = &ap->amdmounts;

	list_for_each(p, head) {

		struct amd_entry *entry;

		entry = list_entry(p, struct amd_entry, entries);

		if (!strcmp(entry->path, path))

			return entry;

	}

	return NULL;

}

struct amd_entry *master_find_amdmount(struct autofs_point *ap, const char *path)

{

	struct amd_entry *entry;

	mounts_mutex_lock(ap);

	entry = __master_find_amdmount(ap, path);

	mounts_mutex_unlock(ap);

	return entry;

}

struct master_mapent *master_new_mapent(struct master *master, const char *path, time_t age)

{

	struct master_mapent *entry;

	int status;

	char *tmp;

	entry = malloc(sizeof(struct master_mapent));

	if (!entry)

		return NULL;

	memset(entry, 0, sizeof(struct master_mapent));

	tmp = strdup(path);

	if (!tmp) {

		free(entry);

		return NULL;

	}

	entry->path = tmp;

	entry->thid = 0;

	entry->age = age;

	entry->master = master;

	entry->current = NULL;

	entry->maps = NULL;

	entry->ap = NULL;

	status = pthread_rwlock_init(&entry->source_lock, NULL);

	if (status)

		fatal(status);

	status = pthread_mutex_init(&entry->current_mutex, NULL);

	if (status)

		fatal(status);

	status = pthread_cond_init(&entry->current_cond, NULL);

	if (status)

		fatal(status);

	INIT_LIST_HEAD(&entry->list);

	return entry;

}

void master_add_mapent(struct master *master, struct master_mapent *entry)

{

	list_add_tail(&entry->list, &master->mounts);

	return;

}

void master_remove_mapent(struct master_mapent *entry)

{

	struct master *master = entry->master;

	if (entry->ap->submount)

		return;

	if (!list_empty(&entry->list)) {

		list_del_init(&entry->list);

		list_add(&entry->join, &master->completed);

	}

	return;

}