x5/khatus.c

   1 #include <sys/select.h>
   2 #include <sys/stat.h>
   3
   4 #include <assert.h>
   5 #include <ctype.h>
   6 #include <errno.h>
   7 #include <fcntl.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <time.h>
  12 #include <unistd.h>
  13
  14 #include <X11/Xlib.h>
  15
  16 #include "bsdtimespec.h"
  17 #include "khlib_log.h"
  18 #include "khlib_time.h"
  19
  20 #define usage(...) { \
  21         print_usage(); \
  22         fprintf(stderr, "Error:\n    " __VA_ARGS__); \
  23         exit(EXIT_FAILURE); \
  24 }
  25 #define ERRMSG "ERROR"
  26
  27
  28 static const char errmsg[] = ERRMSG;
  29 static const int  errlen   = sizeof(ERRMSG) - 1;
  30
  31 char *argv0;
  32
  33 /* TODO: Convert slot list to slot array. */
  34 typedef struct Slot Slot;
  35 struct Slot {
  36         char            *in_fifo;
  37         int              in_fd;
  38         struct timespec  in_last_read;
  39         struct timespec  out_ttl;
  40         int              out_width;
  41         int              out_pos_lo;   /* Lowest  position on the output buffer. */
  42         int              out_pos_cur;  /* Current position on the output buffer. */
  43         int              out_pos_hi;   /* Highest position on the output buffer. */
  44         Slot            *next;
  45 };
  46
  47 typedef struct Config Config;
  48 struct Config {
  49         double interval;
  50         char * separator;
  51         Slot * slots;
  52         int    slot_count;
  53         int    total_width;
  54         int    output_to_x_root_window;
  55 };
  56
  57 enum read_status {
  58         END_OF_FILE,
  59         END_OF_MESSAGE,
  60         RETRY,
  61         FAILURE
  62 };
  63
  64 Slot *
  65 slots_rev(Slot *old)
  66 {
  67         Slot *tmp = NULL;
  68         Slot *new = NULL;
  69
  70         while (old) {
  71                 tmp       = old->next;
  72                 old->next = new;
  73                 new       = old;
  74                 old       = tmp;
  75         }
  76         return new;
  77 }
  78
  79 void
  80 slot_print(Slot *s)
  81 {
  82         khlib_info("Slot "
  83             "{"
  84             " in_fifo = %s,"
  85             " in_fd = %d,"
  86             " out_width = %d,"
  87             " in_last_read = {tv_sec = %ld, tv_nsec = %ld}"
  88             " out_ttl = {tv_sec = %ld, tv_nsec = %ld},"
  89             " out_pos_lo = %d,"
  90             " out_pos_cur = %d,"
  91             " out_pos_hi = %d,"
  92             " next = %p,"
  93             " }\n",
  94             s->in_fifo,
  95             s->in_fd,
  96             s->out_width,
  97             s->in_last_read.tv_sec,
  98             s->in_last_read.tv_nsec,
  99             s->out_ttl.tv_sec,
 100             s->out_ttl.tv_nsec,
 101             s->out_pos_lo,
 102             s->out_pos_cur,
 103             s->out_pos_hi,
 104             s->next
 105         );
 106 }
 107
 108 void
 109 slots_print(Slot *head)
 110 {
 111         for (Slot *s = head; s; s = s->next) {
 112                 slot_print(s);
 113         }
 114 }
 115
 116 void
 117 slot_expire(Slot *s, struct timespec t, char *buf)
 118 {
 119         struct timespec td;
 120
 121         timespecsub(&t, &(s->in_last_read), &td);
 122         if (timespeccmp(&td, &(s->out_ttl), >=)) {
 123                 /* TODO: Maybe configurable expiry character. */
 124                 memset(buf + s->out_pos_lo, '_', s->out_width);
 125                 khlib_warn("Slot expired: \"%s\"\n", s->in_fifo);
 126         }
 127 }
 128
 129 void
 130 slot_set_error(Slot *s, char *buf)
 131 {
 132         char *b;
 133         int i;
 134
 135         s->in_fd = -1;
 136         b = buf + s->out_pos_lo;
 137         /* Copy as much of the error message as possible.
 138          * EXCLUDING the terminating \0. */
 139         for (i = 0; i < errlen && i < s->out_width; i++)
 140                 b[i] = errmsg[i];
 141         /* Any remaining positions: */
 142         memset(b + i, '_', s->out_width - i);
 143 }
 144
 145 enum read_status
 146 slot_read(Slot *s, char *buf)
 147 {
 148         char c;  /* Character read. */
 149         int  r;  /* Remaining unused positions in buffer range. */
 150
 151         for (;;) {
 152                 switch (read(s->in_fd, &c, 1)) {
 153                 case -1:
 154                         khlib_error(
 155                             "Failed to read: \"%s\". errno: %d, msg: %s\n",
 156                             s->in_fifo,
 157                             errno,
 158                             strerror(errno)
 159                         );
 160                         switch (errno) {
 161                         case EINTR:
 162                         case EAGAIN:
 163                                 return RETRY;
 164                         default:
 165                                 return FAILURE;
 166                         }
 167                 case  0:
 168                         khlib_debug("%s: End of FILE\n", s->in_fifo);
 169                         s->out_pos_cur = s->out_pos_lo;
 170                         return END_OF_FILE;
 171                 case  1:
 172                         /* TODO: Consider making msg term char a CLI option */
 173                         if (c == '\n' || c == '\0') {
 174                                 r = (s->out_pos_hi - s->out_pos_cur) + 1;
 175                                 if (r > 0)
 176                                         memset(buf + s->out_pos_cur, ' ', r);
 177                                 return END_OF_MESSAGE;
 178                         } else {
 179                                 if (s->out_pos_cur <= s->out_pos_hi)
 180                                         buf[s->out_pos_cur++] = c;
 181                                 else
 182                                         /*
 183                                          * Force EOM beyond available range.
 184                                          * To ensure that a rogue large message
 185                                          * doesn't trap us here needlessly
 186                                          * long.
 187                                          */
 188                                         return END_OF_MESSAGE;
 189                         }
 190                         break;
 191                 default:
 192                         assert(0);
 193                 }
 194         }
 195 }
 196
 197 void
 198 slots_read(Config *cfg, struct timespec *ti, char *buf)
 199 {
 200         fd_set fds;
 201         int maxfd = -1;
 202         int ready = 0;
 203         struct stat st;
 204         struct timespec t;
 205         Slot *s;
 206
 207         FD_ZERO(&fds);
 208         for (s = cfg->slots; s; s = s->next) {
 209                 /* TODO: Create the FIFO if it doesn't already exist. */
 210                 if (lstat(s->in_fifo, &st) < 0) {
 211                         khlib_error(
 212                             "Cannot stat \"%s\". Error: %s\n",
 213                             s->in_fifo,
 214                             strerror(errno)
 215                         );
 216                         slot_set_error(s, buf);
 217                         continue;
 218                 }
 219                 if (!(st.st_mode & S_IFIFO)) {
 220                         khlib_error("\"%s\" is not a FIFO\n", s->in_fifo);
 221                         slot_set_error(s, buf);
 222                         continue;
 223                 }
 224                 if (s->in_fd < 0) {
 225                         khlib_debug(
 226                             "%s: closed. opening. in_fd: %d\n",
 227                             s->in_fifo,
 228                             s->in_fd
 229                         );
 230                         s->in_fd = open(s->in_fifo, O_RDONLY | O_NONBLOCK);
 231                 } else {
 232                         khlib_debug(
 233                             "%s: already openned. in_fd: %d\n",
 234                             s->in_fifo,
 235                             s->in_fd
 236                         );
 237                 }
 238                 if (s->in_fd == -1) {
 239                         /* TODO Consider backing off retries for failed slots */
 240                         khlib_error("Failed to open \"%s\"\n", s->in_fifo);
 241                         slot_set_error(s, buf);
 242                         continue;
 243                 }
 244                 khlib_debug("%s: open. in_fd: %d\n", s->in_fifo, s->in_fd);
 245                 if (s->in_fd > maxfd)
 246                         maxfd = s->in_fd;
 247                 FD_SET(s->in_fd, &fds);
 248         }
 249         khlib_debug("selecting...\n");
 250         ready = pselect(maxfd + 1, &fds, NULL, NULL, ti, NULL);
 251         khlib_debug("ready: %d\n", ready);
 252         clock_gettime(CLOCK_MONOTONIC, &t);
 253         if (ready == -1) {
 254                 switch (errno) {
 255                 case EINTR:
 256                         khlib_error(
 257                             "pselect temp failure: %d, errno: %d, msg: %s\n",
 258                             ready,
 259                             errno,
 260                             strerror(errno)
 261                         );
 262                         /* TODO: Reconsider what to do here. */
 263                         return;
 264                 default:
 265                         khlib_fatal(
 266                             "pselect failed: %d, errno: %d, msg: %s\n",
 267                             ready,
 268                             errno,
 269                             strerror(errno)
 270                         );
 271                 }
 272         }
 273         /* At-least-once ensures that expiries are still checked on timeouts. */
 274         do {
 275                 for (s = cfg->slots; s; s = s->next) {
 276                         if (s->in_fd < 0)
 277                                 continue;
 278                         if (FD_ISSET(s->in_fd, &fds)) {
 279                                 khlib_debug("reading: %s\n", s->in_fifo);
 280                                 switch (slot_read(s, buf)) {
 281                                 /*
 282                                  * ### MESSAGE LOSS ###
 283                                  * is introduced by closing at EOM in addition
 284                                  * to EOF, since there may be unread messages
 285                                  * remaining in the pipe. However,
 286                                  *
 287                                  * ### INTER-MESSAGE PUSHBACK ###
 288                                  * is also gained, since pipes block at the
 289                                  * "open" call.
 290                                  *
 291                                  * This is an acceptable trade-off because we
 292                                  * are a stateless reporter of a _most-recent_
 293                                  * status, not a stateful accumulator.
 294                                  *
 295                                  * ### LOSSLESS ALTERNATIVES ###
 296                                  * - Read each pipe until EOF before reading
 297                                  *   another.
 298                                  *   PROBLEM: a fast writer can trap us in the
 299                                  *   read loop.
 300                                  *
 301                                  * - Read each pipe until EOM, but close only
 302                                  *   at EOF.
 303                                  *   PROBLEM: a fast writer can fill the pipe
 304                                  *   faster than we can read it and we end-up
 305                                  *   displaying stale data.
 306                                  *
 307                                  */
 308                                 case END_OF_MESSAGE:
 309                                 case END_OF_FILE:
 310                                 case FAILURE:
 311                                         close(s->in_fd);
 312                                         s->in_fd        = -1;
 313                                         s->in_last_read = t;
 314                                         s->out_pos_cur  = s->out_pos_lo;
 315                                         ready--;
 316                                         break;
 317                                 case RETRY:
 318                                         break;
 319                                 default:
 320                                         assert(0);
 321                                 }
 322                         } else {
 323                                 slot_expire(s, t, buf);
 324                         }
 325                 }
 326         } while (ready);
 327         assert(ready == 0);
 328 }
 329
 330 void
 331 config_print(Config *cfg)
 332 {
 333         khlib_info(
 334             "Config "
 335             "{"
 336             " interval = %f,"
 337             " separator = %s,"
 338             " slot_count = %d,"
 339             " total_width = %d,"
 340             " slots = ..."
 341             " }\n",
 342             cfg->interval,
 343             cfg->separator,
 344             cfg->slot_count,
 345             cfg->total_width
 346         );
 347         slots_print(cfg->slots);
 348 }
 349
 350 int
 351 is_pos_num(char *str)
 352 {
 353         while (*str != '\0')
 354                 if (!isdigit(*(str++)))
 355                         return 0;
 356         return 1;
 357 }
 358
 359 int
 360 is_decimal(char *str)
 361 {
 362         char c;
 363         int seen = 0;
 364
 365         while ((c = *(str++)) != '\0')
 366                 if (!isdigit(c)) {
 367                         if (c == '.' && !seen++)
 368                                 continue;
 369                         else
 370                                 return 0;
 371                 }
 372         return 1;
 373 }
 374
 375 void
 376 print_usage()
 377 {
 378         assert(argv0);
 379         fprintf(
 380             stderr,
 381             "\n"
 382             "Usage: %s [OPTION ...] SPEC [SPEC ...]\n"
 383             "\n"
 384             "  SPEC       = FILE_PATH DATA_WIDTH DATA_TTL\n"
 385             "  FILE_PATH  = string\n"
 386             "  DATA_WIDTH = int  (* (positive) number of characters *)\n"
 387             "  DATA_TTL   = float  (* (positive) number of seconds *)\n"
 388             "  OPTION     = -i INTERVAL\n"
 389             "             | -s SEPARATOR\n"
 390             "             | -x (* Output to X root window *)\n"
 391             "             | -l LOG_LEVEL\n"
 392             "  SEPARATOR  = string\n"
 393             "  INTERVAL   = float  (* (positive) number of seconds *)\n"
 394             "  LOG_LEVEL  = int  (* %d through %d *)\n"
 395             "\n",
 396             argv0,
 397             Nothing,
 398             Debug
 399         );
 400         fprintf(
 401             stderr,
 402             "Example: %s -i 1 /dev/shm/khatus/khatus_sensor_x 4 10\n"
 403             "\n",
 404             argv0
 405         );
 406 }
 407
 408 /* For mutually-recursive calls. */
 409 void opts_parse_any(Config *, int, char *[], int);
 410
 411 void
 412 parse_opts_opt_i(Config *cfg, int argc, char *argv[], int i)
 413 {
 414         char *param;
 415
 416         if (i >= argc)
 417                 usage("Option -i parameter is missing.\n");
 418         param = argv[i++];
 419         if (!is_decimal(param))
 420                 usage("Option -i parameter is invalid: \"%s\"\n", param);
 421         cfg->interval = atof(param);
 422         opts_parse_any(cfg, argc, argv, i);
 423 }
 424
 425 void
 426 parse_opts_opt_s(Config *cfg, int argc, char *argv[], int i)
 427 {
 428         if (i >= argc)
 429                 usage("Option -s parameter is missing.\n");
 430         cfg->separator = calloc((strlen(argv[i]) + 1), sizeof(char));
 431         strcpy(cfg->separator, argv[i]);
 432         opts_parse_any(cfg, argc, argv, ++i);
 433 }
 434
 435 void
 436 parse_opts_opt_l(Config *cfg, int argc, char *argv[], int i)
 437 {
 438         char *param;
 439         int log_level;
 440
 441         if (i >= argc)
 442                 usage("Option -l parameter is missing.\n");
 443         param = argv[i++];
 444         if (!is_pos_num(param))
 445                 usage("Option -l parameter is invalid: \"%s\"\n", param);
 446         log_level = atoi(param);
 447         if (log_level > Debug)
 448                 usage(
 449                     "Option -l value (%d) exceeds maximum (%d)\n",
 450                     log_level,
 451                     Debug
 452                 );
 453         _khlib_log_level = log_level;
 454         opts_parse_any(cfg, argc, argv, i);
 455 }
 456
 457 void
 458 parse_opts_opt(Config *cfg, int argc, char *argv[], int i)
 459 {
 460         switch (argv[i][1]) {
 461         case 'i':
 462                 /* TODO: Generic set_int */
 463                 parse_opts_opt_i(cfg, argc, argv, ++i);
 464                 break;
 465         case 's':
 466                 /* TODO: Generic set_str */
 467                 parse_opts_opt_s(cfg, argc, argv, ++i);
 468                 break;
 469         case 'x':
 470                 cfg->output_to_x_root_window = 1;
 471                 opts_parse_any(cfg, argc, argv, ++i);
 472                 break;
 473         case 'l':
 474                 /* TODO: Generic set_int */
 475                 parse_opts_opt_l(cfg, argc, argv, ++i);
 476                 break;
 477         default :
 478                 usage("Option \"%s\" is invalid\n", argv[i]);
 479         }
 480 }
 481
 482 void
 483 parse_opts_spec(Config *cfg, int argc, char *argv[], int i)
 484 {
 485         char *n;
 486         char *w;
 487         char *t;
 488         struct timespec in_last_read;
 489         Slot *s;
 490
 491         if ((i + 3) > argc)
 492                 usage(
 493                     "[spec] Parameter(s) missing for fifo \"%s\".\n",
 494                     argv[i]
 495                 );
 496
 497         n = argv[i++];
 498         w = argv[i++];
 499         t = argv[i++];
 500
 501         if (!is_pos_num(w))
 502                 usage("[spec] Invalid width: \"%s\", for fifo \"%s\"\n", w, n);
 503         if (!is_decimal(t))
 504                 usage("[spec] Invalid TTL: \"%s\", for fifo \"%s\"\n", t, n);
 505
 506         in_last_read.tv_sec  = 0;
 507         in_last_read.tv_nsec = 0;
 508         s = calloc(1, sizeof(struct Slot));
 509
 510         if (s) {
 511                 s->in_fifo      = n;
 512                 s->in_fd        = -1;
 513                 s->out_width    = atoi(w);
 514                 s->out_ttl      = khlib_timespec_of_float(atof(t));
 515                 s->in_last_read = in_last_read;
 516                 s->out_pos_lo   = cfg->total_width;
 517                 s->out_pos_cur  = s->out_pos_lo;
 518                 s->out_pos_hi   = s->out_pos_lo + s->out_width - 1;
 519                 s->next         = cfg->slots;
 520
 521                 cfg->slots        = s;
 522                 cfg->total_width += s->out_width;
 523                 cfg->slot_count++;
 524         } else {
 525                 khlib_fatal("[memory] Allocation failure.");
 526         }
 527         opts_parse_any(cfg, argc, argv, i);
 528 }
 529
 530 void
 531 opts_parse_any(Config *cfg, int argc, char *argv[], int i)
 532 {
 533         if (i < argc) {
 534                 switch (argv[i][0]) {
 535                 case '-':
 536                         parse_opts_opt(cfg, argc, argv, i);
 537                         break;
 538                 default :
 539                         parse_opts_spec(cfg, argc, argv, i);
 540                 }
 541         }
 542 }
 543
 544 void
 545 opts_parse(Config *cfg, int argc, char *argv[])
 546 {
 547         opts_parse_any(cfg, argc, argv, 1);
 548         cfg->slots = slots_rev(cfg->slots);
 549 }
 550
 551 int
 552 main(int argc, char *argv[])
 553 {
 554         Config cfg = {
 555                 .interval    = 1.0,
 556                 .separator   = "|",
 557                 .slots       = NULL,
 558                 .slot_count  = 0,
 559                 .total_width = 0,
 560                 .output_to_x_root_window = 0,
 561         };
 562
 563         int width  = 0;
 564         int nslots = 0;
 565         int seplen = 0;
 566         int prefix = 0;
 567         int errors = 0;
 568         char *buf;
 569         Display *d = NULL;
 570         struct stat st;
 571         struct timespec
 572                 t0,  /* time stamp. before reading slots */
 573                 t1,  /* time stamp. after  reading slots */
 574                 ti,  /* time interval desired    (t1 - t0) */
 575                 td,  /* time interval measured   (t1 - t0) */
 576                 tc;  /* time interval correction (ti - td) when td < ti */
 577         Slot *s;
 578
 579         argv0 = argv[0];
 580
 581         opts_parse(&cfg, argc, argv);
 582         khlib_debug("argv0 = %s\n", argv0);
 583         config_print(&cfg);
 584
 585         ti = khlib_timespec_of_float(cfg.interval);
 586
 587         if (cfg.slots == NULL)
 588                 usage("No slot specs were given!\n");
 589
 590         /* 1st pass to check file existence and type */
 591         for (s = cfg.slots; s; s = s->next) {
 592                 if (lstat(s->in_fifo, &st) < 0) {
 593                         khlib_error(
 594                             "Cannot stat \"%s\". Error: %s\n",
 595                             s->in_fifo,
 596                             strerror(errno)
 597                         );
 598                         errors++;
 599                         continue;
 600                 }
 601                 if (!(st.st_mode & S_IFIFO)) {
 602                         khlib_error("\"%s\" is not a FIFO\n", s->in_fifo);
 603                         errors++;
 604                         continue;
 605                 }
 606         }
 607         if (errors)
 608                 khlib_fatal(
 609                     "Encountered errors with given file paths. See log.\n"
 610                 );
 611
 612         width  = cfg.total_width;
 613         seplen = strlen(cfg.separator);
 614
 615         /* 2nd pass to make space for separators */
 616         for (s = cfg.slots; s; s = s->next) {
 617                 s->out_pos_lo  += prefix;
 618                 s->out_pos_hi += prefix;
 619                 s->out_pos_cur = s->out_pos_lo;
 620                 prefix += seplen;
 621                 nslots++;
 622         }
 623         width += (seplen * (nslots - 1));
 624         buf = calloc(1, width + 1);
 625         if (buf == NULL)
 626                 khlib_fatal(
 627                     "[memory] Failed to allocate buffer of %d bytes",
 628                     width
 629                 );
 630         memset(buf, ' ', width);
 631         buf[width] = '\0';
 632         /* 3rd pass to set the separators */
 633         for (s = cfg.slots; s; s = s->next) {
 634                 if (s->out_pos_lo) {  /* Skip the first, left-most */
 635                         /* Copying only seplen ensures we omit the '\0' byte. */
 636                         strncpy(
 637                             buf + (s->out_pos_lo - seplen),
 638                             cfg.separator,
 639                             seplen
 640                         );
 641                 }
 642         }
 643
 644         if (cfg.output_to_x_root_window && !(d = XOpenDisplay(NULL)))
 645                 khlib_fatal("XOpenDisplay failed with: %p\n", d);
 646         /* TODO: Handle signals */
 647         for (;;) {
 648                 clock_gettime(CLOCK_MONOTONIC, &t0); // FIXME: check errors
 649                 slots_read(&cfg, &ti, buf);
 650                 if (cfg.output_to_x_root_window) {
 651                         if (XStoreName(d, DefaultRootWindow(d), buf) < 0)
 652                                 khlib_fatal("XStoreName failed.\n");
 653                         XFlush(d);
 654                 } else {
 655                         puts(buf);
 656                         fflush(stdout);
 657                 }
 658                 clock_gettime(CLOCK_MONOTONIC, &t1); // FIXME: check errors
 659                 timespecsub(&t1, &t0, &td);
 660                 khlib_debug(
 661                     "td {tv_sec = %ld, tv_nsec = %ld}\n",
 662                     td.tv_sec,
 663                     td.tv_nsec
 664                 );
 665                 if (timespeccmp(&td, &ti, <)) {
 666                         /*
 667                          * Pushback on data producers by refusing to read the
 668                          * pipe more frequently than the interval.
 669                          */
 670                         timespecsub(&ti, &td, &tc);
 671                         khlib_sleep(&tc);
 672                 }
 673         }
 674         return EXIT_SUCCESS;
 675 }