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

#include "lint.h"
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <fcntl.h>
#include <mtlib.h>
#include <attr.h>
#include <sys/types.h>
#include <sys/syscall.h>
#include <sys/stat.h>
#include <sys/file.h>
#include <unistd.h>
#include <dlfcn.h>
#include <stdio.h>
#include <atomic.h>

static int (*nvpacker)(nvlist_t *, char **, size_t *, int, int);
static int (*nvsize)(nvlist_t *, size_t *, int);
static int (*nvunpacker)(char *, size_t, nvlist_t **);
static int (*nvfree)(nvlist_t *);
static int (*nvlookupint64)(nvlist_t *, const char *, uint64_t *);

static mutex_t attrlock = DEFAULTMUTEX;
static int initialized;

static char *xattr_view_name[XATTR_VIEW_LAST] = {
	VIEW_READONLY,
	VIEW_READWRITE
};

int
__openattrdirat(int fd, const char *name)
{
	return (syscall(SYS_openat, fd, name, FXATTRDIROPEN, 0));
}

static int
attrat_init()
{
	void *packer;
	void *sizer;
	void *unpacker;
	void *freer;
	void *looker;

	if (initialized == 0) {
		void *handle = dlopen("libnvpair.so.1", RTLD_LAZY);

		if (handle == NULL ||
		    (packer = dlsym(handle, "nvlist_pack")) == NULL ||
		    (sizer = dlsym(handle, "nvlist_size")) == NULL ||
		    (unpacker = dlsym(handle, "nvlist_unpack")) == NULL ||
		    (freer = dlsym(handle, "nvlist_free")) == NULL ||
		    (looker = dlsym(handle, "nvlist_lookup_uint64")) == NULL) {
			if (handle)
				(void) dlclose(handle);
			return (-1);
		}

		lmutex_lock(&attrlock);

		if (initialized != 0) {
			lmutex_unlock(&attrlock);
			(void) dlclose(handle);
			return (0);
		}

		nvpacker = (int (*)(nvlist_t *, char **, size_t *, int, int))
		    packer;
		nvsize = (int (*)(nvlist_t *, size_t *, int))
		    sizer;
		nvunpacker = (int (*)(char *, size_t, nvlist_t **))
		    unpacker;
		nvfree = (int (*)(nvlist_t *))
		    freer;
		nvlookupint64 = (int (*)(nvlist_t *, const char *, uint64_t *))
		    looker;

		membar_producer();
		initialized = 1;
		lmutex_unlock(&attrlock);
	}
	return (0);
}

static int
attr_nv_pack(nvlist_t *request, void **nv_request, size_t *nv_requestlen)
{
	size_t bufsize;
	char *packbuf = NULL;

	if (nvsize(request, &bufsize, NV_ENCODE_XDR) != 0) {
		errno = EINVAL;
		return (-1);
	}

	packbuf = malloc(bufsize);
	if (packbuf == NULL)
		return (-1);
	if (nvpacker(request, &packbuf, &bufsize, NV_ENCODE_XDR, 0) != 0) {
		free(packbuf);
		errno = EINVAL;
		return (-1);
	} else {
		*nv_request = (void *)packbuf;
		*nv_requestlen = bufsize;
	}
	return (0);
}

static const char *
view_to_name(xattr_view_t view)
{
	if (view >= XATTR_VIEW_LAST || view < 0)
		return (NULL);
	return (xattr_view_name[view]);
}

static int
xattr_openat(int basefd, xattr_view_t view, int mode)
{
	const char *xattrname;
	int xattrfd;
	int oflag;

	switch (view) {
	case XATTR_VIEW_READONLY:
		oflag = O_RDONLY;
		break;
	case XATTR_VIEW_READWRITE:
		oflag = mode & O_RDWR;
		break;
	default:
		errno = EINVAL;
		return (-1);
	}
	if (mode & O_XATTR)
		oflag |= O_XATTR;

	xattrname = view_to_name(view);
	xattrfd = openat(basefd, xattrname, oflag);
	if (xattrfd < 0)
		return (xattrfd);
	/* Don't cache sysattr info (advisory) */
	(void) directio(xattrfd, DIRECTIO_ON);
	return (xattrfd);
}

