usr.sbin/moused/moused.c

   1 /**
   2  ** Copyright (c) 1995 Michael Smith, All rights reserved.
   3  **
   4  ** Redistribution and use in source and binary forms, with or without
   5  ** modification, are permitted provided that the following conditions
   6  ** are met:
   7  ** 1. Redistributions of source code must retain the above copyright
   8  **    notice, this list of conditions and the following disclaimer as
   9  **    the first lines of this file unmodified.
  10  ** 2. Redistributions in binary form must reproduce the above copyright
  11  **    notice, this list of conditions and the following disclaimer in the
  12  **    documentation and/or other materials provided with the distribution.
  13  ** 3. All advertising materials mentioning features or use of this software
  14  **    must display the following acknowledgment:
  15  **      This product includes software developed by Michael Smith.
  16  ** 4. The name of the author may not be used to endorse or promote products
  17  **    derived from this software without specific prior written permission.
  18  **
  19  **
  20  ** THIS SOFTWARE IS PROVIDED BY Michael Smith ``AS IS'' AND ANY
  21  ** EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  ** PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Michael Smith BE LIABLE FOR
  24  ** ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  ** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  ** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  27  ** BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  28  ** WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  29  ** OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  ** EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  **
  32  **/
  33
  34 /**
  35  ** MOUSED.C
  36  **
  37  ** Mouse daemon : listens to a serial port, the bus mouse interface, or
  38  ** the PS/2 mouse port for mouse data stream, interprets data and passes
  39  ** ioctls off to the console driver.
  40  **
  41  ** The mouse interface functions are derived closely from the mouse
  42  ** handler in the XFree86 X server.  Many thanks to the XFree86 people
  43  ** for their great work!
  44  **
  45  **/
  46
  47 #include <sys/cdefs.h>
  48 __FBSDID("$FreeBSD$");
  49
  50 #include <sys/param.h>
  51 #include <sys/consio.h>
  52 #include <sys/mouse.h>
  53 #include <sys/socket.h>
  54 #include <sys/stat.h>
  55 #include <sys/time.h>
  56 #include <sys/un.h>
  57
  58 #include <ctype.h>
  59 #include <err.h>
  60 #include <errno.h>
  61 #include <fcntl.h>
  62 #include <libutil.h>
  63 #include <limits.h>
  64 #include <setjmp.h>
  65 #include <signal.h>
  66 #include <stdarg.h>
  67 #include <stdint.h>
  68 #include <stdio.h>
  69 #include <stdlib.h>
  70 #include <string.h>
  71 #include <syslog.h>
  72 #include <termios.h>
  73 #include <unistd.h>
  74 #include <math.h>
  75
  76 #define MAX_CLICKTHRESHOLD      2000    /* 2 seconds */
  77 #define MAX_BUTTON2TIMEOUT      2000    /* 2 seconds */
  78 #define DFLT_CLICKTHRESHOLD      500    /* 0.5 second */
  79 #define DFLT_BUTTON2TIMEOUT      100    /* 0.1 second */
  80 #define DFLT_SCROLLTHRESHOLD       3    /* 3 pixels */
  81 #define DFLT_SCROLLSPEED           2    /* 2 pixels */
  82
  83 /* Abort 3-button emulation delay after this many movement events. */
  84 #define BUTTON2_MAXMOVE 3
  85
  86 #define TRUE            1
  87 #define FALSE           0
  88
  89 #define MOUSE_XAXIS     (-1)
  90 #define MOUSE_YAXIS     (-2)
  91
  92 /* Logitech PS2++ protocol */
  93 #define MOUSE_PS2PLUS_CHECKBITS(b)      \
  94                         ((((b[2] & 0x03) << 2) | 0x02) == (b[1] & 0x0f))
  95 #define MOUSE_PS2PLUS_PACKET_TYPE(b)    \
  96                         (((b[0] & 0x30) >> 2) | ((b[1] & 0x30) >> 4))
  97
  98 #define ChordMiddle     0x0001
  99 #define Emulate3Button  0x0002
 100 #define ClearDTR        0x0004
 101 #define ClearRTS        0x0008
 102 #define NoPnP           0x0010
 103 #define VirtualScroll   0x0020
 104 #define HVirtualScroll  0x0040
 105 #define ExponentialAcc  0x0080
 106
 107 #define ID_NONE         0
 108 #define ID_PORT         1
 109 #define ID_IF           2
 110 #define ID_TYPE         4
 111 #define ID_MODEL        8
 112 #define ID_ALL          (ID_PORT | ID_IF | ID_TYPE | ID_MODEL)
 113
 114 /* Operations on timespecs */
 115 #define tsclr(tvp)      ((tvp)->tv_sec = (tvp)->tv_nsec = 0)
 116 #define tscmp(tvp, uvp, cmp)                                            \
 117         (((tvp)->tv_sec == (uvp)->tv_sec) ?                             \
 118             ((tvp)->tv_nsec cmp (uvp)->tv_nsec) :                       \
 119             ((tvp)->tv_sec cmp (uvp)->tv_sec))
 120 #define tssub(tvp, uvp, vvp)                                            \
 121         do {                                                            \
 122                 (vvp)->tv_sec = (tvp)->tv_sec - (uvp)->tv_sec;          \
 123                 (vvp)->tv_nsec = (tvp)->tv_nsec - (uvp)->tv_nsec;       \
 124                 if ((vvp)->tv_nsec < 0) {                               \
 125                         (vvp)->tv_sec--;                                \
 126                         (vvp)->tv_nsec += 1000000000;                   \
 127                 }                                                       \
 128         } while (0)
 129
 130 #define debug(...) do {                                         \
 131         if (debug && nodaemon)                                  \
 132                 warnx(__VA_ARGS__);                             \
 133 } while (0)
 134
 135 #define logerr(e, ...) do {                                     \
 136         log_or_warn(LOG_DAEMON | LOG_ERR, errno, __VA_ARGS__);  \
 137         exit(e);                                                \
 138 } while (0)
 139
 140 #define logerrx(e, ...) do {                                    \
 141         log_or_warn(LOG_DAEMON | LOG_ERR, 0, __VA_ARGS__);      \
 142         exit(e);                                                \
 143 } while (0)
 144
 145 #define logwarn(...)                                            \
 146         log_or_warn(LOG_DAEMON | LOG_WARNING, errno, __VA_ARGS__)
 147
 148 #define logwarnx(...)                                           \
 149         log_or_warn(LOG_DAEMON | LOG_WARNING, 0, __VA_ARGS__)
 150
 151 /* structures */
 152
 153 /* symbol table entry */
 154 typedef struct {
 155     const char *name;
 156     int val;
 157     int val2;
 158 } symtab_t;
 159
 160 /* serial PnP ID string */
 161 typedef struct {
 162     int revision;       /* PnP revision, 100 for 1.00 */
 163     const char *eisaid; /* EISA ID including mfr ID and product ID */
 164     char *serial;       /* serial No, optional */
 165     const char *class;  /* device class, optional */
 166     char *compat;       /* list of compatible drivers, optional */
 167     char *description;  /* product description, optional */
 168     int neisaid;        /* length of the above fields... */
 169     int nserial;
 170     int nclass;
 171     int ncompat;
 172     int ndescription;
 173 } pnpid_t;
 174
 175 /* global variables */
 176
 177 int     debug = 0;
 178 int     nodaemon = FALSE;
 179 int     background = FALSE;
 180 int     paused = FALSE;
 181 int     identify = ID_NONE;
 182 int     extioctl = FALSE;
 183 const char *pidfile = "/var/run/moused.pid";
 184 struct pidfh *pfh;
 185
 186 #define SCROLL_NOTSCROLLING     0
 187 #define SCROLL_PREPARE          1
 188 #define SCROLL_SCROLLING        2
 189
 190 static int      scroll_state;
 191 static int      scroll_movement;
 192 static int      hscroll_movement;
 193
 194 /* local variables */
 195
 196 /* interface (the table must be ordered by MOUSE_IF_XXX in mouse.h) */
 197 static symtab_t rifs[] = {
 198     { "serial",         MOUSE_IF_SERIAL,        0 },
 199     { "bus",            MOUSE_IF_BUS,           0 },
 200     { "inport",         MOUSE_IF_INPORT,        0 },
 201     { "ps/2",           MOUSE_IF_PS2,           0 },
 202     { "sysmouse",       MOUSE_IF_SYSMOUSE,      0 },
 203     { "usb",            MOUSE_IF_USB,           0 },
 204     { NULL,             MOUSE_IF_UNKNOWN,       0 },
 205 };
 206
 207 /* types (the table must be ordered by MOUSE_PROTO_XXX in mouse.h) */
 208 static const char *rnames[] = {
 209     "microsoft",
 210     "mousesystems",
 211     "logitech",
 212     "mmseries",
 213     "mouseman",
 214     "busmouse",
 215     "inportmouse",
 216     "ps/2",
 217     "mmhitab",
 218     "glidepoint",
 219     "intellimouse",
 220     "thinkingmouse",
 221     "sysmouse",
 222     "x10mouseremote",
 223     "kidspad",
 224     "versapad",
 225     "jogdial",
 226 #if notyet
 227     "mariqua",
 228 #endif
 229     "gtco_digipad",
 230     NULL
 231 };
 232
 233 /* models */
 234 static symtab_t rmodels[] = {
 235     { "NetScroll",              MOUSE_MODEL_NETSCROLL,          0 },
 236     { "NetMouse/NetScroll Optical", MOUSE_MODEL_NET,            0 },
 237     { "GlidePoint",             MOUSE_MODEL_GLIDEPOINT,         0 },
 238     { "ThinkingMouse",          MOUSE_MODEL_THINK,              0 },
 239     { "IntelliMouse",           MOUSE_MODEL_INTELLI,            0 },
 240     { "EasyScroll/SmartScroll", MOUSE_MODEL_EASYSCROLL,         0 },
 241     { "MouseMan+",              MOUSE_MODEL_MOUSEMANPLUS,       0 },
 242     { "Kidspad",                MOUSE_MODEL_KIDSPAD,            0 },
 243     { "VersaPad",               MOUSE_MODEL_VERSAPAD,           0 },
 244     { "IntelliMouse Explorer",  MOUSE_MODEL_EXPLORER,           0 },
 245     { "4D Mouse",               MOUSE_MODEL_4D,                 0 },
 246     { "4D+ Mouse",              MOUSE_MODEL_4DPLUS,             0 },
 247     { "Synaptics Touchpad",     MOUSE_MODEL_SYNAPTICS,          0 },
 248     { "generic",                MOUSE_MODEL_GENERIC,            0 },
 249     { NULL,                     MOUSE_MODEL_UNKNOWN,            0 },
 250 };
 251
 252 /* PnP EISA/product IDs */
 253 static symtab_t pnpprod[] = {
 254     /* Kensignton ThinkingMouse */
 255     { "KML0001",        MOUSE_PROTO_THINK,      MOUSE_MODEL_THINK },
 256     /* MS IntelliMouse */
 257     { "MSH0001",        MOUSE_PROTO_INTELLI,    MOUSE_MODEL_INTELLI },
 258     /* MS IntelliMouse TrackBall */
 259     { "MSH0004",        MOUSE_PROTO_INTELLI,    MOUSE_MODEL_INTELLI },
 260     /* Tremon Wheel Mouse MUSD */
 261     { "HTK0001",        MOUSE_PROTO_INTELLI,    MOUSE_MODEL_INTELLI },
 262     /* Genius PnP Mouse */
 263     { "KYE0001",        MOUSE_PROTO_MS,         MOUSE_MODEL_GENERIC },
 264     /* MouseSystems SmartScroll Mouse (OEM from Genius?) */
 265     { "KYE0002",        MOUSE_PROTO_MS,         MOUSE_MODEL_EASYSCROLL },
 266     /* Genius NetMouse */
 267     { "KYE0003",        MOUSE_PROTO_INTELLI,    MOUSE_MODEL_NET },
 268     /* Genius Kidspad, Easypad and other tablets */
 269     { "KYE0005",        MOUSE_PROTO_KIDSPAD,    MOUSE_MODEL_KIDSPAD },
 270     /* Genius EZScroll */
 271     { "KYEEZ00",        MOUSE_PROTO_MS,         MOUSE_MODEL_EASYSCROLL },
 272     /* Logitech Cordless MouseMan Wheel */
 273     { "LGI8033",        MOUSE_PROTO_INTELLI,    MOUSE_MODEL_MOUSEMANPLUS },
 274     /* Logitech MouseMan (new 4 button model) */
 275     { "LGI800C",        MOUSE_PROTO_INTELLI,    MOUSE_MODEL_MOUSEMANPLUS },
 276     /* Logitech MouseMan+ */
 277     { "LGI8050",        MOUSE_PROTO_INTELLI,    MOUSE_MODEL_MOUSEMANPLUS },
 278     /* Logitech FirstMouse+ */
 279     { "LGI8051",        MOUSE_PROTO_INTELLI,    MOUSE_MODEL_MOUSEMANPLUS },
 280     /* Logitech serial */
 281     { "LGI8001",        MOUSE_PROTO_LOGIMOUSEMAN, MOUSE_MODEL_GENERIC },
 282     /* A4 Tech 4D/4D+ Mouse */
 283     { "A4W0005",        MOUSE_PROTO_INTELLI,    MOUSE_MODEL_4D },
 284     /* 8D Scroll Mouse */
 285     { "PEC9802",        MOUSE_PROTO_INTELLI,    MOUSE_MODEL_INTELLI },
 286     /* Mitsumi Wireless Scroll Mouse */
 287     { "MTM6401",        MOUSE_PROTO_INTELLI,    MOUSE_MODEL_INTELLI },
 288
 289     /* MS bus */
 290     { "PNP0F00",        MOUSE_PROTO_BUS,        MOUSE_MODEL_GENERIC },
 291     /* MS serial */
 292     { "PNP0F01",        MOUSE_PROTO_MS,         MOUSE_MODEL_GENERIC },
 293     /* MS InPort */
 294     { "PNP0F02",        MOUSE_PROTO_INPORT,     MOUSE_MODEL_GENERIC },
 295     /* MS PS/2 */
 296     { "PNP0F03",        MOUSE_PROTO_PS2,        MOUSE_MODEL_GENERIC },
 297     /*
 298      * EzScroll returns PNP0F04 in the compatible device field; but it
 299      * doesn't look compatible... XXX
 300      */
 301     /* MouseSystems */
 302     { "PNP0F04",        MOUSE_PROTO_MSC,        MOUSE_MODEL_GENERIC },
 303     /* MouseSystems */
 304     { "PNP0F05",        MOUSE_PROTO_MSC,        MOUSE_MODEL_GENERIC },
 305 #if notyet
 306     /* Genius Mouse */
 307     { "PNP0F06",        MOUSE_PROTO_XXX,        MOUSE_MODEL_GENERIC },
 308     /* Genius Mouse */
 309     { "PNP0F07",        MOUSE_PROTO_XXX,        MOUSE_MODEL_GENERIC },
 310 #endif
 311     /* Logitech serial */
 312     { "PNP0F08",        MOUSE_PROTO_LOGIMOUSEMAN, MOUSE_MODEL_GENERIC },
 313     /* MS BallPoint serial */
 314     { "PNP0F09",        MOUSE_PROTO_MS,         MOUSE_MODEL_GENERIC },
 315     /* MS PnP serial */
 316     { "PNP0F0A",        MOUSE_PROTO_MS,         MOUSE_MODEL_GENERIC },
 317     /* MS PnP BallPoint serial */
 318     { "PNP0F0B",        MOUSE_PROTO_MS,         MOUSE_MODEL_GENERIC },
 319     /* MS serial comatible */
 320     { "PNP0F0C",        MOUSE_PROTO_MS,         MOUSE_MODEL_GENERIC },
 321     /* MS InPort comatible */
 322     { "PNP0F0D",        MOUSE_PROTO_INPORT,     MOUSE_MODEL_GENERIC },
 323     /* MS PS/2 comatible */
 324     { "PNP0F0E",        MOUSE_PROTO_PS2,        MOUSE_MODEL_GENERIC },
 325     /* MS BallPoint comatible */
 326     { "PNP0F0F",        MOUSE_PROTO_MS,         MOUSE_MODEL_GENERIC },
 327 #if notyet
 328     /* TI QuickPort */
 329     { "PNP0F10",        MOUSE_PROTO_XXX,        MOUSE_MODEL_GENERIC },
 330 #endif
 331     /* MS bus comatible */
 332     { "PNP0F11",        MOUSE_PROTO_BUS,        MOUSE_MODEL_GENERIC },
 333     /* Logitech PS/2 */
 334     { "PNP0F12",        MOUSE_PROTO_PS2,        MOUSE_MODEL_GENERIC },
 335     /* PS/2 */
 336     { "PNP0F13",        MOUSE_PROTO_PS2,        MOUSE_MODEL_GENERIC },
 337 #if notyet
 338     /* MS Kids Mouse */
 339     { "PNP0F14",        MOUSE_PROTO_XXX,        MOUSE_MODEL_GENERIC },
 340 #endif
 341     /* Logitech bus */
 342     { "PNP0F15",        MOUSE_PROTO_BUS,        MOUSE_MODEL_GENERIC },
 343 #if notyet
 344     /* Logitech SWIFT */
 345     { "PNP0F16",        MOUSE_PROTO_XXX,        MOUSE_MODEL_GENERIC },
 346 #endif
 347     /* Logitech serial compat */
 348     { "PNP0F17",        MOUSE_PROTO_LOGIMOUSEMAN, MOUSE_MODEL_GENERIC },
 349     /* Logitech bus compatible */
 350     { "PNP0F18",        MOUSE_PROTO_BUS,        MOUSE_MODEL_GENERIC },
 351     /* Logitech PS/2 compatible */
 352     { "PNP0F19",        MOUSE_PROTO_PS2,        MOUSE_MODEL_GENERIC },
 353 #if notyet
 354     /* Logitech SWIFT compatible */
 355     { "PNP0F1A",        MOUSE_PROTO_XXX,        MOUSE_MODEL_GENERIC },
 356     /* HP Omnibook */
 357     { "PNP0F1B",        MOUSE_PROTO_XXX,        MOUSE_MODEL_GENERIC },
 358     /* Compaq LTE TrackBall PS/2 */
 359     { "PNP0F1C",        MOUSE_PROTO_XXX,        MOUSE_MODEL_GENERIC },
 360     /* Compaq LTE TrackBall serial */
 361     { "PNP0F1D",        MOUSE_PROTO_XXX,        MOUSE_MODEL_GENERIC },
 362     /* MS Kidts Trackball */
 363     { "PNP0F1E",        MOUSE_PROTO_XXX,        MOUSE_MODEL_GENERIC },
 364 #endif
 365     /* Interlink VersaPad */
 366     { "LNK0001",        MOUSE_PROTO_VERSAPAD,   MOUSE_MODEL_VERSAPAD },
 367
 368     { NULL,             MOUSE_PROTO_UNKNOWN,    MOUSE_MODEL_GENERIC },
 369 };
 370
 371 /* the table must be ordered by MOUSE_PROTO_XXX in mouse.h */
 372 static unsigned short rodentcflags[] =
 373 {
 374     (CS7                   | CREAD | CLOCAL | HUPCL),   /* MicroSoft */
 375     (CS8 | CSTOPB          | CREAD | CLOCAL | HUPCL),   /* MouseSystems */
 376     (CS8 | CSTOPB          | CREAD | CLOCAL | HUPCL),   /* Logitech */
 377     (CS8 | PARENB | PARODD | CREAD | CLOCAL | HUPCL),   /* MMSeries */
 378     (CS7                   | CREAD | CLOCAL | HUPCL),   /* MouseMan */
 379     0,                                                  /* Bus */
 380     0,                                                  /* InPort */
 381     0,                                                  /* PS/2 */
 382     (CS8                   | CREAD | CLOCAL | HUPCL),   /* MM HitTablet */
 383     (CS7                   | CREAD | CLOCAL | HUPCL),   /* GlidePoint */
 384     (CS7                   | CREAD | CLOCAL | HUPCL),   /* IntelliMouse */
 385     (CS7                   | CREAD | CLOCAL | HUPCL),   /* Thinking Mouse */
 386     (CS8 | CSTOPB          | CREAD | CLOCAL | HUPCL),   /* sysmouse */
 387     (CS7                   | CREAD | CLOCAL | HUPCL),   /* X10 MouseRemote */
 388     (CS8 | PARENB | PARODD | CREAD | CLOCAL | HUPCL),   /* kidspad etc. */
 389     (CS8                   | CREAD | CLOCAL | HUPCL),   /* VersaPad */
 390     0,                                                  /* JogDial */
 391 #if notyet
 392     (CS8 | CSTOPB          | CREAD | CLOCAL | HUPCL),   /* Mariqua */
 393 #endif
 394     (CS8                   | CREAD |          HUPCL ),  /* GTCO Digi-Pad */
 395 };
 396
 397 static struct rodentparam {
 398     int flags;
 399     const char *portname;       /* /dev/XXX */
 400     int rtype;                  /* MOUSE_PROTO_XXX */
 401     int level;                  /* operation level: 0 or greater */
 402     int baudrate;
 403     int rate;                   /* report rate */
 404     int resolution;             /* MOUSE_RES_XXX or a positive number */
 405     int zmap[4];                /* MOUSE_{X|Y}AXIS or a button number */
 406     int wmode;                  /* wheel mode button number */
 407     int mfd;                    /* mouse file descriptor */
 408     int cfd;                    /* /dev/consolectl file descriptor */
 409     int mremsfd;                /* mouse remote server file descriptor */
 410     int mremcfd;                /* mouse remote client file descriptor */
 411     long clickthreshold;        /* double click speed in msec */
 412     long button2timeout;        /* 3 button emulation timeout */
 413     mousehw_t hw;               /* mouse device hardware information */
 414     mousemode_t mode;           /* protocol information */
 415     float accelx;               /* Acceleration in the X axis */
 416     float accely;               /* Acceleration in the Y axis */
 417     float expoaccel;            /* Exponential acceleration */
 418     float expoffset;            /* Movement offset for exponential accel. */
 419     float remainx;              /* Remainder on X and Y axis, respectively... */
 420     float remainy;              /*    ... to compensate for rounding errors. */
 421     int scrollthreshold;        /* Movement distance before virtual scrolling */
 422     int scrollspeed;            /* Movement distance to rate of scrolling */
 423 } rodent = {
 424     .flags = 0,
 425     .portname = NULL,
 426     .rtype = MOUSE_PROTO_UNKNOWN,
 427     .level = -1,
 428     .baudrate = 1200,
 429     .rate = 0,
 430     .resolution = MOUSE_RES_UNKNOWN,
 431     .zmap = { 0, 0, 0, 0 },
 432     .wmode = 0,
 433     .mfd = -1,
 434     .cfd = -1,
 435     .mremsfd = -1,
 436     .mremcfd = -1,
 437     .clickthreshold = DFLT_CLICKTHRESHOLD,
 438     .button2timeout = DFLT_BUTTON2TIMEOUT,
 439     .accelx = 1.0,
 440     .accely = 1.0,
 441     .expoaccel = 1.0,
 442     .expoffset = 1.0,
 443     .remainx = 0.0,
 444     .remainy = 0.0,
 445     .scrollthreshold = DFLT_SCROLLTHRESHOLD,
 446     .scrollspeed = DFLT_SCROLLSPEED,
 447 };
 448
 449 /* button status */
 450 struct button_state {
 451     int count;          /* 0: up, 1: single click, 2: double click,... */
 452     struct timespec ts; /* timestamp on the last button event */
 453 };
 454 static struct button_state      bstate[MOUSE_MAXBUTTON];        /* button state */
 455 static struct button_state      *mstate[MOUSE_MAXBUTTON];/* mapped button st.*/
 456 static struct button_state      zstate[4];               /* Z/W axis state */
 457
 458 /* state machine for 3 button emulation */
 459
 460 #define S0      0       /* start */
 461 #define S1      1       /* button 1 delayed down */
 462 #define S2      2       /* button 3 delayed down */
 463 #define S3      3       /* both buttons down -> button 2 down */
 464 #define S4      4       /* button 1 delayed up */
 465 #define S5      5       /* button 1 down */
 466 #define S6      6       /* button 3 down */
 467 #define S7      7       /* both buttons down */
 468 #define S8      8       /* button 3 delayed up */
 469 #define S9      9       /* button 1 or 3 up after S3 */
 470
 471 #define A(b1, b3)       (((b1) ? 2 : 0) | ((b3) ? 1 : 0))
 472 #define A_TIMEOUT       4
 473 #define S_DELAYED(st)   (states[st].s[A_TIMEOUT] != (st))
 474
 475 static struct {
 476     int s[A_TIMEOUT + 1];
 477     int buttons;
 478     int mask;
 479     int timeout;
 480 } states[10] = {
 481     /* S0 */
 482     { { S0, S2, S1, S3, S0 }, 0, ~(MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN), FALSE },
 483     /* S1 */
 484     { { S4, S2, S1, S3, S5 }, 0, ~MOUSE_BUTTON1DOWN, FALSE },
 485     /* S2 */
 486     { { S8, S2, S1, S3, S6 }, 0, ~MOUSE_BUTTON3DOWN, FALSE },
 487     /* S3 */
 488     { { S0, S9, S9, S3, S3 }, MOUSE_BUTTON2DOWN, ~0, FALSE },
 489     /* S4 */
 490     { { S0, S2, S1, S3, S0 }, MOUSE_BUTTON1DOWN, ~0, TRUE },
 491     /* S5 */
 492     { { S0, S2, S5, S7, S5 }, MOUSE_BUTTON1DOWN, ~0, FALSE },
 493     /* S6 */
 494     { { S0, S6, S1, S7, S6 }, MOUSE_BUTTON3DOWN, ~0, FALSE },
 495     /* S7 */
 496     { { S0, S6, S5, S7, S7 }, MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN, ~0, FALSE },
 497     /* S8 */
 498     { { S0, S2, S1, S3, S0 }, MOUSE_BUTTON3DOWN, ~0, TRUE },
 499     /* S9 */
 500     { { S0, S9, S9, S3, S9 }, 0, ~(MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN), FALSE },
 501 };
 502 static int              mouse_button_state;
 503 static struct timespec  mouse_button_state_ts;
 504 static int              mouse_move_delayed;
 505
 506 static jmp_buf env;
 507
 508 struct drift_xy {
 509     int x;
 510     int y;
 511 };
 512 static int              drift_distance = 4;     /* max steps X+Y */
 513 static int              drift_time = 500;       /* in 0.5 sec */
 514 static struct timespec  drift_time_ts;
 515 static struct timespec  drift_2time_ts;         /* 2*drift_time */
 516 static int              drift_after = 4000;     /* 4 sec */
 517 static struct timespec  drift_after_ts;
 518 static int              drift_terminate = FALSE;
 519 static struct timespec  drift_current_ts;
 520 static struct timespec  drift_tmp;
 521 static struct timespec  drift_last_activity = {0, 0};
 522 static struct timespec  drift_since = {0, 0};
 523 static struct drift_xy  drift_last = {0, 0};    /* steps in last drift_time */
 524 static struct drift_xy  drift_previous = {0, 0};        /* steps in prev. drift_time */
 525
 526 /* function prototypes */
 527
 528 static void     linacc(int, int, int*, int*);
 529 static void     expoacc(int, int, int*, int*);
 530 static void     moused(void);
 531 static void     hup(int sig);
 532 static void     cleanup(int sig);
 533 static void     pause_mouse(int sig);
 534 static void     usage(void);
 535 static void     log_or_warn(int log_pri, int errnum, const char *fmt, ...)
 536                     __printflike(3, 4);
 537
 538 static int      r_identify(void);
 539 static const char *r_if(int type);
 540 static const char *r_name(int type);
 541 static const char *r_model(int model);
 542 static void     r_init(void);
 543 static int      r_protocol(u_char b, mousestatus_t *act);
 544 static int      r_statetrans(mousestatus_t *a1, mousestatus_t *a2, int trans);
 545 static int      r_installmap(char *arg);
 546 static void     r_map(mousestatus_t *act1, mousestatus_t *act2);
 547 static void     r_timestamp(mousestatus_t *act);
 548 static int      r_timeout(void);
 549 static void     r_click(mousestatus_t *act);
 550 static void     setmousespeed(int old, int new, unsigned cflag);
 551
 552 static int      pnpwakeup1(void);
 553 static int      pnpwakeup2(void);
 554 static int      pnpgets(char *buf);
 555 static int      pnpparse(pnpid_t *id, char *buf, int len);
 556 static symtab_t *pnpproto(pnpid_t *id);
 557
 558 static symtab_t *gettoken(symtab_t *tab, const char *s, int len);
 559 static const char *gettokenname(symtab_t *tab, int val);
 560
 561 static void     mremote_serversetup(void);
 562 static void     mremote_clientchg(int add);
 563
 564 static int      kidspad(u_char rxc, mousestatus_t *act);
 565 static int      gtco_digipad(u_char, mousestatus_t *);
 566
 567 int
 568 main(int argc, char *argv[])
 569 {
 570     int c;
 571     int i;
 572     int j;
 573     static int retry;
 574
 575     for (i = 0; i < MOUSE_MAXBUTTON; ++i)
 576         mstate[i] = &bstate[i];
 577
 578     while ((c = getopt(argc, argv, "3A:C:DE:F:HI:L:PRS:T:VU:a:cdfhi:l:m:p:r:st:w:z:")) != -1)
 579         switch(c) {
 580
 581         case '3':
 582             rodent.flags |= Emulate3Button;
 583             break;
 584
 585         case 'E':
 586             rodent.button2timeout = atoi(optarg);
 587             if ((rodent.button2timeout < 0) ||
 588                 (rodent.button2timeout > MAX_BUTTON2TIMEOUT)) {
 589                 warnx("invalid argument `%s'", optarg);
 590                 usage();
 591             }
 592             break;
 593
 594         case 'a':
 595             i = sscanf(optarg, "%f,%f", &rodent.accelx, &rodent.accely);
 596             if (i == 0) {
 597                 warnx("invalid linear acceleration argument '%s'", optarg);
 598                 usage();
 599             }
 600
 601             if (i == 1)
 602                 rodent.accely = rodent.accelx;
 603
 604             break;
 605
 606         case 'A':
 607             rodent.flags |= ExponentialAcc;
 608             i = sscanf(optarg, "%f,%f", &rodent.expoaccel, &rodent.expoffset);
 609             if (i == 0) {
 610                 warnx("invalid exponential acceleration argument '%s'", optarg);
 611                 usage();
 612             }
 613
 614             if (i == 1)
 615                 rodent.expoffset = 1.0;
 616
 617             break;
 618
 619         case 'c':
 620             rodent.flags |= ChordMiddle;
 621             break;
 622
 623         case 'd':
 624             ++debug;
 625             break;
 626
 627         case 'f':
 628             nodaemon = TRUE;
 629             break;
 630
 631         case 'i':
 632             if (strcmp(optarg, "all") == 0)
 633                 identify = ID_ALL;
 634             else if (strcmp(optarg, "port") == 0)
 635                 identify = ID_PORT;
 636             else if (strcmp(optarg, "if") == 0)
 637                 identify = ID_IF;
 638             else if (strcmp(optarg, "type") == 0)
 639                 identify = ID_TYPE;
 640             else if (strcmp(optarg, "model") == 0)
 641                 identify = ID_MODEL;
 642             else {
 643                 warnx("invalid argument `%s'", optarg);
 644                 usage();
 645             }
 646             nodaemon = TRUE;
 647             break;
 648
 649         case 'l':
 650             rodent.level = atoi(optarg);
 651             if ((rodent.level < 0) || (rodent.level > 4)) {
 652                 warnx("invalid argument `%s'", optarg);
 653                 usage();
 654             }
 655             break;
 656
 657         case 'm':
 658             if (!r_installmap(optarg)) {
 659                 warnx("invalid argument `%s'", optarg);
 660                 usage();
 661             }
 662             break;
 663
 664         case 'p':
 665             rodent.portname = optarg;
 666             break;
 667
 668         case 'r':
 669             if (strcmp(optarg, "high") == 0)
 670                 rodent.resolution = MOUSE_RES_HIGH;
 671             else if (strcmp(optarg, "medium-high") == 0)
 672                 rodent.resolution = MOUSE_RES_HIGH;
 673             else if (strcmp(optarg, "medium-low") == 0)
 674                 rodent.resolution = MOUSE_RES_MEDIUMLOW;
 675             else if (strcmp(optarg, "low") == 0)
 676                 rodent.resolution = MOUSE_RES_LOW;
 677             else if (strcmp(optarg, "default") == 0)
 678                 rodent.resolution = MOUSE_RES_DEFAULT;
 679             else {
 680                 rodent.resolution = atoi(optarg);
 681                 if (rodent.resolution <= 0) {
 682                     warnx("invalid argument `%s'", optarg);
 683                     usage();
 684                 }
 685             }
 686             break;
 687
 688         case 's':
 689             rodent.baudrate = 9600;
 690             break;
 691
 692         case 'w':
 693             i = atoi(optarg);
 694             if ((i <= 0) || (i > MOUSE_MAXBUTTON)) {
 695                 warnx("invalid argument `%s'", optarg);
 696                 usage();
 697             }
 698             rodent.wmode = 1 << (i - 1);
 699             break;
 700
 701         case 'z':
 702             if (strcmp(optarg, "x") == 0)
 703                 rodent.zmap[0] = MOUSE_XAXIS;
 704             else if (strcmp(optarg, "y") == 0)
 705                 rodent.zmap[0] = MOUSE_YAXIS;
 706             else {
 707                 i = atoi(optarg);
 708                 /*
 709                  * Use button i for negative Z axis movement and
 710                  * button (i + 1) for positive Z axis movement.
 711                  */
 712                 if ((i <= 0) || (i > MOUSE_MAXBUTTON - 1)) {
 713                     warnx("invalid argument `%s'", optarg);
 714                     usage();
 715                 }
 716                 rodent.zmap[0] = i;
 717                 rodent.zmap[1] = i + 1;
 718                 debug("optind: %d, optarg: '%s'", optind, optarg);
 719                 for (j = 1; j < 4; ++j) {
 720                     if ((optind >= argc) || !isdigit(*argv[optind]))
 721                         break;
 722                     i = atoi(argv[optind]);
 723                     if ((i <= 0) || (i > MOUSE_MAXBUTTON - 1)) {
 724                         warnx("invalid argument `%s'", argv[optind]);
 725                         usage();
 726                     }
 727                     rodent.zmap[j] = i;
 728                     ++optind;
 729                 }
 730                 if ((rodent.zmap[2] != 0) && (rodent.zmap[3] == 0))
 731                     rodent.zmap[3] = rodent.zmap[2] + 1;
 732             }
 733             break;
 734
 735         case 'C':
 736             rodent.clickthreshold = atoi(optarg);
 737             if ((rodent.clickthreshold < 0) ||
 738                 (rodent.clickthreshold > MAX_CLICKTHRESHOLD)) {
 739                 warnx("invalid argument `%s'", optarg);
 740                 usage();
 741             }
 742             break;
 743
 744         case 'D':
 745             rodent.flags |= ClearDTR;
 746             break;
 747
 748         case 'F':
 749             rodent.rate = atoi(optarg);
 750             if (rodent.rate <= 0) {
 751                 warnx("invalid argument `%s'", optarg);
 752                 usage();
 753             }
 754             break;
 755
 756         case 'H':
 757             rodent.flags |= HVirtualScroll;
 758             break;
 759
 760         case 'I':
 761             pidfile = optarg;
 762             break;
 763
 764         case 'L':
 765             rodent.scrollspeed = atoi(optarg);
 766             if (rodent.scrollspeed < 0) {
 767                 warnx("invalid argument `%s'", optarg);
 768                 usage();
 769             }
 770             break;
 771
 772         case 'P':
 773             rodent.flags |= NoPnP;
 774             break;
 775
 776         case 'R':
 777             rodent.flags |= ClearRTS;
 778             break;
 779
 780         case 'S':
 781             rodent.baudrate = atoi(optarg);
 782             if (rodent.baudrate <= 0) {
 783                 warnx("invalid argument `%s'", optarg);
 784                 usage();
 785             }
 786             debug("rodent baudrate %d", rodent.baudrate);
 787             break;
 788
 789         case 'T':
 790             drift_terminate = TRUE;
 791             sscanf(optarg, "%d,%d,%d", &drift_distance, &drift_time,
 792                 &drift_after);
 793             if (drift_distance <= 0 || drift_time <= 0 || drift_after <= 0) {
 794                 warnx("invalid argument `%s'", optarg);
 795                 usage();
 796             }
 797             debug("terminate drift: distance %d, time %d, after %d",
 798                 drift_distance, drift_time, drift_after);
 799             drift_time_ts.tv_sec = drift_time / 1000;
 800             drift_time_ts.tv_nsec = (drift_time % 1000) * 1000000;
 801             drift_2time_ts.tv_sec = (drift_time *= 2) / 1000;
 802             drift_2time_ts.tv_nsec = (drift_time % 1000) * 1000000;
 803             drift_after_ts.tv_sec = drift_after / 1000;
 804             drift_after_ts.tv_nsec = (drift_after % 1000) * 1000000;
 805             break;
 806
 807         case 't':
 808             if (strcmp(optarg, "auto") == 0) {
 809                 rodent.rtype = MOUSE_PROTO_UNKNOWN;
 810                 rodent.flags &= ~NoPnP;
 811                 rodent.level = -1;
 812                 break;
 813             }
 814             for (i = 0; rnames[i] != NULL; i++)
 815                 if (strcmp(optarg, rnames[i]) == 0) {
 816                     rodent.rtype = i;
 817                     rodent.flags |= NoPnP;
 818                     rodent.level = (i == MOUSE_PROTO_SYSMOUSE) ? 1 : 0;
 819                     break;
 820                 }
 821             if (rnames[i] == NULL) {
 822                 warnx("no such mouse type `%s'", optarg);
 823                 usage();
 824             }
 825             break;
 826
 827         case 'V':
 828             rodent.flags |= VirtualScroll;
 829             break;
 830         case 'U':
 831             rodent.scrollthreshold = atoi(optarg);
 832             if (rodent.scrollthreshold < 0) {
 833                 warnx("invalid argument `%s'", optarg);
 834                 usage();
 835             }
 836             break;
 837
 838         case 'h':
 839         case '?':
 840         default:
 841             usage();
 842         }
 843
 844     /* fix Z axis mapping */
 845     for (i = 0; i < 4; ++i) {
 846         if (rodent.zmap[i] > 0) {
 847             for (j = 0; j < MOUSE_MAXBUTTON; ++j) {
 848                 if (mstate[j] == &bstate[rodent.zmap[i] - 1])
 849                     mstate[j] = &zstate[i];
 850             }
 851             rodent.zmap[i] = 1 << (rodent.zmap[i] - 1);
 852         }
 853     }
 854
 855     /* the default port name */
 856     switch(rodent.rtype) {
 857
 858     case MOUSE_PROTO_INPORT:
 859         /* INPORT and BUS are the same... */
 860         rodent.rtype = MOUSE_PROTO_BUS;
 861         /* FALLTHROUGH */
 862     case MOUSE_PROTO_BUS:
 863         if (!rodent.portname)
 864             rodent.portname = "/dev/mse0";
 865         break;
 866
 867     case MOUSE_PROTO_PS2:
 868         if (!rodent.portname)
 869             rodent.portname = "/dev/psm0";
 870         break;
 871
 872     default:
 873         if (rodent.portname)
 874             break;
 875         warnx("no port name specified");
 876         usage();
 877     }
 878
 879     retry = 1;
 880     if (strncmp(rodent.portname, "/dev/ums", 8) == 0) {
 881         retry = 5;
 882     }
 883
 884     for (;;) {
 885         if (setjmp(env) == 0) {
 886             signal(SIGHUP, hup);
 887             signal(SIGINT , cleanup);
 888             signal(SIGQUIT, cleanup);
 889             signal(SIGTERM, cleanup);
 890             signal(SIGUSR1, pause_mouse);
 891             for (i = 0; i < retry; ++i) {
 892                 if (i > 0)
 893                     sleep(2);
 894                 rodent.mfd = open(rodent.portname, O_RDWR | O_NONBLOCK);
 895                 if (rodent.mfd != -1 || errno != ENOENT)
 896                     break;
 897             }
 898             if (rodent.mfd == -1)
 899                 logerr(1, "unable to open %s", rodent.portname);
 900             if (r_identify() == MOUSE_PROTO_UNKNOWN) {
 901                 logwarnx("cannot determine mouse type on %s", rodent.portname);
 902                 close(rodent.mfd);
 903                 rodent.mfd = -1;
 904             }
 905
 906             /* print some information */
 907             if (identify != ID_NONE) {
 908                 if (identify == ID_ALL)
 909                     printf("%s %s %s %s\n",
 910                         rodent.portname, r_if(rodent.hw.iftype),
 911                         r_name(rodent.rtype), r_model(rodent.hw.model));
 912                 else if (identify & ID_PORT)
 913                     printf("%s\n", rodent.portname);
 914                 else if (identify & ID_IF)
 915                     printf("%s\n", r_if(rodent.hw.iftype));
 916                 else if (identify & ID_TYPE)
 917                     printf("%s\n", r_name(rodent.rtype));
 918                 else if (identify & ID_MODEL)
 919                     printf("%s\n", r_model(rodent.hw.model));
 920                 exit(0);
 921             } else {
 922                 debug("port: %s  interface: %s  type: %s  model: %s",
 923                     rodent.portname, r_if(rodent.hw.iftype),
 924                     r_name(rodent.rtype), r_model(rodent.hw.model));
 925             }
 926
 927             if (rodent.mfd == -1) {
 928                 /*
 929                  * We cannot continue because of error.  Exit if the
 930                  * program has not become a daemon.  Otherwise, block
 931                  * until the user corrects the problem and issues SIGHUP.
 932                  */
 933                 if (!background)
 934                     exit(1);
 935                 sigpause(0);
 936             }
 937
 938             r_init();                   /* call init function */
 939             moused();
 940         }
 941
 942         if (rodent.mfd != -1)
 943             close(rodent.mfd);
 944         if (rodent.cfd != -1)
 945             close(rodent.cfd);
 946         rodent.mfd = rodent.cfd = -1;
 947     }
 948     /* NOT REACHED */
 949
 950     exit(0);
 951 }
 952
 953 /*
 954  * Function to calculate linear acceleration.
 955  *
 956  * If there are any rounding errors, the remainder
 957  * is stored in the remainx and remainy variables
 958  * and taken into account upon the next movement.
 959  */
 960
 961 static void
 962 linacc(int dx, int dy, int *movex, int *movey)
 963 {
 964     float fdx, fdy;
 965
 966     if (dx == 0 && dy == 0) {
 967         *movex = *movey = 0;
 968         return;
 969     }
 970     fdx = dx * rodent.accelx + rodent.remainx;
 971     fdy = dy * rodent.accely + rodent.remainy;
 972     *movex = lround(fdx);
 973     *movey = lround(fdy);
 974     rodent.remainx = fdx - *movex;
 975     rodent.remainy = fdy - *movey;
 976 }
 977
 978 /*
 979  * Function to calculate exponential acceleration.
 980  * (Also includes linear acceleration if enabled.)
 981  *
 982  * In order to give a smoother behaviour, we record the four
 983  * most recent non-zero movements and use their average value
 984  * to calculate the acceleration.
 985  */
 986
 987 static void
 988 expoacc(int dx, int dy, int *movex, int *movey)
 989 {
 990     static float lastlength[3] = {0.0, 0.0, 0.0};
 991     float fdx, fdy, length, lbase, accel;
 992
 993     if (dx == 0 && dy == 0) {
 994         *movex = *movey = 0;
 995         return;
 996     }
 997     fdx = dx * rodent.accelx;
 998     fdy = dy * rodent.accely;
 999     length = sqrtf((fdx * fdx) + (fdy * fdy));          /* Pythagoras */
1000     length = (length + lastlength[0] + lastlength[1] + lastlength[2]) / 4;
1001     lbase = length / rodent.expoffset;
1002     accel = powf(lbase, rodent.expoaccel) / lbase;
1003     fdx = fdx * accel + rodent.remainx;
1004     fdy = fdy * accel + rodent.remainy;
1005     *movex = lroundf(fdx);
1006     *movey = lroundf(fdy);
1007     rodent.remainx = fdx - *movex;
1008     rodent.remainy = fdy - *movey;
1009     lastlength[2] = lastlength[1];
1010     lastlength[1] = lastlength[0];
1011     lastlength[0] = length;     /* Insert new average, not original length! */
1012 }
1013
1014 static void
1015 moused(void)
1016 {
1017     struct mouse_info mouse;
1018     mousestatus_t action0;              /* original mouse action */
1019     mousestatus_t action;               /* interrim buffer */
1020     mousestatus_t action2;              /* mapped action */
1021     struct timeval timeout;
1022     fd_set fds;
1023     u_char b;
1024     pid_t mpid;
1025     int flags;
1026     int c;
1027     int i;
1028
1029     if ((rodent.cfd = open("/dev/consolectl", O_RDWR, 0)) == -1)
1030         logerr(1, "cannot open /dev/consolectl");
1031
1032     if (!nodaemon && !background) {
1033         pfh = pidfile_open(pidfile, 0600, &mpid);
1034         if (pfh == NULL) {
1035             if (errno == EEXIST)
1036                 logerrx(1, "moused already running, pid: %d", mpid);
1037             logwarn("cannot open pid file");
1038         }
1039         if (daemon(0, 0)) {
1040             int saved_errno = errno;
1041             pidfile_remove(pfh);
1042             errno = saved_errno;
1043             logerr(1, "failed to become a daemon");
1044         } else {
1045             background = TRUE;
1046             pidfile_write(pfh);
1047         }
1048     }
1049
1050     /* clear mouse data */
1051     bzero(&action0, sizeof(action0));
1052     bzero(&action, sizeof(action));
1053     bzero(&action2, sizeof(action2));
1054     bzero(&mouse, sizeof(mouse));
1055     mouse_button_state = S0;
1056     clock_gettime(CLOCK_MONOTONIC_FAST, &mouse_button_state_ts);
1057     mouse_move_delayed = 0;
1058     for (i = 0; i < MOUSE_MAXBUTTON; ++i) {
1059         bstate[i].count = 0;
1060         bstate[i].ts = mouse_button_state_ts;
1061     }
1062     for (i = 0; i < (int)(sizeof(zstate) / sizeof(zstate[0])); ++i) {
1063         zstate[i].count = 0;
1064         zstate[i].ts = mouse_button_state_ts;
1065     }
1066
1067     /* choose which ioctl command to use */
1068     mouse.operation = MOUSE_MOTION_EVENT;
1069     extioctl = (ioctl(rodent.cfd, CONS_MOUSECTL, &mouse) == 0);
1070
1071     /* process mouse data */
1072     timeout.tv_sec = 0;
1073     timeout.tv_usec = 20000;            /* 20 msec */
1074     for (;;) {
1075
1076         FD_ZERO(&fds);
1077         FD_SET(rodent.mfd, &fds);
1078         if (rodent.mremsfd >= 0)
1079             FD_SET(rodent.mremsfd, &fds);
1080         if (rodent.mremcfd >= 0)
1081             FD_SET(rodent.mremcfd, &fds);
1082
1083         c = select(FD_SETSIZE, &fds, NULL, NULL,
1084                    ((rodent.flags & Emulate3Button) &&
1085                     S_DELAYED(mouse_button_state)) ? &timeout : NULL);
1086         if (c < 0) {                    /* error */
1087             logwarn("failed to read from mouse");
1088             continue;
1089         } else if (c == 0) {            /* timeout */
1090             /* assert(rodent.flags & Emulate3Button) */
1091             action0.button = action0.obutton;
1092             action0.dx = action0.dy = action0.dz = 0;
1093             action0.flags = flags = 0;
1094             if (r_timeout() && r_statetrans(&action0, &action, A_TIMEOUT)) {
1095                 if (debug > 2)
1096                     debug("flags:%08x buttons:%08x obuttons:%08x",
1097                           action.flags, action.button, action.obutton);
1098             } else {
1099                 action0.obutton = action0.button;
1100                 continue;
1101             }
1102         } else {
1103             /*  MouseRemote client connect/disconnect  */
1104             if ((rodent.mremsfd >= 0) && FD_ISSET(rodent.mremsfd, &fds)) {
1105                 mremote_clientchg(TRUE);
1106                 continue;
1107             }
1108             if ((rodent.mremcfd >= 0) && FD_ISSET(rodent.mremcfd, &fds)) {
1109                 mremote_clientchg(FALSE);
1110                 continue;
1111             }
1112             /* mouse movement */
1113             if (read(rodent.mfd, &b, 1) == -1) {
1114                 if (errno == EWOULDBLOCK)
1115                     continue;
1116                 else
1117                     return;
1118             }
1119             if ((flags = r_protocol(b, &action0)) == 0)
1120                 continue;
1121
1122             if ((rodent.flags & VirtualScroll) || (rodent.flags & HVirtualScroll)) {
1123                 /* Allow middle button drags to scroll up and down */
1124                 if (action0.button == MOUSE_BUTTON2DOWN) {
1125                     if (scroll_state == SCROLL_NOTSCROLLING) {
1126                         scroll_state = SCROLL_PREPARE;
1127                         scroll_movement = hscroll_movement = 0;
1128                         debug("PREPARING TO SCROLL");
1129                     }
1130                     debug("[BUTTON2] flags:%08x buttons:%08x obuttons:%08x",
1131                           action.flags, action.button, action.obutton);
1132                 } else {
1133                     debug("[NOTBUTTON2] flags:%08x buttons:%08x obuttons:%08x",
1134                           action.flags, action.button, action.obutton);
1135
1136                     /* This isn't a middle button down... move along... */
1137                     if (scroll_state == SCROLL_SCROLLING) {
1138                         /*
1139                          * We were scrolling, someone let go of button 2.
1140                          * Now turn autoscroll off.
1141                          */
1142                         scroll_state = SCROLL_NOTSCROLLING;
1143                         debug("DONE WITH SCROLLING / %d", scroll_state);
1144                     } else if (scroll_state == SCROLL_PREPARE) {
1145                         mousestatus_t newaction = action0;
1146
1147                         /* We were preparing to scroll, but we never moved... */
1148                         r_timestamp(&action0);
1149                         r_statetrans(&action0, &newaction,
1150                                      A(newaction.button & MOUSE_BUTTON1DOWN,
1151                                        action0.button & MOUSE_BUTTON3DOWN));
1152
1153                         /* Send middle down */
1154                         newaction.button = MOUSE_BUTTON2DOWN;
1155                         r_click(&newaction);
1156
1157                         /* Send middle up */
1158                         r_timestamp(&newaction);
1159                         newaction.obutton = newaction.button;
1160                         newaction.button = action0.button;
1161                         r_click(&newaction);
1162                     }
1163                 }
1164             }
1165
1166             r_timestamp(&action0);
1167             r_statetrans(&action0, &action,
1168                          A(action0.button & MOUSE_BUTTON1DOWN,
1169                            action0.button & MOUSE_BUTTON3DOWN));
1170             debug("flags:%08x buttons:%08x obuttons:%08x", action.flags,
1171                   action.button, action.obutton);
1172         }
1173         action0.obutton = action0.button;
1174         flags &= MOUSE_POSCHANGED;
1175         flags |= action.obutton ^ action.button;
1176         action.flags = flags;
1177
1178         if (flags) {                    /* handler detected action */
1179             r_map(&action, &action2);
1180             debug("activity : buttons 0x%08x  dx %d  dy %d  dz %d",
1181                 action2.button, action2.dx, action2.dy, action2.dz);
1182
1183             if ((rodent.flags & VirtualScroll) || (rodent.flags & HVirtualScroll)) {
1184                 /*
1185                  * If *only* the middle button is pressed AND we are moving
1186                  * the stick/trackpoint/nipple, scroll!
1187                  */
1188                 if (scroll_state == SCROLL_PREPARE) {
1189                         /* Middle button down, waiting for movement threshold */
1190                         if (action2.dy || action2.dx) {
1191                                 if (rodent.flags & VirtualScroll) {
1192                                         scroll_movement += action2.dy;
1193                                         if (scroll_movement < -rodent.scrollthreshold) {
1194                                                 scroll_state = SCROLL_SCROLLING;
1195                                         } else if (scroll_movement > rodent.scrollthreshold) {
1196                                                 scroll_state = SCROLL_SCROLLING;
1197                                         }
1198                                 }
1199                                 if (rodent.flags & HVirtualScroll) {
1200                                         hscroll_movement += action2.dx;
1201                                         if (hscroll_movement < -rodent.scrollthreshold) {
1202                                                 scroll_state = SCROLL_SCROLLING;
1203                                         } else if (hscroll_movement > rodent.scrollthreshold) {
1204                                                 scroll_state = SCROLL_SCROLLING;
1205                                         }
1206                                 }
1207                                 if (scroll_state == SCROLL_SCROLLING) scroll_movement = hscroll_movement = 0;
1208                         }
1209                 } else if (scroll_state == SCROLL_SCROLLING) {
1210                          if (rodent.flags & VirtualScroll) {
1211                                  scroll_movement += action2.dy;
1212                                  debug("SCROLL: %d", scroll_movement);
1213                             if (scroll_movement < -rodent.scrollspeed) {
1214                                 /* Scroll down */
1215                                 action2.dz = -1;
1216                                 scroll_movement = 0;
1217                             }
1218                             else if (scroll_movement > rodent.scrollspeed) {
1219                                 /* Scroll up */
1220                                 action2.dz = 1;
1221                                 scroll_movement = 0;
1222                             }
1223                          }
1224                          if (rodent.flags & HVirtualScroll) {
1225                                  hscroll_movement += action2.dx;
1226                                  debug("HORIZONTAL SCROLL: %d", hscroll_movement);
1227
1228                                  if (hscroll_movement < -rodent.scrollspeed) {
1229                                          action2.dz = -2;
1230                                          hscroll_movement = 0;
1231                                  }
1232                                  else if (hscroll_movement > rodent.scrollspeed) {
1233                                          action2.dz = 2;
1234                                          hscroll_movement = 0;
1235                                  }
1236                          }
1237
1238                     /* Don't move while scrolling */
1239                     action2.dx = action2.dy = 0;
1240                 }
1241             }
1242
1243             if (drift_terminate) {
1244                 if ((flags & MOUSE_POSCHANGED) == 0 || action.dz || action2.dz)
1245                     drift_last_activity = drift_current_ts;
1246                 else {
1247                     /* X or/and Y movement only - possibly drift */
1248                     tssub(&drift_current_ts, &drift_last_activity, &drift_tmp);
1249                     if (tscmp(&drift_tmp, &drift_after_ts, >)) {
1250                         tssub(&drift_current_ts, &drift_since, &drift_tmp);
1251                         if (tscmp(&drift_tmp, &drift_time_ts, <)) {
1252                             drift_last.x += action2.dx;
1253                             drift_last.y += action2.dy;
1254                         } else {
1255                             /* discard old accumulated steps (drift) */
1256                             if (tscmp(&drift_tmp, &drift_2time_ts, >))
1257                                 drift_previous.x = drift_previous.y = 0;
1258                             else
1259                                 drift_previous = drift_last;
1260                             drift_last.x = action2.dx;
1261                             drift_last.y = action2.dy;
1262                             drift_since = drift_current_ts;
1263                         }
1264                         if (abs(drift_last.x) + abs(drift_last.y)
1265                           > drift_distance) {
1266                             /* real movement, pass all accumulated steps */
1267                             action2.dx = drift_previous.x + drift_last.x;
1268                             action2.dy = drift_previous.y + drift_last.y;
1269                             /* and reset accumulators */
1270                             tsclr(&drift_since);
1271                             drift_last.x = drift_last.y = 0;
1272                             /* drift_previous will be cleared at next movement*/
1273                             drift_last_activity = drift_current_ts;
1274                         } else {
1275                             continue;   /* don't pass current movement to
1276                                          * console driver */
1277                         }
1278                     }
1279                 }
1280             }
1281
1282             if (extioctl) {
1283                 /* Defer clicks until we aren't VirtualScroll'ing. */
1284                 if (scroll_state == SCROLL_NOTSCROLLING)
1285                     r_click(&action2);
1286
1287                 if (action2.flags & MOUSE_POSCHANGED) {
1288                     mouse.operation = MOUSE_MOTION_EVENT;
1289                     mouse.u.data.buttons = action2.button;
1290                     if (rodent.flags & ExponentialAcc) {
1291                         expoacc(action2.dx, action2.dy,
1292                             &mouse.u.data.x, &mouse.u.data.y);
1293                     }
1294                     else {
1295                         linacc(action2.dx, action2.dy,
1296                             &mouse.u.data.x, &mouse.u.data.y);
1297                     }
1298                     mouse.u.data.z = action2.dz;
1299                     if (debug < 2)
1300                         if (!paused)
1301                                 ioctl(rodent.cfd, CONS_MOUSECTL, &mouse);
1302                 }
1303             } else {
1304                 mouse.operation = MOUSE_ACTION;
1305                 mouse.u.data.buttons = action2.button;
1306                 if (rodent.flags & ExponentialAcc) {
1307                     expoacc(action2.dx, action2.dy,
1308                         &mouse.u.data.x, &mouse.u.data.y);
1309                 }
1310                 else {
1311                     linacc(action2.dx, action2.dy,
1312                         &mouse.u.data.x, &mouse.u.data.y);
1313                 }
1314                 mouse.u.data.z = action2.dz;
1315                 if (debug < 2)
1316                     if (!paused)
1317                         ioctl(rodent.cfd, CONS_MOUSECTL, &mouse);
1318             }
1319
1320             /*
1321              * If the Z axis movement is mapped to an imaginary physical
1322              * button, we need to cook up a corresponding button `up' event
1323              * after sending a button `down' event.
1324              */
1325             if ((rodent.zmap[0] > 0) && (action.dz != 0)) {
1326                 action.obutton = action.button;
1327                 action.dx = action.dy = action.dz = 0;
1328                 r_map(&action, &action2);
1329                 debug("activity : buttons 0x%08x  dx %d  dy %d  dz %d",
1330                     action2.button, action2.dx, action2.dy, action2.dz);
1331
1332                 if (extioctl) {
1333                     r_click(&action2);
1334                 } else {
1335                     mouse.operation = MOUSE_ACTION;
1336                     mouse.u.data.buttons = action2.button;
1337                     mouse.u.data.x = mouse.u.data.y = mouse.u.data.z = 0;
1338                     if (debug < 2)
1339                         if (!paused)
1340                             ioctl(rodent.cfd, CONS_MOUSECTL, &mouse);
1341                 }
1342             }
1343         }
1344     }
1345     /* NOT REACHED */
1346 }
1347
1348 static void
1349 hup(__unused int sig)
1350 {
1351     longjmp(env, 1);
1352 }
1353
1354 static void
1355 cleanup(__unused int sig)
1356 {
1357     if (rodent.rtype == MOUSE_PROTO_X10MOUSEREM)
1358         unlink(_PATH_MOUSEREMOTE);
1359     exit(0);
1360 }
1361
1362 static void
1363 pause_mouse(__unused int sig)
1364 {
1365     paused = !paused;
1366 }
1367
1368 /**
1369  ** usage
1370  **
1371  ** Complain, and free the CPU for more worthy tasks
1372  **/
1373 static void
1374 usage(void)
1375 {
1376     fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n",
1377         "usage: moused [-DRcdfs] [-I file] [-F rate] [-r resolution] [-S baudrate]",
1378         "              [-VH [-U threshold]] [-a X[,Y]] [-C threshold] [-m N=M] [-w N]",
1379         "              [-z N] [-t <mousetype>] [-l level] [-3 [-E timeout]]",
1380         "              [-T distance[,time[,after]]] -p <port>",
1381         "       moused [-d] -i <port|if|type|model|all> -p <port>");
1382     exit(1);
1383 }
1384
1385 /*
1386  * Output an error message to syslog or stderr as appropriate. If
1387  * `errnum' is non-zero, append its string form to the message.
1388  */
1389 static void
1390 log_or_warn(int log_pri, int errnum, const char *fmt, ...)
1391 {
1392         va_list ap;
1393         char buf[256];
1394
1395         va_start(ap, fmt);
1396         vsnprintf(buf, sizeof(buf), fmt, ap);
1397         va_end(ap);
1398         if (errnum) {
1399                 strlcat(buf, ": ", sizeof(buf));
1400                 strlcat(buf, strerror(errnum), sizeof(buf));
1401         }
1402
1403         if (background)
1404                 syslog(log_pri, "%s", buf);
1405         else
1406                 warnx("%s", buf);
1407 }
1408
1409 /**
1410  ** Mouse interface code, courtesy of XFree86 3.1.2.
1411  **
1412  ** Note: Various bits have been trimmed, and in my shortsighted enthusiasm
1413  ** to clean, reformat and rationalise naming, it's quite possible that
1414  ** some things in here have been broken.
1415  **
1416  ** I hope not 8)
1417  **
1418  ** The following code is derived from a module marked :
1419  **/
1420
1421 /* $XConsortium: xf86_Mouse.c,v 1.2 94/10/12 20:33:21 kaleb Exp $ */
1422 /* $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86_Mouse.c,v 3.2 1995/01/28
1423  17:03:40 dawes Exp $ */
1424 /*
1425  *
1426  * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
1427  * Copyright 1993 by David Dawes <dawes@physics.su.oz.au>
1428  *
1429  * Permission to use, copy, modify, distribute, and sell this software and its
1430  * documentation for any purpose is hereby granted without fee, provided that
1431  * the above copyright notice appear in all copies and that both that
1432  * copyright notice and this permission notice appear in supporting
1433  * documentation, and that the names of Thomas Roell and David Dawes not be
1434  * used in advertising or publicity pertaining to distribution of the
1435  * software without specific, written prior permission.  Thomas Roell
1436  * and David Dawes makes no representations about the suitability of this
1437  * software for any purpose.  It is provided "as is" without express or
1438  * implied warranty.
1439  *
1440  * THOMAS ROELL AND DAVID DAWES DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
1441  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
1442  * FITNESS, IN NO EVENT SHALL THOMAS ROELL OR DAVID DAWES BE LIABLE FOR ANY
1443  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
1444  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
1445  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
1446  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1447  *
1448  */
1449
1450 /**
1451  ** GlidePoint support from XFree86 3.2.
1452  ** Derived from the module:
1453  **/
1454
1455 /* $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86_Mouse.c,v 3.19 1996/10/16 14:40:51 dawes Exp $ */
1456 /* $XConsortium: xf86_Mouse.c /main/10 1996/01/30 15:16:12 kaleb $ */
1457
1458 /* the following table must be ordered by MOUSE_PROTO_XXX in mouse.h */
1459 static unsigned char proto[][7] = {
1460     /*  hd_mask hd_id   dp_mask dp_id   bytes b4_mask b4_id */
1461     {   0x40,   0x40,   0x40,   0x00,   3,   ~0x23,  0x00 }, /* MicroSoft */
1462     {   0xf8,   0x80,   0x00,   0x00,   5,    0x00,  0xff }, /* MouseSystems */
1463     {   0xe0,   0x80,   0x80,   0x00,   3,    0x00,  0xff }, /* Logitech */
1464     {   0xe0,   0x80,   0x80,   0x00,   3,    0x00,  0xff }, /* MMSeries */
1465     {   0x40,   0x40,   0x40,   0x00,   3,   ~0x33,  0x00 }, /* MouseMan */
1466     {   0xf8,   0x80,   0x00,   0x00,   5,    0x00,  0xff }, /* Bus */
1467     {   0xf8,   0x80,   0x00,   0x00,   5,    0x00,  0xff }, /* InPort */
1468     {   0xc0,   0x00,   0x00,   0x00,   3,    0x00,  0xff }, /* PS/2 mouse */
1469     {   0xe0,   0x80,   0x80,   0x00,   3,    0x00,  0xff }, /* MM HitTablet */
1470     {   0x40,   0x40,   0x40,   0x00,   3,   ~0x33,  0x00 }, /* GlidePoint */
1471     {   0x40,   0x40,   0x40,   0x00,   3,   ~0x3f,  0x00 }, /* IntelliMouse */
1472     {   0x40,   0x40,   0x40,   0x00,   3,   ~0x33,  0x00 }, /* ThinkingMouse */
1473     {   0xf8,   0x80,   0x00,   0x00,   5,    0x00,  0xff }, /* sysmouse */
1474     {   0x40,   0x40,   0x40,   0x00,   3,   ~0x23,  0x00 }, /* X10 MouseRem */
1475     {   0x80,   0x80,   0x00,   0x00,   5,    0x00,  0xff }, /* KIDSPAD */
1476     {   0xc3,   0xc0,   0x00,   0x00,   6,    0x00,  0xff }, /* VersaPad */
1477     {   0x00,   0x00,   0x00,   0x00,   1,    0x00,  0xff }, /* JogDial */
1478 #if notyet
1479     {   0xf8,   0x80,   0x00,   0x00,   5,   ~0x2f,  0x10 }, /* Mariqua */
1480 #endif
1481 };
1482 static unsigned char cur_proto[7];
1483
1484 static int
1485 r_identify(void)
1486 {
1487     char pnpbuf[256];   /* PnP identifier string may be up to 256 bytes long */
1488     pnpid_t pnpid;
1489     symtab_t *t;
1490     int level;
1491     int len;
1492
1493     /* set the driver operation level, if applicable */
1494     if (rodent.level < 0)
1495         rodent.level = 1;
1496     ioctl(rodent.mfd, MOUSE_SETLEVEL, &rodent.level);
1497     rodent.level = (ioctl(rodent.mfd, MOUSE_GETLEVEL, &level) == 0) ? level : 0;
1498
1499     /*
1500      * Interrogate the driver and get some intelligence on the device...
1501      * The following ioctl functions are not always supported by device
1502      * drivers.  When the driver doesn't support them, we just trust the
1503      * user to supply valid information.
1504      */
1505     rodent.hw.iftype = MOUSE_IF_UNKNOWN;
1506     rodent.hw.model = MOUSE_MODEL_GENERIC;
1507     ioctl(rodent.mfd, MOUSE_GETHWINFO, &rodent.hw);
1508
1509     if (rodent.rtype != MOUSE_PROTO_UNKNOWN)
1510         bcopy(proto[rodent.rtype], cur_proto, sizeof(cur_proto));
1511     rodent.mode.protocol = MOUSE_PROTO_UNKNOWN;
1512     rodent.mode.rate = -1;
1513     rodent.mode.resolution = MOUSE_RES_UNKNOWN;
1514     rodent.mode.accelfactor = 0;
1515     rodent.mode.level = 0;
1516     if (ioctl(rodent.mfd, MOUSE_GETMODE, &rodent.mode) == 0) {
1517         if (rodent.mode.protocol == MOUSE_PROTO_UNKNOWN ||
1518             rodent.mode.protocol >= (int)(sizeof(proto) / sizeof(proto[0]))) {
1519             logwarnx("unknown mouse protocol (%d)", rodent.mode.protocol);
1520             return (MOUSE_PROTO_UNKNOWN);
1521         } else {
1522             /* INPORT and BUS are the same... */
1523             if (rodent.mode.protocol == MOUSE_PROTO_INPORT)
1524                 rodent.mode.protocol = MOUSE_PROTO_BUS;
1525             if (rodent.mode.protocol != rodent.rtype) {
1526                 /* Hmm, the driver doesn't agree with the user... */
1527                 if (rodent.rtype != MOUSE_PROTO_UNKNOWN)
1528                     logwarnx("mouse type mismatch (%s != %s), %s is assumed",
1529                         r_name(rodent.mode.protocol), r_name(rodent.rtype),
1530                         r_name(rodent.mode.protocol));
1531                 rodent.rtype = rodent.mode.protocol;
1532                 bcopy(proto[rodent.rtype], cur_proto, sizeof(cur_proto));
1533             }
1534         }
1535         cur_proto[4] = rodent.mode.packetsize;
1536         cur_proto[0] = rodent.mode.syncmask[0]; /* header byte bit mask */
1537         cur_proto[1] = rodent.mode.syncmask[1]; /* header bit pattern */
1538     }
1539
1540     /* maybe this is a PnP mouse... */
1541     if (rodent.mode.protocol == MOUSE_PROTO_UNKNOWN) {
1542
1543         if (rodent.flags & NoPnP)
1544             return (rodent.rtype);
1545         if (((len = pnpgets(pnpbuf)) <= 0) || !pnpparse(&pnpid, pnpbuf, len))
1546             return (rodent.rtype);
1547
1548         debug("PnP serial mouse: '%*.*s' '%*.*s' '%*.*s'",
1549             pnpid.neisaid, pnpid.neisaid, pnpid.eisaid,
1550             pnpid.ncompat, pnpid.ncompat, pnpid.compat,
1551             pnpid.ndescription, pnpid.ndescription, pnpid.description);
1552
1553         /* we have a valid PnP serial device ID */
1554         rodent.hw.iftype = MOUSE_IF_SERIAL;
1555         t = pnpproto(&pnpid);
1556         if (t != NULL) {
1557             rodent.mode.protocol = t->val;
1558             rodent.hw.model = t->val2;
1559         } else {
1560             rodent.mode.protocol = MOUSE_PROTO_UNKNOWN;
1561         }
1562         if (rodent.mode.protocol == MOUSE_PROTO_INPORT)
1563             rodent.mode.protocol = MOUSE_PROTO_BUS;
1564
1565         /* make final adjustment */
1566         if (rodent.mode.protocol != MOUSE_PROTO_UNKNOWN) {
1567             if (rodent.mode.protocol != rodent.rtype) {
1568                 /* Hmm, the device doesn't agree with the user... */
1569                 if (rodent.rtype != MOUSE_PROTO_UNKNOWN)
1570                     logwarnx("mouse type mismatch (%s != %s), %s is assumed",
1571                         r_name(rodent.mode.protocol), r_name(rodent.rtype),
1572                         r_name(rodent.mode.protocol));
1573                 rodent.rtype = rodent.mode.protocol;
1574                 bcopy(proto[rodent.rtype], cur_proto, sizeof(cur_proto));
1575             }
1576         }
1577     }
1578
1579     debug("proto params: %02x %02x %02x %02x %d %02x %02x",
1580         cur_proto[0], cur_proto[1], cur_proto[2], cur_proto[3],
1581         cur_proto[4], cur_proto[5], cur_proto[6]);
1582
1583     return (rodent.rtype);
1584 }
1585
1586 static const char *
1587 r_if(int iftype)
1588 {
1589
1590     return (gettokenname(rifs, iftype));
1591 }
1592
1593 static const char *
1594 r_name(int type)
1595 {
1596     const char *unknown = "unknown";
1597
1598     return (type == MOUSE_PROTO_UNKNOWN ||
1599         type >= (int)(sizeof(rnames) / sizeof(rnames[0])) ?
1600         unknown : rnames[type]);
1601 }
1602
1603 static const char *
1604 r_model(int model)
1605 {
1606
1607     return (gettokenname(rmodels, model));
1608 }
1609
1610 static void
1611 r_init(void)
1612 {
1613     unsigned char buf[16];      /* scrach buffer */
1614     fd_set fds;
1615     const char *s;
1616     char c;
1617     int i;
1618
1619     /**
1620      ** This comment is a little out of context here, but it contains
1621      ** some useful information...
1622      ********************************************************************
1623      **
1624      ** The following lines take care of the Logitech MouseMan protocols.
1625      **
1626      ** NOTE: There are different versions of both MouseMan and TrackMan!
1627      **       Hence I add another protocol P_LOGIMAN, which the user can
1628      **       specify as MouseMan in his XF86Config file. This entry was
1629      **       formerly handled as a special case of P_MS. However, people
1630      **       who don't have the middle button problem, can still specify
1631      **       Microsoft and use P_MS.
1632      **
1633      ** By default, these mice should use a 3 byte Microsoft protocol
1634      ** plus a 4th byte for the middle button. However, the mouse might
1635      ** have switched to a different protocol before we use it, so I send
1636      ** the proper sequence just in case.
1637      **
1638      ** NOTE: - all commands to (at least the European) MouseMan have to
1639      **         be sent at 1200 Baud.
1640      **       - each command starts with a '*'.
1641      **       - whenever the MouseMan receives a '*', it will switch back
1642      **  to 1200 Baud. Hence I have to select the desired protocol
1643      **  first, then select the baud rate.
1644      **
1645      ** The protocols supported by the (European) MouseMan are:
1646      **   -  5 byte packed binary protocol, as with the Mouse Systems
1647      **      mouse. Selected by sequence "*U".
1648      **   -  2 button 3 byte MicroSoft compatible protocol. Selected
1649      **      by sequence "*V".
1650      **   -  3 button 3+1 byte MicroSoft compatible protocol (default).
1651      **      Selected by sequence "*X".
1652      **
1653      ** The following baud rates are supported:
1654      **   -  1200 Baud (default). Selected by sequence "*n".
1655      **   -  9600 Baud. Selected by sequence "*q".
1656      **
1657      ** Selecting a sample rate is no longer supported with the MouseMan!
1658      ** Some additional lines in xf86Config.c take care of ill configured
1659      ** baud rates and sample rates. (The user will get an error.)
1660      */
1661
1662     switch (rodent.rtype) {
1663
1664     case MOUSE_PROTO_LOGI:
1665         /*
1666          * The baud rate selection command must be sent at the current
1667          * baud rate; try all likely settings
1668          */
1669         setmousespeed(9600, rodent.baudrate, rodentcflags[rodent.rtype]);
1670         setmousespeed(4800, rodent.baudrate, rodentcflags[rodent.rtype]);
1671         setmousespeed(2400, rodent.baudrate, rodentcflags[rodent.rtype]);
1672         setmousespeed(1200, rodent.baudrate, rodentcflags[rodent.rtype]);
1673         /* select MM series data format */
1674         write(rodent.mfd, "S", 1);
1675         setmousespeed(rodent.baudrate, rodent.baudrate,
1676                       rodentcflags[MOUSE_PROTO_MM]);
1677         /* select report rate/frequency */
1678         if      (rodent.rate <= 0)   write(rodent.mfd, "O", 1);
1679         else if (rodent.rate <= 15)  write(rodent.mfd, "J", 1);
1680         else if (rodent.rate <= 27)  write(rodent.mfd, "K", 1);
1681         else if (rodent.rate <= 42)  write(rodent.mfd, "L", 1);
1682         else if (rodent.rate <= 60)  write(rodent.mfd, "R", 1);
1683         else if (rodent.rate <= 85)  write(rodent.mfd, "M", 1);
1684         else if (rodent.rate <= 125) write(rodent.mfd, "Q", 1);
1685         else                         write(rodent.mfd, "N", 1);
1686         break;
1687
1688     case MOUSE_PROTO_LOGIMOUSEMAN:
1689         /* The command must always be sent at 1200 baud */
1690         setmousespeed(1200, 1200, rodentcflags[rodent.rtype]);
1691         write(rodent.mfd, "*X", 2);
1692         setmousespeed(1200, rodent.baudrate, rodentcflags[rodent.rtype]);
1693         break;
1694
1695     case MOUSE_PROTO_HITTAB:
1696         setmousespeed(1200, rodent.baudrate, rodentcflags[rodent.rtype]);
1697
1698         /*
1699          * Initialize Hitachi PUMA Plus - Model 1212E to desired settings.
1700          * The tablet must be configured to be in MM mode, NO parity,
1701          * Binary Format.  xf86Info.sampleRate controls the sensativity
1702          * of the tablet.  We only use this tablet for it's 4-button puck
1703          * so we don't run in "Absolute Mode"
1704          */
1705         write(rodent.mfd, "z8", 2);     /* Set Parity = "NONE" */
1706         usleep(50000);
1707         write(rodent.mfd, "zb", 2);     /* Set Format = "Binary" */
1708         usleep(50000);
1709         write(rodent.mfd, "@", 1);      /* Set Report Mode = "Stream" */
1710         usleep(50000);
1711         write(rodent.mfd, "R", 1);      /* Set Output Rate = "45 rps" */
1712         usleep(50000);
1713         write(rodent.mfd, "I\x20", 2);  /* Set Incrememtal Mode "20" */
1714         usleep(50000);
1715         write(rodent.mfd, "E", 1);      /* Set Data Type = "Relative */
1716         usleep(50000);
1717
1718         /* Resolution is in 'lines per inch' on the Hitachi tablet */
1719         if      (rodent.resolution == MOUSE_RES_LOW)            c = 'g';
1720         else if (rodent.resolution == MOUSE_RES_MEDIUMLOW)      c = 'e';
1721         else if (rodent.resolution == MOUSE_RES_MEDIUMHIGH)     c = 'h';
1722         else if (rodent.resolution == MOUSE_RES_HIGH)           c = 'd';
1723         else if (rodent.resolution <=   40)                     c = 'g';
1724         else if (rodent.resolution <=  100)                     c = 'd';
1725         else if (rodent.resolution <=  200)                     c = 'e';
1726         else if (rodent.resolution <=  500)                     c = 'h';
1727         else if (rodent.resolution <= 1000)                     c = 'j';
1728         else                    c = 'd';
1729         write(rodent.mfd, &c, 1);
1730         usleep(50000);
1731
1732         write(rodent.mfd, "\021", 1);   /* Resume DATA output */
1733         break;
1734
1735     case MOUSE_PROTO_THINK:
1736         setmousespeed(1200, rodent.baudrate, rodentcflags[rodent.rtype]);
1737         /* the PnP ID string may be sent again, discard it */
1738         usleep(200000);
1739         i = FREAD;
1740         ioctl(rodent.mfd, TIOCFLUSH, &i);
1741         /* send the command to initialize the beast */
1742         for (s = "E5E5"; *s; ++s) {
1743             write(rodent.mfd, s, 1);
1744             FD_ZERO(&fds);
1745             FD_SET(rodent.mfd, &fds);
1746             if (select(FD_SETSIZE, &fds, NULL, NULL, NULL) <= 0)
1747                 break;
1748             read(rodent.mfd, &c, 1);
1749             debug("%c", c);
1750             if (c != *s)
1751                 break;
1752         }
1753         break;
1754
1755     case MOUSE_PROTO_JOGDIAL:
1756         break;
1757     case MOUSE_PROTO_MSC:
1758         setmousespeed(1200, rodent.baudrate, rodentcflags[rodent.rtype]);
1759         if (rodent.flags & ClearDTR) {
1760            i = TIOCM_DTR;
1761            ioctl(rodent.mfd, TIOCMBIC, &i);
1762         }
1763         if (rodent.flags & ClearRTS) {
1764            i = TIOCM_RTS;
1765            ioctl(rodent.mfd, TIOCMBIC, &i);
1766         }
1767         break;
1768
1769     case MOUSE_PROTO_SYSMOUSE:
1770         if (rodent.hw.iftype == MOUSE_IF_SYSMOUSE)
1771             setmousespeed(1200, rodent.baudrate, rodentcflags[rodent.rtype]);
1772         /* FALLTHROUGH */
1773
1774     case MOUSE_PROTO_BUS:
1775     case MOUSE_PROTO_INPORT:
1776     case MOUSE_PROTO_PS2:
1777         if (rodent.rate >= 0)
1778             rodent.mode.rate = rodent.rate;
1779         if (rodent.resolution != MOUSE_RES_UNKNOWN)
1780             rodent.mode.resolution = rodent.resolution;
1781         ioctl(rodent.mfd, MOUSE_SETMODE, &rodent.mode);
1782         break;
1783
1784     case MOUSE_PROTO_X10MOUSEREM:
1785         mremote_serversetup();
1786         setmousespeed(1200, rodent.baudrate, rodentcflags[rodent.rtype]);
1787         break;
1788
1789
1790     case MOUSE_PROTO_VERSAPAD:
1791         tcsendbreak(rodent.mfd, 0);     /* send break for 400 msec */
1792         i = FREAD;
1793         ioctl(rodent.mfd, TIOCFLUSH, &i);
1794         for (i = 0; i < 7; ++i) {
1795             FD_ZERO(&fds);
1796             FD_SET(rodent.mfd, &fds);
1797             if (select(FD_SETSIZE, &fds, NULL, NULL, NULL) <= 0)
1798                 break;
1799             read(rodent.mfd, &c, 1);
1800             buf[i] = c;
1801         }
1802         debug("%s\n", buf);
1803         if ((buf[0] != 'V') || (buf[1] != 'P')|| (buf[7] != '\r'))
1804             break;
1805         setmousespeed(9600, rodent.baudrate, rodentcflags[rodent.rtype]);
1806         tcsendbreak(rodent.mfd, 0);     /* send break for 400 msec again */
1807         for (i = 0; i < 7; ++i) {
1808             FD_ZERO(&fds);
1809             FD_SET(rodent.mfd, &fds);
1810             if (select(FD_SETSIZE, &fds, NULL, NULL, NULL) <= 0)
1811                 break;
1812             read(rodent.mfd, &c, 1);
1813             debug("%c", c);
1814             if (c != buf[i])
1815                 break;
1816         }
1817         i = FREAD;
1818         ioctl(rodent.mfd, TIOCFLUSH, &i);
1819         break;
1820
1821     default:
1822         setmousespeed(1200, rodent.baudrate, rodentcflags[rodent.rtype]);
1823         break;
1824     }
1825 }
1826
1827 static int
1828 r_protocol(u_char rBuf, mousestatus_t *act)
1829 {
1830     /* MOUSE_MSS_BUTTON?DOWN -> MOUSE_BUTTON?DOWN */
1831     static int butmapmss[4] = { /* Microsoft, MouseMan, GlidePoint,
1832                                    IntelliMouse, Thinking Mouse */
1833         0,
1834         MOUSE_BUTTON3DOWN,
1835         MOUSE_BUTTON1DOWN,
1836         MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN,
1837     };
1838     static int butmapmss2[4] = { /* Microsoft, MouseMan, GlidePoint,
1839                                     Thinking Mouse */
1840         0,
1841         MOUSE_BUTTON4DOWN,
1842         MOUSE_BUTTON2DOWN,
1843         MOUSE_BUTTON2DOWN | MOUSE_BUTTON4DOWN,
1844     };
1845     /* MOUSE_INTELLI_BUTTON?DOWN -> MOUSE_BUTTON?DOWN */
1846     static int butmapintelli[4] = { /* IntelliMouse, NetMouse, Mie Mouse,
1847                                        MouseMan+ */
1848         0,
1849         MOUSE_BUTTON2DOWN,
1850         MOUSE_BUTTON4DOWN,
1851         MOUSE_BUTTON2DOWN | MOUSE_BUTTON4DOWN,
1852     };
1853     /* MOUSE_MSC_BUTTON?UP -> MOUSE_BUTTON?DOWN */
1854     static int butmapmsc[8] = { /* MouseSystems, MMSeries, Logitech,
1855                                    Bus, sysmouse */
1856         0,
1857         MOUSE_BUTTON3DOWN,
1858         MOUSE_BUTTON2DOWN,
1859         MOUSE_BUTTON2DOWN | MOUSE_BUTTON3DOWN,
1860         MOUSE_BUTTON1DOWN,
1861         MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN,
1862         MOUSE_BUTTON1DOWN | MOUSE_BUTTON2DOWN,
1863         MOUSE_BUTTON1DOWN | MOUSE_BUTTON2DOWN | MOUSE_BUTTON3DOWN
1864     };
1865     /* MOUSE_PS2_BUTTON?DOWN -> MOUSE_BUTTON?DOWN */
1866     static int butmapps2[8] = { /* PS/2 */
1867         0,
1868         MOUSE_BUTTON1DOWN,
1869         MOUSE_BUTTON3DOWN,
1870         MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN,
1871         MOUSE_BUTTON2DOWN,
1872         MOUSE_BUTTON1DOWN | MOUSE_BUTTON2DOWN,
1873         MOUSE_BUTTON2DOWN | MOUSE_BUTTON3DOWN,
1874         MOUSE_BUTTON1DOWN | MOUSE_BUTTON2DOWN | MOUSE_BUTTON3DOWN
1875     };
1876     /* for Hitachi tablet */
1877     static int butmaphit[8] = { /* MM HitTablet */
1878         0,
1879         MOUSE_BUTTON3DOWN,
1880         MOUSE_BUTTON2DOWN,
1881         MOUSE_BUTTON1DOWN,
1882         MOUSE_BUTTON4DOWN,
1883         MOUSE_BUTTON5DOWN,
1884         MOUSE_BUTTON6DOWN,
1885         MOUSE_BUTTON7DOWN,
1886     };
1887     /* for serial VersaPad */
1888     static int butmapversa[8] = { /* VersaPad */
1889         0,
1890         0,
1891         MOUSE_BUTTON3DOWN,
1892         MOUSE_BUTTON3DOWN,
1893         MOUSE_BUTTON1DOWN,
1894         MOUSE_BUTTON1DOWN,
1895         MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN,
1896         MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN,
1897     };
1898     /* for PS/2 VersaPad */
1899     static int butmapversaps2[8] = { /* VersaPad */
1900         0,
1901         MOUSE_BUTTON3DOWN,
1902         0,
1903         MOUSE_BUTTON3DOWN,
1904         MOUSE_BUTTON1DOWN,
1905         MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN,
1906         MOUSE_BUTTON1DOWN,
1907         MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN,
1908     };
1909     static int           pBufP = 0;
1910     static unsigned char pBuf[8];
1911     static int           prev_x, prev_y;
1912     static int           on = FALSE;
1913     int                  x, y;
1914
1915     debug("received char 0x%x",(int)rBuf);
1916     if (rodent.rtype == MOUSE_PROTO_KIDSPAD)
1917         return (kidspad(rBuf, act));
1918     if (rodent.rtype == MOUSE_PROTO_GTCO_DIGIPAD)
1919         return (gtco_digipad(rBuf, act));
1920
1921     /*
1922      * Hack for resyncing: We check here for a package that is:
1923      *  a) illegal (detected by wrong data-package header)
1924      *  b) invalid (0x80 == -128 and that might be wrong for MouseSystems)
1925      *  c) bad header-package
1926      *
1927      * NOTE: b) is a voilation of the MouseSystems-Protocol, since values of
1928      *       -128 are allowed, but since they are very seldom we can easily
1929      *       use them as package-header with no button pressed.
1930      * NOTE/2: On a PS/2 mouse any byte is valid as a data byte. Furthermore,
1931      *         0x80 is not valid as a header byte. For a PS/2 mouse we skip
1932      *         checking data bytes.
1933      *         For resyncing a PS/2 mouse we require the two most significant
1934      *         bits in the header byte to be 0. These are the overflow bits,
1935      *         and in case of an overflow we actually lose sync. Overflows
1936      *         are very rare, however, and we quickly gain sync again after
1937      *         an overflow condition. This is the best we can do. (Actually,
1938      *         we could use bit 0x08 in the header byte for resyncing, since
1939      *         that bit is supposed to be always on, but nobody told
1940      *         Microsoft...)
1941      */
1942
1943     if (pBufP != 0 && rodent.rtype != MOUSE_PROTO_PS2 &&
1944         ((rBuf & cur_proto[2]) != cur_proto[3] || rBuf == 0x80))
1945     {
1946         pBufP = 0;              /* skip package */
1947     }
1948
1949     if (pBufP == 0 && (rBuf & cur_proto[0]) != cur_proto[1])
1950         return (0);
1951
1952     /* is there an extra data byte? */
1953     if (pBufP >= cur_proto[4] && (rBuf & cur_proto[0]) != cur_proto[1])
1954     {
1955         /*
1956          * Hack for Logitech MouseMan Mouse - Middle button
1957          *
1958          * Unfortunately this mouse has variable length packets: the standard
1959          * Microsoft 3 byte packet plus an optional 4th byte whenever the
1960          * middle button status changes.
1961          *
1962          * We have already processed the standard packet with the movement
1963          * and button info.  Now post an event message with the old status
1964          * of the left and right buttons and the updated middle button.
1965          */
1966
1967         /*
1968          * Even worse, different MouseMen and TrackMen differ in the 4th
1969          * byte: some will send 0x00/0x20, others 0x01/0x21, or even
1970          * 0x02/0x22, so I have to strip off the lower bits.
1971          *
1972          * [JCH-96/01/21]
1973          * HACK for ALPS "fourth button". (It's bit 0x10 of the "fourth byte"
1974          * and it is activated by tapping the glidepad with the finger! 8^)
1975          * We map it to bit bit3, and the reverse map in xf86Events just has
1976          * to be extended so that it is identified as Button 4. The lower
1977          * half of the reverse-map may remain unchanged.
1978          */
1979
1980         /*
1981          * [KY-97/08/03]
1982          * Receive the fourth byte only when preceding three bytes have
1983          * been detected (pBufP >= cur_proto[4]).  In the previous
1984          * versions, the test was pBufP == 0; thus, we may have mistakingly
1985          * received a byte even if we didn't see anything preceding
1986          * the byte.
1987          */
1988
1989         if ((rBuf & cur_proto[5]) != cur_proto[6]) {
1990             pBufP = 0;
1991             return (0);
1992         }
1993
1994         switch (rodent.rtype) {
1995 #if notyet
1996         case MOUSE_PROTO_MARIQUA:
1997             /*
1998              * This mouse has 16! buttons in addition to the standard
1999              * three of them.  They return 0x10 though 0x1f in the
2000              * so-called `ten key' mode and 0x30 though 0x3f in the
2001              * `function key' mode.  As there are only 31 bits for
2002              * button state (including the standard three), we ignore
2003              * the bit 0x20 and don't distinguish the two modes.
2004              */
2005             act->dx = act->dy = act->dz = 0;
2006             act->obutton = act->button;
2007             rBuf &= 0x1f;
2008             act->button = (1 << (rBuf - 13))
2009                 | (act->obutton & (MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN));
2010             /*
2011              * FIXME: this is a button "down" event. There needs to be
2012              * a corresponding button "up" event... XXX
2013              */
2014             break;
2015 #endif /* notyet */
2016         case MOUSE_PROTO_JOGDIAL:
2017             break;
2018
2019         /*
2020          * IntelliMouse, NetMouse (including NetMouse Pro) and Mie Mouse
2021          * always send the fourth byte, whereas the fourth byte is
2022          * optional for GlidePoint and ThinkingMouse. The fourth byte
2023          * is also optional for MouseMan+ and FirstMouse+ in their
2024          * native mode. It is always sent if they are in the IntelliMouse
2025          * compatible mode.
2026          */
2027         case MOUSE_PROTO_INTELLI:       /* IntelliMouse, NetMouse, Mie Mouse,
2028                                            MouseMan+ */
2029             act->dx = act->dy = 0;
2030             act->dz = (rBuf & 0x08) ? (rBuf & 0x0f) - 16 : (rBuf & 0x0f);
2031             if ((act->dz >= 7) || (act->dz <= -7))
2032                 act->dz = 0;
2033             act->obutton = act->button;
2034             act->button = butmapintelli[(rBuf & MOUSE_MSS_BUTTONS) >> 4]
2035                 | (act->obutton & (MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN));
2036             break;
2037
2038         default:
2039             act->dx = act->dy = act->dz = 0;
2040             act->obutton = act->button;
2041             act->button = butmapmss2[(rBuf & MOUSE_MSS_BUTTONS) >> 4]
2042                 | (act->obutton & (MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN));
2043             break;
2044         }
2045
2046         act->flags = ((act->dx || act->dy || act->dz) ? MOUSE_POSCHANGED : 0)
2047             | (act->obutton ^ act->button);
2048         pBufP = 0;
2049         return (act->flags);
2050     }
2051
2052     if (pBufP >= cur_proto[4])
2053         pBufP = 0;
2054     pBuf[pBufP++] = rBuf;
2055     if (pBufP != cur_proto[4])
2056         return (0);
2057
2058     /*
2059      * assembly full package
2060      */
2061
2062     debug("assembled full packet (len %d) %x,%x,%x,%x,%x,%x,%x,%x",
2063         cur_proto[4],
2064         pBuf[0], pBuf[1], pBuf[2], pBuf[3],
2065         pBuf[4], pBuf[5], pBuf[6], pBuf[7]);
2066
2067     act->dz = 0;
2068     act->obutton = act->button;
2069     switch (rodent.rtype)
2070     {
2071     case MOUSE_PROTO_MS:                /* Microsoft */
2072     case MOUSE_PROTO_LOGIMOUSEMAN:      /* MouseMan/TrackMan */
2073     case MOUSE_PROTO_X10MOUSEREM:       /* X10 MouseRemote */
2074         act->button = act->obutton & MOUSE_BUTTON4DOWN;
2075         if (rodent.flags & ChordMiddle)
2076             act->button |= ((pBuf[0] & MOUSE_MSS_BUTTONS) == MOUSE_MSS_BUTTONS)
2077                 ? MOUSE_BUTTON2DOWN
2078                 : butmapmss[(pBuf[0] & MOUSE_MSS_BUTTONS) >> 4];
2079         else
2080             act->button |= (act->obutton & MOUSE_BUTTON2DOWN)
2081                 | butmapmss[(pBuf[0] & MOUSE_MSS_BUTTONS) >> 4];
2082
2083         /* Send X10 btn events to remote client (ensure -128-+127 range) */
2084         if ((rodent.rtype == MOUSE_PROTO_X10MOUSEREM) &&
2085             ((pBuf[0] & 0xFC) == 0x44) && (pBuf[2] == 0x3F)) {
2086             if (rodent.mremcfd >= 0) {
2087                 unsigned char key = (signed char)(((pBuf[0] & 0x03) << 6) |
2088                                                   (pBuf[1] & 0x3F));
2089                 write(rodent.mremcfd, &key, 1);
2090             }
2091             return (0);
2092         }
2093
2094         act->dx = (signed char)(((pBuf[0] & 0x03) << 6) | (pBuf[1] & 0x3F));
2095         act->dy = (signed char)(((pBuf[0] & 0x0C) << 4) | (pBuf[2] & 0x3F));
2096         break;
2097
2098     case MOUSE_PROTO_GLIDEPOINT:        /* GlidePoint */
2099     case MOUSE_PROTO_THINK:             /* ThinkingMouse */
2100     case MOUSE_PROTO_INTELLI:           /* IntelliMouse, NetMouse, Mie Mouse,
2101                                            MouseMan+ */
2102         act->button = (act->obutton & (MOUSE_BUTTON2DOWN | MOUSE_BUTTON4DOWN))
2103             | butmapmss[(pBuf[0] & MOUSE_MSS_BUTTONS) >> 4];
2104         act->dx = (signed char)(((pBuf[0] & 0x03) << 6) | (pBuf[1] & 0x3F));
2105         act->dy = (signed char)(((pBuf[0] & 0x0C) << 4) | (pBuf[2] & 0x3F));
2106         break;
2107
2108     case MOUSE_PROTO_MSC:               /* MouseSystems Corp */
2109 #if notyet
2110     case MOUSE_PROTO_MARIQUA:           /* Mariqua */
2111 #endif
2112         act->button = butmapmsc[(~pBuf[0]) & MOUSE_MSC_BUTTONS];
2113         act->dx =    (signed char)(pBuf[1]) + (signed char)(pBuf[3]);
2114         act->dy = - ((signed char)(pBuf[2]) + (signed char)(pBuf[4]));
2115         break;
2116
2117     case MOUSE_PROTO_JOGDIAL:           /* JogDial */
2118             if (rBuf == 0x6c)
2119               act->dz = -1;
2120             if (rBuf == 0x72)
2121               act->dz = 1;
2122             if (rBuf == 0x64)
2123               act->button = MOUSE_BUTTON1DOWN;
2124             if (rBuf == 0x75)
2125               act->button = 0;
2126         break;
2127
2128     case MOUSE_PROTO_HITTAB:            /* MM HitTablet */
2129         act->button = butmaphit[pBuf[0] & 0x07];
2130         act->dx = (pBuf[0] & MOUSE_MM_XPOSITIVE) ?   pBuf[1] : - pBuf[1];
2131         act->dy = (pBuf[0] & MOUSE_MM_YPOSITIVE) ? - pBuf[2] :   pBuf[2];
2132         break;
2133
2134     case MOUSE_PROTO_MM:                /* MM Series */
2135     case MOUSE_PROTO_LOGI:              /* Logitech Mice */
2136         act->button = butmapmsc[pBuf[0] & MOUSE_MSC_BUTTONS];
2137         act->dx = (pBuf[0] & MOUSE_MM_XPOSITIVE) ?   pBuf[1] : - pBuf[1];
2138         act->dy = (pBuf[0] & MOUSE_MM_YPOSITIVE) ? - pBuf[2] :   pBuf[2];
2139         break;
2140
2141     case MOUSE_PROTO_VERSAPAD:          /* VersaPad */
2142         act->button = butmapversa[(pBuf[0] & MOUSE_VERSA_BUTTONS) >> 3];
2143         act->button |= (pBuf[0] & MOUSE_VERSA_TAP) ? MOUSE_BUTTON4DOWN : 0;
2144         act->dx = act->dy = 0;
2145         if (!(pBuf[0] & MOUSE_VERSA_IN_USE)) {
2146             on = FALSE;
2147             break;
2148         }
2149         x = (pBuf[2] << 6) | pBuf[1];
2150         if (x & 0x800)
2151             x -= 0x1000;
2152         y = (pBuf[4] << 6) | pBuf[3];
2153         if (y & 0x800)
2154             y -= 0x1000;
2155         if (on) {
2156             act->dx = prev_x - x;
2157             act->dy = prev_y - y;
2158         } else {
2159             on = TRUE;
2160         }
2161         prev_x = x;
2162         prev_y = y;
2163         break;
2164
2165     case MOUSE_PROTO_BUS:               /* Bus */
2166     case MOUSE_PROTO_INPORT:            /* InPort */
2167         act->button = butmapmsc[(~pBuf[0]) & MOUSE_MSC_BUTTONS];
2168         act->dx =   (signed char)pBuf[1];
2169         act->dy = - (signed char)pBuf[2];
2170         break;
2171
2172     case MOUSE_PROTO_PS2:               /* PS/2 */
2173         act->button = butmapps2[pBuf[0] & MOUSE_PS2_BUTTONS];
2174         act->dx = (pBuf[0] & MOUSE_PS2_XNEG) ?    pBuf[1] - 256  :  pBuf[1];
2175         act->dy = (pBuf[0] & MOUSE_PS2_YNEG) ?  -(pBuf[2] - 256) : -pBuf[2];
2176         /*
2177          * Moused usually operates the psm driver at the operation level 1
2178          * which sends mouse data in MOUSE_PROTO_SYSMOUSE protocol.
2179          * The following code takes effect only when the user explicitly
2180          * requets the level 2 at which wheel movement and additional button
2181          * actions are encoded in model-dependent formats. At the level 0
2182          * the following code is no-op because the psm driver says the model
2183          * is MOUSE_MODEL_GENERIC.
2184          */
2185         switch (rodent.hw.model) {
2186         case MOUSE_MODEL_EXPLORER:
2187             /* wheel and additional button data is in the fourth byte */
2188             act->dz = (pBuf[3] & MOUSE_EXPLORER_ZNEG)
2189                 ? (pBuf[3] & 0x0f) - 16 : (pBuf[3] & 0x0f);
2190             act->button |= (pBuf[3] & MOUSE_EXPLORER_BUTTON4DOWN)
2191                 ? MOUSE_BUTTON4DOWN : 0;
2192             act->button |= (pBuf[3] & MOUSE_EXPLORER_BUTTON5DOWN)
2193                 ? MOUSE_BUTTON5DOWN : 0;
2194             break;
2195         case MOUSE_MODEL_INTELLI:
2196         case MOUSE_MODEL_NET:
2197             /* wheel data is in the fourth byte */
2198             act->dz = (signed char)pBuf[3];
2199             if ((act->dz >= 7) || (act->dz <= -7))
2200                 act->dz = 0;
2201             /* some compatible mice may have additional buttons */
2202             act->button |= (pBuf[0] & MOUSE_PS2INTELLI_BUTTON4DOWN)
2203                 ? MOUSE_BUTTON4DOWN : 0;
2204             act->button |= (pBuf[0] & MOUSE_PS2INTELLI_BUTTON5DOWN)
2205                 ? MOUSE_BUTTON5DOWN : 0;
2206             break;
2207         case MOUSE_MODEL_MOUSEMANPLUS:
2208             if (((pBuf[0] & MOUSE_PS2PLUS_SYNCMASK) == MOUSE_PS2PLUS_SYNC)
2209                     && (abs(act->dx) > 191)
2210                     && MOUSE_PS2PLUS_CHECKBITS(pBuf)) {
2211                 /* the extended data packet encodes button and wheel events */
2212                 switch (MOUSE_PS2PLUS_PACKET_TYPE(pBuf)) {
2213                 case 1:
2214                     /* wheel data packet */
2215                     act->dx = act->dy = 0;
2216                     if (pBuf[2] & 0x80) {
2217                         /* horizontal roller count - ignore it XXX*/
2218                     } else {
2219                         /* vertical roller count */
2220                         act->dz = (pBuf[2] & MOUSE_PS2PLUS_ZNEG)
2221                             ? (pBuf[2] & 0x0f) - 16 : (pBuf[2] & 0x0f);
2222                     }
2223                     act->button |= (pBuf[2] & MOUSE_PS2PLUS_BUTTON4DOWN)
2224                         ? MOUSE_BUTTON4DOWN : 0;
2225                     act->button |= (pBuf[2] & MOUSE_PS2PLUS_BUTTON5DOWN)
2226                         ? MOUSE_BUTTON5DOWN : 0;
2227                     break;
2228                 case 2:
2229                     /* this packet type is reserved by Logitech */
2230                     /*
2231                      * IBM ScrollPoint Mouse uses this packet type to
2232                      * encode both vertical and horizontal scroll movement.
2233                      */
2234                     act->dx = act->dy = 0;
2235                     /* horizontal roller count */
2236                     if (pBuf[2] & 0x0f)
2237                         act->dz = (pBuf[2] & MOUSE_SPOINT_WNEG) ? -2 : 2;
2238                     /* vertical roller count */
2239                     if (pBuf[2] & 0xf0)
2240                         act->dz = (pBuf[2] & MOUSE_SPOINT_ZNEG) ? -1 : 1;
2241 #if 0
2242                     /* vertical roller count */
2243                     act->dz = (pBuf[2] & MOUSE_SPOINT_ZNEG)
2244                         ? ((pBuf[2] >> 4) & 0x0f) - 16
2245                         : ((pBuf[2] >> 4) & 0x0f);
2246                     /* horizontal roller count */
2247                     act->dw = (pBuf[2] & MOUSE_SPOINT_WNEG)
2248                         ? (pBuf[2] & 0x0f) - 16 : (pBuf[2] & 0x0f);
2249 #endif
2250                     break;
2251                 case 0:
2252                     /* device type packet - shouldn't happen */
2253                     /* FALLTHROUGH */
2254                 default:
2255                     act->dx = act->dy = 0;
2256                     act->button = act->obutton;
2257                     debug("unknown PS2++ packet type %d: 0x%02x 0x%02x 0x%02x\n",
2258                           MOUSE_PS2PLUS_PACKET_TYPE(pBuf),
2259                           pBuf[0], pBuf[1], pBuf[2]);
2260                     break;
2261                 }
2262             } else {
2263                 /* preserve button states */
2264                 act->button |= act->obutton & MOUSE_EXTBUTTONS;
2265             }
2266             break;
2267         case MOUSE_MODEL_GLIDEPOINT:
2268             /* `tapping' action */
2269             act->button |= ((pBuf[0] & MOUSE_PS2_TAP)) ? 0 : MOUSE_BUTTON4DOWN;
2270             break;
2271         case MOUSE_MODEL_NETSCROLL:
2272             /* three addtional bytes encode buttons and wheel events */
2273             act->button |= (pBuf[3] & MOUSE_PS2_BUTTON3DOWN)
2274                 ? MOUSE_BUTTON4DOWN : 0;
2275             act->button |= (pBuf[3] & MOUSE_PS2_BUTTON1DOWN)
2276                 ? MOUSE_BUTTON5DOWN : 0;
2277             act->dz = (pBuf[3] & MOUSE_PS2_XNEG) ? pBuf[4] - 256 : pBuf[4];
2278             break;
2279         case MOUSE_MODEL_THINK:
2280             /* the fourth button state in the first byte */
2281             act->button |= (pBuf[0] & MOUSE_PS2_TAP) ? MOUSE_BUTTON4DOWN : 0;
2282             break;
2283         case MOUSE_MODEL_VERSAPAD:
2284             act->button = butmapversaps2[pBuf[0] & MOUSE_PS2VERSA_BUTTONS];
2285             act->button |=
2286                 (pBuf[0] & MOUSE_PS2VERSA_TAP) ? MOUSE_BUTTON4DOWN : 0;
2287             act->dx = act->dy = 0;
2288             if (!(pBuf[0] & MOUSE_PS2VERSA_IN_USE)) {
2289                 on = FALSE;
2290                 break;
2291             }
2292             x = ((pBuf[4] << 8) & 0xf00) | pBuf[1];
2293             if (x & 0x800)
2294                 x -= 0x1000;
2295             y = ((pBuf[4] << 4) & 0xf00) | pBuf[2];
2296             if (y & 0x800)
2297                 y -= 0x1000;
2298             if (on) {
2299                 act->dx = prev_x - x;
2300                 act->dy = prev_y - y;
2301             } else {
2302                 on = TRUE;
2303             }
2304             prev_x = x;
2305             prev_y = y;
2306             break;
2307         case MOUSE_MODEL_4D:
2308             act->dx = (pBuf[1] & 0x80) ?    pBuf[1] - 256  :  pBuf[1];
2309             act->dy = (pBuf[2] & 0x80) ?  -(pBuf[2] - 256) : -pBuf[2];
2310             switch (pBuf[0] & MOUSE_4D_WHEELBITS) {
2311             case 0x10:
2312                 act->dz = 1;
2313                 break;
2314             case 0x30:
2315                 act->dz = -1;
2316                 break;
2317             case 0x40:  /* 2nd wheel rolling right XXX */
2318                 act->dz = 2;
2319                 break;
2320             case 0xc0:  /* 2nd wheel rolling left XXX */
2321                 act->dz = -2;
2322                 break;
2323             }
2324             break;
2325         case MOUSE_MODEL_4DPLUS:
2326             if ((act->dx < 16 - 256) && (act->dy > 256 - 16)) {
2327                 act->dx = act->dy = 0;
2328                 if (pBuf[2] & MOUSE_4DPLUS_BUTTON4DOWN)
2329                     act->button |= MOUSE_BUTTON4DOWN;
2330                 act->dz = (pBuf[2] & MOUSE_4DPLUS_ZNEG)
2331                               ? ((pBuf[2] & 0x07) - 8) : (pBuf[2] & 0x07);
2332             } else {
2333                 /* preserve previous button states */
2334                 act->button |= act->obutton & MOUSE_EXTBUTTONS;
2335             }
2336             break;
2337         case MOUSE_MODEL_GENERIC:
2338         default:
2339             break;
2340         }
2341         break;
2342
2343     case MOUSE_PROTO_SYSMOUSE:          /* sysmouse */
2344         act->button = butmapmsc[(~pBuf[0]) & MOUSE_SYS_STDBUTTONS];
2345         act->dx =    (signed char)(pBuf[1]) + (signed char)(pBuf[3]);
2346         act->dy = - ((signed char)(pBuf[2]) + (signed char)(pBuf[4]));
2347         if (rodent.level == 1) {
2348             act->dz = ((signed char)(pBuf[5] << 1) + (signed char)(pBuf[6] << 1)) >> 1;
2349             act->button |= ((~pBuf[7] & MOUSE_SYS_EXTBUTTONS) << 3);
2350         }
2351         break;
2352
2353     default:
2354         return (0);
2355     }
2356     /*
2357      * We don't reset pBufP here yet, as there may be an additional data
2358      * byte in some protocols. See above.
2359      */
2360
2361     /* has something changed? */
2362     act->flags = ((act->dx || act->dy || act->dz) ? MOUSE_POSCHANGED : 0)
2363         | (act->obutton ^ act->button);
2364
2365     return (act->flags);
2366 }
2367
2368 static int
2369 r_statetrans(mousestatus_t *a1, mousestatus_t *a2, int trans)
2370 {
2371     int changed;
2372     int flags;
2373
2374     a2->dx = a1->dx;
2375     a2->dy = a1->dy;
2376     a2->dz = a1->dz;
2377     a2->obutton = a2->button;
2378     a2->button = a1->button;
2379     a2->flags = a1->flags;
2380     changed = FALSE;
2381
2382     if (rodent.flags & Emulate3Button) {
2383         if (debug > 2)
2384             debug("state:%d, trans:%d -> state:%d",
2385                   mouse_button_state, trans,
2386                   states[mouse_button_state].s[trans]);
2387         /*
2388          * Avoid re-ordering button and movement events. While a button
2389          * event is deferred, throw away up to BUTTON2_MAXMOVE movement
2390          * events to allow for mouse jitter. If more movement events
2391          * occur, then complete the deferred button events immediately.
2392          */
2393         if ((a2->dx != 0 || a2->dy != 0) &&
2394             S_DELAYED(states[mouse_button_state].s[trans])) {
2395                 if (++mouse_move_delayed > BUTTON2_MAXMOVE) {
2396                         mouse_move_delayed = 0;
2397                         mouse_button_state =
2398                             states[mouse_button_state].s[A_TIMEOUT];
2399                         changed = TRUE;
2400                 } else
2401                         a2->dx = a2->dy = 0;
2402         } else
2403                 mouse_move_delayed = 0;
2404         if (mouse_button_state != states[mouse_button_state].s[trans])
2405                 changed = TRUE;
2406         if (changed)
2407                 clock_gettime(CLOCK_MONOTONIC_FAST, &mouse_button_state_ts);
2408         mouse_button_state = states[mouse_button_state].s[trans];
2409         a2->button &=
2410             ~(MOUSE_BUTTON1DOWN | MOUSE_BUTTON2DOWN | MOUSE_BUTTON3DOWN);
2411         a2->button &= states[mouse_button_state].mask;
2412         a2->button |= states[mouse_button_state].buttons;
2413         flags = a2->flags & MOUSE_POSCHANGED;
2414         flags |= a2->obutton ^ a2->button;
2415         if (flags & MOUSE_BUTTON2DOWN) {
2416             a2->flags = flags & MOUSE_BUTTON2DOWN;
2417             r_timestamp(a2);
2418         }
2419         a2->flags = flags;
2420     }
2421     return (changed);
2422 }
2423
2424 /* phisical to logical button mapping */
2425 static int p2l[MOUSE_MAXBUTTON] = {
2426     MOUSE_BUTTON1DOWN, MOUSE_BUTTON2DOWN, MOUSE_BUTTON3DOWN, MOUSE_BUTTON4DOWN,
2427     MOUSE_BUTTON5DOWN, MOUSE_BUTTON6DOWN, MOUSE_BUTTON7DOWN, MOUSE_BUTTON8DOWN,
2428     0x00000100,        0x00000200,        0x00000400,        0x00000800,
2429     0x00001000,        0x00002000,        0x00004000,        0x00008000,
2430     0x00010000,        0x00020000,        0x00040000,        0x00080000,
2431     0x00100000,        0x00200000,        0x00400000,        0x00800000,
2432     0x01000000,        0x02000000,        0x04000000,        0x08000000,
2433     0x10000000,        0x20000000,        0x40000000,
2434 };
2435
2436 static char *
2437 skipspace(char *s)
2438 {
2439     while(isspace(*s))
2440         ++s;
2441     return (s);
2442 }
2443
2444 static int
2445 r_installmap(char *arg)
2446 {
2447     int pbutton;
2448     int lbutton;
2449     char *s;
2450
2451     while (*arg) {
2452         arg = skipspace(arg);
2453         s = arg;
2454         while (isdigit(*arg))
2455             ++arg;
2456         arg = skipspace(arg);
2457         if ((arg <= s) || (*arg != '='))
2458             return (FALSE);
2459         lbutton = atoi(s);
2460
2461         arg = skipspace(++arg);
2462         s = arg;
2463         while (isdigit(*arg))
2464             ++arg;
2465         if ((arg <= s) || (!isspace(*arg) && (*arg != '\0')))
2466             return (FALSE);
2467         pbutton = atoi(s);
2468
2469         if ((lbutton <= 0) || (lbutton > MOUSE_MAXBUTTON))
2470             return (FALSE);
2471         if ((pbutton <= 0) || (pbutton > MOUSE_MAXBUTTON))
2472             return (FALSE);
2473         p2l[pbutton - 1] = 1 << (lbutton - 1);
2474         mstate[lbutton - 1] = &bstate[pbutton - 1];
2475     }
2476
2477     return (TRUE);
2478 }
2479
2480 static void
2481 r_map(mousestatus_t *act1, mousestatus_t *act2)
2482 {
2483     register int pb;
2484     register int pbuttons;
2485     int lbuttons;
2486
2487     pbuttons = act1->button;
2488     lbuttons = 0;
2489
2490     act2->obutton = act2->button;
2491     if (pbuttons & rodent.wmode) {
2492         pbuttons &= ~rodent.wmode;
2493         act1->dz = act1->dy;
2494         act1->dx = 0;
2495         act1->dy = 0;
2496     }
2497     act2->dx = act1->dx;
2498     act2->dy = act1->dy;
2499     act2->dz = act1->dz;
2500
2501     switch (rodent.zmap[0]) {
2502     case 0:     /* do nothing */
2503         break;
2504     case MOUSE_XAXIS:
2505         if (act1->dz != 0) {
2506             act2->dx = act1->dz;
2507             act2->dz = 0;
2508         }
2509         break;
2510     case MOUSE_YAXIS:
2511         if (act1->dz != 0) {
2512             act2->dy = act1->dz;
2513             act2->dz = 0;
2514         }
2515         break;
2516     default:    /* buttons */
2517         pbuttons &= ~(rodent.zmap[0] | rodent.zmap[1]
2518                     | rodent.zmap[2] | rodent.zmap[3]);
2519         if ((act1->dz < -1) && rodent.zmap[2]) {
2520             pbuttons |= rodent.zmap[2];
2521             zstate[2].count = 1;
2522         } else if (act1->dz < 0) {
2523             pbuttons |= rodent.zmap[0];
2524             zstate[0].count = 1;
2525         } else if ((act1->dz > 1) && rodent.zmap[3]) {
2526             pbuttons |= rodent.zmap[3];
2527             zstate[3].count = 1;
2528         } else if (act1->dz > 0) {
2529             pbuttons |= rodent.zmap[1];
2530             zstate[1].count = 1;
2531         }
2532         act2->dz = 0;
2533         break;
2534     }
2535
2536     for (pb = 0; (pb < MOUSE_MAXBUTTON) && (pbuttons != 0); ++pb) {
2537         lbuttons |= (pbuttons & 1) ? p2l[pb] : 0;
2538         pbuttons >>= 1;
2539     }
2540     act2->button = lbuttons;
2541
2542     act2->flags = ((act2->dx || act2->dy || act2->dz) ? MOUSE_POSCHANGED : 0)
2543         | (act2->obutton ^ act2->button);
2544 }
2545
2546 static void
2547 r_timestamp(mousestatus_t *act)
2548 {
2549     struct timespec ts;
2550     struct timespec ts1;
2551     struct timespec ts2;
2552     struct timespec ts3;
2553     int button;
2554     int mask;
2555     int i;
2556
2557     mask = act->flags & MOUSE_BUTTONS;
2558 #if 0
2559     if (mask == 0)
2560         return;
2561 #endif
2562
2563     clock_gettime(CLOCK_MONOTONIC_FAST, &ts1);
2564     drift_current_ts = ts1;
2565
2566     /* double click threshold */
2567     ts2.tv_sec = rodent.clickthreshold / 1000;
2568     ts2.tv_nsec = (rodent.clickthreshold % 1000) * 1000000;
2569     tssub(&ts1, &ts2, &ts);
2570     debug("ts:  %jd %ld", (intmax_t)ts.tv_sec, ts.tv_nsec);
2571
2572     /* 3 button emulation timeout */
2573     ts2.tv_sec = rodent.button2timeout / 1000;
2574     ts2.tv_nsec = (rodent.button2timeout % 1000) * 1000000;
2575     tssub(&ts1, &ts2, &ts3);
2576
2577     button = MOUSE_BUTTON1DOWN;
2578     for (i = 0; (i < MOUSE_MAXBUTTON) && (mask != 0); ++i) {
2579         if (mask & 1) {
2580             if (act->button & button) {
2581                 /* the button is down */
2582                 debug("  :  %jd %ld",
2583                     (intmax_t)bstate[i].ts.tv_sec, bstate[i].ts.tv_nsec);
2584                 if (tscmp(&ts, &bstate[i].ts, >)) {
2585                     bstate[i].count = 1;
2586                 } else {
2587                     ++bstate[i].count;
2588                 }
2589                 bstate[i].ts = ts1;
2590             } else {
2591                 /* the button is up */
2592                 bstate[i].ts = ts1;
2593             }
2594         } else {
2595             if (act->button & button) {
2596                 /* the button has been down */
2597                 if (tscmp(&ts3, &bstate[i].ts, >)) {
2598                     bstate[i].count = 1;
2599                     bstate[i].ts = ts1;
2600                     act->flags |= button;
2601                     debug("button %d timeout", i + 1);
2602                 }
2603             } else {
2604                 /* the button has been up */
2605             }
2606         }
2607         button <<= 1;
2608         mask >>= 1;
2609     }
2610 }
2611
2612 static int
2613 r_timeout(void)
2614 {
2615     struct timespec ts;
2616     struct timespec ts1;
2617     struct timespec ts2;
2618
2619     if (states[mouse_button_state].timeout)
2620         return (TRUE);
2621     clock_gettime(CLOCK_MONOTONIC_FAST, &ts1);
2622     ts2.tv_sec = rodent.button2timeout / 1000;
2623     ts2.tv_nsec = (rodent.button2timeout % 1000) * 1000000;
2624     tssub(&ts1, &ts2, &ts);
2625     return (tscmp(&ts, &mouse_button_state_ts, >));
2626 }
2627
2628 static void
2629 r_click(mousestatus_t *act)
2630 {
2631     struct mouse_info mouse;
2632     int button;
2633     int mask;
2634     int i;
2635
2636     mask = act->flags & MOUSE_BUTTONS;
2637     if (mask == 0)
2638         return;
2639
2640     button = MOUSE_BUTTON1DOWN;
2641     for (i = 0; (i < MOUSE_MAXBUTTON) && (mask != 0); ++i) {
2642         if (mask & 1) {
2643             debug("mstate[%d]->count:%d", i, mstate[i]->count);
2644             if (act->button & button) {
2645                 /* the button is down */
2646                 mouse.u.event.value = mstate[i]->count;
2647             } else {
2648                 /* the button is up */
2649                 mouse.u.event.value = 0;
2650             }
2651             mouse.operation = MOUSE_BUTTON_EVENT;
2652             mouse.u.event.id = button;
2653             if (debug < 2)
2654                 if (!paused)
2655                     ioctl(rodent.cfd, CONS_MOUSECTL, &mouse);
2656             debug("button %d  count %d", i + 1, mouse.u.event.value);
2657         }
2658         button <<= 1;
2659         mask >>= 1;
2660     }
2661 }
2662
2663 /* $XConsortium: posix_tty.c,v 1.3 95/01/05 20:42:55 kaleb Exp $ */
2664 /* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/shared/posix_tty.c,v 3.4 1995/01/28 17:05:03 dawes Exp $ */
2665 /*
2666  * Copyright 1993 by David Dawes <dawes@physics.su.oz.au>
2667  *
2668  * Permission to use, copy, modify, distribute, and sell this software and its
2669  * documentation for any purpose is hereby granted without fee, provided that
2670  * the above copyright notice appear in all copies and that both that
2671  * copyright notice and this permission notice appear in supporting
2672  * documentation, and that the name of David Dawes
2673  * not be used in advertising or publicity pertaining to distribution of
2674  * the software without specific, written prior permission.
2675  * David Dawes makes no representations about the suitability of this
2676  * software for any purpose.  It is provided "as is" without express or
2677  * implied warranty.
2678  *
2679  * DAVID DAWES DISCLAIMS ALL WARRANTIES WITH REGARD TO
2680  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
2681  * FITNESS, IN NO EVENT SHALL DAVID DAWES BE LIABLE FOR
2682  * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
2683  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
2684  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
2685  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
2686  *
2687  */
2688
2689
2690 static void
2691 setmousespeed(int old, int new, unsigned cflag)
2692 {
2693         struct termios tty;
2694         const char *c;
2695
2696         if (tcgetattr(rodent.mfd, &tty) < 0)
2697         {
2698                 logwarn("unable to get status of mouse fd");
2699                 return;
2700         }
2701
2702         tty.c_iflag = IGNBRK | IGNPAR;
2703         tty.c_oflag = 0;
2704         tty.c_lflag = 0;
2705         tty.c_cflag = (tcflag_t)cflag;
2706         tty.c_cc[VTIME] = 0;
2707         tty.c_cc[VMIN] = 1;
2708
2709         switch (old)
2710         {
2711         case 9600:
2712                 cfsetispeed(&tty, B9600);
2713                 cfsetospeed(&tty, B9600);
2714                 break;
2715         case 4800:
2716                 cfsetispeed(&tty, B4800);
2717                 cfsetospeed(&tty, B4800);
2718                 break;
2719         case 2400:
2720                 cfsetispeed(&tty, B2400);
2721                 cfsetospeed(&tty, B2400);
2722                 break;
2723         case 1200:
2724         default:
2725                 cfsetispeed(&tty, B1200);
2726                 cfsetospeed(&tty, B1200);
2727         }
2728
2729         if (tcsetattr(rodent.mfd, TCSADRAIN, &tty) < 0)
2730         {
2731                 logwarn("unable to set status of mouse fd");
2732                 return;
2733         }
2734
2735         switch (new)
2736         {
2737         case 9600:
2738                 c = "*q";
2739                 cfsetispeed(&tty, B9600);
2740                 cfsetospeed(&tty, B9600);
2741                 break;
2742         case 4800:
2743                 c = "*p";
2744                 cfsetispeed(&tty, B4800);
2745                 cfsetospeed(&tty, B4800);
2746                 break;
2747         case 2400:
2748                 c = "*o";
2749                 cfsetispeed(&tty, B2400);
2750                 cfsetospeed(&tty, B2400);
2751                 break;
2752         case 1200:
2753         default:
2754                 c = "*n";
2755                 cfsetispeed(&tty, B1200);
2756                 cfsetospeed(&tty, B1200);
2757         }
2758
2759         if (rodent.rtype == MOUSE_PROTO_LOGIMOUSEMAN
2760             || rodent.rtype == MOUSE_PROTO_LOGI)
2761         {
2762                 if (write(rodent.mfd, c, 2) != 2)
2763                 {
2764                         logwarn("unable to write to mouse fd");
2765                         return;
2766                 }
2767         }
2768         usleep(100000);
2769
2770         if (tcsetattr(rodent.mfd, TCSADRAIN, &tty) < 0)
2771                 logwarn("unable to set status of mouse fd");
2772 }
2773
2774 /*
2775  * PnP COM device support
2776  *
2777  * It's a simplistic implementation, but it works :-)
2778  * KY, 31/7/97.
2779  */
2780
2781 /*
2782  * Try to elicit a PnP ID as described in
2783  * Microsoft, Hayes: "Plug and Play External COM Device Specification,
2784  * rev 1.00", 1995.
2785  *
2786  * The routine does not fully implement the COM Enumerator as par Section
2787  * 2.1 of the document.  In particular, we don't have idle state in which
2788  * the driver software monitors the com port for dynamic connection or
2789  * removal of a device at the port, because `moused' simply quits if no
2790  * device is found.
2791  *
2792  * In addition, as PnP COM device enumeration procedure slightly has
2793  * changed since its first publication, devices which follow earlier
2794  * revisions of the above spec. may fail to respond if the rev 1.0
2795  * procedure is used. XXX
2796  */
2797 static int
2798 pnpwakeup1(void)
2799 {
2800     struct timeval timeout;
2801     fd_set fds;
2802     int i;
2803
2804     /*
2805      * This is the procedure described in rev 1.0 of PnP COM device spec.
2806      * Unfortunately, some devices which comform to earlier revisions of
2807      * the spec gets confused and do not return the ID string...
2808      */
2809     debug("PnP COM device rev 1.0 probe...");
2810
2811     /* port initialization (2.1.2) */
2812     ioctl(rodent.mfd, TIOCMGET, &i);
2813     i |= TIOCM_DTR;             /* DTR = 1 */
2814     i &= ~TIOCM_RTS;            /* RTS = 0 */
2815     ioctl(rodent.mfd, TIOCMSET, &i);
2816     usleep(240000);
2817
2818     /*
2819      * The PnP COM device spec. dictates that the mouse must set DSR
2820      * in response to DTR (by hardware or by software) and that if DSR is
2821      * not asserted, the host computer should think that there is no device
2822      * at this serial port.  But some mice just don't do that...
2823      */
2824     ioctl(rodent.mfd, TIOCMGET, &i);
2825     debug("modem status 0%o", i);
2826     if ((i & TIOCM_DSR) == 0)
2827         return (FALSE);
2828
2829     /* port setup, 1st phase (2.1.3) */
2830     setmousespeed(1200, 1200, (CS7 | CREAD | CLOCAL | HUPCL));
2831     i = TIOCM_DTR | TIOCM_RTS;  /* DTR = 0, RTS = 0 */
2832     ioctl(rodent.mfd, TIOCMBIC, &i);
2833     usleep(240000);
2834     i = TIOCM_DTR;              /* DTR = 1, RTS = 0 */
2835     ioctl(rodent.mfd, TIOCMBIS, &i);
2836     usleep(240000);
2837
2838     /* wait for response, 1st phase (2.1.4) */
2839     i = FREAD;
2840     ioctl(rodent.mfd, TIOCFLUSH, &i);
2841     i = TIOCM_RTS;              /* DTR = 1, RTS = 1 */
2842     ioctl(rodent.mfd, TIOCMBIS, &i);
2843
2844     /* try to read something */
2845     FD_ZERO(&fds);
2846     FD_SET(rodent.mfd, &fds);
2847     timeout.tv_sec = 0;
2848     timeout.tv_usec = 240000;
2849     if (select(FD_SETSIZE, &fds, NULL, NULL, &timeout) > 0) {
2850         debug("pnpwakeup1(): valid response in first phase.");
2851         return (TRUE);
2852     }
2853
2854     /* port setup, 2nd phase (2.1.5) */
2855     i = TIOCM_DTR | TIOCM_RTS;  /* DTR = 0, RTS = 0 */
2856     ioctl(rodent.mfd, TIOCMBIC, &i);
2857     usleep(240000);
2858
2859     /* wait for respose, 2nd phase (2.1.6) */
2860     i = FREAD;
2861     ioctl(rodent.mfd, TIOCFLUSH, &i);
2862     i = TIOCM_DTR | TIOCM_RTS;  /* DTR = 1, RTS = 1 */
2863     ioctl(rodent.mfd, TIOCMBIS, &i);
2864
2865     /* try to read something */
2866     FD_ZERO(&fds);
2867     FD_SET(rodent.mfd, &fds);
2868     timeout.tv_sec = 0;
2869     timeout.tv_usec = 240000;
2870     if (select(FD_SETSIZE, &fds, NULL, NULL, &timeout) > 0) {
2871         debug("pnpwakeup1(): valid response in second phase.");
2872         return (TRUE);
2873     }
2874
2875     return (FALSE);
2876 }
2877
2878 static int
2879 pnpwakeup2(void)
2880 {
2881     struct timeval timeout;
2882     fd_set fds;
2883     int i;
2884
2885     /*
2886      * This is a simplified procedure; it simply toggles RTS.
2887      */
2888     debug("alternate probe...");
2889
2890     ioctl(rodent.mfd, TIOCMGET, &i);
2891     i |= TIOCM_DTR;             /* DTR = 1 */
2892     i &= ~TIOCM_RTS;            /* RTS = 0 */
2893     ioctl(rodent.mfd, TIOCMSET, &i);
2894     usleep(240000);
2895
2896     setmousespeed(1200, 1200, (CS7 | CREAD | CLOCAL | HUPCL));
2897
2898     /* wait for respose */
2899     i = FREAD;
2900     ioctl(rodent.mfd, TIOCFLUSH, &i);
2901     i = TIOCM_DTR | TIOCM_RTS;  /* DTR = 1, RTS = 1 */
2902     ioctl(rodent.mfd, TIOCMBIS, &i);
2903
2904     /* try to read something */
2905     FD_ZERO(&fds);
2906     FD_SET(rodent.mfd, &fds);
2907     timeout.tv_sec = 0;
2908     timeout.tv_usec = 240000;
2909     if (select(FD_SETSIZE, &fds, NULL, NULL, &timeout) > 0) {
2910         debug("pnpwakeup2(): valid response.");
2911         return (TRUE);
2912     }
2913
2914     return (FALSE);
2915 }
2916
2917 static int
2918 pnpgets(char *buf)
2919 {
2920     struct timeval timeout;
2921     fd_set fds;
2922     int begin;
2923     int i;
2924     char c;
2925
2926     if (!pnpwakeup1() && !pnpwakeup2()) {
2927         /*
2928          * According to PnP spec, we should set DTR = 1 and RTS = 0 while
2929          * in idle state.  But, `moused' shall set DTR = RTS = 1 and proceed,
2930          * assuming there is something at the port even if it didn't
2931          * respond to the PnP enumeration procedure.
2932          */
2933         i = TIOCM_DTR | TIOCM_RTS;              /* DTR = 1, RTS = 1 */
2934         ioctl(rodent.mfd, TIOCMBIS, &i);
2935         return (0);
2936     }
2937
2938     /* collect PnP COM device ID (2.1.7) */
2939     begin = -1;
2940     i = 0;
2941     usleep(240000);     /* the mouse must send `Begin ID' within 200msec */
2942     while (read(rodent.mfd, &c, 1) == 1) {
2943         /* we may see "M", or "M3..." before `Begin ID' */
2944         buf[i++] = c;
2945         if ((c == 0x08) || (c == 0x28)) {       /* Begin ID */
2946             debug("begin-id %02x", c);
2947             begin = i - 1;
2948             break;
2949         }
2950         debug("%c %02x", c, c);
2951         if (i >= 256)
2952             break;
2953     }
2954     if (begin < 0) {
2955         /* we haven't seen `Begin ID' in time... */
2956         goto connect_idle;
2957     }
2958
2959     ++c;                        /* make it `End ID' */
2960     for (;;) {
2961         FD_ZERO(&fds);
2962         FD_SET(rodent.mfd, &fds);
2963         timeout.tv_sec = 0;
2964         timeout.tv_usec = 240000;
2965         if (select(FD_SETSIZE, &fds, NULL, NULL, &timeout) <= 0)
2966             break;
2967
2968         read(rodent.mfd, &buf[i], 1);
2969         if (buf[i++] == c)      /* End ID */
2970             break;
2971         if (i >= 256)
2972             break;
2973     }
2974     if (begin > 0) {
2975         i -= begin;
2976         bcopy(&buf[begin], &buf[0], i);
2977     }
2978     /* string may not be human readable... */
2979     debug("len:%d, '%-*.*s'", i, i, i, buf);
2980
2981     if (buf[i - 1] == c)
2982         return (i);             /* a valid PnP string */
2983
2984     /*
2985      * According to PnP spec, we should set DTR = 1 and RTS = 0 while
2986      * in idle state.  But, `moused' shall leave the modem control lines
2987      * as they are. See above.
2988      */
2989 connect_idle:
2990
2991     /* we may still have something in the buffer */
2992     return ((i > 0) ? i : 0);
2993 }
2994
2995 static int
2996 pnpparse(pnpid_t *id, char *buf, int len)
2997 {
2998     char s[3];
2999     int offset;
3000     int sum = 0;
3001     int i, j;
3002
3003     id->revision = 0;
3004     id->eisaid = NULL;
3005     id->serial = NULL;
3006     id->class = NULL;
3007     id->compat = NULL;
3008     id->description = NULL;
3009     id->neisaid = 0;
3010     id->nserial = 0;
3011     id->nclass = 0;
3012     id->ncompat = 0;
3013     id->ndescription = 0;
3014
3015     if ((buf[0] != 0x28) && (buf[0] != 0x08)) {
3016         /* non-PnP mice */
3017         switch(buf[0]) {
3018         default:
3019             return (FALSE);
3020         case 'M': /* Microsoft */
3021             id->eisaid = "PNP0F01";
3022             break;
3023         case 'H': /* MouseSystems */
3024             id->eisaid = "PNP0F04";
3025             break;
3026         }
3027         id->neisaid = strlen(id->eisaid);
3028         id->class = "MOUSE";
3029         id->nclass = strlen(id->class);
3030         debug("non-PnP mouse '%c'", buf[0]);
3031         return (TRUE);
3032     }
3033
3034     /* PnP mice */
3035     offset = 0x28 - buf[0];
3036
3037     /* calculate checksum */
3038     for (i = 0; i < len - 3; ++i) {
3039         sum += buf[i];
3040         buf[i] += offset;
3041     }
3042     sum += buf[len - 1];
3043     for (; i < len; ++i)
3044         buf[i] += offset;
3045     debug("PnP ID string: '%*.*s'", len, len, buf);
3046
3047     /* revision */
3048     buf[1] -= offset;
3049     buf[2] -= offset;
3050     id->revision = ((buf[1] & 0x3f) << 6) | (buf[2] & 0x3f);
3051     debug("PnP rev %d.%02d", id->revision / 100, id->revision % 100);
3052
3053     /* EISA vender and product ID */
3054     id->eisaid = &buf[3];
3055     id->neisaid = 7;
3056
3057     /* option strings */
3058     i = 10;
3059     if (buf[i] == '\\') {
3060         /* device serial # */
3061         for (j = ++i; i < len; ++i) {
3062             if (buf[i] == '\\')
3063                 break;
3064         }
3065         if (i >= len)
3066             i -= 3;
3067         if (i - j == 8) {
3068             id->serial = &buf[j];
3069             id->nserial = 8;
3070         }
3071     }
3072     if (buf[i] == '\\') {
3073         /* PnP class */
3074         for (j = ++i; i < len; ++i) {
3075             if (buf[i] == '\\')
3076                 break;
3077         }
3078         if (i >= len)
3079             i -= 3;
3080         if (i > j + 1) {
3081             id->class = &buf[j];
3082             id->nclass = i - j;
3083         }
3084     }
3085     if (buf[i] == '\\') {
3086         /* compatible driver */
3087         for (j = ++i; i < len; ++i) {
3088             if (buf[i] == '\\')
3089                 break;
3090         }
3091         /*
3092          * PnP COM spec prior to v0.96 allowed '*' in this field,
3093          * it's not allowed now; just igore it.
3094          */
3095         if (buf[j] == '*')
3096             ++j;
3097         if (i >= len)
3098             i -= 3;
3099         if (i > j + 1) {
3100             id->compat = &buf[j];
3101             id->ncompat = i - j;
3102         }
3103     }
3104     if (buf[i] == '\\') {
3105         /* product description */
3106         for (j = ++i; i < len; ++i) {
3107             if (buf[i] == ';')
3108                 break;
3109         }
3110         if (i >= len)
3111             i -= 3;
3112         if (i > j + 1) {
3113             id->description = &buf[j];
3114             id->ndescription = i - j;
3115         }
3116     }
3117
3118     /* checksum exists if there are any optional fields */
3119     if ((id->nserial > 0) || (id->nclass > 0)
3120         || (id->ncompat > 0) || (id->ndescription > 0)) {
3121         debug("PnP checksum: 0x%X", sum);
3122         sprintf(s, "%02X", sum & 0x0ff);
3123         if (strncmp(s, &buf[len - 3], 2) != 0) {
3124 #if 0
3125             /*
3126              * I found some mice do not comply with the PnP COM device
3127              * spec regarding checksum... XXX
3128              */
3129             logwarnx("PnP checksum error", 0);
3130             return (FALSE);
3131 #endif
3132         }
3133     }
3134
3135     return (TRUE);
3136 }
3137
3138 static symtab_t *
3139 pnpproto(pnpid_t *id)
3140 {
3141     symtab_t *t;
3142     int i, j;
3143
3144     if (id->nclass > 0)
3145         if (strncmp(id->class, "MOUSE", id->nclass) != 0 &&
3146             strncmp(id->class, "TABLET", id->nclass) != 0)
3147             /* this is not a mouse! */
3148             return (NULL);
3149
3150     if (id->neisaid > 0) {
3151         t = gettoken(pnpprod, id->eisaid, id->neisaid);
3152         if (t->val != MOUSE_PROTO_UNKNOWN)
3153             return (t);
3154     }
3155
3156     /*
3157      * The 'Compatible drivers' field may contain more than one
3158      * ID separated by ','.
3159      */
3160     if (id->ncompat <= 0)
3161         return (NULL);
3162     for (i = 0; i < id->ncompat; ++i) {
3163         for (j = i; id->compat[i] != ','; ++i)
3164             if (i >= id->ncompat)
3165                 break;
3166         if (i > j) {
3167             t = gettoken(pnpprod, id->compat + j, i - j);
3168             if (t->val != MOUSE_PROTO_UNKNOWN)
3169                 return (t);
3170         }
3171     }
3172
3173     return (NULL);
3174 }
3175
3176 /* name/val mapping */
3177
3178 static symtab_t *
3179 gettoken(symtab_t *tab, const char *s, int len)
3180 {
3181     int i;
3182
3183     for (i = 0; tab[i].name != NULL; ++i) {
3184         if (strncmp(tab[i].name, s, len) == 0)
3185             break;
3186     }
3187     return (&tab[i]);
3188 }
3189
3190 static const char *
3191 gettokenname(symtab_t *tab, int val)
3192 {
3193     static const char unknown[] = "unknown";
3194     int i;
3195
3196     for (i = 0; tab[i].name != NULL; ++i) {
3197         if (tab[i].val == val)
3198             return (tab[i].name);
3199     }
3200     return (unknown);
3201 }
3202
3203
3204 /*
3205  * code to read from the Genius Kidspad tablet.
3206
3207 The tablet responds to the COM PnP protocol 1.0 with EISA-ID KYE0005,
3208 and to pre-pnp probes (RTS toggle) with 'T' (tablet ?)
3209 9600, 8 bit, parity odd.
3210
3211 The tablet puts out 5 bytes. b0 (mask 0xb8, value 0xb8) contains
3212 the proximity, tip and button info:
3213    (byte0 & 0x1)        true = tip pressed
3214    (byte0 & 0x2)        true = button pressed
3215    (byte0 & 0x40)       false = pen in proximity of tablet.
3216
3217 The next 4 bytes are used for coordinates xl, xh, yl, yh (7 bits valid).
3218
3219 Only absolute coordinates are returned, so we use the following approach:
3220 we store the last coordinates sent when the pen went out of the tablet,
3221
3222
3223  *
3224  */
3225
3226 typedef enum {
3227     S_IDLE, S_PROXY, S_FIRST, S_DOWN, S_UP
3228 } k_status;
3229
3230 static int
3231 kidspad(u_char rxc, mousestatus_t *act)
3232 {
3233     static int buf[5];
3234     static int buflen = 0, b_prev = 0 , x_prev = -1, y_prev = -1;
3235     static k_status status = S_IDLE;
3236     static struct timespec old, now;
3237
3238     int x, y;
3239
3240     if (buflen > 0 && (rxc & 0x80)) {
3241         fprintf(stderr, "invalid code %d 0x%x\n", buflen, rxc);
3242         buflen = 0;
3243     }
3244     if (buflen == 0 && (rxc & 0xb8) != 0xb8) {
3245         fprintf(stderr, "invalid code 0 0x%x\n", rxc);
3246         return (0);     /* invalid code, no action */
3247     }
3248     buf[buflen++] = rxc;
3249     if (buflen < 5)
3250         return (0);
3251
3252     buflen = 0; /* for next time... */
3253
3254     x = buf[1]+128*(buf[2] - 7);
3255     if (x < 0) x = 0;
3256     y = 28*128 - (buf[3] + 128* (buf[4] - 7));
3257     if (y < 0) y = 0;
3258
3259     x /= 8;
3260     y /= 8;
3261
3262     act->flags = 0;
3263     act->obutton = act->button;
3264     act->dx = act->dy = act->dz = 0;
3265     clock_gettime(CLOCK_MONOTONIC_FAST, &now);
3266     if (buf[0] & 0x40) /* pen went out of reach */
3267         status = S_IDLE;
3268     else if (status == S_IDLE) { /* pen is newly near the tablet */
3269         act->flags |= MOUSE_POSCHANGED; /* force update */
3270         status = S_PROXY;
3271         x_prev = x;
3272         y_prev = y;
3273     }
3274     old = now;
3275     act->dx = x - x_prev;
3276     act->dy = y - y_prev;
3277     if (act->dx || act->dy)
3278         act->flags |= MOUSE_POSCHANGED;
3279     x_prev = x;
3280     y_prev = y;
3281     if (b_prev != 0 && b_prev != buf[0]) { /* possibly record button change */
3282         act->button = 0;
3283         if (buf[0] & 0x01) /* tip pressed */
3284             act->button |= MOUSE_BUTTON1DOWN;
3285         if (buf[0] & 0x02) /* button pressed */
3286             act->button |= MOUSE_BUTTON2DOWN;
3287         act->flags |= MOUSE_BUTTONSCHANGED;
3288     }
3289     b_prev = buf[0];
3290     return (act->flags);
3291 }
3292
3293 static int
3294 gtco_digipad (u_char rxc, mousestatus_t *act)
3295 {
3296         static u_char buf[5];
3297         static int buflen = 0, b_prev = 0 , x_prev = -1, y_prev = -1;
3298         static k_status status = S_IDLE;
3299         int x, y;
3300
3301 #define GTCO_HEADER     0x80
3302 #define GTCO_PROXIMITY  0x40
3303 #define GTCO_START      (GTCO_HEADER|GTCO_PROXIMITY)
3304 #define GTCO_BUTTONMASK 0x3c
3305
3306
3307         if (buflen > 0 && ((rxc & GTCO_HEADER) != GTCO_HEADER)) {
3308                 fprintf(stderr, "invalid code %d 0x%x\n", buflen, rxc);
3309                 buflen = 0;
3310         }
3311         if (buflen == 0 && (rxc & GTCO_START) != GTCO_START) {
3312                 fprintf(stderr, "invalid code 0 0x%x\n", rxc);
3313                 return (0);     /* invalid code, no action */
3314         }
3315
3316         buf[buflen++] = rxc;
3317         if (buflen < 5)
3318                 return (0);
3319
3320         buflen = 0;     /* for next time... */
3321
3322         x = ((buf[2] & ~GTCO_START) << 6 | (buf[1] & ~GTCO_START));
3323         y = 4768 - ((buf[4] & ~GTCO_START) << 6 | (buf[3] & ~GTCO_START));
3324
3325         x /= 2.5;
3326         y /= 2.5;
3327
3328         act->flags = 0;
3329         act->obutton = act->button;
3330         act->dx = act->dy = act->dz = 0;
3331
3332         if ((buf[0] & 0x40) == 0) /* pen went out of reach */
3333                 status = S_IDLE;
3334         else if (status == S_IDLE) { /* pen is newly near the tablet */
3335                 act->flags |= MOUSE_POSCHANGED; /* force update */
3336                 status = S_PROXY;
3337                 x_prev = x;
3338                 y_prev = y;
3339         }
3340
3341         act->dx = x - x_prev;
3342         act->dy = y - y_prev;
3343         if (act->dx || act->dy)
3344                 act->flags |= MOUSE_POSCHANGED;
3345         x_prev = x;
3346         y_prev = y;
3347
3348         /* possibly record button change */
3349         if (b_prev != 0 && b_prev != buf[0]) {
3350                 act->button = 0;
3351                 if (buf[0] & 0x04) {
3352                         /* tip pressed/yellow */
3353                         act->button |= MOUSE_BUTTON1DOWN;
3354                 }
3355                 if (buf[0] & 0x08) {
3356                         /* grey/white */
3357                         act->button |= MOUSE_BUTTON2DOWN;
3358                 }
3359                 if (buf[0] & 0x10) {
3360                         /* black/green */
3361                         act->button |= MOUSE_BUTTON3DOWN;
3362                 }
3363                 if (buf[0] & 0x20) {
3364                         /* tip+grey/blue */
3365                         act->button |= MOUSE_BUTTON4DOWN;
3366                 }
3367                 act->flags |= MOUSE_BUTTONSCHANGED;
3368         }
3369         b_prev = buf[0];
3370         return (act->flags);
3371 }
3372
3373 static void
3374 mremote_serversetup(void)
3375 {
3376     struct sockaddr_un ad;
3377
3378     /* Open a UNIX domain stream socket to listen for mouse remote clients */
3379     unlink(_PATH_MOUSEREMOTE);
3380
3381     if ((rodent.mremsfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
3382         logerrx(1, "unable to create unix domain socket %s",_PATH_MOUSEREMOTE);
3383
3384     umask(0111);
3385
3386     bzero(&ad, sizeof(ad));
3387     ad.sun_family = AF_UNIX;
3388     strcpy(ad.sun_path, _PATH_MOUSEREMOTE);
3389 #ifndef SUN_LEN
3390 #define SUN_LEN(unp) (((char *)(unp)->sun_path - (char *)(unp)) + \
3391                        strlen((unp)->path))
3392 #endif
3393     if (bind(rodent.mremsfd, (struct sockaddr *) &ad, SUN_LEN(&ad)) < 0)
3394         logerrx(1, "unable to bind unix domain socket %s", _PATH_MOUSEREMOTE);
3395
3396     listen(rodent.mremsfd, 1);
3397 }
3398
3399 static void
3400 mremote_clientchg(int add)
3401 {
3402     struct sockaddr_un ad;
3403     socklen_t ad_len;
3404     int fd;
3405
3406     if (rodent.rtype != MOUSE_PROTO_X10MOUSEREM)
3407         return;
3408
3409     if (add) {
3410         /*  Accept client connection, if we don't already have one  */
3411         ad_len = sizeof(ad);
3412         fd = accept(rodent.mremsfd, (struct sockaddr *) &ad, &ad_len);
3413         if (fd < 0)
3414             logwarnx("failed accept on mouse remote socket");
3415
3416         if (rodent.mremcfd < 0) {
3417             rodent.mremcfd = fd;
3418             debug("remote client connect...accepted");
3419         }
3420         else {
3421             close(fd);
3422             debug("another remote client connect...disconnected");
3423         }
3424     }
3425     else {
3426         /* Client disconnected */
3427         debug("remote client disconnected");
3428         close(rodent.mremcfd);
3429         rodent.mremcfd = -1;
3430     }
3431 }