chiark / gitweb /
bus-proxy: share policy between threads
[elogind.git] / src / bus-proxyd / driver.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2010 Lennart Poettering
7   Copyright 2013 Daniel Mack
8   Copyright 2014 Kay Sievers
9
10   systemd is free software; you can redistribute it and/or modify it
11   under the terms of the GNU Lesser General Public License as published by
12   the Free Software Foundation; either version 2.1 of the License, or
13   (at your option) any later version.
14
15   systemd is distributed in the hope that it will be useful, but
16   WITHOUT ANY WARRANTY; without even the implied warranty of
17   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18   Lesser General Public License for more details.
19
20   You should have received a copy of the GNU Lesser General Public License
21   along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 ***/
23
24 #include <sys/types.h>
25 #include <unistd.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <stddef.h>
29
30 #include "log.h"
31 #include "util.h"
32 #include "sd-bus.h"
33 #include "bus-internal.h"
34 #include "bus-message.h"
35 #include "bus-util.h"
36 #include "build.h"
37 #include "strv.h"
38 #include "def.h"
39 #include "capability.h"
40 #include "bus-control.h"
41 #include "set.h"
42 #include "driver.h"
43 #include "synthesize.h"
44
45 static int get_creds_by_name(sd_bus *bus, const char *name, uint64_t mask, sd_bus_creds **_creds, sd_bus_error *error) {
46         _cleanup_bus_creds_unref_ sd_bus_creds *c = NULL;
47         int r;
48
49         assert(bus);
50         assert(name);
51         assert(_creds);
52
53         r = sd_bus_get_name_creds(bus, name, mask, &c);
54         if (r == -ESRCH || r == -ENXIO)
55                 return sd_bus_error_setf(error, SD_BUS_ERROR_NAME_HAS_NO_OWNER, "Name %s is currently not owned by anyone.", name);
56         if (r < 0)
57                 return r;
58
59         if ((c->mask & mask) != mask)
60                 return -ENOTSUP;
61
62         *_creds = c;
63         c = NULL;
64
65         return 0;
66 }
67
68 static int get_creds_by_message(sd_bus *bus, sd_bus_message *m, uint64_t mask, sd_bus_creds **_creds, sd_bus_error *error) {
69         const char *name;
70         int r;
71
72         assert(bus);
73         assert(m);
74         assert(_creds);
75
76         r = sd_bus_message_read(m, "s", &name);
77         if (r < 0)
78                 return r;
79
80         return get_creds_by_name(bus, name, mask, _creds, error);
81 }
82
83 int bus_proxy_process_driver(sd_bus *a, sd_bus *b, sd_bus_message *m, SharedPolicy *sp, const struct ucred *ucred, Set *owned_names) {
84         int r;
85
86         assert(a);
87         assert(b);
88         assert(m);
89
90         if (!a->is_kernel)
91                 return 0;
92
93         if (!streq_ptr(sd_bus_message_get_destination(m), "org.freedesktop.DBus"))
94                 return 0;
95
96         /* The "Hello()" call is is handled in process_hello() */
97
98         if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
99
100                 if (!sd_bus_message_has_signature(m, ""))
101                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
102
103                 return synthetic_reply_method_return(m, "s",
104                         "<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\" "
105                           "\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"
106                         "<node>\n"
107                         " <interface name=\"org.freedesktop.DBus.Introspectable\">\n"
108                         "  <method name=\"Introspect\">\n"
109                         "   <arg name=\"data\" type=\"s\" direction=\"out\"/>\n"
110                         "  </method>\n"
111                         " </interface>\n"
112                         " <interface name=\"org.freedesktop.DBus\">\n"
113                         "  <method name=\"AddMatch\">\n"
114                         "   <arg type=\"s\" direction=\"in\"/>\n"
115                         "  </method>\n"
116                         "  <method name=\"RemoveMatch\">\n"
117                         "   <arg type=\"s\" direction=\"in\"/>\n"
118                         "  </method>\n"
119                         "  <method name=\"GetConnectionSELinuxSecurityContext\">\n"
120                         "   <arg type=\"s\" direction=\"in\"/>\n"
121                         "   <arg type=\"ay\" direction=\"out\"/>\n"
122                         "  </method>\n"
123                         "  <method name=\"GetConnectionUnixProcessID\">\n"
124                         "   <arg type=\"s\" direction=\"in\"/>\n"
125                         "   <arg type=\"u\" direction=\"out\"/>\n"
126                         "  </method>\n"
127                         "  <method name=\"GetConnectionUnixUser\">\n"
128                         "   <arg type=\"s\" direction=\"in\"/>\n"
129                         "   <arg type=\"u\" direction=\"out\"/>\n"
130                         "  </method>\n"
131                         "  <method name=\"GetId\">\n"
132                         "   <arg type=\"s\" direction=\"out\"/>\n"
133                         "  </method>\n"
134                         "  <method name=\"GetNameOwner\">\n"
135                         "   <arg type=\"s\" direction=\"in\"/>\n"
136                         "   <arg type=\"s\" direction=\"out\"/>\n"
137                         "  </method>\n"
138                         "  <method name=\"Hello\">\n"
139                         "   <arg type=\"s\" direction=\"out\"/>\n"
140                         "  </method>\n"
141                         "  <method name=\"ListActivatableNames\">\n"
142                         "   <arg type=\"as\" direction=\"out\"/>\n"
143                         "  </method>\n"
144                         "  <method name=\"ListNames\">\n"
145                         "   <arg type=\"as\" direction=\"out\"/>\n"
146                         "  </method>\n"
147                         "  <method name=\"ListQueuedOwners\">\n"
148                         "   <arg type=\"s\" direction=\"in\"/>\n"
149                         "   <arg type=\"as\" direction=\"out\"/>\n"
150                         "  </method>\n"
151                         "  <method name=\"NameHasOwner\">\n"
152                         "   <arg type=\"s\" direction=\"in\"/>\n"
153                         "   <arg type=\"b\" direction=\"out\"/>\n"
154                         "  </method>\n"
155                         "  <method name=\"ReleaseName\">\n"
156                         "   <arg type=\"s\" direction=\"in\"/>\n"
157                         "   <arg type=\"u\" direction=\"out\"/>\n"
158                         "  </method>\n"
159                         "  <method name=\"ReloadConfig\">\n"
160                         "  </method>\n"
161                         "  <method name=\"RequestName\">\n"
162                         "   <arg type=\"s\" direction=\"in\"/>\n"
163                         "   <arg type=\"u\" direction=\"in\"/>\n"
164                         "   <arg type=\"u\" direction=\"out\"/>\n"
165                         "  </method>\n"
166                         "  <method name=\"StartServiceByName\">\n"
167                         "   <arg type=\"s\" direction=\"in\"/>\n"
168                         "   <arg type=\"u\" direction=\"in\"/>\n"
169                         "   <arg type=\"u\" direction=\"out\"/>\n"
170                         "  </method>\n"
171                         "  <method name=\"UpdateActivationEnvironment\">\n"
172                         "   <arg type=\"a{ss}\" direction=\"in\"/>\n"
173                         "  </method>\n"
174                         "  <signal name=\"NameAcquired\">\n"
175                         "   <arg type=\"s\"/>\n"
176                         "  </signal>\n"
177                         "  <signal name=\"NameLost\">\n"
178                         "   <arg type=\"s\"/>\n"
179                         "  </signal>\n"
180                         "  <signal name=\"NameOwnerChanged\">\n"
181                         "   <arg type=\"s\"/>\n"
182                         "   <arg type=\"s\"/>\n"
183                         "   <arg type=\"s\"/>\n"
184                         "  </signal>\n"
185                         " </interface>\n"
186                         "</node>\n");
187
188         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "AddMatch")) {
189                 const char *match;
190
191                 if (!sd_bus_message_has_signature(m, "s"))
192                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
193
194                 r = sd_bus_message_read(m, "s", &match);
195                 if (r < 0)
196                         return synthetic_reply_method_errno(m, r, NULL);
197
198                 r = sd_bus_add_match(a, NULL, match, NULL, NULL);
199                 if (r < 0)
200                         return synthetic_reply_method_errno(m, r, NULL);
201
202                 return synthetic_reply_method_return(m, NULL);
203
204         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "RemoveMatch")) {
205                 const char *match;
206
207                 if (!sd_bus_message_has_signature(m, "s"))
208                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
209
210                 r = sd_bus_message_read(m, "s", &match);
211                 if (r < 0)
212                         return synthetic_reply_method_errno(m, r, NULL);
213
214                 r = bus_remove_match_by_string(a, match, NULL, NULL);
215                 if (r == 0)
216                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_MATCH_RULE_NOT_FOUND, "Match rule not found"));
217                 if (r < 0)
218                         return synthetic_reply_method_errno(m, r, NULL);
219
220                 return synthetic_reply_method_return(m, NULL);
221
222         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetConnectionSELinuxSecurityContext")) {
223                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
224                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
225
226                 if (!sd_bus_message_has_signature(m, "s"))
227                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
228
229                 r = get_creds_by_message(a, m, SD_BUS_CREDS_SELINUX_CONTEXT, &creds, &error);
230                 if (r < 0)
231                         return synthetic_reply_method_errno(m, r, &error);
232
233                 return synthetic_reply_method_return(m, "y", creds->label, strlen(creds->label));
234
235         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetConnectionUnixProcessID")) {
236                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
237                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
238
239                 if (!sd_bus_message_has_signature(m, "s"))
240                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
241
242                 r = get_creds_by_message(a, m, SD_BUS_CREDS_PID, &creds, &error);
243                 if (r < 0)
244                         return synthetic_reply_method_errno(m, r, &error);
245
246                 return synthetic_reply_method_return(m, "u", (uint32_t) creds->pid);
247
248         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetConnectionUnixUser")) {
249                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
250                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
251
252                 if (!sd_bus_message_has_signature(m, "s"))
253                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
254
255                 r = get_creds_by_message(a, m, SD_BUS_CREDS_UID, &creds, &error);
256                 if (r < 0)
257                         return synthetic_reply_method_errno(m, r, &error);
258
259                 return synthetic_reply_method_return(m, "u", (uint32_t) creds->uid);
260
261         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetId")) {
262                 sd_id128_t server_id;
263                 char buf[SD_ID128_STRING_MAX];
264
265                 if (!sd_bus_message_has_signature(m, ""))
266                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
267
268                 r = sd_bus_get_bus_id(a, &server_id);
269                 if (r < 0)
270                         return synthetic_reply_method_errno(m, r, NULL);
271
272                 return synthetic_reply_method_return(m, "s", sd_id128_to_string(server_id, buf));
273
274         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetNameOwner")) {
275                 const char *name;
276                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
277                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
278
279                 if (!sd_bus_message_has_signature(m, "s"))
280                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
281
282                 r = sd_bus_message_read(m, "s", &name);
283                 if (r < 0)
284                         return synthetic_reply_method_errno(m, r, NULL);
285
286                 if (streq(name, "org.freedesktop.DBus"))
287                         return synthetic_reply_method_return(m, "s", "org.freedesktop.DBus");
288
289                 r = get_creds_by_name(a, name, SD_BUS_CREDS_UNIQUE_NAME, &creds, &error);
290                 if (r < 0)
291                         return synthetic_reply_method_errno(m, r, &error);
292
293                 return synthetic_reply_method_return(m, "s", creds->unique_name);
294
295         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ListActivatableNames")) {
296                 _cleanup_strv_free_ char **names = NULL;
297
298                 if (!sd_bus_message_has_signature(m, ""))
299                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
300
301                 r = sd_bus_list_names(a, NULL, &names);
302                 if (r < 0)
303                         return synthetic_reply_method_errno(m, r, NULL);
304
305                 /* Let's sort the names list to make it stable */
306                 strv_sort(names);
307
308                 return synthetic_reply_return_strv(m, names);
309
310         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ListNames")) {
311                 _cleanup_strv_free_ char **names = NULL;
312
313                 if (!sd_bus_message_has_signature(m, ""))
314                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
315
316                 r = sd_bus_list_names(a, &names, NULL);
317                 if (r < 0)
318                         return synthetic_reply_method_errno(m, r, NULL);
319
320                 r = strv_extend(&names, "org.freedesktop.DBus");
321                 if (r < 0)
322                         return synthetic_reply_method_errno(m, r, NULL);
323
324                 /* Let's sort the names list to make it stable */
325                 strv_sort(names);
326
327                 return synthetic_reply_return_strv(m, names);
328
329         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ListQueuedOwners")) {
330                 struct kdbus_cmd_name_list cmd = {};
331                 struct kdbus_name_list *name_list;
332                 struct kdbus_name_info *name;
333                 _cleanup_strv_free_ char **owners = NULL;
334                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
335                 char *arg0;
336                 int err = 0;
337
338                 if (!sd_bus_message_has_signature(m, "s"))
339                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
340
341                 r = sd_bus_message_read(m, "s", &arg0);
342                 if (r < 0)
343                         return synthetic_reply_method_errno(m, r, NULL);
344
345                 r = sd_bus_get_name_creds(a, arg0, 0, NULL);
346                 if (r == -ESRCH || r == -ENXIO) {
347                         sd_bus_error_setf(&error, SD_BUS_ERROR_NAME_HAS_NO_OWNER, "Could not get owners of name '%s': no such name.", arg0);
348                         return synthetic_reply_method_errno(m, r, &error);
349                 }
350                 if (r < 0)
351                         return synthetic_reply_method_errno(m, r, NULL);
352
353                 cmd.flags = KDBUS_NAME_LIST_QUEUED;
354                 r = ioctl(a->input_fd, KDBUS_CMD_NAME_LIST, &cmd);
355                 if (r < 0)
356                         return synthetic_reply_method_errno(m, -errno, NULL);
357
358                 name_list = (struct kdbus_name_list *) ((uint8_t *) a->kdbus_buffer + cmd.offset);
359
360                 KDBUS_ITEM_FOREACH(name, name_list, names) {
361                         const char *entry_name = NULL;
362                         struct kdbus_item *item;
363                         char *n;
364
365                         KDBUS_ITEM_FOREACH(item, name, items)
366                                 if (item->type == KDBUS_ITEM_OWNED_NAME)
367                                         entry_name = item->name.name;
368
369                         if (!streq_ptr(entry_name, arg0))
370                                 continue;
371
372                         if (asprintf(&n, ":1.%llu", (unsigned long long) name->owner_id) < 0) {
373                                 err  = -ENOMEM;
374                                 break;
375                         }
376
377                         r = strv_consume(&owners, n);
378                         if (r < 0) {
379                                 err = r;
380                                 break;
381                         }
382                 }
383
384                 r = bus_kernel_cmd_free(a, cmd.offset);
385                 if (r < 0)
386                         return synthetic_reply_method_errno(m, r, NULL);
387
388                 if (err < 0)
389                         return synthetic_reply_method_errno(m, err, NULL);
390
391                 return synthetic_reply_return_strv(m, owners);
392
393         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "NameHasOwner")) {
394                 const char *name;
395
396                 if (!sd_bus_message_has_signature(m, "s"))
397                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
398
399                 r = sd_bus_message_read(m, "s", &name);
400                 if (r < 0)
401                         return synthetic_reply_method_errno(m, r, NULL);
402
403                 if (streq(name, "org.freedesktop.DBus"))
404                         return synthetic_reply_method_return(m, "b", true);
405
406                 r = sd_bus_get_name_creds(a, name, 0, NULL);
407                 if (r < 0 && r != -ESRCH && r != -ENXIO)
408                         return synthetic_reply_method_errno(m, r, NULL);
409
410                 return synthetic_reply_method_return(m, "b", r >= 0);
411
412         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ReleaseName")) {
413                 const char *name;
414
415                 if (!sd_bus_message_has_signature(m, "s"))
416                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
417
418                 r = sd_bus_message_read(m, "s", &name);
419                 if (r < 0)
420                         return synthetic_reply_method_errno(m, r, NULL);
421
422                 r = sd_bus_release_name(a, name);
423                 if (r < 0) {
424                         if (r == -ESRCH)
425                                 return synthetic_reply_method_return(m, "u", BUS_NAME_NON_EXISTENT);
426                         if (r == -EADDRINUSE)
427                                 return synthetic_reply_method_return(m, "u", BUS_NAME_NOT_OWNER);
428
429                         return synthetic_reply_method_errno(m, r, NULL);
430                 }
431
432                 set_remove(owned_names, (char*) name);
433
434                 return synthetic_reply_method_return(m, "u", BUS_NAME_RELEASED);
435
436         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ReloadConfig")) {
437                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
438
439                 if (!sd_bus_message_has_signature(m, ""))
440                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
441
442                 r = sd_bus_error_setf(&error, SD_BUS_ERROR_NOT_SUPPORTED, "%s() is not supported", sd_bus_message_get_member(m));
443
444                 return synthetic_reply_method_errno(m, r, &error);
445
446         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "RequestName")) {
447                 const char *name;
448                 uint32_t flags, param;
449                 bool in_queue;
450
451                 if (!sd_bus_message_has_signature(m, "su"))
452                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
453
454                 r = sd_bus_message_read(m, "su", &name, &flags);
455                 if (r < 0)
456                         return synthetic_reply_method_errno(m, r, NULL);
457
458                 if (sp) {
459                         Policy *policy;
460                         bool denied;
461
462                         policy = shared_policy_acquire(sp);
463                         denied = !policy_check_own(policy, ucred->uid, ucred->gid, name);
464                         shared_policy_release(sp, policy);
465                         if (denied)
466                                 return synthetic_reply_method_errno(m, -EPERM, NULL);
467                 }
468
469                 if ((flags & ~(BUS_NAME_ALLOW_REPLACEMENT|BUS_NAME_REPLACE_EXISTING|BUS_NAME_DO_NOT_QUEUE)) != 0)
470                         return synthetic_reply_method_errno(m, -EINVAL, NULL);
471
472                 param = 0;
473                 if (flags & BUS_NAME_ALLOW_REPLACEMENT)
474                         param |= SD_BUS_NAME_ALLOW_REPLACEMENT;
475                 if (flags & BUS_NAME_REPLACE_EXISTING)
476                         param |= SD_BUS_NAME_REPLACE_EXISTING;
477                 if (!(flags & BUS_NAME_DO_NOT_QUEUE))
478                         param |= SD_BUS_NAME_QUEUE;
479
480                 r = set_put_strdup(owned_names, name);
481                 if (r < 0)
482                         return synthetic_reply_method_errno(m, r, NULL);
483
484                 r = sd_bus_request_name(a, name, param);
485                 if (r < 0) {
486                         if (r == -EALREADY)
487                                 return synthetic_reply_method_return(m, "u", BUS_NAME_ALREADY_OWNER);
488
489                         set_remove(owned_names, (char*) name);
490
491                         if (r == -EEXIST)
492                                 return synthetic_reply_method_return(m, "u", BUS_NAME_EXISTS);
493                         return synthetic_reply_method_errno(m, r, NULL);
494                 }
495
496                 in_queue = (r == 0);
497
498                 if (in_queue)
499                         return synthetic_reply_method_return(m, "u", BUS_NAME_IN_QUEUE);
500
501                 return synthetic_reply_method_return(m, "u", BUS_NAME_PRIMARY_OWNER);
502
503         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "StartServiceByName")) {
504                 _cleanup_bus_message_unref_ sd_bus_message *msg = NULL;
505                 const char *name;
506                 uint32_t flags;
507
508                 if (!sd_bus_message_has_signature(m, "su"))
509                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
510
511                 r = sd_bus_message_read(m, "su", &name, &flags);
512                 if (r < 0)
513                         return synthetic_reply_method_errno(m, r, NULL);
514
515                 if (flags != 0)
516                         return synthetic_reply_method_errno(m, -EINVAL, NULL);
517
518                 r = sd_bus_get_name_creds(a, name, 0, NULL);
519                 if (r >= 0 || streq(name, "org.freedesktop.DBus"))
520                         return synthetic_reply_method_return(m, "u", BUS_START_REPLY_ALREADY_RUNNING);
521                 if (r != -ESRCH)
522                         return synthetic_reply_method_errno(m, r, NULL);
523
524                 r = sd_bus_message_new_method_call(
525                                 a,
526                                 &msg,
527                                 name,
528                                 "/",
529                                 "org.freedesktop.DBus.Peer",
530                                 "Ping");
531                 if (r < 0)
532                         return synthetic_reply_method_errno(m, r, NULL);
533
534                 r = sd_bus_send(a, msg, NULL);
535                 if (r < 0)
536                         return synthetic_reply_method_errno(m, r, NULL);
537
538                 return synthetic_reply_method_return(m, "u", BUS_START_REPLY_SUCCESS);
539
540         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "UpdateActivationEnvironment")) {
541                 _cleanup_bus_message_unref_ sd_bus_message *msg = NULL;
542                 _cleanup_strv_free_ char **args = NULL;
543
544                 if (!sd_bus_message_has_signature(m, "a{ss}"))
545                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
546
547                 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "{ss}");
548                 if (r < 0)
549                         return synthetic_reply_method_errno(m, r, NULL);
550
551                 while ((r = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY, "ss")) > 0) {
552                         _cleanup_free_ char *s = NULL;
553                         const char *key;
554                         const char *value;
555
556                         r = sd_bus_message_read(m, "ss", &key, &value);
557                         if (r < 0)
558                                 return synthetic_reply_method_errno(m, r, NULL);
559
560                         s = strjoin(key, "=", value, NULL);
561                         if (!s)
562                                 return synthetic_reply_method_errno(m, -ENOMEM, NULL);
563
564                         r  = strv_extend(&args, s);
565                         if (r < 0)
566                                 return synthetic_reply_method_errno(m, r, NULL);
567
568                         r = sd_bus_message_exit_container(m);
569                         if (r < 0)
570                                 return synthetic_reply_method_errno(m, r, NULL);
571                 }
572
573                 r = sd_bus_message_exit_container(m);
574                 if (r < 0)
575                         return synthetic_reply_method_errno(m, r, NULL);
576
577                 if (!args)
578                         return synthetic_reply_method_errno(m, -EINVAL, NULL);
579
580                 r = sd_bus_message_new_method_call(
581                                 a,
582                                 &msg,
583                                 "org.freedesktop.systemd1",
584                                 "/org/freedesktop/systemd1",
585                                 "org.freedesktop.systemd1.Manager",
586                                 "SetEnvironment");
587                 if (r < 0)
588                         return synthetic_reply_method_errno(m, r, NULL);
589
590                 r = sd_bus_message_append_strv(msg, args);
591                 if (r < 0)
592                         return synthetic_reply_method_errno(m, r, NULL);
593
594                 r = sd_bus_call(a, msg, 0, NULL, NULL);
595                 if (r < 0)
596                         return synthetic_reply_method_errno(m, r, NULL);
597
598                return synthetic_reply_method_return(m, NULL);
599
600         } else {
601                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
602
603                 r = sd_bus_error_setf(&error, SD_BUS_ERROR_UNKNOWN_METHOD, "Unknown method '%s'.", m->member);
604
605                 return synthetic_reply_method_errno(m, r, &error);
606         }
607 }