static int
cgetattr(int fd, nvlist_t **response)
{
	int error;
	int bytesread;
	void *nv_response;
	size_t nv_responselen;
	struct stat buf;

	if ((error = attrat_init()) != 0)
		return (error);
	if ((error = fstat(fd, &buf)) != 0)
		return (error);
	nv_responselen = buf.st_size;

	if ((nv_response = malloc(nv_responselen)) == NULL)
		return (-1);
	bytesread = read(fd, nv_response, nv_responselen);
	if (bytesread != nv_responselen) {
		free(nv_response);
		errno = EFAULT;
		return (-1);
	}

	if (nvunpacker(nv_response, nv_responselen, response)) {
		free(nv_response);
		errno = ENOMEM;
		return (-1);
	}

	free(nv_response);
	return (0);
}

static int
csetattr(int fd, nvlist_t *request)
{
	int error, saveerrno;
	int byteswritten;
	void *nv_request;
	size_t nv_requestlen;

	if ((error = attrat_init()) != 0)
		return (error);

	if ((error = attr_nv_pack(request, &nv_request, &nv_requestlen)) != 0)
		return (error);

	byteswritten = write(fd, nv_request, nv_requestlen);
	if (byteswritten != nv_requestlen) {
		saveerrno = errno;
		free(nv_request);
		errno = saveerrno;
		return (-1);
	}

	free(nv_request);
	return (0);
}

int
fgetattr(int basefd, xattr_view_t view, nvlist_t **response)
{
	int error, saveerrno, xattrfd;

	if ((xattrfd = xattr_openat(basefd, view, O_XATTR)) < 0)
		return (xattrfd);

	error = cgetattr(xattrfd, response);
	saveerrno = errno;
	(void) close(xattrfd);
	errno = saveerrno;
	return (error);
}

int
fsetattr(int basefd, xattr_view_t view, nvlist_t *request)
{
	int error, saveerrno, xattrfd;

	if ((xattrfd = xattr_openat(basefd, view, O_RDWR | O_XATTR)) < 0)
		return (xattrfd);
	error = csetattr(xattrfd, request);
	saveerrno = errno;
	(void) close(xattrfd);
	errno = saveerrno;
	return (error);
}

int
getattrat(int basefd, xattr_view_t view, const char *name, nvlist_t **response)
{
	int error, saveerrno, namefd, xattrfd;

	if ((namefd = __openattrdirat(basefd, name)) < 0)
		return (namefd);

	if ((xattrfd = xattr_openat(namefd, view, 0)) < 0) {
		saveerrno = errno;
		(void) close(namefd);
		errno = saveerrno;
		return (xattrfd);
	}

	error = cgetattr(xattrfd, response);
	saveerrno = errno;
	(void) close(namefd);
	(void) close(xattrfd);
	errno = saveerrno;
	return (error);
}

int
setattrat(int basefd, xattr_view_t view, const char *name, nvlist_t *request)
{
	int error, saveerrno, namefd, xattrfd;

	if ((namefd = __openattrdirat(basefd, name)) < 0)
		return (namefd);

	if ((xattrfd = xattr_openat(namefd, view, O_RDWR)) < 0) {
		saveerrno = errno;
		(void) close(namefd);
		errno = saveerrno;
		return (xattrfd);
	}

	error = csetattr(xattrfd, request);
	saveerrno = errno;
	(void) close(namefd);
	(void) close(xattrfd);
	errno = saveerrno;
	return (error);
}

void
libc_nvlist_free(nvlist_t *nvp)
{
	(void) nvfree(nvp);
}

int
libc_nvlist_lookup_uint64(nvlist_t *nvp, const char *name, uint64_t *value)
{
	return (nvlookupint64(nvp, name, value));
}