chiark / gitweb /
fix compilation with --enable-debug
[elogind.git] / libudev / libudev-monitor.c
1 /*
2  * libudev - interface to udev device information
3  *
4  * Copyright (C) 2008-2010 Kay Sievers <kay.sievers@vrfy.org>
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  */
11
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <stddef.h>
15 #include <unistd.h>
16 #include <errno.h>
17 #include <string.h>
18 #include <dirent.h>
19 #include <sys/poll.h>
20 #include <sys/stat.h>
21 #include <sys/socket.h>
22 #include <sys/un.h>
23 #include <arpa/inet.h>
24 #include <linux/netlink.h>
25 #include <linux/filter.h>
26
27 #include "libudev.h"
28 #include "libudev-private.h"
29
30 /**
31  * SECTION:libudev-monitor
32  * @short_description: device event source
33  *
34  * Connects to a device event source.
35  */
36
37 /**
38  * udev_monitor:
39  *
40  * Opaque object handling one event source.
41  */
42 struct udev_monitor {
43         struct udev *udev;
44         int refcount;
45         int sock;
46         struct sockaddr_nl snl;
47         struct sockaddr_nl snl_trusted_sender;
48         struct sockaddr_nl snl_destination;
49         struct sockaddr_un sun;
50         socklen_t addrlen;
51         struct udev_list_node filter_subsystem_list;
52         struct udev_list_node filter_tag_list;
53 };
54
55 enum udev_monitor_netlink_group {
56         UDEV_MONITOR_NONE,
57         UDEV_MONITOR_KERNEL,
58         UDEV_MONITOR_UDEV,
59 };
60
61 #define UDEV_MONITOR_MAGIC              0xfeedcafe
62 struct udev_monitor_netlink_header {
63         /* "libudev" prefix to distinguish libudev and kernel messages */
64         char prefix[8];
65         /*
66          * magic to protect against daemon <-> library message format mismatch
67          * used in the kernel from socket filter rules; needs to be stored in network order
68          */
69         unsigned int magic;
70         /* total length of header structure known to the sender */
71         unsigned int header_size;
72         /* properties string buffer */
73         unsigned int properties_off;
74         unsigned int properties_len;
75         /*
76          * hashes of primary device properties strings, to let libudev subscribers
77          * use in-kernel socket filters; values need to be stored in network order
78          */
79         unsigned int filter_subsystem_hash;
80         unsigned int filter_devtype_hash;
81         unsigned int filter_tag_bloom_hi;
82         unsigned int filter_tag_bloom_lo;
83 };
84
85 static struct udev_monitor *udev_monitor_new(struct udev *udev)
86 {
87         struct udev_monitor *udev_monitor;
88
89         udev_monitor = calloc(1, sizeof(struct udev_monitor));
90         if (udev_monitor == NULL)
91                 return NULL;
92         udev_monitor->refcount = 1;
93         udev_monitor->udev = udev;
94         udev_list_init(&udev_monitor->filter_subsystem_list);
95         udev_list_init(&udev_monitor->filter_tag_list);
96         return udev_monitor;
97 }
98
99 /**
100  * udev_monitor_new_from_socket:
101  * @udev: udev library context
102  * @socket_path: unix socket path
103  *
104  * Create new udev monitor and connect to a specified socket. The
105  * path to a socket either points to an existing socket file, or if
106  * the socket path starts with a '@' character, an abstract namespace
107  * socket will be used.
108  *
109  * A socket file will not be created. If it does not already exist,
110  * it will fall-back and connect to an abstract namespace socket with
111  * the given path. The permissions adjustment of a socket file, as
112  * well as the later cleanup, needs to be done by the caller.
113  *
114  * The initial refcount is 1, and needs to be decremented to
115  * release the resources of the udev monitor.
116  *
117  * Returns: a new udev monitor, or #NULL, in case of an error
118  **/
119 struct udev_monitor *udev_monitor_new_from_socket(struct udev *udev, const char *socket_path)
120 {
121         struct udev_monitor *udev_monitor;
122         struct stat statbuf;
123
124         if (udev == NULL)
125                 return NULL;
126         if (socket_path == NULL)
127                 return NULL;
128         udev_monitor = udev_monitor_new(udev);
129         if (udev_monitor == NULL)
130                 return NULL;
131
132         udev_monitor->sun.sun_family = AF_LOCAL;
133         if (socket_path[0] == '@') {
134                 /* translate leading '@' to abstract namespace */
135                 util_strscpy(udev_monitor->sun.sun_path, sizeof(udev_monitor->sun.sun_path), socket_path);
136                 udev_monitor->sun.sun_path[0] = '\0';
137                 udev_monitor->addrlen = offsetof(struct sockaddr_un, sun_path) + strlen(socket_path);
138         } else if (stat(socket_path, &statbuf) == 0 && S_ISSOCK(statbuf.st_mode)) {
139                 /* existing socket file */
140                 util_strscpy(udev_monitor->sun.sun_path, sizeof(udev_monitor->sun.sun_path), socket_path);
141                 udev_monitor->addrlen = offsetof(struct sockaddr_un, sun_path) + strlen(socket_path);
142         } else {
143                 /* no socket file, assume abstract namespace socket */
144                 util_strscpy(&udev_monitor->sun.sun_path[1], sizeof(udev_monitor->sun.sun_path)-1, socket_path);
145                 udev_monitor->addrlen = offsetof(struct sockaddr_un, sun_path) + strlen(socket_path)+1;
146         }
147         udev_monitor->sock = socket(AF_LOCAL, SOCK_DGRAM|SOCK_CLOEXEC, 0);
148         if (udev_monitor->sock == -1) {
149                 err(udev, "error getting socket: %m\n");
150                 free(udev_monitor);
151                 return NULL;
152         }
153
154         dbg(udev, "monitor %p created with '%s'\n", udev_monitor, socket_path);
155         return udev_monitor;
156 }
157
158 /**
159  * udev_monitor_new_from_netlink:
160  * @udev: udev library context
161  * @name: name of event source
162  *
163  * Create new udev monitor and connect to a specified event
164  * source. Valid sources identifiers are "udev" and "kernel".
165  *
166  * Applications should usually not connect directly to the
167  * "kernel" events, because the devices might not be useable
168  * at that time, before udev has configured them, and created
169  * device nodes.
170  *
171  * Accessing devices at the same time as udev, might result
172  * in unpredictable behavior.
173  *
174  * The "udev" events are sent out after udev has finished its
175  * event processing, all rules have been processed, and needed
176  * device nodes are created.
177  *
178  * The initial refcount is 1, and needs to be decremented to
179  * release the resources of the udev monitor.
180  *
181  * Returns: a new udev monitor, or #NULL, in case of an error
182  **/
183 struct udev_monitor *udev_monitor_new_from_netlink(struct udev *udev, const char *name)
184 {
185         struct udev_monitor *udev_monitor;
186         unsigned int group;
187
188         if (udev == NULL)
189                 return NULL;
190
191         if (name == NULL)
192                 group = UDEV_MONITOR_NONE;
193         else if (strcmp(name, "udev") == 0)
194                 group = UDEV_MONITOR_UDEV;
195         else if (strcmp(name, "kernel") == 0)
196                 group = UDEV_MONITOR_KERNEL;
197         else
198                 return NULL;
199
200         udev_monitor = udev_monitor_new(udev);
201         if (udev_monitor == NULL)
202                 return NULL;
203
204         udev_monitor->sock = socket(PF_NETLINK, SOCK_DGRAM|SOCK_CLOEXEC, NETLINK_KOBJECT_UEVENT);
205         if (udev_monitor->sock == -1) {
206                 err(udev, "error getting socket: %m\n");
207                 free(udev_monitor);
208                 return NULL;
209         }
210
211         udev_monitor->snl.nl_family = AF_NETLINK;
212         udev_monitor->snl.nl_groups = group;
213
214         /* default destination for sending */
215         udev_monitor->snl_destination.nl_family = AF_NETLINK;
216         udev_monitor->snl_destination.nl_groups = UDEV_MONITOR_UDEV;
217
218         dbg(udev, "monitor %p created with NETLINK_KOBJECT_UEVENT (%u)\n", udev_monitor, group);
219         return udev_monitor;
220 }
221
222 static inline void bpf_stmt(struct sock_filter *inss, unsigned int *i,
223                             unsigned short code, unsigned int data)
224 {
225         struct sock_filter *ins = &inss[*i];
226
227         ins->code = code;
228         ins->k = data;
229         (*i)++;
230 }
231
232 static inline void bpf_jmp(struct sock_filter *inss, unsigned int *i,
233                            unsigned short code, unsigned int data,
234                            unsigned short jt, unsigned short jf)
235 {
236         struct sock_filter *ins = &inss[*i];
237
238         ins->code = code;
239         ins->jt = jt;
240         ins->jf = jf;
241         ins->k = data;
242         (*i)++;
243 }
244
245 /**
246  * udev_monitor_filter_update:
247  * @udev_monitor: monitor
248  *
249  * Update the installed filter. This might only be needed, if the filter was removed or changed.
250  *
251  * Returns: 0 on success, otherwise a negative error value.
252  */
253 int udev_monitor_filter_update(struct udev_monitor *udev_monitor)
254 {
255         struct sock_filter ins[512];
256         struct sock_fprog filter;
257         unsigned int i;
258         struct udev_list_entry *list_entry;
259         int err;
260
261         if (udev_list_get_entry(&udev_monitor->filter_subsystem_list) == NULL &&
262             udev_list_get_entry(&udev_monitor->filter_tag_list) == NULL)
263                 return 0;
264
265         memset(ins, 0x00, sizeof(ins));
266         i = 0;
267
268         /* load magic in A */
269         bpf_stmt(ins, &i, BPF_LD|BPF_W|BPF_ABS, offsetof(struct udev_monitor_netlink_header, magic));
270         /* jump if magic matches */
271         bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, UDEV_MONITOR_MAGIC, 1, 0);
272         /* wrong magic, pass packet */
273         bpf_stmt(ins, &i, BPF_RET|BPF_K, 0xffffffff);
274
275         if (udev_list_get_entry(&udev_monitor->filter_tag_list) != NULL) {
276                 int tag_matches;
277
278                 /* count tag matches, to calculate end of tag match block */
279                 tag_matches = 0;
280                 udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_monitor->filter_tag_list))
281                         tag_matches++;
282
283                 /* add all tags matches */
284                 udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_monitor->filter_tag_list)) {
285                         uint64_t tag_bloom_bits = util_string_bloom64(udev_list_entry_get_name(list_entry));
286                         uint32_t tag_bloom_hi = tag_bloom_bits >> 32;
287                         uint32_t tag_bloom_lo = tag_bloom_bits & 0xffffffff;
288
289                         /* load device bloom bits in A */
290                         bpf_stmt(ins, &i, BPF_LD|BPF_W|BPF_ABS, offsetof(struct udev_monitor_netlink_header, filter_tag_bloom_hi));
291                         /* clear bits (tag bits & bloom bits) */
292                         bpf_stmt(ins, &i, BPF_ALU|BPF_AND|BPF_K, tag_bloom_hi);
293                         /* jump to next tag if it does not match */
294                         bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, tag_bloom_hi, 0, 3);
295
296                         /* load device bloom bits in A */
297                         bpf_stmt(ins, &i, BPF_LD|BPF_W|BPF_ABS, offsetof(struct udev_monitor_netlink_header, filter_tag_bloom_lo));
298                         /* clear bits (tag bits & bloom bits) */
299                         bpf_stmt(ins, &i, BPF_ALU|BPF_AND|BPF_K, tag_bloom_lo);
300                         /* jump behind end of tag match block if tag matches */
301                         tag_matches--;
302                         bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, tag_bloom_lo, 1 + (tag_matches * 6), 0);
303                 }
304
305                 /* nothing matched, drop packet */
306                 bpf_stmt(ins, &i, BPF_RET|BPF_K, 0);
307         }
308
309         /* add all subsystem matches */
310         if (udev_list_get_entry(&udev_monitor->filter_subsystem_list) != NULL) {
311                 udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_monitor->filter_subsystem_list)) {
312                         unsigned int hash = util_string_hash32(udev_list_entry_get_name(list_entry));
313
314                         /* load device subsystem value in A */
315                         bpf_stmt(ins, &i, BPF_LD|BPF_W|BPF_ABS, offsetof(struct udev_monitor_netlink_header, filter_subsystem_hash));
316                         if (udev_list_entry_get_value(list_entry) == NULL) {
317                                 /* jump if subsystem does not match */
318                                 bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, hash, 0, 1);
319                         } else {
320                                 /* jump if subsystem does not match */
321                                 bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, hash, 0, 3);
322
323                                 /* load device devtype value in A */
324                                 bpf_stmt(ins, &i, BPF_LD|BPF_W|BPF_ABS, offsetof(struct udev_monitor_netlink_header, filter_devtype_hash));
325                                 /* jump if value does not match */
326                                 hash = util_string_hash32(udev_list_entry_get_value(list_entry));
327                                 bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, hash, 0, 1);
328                         }
329
330                         /* matched, pass packet */
331                         bpf_stmt(ins, &i, BPF_RET|BPF_K, 0xffffffff);
332
333                         if (i+1 >= ARRAY_SIZE(ins))
334                                 return -1;
335                 }
336
337                 /* nothing matched, drop packet */
338                 bpf_stmt(ins, &i, BPF_RET|BPF_K, 0);
339         }
340
341         /* matched, pass packet */
342         bpf_stmt(ins, &i, BPF_RET|BPF_K, 0xffffffff);
343
344         /* install filter */
345         filter.len = i;
346         filter.filter = ins;
347         err = setsockopt(udev_monitor->sock, SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter));
348         return err;
349 }
350
351 int udev_monitor_allow_unicast_sender(struct udev_monitor *udev_monitor, struct udev_monitor *sender)
352 {
353         udev_monitor->snl_trusted_sender.nl_pid = sender->snl.nl_pid;
354         return 0;
355 }
356 /**
357  * udev_monitor_enable_receiving:
358  * @udev_monitor: the monitor which should receive events
359  *
360  * Binds the @udev_monitor socket to the event source.
361  *
362  * Returns: 0 on success, otherwise a negative error value.
363  */
364 int udev_monitor_enable_receiving(struct udev_monitor *udev_monitor)
365 {
366         int err;
367         const int on = 1;
368
369         if (udev_monitor->sun.sun_family != 0) {
370                 err = bind(udev_monitor->sock,
371                            (struct sockaddr *)&udev_monitor->sun, udev_monitor->addrlen);
372         } else if (udev_monitor->snl.nl_family != 0) {
373                 udev_monitor_filter_update(udev_monitor);
374                 err = bind(udev_monitor->sock,
375                            (struct sockaddr *)&udev_monitor->snl, sizeof(struct sockaddr_nl));
376                 if (err == 0) {
377                         struct sockaddr_nl snl;
378                         socklen_t addrlen;
379
380                         /*
381                          * get the address the kernel has assigned us
382                          * it is usually, but not necessarily the pid
383                          */
384                         addrlen = sizeof(struct sockaddr_nl);
385                         err = getsockname(udev_monitor->sock, (struct sockaddr *)&snl, &addrlen);
386                         if (err == 0)
387                                 udev_monitor->snl.nl_pid = snl.nl_pid;
388                 }
389         } else {
390                 return -EINVAL;
391         }
392
393         if (err < 0) {
394                 err(udev_monitor->udev, "bind failed: %m\n");
395                 return err;
396         }
397
398         /* enable receiving of sender credentials */
399         setsockopt(udev_monitor->sock, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on));
400         return 0;
401 }
402
403 /**
404  * udev_monitor_set_receive_buffer_size:
405  * @udev_monitor: the monitor which should receive events
406  * @size: the size in bytes
407  *
408  * Set the size of the kernel socket buffer. This call needs the
409  * appropriate privileges to succeed.
410  *
411  * Returns: 0 on success, otherwise -1 on error.
412  */
413 int udev_monitor_set_receive_buffer_size(struct udev_monitor *udev_monitor, int size)
414 {
415         if (udev_monitor == NULL)
416                 return -1;
417         return setsockopt(udev_monitor->sock, SOL_SOCKET, SO_RCVBUFFORCE, &size, sizeof(size));
418 }
419
420 int udev_monitor_disconnect(struct udev_monitor *udev_monitor)
421 {
422         int err;
423
424         err = close(udev_monitor->sock);
425         udev_monitor->sock = -1;
426         return err;
427 }
428
429 /**
430  * udev_monitor_ref:
431  * @udev_monitor: udev monitor
432  *
433  * Take a reference of a udev monitor.
434  *
435  * Returns: the passed udev monitor
436  **/
437 struct udev_monitor *udev_monitor_ref(struct udev_monitor *udev_monitor)
438 {
439         if (udev_monitor == NULL)
440                 return NULL;
441         udev_monitor->refcount++;
442         return udev_monitor;
443 }
444
445 /**
446  * udev_monitor_unref:
447  * @udev_monitor: udev monitor
448  *
449  * Drop a reference of a udev monitor. If the refcount reaches zero,
450  * the bound socket will be closed, and the resources of the monitor
451  * will be released.
452  *
453  **/
454 void udev_monitor_unref(struct udev_monitor *udev_monitor)
455 {
456         if (udev_monitor == NULL)
457                 return;
458         udev_monitor->refcount--;
459         if (udev_monitor->refcount > 0)
460                 return;
461         if (udev_monitor->sock >= 0)
462                 close(udev_monitor->sock);
463         udev_list_cleanup_entries(udev_monitor->udev, &udev_monitor->filter_subsystem_list);
464         udev_list_cleanup_entries(udev_monitor->udev, &udev_monitor->filter_tag_list);
465         dbg(udev_monitor->udev, "monitor %p released\n", udev_monitor);
466         free(udev_monitor);
467 }
468
469 /**
470  * udev_monitor_get_udev:
471  * @udev_monitor: udev monitor
472  *
473  * Retrieve the udev library context the monitor was created with.
474  *
475  * Returns: the udev library context
476  **/
477 struct udev *udev_monitor_get_udev(struct udev_monitor *udev_monitor)
478 {
479         if (udev_monitor == NULL)
480                 return NULL;
481         return udev_monitor->udev;
482 }
483
484 /**
485  * udev_monitor_get_fd:
486  * @udev_monitor: udev monitor
487  *
488  * Retrieve the socket file descriptor associated with the monitor.
489  *
490  * Returns: the socket file descriptor
491  **/
492 int udev_monitor_get_fd(struct udev_monitor *udev_monitor)
493 {
494         if (udev_monitor == NULL)
495                 return -1;
496         return udev_monitor->sock;
497 }
498
499 static int passes_filter(struct udev_monitor *udev_monitor, struct udev_device *udev_device)
500 {
501         struct udev_list_entry *list_entry;
502
503         if (udev_list_get_entry(&udev_monitor->filter_subsystem_list) == NULL)
504                 goto tag;
505         udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_monitor->filter_subsystem_list)) {
506                 const char *subsys = udev_list_entry_get_name(list_entry);
507                 const char *dsubsys = udev_device_get_subsystem(udev_device);
508                 const char *devtype;
509                 const char *ddevtype;
510
511                 if (strcmp(dsubsys, subsys) != 0)
512                         continue;
513
514                 devtype = udev_list_entry_get_value(list_entry);
515                 if (devtype == NULL)
516                         goto tag;
517                 ddevtype = udev_device_get_devtype(udev_device);
518                 if (ddevtype == NULL)
519                         continue;
520                 if (strcmp(ddevtype, devtype) == 0)
521                         goto tag;
522         }
523         return 0;
524
525 tag:
526         if (udev_list_get_entry(&udev_monitor->filter_tag_list) == NULL)
527                 return 1;
528         udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_monitor->filter_tag_list)) {
529                 const char *tag = udev_list_entry_get_name(list_entry);
530
531                 if (udev_device_has_tag(udev_device, tag))
532                         return 1;
533         }
534         return 0;
535 }
536
537 /**
538  * udev_monitor_receive_device:
539  * @udev_monitor: udev monitor
540  *
541  * Receive data from the udev monitor socket, allocate a new udev
542  * device, fill in the received data, and return the device.
543  *
544  * Only socket connections with uid=0 are accepted. The caller
545  * needs to make sure that there is data to read from the socket.
546  * The call will block until the socket becomes readable.
547  *
548  * The initial refcount is 1, and needs to be decremented to
549  * release the resources of the udev device.
550  *
551  * Returns: a new udev device, or #NULL, in case of an error
552  **/
553 struct udev_device *udev_monitor_receive_device(struct udev_monitor *udev_monitor)
554 {
555         struct udev_device *udev_device;
556         struct msghdr smsg;
557         struct iovec iov;
558         char cred_msg[CMSG_SPACE(sizeof(struct ucred))];
559         struct cmsghdr *cmsg;
560         struct sockaddr_nl snl;
561         struct ucred *cred;
562         char buf[8192];
563         ssize_t buflen;
564         ssize_t bufpos;
565         struct udev_monitor_netlink_header *nlh;
566
567 retry:
568         if (udev_monitor == NULL)
569                 return NULL;
570         memset(buf, 0x00, sizeof(buf));
571         iov.iov_base = &buf;
572         iov.iov_len = sizeof(buf);
573         memset (&smsg, 0x00, sizeof(struct msghdr));
574         smsg.msg_iov = &iov;
575         smsg.msg_iovlen = 1;
576         smsg.msg_control = cred_msg;
577         smsg.msg_controllen = sizeof(cred_msg);
578
579         if (udev_monitor->snl.nl_family != 0) {
580                 smsg.msg_name = &snl;
581                 smsg.msg_namelen = sizeof(snl);
582         }
583
584         buflen = recvmsg(udev_monitor->sock, &smsg, 0);
585         if (buflen < 0) {
586                 if (errno != EINTR)
587                         info(udev_monitor->udev, "unable to receive message\n");
588                 return NULL;
589         }
590
591         if (buflen < 32 || (size_t)buflen >= sizeof(buf)) {
592                 info(udev_monitor->udev, "invalid message length\n");
593                 return NULL;
594         }
595
596         if (udev_monitor->snl.nl_family != 0) {
597                 if (snl.nl_groups == 0) {
598                         /* unicast message, check if we trust the sender */
599                         if (udev_monitor->snl_trusted_sender.nl_pid == 0 ||
600                             snl.nl_pid != udev_monitor->snl_trusted_sender.nl_pid) {
601                                 info(udev_monitor->udev, "unicast netlink message ignored\n");
602                                 return NULL;
603                         }
604                 } else if (snl.nl_groups == UDEV_MONITOR_KERNEL) {
605                         if (snl.nl_pid > 0) {
606                                 info(udev_monitor->udev, "multicast kernel netlink message from pid %d ignored\n",
607                                      snl.nl_pid);
608                                 return NULL;
609                         }
610                 }
611         }
612
613         cmsg = CMSG_FIRSTHDR(&smsg);
614         if (cmsg == NULL || cmsg->cmsg_type != SCM_CREDENTIALS) {
615                 info(udev_monitor->udev, "no sender credentials received, message ignored\n");
616                 return NULL;
617         }
618
619         cred = (struct ucred *)CMSG_DATA(cmsg);
620         if (cred->uid != 0) {
621                 info(udev_monitor->udev, "sender uid=%d, message ignored\n", cred->uid);
622                 return NULL;
623         }
624
625         if (memcmp(buf, "libudev", 8) == 0) {
626                 /* udev message needs proper version magic */
627                 nlh = (struct udev_monitor_netlink_header *) buf;
628                 if (nlh->magic != htonl(UDEV_MONITOR_MAGIC))
629                         return NULL;
630                 if (nlh->properties_off+32 > buflen)
631                         return NULL;
632                 bufpos = nlh->properties_off;
633         } else {
634                 /* kernel message with header */
635                 bufpos = strlen(buf) + 1;
636                 if ((size_t)bufpos < sizeof("a@/d") || bufpos >= buflen) {
637                         info(udev_monitor->udev, "invalid message length\n");
638                         return NULL;
639                 }
640
641                 /* check message header */
642                 if (strstr(buf, "@/") == NULL) {
643                         info(udev_monitor->udev, "unrecognized message header\n");
644                         return NULL;
645                 }
646         }
647
648         udev_device = udev_device_new(udev_monitor->udev);
649         if (udev_device == NULL)
650                 return NULL;
651         udev_device_set_info_loaded(udev_device);
652
653         while (bufpos < buflen) {
654                 char *key;
655                 size_t keylen;
656
657                 key = &buf[bufpos];
658                 keylen = strlen(key);
659                 if (keylen == 0)
660                         break;
661                 bufpos += keylen + 1;
662                 udev_device_add_property_from_string_parse(udev_device, key);
663         }
664
665         if (udev_device_add_property_from_string_parse_finish(udev_device) < 0) {
666                 info(udev_monitor->udev, "missing values, invalid device\n");
667                 udev_device_unref(udev_device);
668                 return NULL;
669         }
670
671         /* skip device, if it does not pass the current filter */
672         if (!passes_filter(udev_monitor, udev_device)) {
673                 struct pollfd pfd[1];
674                 int rc;
675
676                 udev_device_unref(udev_device);
677
678                 /* if something is queued, get next device */
679                 pfd[0].fd = udev_monitor->sock;
680                 pfd[0].events = POLLIN;
681                 rc = poll(pfd, 1, 0);
682                 if (rc > 0)
683                         goto retry;
684                 return NULL;
685         }
686
687         return udev_device;
688 }
689
690 int udev_monitor_send_device(struct udev_monitor *udev_monitor,
691                              struct udev_monitor *destination, struct udev_device *udev_device)
692 {
693         const char *buf;
694         ssize_t blen;
695         ssize_t count;
696
697         blen = udev_device_get_properties_monitor_buf(udev_device, &buf);
698         if (blen < 32)
699                 return -EINVAL;
700
701         if (udev_monitor->sun.sun_family != 0) {
702                 struct msghdr smsg;
703                 struct iovec iov[2];
704                 const char *action;
705                 char header[2048];
706                 char *s;
707
708                 /* header <action>@<devpath> */
709                 action = udev_device_get_action(udev_device);
710                 if (action == NULL)
711                         return -EINVAL;
712                 s = header;
713                 if (util_strpcpyl(&s, sizeof(header), action, "@", udev_device_get_devpath(udev_device), NULL) == 0)
714                         return -EINVAL;
715                 iov[0].iov_base = header;
716                 iov[0].iov_len = (s - header)+1;
717
718                 /* add properties list */
719                 iov[1].iov_base = (char *)buf;
720                 iov[1].iov_len = blen;
721
722                 memset(&smsg, 0x00, sizeof(struct msghdr));
723                 smsg.msg_iov = iov;
724                 smsg.msg_iovlen = 2;
725                 smsg.msg_name = &udev_monitor->sun;
726                 smsg.msg_namelen = udev_monitor->addrlen;
727                 count = sendmsg(udev_monitor->sock, &smsg, 0);
728                 info(udev_monitor->udev, "passed %zi bytes to socket monitor %p\n", count, udev_monitor);
729                 return count;
730         }
731
732         if (udev_monitor->snl.nl_family != 0) {
733                 struct msghdr smsg;
734                 struct iovec iov[2];
735                 const char *val;
736                 struct udev_monitor_netlink_header nlh;
737                 struct udev_list_entry *list_entry;
738                 uint64_t tag_bloom_bits;
739
740                 /* add versioned header */
741                 memset(&nlh, 0x00, sizeof(struct udev_monitor_netlink_header));
742                 memcpy(nlh.prefix, "libudev", 8);
743                 nlh.magic = htonl(UDEV_MONITOR_MAGIC);
744                 nlh.header_size = sizeof(struct udev_monitor_netlink_header);
745                 val = udev_device_get_subsystem(udev_device);
746                 nlh.filter_subsystem_hash = htonl(util_string_hash32(val));
747                 val = udev_device_get_devtype(udev_device);
748                 if (val != NULL)
749                         nlh.filter_devtype_hash = htonl(util_string_hash32(val));
750                 iov[0].iov_base = &nlh;
751                 iov[0].iov_len = sizeof(struct udev_monitor_netlink_header);
752
753                 /* add tag bloom filter */
754                 tag_bloom_bits = 0;
755                 udev_list_entry_foreach(list_entry, udev_device_get_tags_list_entry(udev_device))
756                         tag_bloom_bits |= util_string_bloom64(udev_list_entry_get_name(list_entry));
757                 if (tag_bloom_bits > 0) {
758                         nlh.filter_tag_bloom_hi = htonl(tag_bloom_bits >> 32);
759                         nlh.filter_tag_bloom_lo = htonl(tag_bloom_bits & 0xffffffff);
760                 }
761
762                 /* add properties list */
763                 nlh.properties_off = iov[0].iov_len;
764                 nlh.properties_len = blen;
765                 iov[1].iov_base = (char *)buf;
766                 iov[1].iov_len = blen;
767
768                 memset(&smsg, 0x00, sizeof(struct msghdr));
769                 smsg.msg_iov = iov;
770                 smsg.msg_iovlen = 2;
771                 /*
772                  * Use custom address for target, or the default one.
773                  *
774                  * If we send to a multicast group, we will get
775                  * ECONNREFUSED, which is expected.
776                  */
777                 if (destination != NULL)
778                         smsg.msg_name = &destination->snl;
779                 else
780                         smsg.msg_name = &udev_monitor->snl_destination;
781                 smsg.msg_namelen = sizeof(struct sockaddr_nl);
782                 count = sendmsg(udev_monitor->sock, &smsg, 0);
783                 info(udev_monitor->udev, "passed %zi bytes to netlink monitor %p\n", count, udev_monitor);
784                 return count;
785         }
786
787         return -EINVAL;
788 }
789
790 /**
791  * udev_monitor_filter_add_match_subsystem_devtype:
792  * @udev_monitor: the monitor
793  * @subsystem: the subsystem value to match the incoming devices against
794  * @devtype: the devtype value to match the incoming devices against
795  *
796  * This filer is efficiently executed inside the kernel, and libudev subscribers
797  * will usually not be woken up for devices which do not match.
798  *
799  * The filter must be installed before the monitor is switched to listening mode.
800  *
801  * Returns: 0 on success, otherwise a negative error value.
802  */
803 int udev_monitor_filter_add_match_subsystem_devtype(struct udev_monitor *udev_monitor, const char *subsystem, const char *devtype)
804 {
805         if (udev_monitor == NULL)
806                 return -EINVAL;
807         if (subsystem == NULL)
808                 return -EINVAL;
809         if (udev_list_entry_add(udev_monitor->udev,
810                                 &udev_monitor->filter_subsystem_list, subsystem, devtype, 0, 0) == NULL)
811                 return -ENOMEM;
812         return 0;
813 }
814
815 /**
816  * udev_monitor_filter_add_match_tag:
817  * @udev_monitor: the monitor
818  * @tag: the name of a tag
819  *
820  * This filer is efficiently executed inside the kernel, and libudev subscribers
821  * will usually not be woken up for devices which do not match.
822  *
823  * The filter must be installed before the monitor is switched to listening mode.
824  *
825  * Returns: 0 on success, otherwise a negative error value.
826  */
827 int udev_monitor_filter_add_match_tag(struct udev_monitor *udev_monitor, const char *tag)
828 {
829         if (udev_monitor == NULL)
830                 return -EINVAL;
831         if (tag == NULL)
832                 return -EINVAL;
833         if (udev_list_entry_add(udev_monitor->udev,
834                                 &udev_monitor->filter_tag_list, tag, NULL, 0, 0) == NULL)
835                 return -ENOMEM;
836         return 0;
837 }
838
839 /**
840  * udev_monitor_filter_remove:
841  * @udev_monitor: monitor
842  *
843  * Remove all filters from monitor.
844  *
845  * Returns: 0 on success, otherwise a negative error value.
846  */
847 int udev_monitor_filter_remove(struct udev_monitor *udev_monitor)
848 {
849         static struct sock_fprog filter = { 0, NULL };
850
851         udev_list_cleanup_entries(udev_monitor->udev, &udev_monitor->filter_subsystem_list);
852         return setsockopt(udev_monitor->sock, SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter));
853 }