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