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

 *   

 *  lookup_multi.c - module for Linux automount to seek multiple lookup

 *                   methods in succession

 *

 *   Copyright 1999 Transmeta Corporation - All Rights Reserved

 *

 *   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; incorporated herein by reference.

 *

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

#include <ctype.h>

#include <limits.h>

#include <malloc.h>

#include <stdio.h>

#include <string.h>

#include <sys/stat.h>

#define MODULE_LOOKUP

#include "automount.h"

#include "nsswitch.h"

#define MAX_MAP_TYPE_STRING	20

#define MODPREFIX "lookup(multi): "

struct module_info {

	int argc;

	const char **argv;

	struct lookup_mod *mod;

};

struct lookup_context {

	int n;

	const char **argl;

	struct module_info *m;

};

int lookup_version = AUTOFS_LOOKUP_VERSION;	/* Required by protocol */

static int free_multi_context(struct lookup_context *);

static struct lookup_context *alloc_context(const char *format,

					    int argc, const char *const *argv)

{

	struct lookup_context *ctxt;

	char buf[MAX_ERR_BUF];

	char **args;

	int i, an;

	char *estr;

	ctxt = malloc(sizeof(struct lookup_context));

	if (!ctxt)

		goto nomem;

	memset(ctxt, 0, sizeof(struct lookup_context));

	if (argc < 1) {

		logerr(MODPREFIX "No map list");

		goto error_out;

	}

	ctxt->n = 1;				/* Always at least one map */

	for (i = 0; i < argc; i++) {

		if (!strcmp(argv[i], "--"))	/* -- separates maps */

			ctxt->n++;

	}

	if (!(ctxt->m = malloc(ctxt->n * sizeof(struct module_info))) ||

	    !(ctxt->argl = malloc((argc + 1) * sizeof(const char *))))

		goto nomem;

	memset(ctxt->m, 0, ctxt->n * sizeof(struct module_info));

	memcpy(ctxt->argl, argv, (argc + 1) * sizeof(const char *));

	args = NULL;

	for (i = an = 0; ctxt->argl[an]; an++) {

		if (ctxt->m[i].argc == 0)

			args = (char **) &ctxt->argl[an];

		if (strcmp(ctxt->argl[an], "--"))

			ctxt->m[i].argc++;

		else {

			ctxt->argl[an] = NULL;

			if (!args) {

				logerr(MODPREFIX "error assigning map args");

				goto error_out;

			}

			ctxt->m[i].argv = copy_argv(ctxt->m[i].argc,

						    (const char **) args);

			if (!ctxt->m[i].argv)

				goto nomem;

			args = NULL;

			i++;

		}

	}

	/* catch the last one */

	if (args) {

		ctxt->m[i].argv = copy_argv(ctxt->m[i].argc, (const char **) args);

		if (!ctxt->m[i].argv)

			goto nomem;

	}

	return ctxt;

nomem:

	estr = strerror_r(errno, buf, MAX_ERR_BUF);

	logerr(MODPREFIX "error: %s", estr);

error_out:

	free_multi_context(ctxt);

	free(ctxt);

	return NULL;

}

static int free_multi_context(struct lookup_context *ctxt)

{

	int rv;

	if (!ctxt)

		return 0;

	rv = 0;

	if (ctxt->m) {

		int i;

		for (i = 0; i < ctxt->n; i++) {

			if (ctxt->m[i].mod)

				rv = rv || close_lookup(ctxt->m[i].mod);

			if (ctxt->m[i].argv)

				free_argv(ctxt->m[i].argc, ctxt->m[i].argv);

		}

		free(ctxt->m);

	}

	if (ctxt->argl)

		free(ctxt->argl);

	return rv;

}

static struct lookup_context *update_multi_context(struct lookup_context *ctxt,

						   struct lookup_context *new)

{

	int i;

	for (i = 0; i < new->n && i < ctxt->n; i++) {

		if (new->m[i].mod)

			continue;

		if (!ctxt->m[i].mod)

			continue;

		/* reinit or open failed, use old one, questionable but

		 * we need to do something.

		 */

		new->m[i].mod = ctxt->m[i].mod;

		ctxt->m[i].mod = NULL;

		new->m[i].argc = ctxt->m[i].argc;

		new->m[i].argv = ctxt->m[i].argv;

		ctxt->m[i].argv = NULL;

	}

