src/shared/bus-util.c

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