/* $NetBSD: wsmoused.c,v 1.29 2022/05/20 21:31:24 andvar Exp $ */

/*
 * Copyright (c) 2002, 2003, 2004 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Julio M. Merino Vidal.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. The name authors may not be used to endorse or promote products
 *    derived from this software without specific prior written
 *    permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>

#ifndef lint
__COPYRIGHT("@(#) Copyright (c) 2002, 2003\
 The NetBSD Foundation, Inc.  All rights reserved.");
__RCSID("$NetBSD: wsmoused.c,v 1.29 2022/05/20 21:31:24 andvar Exp $");
#endif /* not lint */

#include <sys/ioctl.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/tty.h>
#include <dev/wscons/wsconsio.h>

#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>
#include <util.h>

#include "pathnames.h"
#include "wsmoused.h"

/* --------------------------------------------------------------------- */

/*
 * Global variables.
 */

static struct mouse Mouse;
static char *Pid_File = NULL;
static int Foreground = 1;
static int X_Console = -1;
static int X_Console_Delay = 5;

#ifdef WSMOUSED_ACTION_MODE
extern struct mode_bootstrap Action_Mode;
#endif
#ifdef WSMOUSED_SELECTION_MODE
extern struct mode_bootstrap Selection_Mode;
#endif

#define MAX_MODES 2
static struct mode_bootstrap *Modes[MAX_MODES];
static struct mode_bootstrap *Avail_Modes[] = {
#ifdef WSMOUSED_ACTION_MODE
	&Action_Mode,
#endif
#ifdef WSMOUSED_SELECTION_MODE
	&Selection_Mode,
#endif
};

/* --------------------------------------------------------------------- */

/*
 * Prototypes for functions private to this module.
 */

static void usage(void) __attribute__((__noreturn__));
static void open_device(unsigned int);
static void init_mouse(void);
static void event_loop(void);
static void generic_wscons_event(struct wscons_event);
static int  attach_mode(const char *);
static void attach_modes(char *);
static void detach_mode(const char *);
static void detach_modes(void);
static void signal_terminate(int);

static int debug;

/* --------------------------------------------------------------------- */

/* Shows program usage information and exits. */
static void
usage(void)
{

	(void)fprintf(stderr,
	    "usage: %s [-d device] [-f config_file] [-m modes] [-n]\n",
	    getprogname());
	exit(EXIT_FAILURE);
}

/* --------------------------------------------------------------------- */

/* Logs the given error message to syslog if running in daemon mode, or
 * to the console if running in the foreground. */
void
log_err(int e, const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	if (Foreground)
		verr(e, fmt, ap);
	else {
		int olderrno = errno;
		vsyslog(LOG_DAEMON | LOG_ERR, fmt, ap);
		errno = olderrno;
		syslog(LOG_DAEMON | LOG_ERR, "%m");
		exit(e);
	}
	/* NOTREACHED */
	va_end(ap);
}

/* --------------------------------------------------------------------- */

/* Logs the given error message to syslog if running in daemon mode, or
 * to the console if running in the foreground. */
void
log_errx(int e, const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	if (Foreground)
		verrx(e, fmt, ap);
	else {
		vsyslog(LOG_DAEMON | LOG_ERR, fmt, ap);
		exit(e);
	}
	/* NOTREACHED */
	va_end(ap);
}

/* --------------------------------------------------------------------- */

/* Logs the given info message to syslog if running in daemon mode, or
 * to the console if running in the foreground. */
void
log_info(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	if (Foreground) {
		vfprintf(stderr, fmt, ap);
		fprintf(stderr, "\n");
	} else
		vsyslog(LOG_DAEMON | LOG_INFO, fmt, ap);
	va_end(ap);
}

/* --------------------------------------------------------------------- */

/* Logs the given warning message to syslog if running in daemon mode, or
 * to the console if running in the foreground. */
void
log_warn(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	if (Foreground)
		vwarn(fmt, ap);
	else {
		int olderrno = errno;
		vsyslog(LOG_DAEMON | LOG_WARNING, fmt, ap);
		errno = olderrno;
		syslog(LOG_DAEMON | LOG_WARNING, "%m");
	}
	va_end(ap);
}

