/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <kvm.h>
#include <kstat.h>
#include <sys/types.h>
#include <sys/mnttab.h>
#include <sys/mntent.h>
#include <nfs/nfs.h>
#include <nfs/nfs_clnt.h>
#include <sys/mkdev.h>
#include <inttypes.h>
#include <sys/stat.h>


#include "libfsmgt.h"
#include "replica.h"

#define	IGNORE	0
#define	DEV	1

/*
 * Private variables
 */

static char *mntopts[] = { MNTOPT_IGNORE, MNTOPT_DEV, NULL };

/*
 * Private method declarations
 */

static int ignore(char *);
static int get_kstat_info(nfs_mntlist_t *, int *);
static nfs_mntlist_t *get_mount_data(fs_mntlist_t *, int *);
static nfs_mntlist_t *get_nfs_info(fs_mntlist_t *, int *);
static nfs_mntlist_t *kstat_mount(nfs_mntlist_t *, kstat_t *);
static int load_kstat_data(kstat_ctl_t *, nfs_mntlist_t *, kstat_t *, int *);
static kid_t safe_kstat_read(kstat_ctl_t *, kstat_t *, void *, int *);

/*
 * Public methods
 */

void
nfs_free_mntinfo_list(nfs_mntlist_t *list)
{
	nfs_mntlist_t *tmp;
	int i;

	while (list != NULL) {
		free(list->nml_resource);
		free(list->nml_mountp);
		free(list->nml_fstype);
		free(list->nml_mntopts);
		free(list->nml_time);
		for (i = 0; i < list->nml_failovercount; i++) {
			if (list->nml_failoverlist[i] != NULL)
				free(list->nml_failoverlist[i]);
		}
		free(list->nml_failoverlist);
		free(list->nml_securitymode);
		tmp = list->next;
		free(list);
		list = tmp;
	}
} /* nfs_free_mntinfo_list */

nfs_mntlist_t *
nfs_get_filtered_mount_list(char *resource, char *mountp, char *mntopts,
	char *time, boolean_t find_overlays, int *errp) {

	fs_mntlist_t	*fs_mount_list;
	nfs_mntlist_t	*nfs_mount_list;

	fs_mount_list = fs_get_filtered_mount_list(resource, mountp,
		MNTTYPE_NFS, mntopts, time, find_overlays, errp);
	if (fs_mount_list == NULL) {
		return (NULL);
	}

	if ((nfs_mount_list = get_nfs_info(fs_mount_list, errp)) == NULL) {
		fs_free_mount_list(fs_mount_list);
		return (NULL);
	}

	fs_free_mount_list(fs_mount_list);
	return (nfs_mount_list);
} /* nfs_get_filtered_mount_list */

nfs_mntlist_t *
nfs_get_mounts_by_mntopt(char *mntopt, boolean_t find_overlays, int *errp)
{
	fs_mntlist_t	*fs_mount_list;
	nfs_mntlist_t	*nfs_mount_list;

	fs_mount_list = fs_get_mounts_by_mntopt(mntopt, find_overlays, errp);
	if (fs_mount_list == NULL) {
		return (NULL);
	}

	if ((nfs_mount_list = get_nfs_info(fs_mount_list, errp)) == NULL) {
		fs_free_mount_list(fs_mount_list);
		return (NULL);
	}

	fs_free_mount_list(fs_mount_list);
	return (nfs_mount_list);
} /* nfs_get_mount_by_mntopt */

nfs_mntlist_t *
nfs_get_mount_list(int *errp)
{
	fs_mntlist_t *fs_mount_list;
	nfs_mntlist_t *nfs_mount_list;
	boolean_t find_overlays = B_TRUE;

	if ((fs_mount_list = fs_get_mount_list(find_overlays, errp)) == NULL) {
		fprintf(stderr, "nfs_mntinfo: Can't access mnttab. %s\n",
		    strerror(*errp));
		return (NULL);
	}

	if ((nfs_mount_list = get_nfs_info(fs_mount_list, errp)) == NULL) {
		fs_free_mount_list(fs_mount_list);
		return (NULL);
	}

	fs_free_mount_list(fs_mount_list);
	return (nfs_mount_list);
} /* nfs_get_mount_list */

/*
 * Private methods
 */

static int
get_kstat_info(nfs_mntlist_t *nfs_mntinfo, int *errp)
{
	kstat_ctl_t *libkstat_cookie = NULL;
	nfs_mntlist_t *mrp;
	kstat_t *ksp;

	if ((libkstat_cookie = kstat_open()) == NULL) {
		*errp = errno;
		fprintf(stderr,
		    "nfs_mntinfo: kstat_open(): can't open /dev/kstat.\n");
		return (-1);
	}
	/*
	 * Each kstat consists of header and data sections that are
	 * connected as a "chain" or linked list of kstat stuctures.
	 * The kc_chain used here is the pointer to the global kstat
	 * chain (or the head of the chain of kstat's).
	 */
	for (ksp = libkstat_cookie->kc_chain; ksp; ksp = ksp->ks_next) {
		if ((ksp->ks_type == KSTAT_TYPE_RAW) &&
		    (strcmp(ksp->ks_module, "nfs") == 0) &&
		    (strcmp(ksp->ks_name, "mntinfo") == 0) &&
		    ((mrp = kstat_mount(nfs_mntinfo, ksp)) != NULL)) {
			if (load_kstat_data(libkstat_cookie, mrp, ksp, errp)
			    == -1) {
				nfs_free_mntinfo_list(mrp);
				return (-1);
			}
		}
	}
	return (0);
} /* get_kstat_info */

