/* LWIP service - lwip.c - main program and dispatch code */

#include "lwip.h"
#include "tcpisn.h"
#include "mcast.h"
#include "ethif.h"
#include "rtsock.h"
#include "route.h"
#include "bpfdev.h"

#include "lwip/init.h"
#include "lwip/sys.h"
#include "lwip/timeouts.h"
#include "arch/cc.h"

static int running, recheck_timer;
static minix_timer_t lwip_timer;

static void expire_lwip_timer(int);

/*
 * Return the system uptime in milliseconds.  Also remember that lwIP retrieved
 * the system uptime during this call, so that we know to check for timer
 * updates at the end of the current iteration of the message loop.
 */
uint32_t
sys_now(void)
{

	recheck_timer = TRUE;

	/* TODO: avoid 64-bit arithmetic if possible. */
	return (uint32_t)(((uint64_t)getticks() * 1000) / sys_hz());
}

/*
 * Check if and when lwIP has its next timeout, and set or cancel our timer
 * accordingly.
 */
static void
set_lwip_timer(void)
{
	uint32_t next_timeout;
	clock_t ticks;

	/* Ask lwIP when the next alarm is supposed to go off, if any. */
	next_timeout = sys_timeouts_sleeptime();

	/*
	 * Set or update the lwIP timer.  We rely on set_timer() asking the
	 * kernel for an alarm only if the timeout is different from the one we
	 * gave it last time (if at all).  However, due to conversions between
	 * absolute and relative times, and the fact that we cannot guarantee
	 * that the uptime itself does not change while executing these
	 * routines, set_timer() will sometimes be issuing a kernel call even
	 * if the alarm has not changed.  Not a huge deal, but fixing this will
	 * require a different interface to lwIP and/or the timers library.
	 */
	if (next_timeout != (uint32_t)-1) {
		/*
		 * Round up the next timeout (which is in milliseconds) to the
		 * number of clock ticks to add to the current time.  Avoid any
		 * potential for overflows, no matter how unrealistic..
		 */
		if (next_timeout > TMRDIFF_MAX / sys_hz())
			ticks = TMRDIFF_MAX;
		else
			ticks = (next_timeout * sys_hz() + 999) / 1000;

		set_timer(&lwip_timer, ticks, expire_lwip_timer, 0 /*unused*/);
	} else
		cancel_timer(&lwip_timer);	/* not really needed.. */
}

/*
 * The timer for lwIP timeouts has gone off.  Check timeouts, and possibly set
 * a new timer.
 */
static void
expire_lwip_timer(int arg __unused)
{

	/* Let lwIP do its work. */
	sys_check_timeouts();

	/*
	 * See if we have to update our timer for the next lwIP timer.  Doing
	 * this here, rather than from the main loop, avoids one kernel call.
	 */
	set_lwip_timer();

	recheck_timer = FALSE;
}

/*
 * Check whether we should adjust our local timer based on a change in the next
 * lwIP timeout.
 */
static void
check_lwip_timer(void)
{

	/*
	 * We make the assumption that whenever lwIP starts a timer, it will
	 * need to retrieve the current time.  Thus, whenever sys_now() is
	 * called, we set the 'recheck_timer' flag.  Here, we check whether to
	 * (re)set our lwIP timer only if the flag is set.  As a result, we do
	 * not have to mess with timers for literally every incoming message.
	 *
	 * When lwIP stops a timer, it does not call sys_now(), and thus, we
	 * may miss such updates.  However, timers being stopped should be rare
	 * and getting too many alarm messages is not a big deal.
	 */
	if (!recheck_timer)
		return;

	set_lwip_timer();

	/* Reset the flag for the next message loop iteration. */
	recheck_timer = FALSE;
}

/*
 * Return a random number, for use by lwIP.
 */
uint32_t
lwip_hook_rand(void)
{

	/*
	 * The current known uses of this hook are for selection of initial
	 * TCP/UDP port numbers and for multicast-related timer randomness.
	 * The former case exists only to avoid picking the same starting port
	 * numbers after a reboot.  After that, simple sequential iteration of
	 * the port numbers is used.  The latter case varies the response time
	 * for sending multicast messages.  Thus, none of the current uses of
	 * this function require proper randomness, and so we use the simplest
	 * approach, with time-based initialization to cover the reboot case.
	 * The sequential port number selection could be improved upon, but
	 * such an extension would probably bypass this hook anyway.
	 */
	return lrand48();
}

/*
 * Create a new socket, with the given domain, type, and protocol, for the user
 * process identified by 'user_endpt'.  On success, return the new socket's
 * identifier, with the libsockevent socket stored in 'sock' and an operations
 * table stored in 'ops'.  On failure, return a negative error code.
 */
static sockid_t
alloc_socket(int domain, int type, int protocol, endpoint_t user_endpt,
	struct sock ** sock, const struct sockevent_ops **ops)
{

