src/bus-proxyd/bus-proxyd.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/socket.h>
  25 #include <sys/un.h>
  26 #include <sys/types.h>
  27 #include <fcntl.h>
  28 #include <unistd.h>
  29 #include <string.h>
  30 #include <errno.h>
  31 #include <sys/poll.h>
  32 #include <stddef.h>
  33 #include <getopt.h>
  34
  35 #include "log.h"
  36 #include "util.h"
  37 #include "socket-util.h"
  38 #include "sd-daemon.h"
  39 #include "sd-bus.h"
  40 #include "bus-internal.h"
  41 #include "bus-message.h"
  42 #include "bus-util.h"
  43 #include "build.h"
  44 #include "strv.h"
  45 #include "def.h"
  46 #include "capability.h"
  47 #include "bus-control.h"
  48 #include "smack-util.h"
  49 #include "set.h"
  50 #include "bus-xml-policy.h"
  51
  52 static char *arg_address = NULL;
  53 static char *arg_command_line_buffer = NULL;
  54 static bool arg_drop_privileges = false;
  55 static char **arg_configuration = NULL;
  56
  57 static int help(void) {
  58
  59         printf("%s [OPTIONS...]\n\n"
  60                "Connect STDIO or a socket to a given bus address.\n\n"
  61                "  -h --help               Show this help\n"
  62                "     --version            Show package version\n"
  63                "     --drop-privileges    Drop privileges\n"
  64                "     --configuration=PATH Configuration file or directory\n"
  65                "     --machine=MACHINE    Connect to specified machine\n"
  66                "     --address=ADDRESS    Connect to the bus specified by ADDRESS\n"
  67                "                          (default: " DEFAULT_SYSTEM_BUS_ADDRESS ")\n",
  68                program_invocation_short_name);
  69
  70         return 0;
  71 }
  72
  73 static int parse_argv(int argc, char *argv[]) {
  74
  75         enum {
  76                 ARG_VERSION = 0x100,
  77                 ARG_ADDRESS,
  78                 ARG_DROP_PRIVILEGES,
  79                 ARG_CONFIGURATION,
  80                 ARG_MACHINE,
  81         };
  82
  83         static const struct option options[] = {
  84                 { "help",            no_argument,       NULL, 'h'                 },
  85                 { "version",         no_argument,       NULL, ARG_VERSION         },
  86                 { "address",         required_argument, NULL, ARG_ADDRESS         },
  87                 { "drop-privileges", no_argument,       NULL, ARG_DROP_PRIVILEGES },
  88                 { "configuration",   required_argument, NULL, ARG_CONFIGURATION   },
  89                 { "machine",         required_argument, NULL, ARG_MACHINE         },
  90                 {},
  91         };
  92
  93         int c, r;
  94
  95         assert(argc >= 0);
  96         assert(argv);
  97
  98         while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
  99
 100                 switch (c) {
 101
 102                 case 'h':
 103                         help();
 104                         return 0;
 105
 106                 case ARG_VERSION:
 107                         puts(PACKAGE_STRING);
 108                         puts(SYSTEMD_FEATURES);
 109                         return 0;
 110
 111                 case ARG_ADDRESS: {
 112                         char *a;
 113
 114                         a = strdup(optarg);
 115                         if (!a)
 116                                 return log_oom();
 117
 118                         free(arg_address);
 119                         arg_address = a;
 120                         break;
 121                 }
 122
 123                 case ARG_DROP_PRIVILEGES:
 124                         arg_drop_privileges = true;
 125                         break;
 126
 127                 case ARG_CONFIGURATION:
 128                         r = strv_extend(&arg_configuration, optarg);
 129                         if (r < 0)
 130                                 return log_oom();
 131                         break;
 132
 133                 case ARG_MACHINE: {
 134                         _cleanup_free_ char *e = NULL;
 135                         char *a;
 136
 137                         e = bus_address_escape(optarg);
 138                         if (!e)
 139                                 return log_oom();
 140
 141 #ifdef ENABLE_KDBUS
 142                         a = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
 143 #else
 144                         a = strjoin("x-machine-unix:machine=", e, NULL);
 145 #endif
 146                         if (!a)
 147                                 return log_oom();
 148
 149                         free(arg_address);
 150                         arg_address = a;
 151
 152                         break;
 153                 }
 154
 155                 case '?':
 156                         return -EINVAL;
 157
 158                 default:
 159                         assert_not_reached("Unhandled option");
 160                 }
 161
 162         /* If the first command line argument is only "x" characters
 163          * we'll write who we are talking to into it, so that "ps" is
 164          * explanatory */
 165         arg_command_line_buffer = argv[optind];
 166         if (argc > optind + 1 || (arg_command_line_buffer && !in_charset(arg_command_line_buffer, "x"))) {
 167                 log_error("Too many arguments");
 168                 return -EINVAL;
 169         }
 170
 171         if (!arg_address) {
 172                 arg_address = strdup(DEFAULT_SYSTEM_BUS_ADDRESS);
 173                 if (!arg_address)
 174                         return log_oom();
 175         }
 176
 177         return 1;
 178 }
 179
 180 static int rename_service(sd_bus *a, sd_bus *b) {
 181         _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
 182         _cleanup_free_ char *p = NULL, *name = NULL;
 183         const char *comm;
 184         char **cmdline;
 185         uid_t uid;
 186         pid_t pid;
 187         int r;
 188
 189         assert(a);
 190         assert(b);
 191
 192         r = sd_bus_get_owner_creds(b, SD_BUS_CREDS_UID|SD_BUS_CREDS_PID|SD_BUS_CREDS_CMDLINE|SD_BUS_CREDS_COMM|SD_BUS_CREDS_AUGMENT, &creds);
 193         if (r < 0)
 194                 return r;
 195
 196         r = sd_bus_creds_get_uid(creds, &uid);
 197         if (r < 0)
 198                 return r;
 199
 200         r = sd_bus_creds_get_pid(creds, &pid);
 201         if (r < 0)
 202                 return r;
 203
 204         r = sd_bus_creds_get_cmdline(creds, &cmdline);
 205         if (r < 0)
 206                 return r;
 207
 208         r = sd_bus_creds_get_comm(creds, &comm);
 209         if (r < 0)
 210                 return r;
 211
 212         name = uid_to_name(uid);
 213         if (!name)
 214                 return -ENOMEM;
 215
 216         p = strv_join(cmdline, " ");
 217         if (!p)
 218                 return -ENOMEM;
 219
 220         /* The status string gets the full command line ... */
 221         sd_notifyf(false,
 222                    "STATUS=Processing requests from client PID "PID_FMT" (%s); UID "UID_FMT" (%s)",
 223                    pid, p,
 224                    uid, name);
 225
 226         /* ... and the argv line only the short comm */
 227         if (arg_command_line_buffer) {
 228                 size_t m, w;
 229
 230                 m = strlen(arg_command_line_buffer);
 231                 w = snprintf(arg_command_line_buffer, m,
 232                              "[PID "PID_FMT"/%s; UID "UID_FMT"/%s]",
 233                              pid, comm,
 234                              uid, name);
 235
 236                 if (m > w)
 237                         memzero(arg_command_line_buffer + w, m - w);
 238         }
 239
 240         log_debug("Running on behalf of PID "PID_FMT" (%s), UID "UID_FMT" (%s), %s",
 241                   pid, p,
 242                   uid, name,
 243                   a->unique_name);
 244
 245         return 0;
 246 }
 247
 248 static int synthesize_name_acquired(sd_bus *a, sd_bus *b, sd_bus_message *m) {
 249         _cleanup_bus_message_unref_ sd_bus_message *n = NULL;
 250         const char *name, *old_owner, *new_owner;
 251         int r;
 252
 253         assert(a);
 254         assert(b);
 255         assert(m);
 256
 257         /* If we get NameOwnerChanged for our own name, we need to
 258          * synthesize NameLost/NameAcquired, since socket clients need
 259          * that, even though it is obsoleted on kdbus */
 260
 261         if (!a->is_kernel)
 262                 return 0;
 263
 264         if (!sd_bus_message_is_signal(m, "org.freedesktop.DBus", "NameOwnerChanged") ||
 265             !streq_ptr(m->path, "/org/freedesktop/DBus") ||
 266             !streq_ptr(m->sender, "org.freedesktop.DBus"))
 267                 return 0;
 268
 269         r = sd_bus_message_read(m, "sss", &name, &old_owner, &new_owner);
 270         if (r < 0)
 271                 return r;
 272
 273         r = sd_bus_message_rewind(m, true);
 274         if (r < 0)
 275                 return r;
 276
 277         if (streq(old_owner, a->unique_name)) {
 278
 279                 r = sd_bus_message_new_signal(
 280                                 b,
 281                                 &n,
 282                                 "/org/freedesktop/DBus",
 283                                 "org.freedesktop.DBus",
 284                                 "NameLost");
 285
 286         } else if (streq(new_owner, a->unique_name)) {
 287
 288                 r = sd_bus_message_new_signal(
 289                                 b,
 290                                 &n,
 291                                 "/org/freedesktop/DBus",
 292                                 "org.freedesktop.DBus",
 293                                 "NameAcquired");
 294         } else
 295                 return 0;
 296
 297         if (r < 0)
 298                 return r;
 299
 300         r = sd_bus_message_append(n, "s", name);
 301         if (r < 0)
 302                 return r;
 303
 304         r = bus_message_append_sender(n, "org.freedesktop.DBus");
 305         if (r < 0)
 306                 return r;
 307
 308         r = bus_seal_synthetic_message(b, n);
 309         if (r < 0)
 310                 return r;
 311
 312         return sd_bus_send(b, n, NULL);
 313 }
 314
 315 static int synthetic_driver_send(sd_bus *b, sd_bus_message *m) {
 316         int r;
 317
 318         assert(b);
 319         assert(m);
 320
 321         r = bus_message_append_sender(m, "org.freedesktop.DBus");
 322         if (r < 0)
 323                 return r;
 324
 325         r = bus_seal_synthetic_message(b, m);
 326         if (r < 0)
 327                 return r;
 328
 329         return sd_bus_send(b, m, NULL);
 330 }
 331
 332 static int synthetic_reply_method_error(sd_bus_message *call, const sd_bus_error *e) {
 333         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 334         int r;
 335
 336         assert(call);
 337
 338         if (call->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
 339                 return 0;
 340
 341         r = sd_bus_message_new_method_error(call, &m, e);
 342         if (r < 0)
 343                 return r;
 344
 345         return synthetic_driver_send(call->bus, m);
 346 }
 347
 348 static int synthetic_reply_method_errorf(sd_bus_message *call, const char *name, const char *format, ...) {
 349         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 350         va_list ap;
 351
 352         va_start(ap, format);
 353         bus_error_setfv(&error, name, format, ap);
 354         va_end(ap);
 355
 356         return synthetic_reply_method_error(call, &error);
 357 }
 358
 359 static int synthetic_reply_method_errno(sd_bus_message *call, int error, const sd_bus_error *p) {
 360
 361         _cleanup_bus_error_free_ sd_bus_error berror = SD_BUS_ERROR_NULL;
 362
 363         assert(call);
 364
 365         if (call->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
 366                 return 0;
 367
 368         if (sd_bus_error_is_set(p))
 369                 return synthetic_reply_method_error(call, p);
 370
 371         sd_bus_error_set_errno(&berror, error);
 372
 373         return synthetic_reply_method_error(call, &berror);
 374 }
 375
 376 static int synthetic_reply_method_return(sd_bus_message *call, const char *types, ...) {
 377         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 378         int r;
 379
 380         assert(call);
 381
 382         if (call->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
 383                 return 0;
 384
 385         r = sd_bus_message_new_method_return(call, &m);
 386         if (r < 0)
 387                 return r;
 388
 389         if (!isempty(types)) {
 390                 va_list ap;
 391
 392                 va_start(ap, types);
 393                 r = bus_message_append_ap(m, types, ap);
 394                 va_end(ap);
 395                 if (r < 0)
 396                         return r;
 397         }
 398
 399         return synthetic_driver_send(call->bus, m);
 400 }
 401
 402 static int synthetic_reply_return_strv(sd_bus_message *call, char **l) {
 403         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 404         int r;
 405
 406         assert(call);
 407
 408         if (call->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
 409                 return 0;
 410
 411         r = sd_bus_message_new_method_return(call, &m);
 412         if (r < 0)
 413                 return synthetic_reply_method_errno(call, r, NULL);
 414
 415         r = sd_bus_message_append_strv(m, l);
 416         if (r < 0)
 417                 return synthetic_reply_method_errno(call, r, NULL);
 418
 419         return synthetic_driver_send(call->bus, m);
 420 }
 421
 422 static int get_creds_by_name(sd_bus *bus, const char *name, uint64_t mask, sd_bus_creds **_creds, sd_bus_error *error) {
 423         _cleanup_bus_creds_unref_ sd_bus_creds *c = NULL;
 424         int r;
 425
 426         assert(bus);
 427         assert(name);
 428         assert(_creds);
 429
 430         r = sd_bus_get_name_creds(bus, name, mask, &c);
 431         if (r == -ESRCH || r == -ENXIO)
 432                 return sd_bus_error_setf(error, SD_BUS_ERROR_NAME_HAS_NO_OWNER, "Name %s is currently not owned by anyone.", name);
 433         if (r < 0)
 434                 return r;
 435
 436         if ((c->mask & mask) != mask)
 437                 return -ENOTSUP;
 438
 439         *_creds = c;
 440         c = NULL;
 441
 442         return 0;
 443 }
 444
 445 static int get_creds_by_message(sd_bus *bus, sd_bus_message *m, uint64_t mask, sd_bus_creds **_creds, sd_bus_error *error) {
 446         const char *name;
 447         int r;
 448
 449         assert(bus);
 450         assert(m);
 451         assert(_creds);
 452
 453         r = sd_bus_message_read(m, "s", &name);
 454         if (r < 0)
 455                 return r;
 456
 457         return get_creds_by_name(bus, name, mask, _creds, error);
 458 }
 459
 460 static int process_driver(sd_bus *a, sd_bus *b, sd_bus_message *m, Policy *policy, const struct ucred *ucred, Set *owned_names) {
 461         int r;
 462
 463         assert(a);
 464         assert(b);
 465         assert(m);
 466
 467         if (!a->is_kernel)
 468                 return 0;
 469
 470         if (!streq_ptr(sd_bus_message_get_destination(m), "org.freedesktop.DBus"))
 471                 return 0;
 472
 473         /* The "Hello()" call is is handled in process_hello() */
 474
 475         if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
 476
 477                 if (!sd_bus_message_has_signature(m, ""))
 478                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
 479
 480                 return synthetic_reply_method_return(m, "s",
 481                         "<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\" "
 482                           "\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"
 483                         "<node>\n"
 484                         " <interface name=\"org.freedesktop.DBus.Introspectable\">\n"
 485                         "  <method name=\"Introspect\">\n"
 486                         "   <arg name=\"data\" type=\"s\" direction=\"out\"/>\n"
 487                         "  </method>\n"
 488                         " </interface>\n"
 489                         " <interface name=\"org.freedesktop.DBus\">\n"
 490                         "  <method name=\"AddMatch\">\n"
 491                         "   <arg type=\"s\" direction=\"in\"/>\n"
 492                         "  </method>\n"
 493                         "  <method name=\"RemoveMatch\">\n"
 494                         "   <arg type=\"s\" direction=\"in\"/>\n"
 495                         "  </method>\n"
 496                         "  <method name=\"GetConnectionSELinuxSecurityContext\">\n"
 497                         "   <arg type=\"s\" direction=\"in\"/>\n"
 498                         "   <arg type=\"ay\" direction=\"out\"/>\n"
 499                         "  </method>\n"
 500                         "  <method name=\"GetConnectionUnixProcessID\">\n"
 501                         "   <arg type=\"s\" direction=\"in\"/>\n"
 502                         "   <arg type=\"u\" direction=\"out\"/>\n"
 503                         "  </method>\n"
 504                         "  <method name=\"GetConnectionUnixUser\">\n"
 505                         "   <arg type=\"s\" direction=\"in\"/>\n"
 506                         "   <arg type=\"u\" direction=\"out\"/>\n"
 507                         "  </method>\n"
 508                         "  <method name=\"GetId\">\n"
 509                         "   <arg type=\"s\" direction=\"out\"/>\n"
 510                         "  </method>\n"
 511                         "  <method name=\"GetNameOwner\">\n"
 512                         "   <arg type=\"s\" direction=\"in\"/>\n"
 513                         "   <arg type=\"s\" direction=\"out\"/>\n"
 514                         "  </method>\n"
 515                         "  <method name=\"Hello\">\n"
 516                         "   <arg type=\"s\" direction=\"out\"/>\n"
 517                         "  </method>\n"
 518                         "  <method name=\"ListActivatableNames\">\n"
 519                         "   <arg type=\"as\" direction=\"out\"/>\n"
 520                         "  </method>\n"
 521                         "  <method name=\"ListNames\">\n"
 522                         "   <arg type=\"as\" direction=\"out\"/>\n"
 523                         "  </method>\n"
 524                         "  <method name=\"ListQueuedOwners\">\n"
 525                         "   <arg type=\"s\" direction=\"in\"/>\n"
 526                         "   <arg type=\"as\" direction=\"out\"/>\n"
 527                         "  </method>\n"
 528                         "  <method name=\"NameHasOwner\">\n"
 529                         "   <arg type=\"s\" direction=\"in\"/>\n"
 530                         "   <arg type=\"b\" direction=\"out\"/>\n"
 531                         "  </method>\n"
 532                         "  <method name=\"ReleaseName\">\n"
 533                         "   <arg type=\"s\" direction=\"in\"/>\n"
 534                         "   <arg type=\"u\" direction=\"out\"/>\n"
 535                         "  </method>\n"
 536                         "  <method name=\"ReloadConfig\">\n"
 537                         "  </method>\n"
 538                         "  <method name=\"RequestName\">\n"
 539                         "   <arg type=\"s\" direction=\"in\"/>\n"
 540                         "   <arg type=\"u\" direction=\"in\"/>\n"
 541                         "   <arg type=\"u\" direction=\"out\"/>\n"
 542                         "  </method>\n"
 543                         "  <method name=\"StartServiceByName\">\n"
 544                         "   <arg type=\"s\" direction=\"in\"/>\n"
 545                         "   <arg type=\"u\" direction=\"in\"/>\n"
 546                         "   <arg type=\"u\" direction=\"out\"/>\n"
 547                         "  </method>\n"
 548                         "  <method name=\"UpdateActivationEnvironment\">\n"
 549                         "   <arg type=\"a{ss}\" direction=\"in\"/>\n"
 550                         "  </method>\n"
 551                         "  <signal name=\"NameAcquired\">\n"
 552                         "   <arg type=\"s\"/>\n"
 553                         "  </signal>\n"
 554                         "  <signal name=\"NameLost\">\n"
 555                         "   <arg type=\"s\"/>\n"
 556                         "  </signal>\n"
 557                         "  <signal name=\"NameOwnerChanged\">\n"
 558                         "   <arg type=\"s\"/>\n"
 559                         "   <arg type=\"s\"/>\n"
 560                         "   <arg type=\"s\"/>\n"
 561                         "  </signal>\n"
 562                         " </interface>\n"
 563                         "</node>\n");
 564
 565         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "AddMatch")) {
 566                 const char *match;
 567
 568                 if (!sd_bus_message_has_signature(m, "s"))
 569                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
 570
 571                 r = sd_bus_message_read(m, "s", &match);
 572                 if (r < 0)
 573                         return synthetic_reply_method_errno(m, r, NULL);
 574
 575                 r = sd_bus_add_match(a, NULL, match, NULL, NULL);
 576                 if (r < 0)
 577                         return synthetic_reply_method_errno(m, r, NULL);
 578
 579                 return synthetic_reply_method_return(m, NULL);
 580
 581         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "RemoveMatch")) {
 582                 const char *match;
 583
 584                 if (!sd_bus_message_has_signature(m, "s"))
 585                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
 586
 587                 r = sd_bus_message_read(m, "s", &match);
 588                 if (r < 0)
 589                         return synthetic_reply_method_errno(m, r, NULL);
 590
 591                 r = bus_remove_match_by_string(a, match, NULL, NULL);
 592                 if (r == 0)
 593                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_MATCH_RULE_NOT_FOUND, "Match rule not found"));
 594                 if (r < 0)
 595                         return synthetic_reply_method_errno(m, r, NULL);
 596
 597                 return synthetic_reply_method_return(m, NULL);
 598
 599         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetConnectionSELinuxSecurityContext")) {
 600                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
 601                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 602
 603                 if (!sd_bus_message_has_signature(m, "s"))
 604                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
 605
 606                 r = get_creds_by_message(a, m, SD_BUS_CREDS_SELINUX_CONTEXT, &creds, &error);
 607                 if (r < 0)
 608                         return synthetic_reply_method_errno(m, r, &error);
 609
 610                 return synthetic_reply_method_return(m, "y", creds->label, strlen(creds->label));
 611
 612         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetConnectionUnixProcessID")) {
 613                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
 614                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 615
 616                 if (!sd_bus_message_has_signature(m, "s"))
 617                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
 618
 619                 r = get_creds_by_message(a, m, SD_BUS_CREDS_PID, &creds, &error);
 620                 if (r < 0)
 621                         return synthetic_reply_method_errno(m, r, &error);
 622
 623                 return synthetic_reply_method_return(m, "u", (uint32_t) creds->pid);
 624
 625         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetConnectionUnixUser")) {
 626                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
 627                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 628
 629                 if (!sd_bus_message_has_signature(m, "s"))
 630                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
 631
 632                 r = get_creds_by_message(a, m, SD_BUS_CREDS_UID, &creds, &error);
 633                 if (r < 0)
 634                         return synthetic_reply_method_errno(m, r, &error);
 635
 636                 return synthetic_reply_method_return(m, "u", (uint32_t) creds->uid);
 637
 638         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetId")) {
 639                 sd_id128_t server_id;
 640                 char buf[SD_ID128_STRING_MAX];
 641
 642                 if (!sd_bus_message_has_signature(m, ""))
 643                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
 644
 645                 r = sd_bus_get_bus_id(a, &server_id);
 646                 if (r < 0)
 647                         return synthetic_reply_method_errno(m, r, NULL);
 648
 649                 return synthetic_reply_method_return(m, "s", sd_id128_to_string(server_id, buf));
 650
 651         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetNameOwner")) {
 652                 const char *name;
 653                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
 654                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 655
 656                 if (!sd_bus_message_has_signature(m, "s"))
 657                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
 658
 659                 r = sd_bus_message_read(m, "s", &name);
 660                 if (r < 0)
 661                         return synthetic_reply_method_errno(m, r, NULL);
 662
 663                 if (streq(name, "org.freedesktop.DBus"))
 664                         return synthetic_reply_method_return(m, "s", "org.freedesktop.DBus");
 665
 666                 r = get_creds_by_name(a, name, SD_BUS_CREDS_UNIQUE_NAME, &creds, &error);
 667                 if (r < 0)
 668                         return synthetic_reply_method_errno(m, r, &error);
 669
 670                 return synthetic_reply_method_return(m, "s", creds->unique_name);
 671
 672         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ListActivatableNames")) {
 673                 _cleanup_strv_free_ char **names = NULL;
 674
 675                 if (!sd_bus_message_has_signature(m, ""))
 676                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
 677
 678                 r = sd_bus_list_names(a, NULL, &names);
 679                 if (r < 0)
 680                         return synthetic_reply_method_errno(m, r, NULL);
 681
 682                 /* Let's sort the names list to make it stable */
 683                 strv_sort(names);
 684
 685                 return synthetic_reply_return_strv(m, names);
 686
 687         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ListNames")) {
 688                 _cleanup_strv_free_ char **names = NULL;
 689
 690                 if (!sd_bus_message_has_signature(m, ""))
 691                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
 692
 693                 r = sd_bus_list_names(a, &names, NULL);
 694                 if (r < 0)
 695                         return synthetic_reply_method_errno(m, r, NULL);
 696
 697                 r = strv_extend(&names, "org.freedesktop.DBus");
 698                 if (r < 0)
 699                         return synthetic_reply_method_errno(m, r, NULL);
 700
 701                 /* Let's sort the names list to make it stable */
 702                 strv_sort(names);
 703
 704                 return synthetic_reply_return_strv(m, names);
 705
 706         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ListQueuedOwners")) {
 707                 struct kdbus_cmd_name_list cmd = {};
 708                 struct kdbus_name_list *name_list;
 709                 struct kdbus_name_info *name;
 710                 _cleanup_strv_free_ char **owners = NULL;
 711                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 712                 char *arg0;
 713                 int err = 0;
 714
 715                 if (!sd_bus_message_has_signature(m, "s"))
 716                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
 717
 718                 r = sd_bus_message_read(m, "s", &arg0);
 719                 if (r < 0)
 720                         return synthetic_reply_method_errno(m, r, NULL);
 721
 722                 r = sd_bus_get_name_creds(a, arg0, 0, NULL);
 723                 if (r == -ESRCH || r == -ENXIO) {
 724                         sd_bus_error_setf(&error, SD_BUS_ERROR_NAME_HAS_NO_OWNER, "Could not get owners of name '%s': no such name.", arg0);
 725                         return synthetic_reply_method_errno(m, r, &error);
 726                 }
 727                 if (r < 0)
 728                         return synthetic_reply_method_errno(m, r, NULL);
 729
 730                 cmd.flags = KDBUS_NAME_LIST_QUEUED;
 731                 r = ioctl(a->input_fd, KDBUS_CMD_NAME_LIST, &cmd);
 732                 if (r < 0)
 733                         return synthetic_reply_method_errno(m, -errno, NULL);
 734
 735                 name_list = (struct kdbus_name_list *) ((uint8_t *) a->kdbus_buffer + cmd.offset);
 736
 737                 KDBUS_ITEM_FOREACH(name, name_list, names) {
 738                         const char *entry_name = NULL;
 739                         struct kdbus_item *item;
 740                         char *n;
 741
 742                         KDBUS_ITEM_FOREACH(item, name, items)
 743                                 if (item->type == KDBUS_ITEM_OWNED_NAME)
 744                                         entry_name = item->name.name;
 745
 746                         if (!streq_ptr(entry_name, arg0))
 747                                 continue;
 748
 749                         if (asprintf(&n, ":1.%llu", (unsigned long long) name->owner_id) < 0) {
 750                                 err  = -ENOMEM;
 751                                 break;
 752                         }
 753
 754                         r = strv_consume(&owners, n);
 755                         if (r < 0) {
 756                                 err = r;
 757                                 break;
 758                         }
 759                 }
 760
 761                 r = bus_kernel_cmd_free(a, cmd.offset);
 762                 if (r < 0)
 763                         return synthetic_reply_method_errno(m, r, NULL);
 764
 765                 if (err < 0)
 766                         return synthetic_reply_method_errno(m, err, NULL);
 767
 768                 return synthetic_reply_return_strv(m, owners);
 769
 770         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "NameHasOwner")) {
 771                 const char *name;
 772
 773                 if (!sd_bus_message_has_signature(m, "s"))
 774                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
 775
 776                 r = sd_bus_message_read(m, "s", &name);
 777                 if (r < 0)
 778                         return synthetic_reply_method_errno(m, r, NULL);
 779
 780                 if (streq(name, "org.freedesktop.DBus"))
 781                         return synthetic_reply_method_return(m, "b", true);
 782
 783                 r = sd_bus_get_name_creds(a, name, 0, NULL);
 784                 if (r < 0 && r != -ESRCH && r != -ENXIO)
 785                         return synthetic_reply_method_errno(m, r, NULL);
 786
 787                 return synthetic_reply_method_return(m, "b", r >= 0);
 788
 789         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ReleaseName")) {
 790                 const char *name;
 791
 792                 if (!sd_bus_message_has_signature(m, "s"))
 793                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
 794
 795                 r = sd_bus_message_read(m, "s", &name);
 796                 if (r < 0)
 797                         return synthetic_reply_method_errno(m, r, NULL);
 798
 799                 r = sd_bus_release_name(a, name);
 800                 if (r < 0) {
 801                         if (r == -ESRCH)
 802                                 return synthetic_reply_method_return(m, "u", BUS_NAME_NON_EXISTENT);
 803                         if (r == -EADDRINUSE)
 804                                 return synthetic_reply_method_return(m, "u", BUS_NAME_NOT_OWNER);
 805
 806                         return synthetic_reply_method_errno(m, r, NULL);
 807                 }
 808
 809                 set_remove(owned_names, (char*) name);
 810
 811                 return synthetic_reply_method_return(m, "u", BUS_NAME_RELEASED);
 812
 813         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ReloadConfig")) {
 814                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 815
 816                 if (!sd_bus_message_has_signature(m, ""))
 817                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
 818
 819                 r = sd_bus_error_setf(&error, SD_BUS_ERROR_NOT_SUPPORTED, "%s() is not supported", sd_bus_message_get_member(m));
 820
 821                 return synthetic_reply_method_errno(m, r, &error);
 822
 823         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "RequestName")) {
 824                 const char *name;
 825                 uint32_t flags, param;
 826                 bool in_queue;
 827
 828                 if (!sd_bus_message_has_signature(m, "su"))
 829                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
 830
 831                 r = sd_bus_message_read(m, "su", &name, &flags);
 832                 if (r < 0)
 833                         return synthetic_reply_method_errno(m, r, NULL);
 834
 835                 if (policy && !policy_check_own(policy, ucred->uid, ucred->gid, name))
 836                         return synthetic_reply_method_errno(m, -EPERM, NULL);
 837
 838                 if ((flags & ~(BUS_NAME_ALLOW_REPLACEMENT|BUS_NAME_REPLACE_EXISTING|BUS_NAME_DO_NOT_QUEUE)) != 0)
 839                         return synthetic_reply_method_errno(m, -EINVAL, NULL);
 840
 841                 param = 0;
 842                 if (flags & BUS_NAME_ALLOW_REPLACEMENT)
 843                         param |= SD_BUS_NAME_ALLOW_REPLACEMENT;
 844                 if (flags & BUS_NAME_REPLACE_EXISTING)
 845                         param |= SD_BUS_NAME_REPLACE_EXISTING;
 846                 if (!(flags & BUS_NAME_DO_NOT_QUEUE))
 847                         param |= SD_BUS_NAME_QUEUE;
 848
 849                 r = set_put_strdup(owned_names, name);
 850                 if (r < 0)
 851                         return synthetic_reply_method_errno(m, r, NULL);
 852
 853                 r = sd_bus_request_name(a, name, param);
 854                 if (r < 0) {
 855                         if (r == -EALREADY)
 856                                 return synthetic_reply_method_return(m, "u", BUS_NAME_ALREADY_OWNER);
 857
 858                         set_remove(owned_names, (char*) name);
 859
 860                         if (r == -EEXIST)
 861                                 return synthetic_reply_method_return(m, "u", BUS_NAME_EXISTS);
 862                         return synthetic_reply_method_errno(m, r, NULL);
 863                 }
 864
 865                 in_queue = (r == 0);
 866
 867                 if (in_queue)
 868                         return synthetic_reply_method_return(m, "u", BUS_NAME_IN_QUEUE);
 869
 870                 return synthetic_reply_method_return(m, "u", BUS_NAME_PRIMARY_OWNER);
 871
 872         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "StartServiceByName")) {
 873                 _cleanup_bus_message_unref_ sd_bus_message *msg = NULL;
 874                 const char *name;
 875                 uint32_t flags;
 876
 877                 if (!sd_bus_message_has_signature(m, "su"))
 878                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
 879
 880                 r = sd_bus_message_read(m, "su", &name, &flags);
 881                 if (r < 0)
 882                         return synthetic_reply_method_errno(m, r, NULL);
 883
 884                 if (flags != 0)
 885                         return synthetic_reply_method_errno(m, -EINVAL, NULL);
 886
 887                 r = sd_bus_get_name_creds(a, name, 0, NULL);
 888                 if (r >= 0 || streq(name, "org.freedesktop.DBus"))
 889                         return synthetic_reply_method_return(m, "u", BUS_START_REPLY_ALREADY_RUNNING);
 890                 if (r != -ESRCH)
 891                         return synthetic_reply_method_errno(m, r, NULL);
 892
 893                 r = sd_bus_message_new_method_call(
 894                                 a,
 895                                 &msg,
 896                                 name,
 897                                 "/",
 898                                 "org.freedesktop.DBus.Peer",
 899                                 "Ping");
 900                 if (r < 0)
 901                         return synthetic_reply_method_errno(m, r, NULL);
 902
 903                 r = sd_bus_send(a, msg, NULL);
 904                 if (r < 0)
 905                         return synthetic_reply_method_errno(m, r, NULL);
 906
 907                 return synthetic_reply_method_return(m, "u", BUS_START_REPLY_SUCCESS);
 908
 909         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "UpdateActivationEnvironment")) {
 910                 _cleanup_bus_message_unref_ sd_bus_message *msg = NULL;
 911                 _cleanup_strv_free_ char **args = NULL;
 912
 913                 if (!sd_bus_message_has_signature(m, "a{ss}"))
 914                         return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid parameters"));
 915
 916                 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "{ss}");
 917                 if (r < 0)
 918                         return synthetic_reply_method_errno(m, r, NULL);
 919
 920                 while ((r = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY, "ss")) > 0) {
 921                         _cleanup_free_ char *s = NULL;
 922                         const char *key;
 923                         const char *value;
 924
 925                         r = sd_bus_message_read(m, "ss", &key, &value);
 926                         if (r < 0)
 927                                 return synthetic_reply_method_errno(m, r, NULL);
 928
 929                         s = strjoin(key, "=", value, NULL);
 930                         if (!s)
 931                                 return synthetic_reply_method_errno(m, -ENOMEM, NULL);
 932
 933                         r  = strv_extend(&args, s);
 934                         if (r < 0)
 935                                 return synthetic_reply_method_errno(m, r, NULL);
 936
 937                         r = sd_bus_message_exit_container(m);
 938                         if (r < 0)
 939                                 return synthetic_reply_method_errno(m, r, NULL);
 940                 }
 941
 942                 r = sd_bus_message_exit_container(m);
 943                 if (r < 0)
 944                         return synthetic_reply_method_errno(m, r, NULL);
 945
 946                 if (!args)
 947                         return synthetic_reply_method_errno(m, -EINVAL, NULL);
 948
 949                 r = sd_bus_message_new_method_call(
 950                                 a,
 951                                 &msg,
 952                                 "org.freedesktop.systemd1",
 953                                 "/org/freedesktop/systemd1",
 954                                 "org.freedesktop.systemd1.Manager",
 955                                 "SetEnvironment");
 956                 if (r < 0)
 957                         return synthetic_reply_method_errno(m, r, NULL);
 958
 959                 r = sd_bus_message_append_strv(msg, args);
 960                 if (r < 0)
 961                         return synthetic_reply_method_errno(m, r, NULL);
 962
 963                 r = sd_bus_call(a, msg, 0, NULL, NULL);
 964                 if (r < 0)
 965                         return synthetic_reply_method_errno(m, r, NULL);
 966
 967                return synthetic_reply_method_return(m, NULL);
 968
 969         } else {
 970                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 971
 972                 r = sd_bus_error_setf(&error, SD_BUS_ERROR_UNKNOWN_METHOD, "Unknown method '%s'.", m->member);
 973
 974                 return synthetic_reply_method_errno(m, r, &error);
 975         }
 976 }
 977
 978 static int handle_policy_error(sd_bus_message *m, int r) {
 979         if (r == -ESRCH || r == -ENXIO)
 980                 return synthetic_reply_method_errorf(m, SD_BUS_ERROR_NAME_HAS_NO_OWNER, "Name %s is currently not owned by anyone.", m->destination);
 981
 982         return r;
 983 }
 984
 985 static int process_policy(sd_bus *from, sd_bus *to, sd_bus_message *m, Policy *policy, const struct ucred *our_ucred, Set *owned_names) {
 986         int r;
 987
 988         assert(from);
 989         assert(to);
 990         assert(m);
 991
 992         if (!policy)
 993                 return 0;
 994
 995         /*
 996          * dbus-1 distinguishes expected and non-expected replies by tracking
 997          * method-calls and timeouts. By default, DENY rules are *NEVER* applied
 998          * on expected replies, unless explicitly specified. But we dont track
 999          * method-calls, thus, we cannot know whether a reply is expected.
1000          * Fortunately, the kdbus forbids non-expected replies, so we can safely
1001          * ignore any policy on those and let the kernel deal with it.
1002          *
1003          * TODO: To be correct, we should only ignore policy-tags that are
1004          * applied on non-expected replies. However, so far we don't parse those
1005          * tags so we let everything pass. I haven't seen a DENY policy tag on
1006          * expected-replies, ever, so don't bother..
1007          */
1008         if (m->reply_cookie > 0)
1009                 return 0;
1010
1011         if (from->is_kernel) {
1012                 uid_t sender_uid = UID_INVALID;
1013                 gid_t sender_gid = GID_INVALID;
1014                 char **sender_names = NULL;
1015                 bool granted = false;
1016
1017                 /* Driver messages are always OK */
1018                 if (streq_ptr(m->sender, "org.freedesktop.DBus"))
1019                         return 0;
1020
1021                 /* The message came from the kernel, and is sent to our legacy client. */
1022                 sd_bus_creds_get_well_known_names(&m->creds, &sender_names);
1023
1024                 (void) sd_bus_creds_get_uid(&m->creds, &sender_uid);
1025                 (void) sd_bus_creds_get_gid(&m->creds, &sender_gid);
1026
1027                 if (sender_uid == UID_INVALID || sender_gid == GID_INVALID) {
1028                         _cleanup_bus_creds_unref_ sd_bus_creds *sender_creds = NULL;
1029
1030                         /* If the message came from another legacy
1031                          * client, then the message creds will be
1032                          * missing, simply because on legacy clients
1033                          * per-message creds were unknown. In this
1034                          * case, query the creds of the peer
1035                          * instead. */
1036
1037                         r = bus_get_name_creds_kdbus(from, m->sender, SD_BUS_CREDS_UID|SD_BUS_CREDS_GID, true, &sender_creds);
1038                         if (r < 0)
1039                                 return handle_policy_error(m, r);
1040
1041                         (void) sd_bus_creds_get_uid(sender_creds, &sender_uid);
1042                         (void) sd_bus_creds_get_gid(sender_creds, &sender_gid);
1043                 }
1044
1045                 /* First check whether the sender can send the message to our name */
1046                 if (set_isempty(owned_names)) {
1047                         if (policy_check_send(policy, sender_uid, sender_gid, m->header->type, NULL, m->path, m->interface, m->member))
1048                                 granted = true;
1049                 } else {
1050                         Iterator i;
1051                         char *n;
1052
1053                         SET_FOREACH(n, owned_names, i)
1054                                 if (policy_check_send(policy, sender_uid, sender_gid, m->header->type, n, m->path, m->interface, m->member)) {
1055                                         granted = true;
1056                                         break;
1057                                 }
1058                 }
1059
1060                 if (granted) {
1061                         /* Then check whether us (the recipient) can receive from the sender's name */
1062                         if (strv_isempty(sender_names)) {
1063                                 if (policy_check_recv(policy, our_ucred->uid, our_ucred->gid, m->header->type, NULL, m->path, m->interface, m->member))
1064                                         return 0;
1065                         } else {
1066                                 char **n;
1067
1068                                 STRV_FOREACH(n, sender_names) {
1069                                         if (policy_check_recv(policy, our_ucred->uid, our_ucred->gid, m->header->type, *n, m->path, m->interface, m->member))
1070                                                 return 0;
1071                                 }
1072                         }
1073                 }
1074
1075                 /* Return an error back to the caller */
1076                 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1077                         return synthetic_reply_method_errorf(m, SD_BUS_ERROR_ACCESS_DENIED, "Access prohibited by XML receiver policy.");
1078
1079                 /* Return 1, indicating that the message shall not be processed any further */
1080                 return 1;
1081         }
1082
1083         if (to->is_kernel) {
1084                 _cleanup_bus_creds_unref_ sd_bus_creds *destination_creds = NULL;
1085                 uid_t destination_uid = UID_INVALID;
1086                 gid_t destination_gid = GID_INVALID;
1087                 const char *destination_unique = NULL;
1088                 char **destination_names = NULL;
1089                 bool granted = false;
1090
1091                 /* Driver messages are always OK */
1092                 if (streq_ptr(m->destination, "org.freedesktop.DBus"))
1093                         return 0;
1094
1095                 /* The message came from the legacy client, and is sent to kdbus. */
1096                 if (m->destination) {
1097                         r = bus_get_name_creds_kdbus(to, m->destination,
1098                                                      SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME|
1099                                                      SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID,
1100                                                      true, &destination_creds);
1101                         if (r < 0)
1102                                 return handle_policy_error(m, r);
1103
1104                         r = sd_bus_creds_get_unique_name(destination_creds, &destination_unique);
1105                         if (r < 0)
1106                                 return handle_policy_error(m, r);
1107
1108                         sd_bus_creds_get_well_known_names(destination_creds, &destination_names);
1109
1110                         (void) sd_bus_creds_get_uid(destination_creds, &destination_uid);
1111                         (void) sd_bus_creds_get_gid(destination_creds, &destination_gid);
1112                 }
1113
1114                 /* First check if we (the sender) can send to this name */
1115                 if (strv_isempty(destination_names)) {
1116                         if (policy_check_send(policy, our_ucred->uid, our_ucred->gid, m->header->type, NULL, m->path, m->interface, m->member))
1117                                 granted = true;
1118                 } else {
1119                         char **n;
1120
1121                         STRV_FOREACH(n, destination_names) {
1122                                 if (policy_check_send(policy, our_ucred->uid, our_ucred->gid, m->header->type, *n, m->path, m->interface, m->member)) {
1123
1124                                         /* If we made a receiver decision,
1125                                            then remember which name's policy
1126                                            we used, and to which unique ID it
1127                                            mapped when we made the
1128                                            decision. Then, let's pass this to
1129                                            the kernel when sending the
1130                                            message, so that it refuses the
1131                                            operation should the name and
1132                                            unique ID not map to each other
1133                                            anymore. */
1134
1135                                         r = free_and_strdup(&m->destination_ptr, *n);
1136                                         if (r < 0)
1137                                                 return r;
1138
1139                                         r = bus_kernel_parse_unique_name(destination_unique, &m->verify_destination_id);
1140                                         if (r < 0)
1141                                                 break;
1142
1143                                         granted = true;
1144                                         break;
1145                                 }
1146                         }
1147                 }
1148
1149                 /* Then check if the recipient can receive from our name */
1150                 if (granted) {
1151                         if (set_isempty(owned_names)) {
1152                                 if (policy_check_recv(policy, destination_uid, destination_gid, m->header->type, NULL, m->path, m->interface, m->member))
1153                                         return 0;
1154                         } else {
1155                                 Iterator i;
1156                                 char *n;
1157
1158                                 SET_FOREACH(n, owned_names, i)
1159                                         if (policy_check_recv(policy, destination_uid, destination_gid, m->header->type, n, m->path, m->interface, m->member))
1160                                                 return 0;
1161                         }
1162                 }
1163
1164                 /* Return an error back to the caller */
1165                 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1166                         return synthetic_reply_method_errorf(m, SD_BUS_ERROR_ACCESS_DENIED, "Access prohibited by XML sender policy.");
1167
1168                 /* Return 1, indicating that the message shall not be processed any further */
1169                 return 1;
1170         }
1171
1172         return 0;
1173 }
1174
1175 static int process_hello(sd_bus *a, sd_bus *b, sd_bus_message *m, bool *got_hello) {
1176         _cleanup_bus_message_unref_ sd_bus_message *n = NULL;
1177         bool is_hello;
1178         int r;
1179
1180         assert(a);
1181         assert(b);
1182         assert(m);
1183         assert(got_hello);
1184
1185         /* As reaction to hello we need to respond with two messages:
1186          * the callback reply and the NameAcquired for the unique
1187          * name, since hello is otherwise obsolete on kdbus. */
1188
1189         is_hello =
1190                 sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "Hello") &&
1191                 streq_ptr(m->destination, "org.freedesktop.DBus");
1192
1193         if (!is_hello) {
1194
1195                 if (*got_hello)
1196                         return 0;
1197
1198                 log_error("First packet isn't hello (it's %s.%s), aborting.", m->interface, m->member);
1199                 return -EIO;
1200         }
1201
1202         if (*got_hello) {
1203                 log_error("Got duplicate hello, aborting.");
1204                 return -EIO;
1205         }
1206
1207         *got_hello = true;
1208
1209         if (!a->is_kernel)
1210                 return 0;
1211
1212         r = sd_bus_message_new_method_return(m, &n);
1213         if (r < 0)
1214                 return log_error_errno(r, "Failed to generate HELLO reply: %m");
1215
1216         r = sd_bus_message_append(n, "s", a->unique_name);
1217         if (r < 0)
1218                 return log_error_errno(r, "Failed to append unique name to HELLO reply: %m");
1219
1220         r = bus_message_append_sender(n, "org.freedesktop.DBus");
1221         if (r < 0)
1222                 return log_error_errno(r, "Failed to append sender to HELLO reply: %m");
1223
1224         r = bus_seal_synthetic_message(b, n);
1225         if (r < 0)
1226                 return log_error_errno(r, "Failed to seal HELLO reply: %m");
1227
1228         r = sd_bus_send(b, n, NULL);
1229         if (r < 0)
1230                 return log_error_errno(r, "Failed to send HELLO reply: %m");
1231
1232         n = sd_bus_message_unref(n);
1233         r = sd_bus_message_new_signal(
1234                         b,
1235                         &n,
1236                         "/org/freedesktop/DBus",
1237                         "org.freedesktop.DBus",
1238                         "NameAcquired");
1239         if (r < 0)
1240                 return log_error_errno(r, "Failed to allocate initial NameAcquired message: %m");
1241
1242         r = sd_bus_message_append(n, "s", a->unique_name);
1243         if (r < 0)
1244                 return log_error_errno(r, "Failed to append unique name to NameAcquired message: %m");
1245
1246         r = bus_message_append_sender(n, "org.freedesktop.DBus");
1247         if (r < 0)
1248                 return log_error_errno(r, "Failed to append sender to NameAcquired message: %m");
1249
1250         r = bus_seal_synthetic_message(b, n);
1251         if (r < 0)
1252                 return log_error_errno(r, "Failed to seal NameAcquired message: %m");
1253
1254         r = sd_bus_send(b, n, NULL);
1255         if (r < 0)
1256                 return log_error_errno(r, "Failed to send NameAcquired message: %m");
1257
1258         return 1;
1259 }
1260
1261 static int patch_sender(sd_bus *a, sd_bus_message *m) {
1262         char **well_known = NULL;
1263         sd_bus_creds *c;
1264         int r;
1265
1266         assert(a);
1267         assert(m);
1268
1269         if (!a->is_kernel)
1270                 return 0;
1271
1272         /* We will change the sender of messages from the bus driver
1273          * so that they originate from the bus driver. This is a
1274          * speciality originating from dbus1, where the bus driver did
1275          * not have a unique id, but only the well-known name. */
1276
1277         c = sd_bus_message_get_creds(m);
1278         if (!c)
1279                 return 0;
1280
1281         r = sd_bus_creds_get_well_known_names(c, &well_known);
1282         if (r < 0)
1283                 return r;
1284
1285         if (strv_contains(well_known, "org.freedesktop.DBus"))
1286                 m->sender = "org.freedesktop.DBus";
1287
1288         return 0;
1289 }
1290
1291 static int mac_smack_apply_label_and_drop_cap_mac_admin(pid_t its_pid, const char *new_label) {
1292 #ifdef HAVE_SMACK
1293         int r = 0, k;
1294
1295         if (!mac_smack_use())
1296                 return 0;
1297
1298         if (new_label && its_pid > 0)
1299                 r = mac_smack_apply_pid(its_pid, new_label);
1300
1301         k = drop_capability(CAP_MAC_ADMIN);
1302         return r < 0 ? r : k;
1303 #else
1304         return 0;
1305 #endif
1306 }
1307
1308 int main(int argc, char *argv[]) {
1309
1310         _cleanup_bus_close_unref_ sd_bus *a = NULL, *b = NULL;
1311         sd_id128_t server_id;
1312         int r, in_fd, out_fd;
1313         bool got_hello = false;
1314         bool is_unix;
1315         struct ucred ucred = {};
1316         _cleanup_free_ char *peersec = NULL;
1317         Policy policy_buffer = {}, *policy = NULL;
1318         _cleanup_set_free_free_ Set *owned_names = NULL;
1319         uid_t original_uid;
1320
1321         log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1322         log_parse_environment();
1323         log_open();
1324
1325         r = parse_argv(argc, argv);
1326         if (r <= 0)
1327                 goto finish;
1328
1329         r = sd_listen_fds(0);
1330         if (r == 0) {
1331                 in_fd = STDIN_FILENO;
1332                 out_fd = STDOUT_FILENO;
1333         } else if (r == 1) {
1334                 in_fd = SD_LISTEN_FDS_START;
1335                 out_fd = SD_LISTEN_FDS_START;
1336         } else {
1337                 log_error("Illegal number of file descriptors passed");
1338                 goto finish;
1339         }
1340
1341         original_uid = getuid();
1342
1343         is_unix =
1344                 sd_is_socket(in_fd, AF_UNIX, 0, 0) > 0 &&
1345                 sd_is_socket(out_fd, AF_UNIX, 0, 0) > 0;
1346
1347         if (is_unix) {
1348                 (void) getpeercred(in_fd, &ucred);
1349                 (void) getpeersec(in_fd, &peersec);
1350
1351                 r = mac_smack_apply_label_and_drop_cap_mac_admin(getpid(), peersec);
1352                 if (r < 0)
1353                         log_warning_errno(r, "Failed to set SMACK label (%s) and drop CAP_MAC_ADMIN: %m", peersec);
1354         }
1355
1356         if (arg_drop_privileges) {
1357                 const char *user = "systemd-bus-proxy";
1358                 uid_t uid;
1359                 gid_t gid;
1360
1361                 r = get_user_creds(&user, &uid, &gid, NULL, NULL);
1362                 if (r < 0) {
1363                         log_error_errno(r, "Cannot resolve user name %s: %m", user);
1364                         goto finish;
1365                 }
1366
1367                 r = drop_privileges(uid, gid, 1ULL << CAP_IPC_OWNER);
1368                 if (r < 0)
1369                         goto finish;
1370         }
1371
1372         owned_names = set_new(&string_hash_ops);
1373         if (!owned_names) {
1374                 log_oom();
1375                 goto finish;
1376         }
1377
1378         r = sd_bus_new(&a);
1379         if (r < 0) {
1380                 log_error_errno(r, "Failed to allocate bus: %m");
1381                 goto finish;
1382         }
1383
1384         r = sd_bus_set_description(a, "sd-proxy");
1385         if (r < 0) {
1386                 log_error_errno(r, "Failed to set bus name: %m");
1387                 goto finish;
1388         }
1389
1390         r = sd_bus_set_address(a, arg_address);
1391         if (r < 0) {
1392                 log_error_errno(r, "Failed to set address to connect to: %m");
1393                 goto finish;
1394         }
1395
1396         r = sd_bus_negotiate_fds(a, is_unix);
1397         if (r < 0) {
1398                 log_error_errno(r, "Failed to set FD negotiation: %m");
1399                 goto finish;
1400         }
1401
1402         r = sd_bus_negotiate_creds(a, true, SD_BUS_CREDS_UID|SD_BUS_CREDS_PID|SD_BUS_CREDS_GID|SD_BUS_CREDS_SELINUX_CONTEXT);
1403         if (r < 0) {
1404                 log_error_errno(r, "Failed to set credential negotiation: %m");
1405                 goto finish;
1406         }
1407
1408         if (ucred.pid > 0) {
1409                 a->fake_pids.pid = ucred.pid;
1410                 a->fake_pids_valid = true;
1411
1412                 a->fake_creds.uid = ucred.uid;
1413                 a->fake_creds.euid = UID_INVALID;
1414                 a->fake_creds.suid = UID_INVALID;
1415                 a->fake_creds.fsuid = UID_INVALID;
1416                 a->fake_creds.gid = ucred.gid;
1417                 a->fake_creds.egid = GID_INVALID;
1418                 a->fake_creds.sgid = GID_INVALID;
1419                 a->fake_creds.fsgid = GID_INVALID;
1420                 a->fake_creds_valid = true;
1421         }
1422
1423         if (peersec) {
1424                 a->fake_label = peersec;
1425                 peersec = NULL;
1426         }
1427
1428         a->manual_peer_interface = true;
1429
1430         r = sd_bus_start(a);
1431         if (r < 0) {
1432                 log_error_errno(r, "Failed to start bus client: %m");
1433                 goto finish;
1434         }
1435
1436         r = sd_bus_get_bus_id(a, &server_id);
1437         if (r < 0) {
1438                 log_error_errno(r, "Failed to get server ID: %m");
1439                 goto finish;
1440         }
1441
1442         if (a->is_kernel) {
1443                 if (!arg_configuration) {
1444                         const char *scope;
1445
1446                         r = sd_bus_get_scope(a, &scope);
1447                         if (r < 0) {
1448                                 log_error_errno(r, "Couldn't determine bus scope: %m");
1449                                 goto finish;
1450                         }
1451
1452                         if (streq(scope, "system"))
1453                                 arg_configuration = strv_new(
1454                                                 "/etc/dbus-1/system.conf",
1455                                                 "/etc/dbus-1/system.d/",
1456                                                 "/etc/dbus-1/system-local.conf",
1457                                                 NULL);
1458                         else if (streq(scope, "user"))
1459                                 arg_configuration = strv_new(
1460                                                 "/etc/dbus-1/session.conf",
1461                                                 "/etc/dbus-1/session.d/",
1462                                                 "/etc/dbus-1/session-local.conf",
1463                                                 NULL);
1464                         else {
1465                                 log_error("Unknown scope %s, don't know which policy to load. Refusing.", scope);
1466                                 goto finish;
1467                         }
1468
1469                         if (!arg_configuration) {
1470                                 r = log_oom();
1471                                 goto finish;
1472                         }
1473                 }
1474
1475                 r = policy_load(&policy_buffer, arg_configuration);
1476                 if (r < 0) {
1477                         log_error_errno(r, "Failed to load policy: %m");
1478                         goto finish;
1479                 }
1480
1481                 policy = &policy_buffer;
1482                 /* policy_dump(policy); */
1483
1484                 if (ucred.uid == original_uid)
1485                         log_debug("Permitting access, since bus owner matches bus client.");
1486                 else if (policy_check_hello(policy, ucred.uid, ucred.gid))
1487                         log_debug("Permitting access due to XML policy.");
1488                 else {
1489                         r = log_error_errno(EPERM, "Policy denied connection.");
1490                         goto finish;
1491                 }
1492         }
1493
1494         r = sd_bus_new(&b);
1495         if (r < 0) {
1496                 log_error_errno(r, "Failed to allocate bus: %m");
1497                 goto finish;
1498         }
1499
1500         r = sd_bus_set_fd(b, in_fd, out_fd);
1501         if (r < 0) {
1502                 log_error_errno(r, "Failed to set fds: %m");
1503                 goto finish;
1504         }
1505
1506         r = sd_bus_set_server(b, 1, server_id);
1507         if (r < 0) {
1508                 log_error_errno(r, "Failed to set server mode: %m");
1509                 goto finish;
1510         }
1511
1512         r = sd_bus_negotiate_fds(b, is_unix);
1513         if (r < 0) {
1514                 log_error_errno(r, "Failed to set FD negotiation: %m");
1515                 goto finish;
1516         }
1517
1518         r = sd_bus_negotiate_creds(b, true, SD_BUS_CREDS_UID|SD_BUS_CREDS_PID|SD_BUS_CREDS_GID|SD_BUS_CREDS_SELINUX_CONTEXT);
1519         if (r < 0) {
1520                 log_error_errno(r, "Failed to set credential negotiation: %m");
1521                 goto finish;
1522         }
1523
1524         r = sd_bus_set_anonymous(b, true);
1525         if (r < 0) {
1526                 log_error_errno(r, "Failed to set anonymous authentication: %m");
1527                 goto finish;
1528         }
1529
1530         b->manual_peer_interface = true;
1531
1532         r = sd_bus_start(b);
1533         if (r < 0) {
1534                 log_error_errno(r, "Failed to start bus client: %m");
1535                 goto finish;
1536         }
1537
1538         r = rename_service(a, b);
1539         if (r < 0)
1540                 log_debug_errno(r, "Failed to rename process: %m");
1541
1542         if (a->is_kernel) {
1543                 _cleanup_free_ char *match = NULL;
1544                 const char *unique;
1545
1546                 r = sd_bus_get_unique_name(a, &unique);
1547                 if (r < 0) {
1548                         log_error_errno(r, "Failed to get unique name: %m");
1549                         goto finish;
1550                 }
1551
1552                 match = strjoin("type='signal',"
1553                                 "sender='org.freedesktop.DBus',"
1554                                 "path='/org/freedesktop/DBus',"
1555                                 "interface='org.freedesktop.DBus',"
1556                                 "member='NameOwnerChanged',"
1557                                 "arg1='",
1558                                 unique,
1559                                 "'",
1560                                 NULL);
1561                 if (!match) {
1562                         log_oom();
1563                         goto finish;
1564                 }
1565
1566                 r = sd_bus_add_match(a, NULL, match, NULL, NULL);
1567                 if (r < 0) {
1568                         log_error_errno(r, "Failed to add match for NameLost: %m");
1569                         goto finish;
1570                 }
1571
1572                 free(match);
1573                 match = strjoin("type='signal',"
1574                                 "sender='org.freedesktop.DBus',"
1575                                 "path='/org/freedesktop/DBus',"
1576                                 "interface='org.freedesktop.DBus',"
1577                                 "member='NameOwnerChanged',"
1578                                 "arg2='",
1579                                 unique,
1580                                 "'",
1581                                 NULL);
1582                 if (!match) {
1583                         log_oom();
1584                         goto finish;
1585                 }
1586
1587                 r = sd_bus_add_match(a, NULL, match, NULL, NULL);
1588                 if (r < 0) {
1589                         log_error_errno(r, "Failed to add match for NameAcquired: %m");
1590                         goto finish;
1591                 }
1592         }
1593
1594         for (;;) {
1595                 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1596                 int events_a, events_b, fd;
1597                 uint64_t timeout_a, timeout_b, t;
1598                 struct timespec _ts, *ts;
1599                 struct pollfd *pollfd;
1600                 int k;
1601
1602                 if (got_hello) {
1603                         /* Read messages from bus, to pass them on to our client */
1604
1605                         r = sd_bus_process(a, &m);
1606                         if (r < 0) {
1607                                 /* treat 'connection reset by peer' as clean exit condition */
1608                                 if (r == -ECONNRESET)
1609                                         r = 0;
1610                                 else
1611                                         log_error_errno(r, "Failed to process bus a: %m");
1612
1613                                 goto finish;
1614                         }
1615
1616                         if (m) {
1617                                 bool processed = false;
1618
1619                                 /* We officially got EOF, let's quit */
1620                                 if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected")) {
1621                                         r = 0;
1622                                         goto finish;
1623                                 }
1624
1625                                 k = synthesize_name_acquired(a, b, m);
1626                                 if (k < 0) {
1627                                         r = k;
1628                                         log_error_errno(r, "Failed to synthesize message: %m");
1629                                         goto finish;
1630                                 }
1631
1632                                 patch_sender(a, m);
1633
1634                                 if (policy) {
1635                                         k = process_policy(a, b, m, policy, &ucred, owned_names);
1636                                         if (k < 0) {
1637                                                 r = k;
1638                                                 log_error_errno(r, "Failed to process policy: %m");
1639                                                 goto finish;
1640                                         } else if (k > 0) {
1641                                                 r = 1;
1642                                                 processed = true;
1643                                         }
1644                                 }
1645
1646                                 if (!processed) {
1647                                         k = sd_bus_send(b, m, NULL);
1648                                         if (k < 0) {
1649                                                 if (k == -ECONNRESET) {
1650                                                         r = 0;
1651                                                         goto finish;
1652                                                 } else if (k == -EPERM && m->reply_cookie > 0) {
1653                                                         /* If the peer tries to send a reply and it is rejected with EPERM
1654                                                          * by the kernel, we ignore the error. This catches cases where the
1655                                                          * original method-call didn't had EXPECT_REPLY set, but the proxy-peer
1656                                                          * still sends a reply. This is allowed in dbus1, but not in kdbus. We
1657                                                          * don't want to track reply-windows in the proxy, so we simply ignore
1658                                                          * EPERM for all replies. The only downside is, that callers are no
1659                                                          * longer notified if their replies are dropped. However, this is
1660                                                          * equivalent to the caller's timeout to expire, so this should be
1661                                                          * acceptable. Nobody sane sends replies without a matching method-call,
1662                                                          * so nobody should care. */
1663                                                         r = 1;
1664                                                 } else {
1665                                                         r = k;
1666                                                         log_error_errno(r, "Failed to send message to client: %m");
1667                                                         goto finish;
1668                                                 }
1669                                         } else
1670                                                 r = 1;
1671                                 }
1672                         }
1673
1674                         if (r > 0)
1675                                 continue;
1676                 }
1677
1678                 /* Read messages from our client, to pass them on to the bus */
1679                 r = sd_bus_process(b, &m);
1680                 if (r < 0) {
1681                         /* treat 'connection reset by peer' as clean exit condition */
1682                         if (r == -ECONNRESET)
1683                                 r = 0;
1684                         else
1685                                 log_error_errno(r, "Failed to process bus b: %m");
1686
1687                         goto finish;
1688                 }
1689
1690                 if (m) {
1691                         bool processed = false;
1692
1693                         /* We officially got EOF, let's quit */
1694                         if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected")) {
1695                                 r = 0;
1696                                 goto finish;
1697                         }
1698
1699                         k = process_hello(a, b, m, &got_hello);
1700                         if (k < 0) {
1701                                 r = k;
1702                                 log_error_errno(r, "Failed to process HELLO: %m");
1703                                 goto finish;
1704                         } else if (k > 0) {
1705                                 processed = true;
1706                                 r = 1;
1707                         }
1708
1709                         if (!processed) {
1710                                 k = process_driver(a, b, m, policy, &ucred, owned_names);
1711                                 if (k < 0) {
1712                                         r = k;
1713                                         log_error_errno(r, "Failed to process driver calls: %m");
1714                                         goto finish;
1715                                 } else if (k > 0) {
1716                                         processed = true;
1717                                         r = 1;
1718                                 }
1719
1720                                 if (!processed) {
1721
1722                                         for (;;) {
1723                                                 if (policy) {
1724                                                         k = process_policy(b, a, m, policy, &ucred, owned_names);
1725                                                         if (k < 0) {
1726                                                                 r = k;
1727                                                                 log_error_errno(r, "Failed to process policy: %m");
1728                                                                 goto finish;
1729                                                         } else if (k > 0) {
1730                                                                 processed = true;
1731                                                                 r = 1;
1732                                                                 break;
1733                                                         }
1734                                                 }
1735
1736                                                 k = sd_bus_send(a, m, NULL);
1737                                                 if (k < 0) {
1738                                                         if (k == -EREMCHG) {
1739                                                                 /* The name database changed since the policy check, hence let's check again */
1740                                                                 continue;
1741                                                         } else if (k == -ECONNRESET) {
1742                                                                 r = 0;
1743                                                                 goto finish;
1744                                                         } else if (k == -EPERM && m->reply_cookie > 0) {
1745                                                                 /* see above why EPERM is ignored for replies */
1746                                                                 r = 1;
1747                                                         } else {
1748                                                                 r = k;
1749                                                                 log_error_errno(r, "Failed to send message to bus: %m");
1750                                                                 goto finish;
1751                                                         }
1752                                                 } else
1753                                                         r = 1;
1754
1755                                                 break;
1756                                         }
1757                                 }
1758                         }
1759                 }
1760
1761                 if (r > 0)
1762                         continue;
1763
1764                 fd = sd_bus_get_fd(a);
1765                 if (fd < 0) {
1766                         log_error_errno(r, "Failed to get fd: %m");
1767                         goto finish;
1768                 }
1769
1770                 events_a = sd_bus_get_events(a);
1771                 if (events_a < 0) {
1772                         log_error_errno(r, "Failed to get events mask: %m");
1773                         goto finish;
1774                 }
1775
1776                 r = sd_bus_get_timeout(a, &timeout_a);
1777                 if (r < 0) {
1778                         log_error_errno(r, "Failed to get timeout: %m");
1779                         goto finish;
1780                 }
1781
1782                 events_b = sd_bus_get_events(b);
1783                 if (events_b < 0) {
1784                         log_error_errno(r, "Failed to get events mask: %m");
1785                         goto finish;
1786                 }
1787
1788                 r = sd_bus_get_timeout(b, &timeout_b);
1789                 if (r < 0) {
1790                         log_error_errno(r, "Failed to get timeout: %m");
1791                         goto finish;
1792                 }
1793
1794                 t = timeout_a;
1795                 if (t == (uint64_t) -1 || (timeout_b != (uint64_t) -1 && timeout_b < timeout_a))
1796                         t = timeout_b;
1797
1798                 if (t == (uint64_t) -1)
1799                         ts = NULL;
1800                 else {
1801                         usec_t nw;
1802
1803                         nw = now(CLOCK_MONOTONIC);
1804                         if (t > nw)
1805                                 t -= nw;
1806                         else
1807                                 t = 0;
1808
1809                         ts = timespec_store(&_ts, t);
1810                 }
1811
1812                 pollfd = (struct pollfd[3]) {
1813                         {.fd = fd,     .events = events_a,           },
1814                         {.fd = in_fd,  .events = events_b & POLLIN,  },
1815                         {.fd = out_fd, .events = events_b & POLLOUT, }
1816                 };
1817
1818                 r = ppoll(pollfd, 3, ts, NULL);
1819                 if (r < 0) {
1820                         log_error_errno(errno, "ppoll() failed: %m");
1821                         goto finish;
1822                 }
1823         }
1824
1825 finish:
1826         sd_notify(false,
1827                   "STOPPING=1\n"
1828                   "STATUS=Shutting down.");
1829
1830         policy_free(&policy_buffer);
1831         strv_free(arg_configuration);
1832         free(arg_address);
1833
1834         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1835 }