static int
load_kstat_data(kstat_ctl_t *libkstat_cookie, nfs_mntlist_t *mrp,
    kstat_t *ksp, int *errp)
{
	struct mntinfo_kstat mik;
	seconfig_t nfs_sec;

	if (mrp == 0) {
		return (0);
	}

	if (safe_kstat_read(libkstat_cookie, ksp, &mik, errp) == -1) {
		return (-1);
	}

	if (strlcpy(mrp->nml_proto, mik.mik_proto, KNC_STRSIZE)
	    >= KNC_STRSIZE) {
		*errp = errno;
		return (-1);
	}
	if (strlcpy(mrp->nml_curserver, mik.mik_curserver, SYS_NMLN)
	    >= SYS_NMLN) {
		*errp = errno;
		return (-1);
	}
	mrp->nml_vers = mik.mik_vers;
	/*
	 *  get the secmode name from /etc/nfssec.conf.
	 */
	if (!nfs_getseconfig_bynumber(mik.mik_secmod, &nfs_sec)) {
		mrp->nml_securitymode = strdup(nfs_sec.sc_name);
	} else {
		mrp->nml_securitymode = NULL;
	}
	mrp->nml_curread = mik.mik_curread;
	mrp->nml_curwrite = mik.mik_curwrite;
	mrp->nml_timeo = mik.mik_timeo;
	mrp->nml_retrans = mik.mik_retrans;
	mrp->nml_acregmin = mik.mik_acregmin;
	mrp->nml_acregmax = mik.mik_acregmax;
	mrp->nml_acdirmin = mik.mik_acdirmin;
	mrp->nml_acdirmax = mik.mik_acdirmax;
	mrp->nml_hard =
	    ((mik.mik_flags & MI_HARD) ? B_TRUE : B_FALSE);
	mrp->nml_intr =
	    ((mik.mik_flags & MI_INT) ? B_TRUE : B_FALSE);
	mrp->nml_noac =
	    ((mik.mik_flags & MI_NOAC) ? B_TRUE : B_FALSE);
	mrp->nml_nocto =
	    ((mik.mik_flags & MI_NOCTO) ? B_TRUE : B_FALSE);
	mrp->nml_grpid =
	    ((mik.mik_flags & MI_GRPID) ? B_TRUE : B_FALSE);
	mrp->nml_directio =
	    ((mik.mik_flags & MI_DIRECTIO) ? B_TRUE : B_FALSE);
	mrp->nml_xattr =
	    ((mik.mik_flags & MI_EXTATTR) ? B_TRUE : B_FALSE);
	return (0);
}

nfs_mntlist_t *
kstat_mount(nfs_mntlist_t *nfs_mntinfo, kstat_t *ksp) {
	nfs_mntlist_t *mrp;
	/*
	 * MAXMIN is used to retrieve the minor number
	 * which is compared to the kstat instance.
	 * If they are the same then this is an instance
	 * for which mount information is needed.
	 * MAXMIN is the maximum minor number and is
	 * defined in mkdev.h.
	 */
	mrp = nfs_mntinfo;
	while ((mrp != NULL) &&
	    ((mrp->nml_fsid & MAXMIN) != ksp->ks_instance)) {
		mrp = mrp->next;
	}
	return (mrp);
}

static nfs_mntlist_t *
get_nfs_info(fs_mntlist_t *fslist, int *errp) {
	nfs_mntlist_t *mrp = NULL;
	nfs_mntlist_t *headptr = NULL;
	nfs_mntlist_t *tailptr = NULL;
	fs_mntlist_t *fsmnt_list;

	for (fsmnt_list = fslist; fsmnt_list; fsmnt_list = fsmnt_list->next) {
		/* ignore non "nfs" and the "ignore" entries */

		if ((strcmp(fsmnt_list->fstype, MNTTYPE_NFS) != 0) ||
		    (ignore(fsmnt_list->mntopts))) {
			continue;
		}

		if ((mrp = get_mount_data(fsmnt_list, errp)) == NULL) {
			nfs_free_mntinfo_list(headptr);
			return (NULL);
		}
		if (tailptr == NULL) {
			headptr = mrp;
			tailptr = mrp;
			tailptr->next = NULL;
		} else {
			tailptr->next = mrp;
			tailptr = mrp;
			tailptr->next = NULL;
		}
	}

	if (get_kstat_info(headptr, errp) == -1) {
		nfs_free_mntinfo_list(mrp);
		return (NULL);
	}
	return (headptr);

} /* get_nfs_info */


