/*

 * 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 (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.

 */

/*

 * The zone proxy daemon and zone proxy client.

 *

 * For package operations in zones, the system must make available a certain

 * group of publishers and repositories to client zones.  This ensures that data

 * necessary for installing or updating a zone is always available to zones

 * consumers, regardless of the exact network configuration within the local

 * zone.  In order to accomplish this, the proxy daemon and proxy client provide

 * a TCP proxy to a special repository that is maintained in the global zone.

 *

 * The zone-proxy client is responsible for creating a listening TCP socket in a

 * pre-determined location, and then passing control of that socket to the proxy

 * daemon.  Once the proxy client has completed this hand-off, it sleeps in the

 * local zone, waiting for notification of any changes in the global zone.  If

 * the proxy daemon exits, or is re-configured, the proxy client creates a new

 * socket, and the process is repeated.

 *

 * The proxy daemon listens on the sockets passed to it by the proxy client, and

 * when it gets a new connection, establishes a connection to the zones

 * repository that serves packaging information.  The proxy daemon and client

 * pass information through a door.  The daemon also listens for notifications

 * about zone startup and shutdown on the door.  (zoneadmd, knows to poke the

 * daemon when zones are created or destroyed).  When a zone is created, the

 * proxy daemon enters the zone, and creates a new door there, so that the

 * client and daemon can rendezvous.  The proxy daemon manages a pool of thread

 * workers for handling network connections, and has some door callbacks to

 * manage a pool of IPC threads.

 *

 * Each new connection generates a pair of sockets.  The data transfer algorithm

 * here is lockless, and depends upon event ports as the polling mechanism.  The

 * socket is dup'd, and one is always used for reading, and the other always

 * used for writing.  As long as no thread reads and writes the same fd,

 * operation is atomic, and correct.  When a thread needs data, the event

 * mechanism is used either to wait for data, or to wait to write data.

 * Although each proxy connection has a buffer, we try our best to drain that

 * buffer ASAP, especially before getting more data.

 */

#include <alloca.h>

#include <atomic.h>

#include <door.h>

#include <errno.h>

#include <fcntl.h>

#include <libcontract.h>

#include <libscf.h>

#include <limits.h>

#include <netdb.h>

#include <port.h>

#include <priv.h>

#include <pthread.h>

#include <synch.h>

#include <signal.h>

#include <stddef.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stropts.h>

#include <thread.h>

#include <ucred.h>

#include <unistd.h>

#include <zone.h>

#include <zoneproxy_impl.h>

#include <sys/ctfs.h>

#include <sys/contract/process.h>

#include <sys/queue.h>

#include <sys/resource.h>

#include <sys/socket.h>

#include <sys/stat.h>

#include <sys/sysmacros.h>

#include <sys/types.h>

#include <sys/wait.h>

#define	PROXY_THREAD_DEFAULT		8

#define	PROXY_THREAD_MAX		20

#define	DOOR_THREAD_MAX			5

#define	DEFAULT_LOCK_ALIGN		64

#define	DEFAULT_TIMEOUT			30

#define	TIMEOUT_COUNT			4

#define	MAX_FDS_DEFAULT			6000

#define	SYSREPO_FMRI    "svc:/application/pkg/system-repository:default"

#define	SYSREPO_PG      "config"

#define	SYSREPO_HOST    "host"

#define	SYSREPO_PORT    "port"

#define	DEFAULT_HOST	"127.0.0.1"

#define	DEFAULT_PORT	"1008"

#define	BUFFER_SIZ		8168

#define	CONF_STR_SZ		2048

typedef enum {

	PROXY_USER_GENERIC = 0,

	PROXY_USER_LISTENER,

	PROXY_USER_PAIR,

	PROXY_USER_END

} pu_type_t;

typedef enum {

	PROXY_STATE_INIT = 0,

	PROXY_STATE_WAIT_CONNECT,

	PROXY_STATE_WAIT_DATA,

	PROXY_STATE_CLOSING,

	PROXY_STATE_FREED,

	PROXY_STATE_END

} proxy_state_t;

/* structure definitions */

struct proxy_user {

	pu_type_t	pu_type;

