1 /* keyfaker - Linux keyboard-typer faker
    2    Copyright (C) 2010  Kabel
    3 
    4    This program is free software: you can redistribute it and/or modify
    5    it under the terms of the GNU General Public License as published by
    6    the Free Software Foundation, either version 3 of the License, or
    7    (at your option) any later version.
    8 
    9    This program is distributed in the hope that it will be useful,
   10    but WITHOUT ANY WARRANTY; without even the implied warranty of
   11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   12    GNU General Public License for more details.
   13 
   14    You should have received a copy of the GNU General Public License
   15    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
   16 
   17 #include <errno.h>
   18 #include <signal.h>
   19 #include <stdint.h>
   20 #include <linux/input.h>
   21 #include <linux/uinput.h>
   22 #include <stdio.h>
   23 #include <stdlib.h>
   24 #include <string.h>
   25 #include <sys/types.h>
   26 #include <sys/stat.h>
   27 #include <time.h>
   28 #include <unistd.h>
   29 #include <fcntl.h>
   30 
   31 #define SHIFT 0x00000100
   32 
   33 struct {
   34   int keycode;
   35   char ch;
   36 } keys[] = {
   37   { KEY_0, '0' },
   38   { KEY_1, '1' },
   39   { KEY_2, '2' },
   40   { KEY_3, '3' },
   41   { KEY_4, '4' },
   42   { KEY_5, '5' },
   43   { KEY_6, '6' },
   44   { KEY_7, '7' },
   45   { KEY_8, '8' },
   46   { KEY_9, '9' },
   47   { KEY_MINUS, '-' },
   48   { KEY_EQUAL, '=' },
   49   { KEY_A, 'a' },
   50   { KEY_B, 'b' },
   51   { KEY_C, 'c' },
   52   { KEY_D, 'd' },
   53   { KEY_E, 'e' },
   54   { KEY_F, 'f' },
   55   { KEY_G, 'g' },
   56   { KEY_H, 'h' },
   57   { KEY_I, 'i' },
   58   { KEY_J, 'j' },
   59   { KEY_K, 'k' },
   60   { KEY_L, 'l' },
   61   { KEY_M, 'm' },
   62   { KEY_N, 'n' },
   63   { KEY_O, 'o' },
   64   { KEY_P, 'p' },
   65   { KEY_Q, 'q' },
   66   { KEY_R, 'r' },
   67   { KEY_S, 's' },
   68   { KEY_T, 't' },
   69   { KEY_U, 'u' },
   70   { KEY_V, 'v' },
   71   { KEY_W, 'w' },
   72   { KEY_X, 'x' },
   73   { KEY_Y, 'y' },
   74   { KEY_Z, 'z' },
   75   { KEY_LEFTBRACE, '[' },
   76   { KEY_RIGHTBRACE, ']' },
   77   { KEY_SEMICOLON, ';' },
   78   { KEY_APOSTROPHE, '\'' },
   79   { KEY_BACKSLASH, '\\' },
   80   { KEY_COMMA, ',' },
   81   { KEY_DOT, '.' },
   82   { KEY_SLASH, '/' },
   83   { SHIFT | KEY_0, ')' },
   84   { SHIFT | KEY_1, '!' },
   85   { SHIFT | KEY_2, '@' },
   86   { SHIFT | KEY_3, '#' },
   87   { SHIFT | KEY_4, '$' },
   88   { SHIFT | KEY_5, '%' },
   89   { SHIFT | KEY_6, '^' },
   90   { SHIFT | KEY_7, '&' },
   91   { SHIFT | KEY_8, '*' },
   92   { SHIFT | KEY_9, '(' },
   93   { SHIFT | KEY_MINUS, '_' },
   94   { SHIFT | KEY_EQUAL, '+' },
   95   { SHIFT | KEY_A, 'A' },
   96   { SHIFT | KEY_B, 'B' },
   97   { SHIFT | KEY_C, 'C' },
   98   { SHIFT | KEY_D, 'D' },
   99   { SHIFT | KEY_E, 'E' },
  100   { SHIFT | KEY_F, 'F' },
  101   { SHIFT | KEY_G, 'G' },
  102   { SHIFT | KEY_H, 'H' },
  103   { SHIFT | KEY_I, 'I' },
  104   { SHIFT | KEY_J, 'J' },
  105   { SHIFT | KEY_K, 'K' },
  106   { SHIFT | KEY_L, 'L' },
  107   { SHIFT | KEY_M, 'M' },
  108   { SHIFT | KEY_N, 'N' },
  109   { SHIFT | KEY_O, 'O' },
  110   { SHIFT | KEY_P, 'P' },
  111   { SHIFT | KEY_Q, 'Q' },
  112   { SHIFT | KEY_R, 'R' },
  113   { SHIFT | KEY_S, 'S' },
  114   { SHIFT | KEY_T, 'T' },
  115   { SHIFT | KEY_U, 'U' },
  116   { SHIFT | KEY_V, 'V' },
  117   { SHIFT | KEY_W, 'W' },
  118   { SHIFT | KEY_X, 'X' },
  119   { SHIFT | KEY_Y, 'Y' },
  120   { SHIFT | KEY_Z, 'Z' },
  121   { SHIFT | KEY_LEFTBRACE, '{' },
  122   { SHIFT | KEY_RIGHTBRACE, '}' },
  123   { SHIFT | KEY_SEMICOLON, ':' },
  124   { SHIFT | KEY_APOSTROPHE, '"' },
  125   { SHIFT | KEY_BACKSLASH, '|' },
  126   { SHIFT | KEY_COMMA, '<' },
  127   { SHIFT | KEY_DOT, '>' },
  128   { SHIFT | KEY_SLASH, '?' },
  129   { KEY_SPACE, ' ' },
  130   { KEY_TAB, '\t' },
  131   { KEY_ENTER, '\n' },
  132   { 0, 0 }
  133 };
  134 
  135 int from, to;
  136 
  137 void
  138 sigcatch (int sig)
  139 {
  140   if (sig == SIGINT || sig == SIGTERM)
  141     {
  142       ioctl (from, EVIOCGRAB, NULL);
  143       ioctl (to, UI_DEV_DESTROY);
  144       close (from);
  145       close (to);
  146       exit (EXIT_SUCCESS);
  147     }
  148 }
  149 
  150 int
  151 main (int argc, char ** argv)
  152 {
  153   int i, enabled = 0, shift = 0;
  154   ssize_t rd;
  155   struct input_event ev[64];
  156   char * data = NULL;
  157   off_t datalen = 0;
  158   off_t position = 0;
  159   struct uinput_user_dev ud;
  160   struct timespec now, lastF12, lastF11;
  161   int lF12 = 0, lF11 = 0;
  162 
  163   signal (SIGTERM, sigcatch);
  164   signal (SIGINT, sigcatch);
  165 
  166   if (argc < 3)
  167     {
  168       fprintf (stderr, "usage: %s <device> <fakefile>\n\n", basename (argv[0]));
  169       exit (1);
  170     }
  171 
  172   usleep (100000);
  173 
  174   from = open (argv[1], O_RDONLY);
  175   if (from < 0)
  176     {
  177       fprintf (stderr, "cannot open %s: %s\n", argv[1], strerror (errno));
  178       exit (1);
  179     }
  180 
  181   if (ioctl (from, EVIOCGRAB, (void *) 1) < 0)
  182     {
  183       close (from);
  184       fprintf (stderr, "cannot grab %s: %s\n", argv[1], strerror (errno));
  185       exit (1);
  186     }
  187 
  188   to = open ("/dev/input/uinput", O_WRONLY | O_NONBLOCK);
  189   if (to < 0 && errno == ENOENT)
  190     {
  191       fprintf (stderr, "/dev/input/uinput does not exists, trying modprobe uinput\n", strerror (errno));
  192       system ("modprobe uinput");
  193       sleep (1);
  194       to = open ("/dev/input/uinput", O_WRONLY | O_NONBLOCK);
  195     }
  196   if (to < 0)
  197     {
  198       close (from);
  199       fprintf (stderr, "cannot open /dev/input/uinput: %s\n", strerror (errno));
  200       exit (1);
  201     }
  202 
  203   ioctl (to, UI_SET_EVBIT, EV_SYN);
  204   ioctl (to, UI_SET_EVBIT, EV_KEY);
  205 
  206   for (i = 0; i < KEY_MAX; i++)
  207     ioctl (to, UI_SET_KEYBIT, i);
  208 
  209   memset ((void *) &ud, 0, sizeof (ud));
  210   strcpy (ud.name, "kabel keys");
  211   ud.id.version = 4;
  212   ud.id.bustype = BUS_PCI;
  213   write (to, (char *) &ud, sizeof (ud));
  214 
  215   ioctl (to, UI_DEV_CREATE);
  216 
  217   printf ("started\n");
  218 
  219   while (1)
  220     {
  221       rd = read (from, (char *) ev, sizeof (struct input_event) * 64);
  222       for (i = 0; i < rd / sizeof (struct input_event); i++)
  223         {
  224           if (ev[i].type == EV_KEY)
  225             {
  226               if (ev[i].code == KEY_F11)
  227                 {
  228                   if (ev[i].value == 1)
  229                     {
  230                       clock_gettime (CLOCK_MONOTONIC, &lastF11);
  231                       lF11 = 1;
  232                     }
  233                   else if (lF11)
  234                     {
  235                       struct timespec diff;
  236                       clock_gettime (CLOCK_MONOTONIC, &now);
  237                       diff.tv_sec =  now.tv_sec - lastF11.tv_sec;
  238                       diff.tv_nsec = now.tv_nsec - lastF11.tv_nsec;
  239                       if (diff.tv_nsec < 0)
  240                         {
  241                           diff.tv_sec --;
  242                           diff.tv_nsec += 1000000000;
  243                         }
  244                       if (diff.tv_sec >= 5)
  245                         raise (SIGTERM);
  246                     }
  247                 }
  248               else if (ev[i].code == KEY_F12)
  249                 {
  250                   int changestate = 0;
  251                   if (ev[i].value == 1)
  252                     {
  253                       clock_gettime (CLOCK_MONOTONIC, &lastF12);
  254                       lF12 = 1;
  255                     }
  256                   else if (lF12)
  257                     {
  258                       struct timespec diff;
  259                       clock_gettime (CLOCK_MONOTONIC, &now);
  260                       diff.tv_sec =  now.tv_sec - lastF12.tv_sec;
  261                       diff.tv_nsec = now.tv_nsec - lastF12.tv_nsec;
  262                       if (diff.tv_nsec < 0)
  263                         {
  264                           diff.tv_sec --;
  265                           diff.tv_nsec += 1000000000;
  266                         }
  267                       if (diff.tv_sec >= 3)
  268                         {
  269                           changestate = 1;
  270                           lF12 = 0;
  271                         }
  272                     }
  273                   if (changestate)
  274                     {
  275                       if (!enabled)
  276                         {
  277                           struct stat st;
  278                           int fd;
  279                           fd = open (argv[2], O_RDONLY);
  280                           if (fd < 0)
  281                             {
  282                               fprintf (stderr, "can not open %s for reading\n", argv[2]);
  283                               continue;
  284                             }
  285                           stat (argv[2], &st);
  286                           data = malloc (st.st_size);
  287                           read (fd, data, st.st_size);
  288                           datalen = st.st_size;
  289                           position = 0;
  290                           close (fd);
  291                           printf ("faking enabled with %u bytes of data\n", datalen);
  292                           enabled = 1;
  293                         }
  294                       else
  295                         {
  296                           free (data);
  297                           data = NULL;
  298                           datalen = 0;
  299                           position = 0;
  300                           printf ("faking disabled\n");
  301                           enabled = 0;
  302                         }
  303                     }
  304                   continue;
  305                 }
  306               else if (enabled && position < datalen)
  307                 {
  308                   int j;
  309                   for (j = 0; keys[j].keycode != 0; j++)
  310                     if (ev[i].code == (keys[j].keycode & ~SHIFT))
  311                       break;
  312                   if ((keys[j].keycode & ~SHIFT) != 0)
  313                     {
  314                       int k;
  315                       for (k = 0; keys[k].keycode != 0; k++)
  316                         if (data[position] == keys[k].ch)
  317                           break;
  318                       if (keys[j].ch != 0)
  319                         {
  320                           if (ev[i].value == 1)
  321                             {
  322                               struct input_event tev[4];
  323                               int l, shifted;
  324                               tev[0].time = ev[i].time;
  325                               tev[0].type = EV_KEY;
  326                               tev[0].code = KEY_LEFTSHIFT;
  327                               tev[0].value = 1;
  328                               tev[1].time = ev[i].time;
  329                               tev[1].time.tv_usec += 3000;
  330                               if (tev[1].time.tv_usec > 1000000)
  331                                 {
  332                                   tev[1].time.tv_sec += 1;
  333                                   tev[1].time.tv_usec %= 1000000;
  334                                 }
  335                               tev[1].type = EV_KEY;
  336                               tev[1].code = keys[k].keycode & ~SHIFT;
  337                               tev[1].value = 1;
  338                               tev[2].time = ev[i].time;
  339                               tev[2].time.tv_usec += 6000;
  340                               if (tev[2].time.tv_usec > 1000000)
  341                                 {
  342                                   tev[2].time.tv_sec += 1;
  343                                   tev[2].time.tv_usec %= 1000000;
  344                                 }
  345                               tev[2].type = EV_KEY;
  346                               tev[2].code = keys[k].keycode & ~SHIFT;
  347                               tev[2].value = 0;
  348                               tev[3].time = ev[i].time;
  349                               tev[3].time.tv_usec += 9000;
  350                               if (tev[3].time.tv_usec > 1000000)
  351                                 {
  352                                   tev[3].time.tv_sec += 1;
  353                                   tev[3].time.tv_usec %= 1000000;
  354                                 }
  355                               tev[3].type = EV_KEY;
  356                               tev[3].code = KEY_LEFTSHIFT;
  357                               tev[3].value = 0;
  358                               shifted = keys[k].keycode & SHIFT;
  359                               struct input_event sev;
  360                               sev.type = EV_SYN;
  361                               sev.code = 0;
  362                               sev.value = 0;
  363                               for (l = shifted ? 0 : 1; l < (shifted ? 4 : 3); l++)
  364                                 {
  365                                   write (to, (char *) &tev[l], sizeof (struct input_event));
  366                                   sev.time = tev[l].time;
  367                                   sev.time.tv_usec += 3;
  368                                   if (sev.time.tv_usec >= 1000000)
  369                                     {
  370                                       sev.time.tv_sec += 1;
  371                                       sev.time.tv_usec %= 1000000;
  372                                     }
  373                                   write (to, (char *) &sev, sizeof (struct input_event));
  374                                 }
  375                               position++;
  376                             }
  377                         }
  378                       else
  379                         goto other;
  380                     }
  381                   else
  382                     goto other;
  383                 }
  384               else
  385                 {
  386 other:
  387                   if (!enabled || (enabled && ev[i].code != KEY_LEFTSHIFT &&
  388                                    ev[i].code != KEY_RIGHTSHIFT && ev[i].code != KEY_CAPSLOCK))
  389                     write (to, (char *) &ev[i], sizeof (struct input_event));
  390                   if (enabled && ev[i].code == KEY_BACKSPACE && ev[i].value && position > 0)
  391                     position --;
  392                 }
  393             }
  394           else if (ev[i].type == EV_SYN)
  395             write (to, (char *) &ev[i], sizeof (struct input_event));
  396         }
  397     }
  398 }