/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <unistd.h>
#include <strings.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/errno.h>
#include <limits.h>
#include <libnvpair.h>
#include <dlfcn.h>
#include <link.h>
#include <rp_plugin.h>
#include <fcntl.h>
#include <uuid/uuid.h>
#include <rpc/types.h>
#include <rpc/xdr.h>
#include <rpc/auth.h>
#include <rpc/clnt.h>
#include <rpc/rpc_msg.h>
#include <sys/param.h>
#include <nfs/nfs4.h>
#include <rpcsvc/nfs4_prot.h>
#include "ref_subr.h"

extern int errno;

#define	SERVICE_TYPE	"nfs-basic"

char *nfs_basic_service_type(void);
boolean_t nfs_basic_supports_svc(const char *);
int nfs_basic_deref(const char *, const char *, char *, size_t *);
int nfs_basic_form(const char *, const char *, char *, size_t *);

struct rp_plugin_ops rp_plugin_ops = {
	RP_PLUGIN_V1,
	NULL,			/* rpo_init */
	NULL,			/* rpo_fini */
	nfs_basic_service_type,
	nfs_basic_supports_svc,
	nfs_basic_form,
	nfs_basic_deref
};

/*
 * What service type does this module support?
 */
char *
nfs_basic_service_type()
{
	return (SERVICE_TYPE);
}

/*
 * Does this module support a particular service type?
 */
boolean_t
nfs_basic_supports_svc(const char *svc_type)
{
	if (!svc_type)
		return (0);
	return (!strncasecmp(svc_type, SERVICE_TYPE, strlen(SERVICE_TYPE)));
}

/*
 * Take a string with a set of locations like this:
 *   host1:/path1 host2:/path2 host3:/path3
 * and convert it to an fs_locations4 for the deref routine.
 */
static fs_locations4 *
get_fs_locations(char *buf)
{
	fs_locations4 *result = NULL;
	fs_location4 *fsl_array;
	int i, gothost;
	int fsl_count = 0, escape = 0, delimiter = 0;
	int len;
	char *p, *sp, *dp, buf2[SYMLINK_MAX];

	if (buf == NULL)
		return (NULL);
#ifdef DEBUG
	printf("get_fs_locations: input %s\n", buf);
#endif
	/*
	 * Count fs_location entries by counting spaces.
	 * Remember that escaped spaces ("\ ") may exist.
	 * We mark the location boundaries with null bytes.
	 * Variable use:
	 *   escape -   set if we have found a backspace,
	 *		part of either "\ " or "\\"
	 *   delimiter - set if we have found a space and
	 *		 used to skip multiple spaces
	 */
	for (sp = buf; sp && *sp; sp++) {
		if (*sp == '\\') {
			escape = 1;
			delimiter = 0;
			continue;
		}
		if (*sp == ' ') {
			if (delimiter == 1)
				continue;
			if (escape == 0) {
				delimiter = 1;
				fsl_count++;
				*sp = '\0';
			} else
				escape = 0;
		} else
			delimiter = 0;
	}
	len = sp - buf;
	sp--;
	if (escape == 0 && *sp != '\0')
		fsl_count++;
#ifdef DEBUG
	printf("get_fs_locations: fsl_count %d\n", fsl_count);
#endif
	if (fsl_count == 0)
		goto out;

	/* Alloc space for everything */
	result = calloc(1, sizeof (fs_locations4));
	if (result == NULL)
		goto out;
	fsl_array = calloc(fsl_count, sizeof (fs_location4));
	if (fsl_array == NULL) {
		free(result);
		result = NULL;
		goto out;
	}
	result->locations.locations_len = fsl_count;
	result->locations.locations_val = fsl_array;
	result->fs_root.pathname4_len = 0;
	result->fs_root.pathname4_val = NULL;

	/*
	 * Copy input, removing escapes from host:/path/to/my\ files
	 */
	sp = buf;
	dp = buf2;
	bzero(buf2, sizeof (buf2));

	i = gothost = 0;
	while ((sp && *sp && (sp - buf < len)) || gothost) {

		if (!gothost) {
			/* Drop leading spaces */
			if (*sp == ' ') {
				sp++;
				continue;
			}

			/* Look for the rightmost colon for host */
			p = strrchr(sp, ':');
			if (!p) {
#ifdef DEBUG
				printf("get_fs_locations: skipping %s\n", sp);
#endif
				fsl_count--;
				sp += strlen(sp) + 1;
			} else {
				bcopy(sp, dp, p - sp);
				sp = p + 1;
#ifdef DEBUG
				printf("get_fs_locations: host %s\n", buf2);
#endif
				fsl_array[i].server.server_len = 1;
				fsl_array[i].server.server_val =
				    malloc(sizeof (utf8string));
				if (fsl_array[i].server.server_val == NULL) {
					int j;

					free(result);
					result = NULL;
					for (j = 0; j < i; j++)
						free(fsl_array[j].
						    server.server_val);
					free(fsl_array);
					goto out;
				}
				str_to_utf8(buf2,
				    fsl_array[i].server.server_val);
				gothost = 1;
				dp = buf2;
				bzero(buf2, sizeof (buf2));
			}
			continue;
		}

		/* End of string should mean a pathname */
		if (*sp == '\0' && gothost) {
#ifdef DEBUG
			printf("get_fs_locations: path %s\n", buf2);
#endif
			(void) make_pathname4(buf2, &fsl_array[i].rootpath);
			i++;
			gothost = 0;
			dp = buf2;
			bzero(buf2, sizeof (buf2));
			if (sp - buf < len)
				sp++;
			continue;
		}

		/* Skip a single escape character */
		if (*sp == '\\')
			sp++;

		/* Plain char, just copy it */
		*dp++ = *sp++;
	}

	/*
	 * If we're still expecting a path name, we don't have a
	 * server:/path pair and should discard the server and
	 * note that we got fewer locations than expected.
	 */
	if (gothost) {
		fsl_count--;
		free(fsl_array[i].server.server_val);
		fsl_array[i].server.server_val = NULL;
		fsl_array[i].server.server_len = 0;
	}

	/*
	 * If we have zero entries, we never got a whole server:/path
	 * pair, and so cannot have anything else allocated.
	 */
	if (fsl_count <= 0) {
		free(result);
		free(fsl_array);
		return (NULL);
	}

	/*
	 * Make sure we reflect the right number of locations.
	 */
	if (fsl_count < result->locations.locations_len)
		result->locations.locations_len = fsl_count;

out:
	return (result);
}