	void		(*pu_callback)(struct proxy_user *, port_event_t *);

};

struct proxy_listener {

	pu_type_t	pl_type;

	void		(*pl_callback)(struct proxy_listener *, port_event_t *);

	TAILQ_ENTRY(proxy_listener) pl_list_link;

	zoneid_t	pl_zid;

	int		pl_fd;

	mutex_t		pl_lock;

	boolean_t	pl_cleanup;

	int		pl_pipefd;

	int		pl_closefd;

	char		*pl_proxy_host;

	char		*pl_proxy_port;

	uint64_t	pl_gen;

};

struct proxy_pair {

	pu_type_t	pp_type;

	void		(*pp_callback)(struct proxy_pair *, port_event_t *);

	int		pp_readfd;

	int		pp_writefd;

	size_t		pp_fbcnt;

	proxy_state_t	pp_state;

	char		pp_buffer[BUFFER_SIZ];

};

struct proxy_config {

	mutex_t			pc_lock;

	scf_handle_t		*pc_hdl;

	scf_instance_t		*pc_inst;

	scf_propertygroup_t	*pc_pg;

	scf_property_t		*pc_prop;

	scf_value_t		*pc_val;

	char			*pc_proxy_host;

	char			*pc_proxy_port;

	uint64_t		pc_gen;

};

/* global variables */

int		g_port;

int		g_door;

int		g_pipe_fd;

int		g_max_door_thread = DOOR_THREAD_MAX;

int		g_door_thread_count = 0;

uint_t		g_proxy_pair_count = 0;

thread_key_t	g_thr_info_key;

mutex_t		*g_door_thr_lock;

mutex_t		*g_listener_lock;

mutex_t		*g_thr_pool_lock;

/* global variables protected by g_thr_pool_lock */

int		g_tp_running_threads;

int		g_tp_exited_threads;

int		g_tp_max_threads = PROXY_THREAD_MAX;

int		g_tp_min_threads = PROXY_THREAD_DEFAULT;

cond_t		g_thr_pool_cv = DEFAULTCV;

/* global variables shared between main thread and s_handler thread */

mutex_t		g_quit_lock = DEFAULTMUTEX;

cond_t		g_quit_cv = DEFAULTCV;

/* proxy config protected by internal lock */

struct proxy_config	*g_proxy_config;

boolean_t		g_config_smf;

TAILQ_HEAD(zq_queuehead, proxy_listener);

struct zq_queuehead	zone_listener_list;

static volatile boolean_t g_quit;

/* function declarations */

static struct proxy_listener *alloc_proxy_listener(void);

static struct proxy_pair *alloc_proxy_pair(void);

static int check_connect(struct proxy_pair *);

static int clone_and_register(struct proxy_pair *);

static void close_door_descs(door_desc_t *, uint_t);

static int close_on_exec(int);

static struct proxy_config *config_alloc(void);

static void config_free(struct proxy_config *);

static int config_read(struct proxy_config *);

static int contract_abandon_id(ctid_t);

static int contract_latest(ctid_t *);

static int contract_open(ctid_t, const char *, const char *, int);

static void daemonize_ready(char);

static int daemonize_start(void);

static int do_fattach(int, char *, boolean_t);

static void drop_privs(void);

static void escalate_privs(void);

static void fattach_all_zones(boolean_t);

static void free_proxy_listener(struct proxy_listener *);

static void free_proxy_pair(struct proxy_pair *);

static int init_template(void);

static void listen_func(struct proxy_listener *, port_event_t *);

static void proxy_func(struct proxy_pair *, port_event_t *);

static void *proxy_thread_loop(void *);

static void s_handler(void);

static int send_recv_data(struct proxy_pair *);

static void shutdown_proxypair(struct proxy_pair *);

static void thread_exiting(void *);

static void *thread_manager(void *);

static void usage(void);

static int zpd_add_listener(zoneid_t, int, int, int);

static void zpd_door_create_thread(door_info_t *);

static void *zpd_door_loop(void *);

static void zpd_door_server(void *, char *, size_t, door_desc_t *, uint_t);

static void zpd_fattach_zone(zoneid_t, int, boolean_t);

