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

 *

 *  lookup_dir.c - module for including master files in a directory.

 *

 * Copyright 2011 Red Hat, Inc. All rights reserved.

 * Copyright 2011 Masatake YAMATO <yamato@redhat.com>

 *

 * 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 <stdio.h>

#include <malloc.h>

#include <pwd.h>

#include <string.h>

#include <sys/param.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <dirent.h>

#define MODULE_LOOKUP

#include "automount.h"

#include "nsswitch.h"

#define MODPREFIX "lookup(dir): "

#define MAX_INCLUDE_DEPTH	16

#define AUTOFS_DIR_EXT ".autofs"

#define AUTOFS_DIR_EXTSIZ (sizeof(AUTOFS_DIR_EXT) - 1)

/* Work around non-GNU systems that don't provide versionsort */

#ifdef WITHOUT_VERSIONSORT

#define versionsort alphasort

#endif

struct lookup_context {

  const char *mapname;

};

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

static int do_init(const char *mapfmt,

		   int argc, const char *const *argv,

		   struct lookup_context *ctxt)

{

	struct stat st;

	if (argc < 1) {

		logerr(MODPREFIX "No map name");

		return 1;

	}

	ctxt->mapname = argv[0];

	if (ctxt->mapname[0] != '/') {

		logmsg(MODPREFIX

		     "dir map %s is not an absolute pathname", argv[0]);

		return 1;

	}

	if (access(ctxt->mapname, R_OK)) {

		warn(LOGOPT_NONE, MODPREFIX

		     "dir map %s missing or not readable", argv[0]);

		return 1;

	}

	if (stat(ctxt->mapname, &st)) {

		warn(LOGOPT_NONE, MODPREFIX

		     "dir map %s, could not stat", argv[0]);

		return 1;

	}

	if ((!S_ISDIR(st.st_mode)) && (!S_ISLNK(st.st_mode))) {

		warn(LOGOPT_NONE, MODPREFIX

		     "dir map %s, is not a directory", argv[0]);

		return 1;

	}

	return 0;

}

int lookup_init(const char *mapfmt,

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

{

	struct lookup_context *ctxt;

	char buf[MAX_ERR_BUF];

	*context = NULL;

	ctxt = malloc(sizeof(struct lookup_context));

	if (!ctxt) {

		char *estr = strerror_r(errno, buf, MAX_ERR_BUF);

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

		return 1;

	}

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

	if (do_init(mapfmt, argc, argv, ctxt)) {

		free(ctxt);

		return 1;

	}

	*context = ctxt;

	return 0;

}

int lookup_reinit(const char *mapfmt,

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

{

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

	struct lookup_context new;

	int ret;

	ret = do_init(mapfmt, argc, argv, &new;;

	if (ret)

		return 1;

	ctxt->mapname = new.mapname;

	return 0;

}

static int acceptable_dirent_p(const struct dirent *e)

{

  size_t namesz;

  namesz = strlen(e->d_name);

  if (!namesz)

	  return 0;

  if (e->d_name[0] == '.')

	  return 0;

  if (namesz < AUTOFS_DIR_EXTSIZ + 1 ||

      strcmp(e->d_name + (namesz - AUTOFS_DIR_EXTSIZ),

	     AUTOFS_DIR_EXT))

	  return 0;

  return 1;

}

static int include_file(struct master *master, time_t age, struct lookup_context* ctxt, struct dirent *e)

{

	unsigned int logopt = master->logopt;

	char included_path[PATH_MAX + 1];

	int included_path_len;

	char *save_name;

	int status;

	included_path_len = snprintf(included_path,

				     PATH_MAX + 1,

				     "%s/%s",

				     ctxt->mapname,

				     e->d_name);

	if (included_path_len > PATH_MAX)

		return NSS_STATUS_NOTFOUND;

	save_name = master->name;

	master->name = included_path;

	master->depth++;

	debug(logopt, MODPREFIX "include: %s", master->name);

	status = lookup_nss_read_master(master, age);

	if (status != NSS_STATUS_SUCCESS) {

		warn(logopt,

		     MODPREFIX

		     "failed to read included master map %s",

		     master->name);

	}

	master->depth--;

	master->name = save_name;

	return NSS_STATUS_SUCCESS;

}

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

{

        int n, i;

	struct dirent **namelist = NULL;

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

	unsigned int logopt = master->logopt;

	char buf[MAX_ERR_BUF];

	if (master->depth > MAX_INCLUDE_DEPTH) {

		error(logopt, MODPREFIX

		      "maximum include depth exceeded %s", master->name);

		return NSS_STATUS_UNAVAIL;

	}

	debug(logopt, MODPREFIX "scandir: %s", ctxt->mapname);

	n = scandir(ctxt->mapname, &namelist, acceptable_dirent_p, versionsort);

	if (n < 0) {

	       char *estr = strerror_r(errno, buf, MAX_ERR_BUF);

		error(logopt,

		      MODPREFIX "could not scan master map dir %s: %s",

		      ctxt->mapname,

		      estr);

		return NSS_STATUS_UNAVAIL;

	}

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

		struct dirent *e = namelist[i];

		include_file(master, age, ctxt, e);

		free(e);

	}

	free(namelist);

	return NSS_STATUS_SUCCESS;

}

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

{

	ap->entry->current = NULL;

	master_source_current_signal(ap->entry);

	return NSS_STATUS_UNKNOWN;

}

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

{

	ap->entry->current = NULL;

	master_source_current_signal(ap->entry);

	return NSS_STATUS_UNKNOWN;

}

int lookup_done(void *context)

{

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

	free(ctxt);

	return 0;

}