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