/* --------------------------------------------------------------------- */

/* Logs the given warning message to syslog if running in daemon mode, or
 * to the console if running in the foreground. */
void
log_warnx(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	if (Foreground)
		vwarnx(fmt, ap);
	else
		vsyslog(LOG_DAEMON | LOG_WARNING, fmt, ap);
	va_end(ap);
}

/* --------------------------------------------------------------------- */

/* Initializes mouse information.  Basically, it opens required files
 * for the daemon to work. */
static void
init_mouse(void)
{

	Mouse.m_devfd = -1;
	open_device(0);

	/* Open FIFO, if wanted */
	Mouse.m_fifofd = -1;
	if (Mouse.m_fifoname != NULL) {
		Mouse.m_fifofd = open(Mouse.m_fifoname,
		    O_RDWR | O_NONBLOCK, 0);
		if (Mouse.m_fifofd == -1)
			log_err(EXIT_FAILURE, "cannot open %s",
			    Mouse.m_fifoname);
	}
}

/* --------------------------------------------------------------------- */

/* Opens the mouse device (if not already opened).  The argument `secs'
 * specifies how much seconds the function will wait before trying to
 * open the device; this is used when returning from the X console. */
static void
open_device(unsigned int secs)
{
	int status;

	if (Mouse.m_devfd != -1)
		return;

	sleep(secs);

	/* Open mouse file descriptor */
	Mouse.m_devfd = open(Mouse.m_devname, O_RDONLY | O_NONBLOCK, 0);
	if (Mouse.m_devfd == -1)
		log_err(EXIT_FAILURE, "cannot open %s", Mouse.m_devname);

	const int version = WSMOUSE_EVENT_VERSION;
	status = ioctl(Mouse.m_devfd, WSMOUSEIO_SETVERSION, &version);
	if (status == -1)
		log_err(EXIT_FAILURE, "cannot set version %s", Mouse.m_devname);


	/*
	 * Get calibration data for touch panel.  Not fatal if we can't.
	 */
	Mouse.m_doabs = 0;

	unsigned int mouse_type = 0; /* defined WSMOUSE_TYPE_* start at 1 */
	status = ioctl(Mouse.m_devfd, WSMOUSEIO_GTYPE, &mouse_type);
	if (status == -1) {
		log_warn("WSMOUSEIO_GTYPE");
		return;
	}

	/* absolute position events make no sense for free-ranging mice */
	if (mouse_type != WSMOUSE_TYPE_TPANEL)
		return;

	status = ioctl(Mouse.m_devfd, WSMOUSEIO_GCALIBCOORDS, &Mouse.m_calib);
	if (status == -1) {
		log_warn("WSMOUSEIO_GCALIBCOORDS");
		return;
	}

	Mouse.m_doabs = 1;
}


/* --------------------------------------------------------------------- */

/* Main program event loop.  This function polls the wscons status
 * device and the mouse device; whenever an event is received, the
 * appropriate callback is fired for all attached modes.  If the polls
 * times out (which only happens when the mouse is disabled), another
 * callback is launched. */