	return new;

}

static struct lookup_mod *nss_open_lookup(const char *format, int argc, const char **argv)

{

	struct list_head nsslist;

	struct list_head *head, *p;

	struct lookup_mod *mod;

	char buf[MAX_ERR_BUF], *estr;

	if (!argv || !argv[0])

		return NULL;

	if (*argv[0] == '/') {

		open_lookup("file", MODPREFIX, format, argc, argv, &mod);

		return mod;

	}

	if (!strncmp(argv[0], "file", 4) ||

	    !strncmp(argv[0], "yp", 2) ||

	    !strncmp(argv[0], "nisplus", 7) ||

	    !strncmp(argv[0], "nis", 3) ||

	    !strncmp(argv[0], "ldaps", 5) ||

	    !strncmp(argv[0], "ldap", 4) ||

	    !strncmp(argv[0], "sss", 3)) {

		char type[MAX_MAP_TYPE_STRING];

		char *fmt;

		strcpy(type, argv[0]);

		fmt = strchr(type, ',');

		if (!fmt)

			fmt = (char *) format;

		else {

			*fmt = '\0';

			fmt++;

		}

		open_lookup(argv[0], MODPREFIX, fmt, argc - 1, argv + 1, &mod);

		return mod;

	}

	INIT_LIST_HEAD(&nsslist);

	if (nsswitch_parse(&nsslist)) {

		if (!list_empty(&nsslist))

			free_sources(&nsslist);

		logerr("can't to read name service switch config.");

		return NULL;

	}

	head = &nsslist;

	list_for_each(p, head) {

		struct nss_source *this;

		int status;

		int ret;

		this = list_entry(p, struct nss_source, list);

		if (!strcmp(this->source, "files")) {

			char src_file[] = "file";

			char src_prog[] = "program";

			struct stat st;

			char *type, *path, *save_argv0;

			path = malloc(strlen(AUTOFS_MAP_DIR) + strlen(argv[0]) + 2);

			if (!path) {

				estr = strerror_r(errno, buf, MAX_ERR_BUF);

				logerr(MODPREFIX "error: %s", estr);

				free_sources(&nsslist);

				return NULL;

			}

			strcpy(path, AUTOFS_MAP_DIR);

			strcat(path, "/");

			strcat(path, argv[0]);

			if (stat(path, &st) == -1 || !S_ISREG(st.st_mode)) {

				free(path);

				continue;

			}

			if (st.st_mode & __S_IEXEC)

				type = src_prog;

			else

				type = src_file;

			save_argv0 = (char *) argv[0];

			argv[0] = path;

			status = open_lookup(type, MODPREFIX,

					     format, argc, argv, &mod);

			if (status == NSS_STATUS_SUCCESS) {

				free_sources(&nsslist);

				free(save_argv0);

				return mod;

			}

			argv[0] = save_argv0;

			free(path);

			ret = check_nss_result(this, status);

			if (ret >= 0)

				break;

		}

		status = open_lookup(this->source, MODPREFIX,

				     format, argc, argv, &mod);

		if (status == NSS_STATUS_SUCCESS) {

			free_sources(&nsslist);

			return mod;

		}

		ret = check_nss_result(this, status);

		if (ret >= 0)

			break;

	}

	free_sources(&nsslist);

	return NULL;

}

int lookup_init(const char *my_mapfmt,

		int argc, const char *const *argv, void **context)

{

	struct lookup_context *ctxt;

	int i;

	*context = NULL;

	ctxt = alloc_context(my_mapfmt, argc, argv);

	if (!ctxt)

		return 1;

	for (i = 0; i < ctxt->n; i++) {

		ctxt->m[i].mod = nss_open_lookup(my_mapfmt,

				 ctxt->m[i].argc, ctxt->m[i].argv);

		if (!ctxt->m[i].mod) {

			logerr(MODPREFIX "error opening module");

			free_multi_context(ctxt);

			free(ctxt);

			return 1;

		}

	}

	*context = ctxt;

	return 0;

}

