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