/*

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

 */

#include <sys/types.h>

#include <sys/socket.h>

#include <sys/sysmacros.h>

#include <sys/fm/protocol.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <strings.h>

#include <unistd.h>

#include <pthread.h>

#include <alloca.h>

#include <fcntl.h>

#include <errno.h>

#include <netdb.h>

#include <poll.h>

#include <stdarg.h>

#include <fm/fmd_api.h>

#define	IP_MAGIC	"\177FMA" /* magic string identifying a packet header */

#define	IP_MAGLEN	4	/* length of magic string */

#define	IP_DEBUG_OFF	0	/* No informational debugging printed */

#define	IP_DEBUG_FINE	1	/* Basic debug information printed (default) */

#define	IP_DEBUG_FINER	2	/* More debug information printed. */

#define	IP_DEBUG_FINEST	3	/* All debug information printed */

typedef struct ip_hdr {

	char iph_magic[IP_MAGLEN]; /* magic string */

	uint32_t iph_size;	/* packed size */

} ip_hdr_t;

typedef struct ip_buf {

	void *ipb_buf;		/* data buffer */

	size_t ipb_size;	/* size of buffer */

} ip_buf_t;

} ip_cinfo_t;

typedef struct ip_xprt {

	fmd_xprt_t *ipx_xprt;	/* transport handle */

	int ipx_flags;		/* transport flags */

	int ipx_fd;		/* socket file descriptor */

	int ipx_done;		/* flag indicating connection closed */

	pthread_t ipx_tid;	/* recv-side auxiliary thread */

	ip_buf_t ipx_sndbuf;	/* buffer for sending events */

	ip_buf_t ipx_rcvbuf;	/* buffer for receiving events */

	ip_cinfo_t *ipx_cinfo;	/* info for reconnect */

	char *ipx_addr;		/* address:port of remote connection */

	struct ip_xprt *ipx_next;	/* next ip_xprt in global list */

} ip_xprt_t;

typedef struct ip_stat {

	fmd_stat_t ips_accfail;	/* failed accepts */

	fmd_stat_t ips_badmagic; /* invalid packet headers */

	fmd_stat_t ips_packfail; /* failed packs */

	fmd_stat_t ips_unpackfail; /* failed unpacks */

} ip_stat_t;

static void ip_xprt_create(fmd_xprt_t *, int, int, ip_cinfo_t *, char *);

static void ip_xprt_destroy(ip_xprt_t *);

static ip_stat_t ip_stat = {

	{ "accfail", FMD_TYPE_UINT64, "failed accepts" },

	{ "badmagic", FMD_TYPE_UINT64, "invalid packet headers" },

	{ "packfail", FMD_TYPE_UINT64, "failed packs" },

	{ "unpackfail", FMD_TYPE_UINT64, "failed unpacks" },

};

static fmd_hdl_t *ip_hdl;	/* module handle */

static pthread_mutex_t ip_lock;	/* lock for ip_xps list */

static ip_xprt_t *ip_xps;	/* list of active transports */

static nvlist_t *ip_auth;	/* authority to use for transport(s) */

static size_t ip_size;		/* default buffer size */

static volatile int ip_quit;	/* signal to quit */

static int ip_qlen;		/* queue length for listen(3SOCKET) */

static int ip_mtbf;		/* mtbf for simulating packet drop */

static int ip_external;		/* set transport to be "external" */

static int ip_no_remote_repair;	/* disallow remote repair */

static int ip_hconly;		/* only cache faults that are hc-scheme */

static int ip_rdonly;		/* force transport to be rdonly */

static int ip_hc_present_only;	/* only cache faults if hc-scheme and present */

static char *ip_domain_name;	/* set domain name for received list.suspects */

static hrtime_t ip_burp;	/* make mtbf slower by adding this much delay */

static int ip_translate;	/* call fmd_xprt_translate() before sending */

static char *ip_port;		/* port to connect to (or bind to if server) */

static int ip_retry;		/* retry count for ip_xprt_setup() -1=forever */

static hrtime_t ip_sleep;	/* sleep delay for ip_xprt_setup() */

static int ip_debug_level;	/* level for printing debug messages */

/*

 * Prints a debug message to the fmd debug framework if the debug level is set

 * to at least the given level.

 */

static void

ip_debug(int level, char *fmt, ...)

{

	if (ip_debug_level >= level) {

		va_list args;

		va_start(args, fmt);

		fmd_hdl_vdebug(ip_hdl, fmt, args);

		va_end(args);

	}

}

/*

 * Allocate space in ipx_sndbuf for a header and a packed XDR encoding of

 * the specified nvlist, and then send the buffer to our remote peer.

 */

