git.itanic.dy.fi Git - glucose/blob - main.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4 #include <linux/types.h>
   5 #include <linux/hiddev.h>
   6 #include <string.h>
   7 #include <errno.h>
   8 #include <time.h>
   9
  10 #include "hiddev.h"
  11 #include "utils.h"
  12
  13
  14 struct msg {
  15         int direction;
  16         unsigned char data[64];
  17 };
  18
  19 enum direction {
  20         IN = 666,
  21         OUT,
  22 };
  23
  24 int send_msg(const struct msg *msg, int fd, int usage_code)
  25 {
  26         int ret;
  27
  28         if (msg->direction != OUT) {
  29                 printf("Message direction is not OUT\n");
  30                 exit(1);
  31         }
  32
  33         usleep(30 * 1000);
  34         printf("Sending: ");
  35         print_hex(msg->data + 1, datalen(msg->data) - 1);
  36         print_ascii(msg->data + 1, datalen(msg->data) - 1);
  37
  38         ret = hiddev_write(msg->data, fd, usage_code);
  39         if (ret)
  40                 exit(1);
  41
  42         return 0;
  43 }
  44
  45 int read_and_verify(struct msg *msg, int fd)
  46 {
  47         unsigned char buf[64];
  48         int ret, offset = 0;
  49
  50         while (offset < 64) {
  51                 ret = hiddev_read(buf + offset, sizeof(buf) - offset, fd);
  52
  53                 if (ret < 0)
  54                         goto err;
  55
  56                 offset += ret;
  57         }
  58
  59         memcpy(msg->data, buf, sizeof(buf));
  60         printf("Got data %d: ", datalen(buf));
  61 //      print_hex(buf, datalen(buf));
  62         print_ascii(buf, datalen(buf));
  63 err:
  64         return 0;
  65 }
  66
  67 int read_msgs(int fd)
  68 {
  69         struct msg msg;
  70         while (1) {
  71                 read_and_verify(&msg, fd);
  72                 if (datalen(msg.data) <= 36)
  73                         break;
  74         }
  75
  76         return 0;
  77 }
  78
  79 #define SET_FIRST_BYTE(byte)                                    \
  80         do {                                                    \
  81                 memset(&msg.data, 0, sizeof(msg.data));         \
  82                 msg.data[4] = (byte);                           \
  83                 j = 5;                                          \
  84         } while (0)
  85
  86 #define SET_BYTE(idx, byte)                     \
  87         do {                                    \
  88                 msg.data[(idx) + 4] = (byte);   \
  89                 j = (idx) + 1;                  \
  90         } while (0)
  91
  92 #define SET_BYTES(byte) msg.data[j++] = (byte)
  93
  94 int send_pattern(int fd, int uc, unsigned char byte1, unsigned char byte2)
  95 {
  96         int j;
  97         struct msg msg;
  98         msg.direction = OUT;
  99
 100         usleep(100 * 1000);
 101         SET_FIRST_BYTE(0x01);
 102         SET_BYTES(0x04);
 103         send_msg(&msg, fd, uc);
 104         read_msgs(fd);
 105
 106         usleep(250 * 1000);
 107         SET_BYTE(1, 0x15);
 108         send_msg(&msg, fd, uc);
 109         read_msgs(fd);
 110
 111         usleep(100 * 1000);
 112         SET_BYTE(1, 0x05);
 113         send_msg(&msg, fd, uc);
 114         read_msgs(fd);
 115
 116         SET_FIRST_BYTE(0x02);
 117         SET_BYTES(byte1);
 118         SET_BYTES('|');
 119         send_msg(&msg, fd, uc);
 120         read_msgs(fd);
 121
 122         usleep(100 * 1000);
 123         SET_BYTE(1, byte2);
 124         send_msg(&msg, fd, uc);
 125         read_msgs(fd);
 126
 127         return 0;
 128 }
 129
 130 int communicate(int fd, int uc)
 131 {
 132         int i, j;
 133         struct msg msg, in;
 134         msg.direction = OUT;
 135
 136         read_msgs(fd);
 137         SET_FIRST_BYTE(0x01);
 138         SET_BYTES(0x04);
 139         send_msg(&msg, fd, uc);
 140
 141         usleep(100 * 1000);
 142         SET_BYTE(1, 0x06);
 143         send_msg(&msg, fd, uc);
 144         read_msgs(fd);
 145
 146         SET_BYTE(1, 0x15);
 147         for (i = 0; i < 6; i++) {
 148                 usleep(100 * 1000);
 149                 send_msg(&msg, fd, uc);
 150                 read_msgs(fd);
 151         }
 152         usleep(1000 * 1000);
 153         read_msgs(fd);
 154         send_msg(&msg, fd, uc);
 155         read_msgs(fd);
 156
 157         usleep(100 * 1000);
 158         SET_BYTE(1, 0x05);
 159         send_msg(&msg, fd, uc);
 160         read_msgs(fd);
 161
 162         send_pattern(fd, uc, 'R', 'A');
 163         send_pattern(fd, uc, 'R', 'C');
 164         send_pattern(fd, uc, 'R', 'D');
 165         send_pattern(fd, uc, 'R', 'G');
 166         send_pattern(fd, uc, 'R', 'I');
 167         send_pattern(fd, uc, 'R', 'M');
 168         send_pattern(fd, uc, 'R', 'P');
 169         send_pattern(fd, uc, 'R', 'R');
 170         send_pattern(fd, uc, 'R', 'S');
 171         send_pattern(fd, uc, 'R', 'T');
 172         send_pattern(fd, uc, 'R', 'U');
 173         send_pattern(fd, uc, 'R', 'V');
 174         send_pattern(fd, uc, 'R', 'W');
 175         send_pattern(fd, uc, 'R', 'X');
 176         send_pattern(fd, uc, 'W', 'K');
 177
 178         usleep(100 * 1000);
 179         SET_FIRST_BYTE(0x08);
 180         SET_BYTES('O');
 181         SET_BYTES('b');
 182         SET_BYTES('p');
 183         SET_BYTES('s');
 184         SET_BYTES('e');
 185         SET_BYTES('c');
 186         SET_BYTES('3');
 187         SET_BYTES('|');
 188         send_msg(&msg, fd, uc);
 189         read_msgs(fd);
 190
 191         usleep(410 * 1000);
 192         SET_FIRST_BYTE(0x02);
 193         SET_BYTES('R');
 194         SET_BYTES('|');
 195         send_msg(&msg, fd, uc);
 196         read_msgs(fd);
 197
 198         usleep(100 * 1000);
 199         SET_BYTE(1, 'Y');
 200         send_msg(&msg, fd, uc);
 201         read_msgs(fd);
 202
 203         usleep(100 * 1000);
 204         SET_BYTE(1, 'W');
 205         send_msg(&msg, fd, uc);
 206         read_msgs(fd);
 207
 208         usleep(100 * 1000);
 209         SET_BYTE(1, 'K');
 210         send_msg(&msg, fd, uc);
 211         read_msgs(fd);
 212
 213         usleep(100 * 1000);
 214         SET_BYTE(1, 'C');
 215         send_msg(&msg, fd, uc);
 216         read_msgs(fd);
 217
 218         send_pattern(fd, uc, 'R', 'Z');
 219
 220         usleep(100 * 1000);
 221         SET_FIRST_BYTE(0x01);
 222         SET_BYTES(0x04);
 223         send_msg(&msg, fd, uc);
 224         read_msgs(fd);
 225
 226         usleep(100 * 1000);
 227         SET_BYTE(1, 0x15);
 228         send_msg(&msg, fd, uc);
 229         read_msgs(fd);
 230
 231         usleep(100 * 1000);
 232         SET_BYTE(1, 0x05);
 233         send_msg(&msg, fd, uc);
 234         read_msgs(fd);
 235
 236         usleep(100 * 1000);
 237         SET_BYTE(1, 0x04);
 238         send_msg(&msg, fd, uc);
 239         read_msgs(fd);
 240
 241         usleep(100 * 1000);
 242         send_msg(&msg, fd, uc);
 243         read_msgs(fd);
 244
 245         usleep(100 * 1000);
 246         SET_BYTE(1, 0x06);
 247         send_msg(&msg, fd, uc);
 248         read_msgs(fd);
 249
 250         usleep(100 * 1000);
 251         send_msg(&msg, fd, uc);
 252         read_msgs(fd);
 253
 254         usleep(100 * 1000);
 255         send_msg(&msg, fd, uc);
 256         read_msgs(fd);
 257
 258         usleep(100 * 1000);
 259         do {
 260                 send_msg(&msg, fd, uc);
 261                 read_and_verify(&in, fd);
 262         } while (datalen(in.data) > 45);
 263
 264         return 0;
 265 }
 266
 267 int main(int argc, char *argv[])
 268 {
 269         int fd, usage_code;
 270
 271         fd = hiddev_open(argv[1], &usage_code);
 272         if (fd < 0)
 273                 return 1;
 274
 275         communicate(fd, usage_code);
 276
 277         return 0;
 278 }