/*
 * Deref function for nfs-basic service type returns an fs_locations4.
 */
int
nfs_basic_deref(const char *svc_type, const char *svc_data, char *buf,
    size_t *bufsz)
{
	int slen, err;
	fs_locations4 *fsl;
	XDR xdr;

	if ((!svc_type) || (!svc_data) || (!buf) || (!bufsz) || (*bufsz == 0))
		return (EINVAL);

	if (strcasecmp(svc_type, SERVICE_TYPE))
		return (ENOTSUP);

	fsl = get_fs_locations((char *)svc_data);
	if (fsl == NULL)
		return (ENOENT);
#ifdef DEBUG
	printf("nfs_basic_deref: past get_fs_locations()\n");
#endif
	slen = xdr_sizeof(xdr_fs_locations4, (void *)fsl);
	if (slen > *bufsz) {
		*bufsz = slen;
		xdr_free(xdr_fs_locations4, (char *)fsl);
		return (EOVERFLOW);
	}
#ifdef DEBUG
	printf("nfs_basic_deref: past buffer check\n");
	print_referral_summary(fsl);
#endif
	xdrmem_create(&xdr, buf, *bufsz, XDR_ENCODE);
	err = xdr_fs_locations4(&xdr, fsl);
	XDR_DESTROY(&xdr);
	xdr_free(xdr_fs_locations4, (char *)fsl);
	if (err != TRUE)
		return (EINVAL);
	*bufsz = slen;
#ifdef DEBUG
	printf("nfs_basic_deref: past xdr_fs_locations4() and done\n");
#endif
	return (0);
}

/*
 * Form function for nfs-basic service type.
 */
int
nfs_basic_form(const char *svc_type, const char *svc_data, char *buf,
    size_t *bufsz)
{
	int slen;

	if ((!svc_type) || (!svc_data) || (!buf) || (*bufsz == 0))
		return (EINVAL);

	if (strcmp(svc_type, SERVICE_TYPE))
		return (ENOTSUP);

	slen = strlen(svc_data) + 1;
	if (slen > *bufsz) {
		*bufsz = slen;
		return (EOVERFLOW);
	}
	*bufsz = slen;
	strncpy(buf, svc_data, slen);
	return (0);
}