static int

ip_fmdo_send(fmd_hdl_t *hdl, fmd_xprt_t *xp, fmd_event_t *ep, nvlist_t *nvl)

{

	ip_xprt_t *ipx;

	size_t size, nvsize;

	char *buf, *nvbuf;

	ip_hdr_t *iph;

	ssize_t r, n;

	int err;

	if (xp == NULL) {

		ip_debug(IP_DEBUG_FINE, "ip_fmdo_send failed: xp=NULL\n");

		return (FMD_SEND_FAILED);

	}

	ipx = fmd_xprt_getspecific(hdl, xp);

	/*

	 * For testing purposes, if ip_mtbf is non-zero, use this to pseudo-

	 * randomly simulate the need for retries.  If ip_burp is also set,

	 * then we also suspend the transport for a bit and wake it up again.

	 */

	if (ip_mtbf != 0 && gethrtime() % ip_mtbf == 0) {

		if (ip_burp != 0) {

			ip_debug(IP_DEBUG_FINE, "burping ipx %s", IPX_ID(ipx));

			ipx->ipx_flags |= FMD_XPRT_SUSPENDED;

			fmd_xprt_suspend(ip_hdl, xp);

		}

		return (FMD_SEND_RETRY);

	}

	if (ip_translate && (nvl = fmd_xprt_translate(hdl, xp, ep)) == NULL) {

		fmd_hdl_error(hdl, "failed to translate event %p", (void *)ep);

		return (FMD_SEND_FAILED);

	}

	(void) nvlist_size(nvl, &nvsize, NV_ENCODE_XDR);

	size = r = sizeof (ip_hdr_t) + nvsize;

	if (ipx->ipx_sndbuf.ipb_size < size) {

		fmd_hdl_free(hdl, ipx->ipx_sndbuf.ipb_buf,

		    ipx->ipx_sndbuf.ipb_size);

		ipx->ipx_sndbuf.ipb_size = P2ROUNDUP(size, 16);

		ipx->ipx_sndbuf.ipb_buf = fmd_hdl_alloc(hdl,

		    ipx->ipx_sndbuf.ipb_size, FMD_SLEEP);

	}

	buf = ipx->ipx_sndbuf.ipb_buf;

	iph = (ip_hdr_t *)(uintptr_t)buf;

	nvbuf = buf + sizeof (ip_hdr_t);

	bcopy(IP_MAGIC, iph->iph_magic, IP_MAGLEN);

	iph->iph_size = htonl(nvsize);

	err = nvlist_pack(nvl, &nvbuf, &nvsize, NV_ENCODE_XDR, 0);

	if (ip_translate)

		nvlist_free(nvl);

	if (err != 0) {

		fmd_hdl_error(ip_hdl, "failed to pack event for "

		    "transport %p: %s\n", (void *)ipx->ipx_xprt, strerror(err));

		ip_stat.ips_packfail.fmds_value.ui64++;

		return (FMD_SEND_FAILED);

	}

	while (!ip_quit && r != 0) {

		if ((n = send(ipx->ipx_fd, buf, r, 0)) < 0) {

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

				ip_debug(IP_DEBUG_FINE,

				    "failed to send to %s", IPX_ID(ipx));

				return (FMD_SEND_FAILED);

			}

			continue;

		}

		buf += n;

		r -= n;

	}

	ip_debug(IP_DEBUG_FINEST, "Sent event %d bytes to %s",

	    size, IPX_ID(ipx));

	return (FMD_SEND_SUCCESS);

}

/*

 * Sends events over transports that are configured read only.  When the module

 * is in read only mode it will receive all events and only send events that

 * have a subscription set.

 *

 * The configuration file will have to set prop ip_rdonly true and also

 * subscribe for events that are desired to be sent over the transport in order

 * for this function to be used.

 */

/* ARGSUSED */

static void

ip_fmdo_recv(fmd_hdl_t *hdl, fmd_event_t *ep, nvlist_t *nvl, const char *class)

{

	int err;

	ip_xprt_t *ipx;

		(void) pthread_mutex_lock(&ip_lock);

		for (ipx = ip_xps; ipx != NULL; ipx = ipx->ipx_next) {

			err = ip_fmdo_send(hdl, ipx->ipx_xprt, ep, nvl);

			while (FMD_SEND_RETRY == err) {

				err = ip_fmdo_send(hdl, ipx->ipx_xprt, ep, nvl);

			}

		}

		(void) pthread_mutex_unlock(&ip_lock);

	}

}

