projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
swconfig: use libnl-tiny instead of libnl
[openwrt.git] / package / hotplug2 / patches / 100-svn_update.patch
1 diff -urN -x .svn hotplug2-0.9/AUTHORS hotplug2/AUTHORS
2 --- hotplug2-0.9/AUTHORS 2006-10-08 18:13:50.000000000 +0200
3 +++ hotplug2/AUTHORS 2007-06-30 12:59:20.459674000 +0200
4 @@ -1,7 +1,11 @@
5 Authors:
6 ----------
7 iSteve <isteve@bofh.cz>
8 -Tomas Janousek <tomi@nomi.cz>
9 +
10 + Contributions:
11 +----------------
12 +nbd (rules override patch, various fixes, suggestions, testing etc.)
13 +Tomas Janousek <tomi@nomi.cz> (Makefiles, SVN hosting)
14
15 Thanks to:
16 ------------
17 @@ -10,5 +14,9 @@
18 Randy Dunlap (help with isapnpmap)
19 Igor2 (provided testing machines)
20 yanek (provided testing machines)
21 +Zdenek Styblik (provided testing OpenWRT device)
22 +OpenWRT team (for trusting this project)
23 +mtu (debugging, testing, ideas)
24 +mnemoc (trivial sanity changes on makefiles, linux24 compat patches)
25
26 -...anyone taking more than a short peek at the software.
27 \ No newline at end of file
28 +...anyone taking more than a short peek at the software.
29 diff -urN -x .svn hotplug2-0.9/Changelog hotplug2/Changelog
30 --- hotplug2-0.9/Changelog 2006-10-08 15:32:31.000000000 +0200
31 +++ hotplug2/Changelog 2007-07-09 01:17:14.865503750 +0200
32 @@ -1,3 +1,13 @@
33 +0.9 - 1.0:
34 +* Add --set-rules-file.
35 +* Allow any ACTION.
36 +* Add 'printdebug' rule.
37 +* Fix chmod, chown, chgrp.
38 +* Use octal for chmod and makedev.
39 +* Add 'nothrottle' flag, allowing overriding max-children from a rule
40 +* Various bugfixes
41 +* Code comments
42 +
43 0.8 - 0.9:
44 * Use signals to handle children.
45 * Separate info and debugging output.
46 @@ -44,4 +54,4 @@
47 * Add more actions.
48 * Significant cleanup of rules handling.
49 * Better error reporting.
50 -
51 \ No newline at end of file
52 +
53 diff -urN -x .svn hotplug2-0.9/common.mak hotplug2/common.mak
54 --- hotplug2-0.9/common.mak 2006-09-26 01:03:08.000000000 +0200
55 +++ hotplug2/common.mak 2007-07-09 01:17:14.869504000 +0200
56 @@ -1,6 +1,6 @@
57 # vim:set sw=8 nosta:
58
59 -CFLAGS=-Os -DHAVE_RULES -Wall -g
60 +CFLAGS=-Os -DHAVE_RULES -Wall -g -Wextra
61 LDFLAGS=-g
62
63 INSTALL=install -c -m 644
64 @@ -10,7 +10,7 @@
65 .PHONY: all clean dep install install-recursive clean-recursive \
66 dep-recursive all-recursive
67
68 -MAKEDEP=-gcc $(CFLAGS) -MM $(wildcard *.c *.cc) > .depend
69 +MAKEDEP=-$(CC) $(CFLAGS) -MM $(wildcard *.c *.cc) > .depend
70 dep: dep-recursive
71 $(MAKEDEP)
72 .depend:
73 diff -urN -x .svn hotplug2-0.9/docs/hotplug2.8 hotplug2/docs/hotplug2.8
74 --- hotplug2-0.9/docs/hotplug2.8 2006-09-26 09:23:36.000000000 +0200
75 +++ hotplug2/docs/hotplug2.8 2007-06-28 14:50:59.874955160 +0200
76 @@ -22,6 +22,8 @@
77 .TP
78 \fB\-\-dumb\fR, \fB\-\-no\-dumb\fR
79 Run or do not run hotplug2 in dumb mode. Dumb mode means that rules are being ignored, the only action taken is mload modules to all devices whose uevent exports MODALIAS. Only available if compiled with HAVE_RULES.
80 +\fB\-\-override\fR, \fB\-\-no\-override\fR
81 +Allows hotplug2 behavior overriding for different rules, using various flags. See hotplug2 rules documentation for details. The default is not to allow overriding, the flags are therefore ignored.
82 .TP
83 \fB\-\-max\-children <value>\fR
84 Set the value of maximum children hotplug2 may have running simultaneously. Default is 20.
85 @@ -31,6 +33,8 @@
86 .TP
87 \fB\-\-set\-modprobe\-cmd <cmd>\fR
88 Sets the application used to perform modprobe. It only gets used in dumb mode. Default is to autodetect: if '/bin/modprobe' is from module\-init\-tools, use '/sbin/modprobe', otherwise use '/sbin/hotplug2\-modwrap'.
89 +\fB\-\-set\-rules\-file <file>\fR
90 +Sets the path to the file containing hotplug2 rules.
91 .SH "SIGNALS"
92 .TP
93 \fBSIGUSR1\fR
94 diff -urN -x .svn hotplug2-0.9/docs/hotplug2.rules.doc hotplug2/docs/hotplug2.rules.doc
95 --- hotplug2-0.9/docs/hotplug2.rules.doc 2006-09-26 10:19:46.000000000 +0200
96 +++ hotplug2/docs/hotplug2.rules.doc 2007-06-28 14:50:59.872955464 +0200
97 @@ -11,12 +11,12 @@
98 [... [...]]
99 }
100
101 -Comments are allowed, they are prefixed with '#', treating the whole rest of the
102 -line as comment. Please note that comments in place of action parameters are not
103 -supported.
104 +Comments are allowed, they are prefixed with '#', treating the whole rest of
105 +the line as comment. Please note that comments in place of action parameters
106 +are not supported.
107
108 -The <key> is one of the environmental variables that have been obtained by the
109 -uevent netlink.
110 +The <key> is one of the environmental variables that have been obtained by
111 +the uevent netlink.
112
113 COMMON KEYS
114 -----------
115 @@ -66,9 +66,9 @@
116 -------
117
118 * run <...>
119 - Execute an application using system();, takes one parameter. Note that
120 - the application has set all environmental variables read by uevent
121 - netlink.
122 + Execute an application using system();, takes one parameter. Note
123 + that the application has set all environmental variables read by
124 + uevent netlink.
125
126 * break
127 Break the processing of the current block of actions.
128 @@ -86,23 +86,22 @@
129
130 * exec <application [parameter [parameter [...]]]> ;
131 Execute an application. Takes variable number of parameters, but the
132 - last parameter must be terminated with semicolon. Again, all variables
133 - are set as environmental.
134 + last parameter must be terminated with semicolon. Again, all
135 + variables are set as environmental.
136
137 - If you need to escape the ';', use '\\;'. Only applies for actions with
138 - variable number of parameters.
139 + If you need to escape the ';', use '\\;'. Only applies for actions
140 + with variable number of parameters.
141
142 * makedev <path> <mode>
143 - Create a device with given mode. The mode is not in octal unless it
144 - starts with '0', eg. "0644" != "644".
145 + Create a device with given mode. Mode is interpreted as octal.
146
147 Major, minor and devpath must be set for makedev to be able to work.
148 Tests for these variables are also performed internally in makedev
149 function.
150
151 * symlink <target> <linkname>
152 - Create a symbolic link (symlink, also known as soft link) pointing at
153 - target with name linkname.
154 + Create a symbolic link (symlink, also known as soft link) pointing
155 + at target with name linkname.
156
157 * chown <path> <owner name>
158 Change owner of path to owner name.
159 @@ -111,12 +110,32 @@
160 Change group of path to group name.
161
162 * chmod <path> <mode>
163 - Change mode of path to given mode. Like with makedev, heading '0' is
164 - necessary for the mode to be interpreted as octal.
165 + Change mode of path to given mode. Mode is interpreted as octal.
166
167 * setenv <key> <value>
168 Sets environmental variable key to the given value. If an env var
169 of the given name already exists, it gets overwritten.
170 +
171 + * printdebug
172 + Prints all variables read from kernel.
173 +
174 + FLAGS
175 + -----
176 +
177 +Flags are, syntactically, just like actions; their semantical value is different however.
178 +Instead of doing something, they instead change the general behavior of the processing
179 +of the given rule.
180 +
181 +Note that for flags to work, you also have to invoke it with --override.
182 +
183 +Currently, only one flag is implemented:
184 +
185 + * nothrottle
186 + Forcibly overrides hotplug2 throttling mechanism. If _all_ rules that match
187 + the given kernel event have 'nothrottle' set, hotplug2 will not wait for
188 + children count to get under max-children limit. That allows to throttle
189 + eg. helper application execution or modprobes, but yet keep node devices
190 + fast.
191
192 ESCAPING
193 --------
194 @@ -136,8 +155,9 @@
195 SAMPLE CONFIG
196 -------------
197
198 -Below is a sample hotplug2.rules file. It loads modules to all available devices
199 -quietly and creates device nodes for block devices.
200 +Below is a sample hotplug2.rules file. It loads modules to all available
201 +devices quietly and creates device nodes for block devices. Note that this
202 +sample is not very viable for real life usage.
203 ---------------------------------------------------------------------------------
204 MODALIAS is set {
205 exec modprobe -q %MODALIAS% ;
206 @@ -146,3 +166,33 @@
207 SUBSYSTEM == block, DEVPATH is set, MAJOR is set, MINOR is set {
208 makedev /dev/%DEVICENAME% 0644
209 }
210 +
211 +
212 +Please find also the more complex set of rules, dedicated to handling most
213 +common needs.
214 +---------------------------------------------------------------------------------
215 +#For debugging
216 +#ACTION is set {
217 +# printdebug
218 +#}
219 +
220 +# Load modules (what old hotplug did)
221 +MODALIAS is set {
222 + exec modprobe -q %MODALIAS% ;
223 +}
224 +
225 +# Create device nodes
226 +DEVPATH is set, MAJOR is set, MINOR is set {
227 + makedev /dev/%DEVICENAME% 0644
228 +}
229 +
230 +# Mount a USB flashdisk
231 +ACTION == add, PHYSDEVPATH ~~ "/usb[0-9]*/", DEVICENAME ~~ "^sd[a-z][0-9]+$", DEVPATH is set, MAJOR is set, MINOR is set {
232 + makedev /dev/%DEVICENAME% 0644
233 + exec mount /dev/%DEVICENAME% /mnt/%DEVICENAME%
234 +}
235 +
236 +# Unmount a USB flashdisk
237 +ACTION == remove, PHYSDEVPATH ~~ "/usb[0-9]*/", DEVICENAME ~~ "^sd[a-z][0-9]+$", MAJOR is set, MINOR is set {
238 + exec umount /mnt/%DEVICENAME%
239 +}
240 diff -urN -x .svn hotplug2-0.9/docs/Makefile hotplug2/docs/Makefile
241 --- hotplug2-0.9/docs/Makefile 2006-09-26 00:27:02.000000000 +0200
242 +++ hotplug2/docs/Makefile 2007-06-28 14:50:59.875955008 +0200
243 @@ -2,12 +2,13 @@
244
245 BINS=
246 SUBDIRS=
247 -
248 +DESTDIR=
249 +MANDIR=/usr/share/man
250
251 all:
252
253 install:
254 - $(INSTALL) $(wildcard *.8) /usr/share/man/man8/
255 + $(INSTALL) $(wildcard *.8) $(DESTDIR)$(MANDIR)/man8/
256
257
258 include ../common.mak
259 diff -urN -x .svn hotplug2-0.9/examples/Makefile hotplug2/examples/Makefile
260 --- hotplug2-0.9/examples/Makefile 2006-09-26 01:03:08.000000000 +0200
261 +++ hotplug2/examples/Makefile 2007-06-28 14:50:59.991937376 +0200
262 @@ -2,19 +2,23 @@
263
264 BINS=
265 SUBDIRS=
266 +DESTDIR=
267 +KERNELVER=`uname -r`
268
269
270 all:
271
272 install:
273 - case "`uname -r`" in \
274 - 2.6.*) \
275 - $(INSTALL) hotplug2.rules-2.6kernel /etc/hotplug2.rules \
276 - ;; \
277 - *) \
278 - $(INSTALL) hotplug2.rules-2.4kernel /etc/hotplug2.rules \
279 - ;; \
280 - esac
281 + if ! [ -e "/etc/hotplug2.rules" ]; then \
282 + case "$(KERNELVER)" in \
283 + 2.6.*) \
284 + $(INSTALL) hotplug2.rules-2.6kernel $(DESTDIR)/etc/hotplug2.rules \
285 + ;; \
286 + *) \
287 + $(INSTALL) hotplug2.rules-2.4kernel $(DESTDIR)/etc/hotplug2.rules \
288 + ;; \
289 + esac; \
290 + fi;
291
292
293 include ../common.mak
294 diff -urN -x .svn hotplug2-0.9/filemap_utils.c hotplug2/filemap_utils.c
295 --- hotplug2-0.9/filemap_utils.c 2006-09-25 12:14:12.000000000 +0200
296 +++ hotplug2/filemap_utils.c 2007-07-09 02:01:10.966249750 +0200
297 @@ -16,7 +16,15 @@
298
299 #include "filemap_utils.h"
300
301 -int map_file(char *filename, struct filemap_t *filemap) {
302 +/**
303 + * Basic open/mmap wrapper to make things simpler.
304 + *
305 + * @1 Filename of the mmaped file
306 + * @2 Pointer to filemap structure
307 + *
308 + * Returns: 0 if success, 1 otherwise
309 + */
310 +int map_file(const char *filename, struct filemap_t *filemap) {
311 struct stat statbuf;
312
313 filemap->fd = open(filename, O_RDONLY);
314 @@ -40,9 +48,16 @@
315 return 0;
316 }
317
318 +/**
319 + * Basic close/munmap wrapper.
320 + *
321 + * @1 Pointer to filemap structure
322 + *
323 + * Returns: always 0
324 + */
325 int unmap_file(struct filemap_t *filemap) {
326 - close(filemap->fd);
327 munmap(filemap->map, filemap->size);
328 + close(filemap->fd);
329
330 return 0;
331 }
332 diff -urN -x .svn hotplug2-0.9/filemap_utils.h hotplug2/filemap_utils.h
333 --- hotplug2-0.9/filemap_utils.h 2006-09-25 22:24:36.000000000 +0200
334 +++ hotplug2/filemap_utils.h 2007-07-09 02:01:10.962249500 +0200
335 @@ -14,6 +14,6 @@
336 void *map;
337 };
338
339 -int map_file(char *, struct filemap_t *);
340 +int map_file(const char *, struct filemap_t *);
341 int unmap_file(struct filemap_t *);
342 #endif
343 diff -urN -x .svn hotplug2-0.9/hotplug2.c hotplug2/hotplug2.c
344 --- hotplug2-0.9/hotplug2.c 2006-10-08 15:18:23.000000000 +0200
345 +++ hotplug2/hotplug2.c 2007-07-09 02:01:10.962249500 +0200
346 @@ -23,7 +23,9 @@
347 #include <linux/netlink.h>
348
349 #include "mem_utils.h"
350 +#include "filemap_utils.h"
351 #include "hotplug2.h"
352 +#include "hotplug2_utils.h"
353 #include "rules.h"
354 #include "childlist.h"
355
356 @@ -32,10 +34,16 @@
357 child == NULL && \
358 highest_seqnum == get_kernel_seqnum())
359
360 +/*
361 + * These variables are accessed from throughout the code.
362 + *
363 + * TODO: Move this into a hotplug2_t-like variable.
364 + */
365 event_seqnum_t highest_seqnum = 0;
366 pid_t coldplug_p;
367 int coldplug = 1;
368 int persistent = 0;
369 +int override = 0;
370 int max_child_c = 20;
371 int dumb = 0;
372 int terminate = 0;
373 @@ -45,6 +53,14 @@
374
375 char *modprobe_command = NULL;
376
377 +/**
378 + * Release all memory associated with an uevent read from kernel. The given
379 + * pointer is no longer valid, as it gets freed as well.
380 + *
381 + * @1 The event that is to be freed.
382 + *
383 + * Returns: void
384 + */
385 inline void free_hotplug2_event(struct hotplug2_event_t *event) {
386 int i;
387
388 @@ -57,6 +73,13 @@
389 free(event);
390 }
391
392 +/**
393 + * A trivial function determining the action that the uevent.
394 + *
395 + * @1 String containing the action name (null-terminated).
396 + *
397 + * Returns: Macro of the given action
398 + */
399 inline int get_hotplug2_event_action(char *action) {
400 if (!strcmp(action, "add"))
401 return ACTION_ADD;
402 @@ -67,6 +90,14 @@
403 return ACTION_UNKNOWN;
404 }
405
406 +/**
407 + * Looks up a value according to the given key.
408 + *
409 + * @1 A hotplug event structure
410 + * @2 Key for lookup
411 + *
412 + * Returns: The value of the key or NULL if no such key found
413 + */
414 char *get_hotplug2_value_by_key(struct hotplug2_event_t *event, char *key) {
415 int i;
416
417 @@ -78,7 +109,16 @@
418 return NULL;
419 }
420
421 -inline int add_hotplug2_event_env(struct hotplug2_event_t *event, char *item) {
422 +/**
423 + * Appends a key-value pair described by the second argument to the
424 + * hotplug event.
425 + *
426 + * @1 A hotplug event structure
427 + * @1 An item in format "key=value" to be appended
428 + *
429 + * Returns: 0 if success, -1 if the string is malformed
430 + */
431 +int add_hotplug2_event_env(struct hotplug2_event_t *event, char *item) {
432 char *ptr, *tmp;
433
434 ptr = strchr(item, '=');
435 @@ -94,6 +134,8 @@
436
437 /*
438 * Variables not generated by kernel but demanded nonetheless...
439 + *
440 + * TODO: Split this to a different function
441 */
442 if (!strcmp(item, "DEVPATH")) {
443 event->env_vars_c++;
444 @@ -109,6 +151,15 @@
445 return 0;
446 }
447
448 +/**
449 + * Duplicates all allocated memory of a source hotplug event
450 + * and returns a new hotplug event, an identical copy of the
451 + * source event.
452 + *
453 + * @1 Source hotplug event structure
454 + *
455 + * Returns: A copy of the source event structure
456 + */
457 inline struct hotplug2_event_t *dup_hotplug2_event(struct hotplug2_event_t *src) {
458 struct hotplug2_event_t *dest;
459 int i;
460 @@ -129,6 +180,14 @@
461 return dest;
462 }
463
464 +/**
465 + * Parses a string into a hotplug event structurs.
466 + *
467 + * @1 The event string (not null terminated)
468 + * @2 The size of the event string
469 + *
470 + * Returns: A new event structure
471 + */
472 inline struct hotplug2_event_t *get_hotplug2_event(char *event_str, int size) {
473 char *ptr;
474 struct hotplug2_event_t *event;
475 @@ -161,59 +220,15 @@
476 return event;
477 }
478
479 -inline event_seqnum_t get_kernel_seqnum() {
480 - FILE *fp;
481 -
482 - char filename[64];
483 - char seqnum[64];
484 -
485 - strcpy(filename, sysfs_seqnum_path);
486 -
487 - fp = fopen(filename, "r");
488 - if (fp == NULL)
489 - return 0;
490 -
491 - fread(seqnum, 1, 64, fp);
492 - fclose(fp);
493 -
494 - return strtoull(seqnum, NULL, 0);
495 -}
496 -
497 -inline int init_netlink_socket() {
498 - int netlink_socket;
499 - struct sockaddr_nl snl;
500 - int buffersize = 16 * 1024 * 1024;
501 -
502 - memset(&snl, 0x00, sizeof(struct sockaddr_nl));
503 - snl.nl_family = AF_NETLINK;
504 - snl.nl_pid = getpid();
505 - snl.nl_groups = 1;
506 - netlink_socket = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
507 - if (netlink_socket == -1) {
508 - ERROR("opening netlink","Failed socket: %s.", strerror(errno));
509 - return -1;
510 - }
511 -
512 - if (setsockopt(netlink_socket, SOL_SOCKET, SO_RCVBUFFORCE, &buffersize, sizeof(buffersize))) {
513 - ERROR("opening netlink","Failed setsockopt: %s. (non-critical)", strerror(errno));
514 -
515 - /* Somewhat safe default. */
516 - buffersize = 106496;
517 -
518 - if (setsockopt(netlink_socket, SOL_SOCKET, SO_RCVBUF, &buffersize, sizeof(buffersize))) {
519 - ERROR("opening netlink","Failed setsockopt: %s. (critical)", strerror(errno));
520 - }
521 - }
522 -
523 - if (bind(netlink_socket, (struct sockaddr *) &snl, sizeof(struct sockaddr_nl))) {
524 - ERROR("opening netlink","Failed bind: %s.", strerror(errno));
525 - close(netlink_socket);
526 - return -1;
527 - }
528 -
529 - return netlink_socket;
530 -}
531 -
532 +/**
533 + * Evaluates an argument into a true/false value.
534 + *
535 + * @1 argument
536 + * @2 argument flag
537 + * @3 pointer to output value
538 + *
539 + * Returns: 0 if success, -1 otherwise
540 + */
541 int get_bool_opt(char *argv, char *name, int *value) {
542 int rv = -1;
543
544 @@ -238,7 +253,13 @@
545 }
546 }
547
548 -void cleanup(void) {
549 +/**
550 + * Performs a cleanup; closes uevent socket, resets signal
551 + * handlers, waits for all the children.
552 + *
553 + * Returns: void
554 + */
555 +void cleanup() {
556 pid_t p;
557
558 close(netlink_socket);
559 @@ -254,6 +275,13 @@
560 INFO("cleanup", "All children terminated.");
561 }
562
563 +/**
564 + * Handles all signals.
565 + *
566 + * @1 Signal identifier
567 + *
568 + * Returns: void
569 + */
570 void sighandler(int sig) {
571 pid_t p;
572
573 @@ -313,6 +341,14 @@
574 }
575
576 #ifdef HAVE_RULES
577 +/**
578 + * Execute all rules for this particular event.
579 + *
580 + * @1 Hotplug event structure
581 + * @2 Rules structure, containing array of rules
582 + *
583 + * Returns: void
584 + */
585 void perform_action(struct hotplug2_event_t *event, struct rules_t *rules) {
586 int i, rv;
587
588 @@ -324,13 +360,72 @@
589
590 free_hotplug2_event(event);
591 }
592 +
593 +/**
594 + * Iterates through all rules, and performs an AND between all flags that
595 + * would apply during execution (ie. all rules that have conditions matching
596 + * the hotplug event).
597 + *
598 + * @1 Hotplug event structure
599 + * @2 Rules structure, containing array of rules
600 + *
601 + * Returns: Flags that apply to all matching rules
602 + */
603 +int flags_eval(struct hotplug2_event_t *event, struct rules_t *rules) {
604 + int flags = FLAG_ALL;
605 + int match = 0;
606 + int i, j;
607 +
608 + for (i = 0; i < rules->rules_c; i++) {
609 + match = 1;
610 +
611 + for (j = 0; j < rules->rules[i].conditions_c; j++) {
612 + if (rule_condition_eval(event, &rules->rules[i].conditions[j]) != EVAL_MATCH) {
613 + match = 0;
614 + break;
615 + }
616 + }
617 +
618 + /*
619 + * Logical AND between flags we've got already and
620 + * those we're adding.
621 + */
622 + if (match) {
623 + rule_flags(&rules->rules[i]);
624 + flags &= rules->rules[i].flags;
625 + }
626 + }
627 +
628 + /*
629 + * A little trick; if no rule matched, we return FLAG_ALL
630 + * and have it skipped completely.
631 + */
632 +
633 + return flags;
634 +}
635 +#else
636 +#define perform_action(event, rules)
637 #endif
638
639 +/**
640 + * Blindly modprobe the modalias, nothing more.
641 + *
642 + * @1 Hotplug event structure
643 + * @2 Modalias to be loaded
644 + *
645 + * Returns: void
646 + */
647 void perform_dumb_action(struct hotplug2_event_t *event, char *modalias) {
648 free_hotplug2_event(event);
649 execl(modprobe_command, modprobe_command, "-q", modalias, NULL);
650 }
651
652 +/**
653 + * Attempt to figure out whether our modprobe command can handle modalias.
654 + * If not, use our own wrapper.
655 + *
656 + * Returns: 0 if success, -1 otherwise
657 + */
658 int get_modprobe_command() {
659 pid_t p;
660 int fds[2];
661 @@ -381,6 +476,9 @@
662 }
663
664 int main(int argc, char *argv[]) {
665 + /*
666 + * TODO, cleanup
667 + */
668 static char buffer[UEVENT_BUFFER_SIZE+512];
669 struct hotplug2_event_t *tmpevent;
670 char *modalias, *seqnum;
671 @@ -390,28 +488,39 @@
672 int size;
673 int rv = 0;
674 int i;
675 + unsigned int flags;
676 char *coldplug_command = NULL;
677 + char *rules_file = HOTPLUG2_RULE_PATH;
678 sigset_t block_mask;
679
680 struct rules_t *rules = NULL;
681 - struct stat statbuf;
682 - void *filemap;
683 - int rule_fd;
684 + struct filemap_t filemap;
685
686 struct options_t bool_options[] = {
687 {"persistent", &persistent},
688 {"coldplug", &coldplug},
689 {"udevtrigger", &coldplug}, /* compatibility */
690 + {"override", &override},
691 #ifdef HAVE_RULES
692 {"dumb", &dumb},
693 #endif
694 {NULL, NULL}
695 };
696
697 + /*
698 + * We parse all the options...
699 + */
700 for (argc--; argc > 0; argc--) {
701 argv++;
702 + /*
703 + * TODO, cleanup
704 + */
705 for (i = 0; bool_options[i].name != NULL; i++) {
706 if (!get_bool_opt(*argv, bool_options[i].name, bool_options[i].value)) {
707 + /*
708 + * Bool options are --option or --no-options. If we handled
709 + * it, quit iterating.
710 + */
711 break;
712 } else {
713 if (!strcmp(*argv, "--max-children")) {
714 @@ -435,52 +544,52 @@
715 break;
716
717 modprobe_command = *argv;
718 + } else if (!strcmp(*argv, "--set-rules-file")) {
719 + argv++;
720 + argc--;
721 + if (argc <= 0)
722 + break;
723 +
724 + rules_file = *argv;
725 }
726 }
727 }
728 }
729
730 -#ifdef HAVE_RULES
731 +#ifndef HAVE_RULES
732 + /*
733 + * We don't use rules, so we use dumb mode only.
734 + */
735 + dumb = 1;
736 +#else
737 + /*
738 + * We're not in dumb mode, parse the rules. If we fail,
739 + * faillback to dumb mode.
740 + */
741 if (!dumb) {
742 - filemap = MAP_FAILED;
743 - rule_fd = open(HOTPLUG2_RULE_PATH, O_RDONLY | O_NOATIME);
744 - if (rule_fd == -1) {
745 - dumb = 1;
746 - ERROR("rules parse","Unable to open rules file: %s.", strerror(errno));
747 - goto end_rules;
748 - }
749 -
750 - if (fstat(rule_fd, &statbuf)) {
751 - dumb = 1;
752 - ERROR("rules parse","Unable to stat rules file: %s.", strerror(errno));
753 - goto end_rules;
754 - }
755 -
756 - filemap = mmap(0, statbuf.st_size, PROT_READ, MAP_SHARED, rule_fd, 0);
757 - if (filemap == MAP_FAILED) {
758 + if (map_file(rules_file, &filemap)) {
759 + ERROR("rules parse","Unable to open/mmap rules file.");
760 dumb = 1;
761 - ERROR("rules parse","Unable to mmap rules file: %s.", strerror(errno));
762 goto end_rules;
763 }
764
765 - rules = rules_from_config((char*)filemap);
766 + rules = rules_from_config((char*)(filemap.map), NULL);
767 if (rules == NULL) {
768 ERROR("rules parse","Unable to parse rules file.");
769 dumb = 1;
770 }
771 +
772 + unmap_file(&filemap);
773
774 end_rules:
775 - if (filemap != MAP_FAILED)
776 - munmap(filemap, statbuf.st_size);
777 - if (rule_fd != -1)
778 - close(rule_fd);
779 -
780 if (dumb == 1)
781 ERROR("rules parse","Parsing rules failed, switching to dumb mode.");
782 - } else if (!modprobe_command)
783 -#else
784 - if (dumb && !modprobe_command)
785 + } else
786 #endif
787 + /*
788 + * No modprobe command specified, let's autodetect it.
789 + */
790 + if (!modprobe_command)
791 {
792 if (get_modprobe_command()) {
793 ERROR("modprobe_command","Unable to autodetect modprobe command.");
794 @@ -489,7 +598,10 @@
795 DBG("modprobe_command", "Using modprobe: `%s'.", modprobe_command);
796 }
797
798 - netlink_socket = init_netlink_socket();
799 + /*
800 + * Open netlink socket to read the uevents
801 + */
802 + netlink_socket = init_netlink_socket(NETLINK_BIND);
803
804 if (netlink_socket == -1) {
805 ERROR("netlink init","Unable to open netlink socket.");
806 @@ -503,6 +615,9 @@
807 signal(SIGINT, sighandler);
808 signal(SIGCHLD, sighandler);
809
810 + /*
811 + * If we desire coldplugging, we initiate it right now.
812 + */
813 if (coldplug) {
814 if (coldplug_command == NULL)
815 coldplug_command = UDEVTRIGGER_COMMAND;
816 @@ -523,10 +638,19 @@
817 coldplug_p = FORK_FINISHED;
818 }
819
820 + /*
821 + * Main loop reading uevents
822 + */
823 while (!terminate) {
824 + /*
825 + * Read the uevent packet
826 + */
827 size = recv(netlink_socket, &buffer, sizeof(buffer), 0);
828 recv_errno = errno;
829
830 + /*
831 + * Parse the event into an event structure
832 + */
833 tmpevent = get_hotplug2_event(buffer, size);
834
835 if (tmpevent == NULL) {
836 @@ -534,26 +658,61 @@
837 continue;
838 }
839
840 + /*
841 + * Look up two important items of the event
842 + */
843 modalias = get_hotplug2_value_by_key(tmpevent, "MODALIAS");
844 seqnum = get_hotplug2_value_by_key(tmpevent, "SEQNUM");
845 -
846 +
847 + /*
848 + * Seqnum is necessary not to end up in a race with the kernel.
849 + */
850 if (seqnum == NULL) {
851 free_hotplug2_event(tmpevent);
852 ERROR("reading events", "Malformed event read (missing SEQNUM).");
853 continue;
854 }
855
856 + /*
857 + * Maintain seqnum continuity
858 + */
859 cur_seqnum = strtoull(seqnum, NULL, 0);
860 if (cur_seqnum > highest_seqnum)
861 highest_seqnum = cur_seqnum;
862
863 - if (tmpevent->action == ACTION_ADD && (!dumb || modalias != NULL)) {
864 + /*
865 + * If we are in smart mode, we'll always pass. If we're in dumb mode,
866 + * we only pass events that have 'add' action and have modalias set.
867 + */
868 + if ((dumb && tmpevent->action == ACTION_ADD && modalias != NULL) || (!dumb)) {
869 + /*
870 + * Pre-evaluation of the flags
871 + */
872 + if (!dumb && override) {
873 + flags = flags_eval(tmpevent, rules);
874 +
875 + DBG("flags", "flag returned: %8x", flags);
876 +
877 + if (flags == FLAG_ALL)
878 + continue;
879 + } else {
880 + flags = FLAG_UNSET;
881 + }
882 +
883 /*
884 * We have more children than we want. Wait until SIGCHLD handler reduces
885 * their numbers.
886 + *
887 + * Unless, of course, we've specified otherwise and no rules that match
888 + * need throttling.
889 */
890 - while (child_c >= max_child_c) {
891 - usleep(HOTPLUG2_THROTTLE_INTERVAL);
892 + if (!flags & FLAG_NOTHROTTLE) {
893 + /*
894 + * Okay, throttle away!
895 + */
896 + while (child_c >= max_child_c) {
897 + usleep(HOTPLUG2_THROTTLE_INTERVAL);
898 + }
899 }
900
901 sigemptyset(&block_mask);
902 @@ -562,17 +721,18 @@
903 p = fork();
904 switch (p) {
905 case -1:
906 - ERROR("event","fork failed: %s.", strerror(errno));
907 + ERROR("event", "fork failed: %s.", strerror(errno));
908 break;
909 case 0:
910 + /*
911 + * TODO: We do not have to dup here, or do we?
912 + */
913 sigprocmask(SIG_UNBLOCK, &block_mask, 0);
914 signal(SIGCHLD, SIG_DFL);
915 signal(SIGUSR1, SIG_DFL);
916 -#ifdef HAVE_RULES
917 if (!dumb)
918 perform_action(dup_hotplug2_event(tmpevent), rules);
919 else
920 -#endif
921 perform_dumb_action(dup_hotplug2_event(tmpevent), modalias);
922 exit(0);
923 break;
924 @@ -593,12 +753,10 @@
925 signal(SIGINT, SIG_DFL);
926 signal(SIGCHLD, SIG_DFL);
927
928 -#ifdef HAVE_RULES
929 if (!dumb) {
930 rules_free(rules);
931 free(rules);
932 }
933 -#endif
934
935 cleanup();
936
937 diff -urN -x .svn hotplug2-0.9/hotplug2-dnode.c hotplug2/hotplug2-dnode.c
938 --- hotplug2-0.9/hotplug2-dnode.c 2006-09-26 17:35:35.000000000 +0200
939 +++ hotplug2/hotplug2-dnode.c 2007-07-09 01:17:14.869504000 +0200
940 @@ -27,6 +27,7 @@
941
942 #include "mem_utils.h"
943 #include "hotplug2.h"
944 +#include "hotplug2_utils.h"
945 #include "parser_utils.h"
946
947 #define MODALIAS_MAX_LEN 1024
948 @@ -45,59 +46,17 @@
949
950 #define TEST_INPUT_BIT(i,bm) (bm[i / BITS_PER_LONG] & (((unsigned long)1) << (i%BITS_PER_LONG)))
951
952 -int init_netlink_socket() {
953 - int netlink_socket;
954 - struct sockaddr_nl snl;
955 - int buffersize = 16 * 1024 * 1024;
956 -
957 - memset(&snl, 0x00, sizeof(struct sockaddr_nl));
958 - snl.nl_family = AF_NETLINK;
959 - snl.nl_pid = getpid();
960 - snl.nl_groups = 1;
961 - netlink_socket = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
962 - if (netlink_socket == -1) {
963 - ERROR("opening netlink","Failed socket: %s.", strerror(errno));
964 - return -1;
965 - }
966 -
967 - if (setsockopt(netlink_socket, SOL_SOCKET, SO_SNDBUFFORCE, &buffersize, sizeof(buffersize))) {
968 - ERROR("opening netlink","Failed setsockopt: %s. (non-critical)", strerror(errno));
969 -
970 - /* Somewhat safe default. */
971 - buffersize = 106496;
972 -
973 - if (setsockopt(netlink_socket, SOL_SOCKET, SO_SNDBUF, &buffersize, sizeof(buffersize))) {
974 - ERROR("opening netlink","Failed setsockopt: %s. (critical)", strerror(errno));
975 - }
976 - }
977 -
978 - if (connect(netlink_socket, (struct sockaddr *) &snl, sizeof(struct sockaddr_nl))) {
979 - ERROR("opening netlink","Failed bind: %s.", strerror(errno));
980 - close(netlink_socket);
981 - return -1;
982 - }
983 -
984 - return netlink_socket;
985 -}
986 -
987 -inline event_seqnum_t get_kernel_seqnum() {
988 - FILE *fp;
989 -
990 - char filename[64];
991 - char seqnum[64];
992 -
993 - strcpy(filename, sysfs_seqnum_path);
994 -
995 - fp = fopen(filename, "r");
996 - if (fp == NULL)
997 - return 0;
998 -
999 - fread(seqnum, 1, 64, fp);
1000 - fclose(fp);
1001 -
1002 - return strtoull(seqnum, NULL, 0);
1003 -}
1004 -
1005 +/**
1006 + * Parses a bitmap; output is a list of offsets of bits of a bitmap
1007 + * of arbitrary size that are set to 1.
1008 + *
1009 + * @1 Name of the bitmap parsed
1010 + * @2 The actual bitmap pointer
1011 + * @3 Lower boundary of the bitmap
1012 + * @4 Upper boundary of the bitmap
1013 + *
1014 + * Returns: Newly allocated string containing the offsets
1015 + */
1016 char *bitmap_to_bitstring(char name, unsigned long *bm, unsigned int min_bit, unsigned int max_bit)
1017 {
1018 char *rv;
1019 @@ -120,6 +79,15 @@
1020 return rv;
1021 }
1022
1023 +/**
1024 + * Reverses the bitmap_to_bitstring function.
1025 + *
1026 + * @1 Bitstring to be converted
1027 + * @2 Output bitmap
1028 + * @3 Size of the whole bitmap
1029 + *
1030 + * Returns: void
1031 + */
1032 void string_to_bitmap(char *input, unsigned long *bitmap, int bm_len) {
1033 char *token, *ptr;
1034 int i = 0;
1035 @@ -146,6 +114,14 @@
1036 } \
1037 bitmap = bitmap_to_bitstring(name, bitmap ## _bits, min, mapkey ## _MAX);
1038
1039 +/**
1040 + * Creates an input modalias out of preset environmental variables.
1041 + *
1042 + * @1 Pointer to where modalias will be created
1043 + * @2 Maximum size of the modalias
1044 + *
1045 + * Returns: 0 if success, -1 otherwise
1046 + */
1047 int get_input_modalias(char *modalias, int modalias_len) {
1048 char *product_env;
1049 char *ptr;
1050 @@ -245,6 +221,14 @@
1051 #undef NBITS
1052 #undef TEST_INPUT_BIT
1053
1054 +/**
1055 + * Creates a PCI modalias out of preset environmental variables.
1056 + *
1057 + * @1 Pointer to where modalias will be created
1058 + * @2 Maximum size of the modalias
1059 + *
1060 + * Returns: 0 if success, -1 otherwise
1061 + */
1062 int get_pci_modalias(char *modalias, int modalias_len) {
1063 char *class_env, *id_env, *subsys_env;
1064 char *ptr;
1065 @@ -290,6 +274,15 @@
1066 return 0;
1067 }
1068
1069 +/**
1070 + * Creates an IEEE1394 (FireWire) modalias out of preset environmental
1071 + * variables.
1072 + *
1073 + * @1 Pointer to where modalias will be created
1074 + * @2 Maximum size of the modalias
1075 + *
1076 + * Returns: 0 if success, -1 otherwise
1077 + */
1078 int get_ieee1394_modalias(char *modalias, int modalias_len) {
1079 char *vendor_env, *model_env;
1080 char *specifier_env, *version_env;
1081 @@ -317,6 +310,14 @@
1082 return 0;
1083 }
1084
1085 +/**
1086 + * Creates a serio modalias out of preset environmental variables.
1087 + *
1088 + * @1 Pointer to where modalias will be created
1089 + * @2 Maximum size of the modalias
1090 + *
1091 + * Returns: 0 if success, -1 otherwise
1092 + */
1093 int get_serio_modalias(char *modalias, int modalias_len) {
1094 char *serio_type_env, *serio_proto_env;
1095 char *serio_id_env, *serio_extra_env;
1096 @@ -344,6 +345,14 @@
1097 return 0;
1098 }
1099
1100 +/**
1101 + * Creates an USB modalias out of preset environmental variables.
1102 + *
1103 + * @1 Pointer to where modalias will be created
1104 + * @2 Maximum size of the modalias
1105 + *
1106 + * Returns: 0 if success, -1 otherwise
1107 + */
1108 int get_usb_modalias(char *modalias, int modalias_len) {
1109 char *product_env, *type_env, *interface_env;
1110 char *ptr;
1111 @@ -409,6 +418,16 @@
1112 return 0;
1113 }
1114
1115 +/**
1116 + * Distributes modalias generating according to the bus name.
1117 + *
1118 + * @1 Bus name
1119 + * @2 Pointer to where modalias will be created
1120 + * @3 Maximum size of the modalias
1121 + *
1122 + * Returns: The return value of the subsystem modalias function, or -1 if
1123 + * no match.
1124 + */
1125 int get_modalias(char *bus, char *modalias, int modalias_len) {
1126 memset(modalias, 0, modalias_len);
1127
1128 @@ -435,6 +454,16 @@
1129 return -1;
1130 }
1131
1132 +/**
1133 + * Turns all environmental variables as set when invoked by /proc/sys/hotplug
1134 + * into an uevent formatted (thus not null-terminated) string.
1135 + *
1136 + * @1 All environmental variables
1137 + * @2 Bus of the event (as read from argv)
1138 + * @3 Pointer to size of the returned uevent string
1139 + *
1140 + * Returns: Not null terminated uevent string.
1141 + */
1142 inline char *get_uevent_string(char **environ, char *bus, unsigned long *uevent_string_len) {
1143 char *uevent_string;
1144 char *tmp;
1145 @@ -516,7 +545,7 @@
1146 return 1;
1147 }
1148
1149 - netlink_socket = init_netlink_socket();
1150 + netlink_socket = init_netlink_socket(NETLINK_CONNECT);
1151 if (netlink_socket == -1) {
1152 ERROR("netlink init","Unable to open netlink socket.");
1153 goto exit;
1154 diff -urN -x .svn hotplug2-0.9/hotplug2.h hotplug2/hotplug2.h
1155 --- hotplug2-0.9/hotplug2.h 2006-10-08 12:21:56.000000000 +0200
1156 +++ hotplug2/hotplug2.h 2007-07-09 01:17:14.865503750 +0200
1157 @@ -34,7 +34,7 @@
1158 #endif
1159
1160 #ifndef O_NOATIME
1161 -#define O_NOATIME 01000000
1162 +#define O_NOATIME 01000000
1163 #endif
1164
1165 #define ERROR(action, fmt, arg...) fprintf(stderr, "[%s]: " fmt"\n", action, ##arg);
1166 @@ -47,7 +47,7 @@
1167
1168 #define UEVENT_BUFFER_SIZE 2048
1169 #define HOTPLUG2_POLL_INTERVAL 20000
1170 -#define HOTPLUG2_THROTTLE_INTERVAL 10000
1171 +#define HOTPLUG2_THROTTLE_INTERVAL 10000
1172 #define HOTPLUG2_RULE_PATH "/etc/hotplug2.rules"
1173
1174 #define ACTION_ADD 0
1175 diff -urN -x .svn hotplug2-0.9/hotplug2_utils.c hotplug2/hotplug2_utils.c
1176 --- hotplug2-0.9/hotplug2_utils.c 1970-01-01 01:00:00.000000000 +0100
1177 +++ hotplug2/hotplug2_utils.c 2007-07-09 01:17:14.869504000 +0200
1178 @@ -0,0 +1,96 @@
1179 +#include <stdio.h>
1180 +#include <string.h>
1181 +#include <stdlib.h>
1182 +#include <fcntl.h>
1183 +#include <stdio.h>
1184 +#include <unistd.h>
1185 +#include <errno.h>
1186 +#include <sys/socket.h>
1187 +#include <sys/types.h>
1188 +#include <sys/un.h>
1189 +#include <sys/wait.h>
1190 +#include <linux/types.h>
1191 +#include <linux/netlink.h>
1192 +
1193 +#include "hotplug2_utils.h"
1194 +
1195 +/**
1196 + * A trivial function that reads kernel seqnum from sysfs.
1197 + *
1198 + * Returns: Seqnum as read from sysfs
1199 + */
1200 +inline event_seqnum_t get_kernel_seqnum() {
1201 + FILE *fp;
1202 +
1203 + char filename[64];
1204 + char seqnum[64];
1205 +
1206 + strcpy(filename, sysfs_seqnum_path);
1207 +
1208 + fp = fopen(filename, "r");
1209 + if (fp == NULL)
1210 + return 0;
1211 +
1212 + fread(seqnum, 1, 64, fp);
1213 + fclose(fp);
1214 +
1215 + return strtoull(seqnum, NULL, 0);
1216 +}
1217 +
1218 +/**
1219 + * Opens a PF_NETLINK socket into the kernel, to read uevents.
1220 + *
1221 + * @1 Specifies type of socket (whether we bind or whether we connect)
1222 + *
1223 + * Returns: Socket fd if succesful, -1 otherwise.
1224 + */
1225 +inline int init_netlink_socket(int type) {
1226 + int netlink_socket;
1227 + struct sockaddr_nl snl;
1228 + int buffersize = 16 * 1024 * 1024;
1229 +
1230 + memset(&snl, 0x00, sizeof(struct sockaddr_nl));
1231 + snl.nl_family = AF_NETLINK;
1232 + snl.nl_pid = getpid();
1233 + snl.nl_groups = 1;
1234 + netlink_socket = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
1235 + if (netlink_socket == -1) {
1236 + ERROR("opening netlink","Failed socket: %s.", strerror(errno));
1237 + return -1;
1238 + }
1239 +
1240 + /*
1241 + * We're trying to override buffer size. If we fail, we attempt to set a big buffer and pray.
1242 + */
1243 + if (setsockopt(netlink_socket, SOL_SOCKET, SO_RCVBUFFORCE, &buffersize, sizeof(buffersize))) {
1244 + ERROR("opening netlink","Failed setsockopt: %s. (non-critical)", strerror(errno));
1245 +
1246 + /* Somewhat safe default. */
1247 + buffersize = 106496;
1248 +
1249 + if (setsockopt(netlink_socket, SOL_SOCKET, SO_RCVBUF, &buffersize, sizeof(buffersize))) {
1250 + ERROR("opening netlink","Failed setsockopt: %s. (critical)", strerror(errno));
1251 + }
1252 + }
1253 +
1254 + /*
1255 + * hotplug2-dnode performs connect, while hotplug2 daemon binds
1256 + */
1257 + switch (type) {
1258 + case NETLINK_CONNECT:
1259 + if (connect(netlink_socket, (struct sockaddr *) &snl, sizeof(struct sockaddr_nl))) {
1260 + ERROR("opening netlink","Failed connect: %s.", strerror(errno));
1261 + close(netlink_socket);
1262 + return -1;
1263 + }
1264 +
1265 + default:
1266 + if (bind(netlink_socket, (struct sockaddr *) &snl, sizeof(struct sockaddr_nl))) {
1267 + ERROR("opening netlink","Failed bind: %s.", strerror(errno));
1268 + close(netlink_socket);
1269 + return -1;
1270 + }
1271 + }
1272 +
1273 + return netlink_socket;
1274 +}
1275 diff -urN -x .svn hotplug2-0.9/hotplug2_utils.h hotplug2/hotplug2_utils.h
1276 --- hotplug2-0.9/hotplug2_utils.h 1970-01-01 01:00:00.000000000 +0100
1277 +++ hotplug2/hotplug2_utils.h 2007-07-09 01:17:14.869504000 +0200
1278 @@ -0,0 +1,21 @@
1279 +/*****************************************************************************\
1280 +* _ _ _ _ ___ *
1281 +* | || | ___ | |_ _ __ | | _ _ __ _ |_ ) *
1282 +* | __ |/ _ \| _|| '_ \| || || |/ _` | / / *
1283 +* |_||_|\___/ \__|| .__/|_| \_,_|\__, |/___| *
1284 +* |_| |___/ *
1285 +\*****************************************************************************/
1286 +
1287 +#ifndef HOTPLUG2_UTILS_H
1288 +#define HOTPLUG2_UTILS_H 1
1289 +
1290 +#include "hotplug2.h"
1291 +
1292 +#define NETLINK_UNDEFINED 0
1293 +#define NETLINK_CONNECT 1
1294 +#define NETLINK_BIND 2
1295 +
1296 +inline event_seqnum_t get_kernel_seqnum();
1297 +inline int init_netlink_socket(int);
1298 +
1299 +#endif
1300 diff -urN -x .svn hotplug2-0.9/linux24_compat/hotplug2-coldplug-2.4.c hotplug2/linux24_compat/hotplug2-coldplug-2.4.c
1301 --- hotplug2-0.9/linux24_compat/hotplug2-coldplug-2.4.c 2006-09-25 22:22:47.000000000 +0200
1302 +++ hotplug2/linux24_compat/hotplug2-coldplug-2.4.c 2007-07-09 01:17:14.793499250 +0200
1303 @@ -28,59 +28,7 @@
1304 #include "../mem_utils.h"
1305 #include "../parser_utils.h"
1306 #include "../filemap_utils.h"
1307 -
1308 -inline int init_netlink_socket() {
1309 - int netlink_socket;
1310 - struct sockaddr_nl snl;
1311 - int buffersize = 16 * 1024 * 1024;
1312 -
1313 - memset(&snl, 0x00, sizeof(struct sockaddr_nl));
1314 - snl.nl_family = AF_NETLINK;
1315 - snl.nl_pid = getpid();
1316 - snl.nl_groups = 1;
1317 - netlink_socket = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
1318 - if (netlink_socket == -1) {
1319 - ERROR("opening netlink","Failed socket: %s.", strerror(errno));
1320 - return -1;
1321 - }
1322 -
1323 - if (setsockopt(netlink_socket, SOL_SOCKET, SO_SNDBUFFORCE, &buffersize, sizeof(buffersize))) {
1324 - ERROR("opening netlink","Failed setsockopt: %s. (non-critical)", strerror(errno));
1325 -
1326 - /* Somewhat safe default. */
1327 - buffersize = 106496;
1328 -
1329 - if (setsockopt(netlink_socket, SOL_SOCKET, SO_SNDBUF, &buffersize, sizeof(buffersize))) {
1330 - ERROR("opening netlink","Failed setsockopt: %s. (critical)", strerror(errno));
1331 - }
1332 - }
1333 -
1334 - if (connect(netlink_socket, (struct sockaddr *) &snl, sizeof(struct sockaddr_nl))) {
1335 - ERROR("opening netlink","Failed bind: %s.", strerror(errno));
1336 - close(netlink_socket);
1337 - return -1;
1338 - }
1339 -
1340 - return netlink_socket;
1341 -}
1342 -
1343 -inline event_seqnum_t get_kernel_seqnum() {
1344 - FILE *fp;
1345 -
1346 - char filename[64];
1347 - char seqnum[64];
1348 -
1349 - strcpy(filename, sysfs_seqnum_path);
1350 -
1351 - fp = fopen(filename, "r");
1352 - if (fp == NULL)
1353 - return 0;
1354 -
1355 - fread(seqnum, 1, 64, fp);
1356 - fclose(fp);
1357 -
1358 - return strtoull(seqnum, NULL, 0);
1359 -}
1360 +#include "../hotplug2_utils.h"
1361
1362 inline char *get_uevent_string(char **environ, unsigned long *uevent_string_len) {
1363 char *uevent_string;
1364 @@ -413,7 +361,7 @@
1365 int main(int argc, char *argv[], char **environ) {
1366 int netlink_socket;
1367
1368 - netlink_socket = init_netlink_socket();
1369 + netlink_socket = init_netlink_socket(NETLINK_CONNECT);
1370 if (netlink_socket == -1) {
1371 ERROR("netlink init","Unable to open netlink socket.");
1372 return 1;
1373 diff -urN -x .svn hotplug2-0.9/linux24_compat/hotplug2-modwrap.c hotplug2/linux24_compat/hotplug2-modwrap.c
1374 --- hotplug2-0.9/linux24_compat/hotplug2-modwrap.c 2006-09-25 22:23:07.000000000 +0200
1375 +++ hotplug2/linux24_compat/hotplug2-modwrap.c 2007-07-09 01:17:14.789499000 +0200
1376 @@ -30,8 +30,19 @@
1377 #include "../parser_utils.h"
1378 #include "../filemap_utils.h"
1379
1380 +#define MODULES_PATH "/lib/modules/"
1381 +#define MODULES_ALIAS "modules.alias"
1382 +
1383 +/**
1384 + * A simple fork/exec wrapper
1385 + *
1386 + * @1 Complete argv, including app path
1387 + *
1388 + * Returns: -1 if error, children return value otherwise
1389 + */
1390 int execute(char **argv) {
1391 pid_t p;
1392 + int status;
1393
1394 p = fork();
1395 switch (p) {
1396 @@ -42,10 +53,11 @@
1397 exit(1);
1398 break;
1399 default:
1400 - waitpid(p, NULL, 0);
1401 + waitpid(p, &status, 0);
1402 break;
1403 }
1404 - return 0;
1405 +
1406 + return WEXITSTATUS(status);
1407 }
1408
1409 int main(int argc, char *argv[]) {
1410 @@ -63,21 +75,36 @@
1411
1412 match_alias = strdup(argv[argc - 1]);
1413
1414 + /*
1415 + * If we can't do uname, we're absolutely screwed and there's no
1416 + * sense thinking twice about anything.
1417 + */
1418 if (uname(&unamebuf)) {
1419 ERROR("uname", "Unable to perform uname: %s.", strerror(errno));
1420 return 1;
1421 }
1422
1423 - /* We use this one */
1424 + /*
1425 + * We allow setting the modprobe command to an arbitrary value.
1426 + *
1427 + * The whole trick lies in executing modprobe with exactly the
1428 + * same argv as this app was executed, except we use a different
1429 + * argv[0] (application path) and argv[argc-1] (we substitute
1430 + * the given modalias by the matching module name)
1431 + */
1432 argv[0] = getenv("MODPROBE_COMMAND");
1433 if (argv[0] == NULL)
1434 argv[0] = "/sbin/modprobe";
1435 -
1436 - /* "/lib/modules/" + "/" + "\0" */
1437 - filename = xmalloc(15 + strlen(unamebuf.release) + strlen("modules.alias"));
1438 - strcpy(filename, "/lib/modules/");
1439 +
1440 + /*
1441 + * Compose a path, /lib/modules/`uname -r`/modules.alias
1442 + *
1443 + * "/lib/modules/" + "/" + "\0"
1444 + */
1445 + filename = xmalloc(strlen(MODULES_PATH) + strlen(unamebuf.release) + strlen(MODULES_ALIAS));
1446 + strcpy(filename, MODULES_PATH);
1447 strcat(filename, unamebuf.release);
1448 - strcat(filename, "/modules.alias");
1449 + strcat(filename, MODULES_ALIAS);
1450
1451 if (map_file(filename, &aliasmap)) {
1452 ERROR("map_file", "Unable to map file: `%s'.", filename);
1453 @@ -86,10 +113,16 @@
1454 return 1;
1455 }
1456
1457 + /*
1458 + * Read all the aliases, match them against given parameter.
1459 + */
1460 nptr = aliasmap.map;
1461 while ((line = dup_line(nptr, &nptr)) != NULL) {
1462 nline = line;
1463
1464 + /*
1465 + * We want aliases only
1466 + */
1467 token = dup_token(nline, &nline, isspace);
1468 if (!token || strcmp(token, "alias")) {
1469 free(token);
1470 @@ -98,12 +131,18 @@
1471 }
1472 free(token);
1473
1474 + /*
1475 + * It's an alias, so fetch it
1476 + */
1477 cur_alias = dup_token(nline, &nline, isspace);
1478 if (!cur_alias) {
1479 free(line);
1480 continue;
1481 }
1482
1483 + /*
1484 + * And now we get the module name
1485 + */
1486 module = dup_token(nline, &nline, isspace);
1487 if (!module) {
1488 free(line);
1489 @@ -111,10 +150,14 @@
1490 continue;
1491 }
1492
1493 + /*
1494 + * If we match, we do the modalias->module name
1495 + * substitution as described above and execute.
1496 + */
1497 if (!fnmatch(cur_alias, match_alias, 0)) {
1498 argv[argc - 1] = module;
1499 if (execute(argv)) {
1500 - ERROR("execute", "Unable to execute: `%s'.", argv[0]);
1501 + ERROR("execute", "Error during exection of: `%s'.", argv[0]);
1502 }
1503 }
1504
1505 @@ -122,6 +165,17 @@
1506 free(module);
1507 free(line);
1508 }
1509 +
1510 + /*
1511 + * Perhaps we didn't match anything, so we might've been given
1512 + * a module name instead of a modalias. Try to modprobe it
1513 + * right away.
1514 + */
1515 + if (strcmp(argv[argc - 1], match_alias) == 0) {
1516 + if (execute(argv)) {
1517 + ERROR("execute", "Error during exection of: `%s'.", argv[0]);
1518 + }
1519 + }
1520
1521 free(filename);
1522 free(match_alias);
1523 diff -urN -x .svn hotplug2-0.9/linux24_compat/Makefile hotplug2/linux24_compat/Makefile
1524 --- hotplug2-0.9/linux24_compat/Makefile 2006-09-26 00:26:46.000000000 +0200
1525 +++ hotplug2/linux24_compat/Makefile 2007-07-09 01:17:14.793499250 +0200
1526 @@ -2,16 +2,17 @@
1527
1528 BINS=generate_alias hotplug2-coldplug-2.4 hotplug2-modwrap
1529 SUBDIRS=
1530 +DESTDIR=
1531
1532
1533 all: $(BINS)
1534
1535 install:
1536 - $(INSTALL_BIN) hotplug2-coldplug-2.4 hotplug2-modwrap /sbin/
1537 - $(INSTALL_BIN) generate_alias /usr/sbin/
1538 + $(INSTALL_BIN) hotplug2-coldplug-2.4 hotplug2-modwrap $(DESTDIR)/sbin/
1539 + $(INSTALL_BIN) generate_alias $(DESTDIR)/usr/sbin/
1540
1541
1542 -hotplug2-coldplug-2.4: hotplug2-coldplug-2.4.o ../parser_utils.o ../filemap_utils.o ../mem_utils.o
1543 +hotplug2-coldplug-2.4: hotplug2-coldplug-2.4.o ../parser_utils.o ../filemap_utils.o ../mem_utils.o ../hotplug2_utils.o
1544 hotplug2-modwrap: hotplug2-modwrap.o ../parser_utils.o ../filemap_utils.o ../mem_utils.o
1545 generate_alias: generate_alias.o ../parser_utils.o ../filemap_utils.o ../mem_utils.o
1546
1547 diff -urN -x .svn hotplug2-0.9/Makefile hotplug2/Makefile
1548 --- hotplug2-0.9/Makefile 2006-09-26 01:03:08.000000000 +0200
1549 +++ hotplug2/Makefile 2007-07-09 01:17:14.869504000 +0200
1550 @@ -2,16 +2,17 @@
1551
1552 BINS=hotplug2 hotplug2-dnode
1553 SUBDIRS=linux24_compat docs examples
1554 +DESTDIR=
1555
1556
1557 all: $(BINS)
1558
1559 install:
1560 - $(INSTALL_BIN) $(BINS) /sbin/
1561 + $(INSTALL_BIN) $(BINS) $(DESTDIR)/sbin/
1562
1563
1564 -hotplug2: hotplug2.o childlist.o mem_utils.o rules.o
1565 -hotplug2-dnode: hotplug2-dnode.o mem_utils.o parser_utils.o
1566 +hotplug2: hotplug2.o hotplug2_utils.o childlist.o mem_utils.o rules.o filemap_utils.o
1567 +hotplug2-dnode: hotplug2-dnode.o hotplug2_utils.o mem_utils.o parser_utils.o
1568
1569
1570 include common.mak
1571 diff -urN -x .svn hotplug2-0.9/mem_utils.c hotplug2/mem_utils.c
1572 --- hotplug2-0.9/mem_utils.c 2006-09-25 22:21:45.000000000 +0200
1573 +++ hotplug2/mem_utils.c 2007-07-09 01:17:14.865503750 +0200
1574 @@ -9,6 +9,13 @@
1575 #include <stdlib.h>
1576 #include <stdio.h>
1577
1578 +/**
1579 + * A malloc wrapper. Exits if no memory.
1580 + *
1581 + * @1 Ammount of memory to allocate
1582 + *
1583 + * Returns: Pointer to freshly allocated memory
1584 + */
1585 inline void *xmalloc(size_t size) {
1586 void *ptr;
1587 ptr = malloc(size);
1588 @@ -19,6 +26,14 @@
1589 return ptr;
1590 }
1591
1592 +/**
1593 + * A realloc wrapper. Exits if no memory.
1594 + *
1595 + * @1 Old pointer
1596 + * @2 Ammount of memory to allocate
1597 + *
1598 + * Returns: Pointer to reallocated memory
1599 + */
1600 inline void *xrealloc(void *inptr, size_t size) {
1601 void *ptr;
1602 ptr = realloc(inptr, size);
1603 diff -urN -x .svn hotplug2-0.9/parser_utils.c hotplug2/parser_utils.c
1604 --- hotplug2-0.9/parser_utils.c 2006-09-25 22:21:13.000000000 +0200
1605 +++ hotplug2/parser_utils.c 2007-07-09 01:17:14.865503750 +0200
1606 @@ -12,6 +12,16 @@
1607 #include "mem_utils.h"
1608 #include "parser_utils.h"
1609
1610 +/**
1611 + * Creates a newly allocated null-terminated string representing line
1612 + * starting at a given pointer and ending at the closest newline. If
1613 + * no newline present, returns NULL. TODO, use dup_token
1614 + *
1615 + * @1 Starting pointer
1616 + * @2 Pointer where the end position is returned
1617 + *
1618 + * Returns: Newly allocated string containing the line or NULL
1619 + */
1620 char *dup_line(char *start, char **nptr) {
1621 char *ptr, *rv;
1622
1623 @@ -29,6 +39,15 @@
1624 return rv;
1625 }
1626
1627 +/**
1628 + * Returns a token delimited by the given function.
1629 + *
1630 + * @1 Starting pointer
1631 + * @2 Pointer where the end position is returned
1632 + * @3 Function that identifies the delimiter characters
1633 + *
1634 + * Returns: Newly allocated string containing the token or NULL
1635 + */
1636 char *dup_token(char *start, char **nptr, int (*isdelimiter)(int)) {
1637 char *ptr, *rv;
1638
1639 @@ -56,6 +75,16 @@
1640 return rv;
1641 }
1642
1643 +/**
1644 + * Returns the last token delimited by the given function.
1645 + *
1646 + * @1 Starting pointer of the whole string
1647 + * @2 Starting position
1648 + * @3 Pointer where the end position is returned
1649 + * @4 Function that identifies the delimiter characters
1650 + *
1651 + * Returns: Newly allocated string containing the token or NULL
1652 + */
1653 char *dup_token_r(char *start, char *start_string, char **nptr, int (*isdelimiter)(int)) {
1654 char *ptr, *rv;
1655
1656 diff -urN -x .svn hotplug2-0.9/rules.c hotplug2/rules.c
1657 --- hotplug2-0.9/rules.c 2006-09-29 22:19:31.000000000 +0200
1658 +++ hotplug2/rules.c 2007-07-09 02:01:10.962249500 +0200
1659 @@ -22,11 +22,18 @@
1660 #include <sys/stat.h>
1661
1662 #include "mem_utils.h"
1663 +#include "filemap_utils.h"
1664 #include "hotplug2.h"
1665 #include "rules.h"
1666
1667 -#define last_rule return_rules->rules[return_rules->rules_c - 1]
1668
1669 +/**
1670 + * Function supplementing 'mkdir -p'.
1671 + *
1672 + * @1 Path to be mkdir'd
1673 + *
1674 + * Returns: void
1675 + */
1676 static void mkdir_p(char *path) {
1677 char *ptr;
1678 struct stat statbuf;
1679 @@ -59,6 +66,40 @@
1680 free(path);
1681 }
1682
1683 +/**
1684 + * Function supplementing 'rmdir -p'.
1685 + *
1686 + * @1 Path to be rmdir'd
1687 + *
1688 + * Returns: void
1689 + */
1690 +static void rmdir_p(char *path) {
1691 + char *ptr;
1692 +
1693 + path = strdup(path);
1694 + ptr = path;
1695 + while (ptr != NULL) {
1696 + ptr = strrchr(path, '/');
1697 + if (ptr == NULL)
1698 + break;
1699 +
1700 + *ptr = '\0';
1701 +
1702 + if (rmdir(path))
1703 + break;
1704 + }
1705 + free(path);
1706 +}
1707 +
1708 +/**
1709 + * Replaces all needles by a given value.
1710 + *
1711 + * @1 Haystack (which gets free'd in the function)
1712 + * @2 Needle
1713 + * @3 Needle replacement
1714 + *
1715 + * Returns: Newly allocated haysteck after replacement.
1716 + */
1717 static char *replace_str(char *hay, char *needle, char *replacement) {
1718 char *ptr, *start, *bptr, *buf;
1719 int occurences, j;
1720 @@ -128,7 +169,15 @@
1721 return buf;
1722 }
1723
1724 -inline int isescaped(char *hay, char *ptr) {
1725 +/**
1726 + * Trivial utility, figuring out whether a character is escaped or not.
1727 + *
1728 + * @1 Haystack
1729 + * @2 Pointer to the character in question
1730 + *
1731 + * Returns: 1 if escaped, 0 otherwise
1732 + */
1733 +static inline int isescaped(char *hay, char *ptr) {
1734 if (ptr <= hay)
1735 return 0;
1736
1737 @@ -138,6 +187,15 @@
1738 return 1;
1739 }
1740
1741 +/**
1742 + * Performs replacement of all keys by their value based on the hotplug
1743 + * event structure. Keys are identified as strings %KEY%.
1744 + *
1745 + * @1 Haystack
1746 + * @2 Hotplug event structure
1747 + *
1748 + * Returns: Newly allocated haystack (old is freed)
1749 + */
1750 static char *replace_key_by_value(char *hay, struct hotplug2_event_t *event) {
1751 char *sptr = hay, *ptr = hay;
1752 char *buf, *replacement;
1753 @@ -171,6 +229,17 @@
1754 return hay;
1755 }
1756
1757 +/**
1758 + * Obtains all information from hotplug event structure about a device node.
1759 + * Creates the device node at a given path (expandable by keys) and with
1760 + * given mode.
1761 + *
1762 + * @1 Hotplug event structure
1763 + * @2 Path (may contain keys)
1764 + * @3 Mode of the file
1765 + *
1766 + * Returns: 0 if success, non-zero otherwise
1767 + */
1768 static int make_dev_from_event(struct hotplug2_event_t *event, char *path, mode_t devmode) {
1769 char *subsystem, *major, *minor, *devpath;
1770 int rv = 1;
1771 @@ -196,12 +265,27 @@
1772 path = replace_key_by_value(path, event);
1773 mkdir_p(path);
1774 rv = mknod(path, devmode, makedev(atoi(major), atoi(minor)));
1775 +
1776 + /*
1777 + * Fixes an issue caused by devmode being modified by umask.
1778 + */
1779 + chmod(path, devmode);
1780 +
1781 free(path);
1782
1783 return_value:
1784 return rv;
1785 }
1786
1787 +/**
1788 + * Execute an application without invoking a shell.
1789 + *
1790 + * @1 Hotplug event structure
1791 + * @2 Path to the application, with expandable keys
1792 + * @3 Argv for the application, with expandable keys
1793 + *
1794 + * Returns: Exit status of the application.
1795 + */
1796 static int exec_noshell(struct hotplug2_event_t *event, char *application, char **argv) {
1797 pid_t p;
1798 int i, status;
1799 @@ -211,11 +295,12 @@
1800 case -1:
1801 return -1;
1802 case 0:
1803 + application = replace_key_by_value(strdup(application), event);
1804 for (i = 0; argv[i] != NULL; i++) {
1805 argv[i] = replace_key_by_value(argv[i], event);
1806 }
1807 execvp(application, argv);
1808 - exit(0);
1809 + exit(127);
1810 break;
1811 default:
1812 if (waitpid(p, &status, 0) == -1)
1813 @@ -226,6 +311,14 @@
1814 }
1815 }
1816
1817 +/**
1818 + * Execute an application while invoking a shell.
1819 + *
1820 + * @1 Hotplug event structure
1821 + * @2 The application and all its arguments, with expandable keys
1822 + *
1823 + * Returns: Exit status of the application.
1824 + */
1825 static int exec_shell(struct hotplug2_event_t *event, char *application) {
1826 int rv;
1827
1828 @@ -235,6 +328,15 @@
1829 return rv;
1830 }
1831
1832 +/**
1833 + * Create a symlink, with necessary parent directories.
1834 + *
1835 + * @1 Hotplug event structure
1836 + * @2 Link target, with expandable keys
1837 + * @3 Link name, with expandable keys
1838 + *
1839 + * Returns: return value of symlink()
1840 + */
1841 static int make_symlink(struct hotplug2_event_t *event, char *target, char *linkname) {
1842 int rv;
1843
1844 @@ -250,11 +352,50 @@
1845 return rv;
1846 }
1847
1848 -static int chown_chgrp(int action, char *file, char *param) {
1849 +/**
1850 + * Chmod a given file.
1851 + *
1852 + * @1 Hotplug event structure
1853 + * @2 File name, with expandable keys
1854 + * @3 Chmod value, with expandable keys
1855 + *
1856 + * Returns: return value of chmod()
1857 + */
1858 +static int chmod_file(struct hotplug2_event_t *event, char *file, char *value) {
1859 + int rv;
1860 +
1861 + file = replace_key_by_value(strdup(file), event);
1862 + value = replace_key_by_value(strdup(value), event);
1863 +
1864 + rv = chmod(file, strtoul(value, 0, 8));
1865 +
1866 + free(file);
1867 + free(value);
1868 +
1869 + return rv;
1870 +}
1871 +
1872 +
1873 +/**
1874 + * Change owner or group of a given file.
1875 + *
1876 + * @1 Hotplug event structure
1877 + * @2 Whether we chown or chgrp
1878 + * @3 Filename, with expandable keys
1879 + * @4 Group or user name, with expandable keys
1880 + *
1881 + * Returns: return value of chown()
1882 + */
1883 +static int chown_chgrp(struct hotplug2_event_t *event, int action, char *file, char *param) {
1884 struct group *grp;
1885 struct passwd *pwd;
1886 int rv;
1887 -
1888 +
1889 + file = replace_key_by_value(strdup(file), event);
1890 + param = replace_key_by_value(strdup(param), event);
1891 +
1892 + rv = -1;
1893 +
1894 switch (action) {
1895 case ACT_CHOWN:
1896 pwd = getpwnam(param);
1897 @@ -265,11 +406,37 @@
1898 rv = chown(file, -1, grp->gr_gid);
1899 break;
1900 }
1901 +
1902 + free(file);
1903 + free(param);
1904
1905 - return -1;
1906 + return rv;
1907 +}
1908 +
1909 +/**
1910 + * Prints all uevent keys.
1911 + *
1912 + * @1 Hotplug event structure
1913 + *
1914 + * Returns: void
1915 + */
1916 +static void print_debug(struct hotplug2_event_t *event) {
1917 + int i;
1918 +
1919 + for (i = 0; i < event->env_vars_c; i++)
1920 + printf("%s=%s\n", event->env_vars[i].key, event->env_vars[i].value);
1921 }
1922
1923 -static int rule_condition_eval(struct hotplug2_event_t *event, struct condition_t *condition) {
1924 +/**
1925 + * Evaluates a condition according to a given hotplug event structure.
1926 + *
1927 + * @1 Hotplug event structure
1928 + * @2 Condition to be evaluated
1929 + *
1930 + * Returns: 1 if match, 0 if no match, EVAL_NOT_AVAILABLE if unable to
1931 + * perform evaluation
1932 + */
1933 +int rule_condition_eval(struct hotplug2_event_t *event, struct condition_t *condition) {
1934 int rv;
1935 char *event_value = NULL;
1936 regex_t preg;
1937 @@ -314,6 +481,16 @@
1938 return EVAL_NOT_AVAILABLE;
1939 }
1940
1941 +/**
1942 + * Executes a rule. Contains evaluation of all conditions prior
1943 + * to execution.
1944 + *
1945 + * @1 Hotplug event structure
1946 + * @2 The rule to be executed
1947 + *
1948 + * Returns: 0 if success, -1 if the whole event is to be
1949 + * discared, 1 if bail out of this particular rule was required
1950 + */
1951 int rule_execute(struct hotplug2_event_t *event, struct rule_t *rule) {
1952 int i, last_rv;
1953
1954 @@ -347,11 +524,11 @@
1955 last_rv = make_dev_from_event(event, rule->actions[i].parameter[0], strtoul(rule->actions[i].parameter[1], NULL, 0));
1956 break;
1957 case ACT_CHMOD:
1958 - last_rv = chmod(rule->actions[i].parameter[0], strtoul(rule->actions[i].parameter[1], NULL, 0));
1959 + last_rv = chmod_file(event, rule->actions[i].parameter[0], rule->actions[i].parameter[1]);
1960 break;
1961 case ACT_CHOWN:
1962 case ACT_CHGRP:
1963 - last_rv = chown_chgrp(rule->actions[i].type, rule->actions[i].parameter[0], rule->actions[i].parameter[1]);
1964 + last_rv = chown_chgrp(event, rule->actions[i].type, rule->actions[i].parameter[0], rule->actions[i].parameter[1]);
1965 break;
1966 case ACT_SYMLINK:
1967 last_rv = make_symlink(event, rule->actions[i].parameter[0], rule->actions[i].parameter[1]);
1968 @@ -365,12 +542,49 @@
1969 case ACT_SETENV:
1970 last_rv = setenv(rule->actions[i].parameter[0], rule->actions[i].parameter[1], 1);
1971 break;
1972 + case ACT_REMOVE:
1973 + last_rv = unlink(rule->actions[i].parameter[0]);
1974 + rmdir_p(rule->actions[i].parameter[0]);
1975 + break;
1976 + case ACT_DEBUG:
1977 + print_debug(event);
1978 + last_rv = 0;
1979 + break;
1980 }
1981 }
1982
1983 return 0;
1984 }
1985
1986 +/**
1987 + * Sets the flags of the given rule.
1988 + *
1989 + * @1 Rule structure
1990 + *
1991 + * Returns: void
1992 + */
1993 +void rule_flags(struct rule_t *rule) {
1994 + int i;
1995 +
1996 + for (i = 0; i < rule->actions_c; i++) {
1997 + switch (rule->actions[i].type) {
1998 + case ACT_FLAG_NOTHROTTLE:
1999 + rule->flags |= FLAG_NOTHROTTLE;
2000 + break;
2001 + }
2002 + }
2003 +
2004 + return;
2005 +}
2006 +
2007 +/**
2008 + * Checks whether the given character should initiate
2009 + * further parsing.
2010 + *
2011 + * @1 Character to examine
2012 + *
2013 + * Returns: 1 if it should, 0 otherwise
2014 + */
2015 static inline int isinitiator(int c) {
2016 switch (c) {
2017 case ',':
2018 @@ -383,6 +597,16 @@
2019 return 0;
2020 }
2021
2022 +/**
2023 + * Appends a character to a buffer. Enlarges if necessary.
2024 + *
2025 + * @1 Pointer to the buffer
2026 + * @2 Pointer to buffer size
2027 + * @3 Pointer to last buffer character
2028 + * @4 Appended character
2029 + *
2030 + * Returns: void
2031 + */
2032 static inline void add_buffer(char **buf, int *blen, int *slen, char c) {
2033 if (*slen + 1 >= *blen) {
2034 *blen = *blen + 64;
2035 @@ -394,6 +618,14 @@
2036 *slen += 1;
2037 }
2038
2039 +/**
2040 + * Parses a string into a syntactically acceptable value.
2041 + *
2042 + * @1 Input string
2043 + * @2 Pointer to the new position
2044 + *
2045 + * Returns: Newly allocated string.
2046 + */
2047 static char *rules_get_value(char *input, char **nptr) {
2048 int quotes = QUOTES_NONE;
2049 char *ptr = input;
2050 @@ -471,6 +703,16 @@
2051 return buf;
2052 }
2053
2054 +/**
2055 + * Releases all memory associated with the ruleset. TODO: Make
2056 + * the behavior same for all _free() functions, ie. either
2057 + * release the given pointer itself or keep it, but do it
2058 + * in all functions!
2059 + *
2060 + * @1 The ruleset to be freed
2061 + *
2062 + * Returns: void
2063 + */
2064 void rules_free(struct rules_t *rules) {
2065 int i, j, k;
2066
2067 @@ -492,10 +734,53 @@
2068 free(rules->rules);
2069 }
2070
2071 -struct rules_t *rules_from_config(char *input) {
2072 - int status = STATUS_KEY, terminate;
2073 +/**
2074 + * Includes a rule file.
2075 + *
2076 + * @1 Filename
2077 + * @2 The ruleset structure
2078 + *
2079 + * Returns: 0 if success, -1 otherwise
2080 + */
2081 +int rules_include(const char *filename, struct rules_t **return_rules) {
2082 + struct filemap_t filemap;
2083 + struct rules_t *rules;
2084 +
2085 + if (map_file(filename, &filemap)) {
2086 + ERROR("rules parse","Unable to open/mmap rules file.");
2087 + return -1;
2088 + }
2089 +
2090 + rules = rules_from_config((char*)(filemap.map), *return_rules);
2091 + if (rules == NULL) {
2092 + ERROR("rules parse","Unable to parse rules file.");
2093 + return -1;
2094 + }
2095 +
2096 + unmap_file(&filemap);
2097 +
2098 + return 0;
2099 +}
2100 +
2101 +/**
2102 + * Parses an entire file of rules.
2103 + *
2104 + * @1 The whole file in memory or mmap'd
2105 + *
2106 + * Returns: A newly allocated ruleset.
2107 + */
2108 +struct rules_t *rules_from_config(char *input, struct rules_t *return_rules) {
2109 + #define last_rule return_rules->rules[return_rules->rules_c - 1]
2110 + int nested;
2111 + int status;
2112 + int terminate;
2113 char *buf;
2114 - struct rules_t *return_rules;
2115 +
2116 + /*
2117 + * TODO: cleanup
2118 + *
2119 + * BIIIG cleanup... Use callbacks for actions and for internal actions.
2120 + */
2121
2122 int i, j;
2123 struct key_rec_t conditions[] = { /*NOTE: We never have parameters for conditions. */
2124 @@ -506,6 +791,7 @@
2125 {"!~", 0, COND_NMATCH_RE},
2126 {NULL, 0, -1}
2127 };
2128 +
2129 struct key_rec_t actions[] = {
2130 /*one line / one command*/
2131 {"run", 1, ACT_RUN_SHELL},
2132 @@ -518,6 +804,9 @@
2133 {"chmod", 2, ACT_CHMOD},
2134 {"chgrp", 2, ACT_CHGRP},
2135 {"setenv", 2, ACT_SETENV},
2136 + {"remove", 1, ACT_REMOVE},
2137 + {"nothrottle", 0, ACT_FLAG_NOTHROTTLE},
2138 + {"printdebug", 0, ACT_DEBUG},
2139 /*symlink*/
2140 {"symlink", 2, ACT_SYMLINK},
2141 {"softlink", 2, ACT_SYMLINK},
2142 @@ -527,9 +816,19 @@
2143 {NULL, 0, -1}
2144 };
2145
2146 - return_rules = xmalloc(sizeof(struct rules_t));
2147 - return_rules->rules_c = 1;
2148 - return_rules->rules = xmalloc(sizeof(struct rule_t) * return_rules->rules_c);
2149 + /*
2150 + * A little trick for inclusion.
2151 + */
2152 + if (return_rules == NULL) {
2153 + return_rules = xmalloc(sizeof(struct rules_t));
2154 + return_rules->rules_c = 1;
2155 + return_rules->rules = xmalloc(sizeof(struct rule_t) * return_rules->rules_c);
2156 + nested = 0;
2157 + } else {
2158 + nested = 1;
2159 + }
2160 +
2161 + status = STATUS_KEY;
2162
2163 last_rule.actions = NULL;
2164 last_rule.actions_c = 0;
2165 @@ -549,9 +848,26 @@
2166 /* Skip to next line */
2167 while (*input != '\0' && *input != '\n')
2168 input++;
2169 +
2170 + free(buf);
2171 + continue;
2172 + } else if (buf[0] == '$') {
2173 + buf++;
2174 +
2175 + /*
2176 + * Warning, hack ahead...
2177 + */
2178 + if (!strcmp("include", buf)) {
2179 + buf = rules_get_value(input, &input);
2180 + if (rules_include(buf, &return_rules)) {
2181 + ERROR("rules_include", "Unable to include ruleset '%s'!", buf);
2182 + }
2183 + }
2184 +
2185 + free(buf);
2186 continue;
2187 }
2188 -
2189 +
2190 switch (status) {
2191 case STATUS_KEY:
2192 last_rule.conditions_c++;
2193 @@ -684,8 +1000,14 @@
2194 return_rules->rules_c--;
2195 return return_rules;
2196 } else {
2197 - rules_free(return_rules);
2198 - free(return_rules);
2199 + /*
2200 + * We don't want to cleanup if we're nested.
2201 + */
2202 + if (!nested) {
2203 + rules_free(return_rules);
2204 + free(return_rules);
2205 + }
2206 +
2207 return NULL;
2208 }
2209 }
2210 diff -urN -x .svn hotplug2-0.9/rules.h hotplug2/rules.h
2211 --- hotplug2-0.9/rules.h 2006-09-25 13:42:22.000000000 +0200
2212 +++ hotplug2/rules.h 2007-07-09 02:01:10.962249500 +0200
2213 @@ -24,9 +24,12 @@
2214 #define ACT_CHGRP 6 /* chgrp <...> */
2215 #define ACT_CHOWN 7 /* chown <...> */
2216 #define ACT_SYMLINK 8 /* symlink <...> */
2217 -#define ACT_NEXT_EVENT 9 /* next */
2218 +#define ACT_NEXT_EVENT 9 /* next */
2219 #define ACT_NEXT_IF_FAILED 10 /* next_if_failed */
2220 #define ACT_SETENV 11 /* setenv <...> */
2221 +#define ACT_REMOVE 12 /* remove <...> */
2222 +#define ACT_DEBUG 13 /* debug */
2223 +#define ACT_FLAG_NOTHROTTLE 14 /* sets 'nothrottle' flag */
2224
2225 #define EVAL_MATCH 1
2226 #define EVAL_NOT_MATCH 0
2227 @@ -42,6 +45,10 @@
2228 #define STATUS_INITIATOR 3 /* ',' for next cond, '{' for block*/
2229 #define STATUS_ACTION 4 /* viz ACT_* and '}' for end of block */
2230
2231 +#define FLAG_UNSET 0
2232 +#define FLAG_ALL 0xffffffff
2233 +#define FLAG_NOTHROTTLE 1 /* We want this rule to ignore max_children limit */
2234 +
2235 struct key_rec_t {
2236 char *key;
2237 int param;
2238 @@ -65,6 +72,8 @@
2239
2240 struct action_t *actions;
2241 int actions_c;
2242 +
2243 + unsigned int flags;
2244 };
2245
2246 struct rules_t {
2247 @@ -72,8 +81,10 @@
2248 int rules_c;
2249 };
2250
2251 +int rule_condition_eval(struct hotplug2_event_t *, struct condition_t *);
2252 int rule_execute(struct hotplug2_event_t *, struct rule_t *);
2253 +void rule_flags(struct rule_t *);
2254 void rules_free(struct rules_t *);
2255 -struct rules_t *rules_from_config(char *);
2256 +struct rules_t *rules_from_config(char *, struct rules_t *);
2257
2258 #endif /* ifndef RULES_H*/
2259 Binary files hotplug2-0.9/.swp and hotplug2/.swp differ
2260 diff -urN -x .svn hotplug2-0.9/TODO hotplug2/TODO
2261 --- hotplug2-0.9/TODO 1970-01-01 01:00:00.000000000 +0100
2262 +++ hotplug2/TODO 2007-06-28 14:51:00.012934184 +0200
2263 @@ -0,0 +1 @@
2264 + - live rules update (via inotify)
Personal OpenWRT clone
This page took 0.145047 seconds and 5 git commands to generate.