static void
event_loop(void)
{
	int i, res;
	struct pollfd fds[2];
	struct wscons_event event;

	fds[0].fd = Mouse.m_statfd;
	fds[0].events = POLLIN;

	for (;;) {
		fds[1].fd = Mouse.m_devfd;
		fds[1].events = POLLIN;
		if (Mouse.m_disabled)
			res = poll(fds, 1, INFTIM);
		else
			res = poll(fds, 2, 300);

		if (res < 0)
			log_warn("failed to read from devices");

		if (fds[0].revents & POLLIN) {
			res = read(Mouse.m_statfd, &event, sizeof(event));
			if (debug)
				(void)fprintf(stderr, "event [type=%u,value=%d,"
				    "time=[%lld,%ld]\n", event.type,
				    event.value, (long long)event.time.tv_sec,
				    (long)event.time.tv_nsec);
			if (res != sizeof(event))
				log_warn("failed to read from mouse stat");

			for (i = 0; i < MAX_MODES && Modes[i] != NULL; i++)
				if (Modes[i]->mb_wscons_event != NULL)
					Modes[i]->mb_wscons_event(event, 1);

			generic_wscons_event(event);

			for (i = 0; i < MAX_MODES && Modes[i] != NULL; i++)
				if (Modes[i]->mb_wscons_event != NULL)
					Modes[i]->mb_wscons_event(event, 0);

		} else if (fds[1].revents & POLLIN) {
			res = read(Mouse.m_devfd, &event, sizeof(event));
			if (res != sizeof(event))
				log_warn("failed to read from mouse");

			if (debug)
				(void)fprintf(stderr, "event [type=%u,value=%d,"
				    "time=[%lld,%ld]\n", event.type,
				    event.value, (long long)event.time.tv_sec,
				    (long)event.time.tv_nsec);
			if (Mouse.m_fifofd >= 0) {
				res = write(Mouse.m_fifofd, &event,
				            sizeof(event));
				if (res != sizeof(event))
					log_warn("failed to write to fifo");
			}

			for (i = 0; i < MAX_MODES && Modes[i] != NULL; i++)
				if (Modes[i]->mb_wsmouse_event != NULL)
					Modes[i]->mb_wsmouse_event(event);
		} else {
			for (i = 0; i < MAX_MODES && Modes[i] != NULL; i++)
				if (Modes[i]->mb_poll_timeout != NULL)
					Modes[i]->mb_poll_timeout();
		}
	}
}

/* --------------------------------------------------------------------- */

/* This function parses generic wscons status events.  Actually, it
 * handles the screen switch event to enable or disable the mouse,
 * depending if we are entering or leaving the X console. */
static void
generic_wscons_event(struct wscons_event evt)
{

	switch (evt.type) {
	case WSCONS_EVENT_SCREEN_SWITCH:
		if (evt.value == X_Console) {
			Mouse.m_disabled = 1;
			(void)close(Mouse.m_devfd);
			Mouse.m_devfd = -1;
		} else {
			if (Mouse.m_disabled) {
				open_device(X_Console_Delay);
				Mouse.m_disabled = 0;
			} else {
				(void)close(Mouse.m_devfd);
				Mouse.m_devfd = -1;
				open_device(0);
			}
		}
		break;
	}
}

/* --------------------------------------------------------------------- */

/* Attaches a mode to the list of active modes, based on its name.
 * Returns 1 on success or 0 if the mode fails to initialize or there is
 * any other problem. */
static int
attach_mode(const char *name)
{
	int i, pos;
	struct mode_bootstrap *mb;

	for (i = 0, pos = -1; i < MAX_MODES; i++)
		if (Modes[i] == NULL) {
			pos = i;
			break;
		}
	if (pos == -1) {
		log_warnx("modes table full; cannot register `%s'", name);
		return 0;
	}

	for (i = 0; i < MAX_MODES; i++) {
		mb = Avail_Modes[i];
		if (mb != NULL && strcmp(name, mb->mb_name) == 0) {
			int res;

			res = mb->mb_startup(&Mouse);
			if (res == 0) {
				log_warnx("startup failed for `%s' mode",
				    mb->mb_name);
				return 0;
			} else {
				Modes[pos] = mb;
				return 1;
			}
		}
	}

	log_warnx("unknown mode `%s' (see the `modes' directive)", name);
	return 0;
}

/* --------------------------------------------------------------------- */

/* Attaches all modes given in the whitespace separated string `list'.
 * A fatal error is produced if no active modes can be attached. */
static void
attach_modes(char *list)
{
	char *last, *p;
	int count;

	/* Attach all requested modes */
	(void)memset(&Modes, 0, sizeof(struct mode_bootstrap *) * MAX_MODES);
	for (count = 0, (p = strtok_r(list, " ", &last)); p;
	    (p = strtok_r(NULL, " ", &last))) {
		if (attach_mode(p))
			count++;
	}

	if (count == 0)
		log_errx(EXIT_FAILURE, "no active modes found; exiting...");
}

/* --------------------------------------------------------------------- */

/* Detaches a mode from the active modes list based on its name. */
static void
detach_mode(const char *name)
{
	int i;
	struct mode_bootstrap *mb;

	for (i = 0; i < MAX_MODES; i++) {
		mb = Modes[i];
		if (mb != NULL && strcmp(name, mb->mb_name) == 0) {
			int res;

			res = mb->mb_cleanup();
			if (res == 0) {
				log_warnx("cleanup failed for `%s' mode",
				    mb->mb_name);
				return;
			} else {
				Modes[i] = NULL;
				return;
			}
		}
	}

	log_warnx("unknown mode `%s' (see the `modes' directive)", name);
}

/* --------------------------------------------------------------------- */

/* Detaches all active modes. */
static void
detach_modes(void)
{
	int i;

	for (i = 0; i < MAX_MODES && Modes[i] != NULL; i++)
		detach_mode(Modes[i]->mb_name);
}

/* --------------------------------------------------------------------- */

/* Signal handler for close signals.  The program can only be exited
 * through this function. */
/* ARGSUSED */
static void
signal_terminate(int sig)
{

	detach_modes();
	config_free();
	exit(EXIT_SUCCESS);
}

/* --------------------------------------------------------------------- */

/* Main program.  Parses command line options, reads the configuration
 * file, initializes the mouse and associated files and launches the main
 * event loop. */
int
main(int argc, char **argv)
{
	char *conffile, *modelist, *tstat;
	int needconf, nodaemon, opt;
	struct block *conf;

	setprogname(argv[0]);

	(void)memset(&Mouse, 0, sizeof(struct mouse));
	conffile = _PATH_CONF;
	modelist = NULL;
	needconf = 0;
	nodaemon = -1;

	/* Parse command line options */
	while ((opt = getopt(argc, argv, "Dd:f:m:n")) != -1) {
		switch (opt) {
		case 'D':
			debug++;
			break;
		case 'd': /* Mouse device name */
			Mouse.m_devname = optarg;
			break;
		case 'f': /* Configuration file name */
			needconf = 1;
			conffile = optarg;
			break;
		case 'm': /* List of modes to activate */
			modelist = optarg;
			break;
		case 'n': /* No daemon */
			nodaemon = 1;
			break;
		default:
			usage();
			/* NOTREACHED */
		}
	}

	/* Read the configuration file and get some basic properties */
	config_read(conffile, needconf);
	conf = config_get_mode("Global");
	if (nodaemon == -1)
		nodaemon = block_get_propval_int(conf, "nodaemon", 0);
	X_Console = block_get_propval_int(conf, "xconsole", -1);
	X_Console_Delay = block_get_propval_int(conf, "xconsole_delay",
	    X_Console_Delay);

	/* Open wsdisplay status device */
	tstat = block_get_propval(conf, "ttystat", _PATH_TTYSTAT);
	Mouse.m_statfd = open(tstat, O_RDONLY | O_NONBLOCK, 0);
	if (Mouse.m_statfd == -1)
		log_err(EXIT_FAILURE, "cannot open %s", tstat);

	/* Initialize mouse information and attach modes */
	if (Mouse.m_devname == NULL)
		Mouse.m_devname = block_get_propval(conf, "device",
		    _PATH_DEFAULT_MOUSE);
	Mouse.m_fifoname = block_get_propval(conf, "fifo", NULL);
	init_mouse();
	if (modelist != NULL)
		attach_modes(modelist);
	else
		attach_modes(block_get_propval(conf, "modes", "selection"));

	/* Setup signal handlers */
	(void)signal(SIGINT,  signal_terminate);
	(void)signal(SIGKILL, signal_terminate);
	(void)signal(SIGQUIT, signal_terminate);
	(void)signal(SIGTERM, signal_terminate);

	if (!nodaemon) {
		/* Become a daemon */
		if (daemon(0, 0) == -1)
			log_err(EXIT_FAILURE, "failed to become a daemon");

		/* Create the pidfile, if wanted */
		Pid_File = block_get_propval(conf, "pidfile", NULL);
		if (pidfile(Pid_File) == -1)
			log_warn("pidfile %s", Pid_File);

		Foreground = 0;
	}

	event_loop();

	/* NOTREACHED */
	return EXIT_SUCCESS;
}
