home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / ABUSESRC.ZIP / AbuseSrc / macabuse / src / keydrv.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-20  |  4.2 KB  |  183 lines
  1. /*      Key driver, by Jonathan Clark 
  2.           (portions from showkey.c)
  3. */
  4.  
  5. #include <stdio.h>
  6. #include <unistd.h>
  7. #include <getopt.h>
  8. #include <signal.h>
  9. #include <fcntl.h>
  10. #include <termios.h>
  11. #include <linux/kd.h>
  12. #include <linux/vt.h>
  13. #include <fcntl.h>
  14. #include <sys/stat.h>
  15.  
  16.  
  17.  
  18. unsigned char keyboard_buf[16];
  19.  
  20. #include <linux/keyboard.h>
  21. #include <sys/ioctl.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24.  
  25. int fd,my_console=-1;
  26. struct termios old_term;
  27.  
  28. void clean_up(int close_fd) {
  29.     ioctl(fd, KDSKBMODE, K_XLATE);
  30.  
  31.     tcsetattr(fd, TCSAFLUSH, &old_term);
  32.         if (close_fd)
  33.         close(fd);
  34.         if (close_fd)
  35.           exit(0);
  36. }
  37.  
  38. void go_raw(int open_fd)
  39. {
  40.     struct termios new_term;
  41.         struct vt_stat v;
  42.         if (open_fd)
  43.         {
  44.           if ((fd = open("/dev/console", O_RDONLY)) < 0) {
  45.             perror("/dev/console");
  46.             exit(1);
  47.         }
  48.     }
  49.         if (my_console==-1)
  50.         {
  51.           ioctl(fd,VT_GETSTATE,&v);  /* see which console we are using */ 
  52.           my_console=v.v_active;
  53.         }
  54.         ioctl(fd,VT_WAITACTIVE,my_console);  /* wait for our console to come back */
  55.  
  56.     tcgetattr(fd, &new_term);
  57.     tcgetattr(fd, &old_term);
  58.  
  59.     new_term.c_lflag = new_term.c_lflag & ~ (ICANON | ECHO | ISIG );
  60.     new_term.c_cc[VMIN] = 1; //sizeof(keyboard_buf);
  61.     new_term.c_cc[VTIME] = 0;    /* 0.1 sec intercharacter timeout */
  62.  
  63.     tcsetattr(fd, TCSAFLUSH, &new_term);
  64.     if (ioctl(fd, KDSKBMODE,
  65.         K_RAW)) {
  66.         perror("KDSKBMODE");
  67.         exit(1);
  68.     }
  69.         system("stty raw </dev/console >/dev/console");
  70.  
  71. }
  72.  
  73. void die(int x) {
  74.         fprintf(stderr,"die %d\n",x);
  75.    
  76.     clean_up(1);
  77.     exit(1);
  78. }
  79.  
  80. int key_watch(int write_fd) 
  81. {
  82.         unsigned char map[128];
  83.  
  84.     int i, n,lalt,ralt,switch_to,lctrl,rctrl,up,quit;
  85.  
  86.  
  87.     /*
  88.         if we receive a signal, we want to exit nicely, in
  89.         order not to leave the keyboard in an unusable mode
  90.     */
  91.     signal(SIGHUP, die);
  92.     signal(SIGINT, die);
  93.     signal(SIGQUIT, die);
  94.     signal(SIGILL, die);
  95.     signal(SIGTRAP, die);
  96.     signal(SIGABRT, die);
  97.     signal(SIGIOT, die);
  98.     signal(SIGFPE, die);
  99.     signal(SIGKILL, die);
  100.     signal(SIGUSR1, die);
  101.     signal(SIGSEGV, die);
  102.     signal(SIGUSR2, die);
  103.     signal(SIGPIPE, die);
  104.     signal(SIGTERM, die);
  105.     signal(SIGSTKFLT, die);
  106.     signal(SIGCHLD, die);
  107.     signal(SIGCONT, die);
  108.     signal(SIGSTOP, die);
  109.     signal(SIGTSTP, die);
  110.     signal(SIGTTIN, die);
  111.     signal(SIGTTOU, die);
  112.  
  113.         go_raw(1);
  114.         quit=lalt=ralt=lctrl=rctrl=0;
  115.         memset(map,0,128);
  116.     while (!quit) {
  117.         n = read(fd, keyboard_buf, sizeof(keyboard_buf));
  118.         for (i = 0; i < n; i++) 
  119.                 { up=!(keyboard_buf[i]&0x80);
  120.                   if ((keyboard_buf[i]&0x7f)==56) lalt=up; 
  121.                   if ((keyboard_buf[i]&0x7f)==96) ralt=up;
  122.                   if ((keyboard_buf[i]&0x7f)==29) lctrl=up;
  123.                   if (up || up!=map[(keyboard_buf[i]&0x7f)])
  124.                   {
  125.                     map[(keyboard_buf[i]&0x7f)]=up;
  126.                     if (!write(write_fd,&keyboard_buf[i],1))
  127.             {
  128.               fprintf(stderr,"keydrv : unable to write to parent (cleaning up)\n");
  129.               clean_up(1);
  130.               exit(0);
  131.             }
  132.                   }
  133.                 }
  134.         for (i = 0; i < n; i++) 
  135.                 {
  136.                   if ((lalt || ralt) && (keyboard_buf[i]&0x7f)>=59 &&
  137.                       (keyboard_buf[i]&0x7f)<=68)
  138.                   { 
  139.  
  140.                     switch_to=(keyboard_buf[i]&0x7f)-58;
  141.                     clean_up(0);
  142.             
  143.                     ioctl(fd,VT_ACTIVATE,switch_to);
  144.                     go_raw(0); 
  145.                   }
  146.                   if ((lctrl || rctrl) && (keyboard_buf[i]&0x7f)==46)
  147.                   {
  148.                     fprintf(stderr,"^C\n"); fflush(stderr);
  149.                     quit=1;
  150.                   }
  151.                 }
  152.  
  153.     }
  154.     clean_up(1);
  155.     exit(0);
  156. }
  157.  
  158.  
  159. main()
  160. {
  161.   int f,chd;
  162.   unlink("/tmp/jckey-driver");
  163.   if (mkfifo("/tmp/jckey-driver",S_IRWXU))
  164.   { perror("Key driver : unable to make fifo /tmp/jckey-driver");
  165.     exit(1);
  166.   }
  167.   chd=fork();
  168.   if (chd) 
  169.   { printf("%d\n",chd);
  170.     return 0;
  171.   }
  172.   f=open("/tmp/jckey-driver",O_WRONLY);
  173.   if (f<0)
  174.   { perror("/tmp/jckey-driver"); 
  175.     exit(1);
  176.   }
  177.   key_watch(f);
  178.   close(f);
  179.   unlink("/tmp/jckey-driver");
  180. }
  181.  
  182.  
  183.