static nfs_mntlist_t *
get_mount_data(fs_mntlist_t *fsmnt_list, int *errp) {
	struct replica *rep_list; /* defined in replica.h */
	nfs_mntlist_t *mrp;
	int i, server_count = 0;
	struct stat	stat_buf;

	if ((mrp = malloc(sizeof (nfs_mntlist_t))) == 0) {
		*errp = errno;
		return (NULL);
	}

	if ((stat(fsmnt_list->mountp, &stat_buf) == 0)) {
		mrp->nml_fsid = stat_buf.st_dev;
	} else {
		*errp = errno;
		nfs_free_mntinfo_list(mrp);
		return (NULL);
	}

	if ((mrp->nml_resource = strdup(fsmnt_list->resource))
	    == NULL) {
		*errp = errno;
		nfs_free_mntinfo_list(mrp);
		return (NULL);
	}
	if ((rep_list =
	    parse_replica(mrp->nml_resource, &server_count)) == NULL) {
		nfs_free_mntinfo_list(mrp);
		return (NULL);
	}
	if ((mrp->nml_failoverlist =
	    calloc(server_count, sizeof (char *))) == NULL) {
		nfs_free_mntinfo_list(mrp);
		return (NULL);
	}
	for (i = 0; i < server_count; i++) {
		mrp->nml_failoverlist[i] =
		    malloc(strlen(rep_list[i].host) + strlen(":") +
		    strlen(rep_list[i].path) + 2);
		if (!mrp->nml_failoverlist[i]) {
			nfs_free_mntinfo_list(mrp);
			return (NULL);
		}
		sprintf(mrp->nml_failoverlist[i], "%s%s%s",
		    rep_list[i].host, ":", rep_list[i].path);
	}
	/*
	 * If the number of servers is not 1 then resource is
	 * either a failover list or there is an error. In either
	 * case the path can't be determined and curpath is set to
	 * unknown".
	 */
	if (server_count == 1) {
		if (strcmp(rep_list[0].host, "nfs") == 0) {
			char *path;
			char *last;
			path = strdup(rep_list[0].path);
			if ((path = (char *)strtok_r(path, "//",
			    &last)) != NULL) {
				strcpy(mrp->nml_curpath,
				    strcat("/", last));
			} else {
				/*
				 * If NULL is returned this is an
				 * invalid path entry. no path can
				 * be determined.
				 */
				strcpy(mrp->nml_curpath, "unknown");
			}
		} else {
			strcpy(mrp->nml_curpath,
			    (strchr(mrp->nml_failoverlist[0],
			    ':') + 1));
		}
	} else {
		/*
		 * more than one server in the failover list
		 * path can't be determined.
		 */
		strcpy(mrp->nml_curpath, "unknown");
	}

	mrp->nml_failovercount = server_count;

	for (i = 0; i < server_count; i++) {
		if (rep_list[i].host) {
			free(rep_list[i].host);
		}
		if (rep_list[i].path) {
			free(rep_list[i].path);
		}
	}
	free(rep_list);

	if ((mrp->nml_mountp = strdup(fsmnt_list->mountp)) == NULL) {
		*errp = errno;
		nfs_free_mntinfo_list(mrp);
		return (NULL);
	}
	if ((mrp->nml_fstype = strdup(fsmnt_list->fstype)) == NULL) {
		*errp = errno;
		nfs_free_mntinfo_list(mrp);
		return (NULL);
	}
	if ((mrp->nml_mntopts = strdup(fsmnt_list->mntopts)) == NULL) {
		*errp = errno;
		nfs_free_mntinfo_list(mrp);
		return (NULL);
	}
	if ((mrp->nml_time = strdup(fsmnt_list->time)) == NULL) {
		*errp = errno;
		nfs_free_mntinfo_list(mrp);
		return (NULL);
	}
	if (fsmnt_list->overlayed) {
		mrp->nml_overlayed = B_TRUE;
	} else {
		mrp->nml_overlayed = B_FALSE;
	}
	return (mrp);
} /* get_mount_data */

kid_t
safe_kstat_read(
	kstat_ctl_t *libkstat_cookie,
	kstat_t *ksp,
	void *data,
	int *errp)
{

	kid_t kstat_chain_id = kstat_read(libkstat_cookie, ksp, data);

	if (kstat_chain_id == -1) {
		*errp = errno;
		return (-1);
	}
	return (kstat_chain_id);
} /* safe_kstat_read */


/*
 * ignore - Checks for the ignore mount option in the mount opts string.
 * Returns 1 if the ignore option is found and 0 if not.
 */
static int
ignore(char *opts)
{
	char *value;
	char *s;
	char *tmp;

	if (opts == NULL)
		return (0);
	s = strdup(opts);
	if (s == NULL)
		return (0);

	tmp = s;

	while (*s != '\0') {
		if (getsubopt(&s, mntopts, &value) == IGNORE) {
			free(tmp);
			return (1);
		}
	}
	free(tmp);
	return (0);
} /* ignore */