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