static struct proxy_listener *zpd_find_listener(zoneid_t);

static void zpd_listener_cleanup(struct proxy_listener *);

static int zpd_perm_check(int, zoneid_t);

static void zpd_remove_listener(struct proxy_listener *);

static int zpd_remove_zone(zoneid_t);

static void

usage(void)

{

	(void) fprintf(stderr, "Usage: zoneproxyd [-s host:port]\n");

	exit(EXIT_FAILURE);

}

static int

set_noblocking(int fd)

{

	int		flags;

	if ((flags = fcntl(fd, F_GETFL, 0)) < 0) {

		perror("fcntl (GETFL)");

		return (-1);

	}

	if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {

		perror("fcntl (SETFL)");

		return (-1);

	}

	return (0);

}

static struct proxy_listener *

alloc_proxy_listener(void)

{

	struct proxy_listener	*listener;

	listener = malloc(sizeof (struct proxy_listener));

	if (listener == NULL) {

		perror("malloc");

		return (NULL);

	}

	(void) memset(listener, 0, sizeof (struct proxy_listener));

	listener->pl_type = PROXY_USER_LISTENER;

	listener->pl_callback = listen_func;

	listener->pl_fd = -1;

	listener->pl_pipefd = -1;

	listener->pl_closefd = -1;

	listener->pl_cleanup = B_FALSE;

	if (mutex_init(&listener->pl_lock, USYNC_THREAD, NULL) < 0) {

		perror("mutex_init");

		return (NULL);

	}

	return (listener);

}

static struct proxy_pair *

alloc_proxy_pair(void)

{

	struct proxy_pair	*pair;

	pair = malloc(sizeof (struct proxy_pair));

	if (pair == NULL) {

		perror("malloc");

		return (NULL);

	}

	(void) memset(pair, 0, sizeof (struct proxy_pair));

	pair->pp_type = PROXY_USER_PAIR;

	pair->pp_callback = proxy_func;

	pair->pp_readfd = -1;

	pair->pp_writefd = -1;

	return (pair);

}

static void

free_proxy_listener(struct proxy_listener *listener)

{

	if (listener->pl_fd > -1) {

		if (close(listener->pl_fd) < 0) {

			perror("close");

			exit(EXIT_FAILURE);

		}

	}

	if (listener->pl_pipefd > -1) {

		if (close(listener->pl_pipefd) < 0) {

			perror("close");

			exit(EXIT_FAILURE);

		}

	}

	if (listener->pl_closefd > -1) {

		if (close(listener->pl_closefd) < 0) {

			perror("close");

			exit(EXIT_FAILURE);

		}

	}

	(void) mutex_destroy(&listener->pl_lock);

	free(listener->pl_proxy_host);

	free(listener->pl_proxy_port);

	free(listener);

}

static void

free_proxy_pair(struct proxy_pair *pair)

{

	if (pair->pp_readfd > -1) {

		if (close(pair->pp_readfd) < 0) {

			perror("close");

			exit(EXIT_FAILURE);

		}

	}

	if (pair->pp_writefd > -1) {

		if (close(pair->pp_writefd) < 0) {

			perror("close");

			exit(EXIT_FAILURE);

		}

	}

	pair->pp_state = PROXY_STATE_FREED;

	free(pair);

}

/*

 * Once a pair has been connected, dup the file descriptors, switching read and

 * write, so that both pair can be seperately queued for events.

 */

static int

clone_and_register(struct proxy_pair *pair)

