19603132989

Committed 22 Nov 2025 10:41PM UTC coverage: 72.453% (-0.07%) from 72.518%

Build # 19603132989

Build Type

push

github

Committed by

YHNdnzj

Commit Message

docs: Document cast formatting rules

Run Details

308192 of 425371 relevant lines covered (72.45%)

1182701.2 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.92

/src/shared/securebits-util.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include "alloc-util.h"
#include "extract-word.h"
#include "securebits-util.h"
#include "string-util.h"
#include "strv.h"

static inline const char* secure_bit_to_string(int i) {
        /* match a single bit */

        switch (i) {
                case SECURE_KEEP_CAPS:
                        return "keep-caps";
                case SECURE_KEEP_CAPS_LOCKED:
                        return "keep-caps-locked";
                case SECURE_NO_SETUID_FIXUP:
                        return "no-setuid-fixup";
                case SECURE_NO_SETUID_FIXUP_LOCKED:
                        return "no-setuid-fixup-locked";
                case SECURE_NOROOT:
                        return "noroot";
                case SECURE_NOROOT_LOCKED:
                        return "noroot-locked";
                default:
                        assert_not_reached();
        }
}

int secure_bits_to_string_alloc(int i, char **ret) {
        _cleanup_strv_free_ char **sv = NULL;
        _cleanup_free_ char *joined = NULL;
        int r;

        assert(ret);

        r = secure_bits_to_strv(i, &sv);
        if (r < 0)
                return r;

        joined = strv_join(sv, " ");
        if (!joined)
                return -ENOMEM;

        *ret = TAKE_PTR(joined);
        return 0;
}

int secure_bits_to_strv(int i, char ***ret) {
        _cleanup_strv_free_ char **sv = NULL;
        static const int bits[] = {
                SECURE_KEEP_CAPS,
                SECURE_KEEP_CAPS_LOCKED,
                SECURE_NO_SETUID_FIXUP,
                SECURE_NO_SETUID_FIXUP_LOCKED,
                SECURE_NOROOT,
                SECURE_NOROOT_LOCKED,
        };
        int r;

        assert(ret);

        FOREACH_ELEMENT(bit, bits) {
                if (i & (1 << *bit)) {
                        r = strv_extend(&sv, secure_bit_to_string(*bit));
                        if (r < 0)
                                return r;
                }
        }

        *ret = TAKE_PTR(sv);
        return 0;
}

int secure_bits_from_string(const char *s) {
        int secure_bits = 0;
        const char *p;
        int r;

        for (p = s;;) {
                _cleanup_free_ char *word = NULL;

                r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
                if (r == -ENOMEM)
                        return r;
                if (r <= 0)
                        break;

                if (streq(word, "keep-caps"))
                        secure_bits |= 1 << SECURE_KEEP_CAPS;
                else if (streq(word, "keep-caps-locked"))
                        secure_bits |= 1 << SECURE_KEEP_CAPS_LOCKED;
                else if (streq(word, "no-setuid-fixup"))
                        secure_bits |= 1 << SECURE_NO_SETUID_FIXUP;
                else if (streq(word, "no-setuid-fixup-locked"))
                        secure_bits |= 1 << SECURE_NO_SETUID_FIXUP_LOCKED;
                else if (streq(word, "noroot"))
                        secure_bits |= 1 << SECURE_NOROOT;
                else if (streq(word, "noroot-locked"))
                        secure_bits |= 1 << SECURE_NOROOT_LOCKED;
        }

        return secure_bits;
}

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include "alloc-util.h"
4	#include "extract-word.h"
5	#include "securebits-util.h"
6	#include "string-util.h"
7	#include "strv.h"
8
9	static inline const char* secure_bit_to_string(int i) {	32✔
10	/* match a single bit */
11
12	switch (i) {	32✔
13	case SECURE_KEEP_CAPS:
14	return "keep-caps";
15	case SECURE_KEEP_CAPS_LOCKED:	5✔
16	return "keep-caps-locked";	5✔
17	case SECURE_NO_SETUID_FIXUP:	4✔
18	return "no-setuid-fixup";	4✔
19	case SECURE_NO_SETUID_FIXUP_LOCKED:	4✔
20	return "no-setuid-fixup-locked";	4✔
21	case SECURE_NOROOT:	7✔
22	return "noroot";	7✔
23	case SECURE_NOROOT_LOCKED:	4✔
24	return "noroot-locked";	4✔
25	default:	×
26	assert_not_reached();	×
27	}
28	}
29
30	int secure_bits_to_string_alloc(int i, char **ret) {	14✔
31	_cleanup_strv_free_ char **sv = NULL;	28✔
32	_cleanup_free_ char *joined = NULL;	14✔
33	int r;	14✔
34
35	assert(ret);	14✔
36
37	r = secure_bits_to_strv(i, &sv);	14✔
38	if (r < 0)	14✔
39	return r;
40
41	joined = strv_join(sv, " ");	14✔
42	if (!joined)	14✔
43	return -ENOMEM;
44
45	*ret = TAKE_PTR(joined);	14✔
46	return 0;	14✔
47	}
48
49	int secure_bits_to_strv(int i, char ***ret) {	68✔
50	_cleanup_strv_free_ char **sv = NULL;	68✔
51	static const int bits[] = {	68✔
52	SECURE_KEEP_CAPS,
53	SECURE_KEEP_CAPS_LOCKED,
54	SECURE_NO_SETUID_FIXUP,
55	SECURE_NO_SETUID_FIXUP_LOCKED,
56	SECURE_NOROOT,
57	SECURE_NOROOT_LOCKED,
58	};
59	int r;	68✔
60
61	assert(ret);	68✔
62
63	FOREACH_ELEMENT(bit, bits) {	476✔
64	if (i & (1 << *bit)) {	408✔
65	r = strv_extend(&sv, secure_bit_to_string(*bit));	32✔
66	if (r < 0)	32✔
67	return r;
68	}
69	}
70
71	*ret = TAKE_PTR(sv);	68✔
72	return 0;	68✔
73	}
74
75	int secure_bits_from_string(const char *s) {	18✔
76	int secure_bits = 0;	18✔
77	const char *p;	18✔
78	int r;	18✔
79
80	for (p = s;;) {	18✔
81	_cleanup_free_ char *word = NULL;	34✔
82
83	r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);	52✔
84	if (r == -ENOMEM)	52✔
85	return r;	×
86	if (r <= 0)	52✔
87	break;
88
89	if (streq(word, "keep-caps"))	34✔
90	secure_bits \|= 1 << SECURE_KEEP_CAPS;	9✔
91	else if (streq(word, "keep-caps-locked"))	25✔
92	secure_bits \|= 1 << SECURE_KEEP_CAPS_LOCKED;	3✔
93	else if (streq(word, "no-setuid-fixup"))	22✔
94	secure_bits \|= 1 << SECURE_NO_SETUID_FIXUP;	3✔
95	else if (streq(word, "no-setuid-fixup-locked"))	19✔
96	secure_bits \|= 1 << SECURE_NO_SETUID_FIXUP_LOCKED;	2✔
97	else if (streq(word, "noroot"))	17✔
98	secure_bits \|= 1 << SECURE_NOROOT;	6✔
99	else if (streq(word, "noroot-locked"))	11✔
100	secure_bits \|= 1 << SECURE_NOROOT_LOCKED;	2✔
101	}
102
103	return secure_bits;	18✔
104	}

systemd / systemd / 19603132989

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous