/* $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;
}