	switch (domain) {
	case PF_INET:
#ifdef INET6
	case PF_INET6:
#endif /* INET6 */
		switch (type) {
		case SOCK_STREAM:
			return tcpsock_socket(domain, protocol, sock, ops);

		case SOCK_DGRAM:
			return udpsock_socket(domain, protocol, sock, ops);

		case SOCK_RAW:
			if (!util_is_root(user_endpt))
				return EACCES;

			return rawsock_socket(domain, protocol, sock, ops);

		default:
			return EPROTOTYPE;
		}

	case PF_ROUTE:
		return rtsock_socket(type, protocol, sock, ops);

	case PF_LINK:
		return lnksock_socket(type, protocol, sock, ops);

	default:
		/* This means that the service has been misconfigured. */
		printf("socket() with unsupported domain %d\n", domain);

		return EAFNOSUPPORT;
	}
}

/*
 * Initialize the service.
 */
static int
init(int type __unused, sef_init_info_t * init __unused)
{

	/*
	 * Initialize the random number seed.  See the lwip_hook_rand() comment
	 * on why this weak random number source is currently sufficient.
	 */
	srand48(clock_time(NULL));

	/* Initialize the lwIP library. */
	lwip_init();

	/* Initialize the socket events library. */
	sockevent_init(alloc_socket);

	/* Initialize various helper modules. */
	mempool_init();
	tcpisn_init();
	mcast_init();

	/* Initialize the high-level socket modules. */
	ipsock_init();
	tcpsock_init();
	udpsock_init();
	rawsock_init();

	/* Initialize the various network interface modules. */
	ifdev_init();
	loopif_init();
	ethif_init();

	/* Initialize the network device driver module. */
	ndev_init();

	/* Initialize the low-level socket modules. */
	rtsock_init();
	lnksock_init();

	/* Initialize the routing module. */
	route_init();

	/* Initialize other device modules. */
	bpfdev_init();

	/*
	 * Initialize the MIB module, after all other modules have registered
	 * their subtrees with this module.
	 */
	mibtree_init();

	/*
	 * After everything else has been initialized, set up the default
	 * configuration - in particular, a loopback interface.
	 */
	ifconf_init();

	/*
	 * Initialize the master timer for all the lwIP timers.  Just in case
	 * lwIP starts a timer right away, perform a first check upon entry of
	 * the message loop.
	 */
	init_timer(&lwip_timer);

	recheck_timer = TRUE;

	running = TRUE;

	return OK;
}

/*
 * Perform initialization using the System Event Framework (SEF).
 */
static void
startup(void)
{

	sef_setcb_init_fresh(init);
	/*
	 * This service requires stateless restarts, in that several parts of
	 * the system (including VFS and drivers) expect that if restarted,
	 * this service comes back up with a new endpoint.  Therefore, do not
	 * set a _restart callback here.
	 *
	 * TODO: support for live update.
	 *
	 * TODO: support for immediate shutdown if no sockets are in use, as
	 * also done by UDS.  For now, we never shut down immediately, giving
	 * other processes the opportunity to close sockets on system shutdown.
	 */

	sef_startup();
}

/*
 * The lwIP-based TCP/IP sockets driver.
 */
int
main(void)
{
	message m;
	int r, ipc_status;

	startup();

	while (running) {
		/*
		 * For various reasons, the loopback interface does not pass
		 * packets back into the stack right away.  Instead, it queues
		 * them up for later processing.  We do that processing here.
		 */
		ifdev_poll();

		/*
		 * Unfortunately, lwIP does not tell us when it starts or stops
		 * timers.  This means that we have to check ourselves every
		 * time we have called into lwIP.  For simplicity, we perform
		 * the check here.
		 */
		check_lwip_timer();

		if ((r = sef_receive_status(ANY, &m, &ipc_status)) != OK) {
			if (r == EINTR)
				continue;	/* sef_cancel() was called */

			panic("sef_receive_status failed: %d", r);
		}

		/* Process the received message. */
		if (is_ipc_notify(ipc_status)) {
			switch (m.m_source) {
			case CLOCK:
				expire_timers(m.m_notify.timestamp);

				break;

			case DS_PROC_NR:
				/* Network drivers went up and/or down. */
				ndev_check();

				break;

			default:
				printf("unexpected notify from %d\n",
				    m.m_source);
			}

			continue;
		}

		switch (m.m_source) {
		case MIB_PROC_NR:
			rmib_process(&m, ipc_status);

			break;

		case VFS_PROC_NR:
			/* Is this a socket device request? */
			if (IS_SDEV_RQ(m.m_type)) {
				sockevent_process(&m, ipc_status);

				break;
			}

			/* Is this a character (or block) device request? */
			if (IS_CDEV_RQ(m.m_type) || IS_BDEV_RQ(m.m_type)) {
				bpfdev_process(&m, ipc_status);

				break;
			}

			/* FALLTHROUGH */
		default:
			/* Is this a network device driver response? */
			if (IS_NDEV_RS(m.m_type)) {
				ndev_process(&m, ipc_status);

				break;
			}

			printf("unexpected message %d from %d\n",
			    m.m_type, m.m_source);
		}
	}

	return 0;
}