src/libsystemd/sd-bus/bus-creds.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <linux/capability.h>
   4 #include <stdlib.h>
   5
   6 #include "alloc-util.h"
   7 #include "audit-util.h"
   8 #include "bus-creds.h"
   9 #include "bus-label.h"
  10 #include "bus-message.h"
  11 #include "bus-util.h"
  12 #include "capability-util.h"
  13 #include "cgroup-util.h"
  14 #include "fd-util.h"
  15 #include "fileio.h"
  16 #include "format-util.h"
  17 #include "hexdecoct.h"
  18 #include "parse-util.h"
  19 #include "process-util.h"
  20 #include "string-util.h"
  21 #include "strv.h"
  22 #include "terminal-util.h"
  23 #include "user-util.h"
  24 #include "util.h"
  25
  26 enum {
  27         CAP_OFFSET_INHERITABLE = 0,
  28         CAP_OFFSET_PERMITTED = 1,
  29         CAP_OFFSET_EFFECTIVE = 2,
  30         CAP_OFFSET_BOUNDING = 3
  31 };
  32
  33 void bus_creds_done(sd_bus_creds *c) {
  34         assert(c);
  35
  36         /* For internal bus cred structures that are allocated by
  37          * something else */
  38
  39         free(c->session);
  40         free(c->unit);
  41         free(c->user_unit);
  42         free(c->slice);
  43         free(c->user_slice);
  44         free(c->unescaped_description);
  45         free(c->supplementary_gids);
  46         free(c->tty);
  47
  48         free(c->well_known_names); /* note that this is an strv, but
  49                                     * we only free the array, not the
  50                                     * strings the array points to. The
  51                                     * full strv we only free if
  52                                     * c->allocated is set, see
  53                                     * below. */
  54
  55         strv_free(c->cmdline_array);
  56 }
  57
  58 _public_ sd_bus_creds *sd_bus_creds_ref(sd_bus_creds *c) {
  59
  60         if (!c)
  61                 return NULL;
  62
  63         if (c->allocated) {
  64                 assert(c->n_ref > 0);
  65                 c->n_ref++;
  66         } else {
  67                 sd_bus_message *m;
  68
  69                 /* If this is an embedded creds structure, then
  70                  * forward ref counting to the message */
  71                 m = container_of(c, sd_bus_message, creds);
  72                 sd_bus_message_ref(m);
  73         }
  74
  75         return c;
  76 }
  77
  78 _public_ sd_bus_creds *sd_bus_creds_unref(sd_bus_creds *c) {
  79
  80         if (!c)
  81                 return NULL;
  82
  83         if (c->allocated) {
  84                 assert(c->n_ref > 0);
  85                 c->n_ref--;
  86
  87                 if (c->n_ref == 0) {
  88                         free(c->comm);
  89                         free(c->tid_comm);
  90                         free(c->exe);
  91                         free(c->cmdline);
  92                         free(c->cgroup);
  93                         free(c->capability);
  94                         free(c->label);
  95                         free(c->unique_name);
  96                         free(c->cgroup_root);
  97                         free(c->description);
  98
  99                         c->supplementary_gids = mfree(c->supplementary_gids);
 100
 101                         c->well_known_names = strv_free(c->well_known_names);
 102
 103                         bus_creds_done(c);
 104
 105                         free(c);
 106                 }
 107         } else {
 108                 sd_bus_message *m;
 109
 110                 m = container_of(c, sd_bus_message, creds);
 111                 sd_bus_message_unref(m);
 112         }
 113
 114         return NULL;
 115 }
 116
 117 _public_ uint64_t sd_bus_creds_get_mask(const sd_bus_creds *c) {
 118         assert_return(c, 0);
 119
 120         return c->mask;
 121 }
 122
 123 _public_ uint64_t sd_bus_creds_get_augmented_mask(const sd_bus_creds *c) {
 124         assert_return(c, 0);
 125
 126         return c->augmented;
 127 }
 128
 129 sd_bus_creds* bus_creds_new(void) {
 130         sd_bus_creds *c;
 131
 132         c = new0(sd_bus_creds, 1);
 133         if (!c)
 134                 return NULL;
 135
 136         c->allocated = true;
 137         c->n_ref = 1;
 138         return c;
 139 }
 140
 141 _public_ int sd_bus_creds_new_from_pid(sd_bus_creds **ret, pid_t pid, uint64_t mask) {
 142         sd_bus_creds *c;
 143         int r;
 144
 145         assert_return(pid >= 0, -EINVAL);
 146         assert_return(mask <= _SD_BUS_CREDS_ALL, -EOPNOTSUPP);
 147         assert_return(ret, -EINVAL);
 148
 149         if (pid == 0)
 150                 pid = getpid_cached();
 151
 152         c = bus_creds_new();
 153         if (!c)
 154                 return -ENOMEM;
 155
 156         r = bus_creds_add_more(c, mask | SD_BUS_CREDS_AUGMENT, pid, 0);
 157         if (r < 0) {
 158                 sd_bus_creds_unref(c);
 159                 return r;
 160         }
 161
 162         /* Check if the process existed at all, in case we haven't
 163          * figured that out already */
 164         if (!pid_is_alive(pid)) {
 165                 sd_bus_creds_unref(c);
 166                 return -ESRCH;
 167         }
 168
 169         *ret = c;
 170         return 0;
 171 }
 172
 173 _public_ int sd_bus_creds_get_uid(sd_bus_creds *c, uid_t *uid) {
 174         assert_return(c, -EINVAL);
 175         assert_return(uid, -EINVAL);
 176
 177         if (!(c->mask & SD_BUS_CREDS_UID))
 178                 return -ENODATA;
 179
 180         *uid = c->uid;
 181         return 0;
 182 }
 183
 184 _public_ int sd_bus_creds_get_euid(sd_bus_creds *c, uid_t *euid) {
 185         assert_return(c, -EINVAL);
 186         assert_return(euid, -EINVAL);
 187
 188         if (!(c->mask & SD_BUS_CREDS_EUID))
 189                 return -ENODATA;
 190
 191         *euid = c->euid;
 192         return 0;
 193 }
 194
 195 _public_ int sd_bus_creds_get_suid(sd_bus_creds *c, uid_t *suid) {
 196         assert_return(c, -EINVAL);
 197         assert_return(suid, -EINVAL);
 198
 199         if (!(c->mask & SD_BUS_CREDS_SUID))
 200                 return -ENODATA;
 201
 202         *suid = c->suid;
 203         return 0;
 204 }
 205
 206 _public_ int sd_bus_creds_get_fsuid(sd_bus_creds *c, uid_t *fsuid) {
 207         assert_return(c, -EINVAL);
 208         assert_return(fsuid, -EINVAL);
 209
 210         if (!(c->mask & SD_BUS_CREDS_FSUID))
 211                 return -ENODATA;
 212
 213         *fsuid = c->fsuid;
 214         return 0;
 215 }
 216
 217 _public_ int sd_bus_creds_get_gid(sd_bus_creds *c, gid_t *gid) {
 218         assert_return(c, -EINVAL);
 219         assert_return(gid, -EINVAL);
 220
 221         if (!(c->mask & SD_BUS_CREDS_GID))
 222                 return -ENODATA;
 223
 224         *gid = c->gid;
 225         return 0;
 226 }
 227
 228 _public_ int sd_bus_creds_get_egid(sd_bus_creds *c, gid_t *egid) {
 229         assert_return(c, -EINVAL);
 230         assert_return(egid, -EINVAL);
 231
 232         if (!(c->mask & SD_BUS_CREDS_EGID))
 233                 return -ENODATA;
 234
 235         *egid = c->egid;
 236         return 0;
 237 }
 238
 239 _public_ int sd_bus_creds_get_sgid(sd_bus_creds *c, gid_t *sgid) {
 240         assert_return(c, -EINVAL);
 241         assert_return(sgid, -EINVAL);
 242
 243         if (!(c->mask & SD_BUS_CREDS_SGID))
 244                 return -ENODATA;
 245
 246         *sgid = c->sgid;
 247         return 0;
 248 }
 249
 250 _public_ int sd_bus_creds_get_fsgid(sd_bus_creds *c, gid_t *fsgid) {
 251         assert_return(c, -EINVAL);
 252         assert_return(fsgid, -EINVAL);
 253
 254         if (!(c->mask & SD_BUS_CREDS_FSGID))
 255                 return -ENODATA;
 256
 257         *fsgid = c->fsgid;
 258         return 0;
 259 }
 260
 261 _public_ int sd_bus_creds_get_supplementary_gids(sd_bus_creds *c, const gid_t **gids) {
 262         assert_return(c, -EINVAL);
 263         assert_return(gids, -EINVAL);
 264
 265         if (!(c->mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS))
 266                 return -ENODATA;
 267
 268         *gids = c->supplementary_gids;
 269         return (int) c->n_supplementary_gids;
 270 }
 271
 272 _public_ int sd_bus_creds_get_pid(sd_bus_creds *c, pid_t *pid) {
 273         assert_return(c, -EINVAL);
 274         assert_return(pid, -EINVAL);
 275
 276         if (!(c->mask & SD_BUS_CREDS_PID))
 277                 return -ENODATA;
 278
 279         assert(c->pid > 0);
 280         *pid = c->pid;
 281         return 0;
 282 }
 283
 284 _public_ int sd_bus_creds_get_ppid(sd_bus_creds *c, pid_t *ppid) {
 285         assert_return(c, -EINVAL);
 286         assert_return(ppid, -EINVAL);
 287
 288         if (!(c->mask & SD_BUS_CREDS_PPID))
 289                 return -ENODATA;
 290
 291         /* PID 1 has no parent process. Let's distinguish the case of
 292          * not knowing and not having a parent process by the returned
 293          * error code. */
 294         if (c->ppid == 0)
 295                 return -ENXIO;
 296
 297         *ppid = c->ppid;
 298         return 0;
 299 }
 300
 301 _public_ int sd_bus_creds_get_tid(sd_bus_creds *c, pid_t *tid) {
 302         assert_return(c, -EINVAL);
 303         assert_return(tid, -EINVAL);
 304
 305         if (!(c->mask & SD_BUS_CREDS_TID))
 306                 return -ENODATA;
 307
 308         assert(c->tid > 0);
 309         *tid = c->tid;
 310         return 0;
 311 }
 312
 313 _public_ int sd_bus_creds_get_selinux_context(sd_bus_creds *c, const char **ret) {
 314         assert_return(c, -EINVAL);
 315
 316         if (!(c->mask & SD_BUS_CREDS_SELINUX_CONTEXT))
 317                 return -ENODATA;
 318
 319         assert(c->label);
 320         *ret = c->label;
 321         return 0;
 322 }
 323
 324 _public_ int sd_bus_creds_get_comm(sd_bus_creds *c, const char **ret) {
 325         assert_return(c, -EINVAL);
 326         assert_return(ret, -EINVAL);
 327
 328         if (!(c->mask & SD_BUS_CREDS_COMM))
 329                 return -ENODATA;
 330
 331         assert(c->comm);
 332         *ret = c->comm;
 333         return 0;
 334 }
 335
 336 _public_ int sd_bus_creds_get_tid_comm(sd_bus_creds *c, const char **ret) {
 337         assert_return(c, -EINVAL);
 338         assert_return(ret, -EINVAL);
 339
 340         if (!(c->mask & SD_BUS_CREDS_TID_COMM))
 341                 return -ENODATA;
 342
 343         assert(c->tid_comm);
 344         *ret = c->tid_comm;
 345         return 0;
 346 }
 347
 348 _public_ int sd_bus_creds_get_exe(sd_bus_creds *c, const char **ret) {
 349         assert_return(c, -EINVAL);
 350         assert_return(ret, -EINVAL);
 351
 352         if (!(c->mask & SD_BUS_CREDS_EXE))
 353                 return -ENODATA;
 354
 355         if (!c->exe)
 356                 return -ENXIO;
 357
 358         *ret = c->exe;
 359         return 0;
 360 }
 361
 362 _public_ int sd_bus_creds_get_cgroup(sd_bus_creds *c, const char **ret) {
 363         assert_return(c, -EINVAL);
 364         assert_return(ret, -EINVAL);
 365
 366         if (!(c->mask & SD_BUS_CREDS_CGROUP))
 367                 return -ENODATA;
 368
 369         assert(c->cgroup);
 370         *ret = c->cgroup;
 371         return 0;
 372 }
 373
 374 _public_ int sd_bus_creds_get_unit(sd_bus_creds *c, const char **ret) {
 375         int r;
 376
 377         assert_return(c, -EINVAL);
 378         assert_return(ret, -EINVAL);
 379
 380         if (!(c->mask & SD_BUS_CREDS_UNIT))
 381                 return -ENODATA;
 382
 383         assert(c->cgroup);
 384
 385         if (!c->unit) {
 386                 const char *shifted;
 387
 388                 r = cg_shift_path(c->cgroup, c->cgroup_root, &shifted);
 389                 if (r < 0)
 390                         return r;
 391
 392                 r = cg_path_get_unit(shifted, (char**) &c->unit);
 393                 if (r < 0)
 394                         return r;
 395         }
 396
 397         *ret = c->unit;
 398         return 0;
 399 }
 400
 401 _public_ int sd_bus_creds_get_user_unit(sd_bus_creds *c, const char **ret) {
 402         int r;
 403
 404         assert_return(c, -EINVAL);
 405         assert_return(ret, -EINVAL);
 406
 407         if (!(c->mask & SD_BUS_CREDS_USER_UNIT))
 408                 return -ENODATA;
 409
 410         assert(c->cgroup);
 411
 412         if (!c->user_unit) {
 413                 const char *shifted;
 414
 415                 r = cg_shift_path(c->cgroup, c->cgroup_root, &shifted);
 416                 if (r < 0)
 417                         return r;
 418
 419                 r = cg_path_get_user_unit(shifted, (char**) &c->user_unit);
 420                 if (r < 0)
 421                         return r;
 422         }
 423
 424         *ret = c->user_unit;
 425         return 0;
 426 }
 427
 428 _public_ int sd_bus_creds_get_slice(sd_bus_creds *c, const char **ret) {
 429         int r;
 430
 431         assert_return(c, -EINVAL);
 432         assert_return(ret, -EINVAL);
 433
 434         if (!(c->mask & SD_BUS_CREDS_SLICE))
 435                 return -ENODATA;
 436
 437         assert(c->cgroup);
 438
 439         if (!c->slice) {
 440                 const char *shifted;
 441
 442                 r = cg_shift_path(c->cgroup, c->cgroup_root, &shifted);
 443                 if (r < 0)
 444                         return r;
 445
 446                 r = cg_path_get_slice(shifted, (char**) &c->slice);
 447                 if (r < 0)
 448                         return r;
 449         }
 450
 451         *ret = c->slice;
 452         return 0;
 453 }
 454
 455 _public_ int sd_bus_creds_get_user_slice(sd_bus_creds *c, const char **ret) {
 456         int r;
 457
 458         assert_return(c, -EINVAL);
 459         assert_return(ret, -EINVAL);
 460
 461         if (!(c->mask & SD_BUS_CREDS_USER_SLICE))
 462                 return -ENODATA;
 463
 464         assert(c->cgroup);
 465
 466         if (!c->user_slice) {
 467                 const char *shifted;
 468
 469                 r = cg_shift_path(c->cgroup, c->cgroup_root, &shifted);
 470                 if (r < 0)
 471                         return r;
 472
 473                 r = cg_path_get_user_slice(shifted, (char**) &c->user_slice);
 474                 if (r < 0)
 475                         return r;
 476         }
 477
 478         *ret = c->user_slice;
 479         return 0;
 480 }
 481
 482 _public_ int sd_bus_creds_get_session(sd_bus_creds *c, const char **ret) {
 483         int r;
 484
 485         assert_return(c, -EINVAL);
 486         assert_return(ret, -EINVAL);
 487
 488         if (!(c->mask & SD_BUS_CREDS_SESSION))
 489                 return -ENODATA;
 490
 491         assert(c->cgroup);
 492
 493         if (!c->session) {
 494                 const char *shifted;
 495
 496                 r = cg_shift_path(c->cgroup, c->cgroup_root, &shifted);
 497                 if (r < 0)
 498                         return r;
 499
 500                 r = cg_path_get_session(shifted, (char**) &c->session);
 501                 if (r < 0)
 502                         return r;
 503         }
 504
 505         *ret = c->session;
 506         return 0;
 507 }
 508
 509 _public_ int sd_bus_creds_get_owner_uid(sd_bus_creds *c, uid_t *uid) {
 510         const char *shifted;
 511         int r;
 512
 513         assert_return(c, -EINVAL);
 514         assert_return(uid, -EINVAL);
 515
 516         if (!(c->mask & SD_BUS_CREDS_OWNER_UID))
 517                 return -ENODATA;
 518
 519         assert(c->cgroup);
 520
 521         r = cg_shift_path(c->cgroup, c->cgroup_root, &shifted);
 522         if (r < 0)
 523                 return r;
 524
 525         return cg_path_get_owner_uid(shifted, uid);
 526 }
 527
 528 _public_ int sd_bus_creds_get_cmdline(sd_bus_creds *c, char ***cmdline) {
 529         assert_return(c, -EINVAL);
 530
 531         if (!(c->mask & SD_BUS_CREDS_CMDLINE))
 532                 return -ENODATA;
 533
 534         if (!c->cmdline)
 535                 return -ENXIO;
 536
 537         if (!c->cmdline_array) {
 538                 c->cmdline_array = strv_parse_nulstr(c->cmdline, c->cmdline_size);
 539                 if (!c->cmdline_array)
 540                         return -ENOMEM;
 541         }
 542
 543         *cmdline = c->cmdline_array;
 544         return 0;
 545 }
 546
 547 _public_ int sd_bus_creds_get_audit_session_id(sd_bus_creds *c, uint32_t *sessionid) {
 548         assert_return(c, -EINVAL);
 549         assert_return(sessionid, -EINVAL);
 550
 551         if (!(c->mask & SD_BUS_CREDS_AUDIT_SESSION_ID))
 552                 return -ENODATA;
 553
 554         if (!audit_session_is_valid(c->audit_session_id))
 555                 return -ENXIO;
 556
 557         *sessionid = c->audit_session_id;
 558         return 0;
 559 }
 560
 561 _public_ int sd_bus_creds_get_audit_login_uid(sd_bus_creds *c, uid_t *uid) {
 562         assert_return(c, -EINVAL);
 563         assert_return(uid, -EINVAL);
 564
 565         if (!(c->mask & SD_BUS_CREDS_AUDIT_LOGIN_UID))
 566                 return -ENODATA;
 567
 568         if (!uid_is_valid(c->audit_login_uid))
 569                 return -ENXIO;
 570
 571         *uid = c->audit_login_uid;
 572         return 0;
 573 }
 574
 575 _public_ int sd_bus_creds_get_tty(sd_bus_creds *c, const char **ret) {
 576         assert_return(c, -EINVAL);
 577         assert_return(ret, -EINVAL);
 578
 579         if (!(c->mask & SD_BUS_CREDS_TTY))
 580                 return -ENODATA;
 581
 582         if (!c->tty)
 583                 return -ENXIO;
 584
 585         *ret = c->tty;
 586         return 0;
 587 }
 588
 589 _public_ int sd_bus_creds_get_unique_name(sd_bus_creds *c, const char **unique_name) {
 590         assert_return(c, -EINVAL);
 591         assert_return(unique_name, -EINVAL);
 592
 593         if (!(c->mask & SD_BUS_CREDS_UNIQUE_NAME))
 594                 return -ENODATA;
 595
 596         *unique_name = c->unique_name;
 597         return 0;
 598 }
 599
 600 _public_ int sd_bus_creds_get_well_known_names(sd_bus_creds *c, char ***well_known_names) {
 601         assert_return(c, -EINVAL);
 602         assert_return(well_known_names, -EINVAL);
 603
 604         if (!(c->mask & SD_BUS_CREDS_WELL_KNOWN_NAMES))
 605                 return -ENODATA;
 606
 607         /* As a special hack we return the bus driver as well-known
 608          * names list when this is requested. */
 609         if (c->well_known_names_driver) {
 610                 static const char* const wkn[] = {
 611                         "org.freedesktop.DBus",
 612                         NULL
 613                 };
 614
 615                 *well_known_names = (char**) wkn;
 616                 return 0;
 617         }
 618
 619         if (c->well_known_names_local) {
 620                 static const char* const wkn[] = {
 621                         "org.freedesktop.DBus.Local",
 622                         NULL
 623                 };
 624
 625                 *well_known_names = (char**) wkn;
 626                 return 0;
 627         }
 628
 629         *well_known_names = c->well_known_names;
 630         return 0;
 631 }
 632
 633 _public_ int sd_bus_creds_get_description(sd_bus_creds *c, const char **ret) {
 634         assert_return(c, -EINVAL);
 635         assert_return(ret, -EINVAL);
 636
 637         if (!(c->mask & SD_BUS_CREDS_DESCRIPTION))
 638                 return -ENODATA;
 639
 640         assert(c->description);
 641
 642         if (!c->unescaped_description) {
 643                 c->unescaped_description = bus_label_unescape(c->description);
 644                 if (!c->unescaped_description)
 645                         return -ENOMEM;
 646         }
 647
 648         *ret = c->unescaped_description;
 649         return 0;
 650 }
 651
 652 static int has_cap(sd_bus_creds *c, unsigned offset, int capability) {
 653         size_t sz;
 654
 655         assert(c);
 656         assert(capability >= 0);
 657         assert(c->capability);
 658
 659         if ((unsigned) capability > cap_last_cap())
 660                 return 0;
 661
 662         sz = DIV_ROUND_UP(cap_last_cap(), 32U);
 663
 664         return !!(c->capability[offset * sz + CAP_TO_INDEX(capability)] & CAP_TO_MASK(capability));
 665 }
 666
 667 _public_ int sd_bus_creds_has_effective_cap(sd_bus_creds *c, int capability) {
 668         assert_return(c, -EINVAL);
 669         assert_return(capability >= 0, -EINVAL);
 670
 671         if (!(c->mask & SD_BUS_CREDS_EFFECTIVE_CAPS))
 672                 return -ENODATA;
 673
 674         return has_cap(c, CAP_OFFSET_EFFECTIVE, capability);
 675 }
 676
 677 _public_ int sd_bus_creds_has_permitted_cap(sd_bus_creds *c, int capability) {
 678         assert_return(c, -EINVAL);
 679         assert_return(capability >= 0, -EINVAL);
 680
 681         if (!(c->mask & SD_BUS_CREDS_PERMITTED_CAPS))
 682                 return -ENODATA;
 683
 684         return has_cap(c, CAP_OFFSET_PERMITTED, capability);
 685 }
 686
 687 _public_ int sd_bus_creds_has_inheritable_cap(sd_bus_creds *c, int capability) {
 688         assert_return(c, -EINVAL);
 689         assert_return(capability >= 0, -EINVAL);
 690
 691         if (!(c->mask & SD_BUS_CREDS_INHERITABLE_CAPS))
 692                 return -ENODATA;
 693
 694         return has_cap(c, CAP_OFFSET_INHERITABLE, capability);
 695 }
 696
 697 _public_ int sd_bus_creds_has_bounding_cap(sd_bus_creds *c, int capability) {
 698         assert_return(c, -EINVAL);
 699         assert_return(capability >= 0, -EINVAL);
 700
 701         if (!(c->mask & SD_BUS_CREDS_BOUNDING_CAPS))
 702                 return -ENODATA;
 703
 704         return has_cap(c, CAP_OFFSET_BOUNDING, capability);
 705 }
 706
 707 static int parse_caps(sd_bus_creds *c, unsigned offset, const char *p) {
 708         size_t sz, max;
 709         unsigned i, j;
 710
 711         assert(c);
 712         assert(p);
 713
 714         max = DIV_ROUND_UP(cap_last_cap(), 32U);
 715         p += strspn(p, WHITESPACE);
 716
 717         sz = strlen(p);
 718         if (sz % 8 != 0)
 719                 return -EINVAL;
 720
 721         sz /= 8;
 722         if (sz > max)
 723                 return -EINVAL;
 724
 725         if (!c->capability) {
 726                 c->capability = new0(uint32_t, max * 4);
 727                 if (!c->capability)
 728                         return -ENOMEM;
 729         }
 730
 731         for (i = 0; i < sz; i ++) {
 732                 uint32_t v = 0;
 733
 734                 for (j = 0; j < 8; ++j) {
 735                         int t;
 736
 737                         t = unhexchar(*p++);
 738                         if (t < 0)
 739                                 return -EINVAL;
 740
 741                         v = (v << 4) | t;
 742                 }
 743
 744                 c->capability[offset * max + (sz - i - 1)] = v;
 745         }
 746
 747         return 0;
 748 }
 749
 750 int bus_creds_add_more(sd_bus_creds *c, uint64_t mask, pid_t pid, pid_t tid) {
 751         uint64_t missing;
 752         int r;
 753
 754         assert(c);
 755         assert(c->allocated);
 756
 757         if (!(mask & SD_BUS_CREDS_AUGMENT))
 758                 return 0;
 759
 760         /* Try to retrieve PID from creds if it wasn't passed to us */
 761         if (pid > 0) {
 762                 c->pid = pid;
 763                 c->mask |= SD_BUS_CREDS_PID;
 764         } else if (c->mask & SD_BUS_CREDS_PID)
 765                 pid = c->pid;
 766         else
 767                 /* Without pid we cannot do much... */
 768                 return 0;
 769
 770         /* Try to retrieve TID from creds if it wasn't passed to us */
 771         if (tid <= 0 && (c->mask & SD_BUS_CREDS_TID))
 772                 tid = c->tid;
 773
 774         /* Calculate what we shall and can add */
 775         missing = mask & ~(c->mask|SD_BUS_CREDS_PID|SD_BUS_CREDS_TID|SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_DESCRIPTION|SD_BUS_CREDS_AUGMENT);
 776         if (missing == 0)
 777                 return 0;
 778
 779         if (tid > 0) {
 780                 c->tid = tid;
 781                 c->mask |= SD_BUS_CREDS_TID;
 782         }
 783
 784         if (missing & (SD_BUS_CREDS_PPID |
 785                        SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_SUID | SD_BUS_CREDS_FSUID |
 786                        SD_BUS_CREDS_GID | SD_BUS_CREDS_EGID | SD_BUS_CREDS_SGID | SD_BUS_CREDS_FSGID |
 787                        SD_BUS_CREDS_SUPPLEMENTARY_GIDS |
 788                        SD_BUS_CREDS_EFFECTIVE_CAPS | SD_BUS_CREDS_INHERITABLE_CAPS |
 789                        SD_BUS_CREDS_PERMITTED_CAPS | SD_BUS_CREDS_BOUNDING_CAPS)) {
 790
 791                 _cleanup_fclose_ FILE *f = NULL;
 792                 const char *p;
 793
 794                 p = procfs_file_alloca(pid, "status");
 795
 796                 f = fopen(p, "re");
 797                 if (!f) {
 798                         if (errno == ENOENT)
 799                                 return -ESRCH;
 800                         else if (!IN_SET(errno, EPERM, EACCES))
 801                                 return -errno;
 802                 } else {
 803                         char line[LINE_MAX];
 804
 805                         FOREACH_LINE(line, f, return -errno) {
 806                                 truncate_nl(line);
 807
 808                                 if (missing & SD_BUS_CREDS_PPID) {
 809                                         p = startswith(line, "PPid:");
 810                                         if (p) {
 811                                                 p += strspn(p, WHITESPACE);
 812
 813                                                 /* Explicitly check for PPID 0 (which is the case for PID 1) */
 814                                                 if (!streq(p, "0")) {
 815                                                         r = parse_pid(p, &c->ppid);
 816                                                         if (r < 0)
 817                                                                 return r;
 818
 819                                                 } else
 820                                                         c->ppid = 0;
 821
 822                                                 c->mask |= SD_BUS_CREDS_PPID;
 823                                                 continue;
 824                                         }
 825                                 }
 826
 827                                 if (missing & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID)) {
 828                                         p = startswith(line, "Uid:");
 829                                         if (p) {
 830                                                 unsigned long uid, euid, suid, fsuid;
 831
 832                                                 p += strspn(p, WHITESPACE);
 833                                                 if (sscanf(p, "%lu %lu %lu %lu", &uid, &euid, &suid, &fsuid) != 4)
 834                                                         return -EIO;
 835
 836                                                 if (missing & SD_BUS_CREDS_UID)
 837                                                         c->uid = (uid_t) uid;
 838                                                 if (missing & SD_BUS_CREDS_EUID)
 839                                                         c->euid = (uid_t) euid;
 840                                                 if (missing & SD_BUS_CREDS_SUID)
 841                                                         c->suid = (uid_t) suid;
 842                                                 if (missing & SD_BUS_CREDS_FSUID)
 843                                                         c->fsuid = (uid_t) fsuid;
 844
 845                                                 c->mask |= missing & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID);
 846                                                 continue;
 847                                         }
 848                                 }
 849
 850                                 if (missing & (SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID)) {
 851                                         p = startswith(line, "Gid:");
 852                                         if (p) {
 853                                                 unsigned long gid, egid, sgid, fsgid;
 854
 855                                                 p += strspn(p, WHITESPACE);
 856                                                 if (sscanf(p, "%lu %lu %lu %lu", &gid, &egid, &sgid, &fsgid) != 4)
 857                                                         return -EIO;
 858
 859                                                 if (missing & SD_BUS_CREDS_GID)
 860                                                         c->gid = (gid_t) gid;
 861                                                 if (missing & SD_BUS_CREDS_EGID)
 862                                                         c->egid = (gid_t) egid;
 863                                                 if (missing & SD_BUS_CREDS_SGID)
 864                                                         c->sgid = (gid_t) sgid;
 865                                                 if (missing & SD_BUS_CREDS_FSGID)
 866                                                         c->fsgid = (gid_t) fsgid;
 867
 868                                                 c->mask |= missing & (SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID);
 869                                                 continue;
 870                                         }
 871                                 }
 872
 873                                 if (missing & SD_BUS_CREDS_SUPPLEMENTARY_GIDS) {
 874                                         p = startswith(line, "Groups:");
 875                                         if (p) {
 876                                                 size_t allocated = 0;
 877
 878                                                 for (;;) {
 879                                                         unsigned long g;
 880                                                         int n = 0;
 881
 882                                                         p += strspn(p, WHITESPACE);
 883                                                         if (*p == 0)
 884                                                                 break;
 885
 886                                                         if (sscanf(p, "%lu%n", &g, &n) != 1)
 887                                                                 return -EIO;
 888
 889                                                         if (!GREEDY_REALLOC(c->supplementary_gids, allocated, c->n_supplementary_gids+1))
 890                                                                 return -ENOMEM;
 891
 892                                                         c->supplementary_gids[c->n_supplementary_gids++] = (gid_t) g;
 893                                                         p += n;
 894                                                 }
 895
 896                                                 c->mask |= SD_BUS_CREDS_SUPPLEMENTARY_GIDS;
 897                                                 continue;
 898                                         }
 899                                 }
 900
 901                                 if (missing & SD_BUS_CREDS_EFFECTIVE_CAPS) {
 902                                         p = startswith(line, "CapEff:");
 903                                         if (p) {
 904                                                 r = parse_caps(c, CAP_OFFSET_EFFECTIVE, p);
 905                                                 if (r < 0)
 906                                                         return r;
 907
 908                                                 c->mask |= SD_BUS_CREDS_EFFECTIVE_CAPS;
 909                                                 continue;
 910                                         }
 911                                 }
 912
 913                                 if (missing & SD_BUS_CREDS_PERMITTED_CAPS) {
 914                                         p = startswith(line, "CapPrm:");
 915                                         if (p) {
 916                                                 r = parse_caps(c, CAP_OFFSET_PERMITTED, p);
 917                                                 if (r < 0)
 918                                                         return r;
 919
 920                                                 c->mask |= SD_BUS_CREDS_PERMITTED_CAPS;
 921                                                 continue;
 922                                         }
 923                                 }
 924
 925                                 if (missing & SD_BUS_CREDS_INHERITABLE_CAPS) {
 926                                         p = startswith(line, "CapInh:");
 927                                         if (p) {
 928                                                 r = parse_caps(c, CAP_OFFSET_INHERITABLE, p);
 929                                                 if (r < 0)
 930                                                         return r;
 931
 932                                                 c->mask |= SD_BUS_CREDS_INHERITABLE_CAPS;
 933                                                 continue;
 934                                         }
 935                                 }
 936
 937                                 if (missing & SD_BUS_CREDS_BOUNDING_CAPS) {
 938                                         p = startswith(line, "CapBnd:");
 939                                         if (p) {
 940                                                 r = parse_caps(c, CAP_OFFSET_BOUNDING, p);
 941                                                 if (r < 0)
 942                                                         return r;
 943
 944                                                 c->mask |= SD_BUS_CREDS_BOUNDING_CAPS;
 945                                                 continue;
 946                                         }
 947                                 }
 948                         }
 949                 }
 950         }
 951
 952         if (missing & SD_BUS_CREDS_SELINUX_CONTEXT) {
 953                 const char *p;
 954
 955                 p = procfs_file_alloca(pid, "attr/current");
 956                 r = read_one_line_file(p, &c->label);
 957                 if (r < 0) {
 958                         if (!IN_SET(r, -ENOENT, -EINVAL, -EPERM, -EACCES))
 959                                 return r;
 960                 } else
 961                         c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
 962         }
 963
 964         if (missing & SD_BUS_CREDS_COMM) {
 965                 r = get_process_comm(pid, &c->comm);
 966                 if (r < 0) {
 967                         if (!IN_SET(r, -EPERM, -EACCES))
 968                                 return r;
 969                 } else
 970                         c->mask |= SD_BUS_CREDS_COMM;
 971         }
 972
 973         if (missing & SD_BUS_CREDS_EXE) {
 974                 r = get_process_exe(pid, &c->exe);
 975                 if (r == -ESRCH) {
 976                         /* Unfortunately we cannot really distinguish
 977                          * the case here where the process does not
 978                          * exist, and /proc/$PID/exe being unreadable
 979                          * because $PID is a kernel thread. Hence,
 980                          * assume it is a kernel thread, and rely on
 981                          * that this case is caught with a later
 982                          * call. */
 983                         c->exe = NULL;
 984                         c->mask |= SD_BUS_CREDS_EXE;
 985                 } else if (r < 0) {
 986                         if (!IN_SET(r, -EPERM, -EACCES))
 987                                 return r;
 988                 } else
 989                         c->mask |= SD_BUS_CREDS_EXE;
 990         }
 991
 992         if (missing & SD_BUS_CREDS_CMDLINE) {
 993                 const char *p;
 994
 995                 p = procfs_file_alloca(pid, "cmdline");
 996                 r = read_full_file(p, &c->cmdline, &c->cmdline_size);
 997                 if (r == -ENOENT)
 998                         return -ESRCH;
 999                 if (r < 0) {
1000                         if (!IN_SET(r, -EPERM, -EACCES))
1001                                 return r;
1002                 } else {
1003                         if (c->cmdline_size == 0)
1004                                 c->cmdline = mfree(c->cmdline);
1005
1006                         c->mask |= SD_BUS_CREDS_CMDLINE;
1007                 }
1008         }
1009
1010         if (tid > 0 && (missing & SD_BUS_CREDS_TID_COMM)) {
1011                 _cleanup_free_ char *p = NULL;
1012
1013                 if (asprintf(&p, "/proc/"PID_FMT"/task/"PID_FMT"/comm", pid, tid) < 0)
1014                         return -ENOMEM;
1015
1016                 r = read_one_line_file(p, &c->tid_comm);
1017                 if (r == -ENOENT)
1018                         return -ESRCH;
1019                 if (r < 0) {
1020                         if (!IN_SET(r, -EPERM, -EACCES))
1021                                 return r;
1022                 } else
1023                         c->mask |= SD_BUS_CREDS_TID_COMM;
1024         }
1025
1026         if (missing & (SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_USER_SLICE|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID)) {
1027
1028                 if (!c->cgroup) {
1029                         r = cg_pid_get_path(NULL, pid, &c->cgroup);
1030                         if (r < 0) {
1031                                 if (!IN_SET(r, -EPERM, -EACCES))
1032                                         return r;
1033                         }
1034                 }
1035
1036                 if (!c->cgroup_root) {
1037                         r = cg_get_root_path(&c->cgroup_root);
1038                         if (r < 0)
1039                                 return r;
1040                 }
1041
1042                 if (c->cgroup)
1043                         c->mask |= missing & (SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_USER_SLICE|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID);
1044         }
1045
1046         if (missing & SD_BUS_CREDS_AUDIT_SESSION_ID) {
1047                 r = audit_session_from_pid(pid, &c->audit_session_id);
1048                 if (r == -ENODATA) {
1049                         /* ENODATA means: no audit session id assigned */
1050                         c->audit_session_id = AUDIT_SESSION_INVALID;
1051                         c->mask |= SD_BUS_CREDS_AUDIT_SESSION_ID;
1052                 } else if (r < 0) {
1053                         if (!IN_SET(r, -EOPNOTSUPP, -ENOENT, -EPERM, -EACCES))
1054                                 return r;
1055                 } else
1056                         c->mask |= SD_BUS_CREDS_AUDIT_SESSION_ID;
1057         }
1058
1059         if (missing & SD_BUS_CREDS_AUDIT_LOGIN_UID) {
1060                 r = audit_loginuid_from_pid(pid, &c->audit_login_uid);
1061                 if (r == -ENODATA) {
1062                         /* ENODATA means: no audit login uid assigned */
1063                         c->audit_login_uid = UID_INVALID;
1064                         c->mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID;
1065                 } else if (r < 0) {
1066                         if (!IN_SET(r, -EOPNOTSUPP, -ENOENT, -EPERM, -EACCES))
1067                                 return r;
1068                 } else
1069                         c->mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID;
1070         }
1071
1072         if (missing & SD_BUS_CREDS_TTY) {
1073                 r = get_ctty(pid, NULL, &c->tty);
1074                 if (r == -ENXIO) {
1075                         /* ENXIO means: process has no controlling TTY */
1076                         c->tty = NULL;
1077                         c->mask |= SD_BUS_CREDS_TTY;
1078                 } else if (r < 0) {
1079                         if (!IN_SET(r, -EPERM, -EACCES, -ENOENT))
1080                                 return r;
1081                 } else
1082                         c->mask |= SD_BUS_CREDS_TTY;
1083         }
1084
1085         /* In case only the exe path was to be read we cannot
1086          * distinguish the case where the exe path was unreadable
1087          * because the process was a kernel thread, or when the
1088          * process didn't exist at all. Hence, let's do a final check,
1089          * to be sure. */
1090         if (!pid_is_alive(pid))
1091                 return -ESRCH;
1092
1093         if (tid > 0 && tid != pid && !pid_is_unwaited(tid))
1094                 return -ESRCH;
1095
1096         c->augmented = missing & c->mask;
1097
1098         return 0;
1099 }
1100
1101 int bus_creds_extend_by_pid(sd_bus_creds *c, uint64_t mask, sd_bus_creds **ret) {
1102         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *n = NULL;
1103         int r;
1104
1105         assert(c);
1106         assert(ret);
1107
1108         if ((mask & ~c->mask) == 0 || (!(mask & SD_BUS_CREDS_AUGMENT))) {
1109                 /* There's already all data we need, or augmentation
1110                  * wasn't turned on. */
1111
1112                 *ret = sd_bus_creds_ref(c);
1113                 return 0;
1114         }
1115
1116         n = bus_creds_new();
1117         if (!n)
1118                 return -ENOMEM;
1119
1120         /* Copy the original data over */
1121
1122         if (c->mask & mask & SD_BUS_CREDS_PID) {
1123                 n->pid = c->pid;
1124                 n->mask |= SD_BUS_CREDS_PID;
1125         }
1126
1127         if (c->mask & mask & SD_BUS_CREDS_TID) {
1128                 n->tid = c->tid;
1129                 n->mask |= SD_BUS_CREDS_TID;
1130         }
1131
1132         if (c->mask & mask & SD_BUS_CREDS_PPID) {
1133                 n->ppid = c->ppid;
1134                 n->mask |= SD_BUS_CREDS_PPID;
1135         }
1136
1137         if (c->mask & mask & SD_BUS_CREDS_UID) {
1138                 n->uid = c->uid;
1139                 n->mask |= SD_BUS_CREDS_UID;
1140         }
1141
1142         if (c->mask & mask & SD_BUS_CREDS_EUID) {
1143                 n->euid = c->euid;
1144                 n->mask |= SD_BUS_CREDS_EUID;
1145         }
1146
1147         if (c->mask & mask & SD_BUS_CREDS_SUID) {
1148                 n->suid = c->suid;
1149                 n->mask |= SD_BUS_CREDS_SUID;
1150         }
1151
1152         if (c->mask & mask & SD_BUS_CREDS_FSUID) {
1153                 n->fsuid = c->fsuid;
1154                 n->mask |= SD_BUS_CREDS_FSUID;
1155         }
1156
1157         if (c->mask & mask & SD_BUS_CREDS_GID) {
1158                 n->gid = c->gid;
1159                 n->mask |= SD_BUS_CREDS_GID;
1160         }
1161
1162         if (c->mask & mask & SD_BUS_CREDS_EGID) {
1163                 n->egid = c->egid;
1164                 n->mask |= SD_BUS_CREDS_EGID;
1165         }
1166
1167         if (c->mask & mask & SD_BUS_CREDS_SGID) {
1168                 n->sgid = c->sgid;
1169                 n->mask |= SD_BUS_CREDS_SGID;
1170         }
1171
1172         if (c->mask & mask & SD_BUS_CREDS_FSGID) {
1173                 n->fsgid = c->fsgid;
1174                 n->mask |= SD_BUS_CREDS_FSGID;
1175         }
1176
1177         if (c->mask & mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS) {
1178                 if (c->supplementary_gids) {
1179                         n->supplementary_gids = newdup(gid_t, c->supplementary_gids, c->n_supplementary_gids);
1180                         if (!n->supplementary_gids)
1181                                 return -ENOMEM;
1182                         n->n_supplementary_gids = c->n_supplementary_gids;
1183                 } else {
1184                         n->supplementary_gids = NULL;
1185                         n->n_supplementary_gids = 0;
1186                 }
1187
1188                 n->mask |= SD_BUS_CREDS_SUPPLEMENTARY_GIDS;
1189         }
1190
1191         if (c->mask & mask & SD_BUS_CREDS_COMM) {
1192                 assert(c->comm);
1193
1194                 n->comm = strdup(c->comm);
1195                 if (!n->comm)
1196                         return -ENOMEM;
1197
1198                 n->mask |= SD_BUS_CREDS_COMM;
1199         }
1200
1201         if (c->mask & mask & SD_BUS_CREDS_TID_COMM) {
1202                 assert(c->tid_comm);
1203
1204                 n->tid_comm = strdup(c->tid_comm);
1205                 if (!n->tid_comm)
1206                         return -ENOMEM;
1207
1208                 n->mask |= SD_BUS_CREDS_TID_COMM;
1209         }
1210
1211         if (c->mask & mask & SD_BUS_CREDS_EXE) {
1212                 if (c->exe) {
1213                         n->exe = strdup(c->exe);
1214                         if (!n->exe)
1215                                 return -ENOMEM;
1216                 } else
1217                         n->exe = NULL;
1218
1219                 n->mask |= SD_BUS_CREDS_EXE;
1220         }
1221
1222         if (c->mask & mask & SD_BUS_CREDS_CMDLINE) {
1223                 if (c->cmdline) {
1224                         n->cmdline = memdup(c->cmdline, c->cmdline_size);
1225                         if (!n->cmdline)
1226                                 return -ENOMEM;
1227
1228                         n->cmdline_size = c->cmdline_size;
1229                 } else {
1230                         n->cmdline = NULL;
1231                         n->cmdline_size = 0;
1232                 }
1233
1234                 n->mask |= SD_BUS_CREDS_CMDLINE;
1235         }
1236
1237         if (c->mask & mask & (SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_USER_SLICE|SD_BUS_CREDS_OWNER_UID)) {
1238                 assert(c->cgroup);
1239
1240                 n->cgroup = strdup(c->cgroup);
1241                 if (!n->cgroup)
1242                         return -ENOMEM;
1243
1244                 n->cgroup_root = strdup(c->cgroup_root);
1245                 if (!n->cgroup_root)
1246                         return -ENOMEM;
1247
1248                 n->mask |= mask & (SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_USER_SLICE|SD_BUS_CREDS_OWNER_UID);
1249         }
1250
1251         if (c->mask & mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS)) {
1252                 assert(c->capability);
1253
1254                 n->capability = memdup(c->capability, DIV_ROUND_UP(cap_last_cap(), 32U) * 4 * 4);
1255                 if (!n->capability)
1256                         return -ENOMEM;
1257
1258                 n->mask |= c->mask & mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS);
1259         }
1260
1261         if (c->mask & mask & SD_BUS_CREDS_SELINUX_CONTEXT) {
1262                 assert(c->label);
1263
1264                 n->label = strdup(c->label);
1265                 if (!n->label)
1266                         return -ENOMEM;
1267                 n->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
1268         }
1269
1270         if (c->mask & mask & SD_BUS_CREDS_AUDIT_SESSION_ID) {
1271                 n->audit_session_id = c->audit_session_id;
1272                 n->mask |= SD_BUS_CREDS_AUDIT_SESSION_ID;
1273         }
1274         if (c->mask & mask & SD_BUS_CREDS_AUDIT_LOGIN_UID) {
1275                 n->audit_login_uid = c->audit_login_uid;
1276                 n->mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID;
1277         }
1278
1279         if (c->mask & mask & SD_BUS_CREDS_TTY) {
1280                 if (c->tty) {
1281                         n->tty = strdup(c->tty);
1282                         if (!n->tty)
1283                                 return -ENOMEM;
1284                 } else
1285                         n->tty = NULL;
1286                 n->mask |= SD_BUS_CREDS_TTY;
1287         }
1288
1289         if (c->mask & mask & SD_BUS_CREDS_UNIQUE_NAME) {
1290                 assert(c->unique_name);
1291
1292                 n->unique_name = strdup(c->unique_name);
1293                 if (!n->unique_name)
1294                         return -ENOMEM;
1295                 n->mask |= SD_BUS_CREDS_UNIQUE_NAME;
1296         }
1297
1298         if (c->mask & mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) {
1299                 if (strv_isempty(c->well_known_names))
1300                         n->well_known_names = NULL;
1301                 else {
1302                         n->well_known_names = strv_copy(c->well_known_names);
1303                         if (!n->well_known_names)
1304                                 return -ENOMEM;
1305                 }
1306                 n->well_known_names_driver = c->well_known_names_driver;
1307                 n->well_known_names_local = c->well_known_names_local;
1308                 n->mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES;
1309         }
1310
1311         if (c->mask & mask & SD_BUS_CREDS_DESCRIPTION) {
1312                 assert(c->description);
1313                 n->description = strdup(c->description);
1314                 if (!n->description)
1315                         return -ENOMEM;
1316                 n->mask |= SD_BUS_CREDS_DESCRIPTION;
1317         }
1318
1319         n->augmented = c->augmented & n->mask;
1320
1321         /* Get more data */
1322
1323         r = bus_creds_add_more(n, mask, 0, 0);
1324         if (r < 0)
1325                 return r;
1326
1327         *ret = TAKE_PTR(n);
1328
1329         return 0;
1330 }