{

	struct proxy_pair	*op_pair;

	int			fd;

	/* Allocate another proxy_pair object */

	op_pair = alloc_proxy_pair();

	if (op_pair == NULL) {

		return (-1);

	}

	/* Copy state */

	op_pair->pp_state = pair->pp_state;

	/* Dup fd's switching read for write */

	if ((fd = dup(pair->pp_readfd)) < 0) {

		perror("dup");

		free_proxy_pair(op_pair);

		return (-1);

	}

	op_pair->pp_writefd = fd;

	if ((fd = dup(pair->pp_writefd)) < 0) {

		perror("dup");

		free_proxy_pair(op_pair);

		return (-1);

	}

	op_pair->pp_readfd = fd;

	/* Register each pair to wait for input */

	if (port_associate(g_port, PORT_SOURCE_FD, op_pair->pp_readfd,

	    POLLIN, op_pair) < 0) {

		perror("port_associate");

		free_proxy_pair(op_pair);

		return (-1);

	}

	if (port_associate(g_port, PORT_SOURCE_FD, pair->pp_readfd,

	    POLLIN, pair) < 0) {

		perror("port_associate");

		return (-1);

	}

	/*

	 * Increment the proxy count by two, since there are two proxy-pair

	 * objects per connection, each representing one direction of the flow.

	 * The objects are shutdown separately, so each will decrment the

	 * count by one in its shutdown method.

	 */

	atomic_add_int(&g_proxy_pair_count, 2);

	/*

	 * Try to poke the thread manager.  If someone else is poking him, or

	 * he's already running, just return.  In the worst case the manager

	 * will double-check the number of threads after the timeout.

	 */

	if (mutex_trylock(g_thr_pool_lock) == 0) {

		(void) cond_signal(&g_thr_pool_cv);

		(void) mutex_unlock(g_thr_pool_lock);

	}

	return (0);

}

static void

shutdown_proxypair(struct proxy_pair *pair)

{

	(void) port_dissociate(g_port, PORT_SOURCE_FD, pair->pp_readfd);

	(void) port_dissociate(g_port, PORT_SOURCE_FD, pair->pp_writefd);

	if (pair->pp_fbcnt > 0)

		(void) write(pair->pp_writefd, pair->pp_buffer, pair->pp_fbcnt);

	(void) shutdown(pair->pp_readfd, SHUT_RD);

	(void) shutdown(pair->pp_writefd, SHUT_WR);

	free_proxy_pair(pair);

	atomic_dec_uint(&g_proxy_pair_count);

}

static int

send_recv_data(struct proxy_pair *pair)

{

	int	b_wr;

	int	b_rd;

	int	read_needed = 0;

	int	write_needed = 0;

	if (pair->pp_fbcnt == 0) /* need to read */ {

		b_rd = read(pair->pp_readfd, pair->pp_buffer, BUFFER_SIZ);

		if (b_rd < 0 && (errno == EAGAIN || errno == EWOULDBLOCK ||

		    errno == EINTR)) {

			b_rd = 0;

			read_needed = 1;

		} else if (b_rd <= 0) {

			return (-1);

		}

		pair->pp_fbcnt = b_rd;

	}

	if (pair->pp_fbcnt > 0) {

		b_wr = write(pair->pp_writefd, pair->pp_buffer, pair->pp_fbcnt);

		if (b_wr < 0) {

			if (errno != EAGAIN && errno != EWOULDBLOCK) {

				return (-1);

			}

			b_wr = 0;

		}

		if (b_wr < pair->pp_fbcnt) {

			if (b_wr != 0) {

				(void) memmove(pair->pp_buffer,

				    pair->pp_buffer + b_wr,

				    pair->pp_fbcnt - b_wr);

				pair->pp_fbcnt -= b_wr;

			}

			write_needed = 1;

			/* If the write side is slow, disable read here */

			read_needed = 0;

		} else {

			pair->pp_fbcnt = 0;

			read_needed = 1;

		}

	}

	if (read_needed) {

		if (port_associate(g_port, PORT_SOURCE_FD, pair->pp_readfd,

		    POLLIN, pair) < 0) {

			perror("port_associate");

			return (-1);

		}

	}

	if (write_needed) {

		if (port_associate(g_port, PORT_SOURCE_FD, pair->pp_writefd,

		    POLLOUT, pair) < 0) {

			perror("port_associate");

			return (-1);

		}

	}

	return (0);

}

static void *

proxy_thread_loop(void *arg)

{

	port_event_t ev;

	struct proxy_user *pu;

	int timeouts = 0;

	timespec_t tmot;

	boolean_t timed_out = B_FALSE;

	boolean_t should_exit = B_FALSE;

	for (;;) {

		tmot.tv_sec = DEFAULT_TIMEOUT;