/*

 * Receive a chunk of data of the specified size from our remote peer.  The

 * data is received into ipx_rcvbuf, and then a pointer to the buffer is

 * returned.  NOTE: The data is only valid until the next call to ip_xprt_recv.

 * If the connection breaks or ip_quit is set during receive, NULL is returned.

 */

static void *

ip_xprt_recv(ip_xprt_t *ipx, size_t size)

{

	char *buf = ipx->ipx_rcvbuf.ipb_buf;

	ssize_t n, r = size;

	if (ipx->ipx_rcvbuf.ipb_size < size) {

		fmd_hdl_free(ip_hdl, ipx->ipx_rcvbuf.ipb_buf,

		    ipx->ipx_rcvbuf.ipb_size);

		ipx->ipx_rcvbuf.ipb_size = P2ROUNDUP(size, 16);

		ipx->ipx_rcvbuf.ipb_buf = buf = fmd_hdl_alloc(ip_hdl,

		    ipx->ipx_rcvbuf.ipb_size, FMD_SLEEP);

	}

	while (!ip_quit && r != 0) {

		if ((n = recv(ipx->ipx_fd, buf, r, MSG_WAITALL)) == 0) {

			ipx->ipx_done++;

			return (NULL);

		}

		if (n < 0) {

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

				ip_debug(IP_DEBUG_FINE,

				    "failed to recv on ipx %s", IPX_ID(ipx));

			}

			continue;

		}

		/* Reset retry counter after a successful connection */

		if (ipx->ipx_cinfo) {

		}

		buf += n;

		r -= n;

	}

	return (r ? NULL: ipx->ipx_rcvbuf.ipb_buf);

}

/*

 * Sets the address/port of the remote connection in the connection info struct

 * This is called after a TCP session has been set up with a known remote

 * address (sap)

 */

static void

ip_xprt_set_addr(ip_xprt_t *ipx, const struct sockaddr *sap)

