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