chiark / gitweb /
bus: properly return an error when we detect a method call timeout
[elogind.git] / src / libsystemd-bus / bus-control.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2013 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #ifdef HAVE_VALGRIND_MEMCHECK_H
23 #include <valgrind/memcheck.h>
24 #endif
25
26 #include <stddef.h>
27 #include <errno.h>
28
29 #include "strv.h"
30 #include "sd-bus.h"
31 #include "bus-internal.h"
32 #include "bus-message.h"
33 #include "bus-control.h"
34 #include "bus-bloom.h"
35 #include "bus-util.h"
36
37 _public_ int sd_bus_get_unique_name(sd_bus *bus, const char **unique) {
38         int r;
39
40         assert_return(bus, -EINVAL);
41         assert_return(unique, -EINVAL);
42         assert_return(!bus_pid_changed(bus), -ECHILD);
43
44         r = bus_ensure_running(bus);
45         if (r < 0)
46                 return r;
47
48         *unique = bus->unique_name;
49         return 0;
50 }
51
52 static int bus_request_name_kernel(sd_bus *bus, const char *name, unsigned flags) {
53         struct kdbus_cmd_name *n;
54         size_t l;
55         int r;
56
57         assert(bus);
58         assert(name);
59
60         l = strlen(name);
61         n = alloca0(offsetof(struct kdbus_cmd_name, name) + l + 1);
62         n->size = offsetof(struct kdbus_cmd_name, name) + l + 1;
63         kdbus_translate_request_name_flags(flags, (uint64_t *) &n->flags);
64         memcpy(n->name, name, l+1);
65
66 #ifdef HAVE_VALGRIND_MEMCHECK_H
67         VALGRIND_MAKE_MEM_DEFINED(n, n->size);
68 #endif
69
70         r = ioctl(bus->input_fd, KDBUS_CMD_NAME_ACQUIRE, n);
71         if (r < 0)
72                 return -errno;
73
74         if (n->flags & KDBUS_NAME_IN_QUEUE)
75                 return 0;
76
77         return 1;
78 }
79
80 static int bus_request_name_dbus1(sd_bus *bus, const char *name, unsigned flags) {
81         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
82         uint32_t ret;
83         int r;
84
85         assert(bus);
86         assert(name);
87
88         r = sd_bus_call_method(
89                         bus,
90                         "org.freedesktop.DBus",
91                         "/",
92                         "org.freedesktop.DBus",
93                         "RequestName",
94                         NULL,
95                         &reply,
96                         "su",
97                         name,
98                         flags);
99         if (r < 0)
100                 return r;
101
102         r = sd_bus_message_read(reply, "u", &ret);
103         if (r < 0)
104                 return r;
105
106         if (ret == BUS_NAME_ALREADY_OWNER)
107                 return -EALREADY;
108         else if (ret == BUS_NAME_EXISTS)
109                 return -EEXIST;
110         else if (ret == BUS_NAME_IN_QUEUE)
111                 return 0;
112         else if (ret == BUS_NAME_PRIMARY_OWNER)
113                 return 1;
114
115         return -EIO;
116 }
117
118 _public_ int sd_bus_request_name(sd_bus *bus, const char *name, unsigned flags) {
119         assert_return(bus, -EINVAL);
120         assert_return(name, -EINVAL);
121         assert_return(bus->bus_client, -EINVAL);
122         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
123         assert_return(!bus_pid_changed(bus), -ECHILD);
124         assert_return(!(flags & ~(SD_BUS_NAME_ALLOW_REPLACEMENT|SD_BUS_NAME_REPLACE_EXISTING|SD_BUS_NAME_DO_NOT_QUEUE)), -EINVAL);
125
126         if (bus->is_kernel)
127                 return bus_request_name_kernel(bus, name, flags);
128         else
129                 return bus_request_name_dbus1(bus, name, flags);
130 }
131
132 static int bus_release_name_kernel(sd_bus *bus, const char *name) {
133         struct kdbus_cmd_name *n;
134         size_t l;
135         int r;
136
137         assert(bus);
138         assert(name);
139
140         l = strlen(name);
141         n = alloca0(offsetof(struct kdbus_cmd_name, name) + l + 1);
142         n->size = offsetof(struct kdbus_cmd_name, name) + l + 1;
143         memcpy(n->name, name, l+1);
144
145 #ifdef HAVE_VALGRIND_MEMCHECK_H
146         VALGRIND_MAKE_MEM_DEFINED(n, n->size);
147 #endif
148         r = ioctl(bus->input_fd, KDBUS_CMD_NAME_RELEASE, n);
149         if (r < 0)
150                 return -errno;
151
152         return n->flags;
153 }
154
155 static int bus_release_name_dbus1(sd_bus *bus, const char *name) {
156         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
157         uint32_t ret;
158         int r;
159
160         assert(bus);
161         assert(name);
162
163         r = sd_bus_call_method(
164                         bus,
165                         "org.freedesktop.DBus",
166                         "/",
167                         "org.freedesktop.DBus",
168                         "ReleaseName",
169                         NULL,
170                         &reply,
171                         "s",
172                         name);
173         if (r < 0)
174                 return r;
175
176         r = sd_bus_message_read(reply, "u", &ret);
177         if (r < 0)
178                 return r;
179         if (ret == BUS_NAME_NON_EXISTENT)
180                 return -ENOENT;
181         if (ret == BUS_NAME_NOT_OWNER)
182                 return -EADDRNOTAVAIL;
183         if (ret == BUS_NAME_RELEASED)
184                 return 0;
185
186         return -EINVAL;
187 }
188
189 _public_ int sd_bus_release_name(sd_bus *bus, const char *name) {
190         assert_return(bus, -EINVAL);
191         assert_return(name, -EINVAL);
192         assert_return(bus->bus_client, -EINVAL);
193         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
194         assert_return(!bus_pid_changed(bus), -ECHILD);
195
196         if (bus->is_kernel)
197                 return bus_release_name_kernel(bus, name);
198         else
199                 return bus_release_name_dbus1(bus, name);
200 }
201
202 static int kernel_get_list(sd_bus *bus, uint64_t flags, char ***x) {
203         struct kdbus_cmd_name_list cmd = {};
204         struct kdbus_name_list *name_list;
205         struct kdbus_cmd_name *name;
206         uint64_t previous_id = 0;
207         int r;
208
209         /* Caller will free half-constructed list on failure... */
210
211         cmd.flags = flags;
212
213         r = ioctl(bus->input_fd, KDBUS_CMD_NAME_LIST, &cmd);
214         if (r < 0)
215                 return -errno;
216
217         name_list = (struct kdbus_name_list *) ((uint8_t *) bus->kdbus_buffer + cmd.offset);
218
219         KDBUS_ITEM_FOREACH(name, name_list, names) {
220
221                 if ((flags & KDBUS_NAME_LIST_UNIQUE) && name->id != previous_id) {
222                         char *n;
223
224                         if (asprintf(&n, ":1.%llu", (unsigned long long) name->id) < 0)
225                                 return -ENOMEM;
226
227                         r = strv_push(x, n);
228                         if (r < 0) {
229                                 free(n);
230                                 return -ENOMEM;
231                         }
232
233                         previous_id = name->id;
234                 }
235
236                 if (name->size > sizeof(*name)) {
237                         r = strv_extend(x, name->name);
238                         if (r < 0)
239                                 return -ENOMEM;
240                 }
241         }
242
243         r = ioctl(sd_bus_get_fd(bus), KDBUS_CMD_FREE, &cmd.offset);
244         if (r < 0)
245                 return -errno;
246
247         return 0;
248 }
249
250 static int bus_list_names_kernel(sd_bus *bus, char ***acquired, char ***activatable) {
251         _cleanup_strv_free_ char **x = NULL, **y = NULL;
252         int r;
253
254         if (acquired) {
255                 r = kernel_get_list(bus, KDBUS_NAME_LIST_UNIQUE | KDBUS_NAME_LIST_NAMES, &x);
256                 if (r < 0)
257                         return r;
258         }
259
260         if (activatable) {
261                 r = kernel_get_list(bus, KDBUS_NAME_LIST_STARTERS, &y);
262                 if (r < 0)
263                         return r;
264
265                 *activatable = y;
266                 y = NULL;
267         }
268
269         if (acquired) {
270                 *acquired = x;
271                 x = NULL;
272         }
273
274         return 0;
275 }
276
277 static int bus_list_names_dbus1(sd_bus *bus, char ***acquired, char ***activatable) {
278         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
279         _cleanup_strv_free_ char **x = NULL, **y = NULL;
280         int r;
281
282         if (acquired) {
283                 r = sd_bus_call_method(
284                                 bus,
285                                 "org.freedesktop.DBus",
286                                 "/",
287                                 "org.freedesktop.DBus",
288                                 "ListNames",
289                                 NULL,
290                                 &reply,
291                                 NULL);
292                 if (r < 0)
293                         return r;
294
295                 r = sd_bus_message_read_strv(reply, &x);
296                 if (r < 0)
297                         return r;
298
299                 reply = sd_bus_message_unref(reply);
300         }
301
302         if (activatable) {
303                 r = sd_bus_call_method(
304                                 bus,
305                                 "org.freedesktop.DBus",
306                                 "/",
307                                 "org.freedesktop.DBus",
308                                 "ListActivatableNames",
309                                 NULL,
310                                 &reply,
311                                 NULL);
312                 if (r < 0)
313                         return r;
314
315                 r = sd_bus_message_read_strv(reply, &y);
316                 if (r < 0)
317                         return r;
318
319                 *activatable = y;
320                 y = NULL;
321         }
322
323         if (acquired) {
324                 *acquired = x;
325                 x = NULL;
326         }
327
328         return 0;
329 }
330
331 _public_ int sd_bus_list_names(sd_bus *bus, char ***acquired, char ***activatable) {
332         assert_return(bus, -EINVAL);
333         assert_return(acquired || activatable, -EINVAL);
334         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
335         assert_return(!bus_pid_changed(bus), -ECHILD);
336
337         if (bus->is_kernel)
338                 return bus_list_names_kernel(bus, acquired, activatable);
339         else
340                 return bus_list_names_dbus1(bus, acquired, activatable);
341 }
342
343 static int bus_get_owner_kdbus(
344                 sd_bus *bus,
345                 const char *name,
346                 uint64_t mask,
347                 sd_bus_creds **creds) {
348
349         _cleanup_bus_creds_unref_ sd_bus_creds *c = NULL;
350         struct kdbus_cmd_conn_info *cmd;
351         struct kdbus_conn_info *conn_info;
352         struct kdbus_item *item;
353         size_t size;
354         uint64_t m, id;
355         int r;
356
357         r = bus_kernel_parse_unique_name(name, &id);
358         if (r < 0)
359                 return r;
360         if (r > 0) {
361                 size = offsetof(struct kdbus_cmd_conn_info, name);
362                 cmd = alloca0(size);
363                 cmd->id = id;
364         } else {
365                 size = offsetof(struct kdbus_cmd_conn_info, name) + strlen(name) + 1;
366                 cmd = alloca0(size);
367                 strcpy(cmd->name, name);
368         }
369         cmd->flags = KDBUS_ATTACH_NAMES;
370
371         cmd->size = size;
372         r = ioctl(bus->input_fd, KDBUS_CMD_CONN_INFO, cmd);
373         if (r < 0)
374                 return -errno;
375
376         conn_info = (struct kdbus_conn_info *) ((uint8_t *) bus->kdbus_buffer + cmd->offset);
377
378         c = bus_creds_new();
379         if (!c)
380                 return -ENOMEM;
381
382         if (mask & SD_BUS_CREDS_UNIQUE_NAME) {
383                 if (asprintf(&c->unique_name, ":1.%llu", (unsigned long long) conn_info->id) < 0)
384                         return -ENOMEM;
385
386                 c->mask |= SD_BUS_CREDS_UNIQUE_NAME;
387         }
388
389         KDBUS_ITEM_FOREACH(item, conn_info, items) {
390
391                 switch (item->type) {
392
393                 case KDBUS_ITEM_CREDS:
394                         m = (SD_BUS_CREDS_UID | SD_BUS_CREDS_GID | SD_BUS_CREDS_PID |
395                              SD_BUS_CREDS_TID | SD_BUS_CREDS_PID_STARTTIME) & mask;
396
397                         if (m) {
398                                 c->uid = item->creds.uid;
399                                 c->pid = item->creds.pid;
400                                 c->gid = item->creds.gid;
401                                 c->tid = item->creds.tid;
402                                 c->pid_starttime = item->creds.starttime;
403                                 c->mask |= m;
404                         }
405                         break;
406
407                 case KDBUS_ITEM_PID_COMM:
408                         if (mask & SD_BUS_CREDS_COMM) {
409                                 c->comm = strdup(item->str);
410                                 if (!c->comm) {
411                                         r = -ENOMEM;
412                                         goto fail;
413                                 }
414
415                                 c->mask |= SD_BUS_CREDS_COMM;
416                         }
417                         break;
418
419                 case KDBUS_ITEM_TID_COMM:
420                         if (mask & SD_BUS_CREDS_TID_COMM) {
421                                 c->tid_comm = strdup(item->str);
422                                 if (!c->tid_comm) {
423                                         r = -ENOMEM;
424                                         goto fail;
425                                 }
426
427                                 c->mask |= SD_BUS_CREDS_TID_COMM;
428                         }
429                         break;
430
431                 case KDBUS_ITEM_EXE:
432                         if (mask & SD_BUS_CREDS_EXE) {
433                                 c->exe = strdup(item->str);
434                                 if (!c->exe) {
435                                         r = -ENOMEM;
436                                         goto fail;
437                                 }
438
439                                 c->mask |= SD_BUS_CREDS_EXE;
440                         }
441                         break;
442
443                 case KDBUS_ITEM_CMDLINE:
444                         if (mask & SD_BUS_CREDS_CMDLINE) {
445                                 c->cmdline_size = item->size - KDBUS_ITEM_HEADER_SIZE;
446                                 c->cmdline = memdup(item->data, c->cmdline_size);
447                                 if (!c->cmdline) {
448                                         r = -ENOMEM;
449                                         goto fail;
450                                 }
451
452                                 c->mask |= SD_BUS_CREDS_CMDLINE;
453                         }
454                         break;
455
456                 case KDBUS_ITEM_CGROUP:
457                         m = (SD_BUS_CREDS_CGROUP | SD_BUS_CREDS_UNIT |
458                              SD_BUS_CREDS_USER_UNIT | SD_BUS_CREDS_SLICE |
459                              SD_BUS_CREDS_SESSION | SD_BUS_CREDS_OWNER_UID) & mask;
460
461                         if (m) {
462                                 c->cgroup = strdup(item->str);
463                                 if (!c->cgroup) {
464                                         r = -ENOMEM;
465                                         goto fail;
466                                 }
467
468                                 c->mask |= m;
469                         }
470                         break;
471
472                 case KDBUS_ITEM_CAPS:
473                         m = (SD_BUS_CREDS_EFFECTIVE_CAPS | SD_BUS_CREDS_PERMITTED_CAPS |
474                              SD_BUS_CREDS_INHERITABLE_CAPS | SD_BUS_CREDS_BOUNDING_CAPS) & mask;
475
476                         if (m) {
477                                 c->capability_size = item->size - KDBUS_ITEM_HEADER_SIZE;
478                                 c->capability = memdup(item->data, c->capability_size);
479                                 if (!c->capability) {
480                                         r = -ENOMEM;
481                                         goto fail;
482                                 }
483
484                                 c->mask |= m;
485                         }
486                         break;
487
488                 case KDBUS_ITEM_SECLABEL:
489                         if (mask & SD_BUS_CREDS_SELINUX_CONTEXT) {
490                                 c->label = strdup(item->str);
491                                 if (!c->label) {
492                                         r = -ENOMEM;
493                                         goto fail;
494                                 }
495
496                                 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
497                         }
498                         break;
499
500                 case KDBUS_ITEM_AUDIT:
501                         m = (SD_BUS_CREDS_AUDIT_SESSION_ID | SD_BUS_CREDS_AUDIT_LOGIN_UID) & mask;
502
503                         if (m) {
504                                 c->audit_session_id = item->audit.sessionid;
505                                 c->audit_login_uid = item->audit.loginuid;
506                                 c->mask |= m;
507                         }
508                         break;
509
510                 case KDBUS_ITEM_NAME:
511                         if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) {
512                                 r = strv_extend(&c->well_known_names, item->name.name);
513                                 if (r < 0)
514                                         goto fail;
515
516                                 c->mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES;
517                         }
518                         break;
519                 }
520         }
521
522         if (creds) {
523                 *creds = c;
524                 c = NULL;
525         }
526
527         r = 0;
528
529 fail:
530         ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd->offset);
531         return r;
532 }
533
534 static int bus_get_owner_dbus1(
535                 sd_bus *bus,
536                 const char *name,
537                 uint64_t mask,
538                 sd_bus_creds **creds) {
539
540         _cleanup_bus_message_unref_ sd_bus_message *reply_unique = NULL, *reply = NULL;
541         _cleanup_bus_creds_unref_ sd_bus_creds *c = NULL;
542         const char *unique = NULL;
543         pid_t pid = 0;
544         int r;
545
546         /* Only query the owner if the caller wants to know it or if
547          * the caller just wants to check whether a name exists */
548         if ((mask & SD_BUS_CREDS_UNIQUE_NAME) || mask == 0) {
549                 r = sd_bus_call_method(
550                                 bus,
551                                 "org.freedesktop.DBus",
552                                 "/",
553                                 "org.freedesktop.DBus",
554                                 "GetNameOwner",
555                                 NULL,
556                                 &reply_unique,
557                                 "s",
558                                 name);
559                 if (r < 0)
560                         return r;
561
562                 r = sd_bus_message_read(reply_unique, "s", &unique);
563                 if (r < 0)
564                         return r;
565         }
566
567         if (mask != 0) {
568                 c = bus_creds_new();
569                 if (!c)
570                         return -ENOMEM;
571
572                 if ((mask & SD_BUS_CREDS_UNIQUE_NAME) && unique) {
573                         c->unique_name = strdup(unique);
574                         if (!c->unique_name)
575                                 return -ENOMEM;
576
577                         c->mask |= SD_BUS_CREDS_UNIQUE_NAME;
578                 }
579
580                 if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_GID|
581                             SD_BUS_CREDS_COMM|SD_BUS_CREDS_EXE|SD_BUS_CREDS_CMDLINE|
582                             SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID|
583                             SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS|
584                             SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID)) {
585                         uint32_t u;
586
587                         r = sd_bus_call_method(
588                                         bus,
589                                         "org.freedesktop.DBus",
590                                         "/",
591                                         "org.freedesktop.DBus",
592                                         "GetConnectionUnixProcessID",
593                                         NULL,
594                                         &reply,
595                                         "s",
596                                         unique ? unique : name);
597                         if (r < 0)
598                                 return r;
599
600                         r = sd_bus_message_read(reply, "u", &u);
601                         if (r < 0)
602                                 return r;
603
604                         pid = u;
605                         if (mask & SD_BUS_CREDS_PID) {
606                                 c->pid = u;
607                                 c->mask |= SD_BUS_CREDS_PID;
608                         }
609
610                         reply = sd_bus_message_unref(reply);
611                 }
612
613                 if (mask & SD_BUS_CREDS_UID) {
614                         uint32_t u;
615
616                         r = sd_bus_call_method(
617                                         bus,
618                                         "org.freedesktop.DBus",
619                                         "/",
620                                         "org.freedesktop.DBus",
621                                         "GetConnectionUnixUser",
622                                         NULL,
623                                         &reply,
624                                         "s",
625                                         unique ? unique : name);
626                         if (r < 0)
627                                 return r;
628
629                         r = sd_bus_message_read(reply, "u", &u);
630                         if (r < 0)
631                                 return r;
632
633                         c->uid = u;
634                         c->mask |= SD_BUS_CREDS_UID;
635
636                         reply = sd_bus_message_unref(reply);
637                 }
638
639                 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT) {
640                         const void *p;
641                         size_t sz;
642
643                         r = sd_bus_call_method(
644                                         bus,
645                                         "org.freedesktop.DBus",
646                                         "/",
647                                         "org.freedesktop.DBus",
648                                         "GetConnectionSELinuxSecurityContext",
649                                         NULL,
650                                         &reply,
651                                         "s",
652                                         unique ? unique : name);
653                         if (r < 0)
654                                 return r;
655
656                         r = sd_bus_message_read_array(reply, 'y', &p, &sz);
657                         if (r < 0)
658                                 return r;
659
660                         c->label = strndup(p, sz);
661                         if (!c->label)
662                                 return -ENOMEM;
663
664                         c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
665                 }
666
667                 r = bus_creds_add_more(c, mask, pid, 0);
668                 if (r < 0)
669                         return r;
670         }
671
672         if (creds) {
673                 *creds = c;
674                 c = NULL;
675         }
676
677         return 0;
678 }
679
680 _public_ int sd_bus_get_owner(
681                 sd_bus *bus,
682                 const char *name,
683                 uint64_t mask,
684                 sd_bus_creds **creds) {
685
686         assert_return(bus, -EINVAL);
687         assert_return(name, -EINVAL);
688         assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
689         assert_return(mask == 0 || creds, -EINVAL);
690         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
691         assert_return(!bus_pid_changed(bus), -ECHILD);
692
693         if (bus->is_kernel)
694                 return bus_get_owner_kdbus(bus, name, mask, creds);
695         else
696                 return bus_get_owner_dbus1(bus, name, mask, creds);
697 }
698
699 static int add_name_change_match(sd_bus *bus,
700                                  uint64_t cookie,
701                                  const char *name,
702                                  const char *old_owner,
703                                  const char *new_owner) {
704
705         uint64_t name_id = 0, old_owner_id = 0, new_owner_id = 0;
706         int is_name_id = -1, r;
707         struct kdbus_item *item;
708
709         assert(bus);
710
711         /* If we encounter a match that could match against
712          * NameOwnerChanged messages, then we need to create
713          * KDBUS_MATCH_NAME_{ADD,REMOVE,CHANGE} and
714          * KDBUS_MATCH_ID_{ADD,REMOVE} matches for it, possibly
715          * multiple if the match is underspecified.
716          *
717          * The NameOwnerChanged signals take three parameters with
718          * unique or well-known names, but only some forms actually
719          * exist:
720          *
721          * WELLKNOWN, "", UNIQUE       → KDBUS_MATCH_NAME_ADD
722          * WELLKNOWN, UNIQUE, ""       → KDBUS_MATCH_NAME_REMOVE
723          * WELLKNOWN, UNIQUE, UNIQUE   → KDBUS_MATCH_NAME_CHANGE
724          * UNIQUE, "", UNIQUE          → KDBUS_MATCH_ID_ADD
725          * UNIQUE, UNIQUE, ""          → KDBUS_MATCH_ID_REMOVE
726          *
727          * For the latter two the two unique names must be identical.
728          *
729          * */
730
731         if (name) {
732                 is_name_id = bus_kernel_parse_unique_name(name, &name_id);
733                 if (is_name_id < 0)
734                         return 0;
735         }
736
737         if (old_owner) {
738                 r = bus_kernel_parse_unique_name(old_owner, &old_owner_id);
739                 if (r < 0)
740                         return 0;
741                 if (r == 0)
742                         return 0;
743                 if (is_name_id > 0 && old_owner_id != name_id)
744                         return 0;
745         }
746
747         if (new_owner) {
748                 r = bus_kernel_parse_unique_name(new_owner, &new_owner_id);
749                 if (r < 0)
750                         return r;
751                 if (r == 0)
752                         return 0;
753                 if (is_name_id > 0 && new_owner_id != name_id)
754                         return 0;
755         }
756
757         if (is_name_id <= 0) {
758                 struct kdbus_cmd_match *m;
759                 size_t sz, l;
760
761                 /* If the name argument is missing or is a well-known
762                  * name, then add KDBUS_MATCH_NAME_{ADD,REMOVE,CHANGE}
763                  * matches for it */
764
765                 l = name ? strlen(name) : 0;
766
767                 sz = ALIGN8(offsetof(struct kdbus_cmd_match, items) +
768                             offsetof(struct kdbus_item, name_change) +
769                             offsetof(struct kdbus_notify_name_change, name) +
770                             l+1);
771
772                 m = alloca0(sz);
773                 m->size = sz;
774                 m->cookie = cookie;
775                 m->src_id = KDBUS_SRC_ID_KERNEL;
776
777                 item = m->items;
778                 item->size =
779                         offsetof(struct kdbus_item, name_change) +
780                         offsetof(struct kdbus_notify_name_change, name) +
781                         l+1;
782
783                 item->name_change.old_id = old_owner_id;
784                 item->name_change.new_id = new_owner_id;
785
786                 if (name)
787                         strcpy(item->name_change.name, name);
788
789                 /* If the old name is unset or empty, then
790                  * this can match against added names */
791                 if (!old_owner || old_owner[0] == 0) {
792                         item->type = KDBUS_MATCH_NAME_ADD;
793
794                         r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
795                         if (r < 0)
796                                 return -errno;
797                 }
798
799                 /* If the new name is unset or empty, then
800                  * this can match against removed names */
801                 if (!new_owner || new_owner[0] == 0) {
802                         item->type = KDBUS_MATCH_NAME_REMOVE;
803
804                         r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
805                         if (r < 0)
806                                 return -errno;
807                 }
808
809                 /* If the neither name is explicitly set to
810                  * the empty string, then this can match
811                  * agains changed names */
812                 if (!(old_owner && old_owner[0] == 0) &&
813                     !(new_owner && new_owner[0] == 0)) {
814                         item->type = KDBUS_MATCH_NAME_CHANGE;
815
816                         r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
817                         if (r < 0)
818                                 return -errno;
819                 }
820         }
821
822         if (is_name_id != 0) {
823                 struct kdbus_cmd_match *m;
824                 uint64_t sz;
825
826                 /* If the name argument is missing or is a unique
827                  * name, then add KDBUS_MATCH_ID_{ADD,REMOVE} matches
828                  * for it */
829
830                 sz = ALIGN8(offsetof(struct kdbus_cmd_match, items) +
831                             offsetof(struct kdbus_item, id_change) +
832                             sizeof(struct kdbus_notify_id_change));
833
834                 m = alloca0(sz);
835                 m->size = sz;
836                 m->cookie = cookie;
837                 m->src_id = KDBUS_SRC_ID_KERNEL;
838
839                 item = m->items;
840                 item->size = offsetof(struct kdbus_item, id_change) + sizeof(struct kdbus_notify_id_change);
841                 item->id_change.id = name_id;
842
843                 /* If the old name is unset or empty, then this can
844                  * match against added ids */
845                 if (!old_owner || old_owner[0] == 0) {
846                         item->type = KDBUS_MATCH_ID_ADD;
847
848                         r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
849                         if (r < 0)
850                                 return -errno;
851                 }
852
853                 /* If thew new name is unset or empty, then this can
854                 match against removed ids */
855                 if (!new_owner || new_owner[0] == 0) {
856                         item->type = KDBUS_MATCH_ID_REMOVE;
857
858                         r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
859                         if (r < 0)
860                                 return -errno;
861                 }
862         }
863
864         return 0;
865 }
866
867 static int bus_add_match_internal_kernel(
868                 sd_bus *bus,
869                 const char *match,
870                 struct bus_match_component *components,
871                 unsigned n_components,
872                 uint64_t cookie) {
873
874         struct kdbus_cmd_match *m;
875         struct kdbus_item *item;
876         uint64_t bloom[BLOOM_SIZE/8];
877         size_t sz;
878         const char *sender = NULL;
879         size_t sender_length = 0;
880         uint64_t src_id = KDBUS_MATCH_SRC_ID_ANY;
881         bool using_bloom = false;
882         unsigned i;
883         bool matches_name_change = true;
884         const char *name_change_arg[3] = {};
885         int r;
886
887         assert(bus);
888         assert(match);
889
890         zero(bloom);
891
892         sz = offsetof(struct kdbus_cmd_match, items);
893
894         for (i = 0; i < n_components; i++) {
895                 struct bus_match_component *c = &components[i];
896
897                 switch (c->type) {
898
899                 case BUS_MATCH_SENDER:
900                         if (!streq(c->value_str, "org.freedesktop.DBus"))
901                                 matches_name_change = false;
902
903                         r = bus_kernel_parse_unique_name(c->value_str, &src_id);
904                         if (r < 0)
905                                 return r;
906
907                         if (r > 0) {
908                                 sender = c->value_str;
909                                 sender_length = strlen(sender);
910                                 sz += ALIGN8(offsetof(struct kdbus_item, str) + sender_length + 1);
911                         }
912
913                         break;
914
915                 case BUS_MATCH_MESSAGE_TYPE:
916                         if (c->value_u8 != SD_BUS_MESSAGE_SIGNAL)
917                                 matches_name_change = false;
918
919                         bloom_add_pair(bloom, "message-type", bus_message_type_to_string(c->value_u8));
920                         using_bloom = true;
921                         break;
922
923                 case BUS_MATCH_INTERFACE:
924                         if (!streq(c->value_str, "org.freedesktop.DBus"))
925                                 matches_name_change = false;
926
927                         bloom_add_pair(bloom, "interface", c->value_str);
928                         using_bloom = true;
929                         break;
930
931                 case BUS_MATCH_MEMBER:
932                         if (!streq(c->value_str, "NameOwnerChanged"))
933                                 matches_name_change = false;
934
935                         bloom_add_pair(bloom, "member", c->value_str);
936                         using_bloom = true;
937                         break;
938
939                 case BUS_MATCH_PATH:
940                         if (!streq(c->value_str, "/org/freedesktop/DBus"))
941                                 matches_name_change = false;
942
943                         bloom_add_pair(bloom, "path", c->value_str);
944                         using_bloom = true;
945                         break;
946
947                 case BUS_MATCH_PATH_NAMESPACE:
948                         if (!streq(c->value_str, "/")) {
949                                 bloom_add_pair(bloom, "path-slash-prefix", c->value_str);
950                                 using_bloom = true;
951                         }
952                         break;
953
954                 case BUS_MATCH_ARG...BUS_MATCH_ARG_LAST: {
955                         char buf[sizeof("arg")-1 + 2 + 1];
956
957                         if (c->type - BUS_MATCH_ARG < 3)
958                                 name_change_arg[c->type - BUS_MATCH_ARG] = c->value_str;
959
960                         snprintf(buf, sizeof(buf), "arg%u", c->type - BUS_MATCH_ARG);
961                         bloom_add_pair(bloom, buf, c->value_str);
962                         using_bloom = true;
963                         break;
964                 }
965
966                 case BUS_MATCH_ARG_PATH...BUS_MATCH_ARG_PATH_LAST: {
967                         char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
968
969                         snprintf(buf, sizeof(buf), "arg%u-slash-prefix", c->type - BUS_MATCH_ARG_PATH);
970                         bloom_add_pair(bloom, buf, c->value_str);
971                         using_bloom = true;
972                         break;
973                 }
974
975                 case BUS_MATCH_ARG_NAMESPACE...BUS_MATCH_ARG_NAMESPACE_LAST: {
976                         char buf[sizeof("arg")-1 + 2 + sizeof("-dot-prefix")];
977
978                         snprintf(buf, sizeof(buf), "arg%u-dot-prefix", c->type - BUS_MATCH_ARG_NAMESPACE);
979                         bloom_add_pair(bloom, buf, c->value_str);
980                         using_bloom = true;
981                         break;
982                 }
983
984                 case BUS_MATCH_DESTINATION:
985                         /* The bloom filter does not include
986                            the destination, since it is only
987                            available for broadcast messages
988                            which do not carry a destination
989                            since they are undirected. */
990                         break;
991
992                 case BUS_MATCH_ROOT:
993                 case BUS_MATCH_VALUE:
994                 case BUS_MATCH_LEAF:
995                 case _BUS_MATCH_NODE_TYPE_MAX:
996                 case _BUS_MATCH_NODE_TYPE_INVALID:
997                         assert_not_reached("Invalid match type?");
998                 }
999         }
1000
1001         if (using_bloom)
1002                 sz += ALIGN8(offsetof(struct kdbus_item, data64) + BLOOM_SIZE);
1003
1004         m = alloca0(sz);
1005         m->size = sz;
1006         m->cookie = cookie;
1007         m->src_id = src_id;
1008
1009         item = m->items;
1010
1011         if (using_bloom) {
1012                 item->size = offsetof(struct kdbus_item, data64) + BLOOM_SIZE;
1013                 item->type = KDBUS_MATCH_BLOOM;
1014                 memcpy(item->data64, bloom, BLOOM_SIZE);
1015
1016                 item = KDBUS_ITEM_NEXT(item);
1017         }
1018
1019         if (sender) {
1020                 item->size = offsetof(struct kdbus_item, str) + sender_length + 1;
1021                 item->type = KDBUS_MATCH_SRC_NAME;
1022                 memcpy(item->str, sender, sender_length + 1);
1023         }
1024
1025         r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_ADD, m);
1026         if (r < 0)
1027                 return -errno;
1028
1029         if (matches_name_change) {
1030
1031                 /* If this match could theoretically match
1032                  * NameOwnerChanged messages, we need to
1033                  * install a second non-bloom filter explitly
1034                  * for it */
1035
1036                 r = add_name_change_match(bus, cookie, name_change_arg[0], name_change_arg[1], name_change_arg[2]);
1037                 if (r < 0)
1038                         return r;
1039         }
1040
1041         return 0;
1042 }
1043
1044 static int bus_add_match_internal_dbus1(
1045                 sd_bus *bus,
1046                 const char *match) {
1047
1048         assert(bus);
1049         assert(match);
1050
1051         return sd_bus_call_method(
1052                         bus,
1053                         "org.freedesktop.DBus",
1054                         "/",
1055                         "org.freedesktop.DBus",
1056                         "AddMatch",
1057                         NULL,
1058                         NULL,
1059                         "s",
1060                         match);
1061 }
1062
1063 int bus_add_match_internal(
1064                 sd_bus *bus,
1065                 const char *match,
1066                 struct bus_match_component *components,
1067                 unsigned n_components,
1068                 uint64_t cookie) {
1069
1070         assert(bus);
1071         assert(match);
1072
1073         if (bus->is_kernel)
1074                 return bus_add_match_internal_kernel(bus, match, components, n_components, cookie);
1075         else
1076                 return bus_add_match_internal_dbus1(bus, match);
1077 }
1078
1079 static int bus_remove_match_internal_kernel(
1080                 sd_bus *bus,
1081                 const char *match,
1082                 uint64_t cookie) {
1083
1084         struct kdbus_cmd_match m;
1085         int r;
1086
1087         assert(bus);
1088         assert(match);
1089
1090         zero(m);
1091         m.size = offsetof(struct kdbus_cmd_match, items);
1092         m.cookie = cookie;
1093
1094         r = ioctl(bus->input_fd, KDBUS_CMD_MATCH_REMOVE, &m);
1095         if (r < 0)
1096                 return -errno;
1097
1098         return 0;
1099 }
1100
1101 static int bus_remove_match_internal_dbus1(
1102                 sd_bus *bus,
1103                 const char *match) {
1104
1105         assert(bus);
1106         assert(match);
1107
1108         return sd_bus_call_method(
1109                         bus,
1110                         "org.freedesktop.DBus",
1111                         "/",
1112                         "org.freedesktop.DBus",
1113                         "RemoveMatch",
1114                         NULL,
1115                         NULL,
1116                         "s",
1117                         match);
1118 }
1119
1120 int bus_remove_match_internal(
1121                 sd_bus *bus,
1122                 const char *match,
1123                 uint64_t cookie) {
1124
1125         assert(bus);
1126         assert(match);
1127
1128         if (bus->is_kernel)
1129                 return bus_remove_match_internal_kernel(bus, match, cookie);
1130         else
1131                 return bus_remove_match_internal_dbus1(bus, match);
1132 }
1133
1134 _public_ int sd_bus_get_owner_machine_id(sd_bus *bus, const char *name, sd_id128_t *machine) {
1135         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL, *m = NULL;
1136         const char *mid;
1137         int r;
1138
1139         assert_return(bus, -EINVAL);
1140         assert_return(name, -EINVAL);
1141         assert_return(machine, -EINVAL);
1142         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1143         assert_return(!bus_pid_changed(bus), -ECHILD);
1144
1145         if (streq_ptr(name, bus->unique_name))
1146                 return sd_id128_get_machine(machine);
1147
1148         r = sd_bus_message_new_method_call(
1149                         bus,
1150                         name,
1151                         "/",
1152                         "org.freedesktop.DBus.Peer",
1153                         "GetMachineId", &m);
1154         if (r < 0)
1155                 return r;
1156
1157         r = sd_bus_message_set_no_auto_start(m, true);
1158         if (r < 0)
1159                 return r;
1160
1161         r = sd_bus_call(bus, m, 0, NULL, &reply);
1162         if (r < 0)
1163                 return r;
1164
1165         r = sd_bus_message_read(reply, "s", &mid);
1166         if (r < 0)
1167                 return r;
1168
1169         return sd_id128_from_string(mid, machine);
1170 }