{

	const struct sockaddr_in6 *sin6 = (const void *)sap;

	const struct sockaddr_in *sin = (const void *)sap;

	char buf[INET6_ADDRSTRLEN + 16];

	struct in_addr v4addr;

	in_port_t port;

	int n;

	ip_debug(IP_DEBUG_FINER, "Enter ip_xprt_set_addr");

	if (sap->sa_family == AF_INET6 &&

	    IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {

		IN6_V4MAPPED_TO_INADDR(&sin6->sin6_addr, &v4addr);

		(void) inet_ntop(AF_INET, &v4addr, buf, sizeof (buf));

		port = ntohs(sin6->sin6_port);

	} else if (sap->sa_family == AF_INET6) {

		(void) inet_ntop(AF_INET6, &sin6->sin6_addr, buf, sizeof (buf));

		port = ntohs(sin6->sin6_port);

	} else {

		(void) inet_ntop(AF_INET, &sin->sin_addr, buf, sizeof (buf));

		port = ntohs(sin->sin_port);

	}

	n = strlen(buf);

	(void) snprintf(buf + n, sizeof (buf) - n, ":%u", port);

	if (ipx->ipx_addr)

		fmd_hdl_strfree(ip_hdl, ipx->ipx_addr);

	ipx->ipx_addr = fmd_hdl_strdup(ip_hdl, buf, FMD_SLEEP);

	ip_debug(IP_DEBUG_FINE, "connection addr is %s on %p",

	    ipx->ipx_addr, (void *)ipx);

}

static nvlist_t *

ip_xprt_auth(ip_xprt_t *ipx)

{

	nvlist_t *nvl;

	int err;

	ip_debug(IP_DEBUG_FINER, "Enter ip_xprt_auth");

	if (ip_auth != NULL)

		err = nvlist_dup(ip_auth, &nvl, 0);

	else

		err = nvlist_alloc(&nvl, 0, 0);

	if (err != 0) {

		fmd_hdl_abort(ip_hdl, "failed to create nvlist for "

		    "authority: %s\n", strerror(err));

	}

	if (ip_auth != NULL)

		return (nvl);

	ip_debug(IP_DEBUG_FINE, "ip_authority %s=%s\n",

	    FM_FMRI_AUTH_SERVER, ipx->ipx_addr);

	(void) nvlist_add_uint8(nvl, FM_VERSION, FM_FMRI_AUTH_VERSION);

	(void) nvlist_add_string(nvl, FM_FMRI_AUTH_SERVER, ipx->ipx_addr);

	return (nvl);

}

static void

ip_xprt_accept(ip_xprt_t *ipx)

{

	struct sockaddr_storage sa;

	socklen_t salen = sizeof (sa);

	fmd_xprt_t *xp;

	int fd;

	ip_debug(IP_DEBUG_FINER, "Enter ip_xprt_accept");

	if ((fd = accept(ipx->ipx_fd, (struct sockaddr *)&sa, &salen)) == -1) {

		fmd_hdl_error(ip_hdl, "failed to accept connection");

		ip_stat.ips_accfail.fmds_value.ui64++;

		return;

	}

	ip_debug(IP_DEBUG_FINE, "Accepted socket on fd %d", fd);

	ip_xprt_set_addr(ipx, (struct sockaddr *)&sa);

	xp = fmd_xprt_open(ip_hdl, ipx->ipx_flags,

	    ip_xprt_auth(ipx), NULL);

}

static void

ip_xprt_recv_event(ip_xprt_t *ipx)

{

	ip_hdr_t *iph;

	nvlist_t *nvl;

	size_t size;

	void *buf;

	int err;

	if ((iph = ip_xprt_recv(ipx, sizeof (ip_hdr_t))) == NULL)

		return; /* connection broken */

	if (bcmp(iph->iph_magic, IP_MAGIC, IP_MAGLEN) != 0) {

		fmd_hdl_error(ip_hdl,

		    "invalid hdr magic %x.%x.%x.%x from transport %s\n",

		    iph->iph_magic[0], iph->iph_magic[1], iph->iph_magic[2],

		    iph->iph_magic[3], IPX_ID(ipx));

		ip_stat.ips_badmagic.fmds_value.ui64++;

		return;

	}

	size = ntohl(iph->iph_size);

	if ((buf = ip_xprt_recv(ipx, size)) == NULL)

		return; /* connection broken */

	if ((err = nvlist_unpack(buf, size, &nvl, 0)) != 0) {

		fmd_hdl_error(ip_hdl, "failed to unpack event from "

		    "transport %s: %s\n",

		    IPX_ID(ipx), strerror(err));

		ip_stat.ips_unpackfail.fmds_value.ui64++;

	} else {

		if (ip_domain_name)

			fmd_xprt_add_domain(ip_hdl, nvl, ip_domain_name);

		fmd_xprt_post(ip_hdl, ipx->ipx_xprt, nvl, 0);

	}

	if (fmd_xprt_error(ip_hdl, ipx->ipx_xprt)) {

		fmd_hdl_error(ip_hdl, "protocol error on transport %p",

		    (void *)ipx->ipx_xprt);

		ipx->ipx_done++;

	}

	ip_debug(IP_DEBUG_FINEST, "Recv event %d bytes from %s",

	    size, IPX_ID(ipx));

}

static void

ip_xprt_thread(void *arg)

{

	ip_xprt_t *ipx = arg;

	struct sockaddr_storage sa;

	socklen_t salen = sizeof (sa);

	struct pollfd pfd;

	ip_debug(IP_DEBUG_FINER, "Enter ip_xprt_thread");

	while (!ip_quit && !ipx->ipx_done) {

		if (ipx->ipx_xprt != NULL || (ipx->ipx_flags & FMD_XPRT_ACCEPT))

			pfd.events = POLLIN;

		else

			pfd.events = POLLOUT;

		pfd.fd = ipx->ipx_fd;

		pfd.revents = 0;

		if (poll(&pfd, 1, -1) <= 0)

			continue; /* loop around and check ip_quit */

		if (pfd.revents & (POLLHUP | POLLERR)) {

			ip_debug(IP_DEBUG_FINE, "hangup fd %d\n", ipx->ipx_fd);

			break;

		}

		if (pfd.revents & POLLOUT) {

			/*

			 * Once we're connected, there's no reason to have our

			 * calls to recv() and send() be non-blocking since we

			 * we have separate threads for each: clear O_NONBLOCK.

			 */

			(void) fcntl(ipx->ipx_fd, F_SETFL,

			    fcntl(ipx->ipx_fd, F_GETFL, 0) & ~O_NONBLOCK);

			if (getpeername(ipx->ipx_fd, (struct sockaddr *)&sa,

			    &salen) != 0) {

				bzero(&sa, sizeof (sa));

				break;

			}

			ip_xprt_set_addr(ipx, (struct sockaddr *)&sa);

			ipx->ipx_xprt = fmd_xprt_open(ip_hdl, ipx->ipx_flags,

			    ip_xprt_auth(ipx), ipx);

			ip_debug(IP_DEBUG_FINE, "connect fd %d ipx %p",

			    ipx->ipx_fd, (void *)ipx);

			continue;

		}

		if (pfd.revents & POLLIN) {

			if (ipx->ipx_xprt == NULL)

				ip_xprt_accept(ipx);

			else

				ip_xprt_recv_event(ipx);

		}

	}