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 *m, bool value, bool all) {
 660         char type;
 661         const char *contents;
 662         int r;
 663
 664         assert(name);
 665         assert(m);
 666
 667         r = sd_bus_message_peek_type(m, &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(m, 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(m, 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(m, 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(m, 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(m, 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(m, 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(m, 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(m, SD_BUS_TYPE_ARRAY, contents);
 846                         if (r < 0)
 847                                 return r;
 848
 849                         while ((r = sd_bus_message_read_basic(m, 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(m);
 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(m, 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(m, 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_message_print_all_properties(
 929                 sd_bus_message *m,
 930                 bus_message_print_t func,
 931                 char **filter,
 932                 bool value,
 933                 bool all,
 934                 Set **found_properties) {
 935
 936         int r;
 937
 938         assert(m);
 939
 940         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "{sv}");
 941         if (r < 0)
 942                 return r;
 943
 944         while ((r = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
 945                 const char *name;
 946                 const char *contents;
 947
 948                 r = sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &name);
 949                 if (r < 0)
 950                         return r;
 951
 952                 if (found_properties) {
 953                         r = set_ensure_allocated(found_properties, &string_hash_ops);
 954                         if (r < 0)
 955                                 return log_oom();
 956
 957                         r = set_put(*found_properties, name);
 958                         if (r < 0 && r != EEXIST)
 959                                 return log_oom();
 960                 }
 961
 962                 if (!filter || strv_find(filter, name)) {
 963                         r = sd_bus_message_peek_type(m, NULL, &contents);
 964                         if (r < 0)
 965                                 return r;
 966
 967                         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, contents);
 968                         if (r < 0)
 969                                 return r;
 970
 971                         if (func)
 972                                 r = func(name, m, value, all);
 973                         if (!func || r == 0)
 974                                 r = bus_print_property(name, m, value, all);
 975                         if (r < 0)
 976                                 return r;
 977                         if (r == 0) {
 978                                 if (all)
 979                                         printf("%s=[unprintable]\n", name);
 980                                 /* skip what we didn't read */
 981                                 r = sd_bus_message_skip(m, contents);
 982                                 if (r < 0)
 983                                         return r;
 984                         }
 985
 986                         r = sd_bus_message_exit_container(m);
 987                         if (r < 0)
 988                                 return r;
 989                 } else {
 990                         r = sd_bus_message_skip(m, "v");
 991                         if (r < 0)
 992                                 return r;
 993                 }
 994
 995                 r = sd_bus_message_exit_container(m);
 996                 if (r < 0)
 997                         return r;
 998         }
 999         if (r < 0)
1000                 return r;
1001
1002         r = sd_bus_message_exit_container(m);
1003         if (r < 0)
1004                 return r;
1005
1006         return 0;
1007 }
1008
1009 int bus_print_all_properties(
1010                 sd_bus *bus,
1011                 const char *dest,
1012                 const char *path,
1013                 bus_message_print_t func,
1014                 char **filter,
1015                 bool value,
1016                 bool all,
1017                 Set **found_properties) {
1018
1019         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1020         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1021         int r;
1022
1023         assert(bus);
1024         assert(path);
1025
1026         r = sd_bus_call_method(bus,
1027                         dest,
1028                         path,
1029                         "org.freedesktop.DBus.Properties",
1030                         "GetAll",
1031                         &error,
1032                         &reply,
1033                         "s", "");
1034         if (r < 0)
1035                 return r;
1036
1037         return bus_message_print_all_properties(reply, func, filter, value, all, found_properties);
1038 }
1039
1040 int bus_map_id128(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
1041         sd_id128_t *p = userdata;
1042         const void *v;
1043         size_t n;
1044         int r;
1045
1046         r = sd_bus_message_read_array(m, SD_BUS_TYPE_BYTE, &v, &n);
1047         if (r < 0)
1048                 return r;
1049
1050         if (n == 0)
1051                 *p = SD_ID128_NULL;
1052         else if (n == 16)
1053                 memcpy((*p).bytes, v, n);
1054         else
1055                 return -EINVAL;
1056
1057         return 0;
1058 }
1059
1060 static int map_basic(sd_bus *bus, const char *member, sd_bus_message *m, unsigned flags, sd_bus_error *error, void *userdata) {
1061         char type;
1062         int r;
1063
1064         r = sd_bus_message_peek_type(m, &type, NULL);
1065         if (r < 0)
1066                 return r;
1067
1068         switch (type) {
1069
1070         case SD_BUS_TYPE_STRING: {
1071                 const char **p = userdata;
1072                 const char *s;
1073
1074                 r = sd_bus_message_read_basic(m, type, &s);
1075                 if (r < 0)
1076                         return r;
1077
1078                 if (isempty(s))
1079                         s = NULL;
1080
1081                 if (flags & BUS_MAP_STRDUP)
1082                         return free_and_strdup((char **) userdata, s);
1083
1084                 *p = s;
1085                 return 0;
1086         }
1087
1088         case SD_BUS_TYPE_ARRAY: {
1089                 _cleanup_strv_free_ char **l = NULL;
1090                 char ***p = userdata;
1091
1092                 r = bus_message_read_strv_extend(m, &l);
1093                 if (r < 0)
1094                         return r;
1095
1096                 strv_free(*p);
1097                 *p = TAKE_PTR(l);
1098                 return 0;
1099         }
1100
1101         case SD_BUS_TYPE_BOOLEAN: {
1102                 int b;
1103
1104                 r = sd_bus_message_read_basic(m, type, &b);
1105                 if (r < 0)
1106                         return r;
1107
1108                 if (flags & BUS_MAP_BOOLEAN_AS_BOOL)
1109                         * (bool*) userdata = !!b;
1110                 else
1111                         * (int*) userdata = b;
1112
1113                 return 0;
1114         }
1115
1116         case SD_BUS_TYPE_INT32:
1117         case SD_BUS_TYPE_UINT32: {
1118                 uint32_t u, *p = userdata;
1119
1120                 r = sd_bus_message_read_basic(m, type, &u);
1121                 if (r < 0)
1122                         return r;
1123
1124                 *p = u;
1125                 return 0;
1126         }
1127
1128         case SD_BUS_TYPE_INT64:
1129         case SD_BUS_TYPE_UINT64: {
1130                 uint64_t t, *p = userdata;
1131
1132                 r = sd_bus_message_read_basic(m, type, &t);
1133                 if (r < 0)
1134                         return r;
1135
1136                 *p = t;
1137                 return 0;
1138         }
1139
1140         case SD_BUS_TYPE_DOUBLE: {
1141                 double d, *p = userdata;
1142
1143                 r = sd_bus_message_read_basic(m, type, &d);
1144                 if (r < 0)
1145                         return r;
1146
1147                 *p = d;
1148                 return 0;
1149         }}
1150
1151         return -EOPNOTSUPP;
1152 }
1153
1154 int bus_message_map_all_properties(
1155                 sd_bus_message *m,
1156                 const struct bus_properties_map *map,
1157                 unsigned flags,
1158                 sd_bus_error *error,
1159                 void *userdata) {
1160
1161         int r;
1162
1163         assert(m);
1164         assert(map);
1165
1166         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "{sv}");
1167         if (r < 0)
1168                 return r;
1169
1170         while ((r = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
1171                 const struct bus_properties_map *prop;
1172                 const char *member;
1173                 const char *contents;
1174                 void *v;
1175                 unsigned i;
1176
1177                 r = sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &member);
1178                 if (r < 0)
1179                         return r;
1180
1181                 for (i = 0, prop = NULL; map[i].member; i++)
1182                         if (streq(map[i].member, member)) {
1183                                 prop = &map[i];
1184                                 break;
1185                         }
1186
1187                 if (prop) {
1188                         r = sd_bus_message_peek_type(m, NULL, &contents);
1189                         if (r < 0)
1190                                 return r;
1191
1192                         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, contents);
1193                         if (r < 0)
1194                                 return r;
1195
1196                         v = (uint8_t *)userdata + prop->offset;
1197                         if (map[i].set)
1198                                 r = prop->set(sd_bus_message_get_bus(m), member, m, error, v);
1199                         else
1200                                 r = map_basic(sd_bus_message_get_bus(m), member, m, flags, error, v);
1201                         if (r < 0)
1202                                 return r;
1203
1204                         r = sd_bus_message_exit_container(m);
1205                         if (r < 0)
1206                                 return r;
1207                 } else {
1208                         r = sd_bus_message_skip(m, "v");
1209                         if (r < 0)
1210                                 return r;
1211                 }
1212
1213                 r = sd_bus_message_exit_container(m);
1214                 if (r < 0)
1215                         return r;
1216         }
1217         if (r < 0)
1218                 return r;
1219
1220         return sd_bus_message_exit_container(m);
1221 }
1222
1223 int bus_message_map_properties_changed(
1224                 sd_bus_message *m,
1225                 const struct bus_properties_map *map,
1226                 unsigned flags,
1227                 sd_bus_error *error,
1228                 void *userdata) {
1229
1230         const char *member;
1231         int r, invalidated, i;
1232
1233         assert(m);
1234         assert(map);
1235
1236         r = bus_message_map_all_properties(m, map, flags, error, userdata);
1237         if (r < 0)
1238                 return r;
1239
1240         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "s");
1241         if (r < 0)
1242                 return r;
1243
1244         invalidated = 0;
1245         while ((r = sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &member)) > 0)
1246                 for (i = 0; map[i].member; i++)
1247                         if (streq(map[i].member, member)) {
1248                                 ++invalidated;
1249                                 break;
1250                         }
1251         if (r < 0)
1252                 return r;
1253
1254         r = sd_bus_message_exit_container(m);
1255         if (r < 0)
1256                 return r;
1257
1258         return invalidated;
1259 }
1260
1261 int bus_map_all_properties(
1262                 sd_bus *bus,
1263                 const char *destination,
1264                 const char *path,
1265                 const struct bus_properties_map *map,
1266                 unsigned flags,
1267                 sd_bus_error *error,
1268                 sd_bus_message **reply,
1269                 void *userdata) {
1270
1271         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
1272         int r;
1273
1274         assert(bus);
1275         assert(destination);
1276         assert(path);
1277         assert(map);
1278         assert(reply || (flags & BUS_MAP_STRDUP));
1279
1280         r = sd_bus_call_method(
1281                         bus,
1282                         destination,
1283                         path,
1284                         "org.freedesktop.DBus.Properties",
1285                         "GetAll",
1286                         error,
1287                         &m,
1288                         "s", "");
1289         if (r < 0)
1290                 return r;
1291
1292         r = bus_message_map_all_properties(m, map, flags, error, userdata);
1293         if (r < 0)
1294                 return r;
1295
1296         if (reply)
1297                 *reply = sd_bus_message_ref(m);
1298
1299         return r;
1300 }
1301
1302 int bus_connect_transport(BusTransport transport, const char *host, bool user, sd_bus **ret) {
1303         _cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
1304         int r;
1305
1306         assert(transport >= 0);
1307         assert(transport < _BUS_TRANSPORT_MAX);
1308         assert(ret);
1309
1310         assert_return((transport == BUS_TRANSPORT_LOCAL) == !host, -EINVAL);
1311         assert_return(transport == BUS_TRANSPORT_LOCAL || !user, -EOPNOTSUPP);
1312
1313         switch (transport) {
1314
1315         case BUS_TRANSPORT_LOCAL:
1316                 if (user)
1317                         r = sd_bus_default_user(&bus);
1318                 else
1319                         r = sd_bus_default_system(&bus);
1320
1321                 break;
1322
1323         case BUS_TRANSPORT_REMOTE:
1324                 r = sd_bus_open_system_remote(&bus, host);
1325                 break;
1326
1327         case BUS_TRANSPORT_MACHINE:
1328                 r = sd_bus_open_system_machine(&bus, host);
1329                 break;
1330
1331         default:
1332                 assert_not_reached("Hmm, unknown transport type.");
1333         }
1334         if (r < 0)
1335                 return r;
1336
1337         r = sd_bus_set_exit_on_disconnect(bus, true);
1338         if (r < 0)
1339                 return r;
1340
1341         *ret = bus;
1342         bus = NULL;
1343
1344         return 0;
1345 }
1346
1347 int bus_connect_transport_systemd(BusTransport transport, const char *host, bool user, sd_bus **bus) {
1348         int r;
1349
1350         assert(transport >= 0);
1351         assert(transport < _BUS_TRANSPORT_MAX);
1352         assert(bus);
1353
1354         assert_return((transport == BUS_TRANSPORT_LOCAL) == !host, -EINVAL);
1355         assert_return(transport == BUS_TRANSPORT_LOCAL || !user, -EOPNOTSUPP);
1356
1357         switch (transport) {
1358
1359         case BUS_TRANSPORT_LOCAL:
1360                 if (user)
1361                         r = bus_connect_user_systemd(bus);
1362                 else
1363                         r = bus_connect_system_systemd(bus);
1364
1365                 break;
1366
1367         case BUS_TRANSPORT_REMOTE:
1368                 r = sd_bus_open_system_remote(bus, host);
1369                 break;
1370
1371         case BUS_TRANSPORT_MACHINE:
1372                 r = sd_bus_open_system_machine(bus, host);
1373                 break;
1374
1375         default:
1376                 assert_not_reached("Hmm, unknown transport type.");
1377         }
1378
1379         return r;
1380 }
1381
1382 int bus_property_get_bool(
1383                 sd_bus *bus,
1384                 const char *path,
1385                 const char *interface,
1386                 const char *property,
1387                 sd_bus_message *reply,
1388                 void *userdata,
1389                 sd_bus_error *error) {
1390
1391         int b = *(bool*) userdata;
1392
1393         return sd_bus_message_append_basic(reply, 'b', &b);
1394 }
1395
1396 int bus_property_set_bool(
1397                 sd_bus *bus,
1398                 const char *path,
1399                 const char *interface,
1400                 const char *property,
1401                 sd_bus_message *value,
1402                 void *userdata,
1403                 sd_bus_error *error) {
1404
1405         int b, r;
1406
1407         r = sd_bus_message_read(value, "b", &b);
1408         if (r < 0)
1409                 return r;
1410
1411         *(bool *) userdata = !!b;
1412         return 0;
1413 }
1414
1415 int bus_property_get_id128(
1416                 sd_bus *bus,
1417                 const char *path,
1418                 const char *interface,
1419                 const char *property,
1420                 sd_bus_message *reply,
1421                 void *userdata,
1422                 sd_bus_error *error) {
1423
1424         sd_id128_t *id = userdata;
1425
1426         if (sd_id128_is_null(*id)) /* Add an empty array if the ID is zero */
1427                 return sd_bus_message_append(reply, "ay", 0);
1428         else
1429                 return sd_bus_message_append_array(reply, 'y', id->bytes, 16);
1430 }
1431
1432 #if __SIZEOF_SIZE_T__ != 8
1433 int bus_property_get_size(
1434                 sd_bus *bus,
1435                 const char *path,
1436                 const char *interface,
1437                 const char *property,
1438                 sd_bus_message *reply,
1439                 void *userdata,
1440                 sd_bus_error *error) {
1441
1442         uint64_t sz = *(size_t*) userdata;
1443
1444         return sd_bus_message_append_basic(reply, 't', &sz);
1445 }
1446 #endif
1447
1448 #if __SIZEOF_LONG__ != 8
1449 int bus_property_get_long(
1450                 sd_bus *bus,
1451                 const char *path,
1452                 const char *interface,
1453                 const char *property,
1454                 sd_bus_message *reply,
1455                 void *userdata,
1456                 sd_bus_error *error) {
1457
1458         int64_t l = *(long*) userdata;
1459
1460         return sd_bus_message_append_basic(reply, 'x', &l);
1461 }
1462
1463 int bus_property_get_ulong(
1464                 sd_bus *bus,
1465                 const char *path,
1466                 const char *interface,
1467                 const char *property,
1468                 sd_bus_message *reply,
1469                 void *userdata,
1470                 sd_bus_error *error) {
1471
1472         uint64_t ul = *(unsigned long*) userdata;
1473
1474         return sd_bus_message_append_basic(reply, 't', &ul);
1475 }
1476 #endif
1477
1478 int bus_log_parse_error(int r) {
1479         return log_error_errno(r, "Failed to parse bus message: %m");
1480 }
1481
1482 int bus_log_create_error(int r) {
1483         return log_error_errno(r, "Failed to create bus message: %m");
1484 }
1485
1486 /**
1487  * bus_path_encode_unique() - encode unique object path
1488  * @b: bus connection or NULL
1489  * @prefix: object path prefix
1490  * @sender_id: unique-name of client, or NULL
1491  * @external_id: external ID to be chosen by client, or NULL
1492  * @ret_path: storage for encoded object path pointer
1493  *
1494  * Whenever we provide a bus API that allows clients to create and manage
1495  * server-side objects, we need to provide a unique name for these objects. If
1496  * we let the server choose the name, we suffer from a race condition: If a
1497  * client creates an object asynchronously, it cannot destroy that object until
1498  * it received the method reply. It cannot know the name of the new object,
1499  * thus, it cannot destroy it. Furthermore, it enforces a round-trip.
1500  *
1501  * Therefore, many APIs allow the client to choose the unique name for newly
1502  * created objects. There're two problems to solve, though:
1503  *    1) Object names are usually defined via dbus object paths, which are
1504  *       usually globally namespaced. Therefore, multiple clients must be able
1505  *       to choose unique object names without interference.
1506  *    2) If multiple libraries share the same bus connection, they must be
1507  *       able to choose unique object names without interference.
1508  * The first problem is solved easily by prefixing a name with the
1509  * unique-bus-name of a connection. The server side must enforce this and
1510  * reject any other name. The second problem is solved by providing unique
1511  * suffixes from within sd-bus.
1512  *
1513  * This helper allows clients to create unique object-paths. It uses the
1514  * template '/prefix/sender_id/external_id' and returns the new path in
1515  * @ret_path (must be freed by the caller).
1516  * If @sender_id is NULL, the unique-name of @b is used. If @external_id is
1517  * NULL, this function allocates a unique suffix via @b (by requesting a new
1518  * cookie). If both @sender_id and @external_id are given, @b can be passed as
1519  * NULL.
1520  *
1521  * Returns: 0 on success, negative error code on failure.
1522  */
1523 int bus_path_encode_unique(sd_bus *b, const char *prefix, const char *sender_id, const char *external_id, char **ret_path) {
1524         _cleanup_free_ char *sender_label = NULL, *external_label = NULL;
1525         char external_buf[DECIMAL_STR_MAX(uint64_t)], *p;
1526         int r;
1527
1528         assert_return(b || (sender_id && external_id), -EINVAL);
1529         assert_return(object_path_is_valid(prefix), -EINVAL);
1530         assert_return(ret_path, -EINVAL);
1531
1532         if (!sender_id) {
1533                 r = sd_bus_get_unique_name(b, &sender_id);
1534                 if (r < 0)
1535                         return r;
1536         }
1537
1538         if (!external_id) {
1539                 xsprintf(external_buf, "%"PRIu64, ++b->cookie);
1540                 external_id = external_buf;
1541         }
1542
1543         sender_label = bus_label_escape(sender_id);
1544         if (!sender_label)
1545                 return -ENOMEM;
1546
1547         external_label = bus_label_escape(external_id);
1548         if (!external_label)
1549                 return -ENOMEM;
1550
1551         p = strjoin(prefix, "/", sender_label, "/", external_label);
1552         if (!p)
1553                 return -ENOMEM;
1554
1555         *ret_path = p;
1556         return 0;
1557 }
1558
1559 /**
1560  * bus_path_decode_unique() - decode unique object path
1561  * @path: object path to decode
1562  * @prefix: object path prefix
1563  * @ret_sender: output parameter for sender-id label
1564  * @ret_external: output parameter for external-id label
1565  *
1566  * This does the reverse of bus_path_encode_unique() (see its description for
1567  * details). Both trailing labels, sender-id and external-id, are unescaped and
1568  * returned in the given output parameters (the caller must free them).
1569  *
1570  * Note that this function returns 0 if the path does not match the template
1571  * (see bus_path_encode_unique()), 1 if it matched.
1572  *
1573  * Returns: Negative error code on failure, 0 if the given object path does not
1574  *          match the template (return parameters are set to NULL), 1 if it was
1575  *          parsed successfully (return parameters contain allocated labels).
1576  */
1577 int bus_path_decode_unique(const char *path, const char *prefix, char **ret_sender, char **ret_external) {
1578         const char *p, *q;
1579         char *sender, *external;
1580
1581         assert(object_path_is_valid(path));
1582         assert(object_path_is_valid(prefix));
1583         assert(ret_sender);
1584         assert(ret_external);
1585
1586         p = object_path_startswith(path, prefix);
1587         if (!p) {
1588                 *ret_sender = NULL;
1589                 *ret_external = NULL;
1590                 return 0;
1591         }
1592
1593         q = strchr(p, '/');
1594         if (!q) {
1595                 *ret_sender = NULL;
1596                 *ret_external = NULL;
1597                 return 0;
1598         }
1599
1600         sender = bus_label_unescape_n(p, q - p);
1601         external = bus_label_unescape(q + 1);
1602         if (!sender || !external) {
1603                 free(sender);
1604                 free(external);
1605                 return -ENOMEM;
1606         }
1607
1608         *ret_sender = sender;
1609         *ret_external = external;
1610         return 1;
1611 }
1612
1613 int bus_property_get_rlimit(
1614                 sd_bus *bus,
1615                 const char *path,
1616                 const char *interface,
1617                 const char *property,
1618                 sd_bus_message *reply,
1619                 void *userdata,
1620                 sd_bus_error *error) {
1621
1622         struct rlimit *rl;
1623         uint64_t u;
1624         rlim_t x;
1625         const char *is_soft;
1626
1627         assert(bus);
1628         assert(reply);
1629         assert(userdata);
1630
1631         is_soft = endswith(property, "Soft");
1632         rl = *(struct rlimit**) userdata;
1633         if (rl)
1634                 x = is_soft ? rl->rlim_cur : rl->rlim_max;
1635         else {
1636                 struct rlimit buf = {};
1637                 int z;
1638                 const char *s;
1639
1640                 s = is_soft ? strndupa(property, is_soft - property) : property;
1641
1642                 z = rlimit_from_string(strstr(s, "Limit"));
1643                 assert(z >= 0);
1644
1645                 getrlimit(z, &buf);
1646                 x = is_soft ? buf.rlim_cur : buf.rlim_max;
1647         }
1648
1649         /* rlim_t might have different sizes, let's map
1650          * RLIMIT_INFINITY to (uint64_t) -1, so that it is the same on
1651          * all archs */
1652         u = x == RLIM_INFINITY ? (uint64_t) -1 : (uint64_t) x;
1653
1654         return sd_bus_message_append(reply, "t", u);
1655 }
1656
1657 int bus_track_add_name_many(sd_bus_track *t, char **l) {
1658         int r = 0;
1659         char **i;
1660
1661         assert(t);
1662
1663         /* Continues adding after failure, and returns the first failure. */
1664
1665         STRV_FOREACH(i, l) {
1666                 int k;
1667
1668                 k = sd_bus_track_add_name(t, *i);
1669                 if (k < 0 && r >= 0)
1670                         r = k;
1671         }
1672
1673         return r;
1674 }
1675
1676 int bus_open_system_watch_bind(sd_bus **ret) {
1677         _cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
1678         const char *e;
1679         int r;
1680
1681         assert(ret);
1682
1683         /* Match like sd_bus_open_system(), but with the "watch_bind" feature and the Connected() signal turned on. */
1684
1685         r = sd_bus_new(&bus);
1686         if (r < 0)
1687                 return r;
1688
1689         e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1690         if (!e)
1691                 e = DEFAULT_SYSTEM_BUS_ADDRESS;
1692
1693         r = sd_bus_set_address(bus, e);
1694         if (r < 0)
1695                 return r;
1696
1697         r = sd_bus_set_bus_client(bus, true);
1698         if (r < 0)
1699                 return r;
1700
1701         r = sd_bus_set_trusted(bus, true);
1702         if (r < 0)
1703                 return r;
1704
1705         r = sd_bus_negotiate_creds(bus, true, SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_EFFECTIVE_CAPS);
1706         if (r < 0)
1707                 return r;
1708
1709         r = sd_bus_set_watch_bind(bus, true);
1710         if (r < 0)
1711                 return r;
1712
1713         r = sd_bus_set_connected_signal(bus, true);
1714         if (r < 0)
1715                 return r;
1716
1717         r = sd_bus_start(bus);
1718         if (r < 0)
1719                 return r;
1720
1721         *ret = bus;
1722         bus = NULL;
1723
1724         return 0;
1725 }