src/shared/bus-util.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2013 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include <errno.h>
  21 #include <fcntl.h>
  22 #include <inttypes.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <sys/ioctl.h>
  27 #include <sys/resource.h>
  28 #include <sys/socket.h>
  29 #include <unistd.h>
  30
  31 #include "sd-bus-protocol.h"
  32 #include "sd-bus.h"
  33 #include "sd-daemon.h"
  34 #include "sd-event.h"
  35 #include "sd-id128.h"
  36
  37 #include "alloc-util.h"
  38 #include "bus-internal.h"
  39 #include "bus-label.h"
  40 #include "bus-message.h"
  41 #include "bus-util.h"
  42 #include "def.h"
  43 #include "escape.h"
  44 #include "fd-util.h"
  45 #include "missing.h"
  46 #include "parse-util.h"
  47 #include "proc-cmdline.h"
  48 #include "rlimit-util.h"
  49 #include "stdio-util.h"
  50 #include "strv.h"
  51 #include "user-util.h"
  52
  53 static int name_owner_change_callback(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
  54         sd_event *e = userdata;
  55
  56         assert(m);
  57         assert(e);
  58
  59         sd_bus_close(sd_bus_message_get_bus(m));
  60         sd_event_exit(e, 0);
  61
  62         return 1;
  63 }
  64
  65 int bus_async_unregister_and_exit(sd_event *e, sd_bus *bus, const char *name) {
  66         _cleanup_free_ char *match = NULL;
  67         const char *unique;
  68         int r;
  69
  70         assert(e);
  71         assert(bus);
  72         assert(name);
  73
  74         /* We unregister the name here and then wait for the
  75          * NameOwnerChanged signal for this event to arrive before we
  76          * quit. We do this in order to make sure that any queued
  77          * requests are still processed before we really exit. */
  78
  79         r = sd_bus_get_unique_name(bus, &unique);
  80         if (r < 0)
  81                 return r;
  82
  83         r = asprintf(&match,
  84                      "sender='org.freedesktop.DBus',"
  85                      "type='signal',"
  86                      "interface='org.freedesktop.DBus',"
  87                      "member='NameOwnerChanged',"
  88                      "path='/org/freedesktop/DBus',"
  89                      "arg0='%s',"
  90                      "arg1='%s',"
  91                      "arg2=''", name, unique);
  92         if (r < 0)
  93                 return -ENOMEM;
  94
  95         r = sd_bus_add_match(bus, NULL, match, name_owner_change_callback, e);
  96         if (r < 0)
  97                 return r;
  98
  99         r = sd_bus_release_name(bus, name);
 100         if (r < 0)
 101                 return r;
 102
 103         return 0;
 104 }
 105
 106 int bus_event_loop_with_idle(
 107                 sd_event *e,
 108                 sd_bus *bus,
 109                 const char *name,
 110                 usec_t timeout,
 111                 check_idle_t check_idle,
 112                 void *userdata) {
 113         bool exiting = false;
 114         int r, code;
 115
 116         assert(e);
 117         assert(bus);
 118         assert(name);
 119
 120         for (;;) {
 121                 bool idle;
 122
 123                 r = sd_event_get_state(e);
 124                 if (r < 0)
 125                         return r;
 126                 if (r == SD_EVENT_FINISHED)
 127                         break;
 128
 129                 if (check_idle)
 130                         idle = check_idle(userdata);
 131                 else
 132                         idle = true;
 133
 134                 r = sd_event_run(e, exiting || !idle ? (uint64_t) -1 : timeout);
 135                 if (r < 0)
 136                         return r;
 137
 138                 if (r == 0 && !exiting && idle) {
 139
 140                         r = sd_bus_try_close(bus);
 141                         if (r == -EBUSY)
 142                                 continue;
 143
 144                         /* Fallback for dbus1 connections: we
 145                          * unregister the name and wait for the
 146                          * response to come through for it */
 147                         if (r == -EOPNOTSUPP) {
 148
 149                                 /* Inform the service manager that we
 150                                  * are going down, so that it will
 151                                  * queue all further start requests,
 152                                  * instead of assuming we are already
 153                                  * running. */
 154                                 sd_notify(false, "STOPPING=1");
 155
 156                                 r = bus_async_unregister_and_exit(e, bus, name);
 157                                 if (r < 0)
 158                                         return r;
 159
 160                                 exiting = true;
 161                                 continue;
 162                         }
 163
 164                         if (r < 0)
 165                                 return r;
 166
 167                         sd_event_exit(e, 0);
 168                         break;
 169                 }
 170         }
 171
 172         r = sd_event_get_exit_code(e, &code);
 173         if (r < 0)
 174                 return r;
 175
 176         return code;
 177 }
 178
 179 int bus_name_has_owner(sd_bus *c, const char *name, sd_bus_error *error) {
 180         _cleanup_(sd_bus_message_unrefp) sd_bus_message *rep = NULL;
 181         int r, has_owner = 0;
 182
 183         assert(c);
 184         assert(name);
 185
 186         r = sd_bus_call_method(c,
 187                                "org.freedesktop.DBus",
 188                                "/org/freedesktop/dbus",
 189                                "org.freedesktop.DBus",
 190                                "NameHasOwner",
 191                                error,
 192                                &rep,
 193                                "s",
 194                                name);
 195         if (r < 0)
 196                 return r;
 197
 198         r = sd_bus_message_read_basic(rep, 'b', &has_owner);
 199         if (r < 0)
 200                 return sd_bus_error_set_errno(error, r);
 201
 202         return has_owner;
 203 }
 204
 205 static int check_good_user(sd_bus_message *m, uid_t good_user) {
 206         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
 207         uid_t sender_uid;
 208         int r;
 209
 210         assert(m);
 211
 212         if (good_user == UID_INVALID)
 213                 return 0;
 214
 215         r = sd_bus_query_sender_creds(m, SD_BUS_CREDS_EUID, &creds);
 216         if (r < 0)
 217                 return r;
 218
 219         /* Don't trust augmented credentials for authorization */
 220         assert_return((sd_bus_creds_get_augmented_mask(creds) & SD_BUS_CREDS_EUID) == 0, -EPERM);
 221
 222         r = sd_bus_creds_get_euid(creds, &sender_uid);
 223         if (r < 0)
 224                 return r;
 225
 226         return sender_uid == good_user;
 227 }
 228
 229 int bus_test_polkit(
 230                 sd_bus_message *call,
 231                 int capability,
 232                 const char *action,
 233                 const char **details,
 234                 uid_t good_user,
 235                 bool *_challenge,
 236                 sd_bus_error *e) {
 237
 238         int r;
 239
 240         assert(call);
 241         assert(action);
 242
 243         /* Tests non-interactively! */
 244
 245         r = check_good_user(call, good_user);
 246         if (r != 0)
 247                 return r;
 248
 249         r = sd_bus_query_sender_privilege(call, capability);
 250         if (r < 0)
 251                 return r;
 252         else if (r > 0)
 253                 return 1;
 254 #ifdef ENABLE_POLKIT
 255         else {
 256                 _cleanup_(sd_bus_message_unrefp) sd_bus_message *request = NULL;
 257                 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 258                 int authorized = false, challenge = false;
 259                 const char *sender, **k, **v;
 260
 261                 sender = sd_bus_message_get_sender(call);
 262                 if (!sender)
 263                         return -EBADMSG;
 264
 265                 r = sd_bus_message_new_method_call(
 266                                 call->bus,
 267                                 &request,
 268                                 "org.freedesktop.PolicyKit1",
 269                                 "/org/freedesktop/PolicyKit1/Authority",
 270                                 "org.freedesktop.PolicyKit1.Authority",
 271                                 "CheckAuthorization");
 272                 if (r < 0)
 273                         return r;
 274
 275                 r = sd_bus_message_append(
 276                                 request,
 277                                 "(sa{sv})s",
 278                                 "system-bus-name", 1, "name", "s", sender,
 279                                 action);
 280                 if (r < 0)
 281                         return r;
 282
 283                 r = sd_bus_message_open_container(request, 'a', "{ss}");
 284                 if (r < 0)
 285                         return r;
 286
 287                 STRV_FOREACH_PAIR(k, v, details) {
 288                         r = sd_bus_message_append(request, "{ss}", *k, *v);
 289                         if (r < 0)
 290                                 return r;
 291                 }
 292
 293                 r = sd_bus_message_close_container(request);
 294                 if (r < 0)
 295                         return r;
 296
 297                 r = sd_bus_message_append(request, "us", 0, NULL);
 298                 if (r < 0)
 299                         return r;
 300
 301                 r = sd_bus_call(call->bus, request, 0, e, &reply);
 302                 if (r < 0) {
 303                         /* Treat no PK available as access denied */
 304                         if (sd_bus_error_has_name(e, SD_BUS_ERROR_SERVICE_UNKNOWN)) {
 305                                 sd_bus_error_free(e);
 306                                 return -EACCES;
 307                         }
 308
 309                         return r;
 310                 }
 311
 312                 r = sd_bus_message_enter_container(reply, 'r', "bba{ss}");
 313                 if (r < 0)
 314                         return r;
 315
 316                 r = sd_bus_message_read(reply, "bb", &authorized, &challenge);
 317                 if (r < 0)
 318                         return r;
 319
 320                 if (authorized)
 321                         return 1;
 322
 323                 if (_challenge) {
 324                         *_challenge = challenge;
 325                         return 0;
 326                 }
 327         }
 328 #endif
 329
 330         return -EACCES;
 331 }
 332
 333 #ifdef ENABLE_POLKIT
 334
 335 typedef struct AsyncPolkitQuery {
 336         sd_bus_message *request, *reply;
 337         sd_bus_message_handler_t callback;
 338         void *userdata;
 339         sd_bus_slot *slot;
 340         Hashmap *registry;
 341 } AsyncPolkitQuery;
 342
 343 static void async_polkit_query_free(AsyncPolkitQuery *q) {
 344
 345         if (!q)
 346                 return;
 347
 348         sd_bus_slot_unref(q->slot);
 349
 350         if (q->registry && q->request)
 351                 hashmap_remove(q->registry, q->request);
 352
 353         sd_bus_message_unref(q->request);
 354         sd_bus_message_unref(q->reply);
 355
 356         free(q);
 357 }
 358
 359 static int async_polkit_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
 360         _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
 361         AsyncPolkitQuery *q = userdata;
 362         int r;
 363
 364         assert(reply);
 365         assert(q);
 366
 367         q->slot = sd_bus_slot_unref(q->slot);
 368         q->reply = sd_bus_message_ref(reply);
 369
 370         r = sd_bus_message_rewind(q->request, true);
 371         if (r < 0) {
 372                 r = sd_bus_reply_method_errno(q->request, r, NULL);
 373                 goto finish;
 374         }
 375
 376         r = q->callback(q->request, q->userdata, &error_buffer);
 377         r = bus_maybe_reply_error(q->request, r, &error_buffer);
 378
 379 finish:
 380         async_polkit_query_free(q);
 381
 382         return r;
 383 }
 384
 385 #endif
 386
 387 int bus_verify_polkit_async(
 388                 sd_bus_message *call,
 389                 int capability,
 390                 const char *action,
 391                 const char **details,
 392                 bool interactive,
 393                 uid_t good_user,
 394                 Hashmap **registry,
 395                 sd_bus_error *error) {
 396
 397 #ifdef ENABLE_POLKIT
 398         _cleanup_(sd_bus_message_unrefp) sd_bus_message *pk = NULL;
 399         AsyncPolkitQuery *q;
 400         const char *sender, **k, **v;
 401         sd_bus_message_handler_t callback;
 402         void *userdata;
 403         int c;
 404 #endif
 405         int r;
 406
 407         assert(call);
 408         assert(action);
 409         assert(registry);
 410
 411         r = check_good_user(call, good_user);
 412         if (r != 0)
 413                 return r;
 414
 415 #ifdef ENABLE_POLKIT
 416         q = hashmap_get(*registry, call);
 417         if (q) {
 418                 int authorized, challenge;
 419
 420                 /* This is the second invocation of this function, and
 421                  * there's already a response from polkit, let's
 422                  * process it */
 423                 assert(q->reply);
 424
 425                 if (sd_bus_message_is_method_error(q->reply, NULL)) {
 426                         const sd_bus_error *e;
 427
 428                         /* Copy error from polkit reply */
 429                         e = sd_bus_message_get_error(q->reply);
 430                         sd_bus_error_copy(error, e);
 431
 432                         /* Treat no PK available as access denied */
 433                         if (sd_bus_error_has_name(e, SD_BUS_ERROR_SERVICE_UNKNOWN))
 434                                 return -EACCES;
 435
 436                         return -sd_bus_error_get_errno(e);
 437                 }
 438
 439                 r = sd_bus_message_enter_container(q->reply, 'r', "bba{ss}");
 440                 if (r >= 0)
 441                         r = sd_bus_message_read(q->reply, "bb", &authorized, &challenge);
 442
 443                 if (r < 0)
 444                         return r;
 445
 446                 if (authorized)
 447                         return 1;
 448
 449                 if (challenge)
 450                         return sd_bus_error_set(error, SD_BUS_ERROR_INTERACTIVE_AUTHORIZATION_REQUIRED, "Interactive authentication required.");
 451
 452                 return -EACCES;
 453         }
 454 #endif
 455
 456         r = sd_bus_query_sender_privilege(call, capability);
 457         if (r < 0)
 458                 return r;
 459         else if (r > 0)
 460                 return 1;
 461
 462 #ifdef ENABLE_POLKIT
 463         if (sd_bus_get_current_message(call->bus) != call)
 464                 return -EINVAL;
 465
 466         callback = sd_bus_get_current_handler(call->bus);
 467         if (!callback)
 468                 return -EINVAL;
 469
 470         userdata = sd_bus_get_current_userdata(call->bus);
 471
 472         sender = sd_bus_message_get_sender(call);
 473         if (!sender)
 474                 return -EBADMSG;
 475
 476         c = sd_bus_message_get_allow_interactive_authorization(call);
 477         if (c < 0)
 478                 return c;
 479         if (c > 0)
 480                 interactive = true;
 481
 482         r = hashmap_ensure_allocated(registry, NULL);
 483         if (r < 0)
 484                 return r;
 485
 486         r = sd_bus_message_new_method_call(
 487                         call->bus,
 488                         &pk,
 489                         "org.freedesktop.PolicyKit1",
 490                         "/org/freedesktop/PolicyKit1/Authority",
 491                         "org.freedesktop.PolicyKit1.Authority",
 492                         "CheckAuthorization");
 493         if (r < 0)
 494                 return r;
 495
 496         r = sd_bus_message_append(
 497                         pk,
 498                         "(sa{sv})s",
 499                         "system-bus-name", 1, "name", "s", sender,
 500                         action);
 501         if (r < 0)
 502                 return r;
 503
 504         r = sd_bus_message_open_container(pk, 'a', "{ss}");
 505         if (r < 0)
 506                 return r;
 507
 508         STRV_FOREACH_PAIR(k, v, details) {
 509                 r = sd_bus_message_append(pk, "{ss}", *k, *v);
 510                 if (r < 0)
 511                         return r;
 512         }
 513
 514         r = sd_bus_message_close_container(pk);
 515         if (r < 0)
 516                 return r;
 517
 518         r = sd_bus_message_append(pk, "us", !!interactive, NULL);
 519         if (r < 0)
 520                 return r;
 521
 522         q = new0(AsyncPolkitQuery, 1);
 523         if (!q)
 524                 return -ENOMEM;
 525
 526         q->request = sd_bus_message_ref(call);
 527         q->callback = callback;
 528         q->userdata = userdata;
 529
 530         r = hashmap_put(*registry, call, q);
 531         if (r < 0) {
 532                 async_polkit_query_free(q);
 533                 return r;
 534         }
 535
 536         q->registry = *registry;
 537
 538         r = sd_bus_call_async(call->bus, &q->slot, pk, async_polkit_callback, q, 0);
 539         if (r < 0) {
 540                 async_polkit_query_free(q);
 541                 return r;
 542         }
 543
 544         return 0;
 545 #endif
 546
 547         return -EACCES;
 548 }
 549
 550 void bus_verify_polkit_async_registry_free(Hashmap *registry) {
 551 #ifdef ENABLE_POLKIT
 552         AsyncPolkitQuery *q;
 553
 554         while ((q = hashmap_steal_first(registry)))
 555                 async_polkit_query_free(q);
 556
 557         hashmap_free(registry);
 558 #endif
 559 }
 560
 561 int bus_check_peercred(sd_bus *c) {
 562         struct ucred ucred;
 563         socklen_t l;
 564         int fd;
 565
 566         assert(c);
 567
 568         fd = sd_bus_get_fd(c);
 569         if (fd < 0)
 570                 return fd;
 571
 572         l = sizeof(struct ucred);
 573         if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
 574                 return -errno;
 575
 576         if (l != sizeof(struct ucred))
 577                 return -E2BIG;
 578
 579         if (ucred.uid != 0 && ucred.uid != geteuid())
 580                 return -EPERM;
 581
 582         return 1;
 583 }
 584
 585 int bus_connect_system_systemd(sd_bus **_bus) {
 586         _cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
 587         int r;
 588
 589         assert(_bus);
 590
 591         if (geteuid() != 0)
 592                 return sd_bus_default_system(_bus);
 593
 594         /* If we are root and kdbus is not available, then let's talk
 595          * directly to the system instance, instead of going via the
 596          * bus */
 597
 598         r = sd_bus_new(&bus);
 599         if (r < 0)
 600                 return r;
 601
 602         r = sd_bus_set_address(bus, KERNEL_SYSTEM_BUS_ADDRESS);
 603         if (r < 0)
 604                 return r;
 605
 606         bus->bus_client = true;
 607
 608         r = sd_bus_start(bus);
 609         if (r >= 0) {
 610                 *_bus = bus;
 611                 bus = NULL;
 612                 return 0;
 613         }
 614
 615         bus = sd_bus_unref(bus);
 616
 617         r = sd_bus_new(&bus);
 618         if (r < 0)
 619                 return r;
 620
 621         r = sd_bus_set_address(bus, "unix:path=/run/systemd/private");
 622         if (r < 0)
 623                 return r;
 624
 625         r = sd_bus_start(bus);
 626         if (r < 0)
 627                 return sd_bus_default_system(_bus);
 628
 629         r = bus_check_peercred(bus);
 630         if (r < 0)
 631                 return r;
 632
 633         *_bus = bus;
 634         bus = NULL;
 635
 636         return 0;
 637 }
 638
 639 int bus_connect_user_systemd(sd_bus **_bus) {
 640         _cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
 641         _cleanup_free_ char *ee = NULL;
 642         const char *e;
 643         int r;
 644
 645         /* Try via kdbus first, and then directly */
 646
 647         assert(_bus);
 648
 649         r = sd_bus_new(&bus);
 650         if (r < 0)
 651                 return r;
 652
 653         if (asprintf(&bus->address, KERNEL_USER_BUS_ADDRESS_FMT, getuid()) < 0)
 654                 return -ENOMEM;
 655
 656         bus->bus_client = true;
 657
 658         r = sd_bus_start(bus);
 659         if (r >= 0) {
 660                 *_bus = bus;
 661                 bus = NULL;
 662                 return 0;
 663         }
 664
 665         bus = sd_bus_unref(bus);
 666
 667         e = secure_getenv("XDG_RUNTIME_DIR");
 668         if (!e)
 669                 return sd_bus_default_user(_bus);
 670
 671         ee = bus_address_escape(e);
 672         if (!ee)
 673                 return -ENOMEM;
 674
 675         r = sd_bus_new(&bus);
 676         if (r < 0)
 677                 return r;
 678
 679         bus->address = strjoin("unix:path=", ee, "/systemd/private", NULL);
 680         if (!bus->address)
 681                 return -ENOMEM;
 682
 683         r = sd_bus_start(bus);
 684         if (r < 0)
 685                 return sd_bus_default_user(_bus);
 686
 687         r = bus_check_peercred(bus);
 688         if (r < 0)
 689                 return r;
 690
 691         *_bus = bus;
 692         bus = NULL;
 693
 694         return 0;
 695 }
 696
 697 #define print_property(name, fmt, ...)                                  \
 698         do {                                                            \
 699                 if (value)                                              \
 700                         printf(fmt "\n", __VA_ARGS__);                  \
 701                 else                                                    \
 702                         printf("%s=" fmt "\n", name, __VA_ARGS__);      \
 703         } while(0)
 704
 705 int bus_print_property(const char *name, sd_bus_message *property, bool value, bool all) {
 706         char type;
 707         const char *contents;
 708         int r;
 709
 710         assert(name);
 711         assert(property);
 712
 713         r = sd_bus_message_peek_type(property, &type, &contents);
 714         if (r < 0)
 715                 return r;
 716
 717         switch (type) {
 718
 719         case SD_BUS_TYPE_STRING: {
 720                 const char *s;
 721
 722                 r = sd_bus_message_read_basic(property, type, &s);
 723                 if (r < 0)
 724                         return r;
 725
 726                 if (all || !isempty(s)) {
 727                         _cleanup_free_ char *escaped = NULL;
 728
 729                         escaped = xescape(s, "\n");
 730                         if (!escaped)
 731                                 return -ENOMEM;
 732
 733                         print_property(name, "%s", escaped);
 734                 }
 735
 736                 return 1;
 737         }
 738
 739         case SD_BUS_TYPE_BOOLEAN: {
 740                 int b;
 741
 742                 r = sd_bus_message_read_basic(property, type, &b);
 743                 if (r < 0)
 744                         return r;
 745
 746                 print_property(name, "%s", yes_no(b));
 747
 748                 return 1;
 749         }
 750
 751         case SD_BUS_TYPE_UINT64: {
 752                 uint64_t u;
 753
 754                 r = sd_bus_message_read_basic(property, type, &u);
 755                 if (r < 0)
 756                         return r;
 757
 758                 /* Yes, heuristics! But we can change this check
 759                  * should it turn out to not be sufficient */
 760
 761                 if (endswith(name, "Timestamp")) {
 762                         char timestamp[FORMAT_TIMESTAMP_MAX], *t;
 763
 764                         t = format_timestamp(timestamp, sizeof(timestamp), u);
 765                         if (t || all)
 766                                 print_property(name, "%s", strempty(t));
 767
 768                 } else if (strstr(name, "USec")) {
 769                         char timespan[FORMAT_TIMESPAN_MAX];
 770
 771                         print_property(name, "%s", format_timespan(timespan, sizeof(timespan), u, 0));
 772                 } else
 773                         print_property(name, "%"PRIu64, u);
 774
 775                 return 1;
 776         }
 777
 778         case SD_BUS_TYPE_INT64: {
 779                 int64_t i;
 780
 781                 r = sd_bus_message_read_basic(property, type, &i);
 782                 if (r < 0)
 783                         return r;
 784
 785                 print_property(name, "%"PRIi64, i);
 786
 787                 return 1;
 788         }
 789
 790         case SD_BUS_TYPE_UINT32: {
 791                 uint32_t u;
 792
 793                 r = sd_bus_message_read_basic(property, type, &u);
 794                 if (r < 0)
 795                         return r;
 796
 797                 if (strstr(name, "UMask") || strstr(name, "Mode"))
 798                         print_property(name, "%04o", u);
 799                 else
 800                         print_property(name, "%"PRIu32, u);
 801
 802                 return 1;
 803         }
 804
 805         case SD_BUS_TYPE_INT32: {
 806                 int32_t i;
 807
 808                 r = sd_bus_message_read_basic(property, type, &i);
 809                 if (r < 0)
 810                         return r;
 811
 812                 print_property(name, "%"PRIi32, i);
 813                 return 1;
 814         }
 815
 816         case SD_BUS_TYPE_DOUBLE: {
 817                 double d;
 818
 819                 r = sd_bus_message_read_basic(property, type, &d);
 820                 if (r < 0)
 821                         return r;
 822
 823                 print_property(name, "%g", d);
 824                 return 1;
 825         }
 826
 827         case SD_BUS_TYPE_ARRAY:
 828                 if (streq(contents, "s")) {
 829                         bool first = true;
 830                         const char *str;
 831
 832                         r = sd_bus_message_enter_container(property, SD_BUS_TYPE_ARRAY, contents);
 833                         if (r < 0)
 834                                 return r;
 835
 836                         while ((r = sd_bus_message_read_basic(property, SD_BUS_TYPE_STRING, &str)) > 0) {
 837                                 _cleanup_free_ char *escaped = NULL;
 838
 839                                 if (first && !value)
 840                                         printf("%s=", name);
 841
 842                                 escaped = xescape(str, "\n ");
 843                                 if (!escaped)
 844                                         return -ENOMEM;
 845
 846                                 printf("%s%s", first ? "" : " ", escaped);
 847
 848                                 first = false;
 849                         }
 850                         if (r < 0)
 851                                 return r;
 852
 853                         if (first && all && !value)
 854                                 printf("%s=", name);
 855                         if (!first || all)
 856                                 puts("");
 857
 858                         r = sd_bus_message_exit_container(property);
 859                         if (r < 0)
 860                                 return r;
 861
 862                         return 1;
 863
 864                 } else if (streq(contents, "y")) {
 865                         const uint8_t *u;
 866                         size_t n;
 867
 868                         r = sd_bus_message_read_array(property, SD_BUS_TYPE_BYTE, (const void**) &u, &n);
 869                         if (r < 0)
 870                                 return r;
 871
 872                         if (all || n > 0) {
 873                                 unsigned int i;
 874
 875                                 if (!value)
 876                                         printf("%s=", name);
 877
 878                                 for (i = 0; i < n; i++)
 879                                         printf("%02x", u[i]);
 880
 881                                 puts("");
 882                         }
 883
 884                         return 1;
 885
 886                 } else if (streq(contents, "u")) {
 887                         uint32_t *u;
 888                         size_t n;
 889
 890                         r = sd_bus_message_read_array(property, SD_BUS_TYPE_UINT32, (const void**) &u, &n);
 891                         if (r < 0)
 892                                 return r;
 893
 894                         if (all || n > 0) {
 895                                 unsigned int i;
 896
 897                                 if (!value)
 898                                         printf("%s=", name);
 899
 900                                 for (i = 0; i < n; i++)
 901                                         printf("%08x", u[i]);
 902
 903                                 puts("");
 904                         }
 905
 906                         return 1;
 907                 }
 908
 909                 break;
 910         }
 911
 912         return 0;
 913 }
 914
 915 int bus_print_all_properties(sd_bus *bus, const char *dest, const char *path, char **filter, bool value, bool all) {
 916         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 917         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 918         int r;
 919
 920         assert(bus);
 921         assert(path);
 922
 923         r = sd_bus_call_method(bus,
 924                         dest,
 925                         path,
 926                         "org.freedesktop.DBus.Properties",
 927                         "GetAll",
 928                         &error,
 929                         &reply,
 930                         "s", "");
 931         if (r < 0)
 932                 return r;
 933
 934         r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "{sv}");
 935         if (r < 0)
 936                 return r;
 937
 938         while ((r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
 939                 const char *name;
 940                 const char *contents;
 941
 942                 r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_STRING, &name);
 943                 if (r < 0)
 944                         return r;
 945
 946                 if (!filter || strv_find(filter, name)) {
 947                         r = sd_bus_message_peek_type(reply, NULL, &contents);
 948                         if (r < 0)
 949                                 return r;
 950
 951                         r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_VARIANT, contents);
 952                         if (r < 0)
 953                                 return r;
 954
 955                         r = bus_print_property(name, reply, value, all);
 956                         if (r < 0)
 957                                 return r;
 958                         if (r == 0) {
 959                                 if (all)
 960                                         printf("%s=[unprintable]\n", name);
 961                                 /* skip what we didn't read */
 962                                 r = sd_bus_message_skip(reply, contents);
 963                                 if (r < 0)
 964                                         return r;
 965                         }
 966
 967                         r = sd_bus_message_exit_container(reply);
 968                         if (r < 0)
 969                                 return r;
 970                 } else {
 971                         r = sd_bus_message_skip(reply, "v");
 972                         if (r < 0)
 973                                 return r;
 974                 }
 975
 976                 r = sd_bus_message_exit_container(reply);
 977                 if (r < 0)
 978                         return r;
 979         }
 980         if (r < 0)
 981                 return r;
 982
 983         r = sd_bus_message_exit_container(reply);
 984         if (r < 0)
 985                 return r;
 986
 987         return 0;
 988 }
 989
 990 int bus_map_id128(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
 991         sd_id128_t *p = userdata;
 992         const void *v;
 993         size_t n;
 994         int r;
 995
 996         r = sd_bus_message_read_array(m, SD_BUS_TYPE_BYTE, &v, &n);
 997         if (r < 0)
 998                 return r;
 999
1000         if (n == 0)
1001                 *p = SD_ID128_NULL;
1002         else if (n == 16)
1003                 memcpy((*p).bytes, v, n);
1004         else
1005                 return -EINVAL;
1006
1007         return 0;
1008 }
1009
1010 static int map_basic(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
1011         char type;
1012         int r;
1013
1014         r = sd_bus_message_peek_type(m, &type, NULL);
1015         if (r < 0)
1016                 return r;
1017
1018         switch (type) {
1019
1020         case SD_BUS_TYPE_STRING: {
1021                 char **p = userdata;
1022                 const char *s;
1023
1024                 r = sd_bus_message_read_basic(m, type, &s);
1025                 if (r < 0)
1026                         return r;
1027
1028                 if (isempty(s))
1029                         s = NULL;
1030
1031                 return free_and_strdup(p, s);
1032         }
1033
1034         case SD_BUS_TYPE_ARRAY: {
1035                 _cleanup_strv_free_ char **l = NULL;
1036                 char ***p = userdata;
1037
1038                 r = bus_message_read_strv_extend(m, &l);
1039                 if (r < 0)
1040                         return r;
1041
1042                 strv_free(*p);
1043                 *p = l;
1044                 l = NULL;
1045                 return 0;
1046         }
1047
1048         case SD_BUS_TYPE_BOOLEAN: {
1049                 unsigned b;
1050                 int *p = userdata;
1051
1052                 r = sd_bus_message_read_basic(m, type, &b);
1053                 if (r < 0)
1054                         return r;
1055
1056                 *p = b;
1057                 return 0;
1058         }
1059
1060         case SD_BUS_TYPE_INT32:
1061         case SD_BUS_TYPE_UINT32: {
1062                 uint32_t u, *p = userdata;
1063
1064                 r = sd_bus_message_read_basic(m, type, &u);
1065                 if (r < 0)
1066                         return r;
1067
1068                 *p = u;
1069                 return 0;
1070         }
1071
1072         case SD_BUS_TYPE_INT64:
1073         case SD_BUS_TYPE_UINT64: {
1074                 uint64_t t, *p = userdata;
1075
1076                 r = sd_bus_message_read_basic(m, type, &t);
1077                 if (r < 0)
1078                         return r;
1079
1080                 *p = t;
1081                 return 0;
1082         }
1083
1084         case SD_BUS_TYPE_DOUBLE: {
1085                 double d, *p = userdata;
1086
1087                 r = sd_bus_message_read_basic(m, type, &d);
1088                 if (r < 0)
1089                         return r;
1090
1091                 *p = d;
1092                 return 0;
1093         }}
1094
1095         return -EOPNOTSUPP;
1096 }
1097
1098 int bus_message_map_all_properties(
1099                 sd_bus_message *m,
1100                 const struct bus_properties_map *map,
1101                 void *userdata) {
1102
1103         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1104         int r;
1105
1106         assert(m);
1107         assert(map);
1108
1109         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "{sv}");
1110         if (r < 0)
1111                 return r;
1112
1113         while ((r = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
1114                 const struct bus_properties_map *prop;
1115                 const char *member;
1116                 const char *contents;
1117                 void *v;
1118                 unsigned i;
1119
1120                 r = sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &member);
1121                 if (r < 0)
1122                         return r;
1123
1124                 for (i = 0, prop = NULL; map[i].member; i++)
1125                         if (streq(map[i].member, member)) {
1126                                 prop = &map[i];
1127                                 break;
1128                         }
1129
1130                 if (prop) {
1131                         r = sd_bus_message_peek_type(m, NULL, &contents);
1132                         if (r < 0)
1133                                 return r;
1134
1135                         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, contents);
1136                         if (r < 0)
1137                                 return r;
1138
1139                         v = (uint8_t *)userdata + prop->offset;
1140                         if (map[i].set)
1141                                 r = prop->set(sd_bus_message_get_bus(m), member, m, &error, v);
1142                         else
1143                                 r = map_basic(sd_bus_message_get_bus(m), member, m, &error, v);
1144                         if (r < 0)
1145                                 return r;
1146
1147                         r = sd_bus_message_exit_container(m);
1148                         if (r < 0)
1149                                 return r;
1150                 } else {
1151                         r = sd_bus_message_skip(m, "v");
1152                         if (r < 0)
1153                                 return r;
1154                 }
1155
1156                 r = sd_bus_message_exit_container(m);
1157                 if (r < 0)
1158                         return r;
1159         }
1160         if (r < 0)
1161                 return r;
1162
1163         return sd_bus_message_exit_container(m);
1164 }
1165
1166 int bus_message_map_properties_changed(
1167                 sd_bus_message *m,
1168                 const struct bus_properties_map *map,
1169                 void *userdata) {
1170
1171         const char *member;
1172         int r, invalidated, i;
1173
1174         assert(m);
1175         assert(map);
1176
1177         r = bus_message_map_all_properties(m, map, userdata);
1178         if (r < 0)
1179                 return r;
1180
1181         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "s");
1182         if (r < 0)
1183                 return r;
1184
1185         invalidated = 0;
1186         while ((r = sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &member)) > 0)
1187                 for (i = 0; map[i].member; i++)
1188                         if (streq(map[i].member, member)) {
1189                                 ++invalidated;
1190                                 break;
1191                         }
1192         if (r < 0)
1193                 return r;
1194
1195         r = sd_bus_message_exit_container(m);
1196         if (r < 0)
1197                 return r;
1198
1199         return invalidated;
1200 }
1201
1202 int bus_map_all_properties(
1203                 sd_bus *bus,
1204                 const char *destination,
1205                 const char *path,
1206                 const struct bus_properties_map *map,
1207                 void *userdata) {
1208
1209         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
1210         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1211         int r;
1212
1213         assert(bus);
1214         assert(destination);
1215         assert(path);
1216         assert(map);
1217
1218         r = sd_bus_call_method(
1219                         bus,
1220                         destination,
1221                         path,
1222                         "org.freedesktop.DBus.Properties",
1223                         "GetAll",
1224                         &error,
1225                         &m,
1226                         "s", "");
1227         if (r < 0)
1228                 return r;
1229
1230         return bus_message_map_all_properties(m, map, userdata);
1231 }
1232
1233 int bus_connect_transport(BusTransport transport, const char *host, bool user, sd_bus **ret) {
1234         _cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
1235         int r;
1236
1237         assert(transport >= 0);
1238         assert(transport < _BUS_TRANSPORT_MAX);
1239         assert(ret);
1240
1241         assert_return((transport == BUS_TRANSPORT_LOCAL) == !host, -EINVAL);
1242         assert_return(transport == BUS_TRANSPORT_LOCAL || !user, -EOPNOTSUPP);
1243
1244         switch (transport) {
1245
1246         case BUS_TRANSPORT_LOCAL:
1247                 if (user)
1248                         r = sd_bus_default_user(&bus);
1249                 else
1250                         r = sd_bus_default_system(&bus);
1251
1252                 break;
1253
1254         case BUS_TRANSPORT_REMOTE:
1255                 r = sd_bus_open_system_remote(&bus, host);
1256                 break;
1257
1258         case BUS_TRANSPORT_MACHINE:
1259                 r = sd_bus_open_system_machine(&bus, host);
1260                 break;
1261
1262         default:
1263                 assert_not_reached("Hmm, unknown transport type.");
1264         }
1265         if (r < 0)
1266                 return r;
1267
1268         r = sd_bus_set_exit_on_disconnect(bus, true);
1269         if (r < 0)
1270                 return r;
1271
1272         *ret = bus;
1273         bus = NULL;
1274
1275         return 0;
1276 }
1277
1278 int bus_connect_transport_systemd(BusTransport transport, const char *host, bool user, sd_bus **bus) {
1279         int r;
1280
1281         assert(transport >= 0);
1282         assert(transport < _BUS_TRANSPORT_MAX);
1283         assert(bus);
1284
1285         assert_return((transport == BUS_TRANSPORT_LOCAL) == !host, -EINVAL);
1286         assert_return(transport == BUS_TRANSPORT_LOCAL || !user, -EOPNOTSUPP);
1287
1288         switch (transport) {
1289
1290         case BUS_TRANSPORT_LOCAL:
1291                 if (user)
1292                         r = bus_connect_user_systemd(bus);
1293                 else
1294                         r = bus_connect_system_systemd(bus);
1295
1296                 break;
1297
1298         case BUS_TRANSPORT_REMOTE:
1299                 r = sd_bus_open_system_remote(bus, host);
1300                 break;
1301
1302         case BUS_TRANSPORT_MACHINE:
1303                 r = sd_bus_open_system_machine(bus, host);
1304                 break;
1305
1306         default:
1307                 assert_not_reached("Hmm, unknown transport type.");
1308         }
1309
1310         return r;
1311 }
1312
1313 int bus_property_get_bool(
1314                 sd_bus *bus,
1315                 const char *path,
1316                 const char *interface,
1317                 const char *property,
1318                 sd_bus_message *reply,
1319                 void *userdata,
1320                 sd_bus_error *error) {
1321
1322         int b = *(bool*) userdata;
1323
1324         return sd_bus_message_append_basic(reply, 'b', &b);
1325 }
1326
1327 #if __SIZEOF_SIZE_T__ != 8
1328 int bus_property_get_size(
1329                 sd_bus *bus,
1330                 const char *path,
1331                 const char *interface,
1332                 const char *property,
1333                 sd_bus_message *reply,
1334                 void *userdata,
1335                 sd_bus_error *error) {
1336
1337         uint64_t sz = *(size_t*) userdata;
1338
1339         return sd_bus_message_append_basic(reply, 't', &sz);
1340 }
1341 #endif
1342
1343 #if __SIZEOF_LONG__ != 8
1344 int bus_property_get_long(
1345                 sd_bus *bus,
1346                 const char *path,
1347                 const char *interface,
1348                 const char *property,
1349                 sd_bus_message *reply,
1350                 void *userdata,
1351                 sd_bus_error *error) {
1352
1353         int64_t l = *(long*) userdata;
1354
1355         return sd_bus_message_append_basic(reply, 'x', &l);
1356 }
1357
1358 int bus_property_get_ulong(
1359                 sd_bus *bus,
1360                 const char *path,
1361                 const char *interface,
1362                 const char *property,
1363                 sd_bus_message *reply,
1364                 void *userdata,
1365                 sd_bus_error *error) {
1366
1367         uint64_t ul = *(unsigned long*) userdata;
1368
1369         return sd_bus_message_append_basic(reply, 't', &ul);
1370 }
1371 #endif
1372
1373 int bus_log_parse_error(int r) {
1374         return log_error_errno(r, "Failed to parse bus message: %m");
1375 }
1376
1377 int bus_log_create_error(int r) {
1378         return log_error_errno(r, "Failed to create bus message: %m");
1379 }
1380
1381 /**
1382  * bus_path_encode_unique() - encode unique object path
1383  * @b: bus connection or NULL
1384  * @prefix: object path prefix
1385  * @sender_id: unique-name of client, or NULL
1386  * @external_id: external ID to be chosen by client, or NULL
1387  * @ret_path: storage for encoded object path pointer
1388  *
1389  * Whenever we provide a bus API that allows clients to create and manage
1390  * server-side objects, we need to provide a unique name for these objects. If
1391  * we let the server choose the name, we suffer from a race condition: If a
1392  * client creates an object asynchronously, it cannot destroy that object until
1393  * it received the method reply. It cannot know the name of the new object,
1394  * thus, it cannot destroy it. Furthermore, it enforces a round-trip.
1395  *
1396  * Therefore, many APIs allow the client to choose the unique name for newly
1397  * created objects. There're two problems to solve, though:
1398  *    1) Object names are usually defined via dbus object paths, which are
1399  *       usually globally namespaced. Therefore, multiple clients must be able
1400  *       to choose unique object names without interference.
1401  *    2) If multiple libraries share the same bus connection, they must be
1402  *       able to choose unique object names without interference.
1403  * The first problem is solved easily by prefixing a name with the
1404  * unique-bus-name of a connection. The server side must enforce this and
1405  * reject any other name. The second problem is solved by providing unique
1406  * suffixes from within sd-bus.
1407  *
1408  * This helper allows clients to create unique object-paths. It uses the
1409  * template '/prefix/sender_id/external_id' and returns the new path in
1410  * @ret_path (must be freed by the caller).
1411  * If @sender_id is NULL, the unique-name of @b is used. If @external_id is
1412  * NULL, this function allocates a unique suffix via @b (by requesting a new
1413  * cookie). If both @sender_id and @external_id are given, @b can be passed as
1414  * NULL.
1415  *
1416  * Returns: 0 on success, negative error code on failure.
1417  */
1418 int bus_path_encode_unique(sd_bus *b, const char *prefix, const char *sender_id, const char *external_id, char **ret_path) {
1419         _cleanup_free_ char *sender_label = NULL, *external_label = NULL;
1420         char external_buf[DECIMAL_STR_MAX(uint64_t)], *p;
1421         int r;
1422
1423         assert_return(b || (sender_id && external_id), -EINVAL);
1424         assert_return(object_path_is_valid(prefix), -EINVAL);
1425         assert_return(ret_path, -EINVAL);
1426
1427         if (!sender_id) {
1428                 r = sd_bus_get_unique_name(b, &sender_id);
1429                 if (r < 0)
1430                         return r;
1431         }
1432
1433         if (!external_id) {
1434                 xsprintf(external_buf, "%"PRIu64, ++b->cookie);
1435                 external_id = external_buf;
1436         }
1437
1438         sender_label = bus_label_escape(sender_id);
1439         if (!sender_label)
1440                 return -ENOMEM;
1441
1442         external_label = bus_label_escape(external_id);
1443         if (!external_label)
1444                 return -ENOMEM;
1445
1446         p = strjoin(prefix, "/", sender_label, "/", external_label, NULL);
1447         if (!p)
1448                 return -ENOMEM;
1449
1450         *ret_path = p;
1451         return 0;
1452 }
1453
1454 /**
1455  * bus_path_decode_unique() - decode unique object path
1456  * @path: object path to decode
1457  * @prefix: object path prefix
1458  * @ret_sender: output parameter for sender-id label
1459  * @ret_external: output parameter for external-id label
1460  *
1461  * This does the reverse of bus_path_encode_unique() (see its description for
1462  * details). Both trailing labels, sender-id and external-id, are unescaped and
1463  * returned in the given output parameters (the caller must free them).
1464  *
1465  * Note that this function returns 0 if the path does not match the template
1466  * (see bus_path_encode_unique()), 1 if it matched.
1467  *
1468  * Returns: Negative error code on failure, 0 if the given object path does not
1469  *          match the template (return parameters are set to NULL), 1 if it was
1470  *          parsed successfully (return parameters contain allocated labels).
1471  */
1472 int bus_path_decode_unique(const char *path, const char *prefix, char **ret_sender, char **ret_external) {
1473         const char *p, *q;
1474         char *sender, *external;
1475
1476         assert(object_path_is_valid(path));
1477         assert(object_path_is_valid(prefix));
1478         assert(ret_sender);
1479         assert(ret_external);
1480
1481         p = object_path_startswith(path, prefix);
1482         if (!p) {
1483                 *ret_sender = NULL;
1484                 *ret_external = NULL;
1485                 return 0;
1486         }
1487
1488         q = strchr(p, '/');
1489         if (!q) {
1490                 *ret_sender = NULL;
1491                 *ret_external = NULL;
1492                 return 0;
1493         }
1494
1495         sender = bus_label_unescape_n(p, q - p);
1496         external = bus_label_unescape(q + 1);
1497         if (!sender || !external) {
1498                 free(sender);
1499                 free(external);
1500                 return -ENOMEM;
1501         }
1502
1503         *ret_sender = sender;
1504         *ret_external = external;
1505         return 1;
1506 }
1507
1508 int bus_property_get_rlimit(
1509                 sd_bus *bus,
1510                 const char *path,
1511                 const char *interface,
1512                 const char *property,
1513                 sd_bus_message *reply,
1514                 void *userdata,
1515                 sd_bus_error *error) {
1516
1517         struct rlimit *rl;
1518         uint64_t u;
1519         rlim_t x;
1520         const char *is_soft;
1521
1522         assert(bus);
1523         assert(reply);
1524         assert(userdata);
1525
1526         is_soft = endswith(property, "Soft");
1527         rl = *(struct rlimit**) userdata;
1528         if (rl)
1529                 x = is_soft ? rl->rlim_cur : rl->rlim_max;
1530         else {
1531                 struct rlimit buf = {};
1532                 int z;
1533                 const char *s;
1534
1535                 s = is_soft ? strndupa(property, is_soft - property) : property;
1536
1537                 z = rlimit_from_string(strstr(s, "Limit"));
1538                 assert(z >= 0);
1539
1540                 getrlimit(z, &buf);
1541                 x = is_soft ? buf.rlim_cur : buf.rlim_max;
1542         }
1543
1544         /* rlim_t might have different sizes, let's map
1545          * RLIMIT_INFINITY to (uint64_t) -1, so that it is the same on
1546          * all archs */
1547         u = x == RLIM_INFINITY ? (uint64_t) -1 : (uint64_t) x;
1548
1549         return sd_bus_message_append(reply, "t", u);
1550 }