int lookup_reinit(const char *my_mapfmt,

		  int argc, const char *const *argv, void **context)

{

	struct lookup_context *ctxt = (struct lookup_context *) *context;

	struct list_head nsslist;

	struct list_head *head, *p;

	struct lookup_context *new;

	char buf[MAX_ERR_BUF], *estr;

	int i, ret = 0;

	int status;

	new = alloc_context(my_mapfmt, argc, argv);

	if (!new)

		return 1;

	for (i = 0; i < new->n; i++) {

		if (i >= ctxt->n) {

			new->m[i].mod = nss_open_lookup(my_mapfmt,

							new->m[i].argc,

							new->m[i].argv);

			if (!new->m[i].mod) {

				logerr(MODPREFIX "error opening module");

				/* TODO: check */

				ret = 1;

				goto out;

			}

			continue;

		}

		if (*new->m[i].argv[0] == '/') {

			if (strcmp(new->m[i].argv[0], ctxt->m[i].argv[0]))

				open_lookup("file", MODPREFIX,

					     my_mapfmt,

					     new->m[i].argc,

					     new->m[i].argv,

					     &new->m[i].mod);

			else {

				new->m[i].mod = ctxt->m[i].mod;

				if (reinit_lookup(new->m[i].mod, "file",

					      MODPREFIX, my_mapfmt,

					      new->m[i].argc, new->m[i].argv))

					new->m[i].mod = NULL;

				else

					ctxt->m[i].mod = NULL;

			}

			continue;

		}

		if (!strncmp(new->m[i].argv[0], "file", 4) ||

		    !strncmp(new->m[i].argv[0], "yp", 2) ||

		    !strncmp(new->m[i].argv[0], "nisplus", 7) ||

		    !strncmp(new->m[i].argv[0], "nis", 3) ||

		    !strncmp(new->m[i].argv[0], "ldaps", 5) ||

		    !strncmp(new->m[i].argv[0], "ldap", 4) ||

		    !strncmp(new->m[i].argv[0], "sss", 3)) {

			char type[MAX_MAP_TYPE_STRING];

			char *fmt;

			strcpy(type, new->m[i].argv[0]);

			fmt = strchr(type, ',');

			if (!fmt)

				fmt = (char *) my_mapfmt;

			else {

				*fmt = '\0';

				fmt++;

			}

			if (!strcmp(new->m[i].argv[0], ctxt->m[i].argv[0]) &&

			    !strcmp(new->m[i].argv[1], ctxt->m[i].argv[1])) {

				new->m[i].mod = ctxt->m[i].mod;

				if (reinit_lookup(new->m[i].mod, new->m[i].argv[0],

					      MODPREFIX, fmt,

					      new->m[i].argc - 1, new->m[i].argv + 1))

					new->m[i].mod = NULL;

				else

					ctxt->m[i].mod = NULL;

			} else {

				open_lookup(type, MODPREFIX, fmt,

					    new->m[i].argc - 1,

					    new->m[i].argv + 1,

					    &new->m[i].mod);

			}

			continue;

		}

		INIT_LIST_HEAD(&nsslist);

		if (nsswitch_parse(&nsslist)) {

			if (!list_empty(&nsslist))

				free_sources(&nsslist);

			logerr("can't to read name service switch config.");

			/* TODO: check */

			ret = 1;

			goto out;

		}

		head = &nsslist;

		list_for_each(p, head) {

			struct nss_source *this;

			this = list_entry(p, struct nss_source, list);

			if (!strcmp(this->source, ctxt->m[i].mod->type)) {

				new->m[i].mod = ctxt->m[i].mod;

				if (reinit_lookup(new->m[i].mod, this->source,

					      MODPREFIX, my_mapfmt,

					      new->m[i].argc, new->m[i].argv))

					new->m[i].mod = NULL;

				else

					ctxt->m[i].mod = NULL;

				continue;

			}

			if (!strcmp(this->source, "files")) {

				char src_file[] = "file";

				char src_prog[] = "program";

				struct stat st;

				char *type, *path, *save_argv0;

				path = malloc(strlen(AUTOFS_MAP_DIR) +

					      strlen(new->m[i].argv[0]) + 2);

				if (!path) {

					estr = strerror_r(errno, buf, MAX_ERR_BUF);

					logerr(MODPREFIX "error: %s", estr);

					free_sources(&nsslist);

					ret = 1;

					goto out;

				}

				strcpy(path, AUTOFS_MAP_DIR);

				strcat(path, "/");

				strcat(path, new->m[i].argv[0]);

				if (stat(path, &st) == -1 || !S_ISREG(st.st_mode)) {

					free(path);

					continue;

				}

				if (st.st_mode & __S_IEXEC)

					type = src_prog;

				else

					type = src_file;

				save_argv0 = (char *) new->m[i].argv[0];

				new->m[i].argv[0] = path;

				if (strcmp(type, ctxt->m[i].mod->type)) {

					status = open_lookup(type,

							     MODPREFIX,

							     my_mapfmt,

							     new->m[i].argc,

							     new->m[i].argv,

							     &new->m[i].mod);

					if (status == NSS_STATUS_SUCCESS) {

						free(save_argv0);

						break;

					}

				} else {

					new->m[i].mod = ctxt->m[i].mod;

					if (reinit_lookup(new->m[i].mod, type,

						      MODPREFIX, my_mapfmt,

						      new->m[i].argc, new->m[i].argv))

						new->m[i].mod = NULL;

					else {

						ctxt->m[i].mod = NULL;

						free(save_argv0);

						break;

					}

				}

				new->m[i].argv[0] = save_argv0;

				free(path);

				continue;

			}

			if (strcmp(this->source, ctxt->m[i].mod->type)) {

				status = open_lookup(this->source, MODPREFIX,

						     my_mapfmt,

						     new->m[i].argc,

						     new->m[i].argv,

						     &new->m[i].mod);

				if (status == NSS_STATUS_SUCCESS)

					break;

			} else {

				new->m[i].mod = ctxt->m[i].mod;

				if (reinit_lookup(new->m[i].mod, this->source,

					      MODPREFIX, my_mapfmt,

					      new->m[i].argc, new->m[i].argv))

					new->m[i].mod = NULL;

				else {

					ctxt->m[i].mod = NULL;

					break;

				}

			}

		}

		free_sources(&nsslist);

	}

out:

	/* Update new context with any needed old context */

	*context = update_multi_context(ctxt, new);

	free_multi_context(ctxt);

	free(ctxt);

	return ret;

}

