xref: /illumos-gate/usr/src/cmd/fs.d/nfs/lib/ref_subr.c (revision 8509e9ca)

/*
 * 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>

/*
 * str_to_utf8 - converts a null-terminated C string to a utf8 string
 */
utf8string *
str_to_utf8(char *nm, utf8string *str)
{
	int len;

	if (str == NULL)
		return (NULL);

	if (nm == NULL || *nm == '\0') {
		str->utf8string_len = 0;
		str->utf8string_val = NULL;
		return (NULL);
	}

	len = strlen(nm);

	str->utf8string_val = malloc(len);
	if (str->utf8string_val == NULL) {
		str->utf8string_len = 0;
		return (NULL);
	}
	str->utf8string_len = len;
	bcopy(nm, str->utf8string_val, len);

	return (str);
}

/*
 * Converts a utf8 string to a C string.
 * kmem_allocs a new string if not supplied
 */
char *
utf8_to_str(utf8string *str, uint_t *lenp, char *s)
{
	char	*sp;
	char	*u8p;
	int	len;
	int	 i;

	if (str == NULL)
		return (NULL);

	u8p = str->utf8string_val;
	len = str->utf8string_len;
	if (len <= 0 || u8p == NULL) {
		if (s)
			*s = '\0';
		return (NULL);
	}

	sp = s;
	if (sp == NULL)
		sp = malloc(len + 1);
	if (sp == NULL)
		return (NULL);

	/*
	 * At least check for embedded nulls
	 */
	for (i = 0; i < len; i++) {
		sp[i] = u8p[i];
		if (u8p[i] == '\0') {
			if (s == NULL)
				free(sp);
			return (NULL);
		}
	}
	sp[len] = '\0';
	*lenp = len + 1;

	return (sp);
}

void
print_referral_summary(fs_locations4 *fsl)
{
	int i, j;
	uint_t l;
	char *s;
	fs_location4 *fs;

	if (fsl == NULL) {
		printf("NULL\n");
		return;
	}

	for (i = 0; i < fsl->locations.locations_len; i++) {
		if (i > 0)
			printf("\n");
		fs = &fsl->locations.locations_val[i];
		for (j = 0; j < fs->server.server_len; j++) {
			s = utf8_to_str(&fs->server.server_val[j], &l, NULL);
			if (j > 0)
				printf(",");
			printf("%s", s ? s : "");
			if (s)
				free(s);
		}
		printf(":");
		for (j = 0; j < fs->rootpath.pathname4_len; j++) {
			s = utf8_to_str(&fs->rootpath.pathname4_val[j],
			    &l, NULL);
			printf("/%s", s ? s : "");
			if (s)
				free(s);
		}
		if (fs->rootpath.pathname4_len == 0)
			printf("/");
	}
	printf("\n");
}

/*
 * There is a kernel copy of this routine in nfs4_srv.c.
 * Changes should be kept in sync.
 */
static int
nfs4_create_components(char *path, component4 *comp4)
{
	int slen, plen, ncomp;
	char *ori_path, *nxtc, buf[MAXNAMELEN];

	if (path == NULL)
		return (0);

	plen = strlen(path) + 1;	/* include the terminator */
	ori_path = path;
	ncomp = 0;

	/* count number of components in the path */
	for (nxtc = path; nxtc < ori_path + plen; nxtc++) {
		if (*nxtc == '/' || *nxtc == '\0' || *nxtc == '\n') {
			if ((slen = nxtc - path) == 0) {
				path = nxtc + 1;
				continue;
			}

			if (comp4 != NULL) {
				bcopy(path, buf, slen);
				buf[slen] = '\0';
				if (str_to_utf8(buf, &comp4[ncomp]) == NULL)
					return (0);
			}

			ncomp++;	/* 1 valid component */
			path = nxtc + 1;
		}
		if (*nxtc == '\0' || *nxtc == '\n')
			break;
	}

	return (ncomp);
}

/*
 * There is a kernel copy of this routine in nfs4_srv.c.
 * Changes should be kept in sync.
 */
int
make_pathname4(char *path, pathname4 *pathname)
{
	int ncomp;
	component4 *comp4;

	if (pathname == NULL)
		return (0);

	if (path == NULL) {
		pathname->pathname4_val = NULL;
		pathname->pathname4_len = 0;
		return (0);
	}

	/* count number of components to alloc buffer */
	if ((ncomp = nfs4_create_components(path, NULL)) == 0) {
		pathname->pathname4_val = NULL;
		pathname->pathname4_len = 0;
		return (0);
	}
	comp4 = calloc(ncomp * sizeof (component4), 1);
	if (comp4 == NULL) {
		pathname->pathname4_val = NULL;
		pathname->pathname4_len = 0;
		return (0);
	}

	/* copy components into allocated buffer */
	ncomp = nfs4_create_components(path, comp4);

	pathname->pathname4_val = comp4;
	pathname->pathname4_len = ncomp;

	return (ncomp);
}

bool_t
xdr_component4(register XDR *xdrs, component4 *objp)
{

	if (!xdr_utf8string(xdrs, objp))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_utf8string(register XDR *xdrs, utf8string *objp)
{

	if (xdrs->x_op != XDR_FREE)
		return (xdr_bytes(xdrs, (char **)&objp->utf8string_val,
		    (uint_t *)&objp->utf8string_len, NFS4_MAX_UTF8STRING));
	return (TRUE);
}

bool_t
xdr_pathname4(register XDR *xdrs, pathname4 *objp)
{

	if (!xdr_array(xdrs, (char **)&objp->pathname4_val,
	    (uint_t *)&objp->pathname4_len, NFS4_MAX_PATHNAME4,
	    sizeof (component4), (xdrproc_t)xdr_component4))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_fs_location4(register XDR *xdrs, fs_location4 *objp)
{

	if (xdrs->x_op == XDR_DECODE) {
		objp->server.server_val = NULL;
		objp->rootpath.pathname4_val = NULL;
	}
	if (!xdr_array(xdrs, (char **)&objp->server.server_val,
	    (uint_t *)&objp->server.server_len, ~0,
	    sizeof (utf8string), (xdrproc_t)xdr_utf8string))
		return (FALSE);
	if (!xdr_pathname4(xdrs, &objp->rootpath))
		return (FALSE);
	return (TRUE);
}

bool_t
xdr_fs_locations4(register XDR *xdrs, fs_locations4 *objp)
{

	if (xdrs->x_op == XDR_DECODE) {
		objp->fs_root.pathname4_len = 0;
		objp->fs_root.pathname4_val = NULL;
		objp->locations.locations_val = NULL;
	}
	if (!xdr_pathname4(xdrs, &objp->fs_root))
		return (FALSE);
	if (!xdr_array(xdrs, (char **)&objp->locations.locations_val,
	    (uint_t *)&objp->locations.locations_len, ~0,
	    sizeof (fs_location4), (xdrproc_t)xdr_fs_location4))
		return (FALSE);
	return (TRUE);
}