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