src/udev/collect/collect.c

   1 /*
   2  * Collect variables across events.
   3  *
   4  * usage: collect [--add|--remove] <checkpoint> <id> <idlist>
   5  *
   6  * Adds ID <id> to the list governed by <checkpoint>.
   7  * <id> must be part of the ID list <idlist>.
   8  * If all IDs given by <idlist> are listed (ie collect has been
   9  * invoked for each ID in <idlist>) collect returns 0, the
  10  * number of missing IDs otherwise.
  11  * A negative number is returned on error.
  12  *
  13  * Copyright(C) 2007, Hannes Reinecke <hare@suse.de>
  14  *
  15  * This program is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation, either version 2 of the License, or
  18  * (at your option) any later version.
  19  *
  20  */
  21
  22 #include <errno.h>
  23 #include <getopt.h>
  24 #include <stddef.h>
  25 #include <stdio.h>
  26
  27 #include "alloc-util.h"
  28 #include "libudev-private.h"
  29 #include "macro.h"
  30 #include "stdio-util.h"
  31 #include "string-util.h"
  32 #include "udev-util.h"
  33
  34 #define BUFSIZE 16
  35 #define UDEV_ALARM_TIMEOUT 180
  36
  37 enum collect_state {
  38         STATE_NONE,
  39         STATE_OLD,
  40         STATE_CONFIRMED,
  41 };
  42
  43 struct _mate {
  44         struct udev_list_node node;
  45         char *name;
  46         enum collect_state state;
  47 };
  48
  49 static struct udev_list_node bunch;
  50 static int debug;
  51
  52 /* This can increase dynamically */
  53 static size_t bufsize = BUFSIZE;
  54
  55 static inline struct _mate *node_to_mate(struct udev_list_node *node)
  56 {
  57         return container_of(node, struct _mate, node);
  58 }
  59
  60 noreturn static void sig_alrm(int signo)
  61 {
  62         exit(4);
  63 }
  64
  65 static void usage(void)
  66 {
  67         printf("%s [options] <checkpoint> <id> <idlist>\n\n"
  68                "Collect variables across events.\n\n"
  69                "  -h --help        Print this message\n"
  70                "  -a --add         Add ID <id> to the list <idlist>\n"
  71                "  -r --remove      Remove ID <id> from the list <idlist>\n"
  72                "  -d --debug       Debug to stderr\n\n"
  73                "  Adds ID <id> to the list governed by <checkpoint>.\n"
  74                "  <id> must be part of the list <idlist>.\n"
  75                "  If all IDs given by <idlist> are listed (ie collect has been\n"
  76                "  invoked for each ID in <idlist>) collect returns 0, the\n"
  77                "  number of missing IDs otherwise.\n"
  78                "  On error a negative number is returned.\n\n"
  79                , program_invocation_short_name);
  80 }
  81
  82 /*
  83  * prepare
  84  *
  85  * Prepares the database file
  86  */
  87 static int prepare(char *dir, char *filename)
  88 {
  89         char buf[PATH_MAX];
  90         int r, fd;
  91
  92         r = mkdir(dir, 0700);
  93         if (r < 0 && errno != EEXIST)
  94                 return -errno;
  95
  96         snprintf(buf, sizeof buf, "%s/%s", dir, filename);
  97
  98         fd = open(buf, O_RDWR|O_CREAT|O_CLOEXEC, S_IRUSR|S_IWUSR);
  99         if (fd < 0)
 100                 fprintf(stderr, "Cannot open %s: %m\n", buf);
 101
 102         if (lockf(fd,F_TLOCK,0) < 0) {
 103                 if (debug)
 104                         fprintf(stderr, "Lock taken, wait for %d seconds\n", UDEV_ALARM_TIMEOUT);
 105                 if (IN_SET(errno, EAGAIN, EACCES)) {
 106                         alarm(UDEV_ALARM_TIMEOUT);
 107                         lockf(fd, F_LOCK, 0);
 108                         if (debug)
 109                                 fprintf(stderr, "Acquired lock on %s\n", buf);
 110                 } else {
 111                         if (debug)
 112                                 fprintf(stderr, "Could not get lock on %s: %m\n", buf);
 113                 }
 114         }
 115
 116         return fd;
 117 }
 118
 119 /*
 120  * Read checkpoint file
 121  *
 122  * Tricky reading this. We allocate a buffer twice as large
 123  * as we're going to read. Then we read into the upper half
 124  * of that buffer and start parsing.
 125  * Once we do _not_ find end-of-work terminator (whitespace
 126  * character) we move the upper half to the lower half,
 127  * adjust the read pointer and read the next bit.
 128  * Quite clever methinks :-)
 129  * I should become a programmer ...
 130  *
 131  * Yes, one could have used fgets() for this. But then we'd
 132  * have to use freopen etc which I found quite tedious.
 133  */
 134 static int checkout(int fd)
 135 {
 136         int len;
 137         char *buf, *ptr, *word = NULL;
 138         struct _mate *him;
 139
 140  restart:
 141         len = bufsize >> 1;
 142         buf = malloc(bufsize + 1);
 143         if (!buf)
 144                 return log_oom();
 145         memset(buf, ' ', bufsize);
 146         buf[bufsize] = '\0';
 147
 148         ptr = buf + len;
 149         while ((read(fd, buf + len, len)) > 0) {
 150                 while (ptr && *ptr) {
 151                         word = ptr;
 152                         ptr = strpbrk(word," \n\t\r");
 153                         if (!ptr && word < (buf + len)) {
 154                                 bufsize = bufsize << 1;
 155                                 if (debug)
 156                                         fprintf(stderr, "ID overflow, restarting with size %zu\n", bufsize);
 157                                 free(buf);
 158                                 lseek(fd, 0, SEEK_SET);
 159                                 goto restart;
 160                         }
 161                         if (ptr) {
 162                                 *ptr = '\0';
 163                                 ptr++;
 164                                 if (!strlen(word))
 165                                         continue;
 166
 167                                 if (debug)
 168                                         fprintf(stderr, "Found word %s\n", word);
 169                                 him = malloc(sizeof (struct _mate));
 170                                 if (!him) {
 171                                         free(buf);
 172                                         return log_oom();
 173                                 }
 174                                 him->name = strdup(word);
 175                                 if (!him->name) {
 176                                         free(buf);
 177                                         free(him);
 178                                         return log_oom();
 179                                 }
 180                                 him->state = STATE_OLD;
 181                                 udev_list_node_append(&him->node, &bunch);
 182                                 word = NULL;
 183                         }
 184                 }
 185                 memcpy(buf, buf + len, len);
 186                 memset(buf + len, ' ', len);
 187
 188                 if (!ptr)
 189                         ptr = word;
 190                 if (!ptr)
 191                         break;
 192                 ptr -= len;
 193         }
 194
 195         free(buf);
 196         return 0;
 197 }
 198
 199 /*
 200  * invite
 201  *
 202  * Adds a new ID 'us' to the internal list,
 203  * marks it as confirmed.
 204  */
 205 static void invite(char *us)
 206 {
 207         struct udev_list_node *him_node;
 208         struct _mate *who = NULL;
 209
 210         if (debug)
 211                 fprintf(stderr, "Adding ID '%s'\n", us);
 212
 213         udev_list_node_foreach(him_node, &bunch) {
 214                 struct _mate *him = node_to_mate(him_node);
 215
 216                 if (streq(him->name, us)) {
 217                         him->state = STATE_CONFIRMED;
 218                         who = him;
 219                 }
 220         }
 221         if (debug && !who)
 222                 fprintf(stderr, "ID '%s' not in database\n", us);
 223
 224 }
 225
 226 /*
 227  * reject
 228  *
 229  * Marks the ID 'us' as invalid,
 230  * causing it to be removed when the
 231  * list is written out.
 232  */
 233 static void reject(char *us)
 234 {
 235         struct udev_list_node *him_node;
 236         struct _mate *who = NULL;
 237
 238         if (debug)
 239                 fprintf(stderr, "Removing ID '%s'\n", us);
 240
 241         udev_list_node_foreach(him_node, &bunch) {
 242                 struct _mate *him = node_to_mate(him_node);
 243
 244                 if (streq(him->name, us)) {
 245                         him->state = STATE_NONE;
 246                         who = him;
 247                 }
 248         }
 249         if (debug && !who)
 250                 fprintf(stderr, "ID '%s' not in database\n", us);
 251 }
 252
 253 /*
 254  * kickout
 255  *
 256  * Remove all IDs in the internal list which are not part
 257  * of the list passed via the command line.
 258  */
 259 static void kickout(void)
 260 {
 261         struct udev_list_node *him_node;
 262         struct udev_list_node *tmp;
 263
 264         udev_list_node_foreach_safe(him_node, tmp, &bunch) {
 265                 struct _mate *him = node_to_mate(him_node);
 266
 267                 if (him->state == STATE_OLD) {
 268                         udev_list_node_remove(&him->node);
 269                         free(him->name);
 270                         free(him);
 271                 }
 272         }
 273 }
 274
 275 /*
 276  * missing
 277  *
 278  * Counts all missing IDs in the internal list.
 279  */
 280 static int missing(int fd)
 281 {
 282         char *buf;
 283         int ret = 0;
 284         struct udev_list_node *him_node;
 285
 286         buf = malloc(bufsize);
 287         if (!buf)
 288                 return log_oom();
 289
 290         udev_list_node_foreach(him_node, &bunch) {
 291                 struct _mate *him = node_to_mate(him_node);
 292
 293                 if (him->state == STATE_NONE) {
 294                         ret++;
 295                 } else {
 296                         while (strlen(him->name)+1 >= bufsize) {
 297                                 char *tmpbuf;
 298
 299                                 bufsize = bufsize << 1;
 300                                 tmpbuf = realloc(buf, bufsize);
 301                                 if (!tmpbuf) {
 302                                         free(buf);
 303                                         return log_oom();
 304                                 }
 305                                 buf = tmpbuf;
 306                         }
 307                         snprintf(buf, strlen(him->name)+2, "%s ", him->name);
 308                         if (write(fd, buf, strlen(buf)) < 0) {
 309                                 free(buf);
 310                                 return -1;
 311                         }
 312                 }
 313         }
 314
 315         free(buf);
 316         return ret;
 317 }
 318
 319 /*
 320  * everybody
 321  *
 322  * Prints out the status of the internal list.
 323  */
 324 static void everybody(void)
 325 {
 326         struct udev_list_node *him_node;
 327         const char *state = "";
 328
 329         udev_list_node_foreach(him_node, &bunch) {
 330                 struct _mate *him = node_to_mate(him_node);
 331
 332                 switch (him->state) {
 333                 case STATE_NONE:
 334                         state = "none";
 335                         break;
 336                 case STATE_OLD:
 337                         state = "old";
 338                         break;
 339                 case STATE_CONFIRMED:
 340                         state = "confirmed";
 341                         break;
 342                 }
 343                 fprintf(stderr, "ID: %s=%s\n", him->name, state);
 344         }
 345 }
 346
 347 int main(int argc, char **argv) {
 348         static const struct option options[] = {
 349                 { "add", no_argument, NULL, 'a' },
 350                 { "remove", no_argument, NULL, 'r' },
 351                 { "debug", no_argument, NULL, 'd' },
 352                 { "help", no_argument, NULL, 'h' },
 353                 {}
 354         };
 355         int argi;
 356         char *checkpoint, *us;
 357         int fd;
 358         int i;
 359         int ret = EXIT_SUCCESS;
 360         int prune = 0;
 361         char tmpdir[UTIL_PATH_SIZE];
 362
 363         log_set_target(LOG_TARGET_AUTO);
 364         udev_parse_config();
 365         log_parse_environment();
 366         log_open();
 367
 368         for (;;) {
 369                 int option;
 370
 371                 option = getopt_long(argc, argv, "ardh", options, NULL);
 372                 if (option == -1)
 373                         break;
 374
 375                 switch (option) {
 376                 case 'a':
 377                         prune = 0;
 378                         break;
 379                 case 'r':
 380                         prune = 1;
 381                         break;
 382                 case 'd':
 383                         debug = 1;
 384                         break;
 385                 case 'h':
 386                         usage();
 387                         return 0;
 388                 default:
 389                         return 1;
 390                 }
 391         }
 392
 393         argi = optind;
 394         if (argi + 2 > argc) {
 395                 printf("Missing parameter(s)\n");
 396                 return 1;
 397         }
 398         checkpoint = argv[argi++];
 399         us = argv[argi++];
 400
 401         if (signal(SIGALRM, sig_alrm) == SIG_ERR) {
 402                 fprintf(stderr, "Cannot set SIGALRM: %m\n");
 403                 return 2;
 404         }
 405
 406         udev_list_node_init(&bunch);
 407
 408         if (debug)
 409                 fprintf(stderr, "Using checkpoint '%s'\n", checkpoint);
 410
 411         strscpyl(tmpdir, sizeof(tmpdir), "/run/udev/collect", NULL);
 412         fd = prepare(tmpdir, checkpoint);
 413         if (fd < 0) {
 414                 ret = 3;
 415                 goto out;
 416         }
 417
 418         if (checkout(fd) < 0) {
 419                 ret = 2;
 420                 goto out;
 421         }
 422
 423         for (i = argi; i < argc; i++) {
 424                 struct udev_list_node *him_node;
 425                 struct _mate *who;
 426
 427                 who = NULL;
 428                 udev_list_node_foreach(him_node, &bunch) {
 429                         struct _mate *him = node_to_mate(him_node);
 430
 431                         if (streq(him->name, argv[i]))
 432                                 who = him;
 433                 }
 434                 if (!who) {
 435                         struct _mate *him;
 436
 437                         if (debug)
 438                                 fprintf(stderr, "ID %s: not in database\n", argv[i]);
 439                         him = new(struct _mate, 1);
 440                         if (!him) {
 441                                 ret = ENOMEM;
 442                                 goto out;
 443                         }
 444
 445                         him->name = strdup(argv[i]);
 446                         if (!him->name) {
 447                                 free(him);
 448                                 ret = ENOMEM;
 449                                 goto out;
 450                         }
 451
 452                         him->state = STATE_NONE;
 453                         udev_list_node_append(&him->node, &bunch);
 454                 } else {
 455                         if (debug)
 456                                 fprintf(stderr, "ID %s: found in database\n", argv[i]);
 457                         who->state = STATE_CONFIRMED;
 458                 }
 459         }
 460
 461         if (prune)
 462                 reject(us);
 463         else
 464                 invite(us);
 465
 466         if (debug) {
 467                 everybody();
 468                 fprintf(stderr, "Prune lists\n");
 469         }
 470         kickout();
 471
 472         lseek(fd, 0, SEEK_SET);
 473         ftruncate(fd, 0);
 474         ret = missing(fd);
 475
 476         lockf(fd, F_ULOCK, 0);
 477         close(fd);
 478 out:
 479         if (debug)
 480                 everybody();
 481         if (ret >= 0)
 482                 printf("COLLECT_%s=%d\n", checkpoint, ret);
 483         return ret;
 484 }