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         if (from->is_kernel) {
 996                 uid_t sender_uid = UID_INVALID;
 997                 gid_t sender_gid = GID_INVALID;
 998                 char **sender_names = NULL;
 999                 bool granted = false;
1000
1001                 /* Driver messages are always OK */
1002                 if (streq_ptr(m->sender, "org.freedesktop.DBus"))
1003                         return 0;
1004
1005                 /* The message came from the kernel, and is sent to our legacy client. */
1006                 sd_bus_creds_get_well_known_names(&m->creds, &sender_names);
1007
1008                 (void) sd_bus_creds_get_uid(&m->creds, &sender_uid);
1009                 (void) sd_bus_creds_get_gid(&m->creds, &sender_gid);
1010
1011                 /* First check whether the sender can send the message to our name */
1012                 if (set_isempty(owned_names)) {
1013                         if (policy_check_send(policy, sender_uid, sender_gid, m->header->type, NULL, m->path, m->interface, m->member))
1014                                 granted = true;
1015                 } else {
1016                         Iterator i;
1017                         char *n;
1018
1019                         SET_FOREACH(n, owned_names, i)
1020                                 if (policy_check_send(policy, sender_uid, sender_gid, m->header->type, n, m->path, m->interface, m->member)) {
1021                                         granted = true;
1022                                         break;
1023                                 }
1024                 }
1025
1026                 if (granted) {
1027                         /* Then check whether us (the recipient) can receive from the sender's name */
1028                         if (strv_isempty(sender_names)) {
1029                                 if (policy_check_recv(policy, our_ucred->uid, our_ucred->gid, m->header->type, NULL, m->path, m->interface, m->member))
1030                                         return 0;
1031                         } else {
1032                                 char **n;
1033
1034                                 STRV_FOREACH(n, sender_names) {
1035                                         if (policy_check_recv(policy, our_ucred->uid, our_ucred->gid, m->header->type, *n, m->path, m->interface, m->member))
1036                                                 return 0;
1037                                 }
1038                         }
1039                 }
1040
1041                 /* Return an error back to the caller */
1042                 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1043                         return synthetic_reply_method_errorf(m, SD_BUS_ERROR_ACCESS_DENIED, "Access prohibited by XML receiver policy.");
1044
1045                 /* Return 1, indicating that the message shall not be processed any further */
1046                 return 1;
1047         }
1048
1049         if (to->is_kernel) {
1050                 _cleanup_bus_creds_unref_ sd_bus_creds *destination_creds = NULL;
1051                 uid_t destination_uid = UID_INVALID;
1052                 gid_t destination_gid = GID_INVALID;
1053                 const char *destination_unique = NULL;
1054                 char **destination_names = NULL;
1055                 bool granted = false;
1056
1057                 /* Driver messages are always OK */
1058                 if (streq_ptr(m->destination, "org.freedesktop.DBus"))
1059                         return 0;
1060
1061                 /* The message came from the legacy client, and is sent to kdbus. */
1062                 if (m->destination) {
1063                         r = bus_get_name_creds_kdbus(to, m->destination,
1064                                                      SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME|
1065                                                      SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID,
1066                                                      true, &destination_creds);
1067                         if (r < 0)
1068                                 return handle_policy_error(m, r);
1069
1070                         r = sd_bus_creds_get_unique_name(destination_creds, &destination_unique);
1071                         if (r < 0)
1072                                 return handle_policy_error(m, r);
1073
1074                         sd_bus_creds_get_well_known_names(destination_creds, &destination_names);
1075
1076                         (void) sd_bus_creds_get_uid(destination_creds, &destination_uid);
1077                         (void) sd_bus_creds_get_gid(destination_creds, &destination_gid);
1078                 }
1079
1080                 /* First check if we (the sender) can send to this name */
1081                 if (strv_isempty(destination_names)) {
1082                         if (policy_check_send(policy, our_ucred->uid, our_ucred->gid, m->header->type, NULL, m->path, m->interface, m->member))
1083                                 granted = true;
1084                 } else {
1085                         char **n;
1086
1087                         STRV_FOREACH(n, destination_names) {
1088                                 if (policy_check_send(policy, our_ucred->uid, our_ucred->gid, m->header->type, *n, m->path, m->interface, m->member)) {
1089
1090                                         /* If we made a receiver decision,
1091                                            then remember which name's policy
1092                                            we used, and to which unique ID it
1093                                            mapped when we made the
1094                                            decision. Then, let's pass this to
1095                                            the kernel when sending the
1096                                            message, so that it refuses the
1097                                            operation should the name and
1098                                            unique ID not map to each other
1099                                            anymore. */
1100
1101                                         r = free_and_strdup(&m->destination_ptr, *n);
1102                                         if (r < 0)
1103                                                 return r;
1104
1105                                         r = bus_kernel_parse_unique_name(destination_unique, &m->verify_destination_id);
1106                                         if (r < 0)
1107                                                 break;
1108
1109                                         granted = true;
1110                                         break;
1111                                 }
1112                         }
1113                 }
1114
1115                 /* Then check if the recipient can receive from our name */
1116                 if (granted) {
1117                         if (set_isempty(owned_names)) {
1118                                 if (policy_check_recv(policy, destination_uid, destination_gid, m->header->type, NULL, m->path, m->interface, m->member))
1119                                         return 0;
1120                         } else {
1121                                 Iterator i;
1122                                 char *n;
1123
1124                                 SET_FOREACH(n, owned_names, i)
1125                                         if (policy_check_recv(policy, destination_uid, destination_gid, m->header->type, n, m->path, m->interface, m->member))
1126                                                 return 0;
1127                         }
1128                 }
1129
1130                 /* Return an error back to the caller */
1131                 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1132                         return synthetic_reply_method_errorf(m, SD_BUS_ERROR_ACCESS_DENIED, "Access prohibited by XML sender policy.");
1133
1134                 /* Return 1, indicating that the message shall not be processed any further */
1135                 return 1;
1136         }
1137
1138         return 0;
1139 }
1140
1141 static int process_hello(sd_bus *a, sd_bus *b, sd_bus_message *m, bool *got_hello) {
1142         _cleanup_bus_message_unref_ sd_bus_message *n = NULL;
1143         bool is_hello;
1144         int r;
1145
1146         assert(a);
1147         assert(b);
1148         assert(m);
1149         assert(got_hello);
1150
1151         /* As reaction to hello we need to respond with two messages:
1152          * the callback reply and the NameAcquired for the unique
1153          * name, since hello is otherwise obsolete on kdbus. */
1154
1155         is_hello =
1156                 sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "Hello") &&
1157                 streq_ptr(m->destination, "org.freedesktop.DBus");
1158
1159         if (!is_hello) {
1160
1161                 if (*got_hello)
1162                         return 0;
1163
1164                 log_error("First packet isn't hello (it's %s.%s), aborting.", m->interface, m->member);
1165                 return -EIO;
1166         }
1167
1168         if (*got_hello) {
1169                 log_error("Got duplicate hello, aborting.");
1170                 return -EIO;
1171         }
1172
1173         *got_hello = true;
1174
1175         if (!a->is_kernel)
1176                 return 0;
1177
1178         r = sd_bus_message_new_method_return(m, &n);
1179         if (r < 0)
1180                 return log_error_errno(r, "Failed to generate HELLO reply: %m");
1181
1182         r = sd_bus_message_append(n, "s", a->unique_name);
1183         if (r < 0)
1184                 return log_error_errno(r, "Failed to append unique name to HELLO reply: %m");
1185
1186         r = bus_message_append_sender(n, "org.freedesktop.DBus");
1187         if (r < 0)
1188                 return log_error_errno(r, "Failed to append sender to HELLO reply: %m");
1189
1190         r = bus_seal_synthetic_message(b, n);
1191         if (r < 0)
1192                 return log_error_errno(r, "Failed to seal HELLO reply: %m");
1193
1194         r = sd_bus_send(b, n, NULL);
1195         if (r < 0)
1196                 return log_error_errno(r, "Failed to send HELLO reply: %m");
1197
1198         n = sd_bus_message_unref(n);
1199         r = sd_bus_message_new_signal(
1200                         b,
1201                         &n,
1202                         "/org/freedesktop/DBus",
1203                         "org.freedesktop.DBus",
1204                         "NameAcquired");
1205         if (r < 0)
1206                 return log_error_errno(r, "Failed to allocate initial NameAcquired message: %m");
1207
1208         r = sd_bus_message_append(n, "s", a->unique_name);
1209         if (r < 0)
1210                 return log_error_errno(r, "Failed to append unique name to NameAcquired message: %m");
1211
1212         r = bus_message_append_sender(n, "org.freedesktop.DBus");
1213         if (r < 0)
1214                 return log_error_errno(r, "Failed to append sender to NameAcquired message: %m");
1215
1216         r = bus_seal_synthetic_message(b, n);
1217         if (r < 0)
1218                 return log_error_errno(r, "Failed to seal NameAcquired message: %m");
1219
1220         r = sd_bus_send(b, n, NULL);
1221         if (r < 0)
1222                 return log_error_errno(r, "Failed to send NameAcquired message: %m");
1223
1224         return 1;
1225 }
1226
1227 static int patch_sender(sd_bus *a, sd_bus_message *m) {
1228         char **well_known = NULL;
1229         sd_bus_creds *c;
1230         int r;
1231
1232         assert(a);
1233         assert(m);
1234
1235         if (!a->is_kernel)
1236                 return 0;
1237
1238         /* We will change the sender of messages from the bus driver
1239          * so that they originate from the bus driver. This is a
1240          * speciality originating from dbus1, where the bus driver did
1241          * not have a unique id, but only the well-known name. */
1242
1243         c = sd_bus_message_get_creds(m);
1244         if (!c)
1245                 return 0;
1246
1247         r = sd_bus_creds_get_well_known_names(c, &well_known);
1248         if (r < 0)
1249                 return r;
1250
1251         if (strv_contains(well_known, "org.freedesktop.DBus"))
1252                 m->sender = "org.freedesktop.DBus";
1253
1254         return 0;
1255 }
1256
1257 static int mac_smack_apply_label_and_drop_cap_mac_admin(pid_t its_pid, const char *new_label) {
1258 #ifdef HAVE_SMACK
1259         int r = 0, k;
1260
1261         if (!mac_smack_use())
1262                 return 0;
1263
1264         if (new_label && its_pid > 0)
1265                 r = mac_smack_apply_pid(its_pid, new_label);
1266
1267         k = drop_capability(CAP_MAC_ADMIN);
1268         return r < 0 ? r : k;
1269 #else
1270         return 0;
1271 #endif
1272 }
1273
1274 int main(int argc, char *argv[]) {
1275
1276         _cleanup_bus_close_unref_ sd_bus *a = NULL, *b = NULL;
1277         sd_id128_t server_id;
1278         int r, in_fd, out_fd;
1279         bool got_hello = false;
1280         bool is_unix;
1281         struct ucred ucred = {};
1282         _cleanup_free_ char *peersec = NULL;
1283         Policy policy_buffer = {}, *policy = NULL;
1284         _cleanup_set_free_free_ Set *owned_names = NULL;
1285
1286         log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1287         log_parse_environment();
1288         log_open();
1289
1290         r = parse_argv(argc, argv);
1291         if (r <= 0)
1292                 goto finish;
1293
1294         r = sd_listen_fds(0);
1295         if (r == 0) {
1296                 in_fd = STDIN_FILENO;
1297                 out_fd = STDOUT_FILENO;
1298         } else if (r == 1) {
1299                 in_fd = SD_LISTEN_FDS_START;
1300                 out_fd = SD_LISTEN_FDS_START;
1301         } else {
1302                 log_error("Illegal number of file descriptors passed");
1303                 goto finish;
1304         }
1305
1306         is_unix =
1307                 sd_is_socket(in_fd, AF_UNIX, 0, 0) > 0 &&
1308                 sd_is_socket(out_fd, AF_UNIX, 0, 0) > 0;
1309
1310         if (is_unix) {
1311                 (void) getpeercred(in_fd, &ucred);
1312                 (void) getpeersec(in_fd, &peersec);
1313
1314                 r = mac_smack_apply_label_and_drop_cap_mac_admin(getpid(), peersec);
1315                 if (r < 0)
1316                         log_warning_errno(r, "Failed to set SMACK label (%s) and drop CAP_MAC_ADMIN: %m", peersec);
1317         }
1318
1319         if (arg_drop_privileges) {
1320                 const char *user = "systemd-bus-proxy";
1321                 uid_t uid;
1322                 gid_t gid;
1323
1324                 r = get_user_creds(&user, &uid, &gid, NULL, NULL);
1325                 if (r < 0) {
1326                         log_error_errno(r, "Cannot resolve user name %s: %m", user);
1327                         goto finish;
1328                 }
1329
1330                 r = drop_privileges(uid, gid, 1ULL << CAP_IPC_OWNER);
1331                 if (r < 0)
1332                         goto finish;
1333         }
1334
1335         owned_names = set_new(&string_hash_ops);
1336         if (!owned_names) {
1337                 log_oom();
1338                 goto finish;
1339         }
1340
1341         r = sd_bus_new(&a);
1342         if (r < 0) {
1343                 log_error_errno(r, "Failed to allocate bus: %m");
1344                 goto finish;
1345         }
1346
1347         r = sd_bus_set_description(a, "sd-proxy");
1348         if (r < 0) {
1349                 log_error_errno(r, "Failed to set bus name: %m");
1350                 goto finish;
1351         }
1352
1353         r = sd_bus_set_address(a, arg_address);
1354         if (r < 0) {
1355                 log_error_errno(r, "Failed to set address to connect to: %m");
1356                 goto finish;
1357         }
1358
1359         r = sd_bus_negotiate_fds(a, is_unix);
1360         if (r < 0) {
1361                 log_error_errno(r, "Failed to set FD negotiation: %m");
1362                 goto finish;
1363         }
1364
1365         r = sd_bus_negotiate_creds(a, true, SD_BUS_CREDS_UID|SD_BUS_CREDS_PID|SD_BUS_CREDS_GID|SD_BUS_CREDS_SELINUX_CONTEXT);
1366         if (r < 0) {
1367                 log_error_errno(r, "Failed to set credential negotiation: %m");
1368                 goto finish;
1369         }
1370
1371         if (ucred.pid > 0) {
1372                 a->fake_pids.pid = ucred.pid;
1373                 a->fake_pids_valid = true;
1374
1375                 a->fake_creds.uid = ucred.uid;
1376                 a->fake_creds.euid = UID_INVALID;
1377                 a->fake_creds.suid = UID_INVALID;
1378                 a->fake_creds.fsuid = UID_INVALID;
1379                 a->fake_creds.gid = ucred.gid;
1380                 a->fake_creds.egid = GID_INVALID;
1381                 a->fake_creds.sgid = GID_INVALID;
1382                 a->fake_creds.fsgid = GID_INVALID;
1383                 a->fake_creds_valid = true;
1384         }
1385
1386         if (peersec) {
1387                 a->fake_label = peersec;
1388                 peersec = NULL;
1389         }
1390
1391         a->manual_peer_interface = true;
1392
1393         r = sd_bus_start(a);
1394         if (r < 0) {
1395                 log_error_errno(r, "Failed to start bus client: %m");
1396                 goto finish;
1397         }
1398
1399         r = sd_bus_get_bus_id(a, &server_id);
1400         if (r < 0) {
1401                 log_error_errno(r, "Failed to get server ID: %m");
1402                 goto finish;
1403         }
1404
1405         if (a->is_kernel) {
1406                 if (!arg_configuration) {
1407                         const char *scope;
1408
1409                         r = sd_bus_get_scope(a, &scope);
1410                         if (r < 0) {
1411                                 log_error_errno(r, "Couldn't determine bus scope: %m");
1412                                 goto finish;
1413                         }
1414
1415                         if (streq(scope, "system"))
1416                                 arg_configuration = strv_new(
1417                                                 "/etc/dbus-1/system.conf",
1418                                                 "/etc/dbus-1/system.d/",
1419                                                 "/etc/dbus-1/system-local.conf",
1420                                                 NULL);
1421                         else if (streq(scope, "user"))
1422                                 arg_configuration = strv_new(
1423                                                 "/etc/dbus-1/session.conf",
1424                                                 "/etc/dbus-1/session.d/",
1425                                                 "/etc/dbus-1/session-local.conf",
1426                                                 NULL);
1427                         else {
1428                                 log_error("Unknown scope %s, don't know which policy to load. Refusing.", scope);
1429                                 goto finish;
1430                         }
1431
1432                         if (!arg_configuration) {
1433                                 r = log_oom();
1434                                 goto finish;
1435                         }
1436                 }
1437
1438                 r = policy_load(&policy_buffer, arg_configuration);
1439                 if (r < 0) {
1440                         log_error_errno(r, "Failed to load policy: %m");
1441                         goto finish;
1442                 }
1443
1444                 policy = &policy_buffer;
1445                 /* policy_dump(policy); */
1446
1447                 if (!policy_check_hello(policy, ucred.uid, ucred.gid)) {
1448                         r = log_error_errno(EPERM, "Policy denied connection.");
1449                         goto finish;
1450                 }
1451         }
1452
1453         r = sd_bus_new(&b);
1454         if (r < 0) {
1455                 log_error_errno(r, "Failed to allocate bus: %m");
1456                 goto finish;
1457         }
1458
1459         r = sd_bus_set_fd(b, in_fd, out_fd);
1460         if (r < 0) {
1461                 log_error_errno(r, "Failed to set fds: %m");
1462                 goto finish;
1463         }
1464
1465         r = sd_bus_set_server(b, 1, server_id);
1466         if (r < 0) {
1467                 log_error_errno(r, "Failed to set server mode: %m");
1468                 goto finish;
1469         }
1470
1471         r = sd_bus_negotiate_fds(b, is_unix);
1472         if (r < 0) {
1473                 log_error_errno(r, "Failed to set FD negotiation: %m");
1474                 goto finish;
1475         }
1476
1477         r = sd_bus_negotiate_creds(b, true, SD_BUS_CREDS_UID|SD_BUS_CREDS_PID|SD_BUS_CREDS_GID|SD_BUS_CREDS_SELINUX_CONTEXT);
1478         if (r < 0) {
1479                 log_error_errno(r, "Failed to set credential negotiation: %m");
1480                 goto finish;
1481         }
1482
1483         r = sd_bus_set_anonymous(b, true);
1484         if (r < 0) {
1485                 log_error_errno(r, "Failed to set anonymous authentication: %m");
1486                 goto finish;
1487         }
1488
1489         b->manual_peer_interface = true;
1490
1491         r = sd_bus_start(b);
1492         if (r < 0) {
1493                 log_error_errno(r, "Failed to start bus client: %m");
1494                 goto finish;
1495         }
1496
1497         r = rename_service(a, b);
1498         if (r < 0)
1499                 log_debug_errno(r, "Failed to rename process: %m");
1500
1501         if (a->is_kernel) {
1502                 _cleanup_free_ char *match = NULL;
1503                 const char *unique;
1504
1505                 r = sd_bus_get_unique_name(a, &unique);
1506                 if (r < 0) {
1507                         log_error_errno(r, "Failed to get unique name: %m");
1508                         goto finish;
1509                 }
1510
1511                 match = strjoin("type='signal',"
1512                                 "sender='org.freedesktop.DBus',"
1513                                 "path='/org/freedesktop/DBus',"
1514                                 "interface='org.freedesktop.DBus',"
1515                                 "member='NameOwnerChanged',"
1516                                 "arg1='",
1517                                 unique,
1518                                 "'",
1519                                 NULL);
1520                 if (!match) {
1521                         log_oom();
1522                         goto finish;
1523                 }
1524
1525                 r = sd_bus_add_match(a, NULL, match, NULL, NULL);
1526                 if (r < 0) {
1527                         log_error_errno(r, "Failed to add match for NameLost: %m");
1528                         goto finish;
1529                 }
1530
1531                 free(match);
1532                 match = strjoin("type='signal',"
1533                                 "sender='org.freedesktop.DBus',"
1534                                 "path='/org/freedesktop/DBus',"
1535                                 "interface='org.freedesktop.DBus',"
1536                                 "member='NameOwnerChanged',"
1537                                 "arg2='",
1538                                 unique,
1539                                 "'",
1540                                 NULL);
1541                 if (!match) {
1542                         log_oom();
1543                         goto finish;
1544                 }
1545
1546                 r = sd_bus_add_match(a, NULL, match, NULL, NULL);
1547                 if (r < 0) {
1548                         log_error_errno(r, "Failed to add match for NameAcquired: %m");
1549                         goto finish;
1550                 }
1551         }
1552
1553         for (;;) {
1554                 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1555                 int events_a, events_b, fd;
1556                 uint64_t timeout_a, timeout_b, t;
1557                 struct timespec _ts, *ts;
1558                 struct pollfd *pollfd;
1559                 int k;
1560
1561                 if (got_hello) {
1562                         /* Read messages from bus, to pass them on to our client */
1563
1564                         r = sd_bus_process(a, &m);
1565                         if (r < 0) {
1566                                 /* treat 'connection reset by peer' as clean exit condition */
1567                                 if (r == -ECONNRESET)
1568                                         r = 0;
1569                                 else
1570                                         log_error_errno(r, "Failed to process bus a: %m");
1571
1572                                 goto finish;
1573                         }
1574
1575                         if (m) {
1576                                 bool processed = false;
1577
1578                                 /* We officially got EOF, let's quit */
1579                                 if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected")) {
1580                                         r = 0;
1581                                         goto finish;
1582                                 }
1583
1584                                 k = synthesize_name_acquired(a, b, m);
1585                                 if (k < 0) {
1586                                         r = k;
1587                                         log_error_errno(r, "Failed to synthesize message: %m");
1588                                         goto finish;
1589                                 }
1590
1591                                 patch_sender(a, m);
1592
1593                                 if (policy) {
1594                                         k = process_policy(a, b, m, policy, &ucred, owned_names);
1595                                         if (k < 0) {
1596                                                 r = k;
1597                                                 log_error_errno(r, "Failed to process policy: %m");
1598                                                 goto finish;
1599                                         } else if (k > 0) {
1600                                                 r = 1;
1601                                                 processed = true;
1602                                         }
1603                                 }
1604
1605                                 if (!processed) {
1606                                         k = sd_bus_send(b, m, NULL);
1607                                         if (k < 0) {
1608                                                 if (k == -ECONNRESET) {
1609                                                         r = 0;
1610                                                         goto finish;
1611                                                 } else if (k == -EPERM && m->reply_cookie > 0) {
1612                                                         /* If the peer tries to send a reply and it is rejected with EPERM
1613                                                          * by the kernel, we ignore the error. This catches cases where the
1614                                                          * original method-call didn't had EXPECT_REPLY set, but the proxy-peer
1615                                                          * still sends a reply. This is allowed in dbus1, but not in kdbus. We
1616                                                          * don't want to track reply-windows in the proxy, so we simply ignore
1617                                                          * EPERM for all replies. The only downside is, that callers are no
1618                                                          * longer notified if their replies are dropped. However, this is
1619                                                          * equivalent to the caller's timeout to expire, so this should be
1620                                                          * acceptable. Nobody sane sends replies without a matching method-call,
1621                                                          * so nobody should care. */
1622                                                         r = 1;
1623                                                 } else {
1624                                                         r = k;
1625                                                         log_error_errno(r, "Failed to send message to client: %m");
1626                                                         goto finish;
1627                                                 }
1628                                         } else
1629                                                 r = 1;
1630                                 }
1631                         }
1632
1633                         if (r > 0)
1634                                 continue;
1635                 }
1636
1637                 /* Read messages from our client, to pass them on to the bus */
1638                 r = sd_bus_process(b, &m);
1639                 if (r < 0) {
1640                         /* treat 'connection reset by peer' as clean exit condition */
1641                         if (r == -ECONNRESET)
1642                                 r = 0;
1643                         else
1644                                 log_error_errno(r, "Failed to process bus b: %m");
1645
1646                         goto finish;
1647                 }
1648
1649                 if (m) {
1650                         bool processed = false;
1651
1652                         /* We officially got EOF, let's quit */
1653                         if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected")) {
1654                                 r = 0;
1655                                 goto finish;
1656                         }
1657
1658                         k = process_hello(a, b, m, &got_hello);
1659                         if (k < 0) {
1660                                 r = k;
1661                                 log_error_errno(r, "Failed to process HELLO: %m");
1662                                 goto finish;
1663                         } else if (k > 0) {
1664                                 processed = true;
1665                                 r = 1;
1666                         }
1667
1668                         if (!processed) {
1669                                 k = process_driver(a, b, m, policy, &ucred, owned_names);
1670                                 if (k < 0) {
1671                                         r = k;
1672                                         log_error_errno(r, "Failed to process driver calls: %m");
1673                                         goto finish;
1674                                 } else if (k > 0) {
1675                                         processed = true;
1676                                         r = 1;
1677                                 }
1678
1679                                 if (!processed) {
1680
1681                                         for (;;) {
1682                                                 if (policy) {
1683                                                         k = process_policy(b, a, m, policy, &ucred, owned_names);
1684                                                         if (k < 0) {
1685                                                                 r = k;
1686                                                                 log_error_errno(r, "Failed to process policy: %m");
1687                                                                 goto finish;
1688                                                         } else if (k > 0) {
1689                                                                 processed = true;
1690                                                                 r = 1;
1691                                                                 break;
1692                                                         }
1693                                                 }
1694
1695                                                 k = sd_bus_send(a, m, NULL);
1696                                                 if (k < 0) {
1697                                                         if (k == -EREMCHG) {
1698                                                                 /* The name database changed since the policy check, hence let's check again */
1699                                                                 continue;
1700                                                         } else if (k == -ECONNRESET) {
1701                                                                 r = 0;
1702                                                                 goto finish;
1703                                                         } else if (k == -EPERM && m->reply_cookie > 0) {
1704                                                                 /* see above why EPERM is ignored for replies */
1705                                                                 r = 1;
1706                                                         } else {
1707                                                                 r = k;
1708                                                                 log_error_errno(r, "Failed to send message to bus: %m");
1709                                                                 goto finish;
1710                                                         }
1711                                                 } else
1712                                                         r = 1;
1713
1714                                                 break;
1715                                         }
1716                                 }
1717                         }
1718                 }
1719
1720                 if (r > 0)
1721                         continue;
1722
1723                 fd = sd_bus_get_fd(a);
1724                 if (fd < 0) {
1725                         log_error_errno(r, "Failed to get fd: %m");
1726                         goto finish;
1727                 }
1728
1729                 events_a = sd_bus_get_events(a);
1730                 if (events_a < 0) {
1731                         log_error_errno(r, "Failed to get events mask: %m");
1732                         goto finish;
1733                 }
1734
1735                 r = sd_bus_get_timeout(a, &timeout_a);
1736                 if (r < 0) {
1737                         log_error_errno(r, "Failed to get timeout: %m");
1738                         goto finish;
1739                 }
1740
1741                 events_b = sd_bus_get_events(b);
1742                 if (events_b < 0) {
1743                         log_error_errno(r, "Failed to get events mask: %m");
1744                         goto finish;
1745                 }
1746
1747                 r = sd_bus_get_timeout(b, &timeout_b);
1748                 if (r < 0) {
1749                         log_error_errno(r, "Failed to get timeout: %m");
1750                         goto finish;
1751                 }
1752
1753                 t = timeout_a;
1754                 if (t == (uint64_t) -1 || (timeout_b != (uint64_t) -1 && timeout_b < timeout_a))
1755                         t = timeout_b;
1756
1757                 if (t == (uint64_t) -1)
1758                         ts = NULL;
1759                 else {
1760                         usec_t nw;
1761
1762                         nw = now(CLOCK_MONOTONIC);
1763                         if (t > nw)
1764                                 t -= nw;
1765                         else
1766                                 t = 0;
1767
1768                         ts = timespec_store(&_ts, t);
1769                 }
1770
1771                 pollfd = (struct pollfd[3]) {
1772                         {.fd = fd,     .events = events_a,           },
1773                         {.fd = in_fd,  .events = events_b & POLLIN,  },
1774                         {.fd = out_fd, .events = events_b & POLLOUT, }
1775                 };
1776
1777                 r = ppoll(pollfd, 3, ts, NULL);
1778                 if (r < 0) {
1779                         log_error_errno(errno, "ppoll() failed: %m");
1780                         goto finish;
1781                 }
1782         }
1783
1784 finish:
1785         sd_notify(false,
1786                   "STOPPING=1\n"
1787                   "STATUS=Shutting down.");
1788
1789         policy_free(&policy_buffer);
1790         strv_free(arg_configuration);
1791         free(arg_address);
1792
1793         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1794 }