/*

 * 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

 */

/*

 */

#include <sys/types.h>

#include <sys/socket.h>

#include <bsm/adt_event.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <errno.h>

#include <unistd.h>

#include <pthread.h>

#include <ucred.h>

#include <zone.h>

#include <rad/adr_stream.h>

#include "rad_object.h"

#include "rad_modapi.h"

#include "rad_modapi_xport.h"

#include "rad_connection.h"

#include "rad_xport.h"

#include "api_unix.h"

static boolean_t

sockaddr_init(struct sockaddr_un *addr, const char *name)

{

	size_t namelen;

	size_t addrlen;

	(void) memset(addr, 0, sizeof (*addr));

	addr->sun_family = AF_UNIX;

	namelen = strlen(name);

	addrlen = sizeof (addr->sun_path);

	if (namelen >= addrlen)

		return (B_FALSE);

	(void) strlcpy(addr->sun_path, name, sizeof (addr->sun_path));

	return (B_TRUE);

}

static int

listen_on_name(const char *name)

{

	int fd;

	struct sockaddr_un addr;

	if (unlink(name) == -1 && errno != ENOENT) {

		rad_log(RL_ERROR, "unlink of '%s' failed: %s", name,

		    strerror(errno));

		return (-1);

	}

	if (!sockaddr_init(&addr, name)) {

		rad_log(RL_ERROR, "socket name '%s' too long", name);

		return (-1);

	}

	if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {

		rad_log(RL_ERROR, "socket failed: %s", strerror(errno));

		return (-1);

	}

	if (bind(fd, (struct sockaddr *)&addr, sizeof (addr)) == -1) {

		rad_log(RL_ERROR, "bind to '%s' failed: %s", name,

		    strerror(errno));

		(void) close(fd);

		return (-1);

	}

	if (listen(fd, 15) == -1) {

		rad_log(RL_ERROR, "listen on '%s' failed: %s", name,

		    strerror(errno));

		return (-1);

	}

	return (fd);

}

/*

 * Determines if the ucred represents someone who is effectively us.

 */

static boolean_t

sent_by_joe(ucred_t *uc)

{

	const priv_set_t *theirprivs;

	priv_set_t *myprivs = priv_allocset();

	if (myprivs == NULL) {

		rad_log(RL_ERROR, "failed to allocate privilege set");

		return (B_FALSE);

	}

	/* Could handle this "gracefully", but it isn't supposed to fail */

	if (getppriv(PRIV_PERMITTED, myprivs) == -1)

		rad_log(RL_FATAL, "getppriv(PRIV_PERMITTED) failed: %s",

		    strerror(errno));

	if (uc == NULL ||

	    ucred_geteuid(uc) != getuid() ||

	    ucred_getzoneid(uc) != getzoneid() ||

	    (theirprivs = ucred_getprivset(uc, PRIV_EFFECTIVE)) == NULL ||

	    !priv_issubset(myprivs, theirprivs)) {

		priv_freeset(myprivs);

		rad_log(RL_WARN, "unprivileged client (uid=%d) "

		    "attempted connection to control port", ucred_geteuid(uc));

		return (B_FALSE);

	}

	priv_freeset(myprivs);

	return (B_TRUE);

}

static void

unix_run(void *arg)

{

	radmod_connection_t *conn = arg;

	rad_proto_handle(conn);

	rad_conn_free(conn);

}

static rad_moderr_t

unix_listen(rad_thread_t *arg)

{

	data_t *data = rad_thread_arg(arg);

	int fd;

	data_t *d, *path = struct_get(data, "path");

	d = struct_get(data, "proto");

	const char *protostr = d != NULL ? data_to_string(d) : "rad";

	d = struct_get(data, "control");

	boolean_t control = d != NULL ? data_to_boolean(d) : B_FALSE;

	d = struct_get(data, "peercred");

	boolean_t peercred = d != NULL ? data_to_boolean(d) : B_TRUE;

	rad_protocol_t *proto = rad_proto_find(protostr);

	if (proto == NULL) {

		rad_log(RL_ERROR, "Unable to find protocol \"%s\".", protostr);

		return (rm_config);

	}

	if ((fd = listen_on_name(data_to_string(path))) < 0) {

		rad_log(RL_ERROR, "Error starting AF_UNIX server: %s",

		    strerror(errno));

		return (rm_system);

	}

	rad_thread_ack(arg, rm_ok);

	for (;;) {

		int afd;

		rad_log(RL_DEBUG, "Waiting for connection.\n");

		if ((afd = accept(fd, 0, 0)) == -1) {

			rad_log(RL_WARN, "Error in accept(): %s\n",

			    strerror(errno));

			continue;

		}

		rad_log(RL_DEBUG, "Connection accepted.\n");

		/* subject allocation failure and missing ucred are conflated */

		rad_subject_t *subject = peercred ? rad_subject_create_fd(afd) :

		    NULL;

		if (control) {

			if (subject == NULL) {

				(void) close(afd);

				continue;

			}

			if (!sent_by_joe(subject->rs_ucred)) {

				rad_subject_unref(subject);

				(void) close(afd);

				continue;

			}

			rad_log(RL_DEBUG,

			    "accepting connection on control port");

			subject->rs_control = B_TRUE;

		}

		adr_stream_t *stream = adr_stream_create_fd(afd);

		if (stream == NULL)

			continue;

		radmod_connection_t *conn = rad_conn_create_fd(afd, B_TRUE);

		if (conn == NULL) {

			adr_stream_close(stream);

			adr_stream_free(stream);

			rad_log(RL_WARN, "failed to allocate connection");

			continue;

		}

		conn->rm_conn_xport = stream;

		conn->rm_conn_proto_ops = proto;

		if (subject != NULL &&

		    !rad_conn_setsubject(conn, subject, ADT_login)) {

			rad_conn_close(conn);

			rad_conn_free(conn);

			rad_log(RL_WARN, "failed to set connection subject");

			continue;

		}

		if (rad_thread_create_async(unix_run, conn) != rm_ok) {

			rad_conn_close(conn);

			rad_conn_free(conn);

		}

	}

}

static rad_moderr_t

starter(data_t *data)

{

	data_t *path = struct_get(data, "path");

	if (path == NULL) {

		rad_log(RL_ERROR, "Unix domain socket requires path\n");

		return (rm_config);

	}

	return (rad_thread_create(unix_listen, data));

}

static rad_modinfo_t modinfo = {

	"xport_unix", "unix domain socket transport module",

};

int

_rad_init(void *handle)

{

	if (rad_module_register(handle, RAD_MODVERSION, &modinfo) == -1)

		return (-1);

	rad_xport_register("unix", &t__unix, starter);

	return (0);

}