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         uid_t original_uid;
1286
1287         log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1288         log_parse_environment();
1289         log_open();
1290
1291         r = parse_argv(argc, argv);
1292         if (r <= 0)
1293                 goto finish;
1294
1295         r = sd_listen_fds(0);
1296         if (r == 0) {
1297                 in_fd = STDIN_FILENO;
1298                 out_fd = STDOUT_FILENO;
1299         } else if (r == 1) {
1300                 in_fd = SD_LISTEN_FDS_START;
1301                 out_fd = SD_LISTEN_FDS_START;
1302         } else {
1303                 log_error("Illegal number of file descriptors passed");
1304                 goto finish;
1305         }
1306
1307         original_uid = getuid();
1308
1309         is_unix =
1310                 sd_is_socket(in_fd, AF_UNIX, 0, 0) > 0 &&
1311                 sd_is_socket(out_fd, AF_UNIX, 0, 0) > 0;
1312
1313         if (is_unix) {
1314                 (void) getpeercred(in_fd, &ucred);
1315                 (void) getpeersec(in_fd, &peersec);
1316
1317                 r = mac_smack_apply_label_and_drop_cap_mac_admin(getpid(), peersec);
1318                 if (r < 0)
1319                         log_warning_errno(r, "Failed to set SMACK label (%s) and drop CAP_MAC_ADMIN: %m", peersec);
1320         }
1321
1322         if (arg_drop_privileges) {
1323                 const char *user = "systemd-bus-proxy";
1324                 uid_t uid;
1325                 gid_t gid;
1326
1327                 r = get_user_creds(&user, &uid, &gid, NULL, NULL);
1328                 if (r < 0) {
1329                         log_error_errno(r, "Cannot resolve user name %s: %m", user);
1330                         goto finish;
1331                 }
1332
1333                 r = drop_privileges(uid, gid, 1ULL << CAP_IPC_OWNER);
1334                 if (r < 0)
1335                         goto finish;
1336         }
1337
1338         owned_names = set_new(&string_hash_ops);
1339         if (!owned_names) {
1340                 log_oom();
1341                 goto finish;
1342         }
1343
1344         r = sd_bus_new(&a);
1345         if (r < 0) {
1346                 log_error_errno(r, "Failed to allocate bus: %m");
1347                 goto finish;
1348         }
1349
1350         r = sd_bus_set_description(a, "sd-proxy");
1351         if (r < 0) {
1352                 log_error_errno(r, "Failed to set bus name: %m");
1353                 goto finish;
1354         }
1355
1356         r = sd_bus_set_address(a, arg_address);
1357         if (r < 0) {
1358                 log_error_errno(r, "Failed to set address to connect to: %m");
1359                 goto finish;
1360         }
1361
1362         r = sd_bus_negotiate_fds(a, is_unix);
1363         if (r < 0) {
1364                 log_error_errno(r, "Failed to set FD negotiation: %m");
1365                 goto finish;
1366         }
1367
1368         r = sd_bus_negotiate_creds(a, true, SD_BUS_CREDS_UID|SD_BUS_CREDS_PID|SD_BUS_CREDS_GID|SD_BUS_CREDS_SELINUX_CONTEXT);
1369         if (r < 0) {
1370                 log_error_errno(r, "Failed to set credential negotiation: %m");
1371                 goto finish;
1372         }
1373
1374         if (ucred.pid > 0) {
1375                 a->fake_pids.pid = ucred.pid;
1376                 a->fake_pids_valid = true;
1377
1378                 a->fake_creds.uid = ucred.uid;
1379                 a->fake_creds.euid = UID_INVALID;
1380                 a->fake_creds.suid = UID_INVALID;
1381                 a->fake_creds.fsuid = UID_INVALID;
1382                 a->fake_creds.gid = ucred.gid;
1383                 a->fake_creds.egid = GID_INVALID;
1384                 a->fake_creds.sgid = GID_INVALID;
1385                 a->fake_creds.fsgid = GID_INVALID;
1386                 a->fake_creds_valid = true;
1387         }
1388
1389         if (peersec) {
1390                 a->fake_label = peersec;
1391                 peersec = NULL;
1392         }
1393
1394         a->manual_peer_interface = true;
1395
1396         r = sd_bus_start(a);
1397         if (r < 0) {
1398                 log_error_errno(r, "Failed to start bus client: %m");
1399                 goto finish;
1400         }
1401
1402         r = sd_bus_get_bus_id(a, &server_id);
1403         if (r < 0) {
1404                 log_error_errno(r, "Failed to get server ID: %m");
1405                 goto finish;
1406         }
1407
1408         if (a->is_kernel) {
1409                 if (!arg_configuration) {
1410                         const char *scope;
1411
1412                         r = sd_bus_get_scope(a, &scope);
1413                         if (r < 0) {
1414                                 log_error_errno(r, "Couldn't determine bus scope: %m");
1415                                 goto finish;
1416                         }
1417
1418                         if (streq(scope, "system"))
1419                                 arg_configuration = strv_new(
1420                                                 "/etc/dbus-1/system.conf",
1421                                                 "/etc/dbus-1/system.d/",
1422                                                 "/etc/dbus-1/system-local.conf",
1423                                                 NULL);
1424                         else if (streq(scope, "user"))
1425                                 arg_configuration = strv_new(
1426                                                 "/etc/dbus-1/session.conf",
1427                                                 "/etc/dbus-1/session.d/",
1428                                                 "/etc/dbus-1/session-local.conf",
1429                                                 NULL);
1430                         else {
1431                                 log_error("Unknown scope %s, don't know which policy to load. Refusing.", scope);
1432                                 goto finish;
1433                         }
1434
1435                         if (!arg_configuration) {
1436                                 r = log_oom();
1437                                 goto finish;
1438                         }
1439                 }
1440
1441                 r = policy_load(&policy_buffer, arg_configuration);
1442                 if (r < 0) {
1443                         log_error_errno(r, "Failed to load policy: %m");
1444                         goto finish;
1445                 }
1446
1447                 policy = &policy_buffer;
1448                 /* policy_dump(policy); */
1449
1450                 if (ucred.uid == original_uid)
1451                         log_debug("Permitting access, since bus owner matches bus client.");
1452                 else if (policy_check_hello(policy, ucred.uid, ucred.gid))
1453                         log_debug("Permitting access due to XML policy.");
1454                 else {
1455                         r = log_error_errno(EPERM, "Policy denied connection.");
1456                         goto finish;
1457                 }
1458         }
1459
1460         r = sd_bus_new(&b);
1461         if (r < 0) {
1462                 log_error_errno(r, "Failed to allocate bus: %m");
1463                 goto finish;
1464         }
1465
1466         r = sd_bus_set_fd(b, in_fd, out_fd);
1467         if (r < 0) {
1468                 log_error_errno(r, "Failed to set fds: %m");
1469                 goto finish;
1470         }
1471
1472         r = sd_bus_set_server(b, 1, server_id);
1473         if (r < 0) {
1474                 log_error_errno(r, "Failed to set server mode: %m");
1475                 goto finish;
1476         }
1477
1478         r = sd_bus_negotiate_fds(b, is_unix);
1479         if (r < 0) {
1480                 log_error_errno(r, "Failed to set FD negotiation: %m");
1481                 goto finish;
1482         }
1483
1484         r = sd_bus_negotiate_creds(b, true, SD_BUS_CREDS_UID|SD_BUS_CREDS_PID|SD_BUS_CREDS_GID|SD_BUS_CREDS_SELINUX_CONTEXT);
1485         if (r < 0) {
1486                 log_error_errno(r, "Failed to set credential negotiation: %m");
1487                 goto finish;
1488         }
1489
1490         r = sd_bus_set_anonymous(b, true);
1491         if (r < 0) {
1492                 log_error_errno(r, "Failed to set anonymous authentication: %m");
1493                 goto finish;
1494         }
1495
1496         b->manual_peer_interface = true;
1497
1498         r = sd_bus_start(b);
1499         if (r < 0) {
1500                 log_error_errno(r, "Failed to start bus client: %m");
1501                 goto finish;
1502         }
1503
1504         r = rename_service(a, b);
1505         if (r < 0)
1506                 log_debug_errno(r, "Failed to rename process: %m");
1507
1508         if (a->is_kernel) {
1509                 _cleanup_free_ char *match = NULL;
1510                 const char *unique;
1511
1512                 r = sd_bus_get_unique_name(a, &unique);
1513                 if (r < 0) {
1514                         log_error_errno(r, "Failed to get unique name: %m");
1515                         goto finish;
1516                 }
1517
1518                 match = strjoin("type='signal',"
1519                                 "sender='org.freedesktop.DBus',"
1520                                 "path='/org/freedesktop/DBus',"
1521                                 "interface='org.freedesktop.DBus',"
1522                                 "member='NameOwnerChanged',"
1523                                 "arg1='",
1524                                 unique,
1525                                 "'",
1526                                 NULL);
1527                 if (!match) {
1528                         log_oom();
1529                         goto finish;
1530                 }
1531
1532                 r = sd_bus_add_match(a, NULL, match, NULL, NULL);
1533                 if (r < 0) {
1534                         log_error_errno(r, "Failed to add match for NameLost: %m");
1535                         goto finish;
1536                 }
1537
1538                 free(match);
1539                 match = strjoin("type='signal',"
1540                                 "sender='org.freedesktop.DBus',"
1541                                 "path='/org/freedesktop/DBus',"
1542                                 "interface='org.freedesktop.DBus',"
1543                                 "member='NameOwnerChanged',"
1544                                 "arg2='",
1545                                 unique,
1546                                 "'",
1547                                 NULL);
1548                 if (!match) {
1549                         log_oom();
1550                         goto finish;
1551                 }
1552
1553                 r = sd_bus_add_match(a, NULL, match, NULL, NULL);
1554                 if (r < 0) {
1555                         log_error_errno(r, "Failed to add match for NameAcquired: %m");
1556                         goto finish;
1557                 }
1558         }
1559
1560         for (;;) {
1561                 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1562                 int events_a, events_b, fd;
1563                 uint64_t timeout_a, timeout_b, t;
1564                 struct timespec _ts, *ts;
1565                 struct pollfd *pollfd;
1566                 int k;
1567
1568                 if (got_hello) {
1569                         /* Read messages from bus, to pass them on to our client */
1570
1571                         r = sd_bus_process(a, &m);
1572                         if (r < 0) {
1573                                 /* treat 'connection reset by peer' as clean exit condition */
1574                                 if (r == -ECONNRESET)
1575                                         r = 0;
1576                                 else
1577                                         log_error_errno(r, "Failed to process bus a: %m");
1578
1579                                 goto finish;
1580                         }
1581
1582                         if (m) {
1583                                 bool processed = false;
1584
1585                                 /* We officially got EOF, let's quit */
1586                                 if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected")) {
1587                                         r = 0;
1588                                         goto finish;
1589                                 }
1590
1591                                 k = synthesize_name_acquired(a, b, m);
1592                                 if (k < 0) {
1593                                         r = k;
1594                                         log_error_errno(r, "Failed to synthesize message: %m");
1595                                         goto finish;
1596                                 }
1597
1598                                 patch_sender(a, m);
1599
1600                                 if (policy) {
1601                                         k = process_policy(a, b, m, policy, &ucred, owned_names);
1602                                         if (k < 0) {
1603                                                 r = k;
1604                                                 log_error_errno(r, "Failed to process policy: %m");
1605                                                 goto finish;
1606                                         } else if (k > 0) {
1607                                                 r = 1;
1608                                                 processed = true;
1609                                         }
1610                                 }
1611
1612                                 if (!processed) {
1613                                         k = sd_bus_send(b, m, NULL);
1614                                         if (k < 0) {
1615                                                 if (k == -ECONNRESET) {
1616                                                         r = 0;
1617                                                         goto finish;
1618                                                 } else if (k == -EPERM && m->reply_cookie > 0) {
1619                                                         /* If the peer tries to send a reply and it is rejected with EPERM
1620                                                          * by the kernel, we ignore the error. This catches cases where the
1621                                                          * original method-call didn't had EXPECT_REPLY set, but the proxy-peer
1622                                                          * still sends a reply. This is allowed in dbus1, but not in kdbus. We
1623                                                          * don't want to track reply-windows in the proxy, so we simply ignore
1624                                                          * EPERM for all replies. The only downside is, that callers are no
1625                                                          * longer notified if their replies are dropped. However, this is
1626                                                          * equivalent to the caller's timeout to expire, so this should be
1627                                                          * acceptable. Nobody sane sends replies without a matching method-call,
1628                                                          * so nobody should care. */
1629                                                         r = 1;
1630                                                 } else {
1631                                                         r = k;
1632                                                         log_error_errno(r, "Failed to send message to client: %m");
1633                                                         goto finish;
1634                                                 }
1635                                         } else
1636                                                 r = 1;
1637                                 }
1638                         }
1639
1640                         if (r > 0)
1641                                 continue;
1642                 }
1643
1644                 /* Read messages from our client, to pass them on to the bus */
1645                 r = sd_bus_process(b, &m);
1646                 if (r < 0) {
1647                         /* treat 'connection reset by peer' as clean exit condition */
1648                         if (r == -ECONNRESET)
1649                                 r = 0;
1650                         else
1651                                 log_error_errno(r, "Failed to process bus b: %m");
1652
1653                         goto finish;
1654                 }
1655
1656                 if (m) {
1657                         bool processed = false;
1658
1659                         /* We officially got EOF, let's quit */
1660                         if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected")) {
1661                                 r = 0;
1662                                 goto finish;
1663                         }
1664
1665                         k = process_hello(a, b, m, &got_hello);
1666                         if (k < 0) {
1667                                 r = k;
1668                                 log_error_errno(r, "Failed to process HELLO: %m");
1669                                 goto finish;
1670                         } else if (k > 0) {
1671                                 processed = true;
1672                                 r = 1;
1673                         }
1674
1675                         if (!processed) {
1676                                 k = process_driver(a, b, m, policy, &ucred, owned_names);
1677                                 if (k < 0) {
1678                                         r = k;
1679                                         log_error_errno(r, "Failed to process driver calls: %m");
1680                                         goto finish;
1681                                 } else if (k > 0) {
1682                                         processed = true;
1683                                         r = 1;
1684                                 }
1685
1686                                 if (!processed) {
1687
1688                                         for (;;) {
1689                                                 if (policy) {
1690                                                         k = process_policy(b, a, m, policy, &ucred, owned_names);
1691                                                         if (k < 0) {
1692                                                                 r = k;
1693                                                                 log_error_errno(r, "Failed to process policy: %m");
1694                                                                 goto finish;
1695                                                         } else if (k > 0) {
1696                                                                 processed = true;
1697                                                                 r = 1;
1698                                                                 break;
1699                                                         }
1700                                                 }
1701
1702                                                 k = sd_bus_send(a, m, NULL);
1703                                                 if (k < 0) {
1704                                                         if (k == -EREMCHG) {
1705                                                                 /* The name database changed since the policy check, hence let's check again */
1706                                                                 continue;
1707                                                         } else if (k == -ECONNRESET) {
1708                                                                 r = 0;
1709                                                                 goto finish;
1710                                                         } else if (k == -EPERM && m->reply_cookie > 0) {
1711                                                                 /* see above why EPERM is ignored for replies */
1712                                                                 r = 1;
1713                                                         } else {
1714                                                                 r = k;
1715                                                                 log_error_errno(r, "Failed to send message to bus: %m");
1716                                                                 goto finish;
1717                                                         }
1718                                                 } else
1719                                                         r = 1;
1720
1721                                                 break;
1722                                         }
1723                                 }
1724                         }
1725                 }
1726
1727                 if (r > 0)
1728                         continue;
1729
1730                 fd = sd_bus_get_fd(a);
1731                 if (fd < 0) {
1732                         log_error_errno(r, "Failed to get fd: %m");
1733                         goto finish;
1734                 }
1735
1736                 events_a = sd_bus_get_events(a);
1737                 if (events_a < 0) {
1738                         log_error_errno(r, "Failed to get events mask: %m");
1739                         goto finish;
1740                 }
1741
1742                 r = sd_bus_get_timeout(a, &timeout_a);
1743                 if (r < 0) {
1744                         log_error_errno(r, "Failed to get timeout: %m");
1745                         goto finish;
1746                 }
1747
1748                 events_b = sd_bus_get_events(b);
1749                 if (events_b < 0) {
1750                         log_error_errno(r, "Failed to get events mask: %m");
1751                         goto finish;
1752                 }
1753
1754                 r = sd_bus_get_timeout(b, &timeout_b);
1755                 if (r < 0) {
1756                         log_error_errno(r, "Failed to get timeout: %m");
1757                         goto finish;
1758                 }
1759
1760                 t = timeout_a;
1761                 if (t == (uint64_t) -1 || (timeout_b != (uint64_t) -1 && timeout_b < timeout_a))
1762                         t = timeout_b;
1763
1764                 if (t == (uint64_t) -1)
1765                         ts = NULL;
1766                 else {
1767                         usec_t nw;
1768
1769                         nw = now(CLOCK_MONOTONIC);
1770                         if (t > nw)
1771                                 t -= nw;
1772                         else
1773                                 t = 0;
1774
1775                         ts = timespec_store(&_ts, t);
1776                 }
1777
1778                 pollfd = (struct pollfd[3]) {
1779                         {.fd = fd,     .events = events_a,           },
1780                         {.fd = in_fd,  .events = events_b & POLLIN,  },
1781                         {.fd = out_fd, .events = events_b & POLLOUT, }
1782                 };
1783
1784                 r = ppoll(pollfd, 3, ts, NULL);
1785                 if (r < 0) {
1786                         log_error_errno(errno, "ppoll() failed: %m");
1787                         goto finish;
1788                 }
1789         }
1790
1791 finish:
1792         sd_notify(false,
1793                   "STOPPING=1\n"
1794                   "STATUS=Shutting down.");
1795
1796         policy_free(&policy_buffer);
1797         strv_free(arg_configuration);
1798         free(arg_address);
1799
1800         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1801 }