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