int lookup_read_master(struct master *master, time_t age, void *context)

{

        return NSS_STATUS_UNKNOWN;

}

int lookup_read_map(struct autofs_point *ap, time_t age, void *context)

{

	struct lookup_context *ctxt = (struct lookup_context *) context;

	struct map_source *source;

	int i, ret, at_least_1 = 0;

	source = ap->entry->current;

	ap->entry->current = NULL;

	master_source_current_signal(ap->entry);

	for (i = 0; i < ctxt->n; i++) {

		master_source_current_wait(ap->entry);

		ap->entry->current = source;

		ret = ctxt->m[i].mod->lookup_read_map(ap, age,

						ctxt->m[i].mod->context);

		if (ret & LKP_FAIL || ret == LKP_NOTSUP)

			continue;

		at_least_1 = 1;	

	}

	if (!at_least_1)

		return NSS_STATUS_NOTFOUND;

	return NSS_STATUS_SUCCESS;

}

int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *context)

{

	struct lookup_context *ctxt = (struct lookup_context *) context;

	struct map_source *source;

	int i;

	source = ap->entry->current;

	ap->entry->current = NULL;

	master_source_current_signal(ap->entry);

	for (i = 0; i < ctxt->n; i++) {

		master_source_current_wait(ap->entry);

		ap->entry->current = source;

		if (ctxt->m[i].mod->lookup_mount(ap, name, name_len,

						 ctxt->m[i].mod->context) == 0)

			return NSS_STATUS_SUCCESS;

	}

	return NSS_STATUS_NOTFOUND;		/* No module succeeded */

}

int lookup_done(void *context)

{

	struct lookup_context *ctxt = (struct lookup_context *) context;

	int rv;

	rv = free_multi_context(ctxt);

	free(ctxt);

	return rv;

}