14554080340

Committed 19 Apr 2025 11:46AM UTC coverage: 72.101% (-0.03%) from 72.13%

Build # 14554080340

Build Type

push

github

Committed by

web-flow

Commit Message

Add two new paragraphs to coding style about header files (#37188)

Coverage Stats

296880 of 411754 relevant lines covered (72.1%)

687547.52 hits per line

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

93.18

/src/basic/uid-range.c

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

#include <errno.h>
#include <stdlib.h>
#include <string.h>

#include "alloc-util.h"
#include "errno-util.h"
#include "fd-util.h"
#include "format-util.h"
#include "log.h"
#include "macro.h"
#include "namespace-util.h"
#include "path-util.h"
#include "process-util.h"
#include "sort-util.h"
#include "stat-util.h"
#include "uid-range.h"
#include "user-util.h"

UIDRange *uid_range_free(UIDRange *range) {
        if (!range)
                return NULL;

        free(range->entries);
        return mfree(range);
}

static bool uid_range_entry_intersect(const UIDRangeEntry *a, const UIDRangeEntry *b) {
        assert(a);
        assert(b);

        return a->start <= b->start + b->nr && a->start + a->nr >= b->start;
}

static int uid_range_entry_compare(const UIDRangeEntry *a, const UIDRangeEntry *b) {
        int r;

        assert(a);
        assert(b);

        r = CMP(a->start, b->start);
        if (r != 0)
                return r;

        return CMP(a->nr, b->nr);
}

static void uid_range_coalesce(UIDRange *range) {
        assert(range);

        if (range->n_entries <= 0)
                return;

        typesafe_qsort(range->entries, range->n_entries, uid_range_entry_compare);

        for (size_t i = 0; i < range->n_entries; i++) {
                UIDRangeEntry *x = range->entries + i;

                for (size_t j = i + 1; j < range->n_entries; j++) {
                        UIDRangeEntry *y = range->entries + j;
                        uid_t begin, end;

                        if (!uid_range_entry_intersect(x, y))
                                break;

                        begin = MIN(x->start, y->start);
                        end = MAX(x->start + x->nr, y->start + y->nr);

                        x->start = begin;
                        x->nr = end - begin;

                        if (range->n_entries > j + 1)
                                memmove(y, y + 1, sizeof(UIDRangeEntry) * (range->n_entries - j - 1));

                        range->n_entries--;
                        j--;
                }
        }
}

int uid_range_add_internal(UIDRange **range, uid_t start, uid_t nr, bool coalesce) {
        _cleanup_(uid_range_freep) UIDRange *range_new = NULL;
        UIDRange *p;

        assert(range);

        if (nr <= 0)
                return 0;

        if (start > UINT32_MAX - nr) /* overflow check */
                return -ERANGE;

        if (*range)
                p = *range;
        else {
                range_new = new0(UIDRange, 1);
                if (!range_new)
                        return -ENOMEM;

                p = range_new;
        }

        if (!GREEDY_REALLOC(p->entries, p->n_entries + 1))
                return -ENOMEM;

        p->entries[p->n_entries++] = (UIDRangeEntry) {
                .start = start,
                .nr = nr,
        };

        if (coalesce)
                uid_range_coalesce(p);

        TAKE_PTR(range_new);
        *range = p;

        return 0;
}

int uid_range_add_str(UIDRange **range, const char *s) {
        uid_t start, end;
        int r;

        assert(range);
        assert(s);

        r = parse_uid_range(s, &start, &end);
        if (r < 0)
                return r;

        return uid_range_add_internal(range, start, end - start + 1, /* coalesce = */ true);
}

int uid_range_next_lower(const UIDRange *range, uid_t *uid) {
        uid_t closest = UID_INVALID, candidate;

        assert(range);
        assert(uid);

        if (*uid == 0)
                return -EBUSY;

        candidate = *uid - 1;

        for (size_t i = 0; i < range->n_entries; i++) {
                uid_t begin, end;

                begin = range->entries[i].start;
                end = range->entries[i].start + range->entries[i].nr - 1;

                if (candidate >= begin && candidate <= end) {
                        *uid = candidate;
                        return 1;
                }

                if (end < candidate)
                        closest = end;
        }

        if (closest == UID_INVALID)
                return -EBUSY;

        *uid = closest;
        return 1;
}

bool uid_range_covers(const UIDRange *range, uid_t start, uid_t nr) {
        if (nr == 0) /* empty range? always covered... */
                return true;

        if (start > UINT32_MAX - nr) /* range overflows? definitely not covered... */
                return false;

        if (!range)
                return false;

        FOREACH_ARRAY(i, range->entries, range->n_entries)
                if (start >= i->start &&
                    start + nr <= i->start + i->nr)
                        return true;

        return false;
}

int uid_map_read_one(FILE *f, uid_t *ret_base, uid_t *ret_shift, uid_t *ret_range) {
        uid_t uid_base, uid_shift, uid_range;
        int r;

        assert(f);

        errno = 0;
        r = fscanf(f, UID_FMT " " UID_FMT " " UID_FMT "\n", &uid_base, &uid_shift, &uid_range);
        if (r == EOF)
                return errno_or_else(ENOMSG);
        assert(r >= 0);
        if (r != 3)
                return -EBADMSG;
        if (uid_range <= 0)
                return -EBADMSG;

        if (ret_base)
                *ret_base = uid_base;
        if (ret_shift)
                *ret_shift = uid_shift;
        if (ret_range)
                *ret_range = uid_range;

        return 0;
}

int uid_range_load_userns(const char *path, UIDRangeUsernsMode mode, UIDRange **ret) {
        _cleanup_(uid_range_freep) UIDRange *range = NULL;
        _cleanup_fclose_ FILE *f = NULL;
        int r;

        /* If 'path' is NULL loads the UID range of the userns namespace we run. Otherwise load the data from
         * the specified file (which can be either uid_map or gid_map, in case caller needs to deal with GID
         * maps).
         *
         * To simplify things this will modify the passed array in case of later failure. */

        assert(mode >= 0);
        assert(mode < _UID_RANGE_USERNS_MODE_MAX);
        assert(ret);

        if (!path)
                path = IN_SET(mode, UID_RANGE_USERNS_INSIDE, UID_RANGE_USERNS_OUTSIDE) ? "/proc/self/uid_map" : "/proc/self/gid_map";

        f = fopen(path, "re");
        if (!f) {
                r = -errno;

                if (r == -ENOENT && path_startswith(path, "/proc/"))
                        return proc_mounted() > 0 ? -EOPNOTSUPP : -ENOSYS;

                return r;
        }

        range = new0(UIDRange, 1);
        if (!range)
                return -ENOMEM;

        for (;;) {
                uid_t uid_base, uid_shift, uid_range;

                r = uid_map_read_one(f, &uid_base, &uid_shift, &uid_range);
                if (r == -ENOMSG)
                        break;
                if (r < 0)
                        return r;

                r = uid_range_add_internal(
                                &range,
                                IN_SET(mode, UID_RANGE_USERNS_INSIDE, GID_RANGE_USERNS_INSIDE) ? uid_base : uid_shift,
                                uid_range,
                                /* coalesce = */ false);
                if (r < 0)
                        return r;
        }

        uid_range_coalesce(range);

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

int uid_range_load_userns_by_fd(int userns_fd, UIDRangeUsernsMode mode, UIDRange **ret) {
        _cleanup_(sigkill_waitp) pid_t pid = 0;
        int r;

        assert(userns_fd >= 0);
        assert(mode >= 0);
        assert(mode < _UID_RANGE_USERNS_MODE_MAX);
        assert(ret);

        r = userns_enter_and_pin(userns_fd, &pid);
        if (r < 0)
                return r;

        const char *p = procfs_file_alloca(
                        pid,
                        IN_SET(mode, UID_RANGE_USERNS_INSIDE, UID_RANGE_USERNS_OUTSIDE) ? "uid_map" : "gid_map");

        return uid_range_load_userns(p, mode, ret);
}

bool uid_range_overlaps(const UIDRange *range, uid_t start, uid_t nr) {

        if (!range)
                return false;

        /* Avoid overflow */
        if (start > UINT32_MAX - nr)
                nr = UINT32_MAX - start;

        if (nr == 0)
                return false;

        FOREACH_ARRAY(entry, range->entries, range->n_entries)
                if (start < entry->start + entry->nr &&
                    start + nr >= entry->start)
                        return true;

        return false;
}

bool uid_range_equal(const UIDRange *a, const UIDRange *b) {
        if (a == b)
                return true;

        if (!a || !b)
                return false;

        if (a->n_entries != b->n_entries)
                return false;

        for (size_t i = 0; i < a->n_entries; i++) {
                if (a->entries[i].start != b->entries[i].start)
                        return false;
                if (a->entries[i].nr != b->entries[i].nr)
                        return false;
        }

        return true;
}

int uid_map_search_root(pid_t pid, UIDRangeUsernsMode mode, uid_t *ret) {
        int r;

        assert(pid_is_valid(pid));
        assert(IN_SET(mode, UID_RANGE_USERNS_OUTSIDE, GID_RANGE_USERNS_OUTSIDE));

        const char *p = procfs_file_alloca(pid, mode == UID_RANGE_USERNS_OUTSIDE ? "uid_map" : "gid_map");
        _cleanup_fclose_ FILE *f = fopen(p, "re");
        if (!f) {
                if (errno != ENOENT)
                        return -errno;

                r = proc_mounted();
                if (r < 0)
                        return -ENOENT; /* original error, if we can't determine /proc/ state */

                return r ? -ENOPKG : -ENOSYS;
        }

        for (;;) {
                uid_t uid_base = UID_INVALID, uid_shift = UID_INVALID;

                r = uid_map_read_one(f, &uid_base, &uid_shift, /* ret_uid_range= */ NULL);
                if (r < 0)
                        return r;

                if (uid_base == 0) {
                        if (ret)
                                *ret = uid_shift;
                        return 0;
                }
        }
}

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include <errno.h>
4	#include <stdlib.h>
5	#include <string.h>
6
7	#include "alloc-util.h"
8	#include "errno-util.h"
9	#include "fd-util.h"
10	#include "format-util.h"
11	#include "log.h"
12	#include "macro.h"
13	#include "namespace-util.h"
14	#include "path-util.h"
15	#include "process-util.h"
16	#include "sort-util.h"
17	#include "stat-util.h"
18	#include "uid-range.h"
19	#include "user-util.h"
20
21	UIDRange uid_range_free(UIDRange range) {	2,762✔
22	if (!range)	2,762✔
23	return NULL;
24
25	free(range->entries);	277✔
26	return mfree(range);	277✔
27	}
28
29	static bool uid_range_entry_intersect(const UIDRangeEntry a, const UIDRangeEntry b) {	94✔
30	assert(a);	94✔
31	assert(b);	94✔
32
33	return a->start <= b->start + b->nr && a->start + a->nr >= b->start;	94✔
34	}
35
36	static int uid_range_entry_compare(const UIDRangeEntry a, const UIDRangeEntry b) {	282✔
37	int r;	282✔
38
39	assert(a);	282✔
40	assert(b);	282✔
41
42	r = CMP(a->start, b->start);	282✔
43	if (r != 0)	138✔
44	return r;	262✔
45
46	return CMP(a->nr, b->nr);	20✔
47	}
48
49	static void uid_range_coalesce(UIDRange *range) {	285✔
50	assert(range);	285✔
51
52	if (range->n_entries <= 0)	285✔
53	return;
54
55	typesafe_qsort(range->entries, range->n_entries, uid_range_entry_compare);	269✔
56
57	for (size_t i = 0; i < range->n_entries; i++) {	544✔
58	UIDRangeEntry *x = range->entries + i;	275✔
59
60	for (size_t j = i + 1; j < range->n_entries; j++) {	363✔
61	UIDRangeEntry *y = range->entries + j;	94✔
62	uid_t begin, end;	94✔
63
64	if (!uid_range_entry_intersect(x, y))	94✔
65	break;
66
67	begin = MIN(x->start, y->start);	88✔
68	end = MAX(x->start + x->nr, y->start + y->nr);	88✔
69
70	x->start = begin;	88✔
71	x->nr = end - begin;	88✔
72
73	if (range->n_entries > j + 1)	88✔
74	memmove(y, y + 1, sizeof(UIDRangeEntry) * (range->n_entries - j - 1));	81✔
75
76	range->n_entries--;	88✔
77	j--;	88✔
78	}
79	}
80	}
81
82	int uid_range_add_internal(UIDRange **range, uid_t start, uid_t nr, bool coalesce) {	350✔
83	_cleanup_(uid_range_freep) UIDRange *range_new = NULL;	350✔
84	UIDRange *p;	350✔
85
86	assert(range);	350✔
87
88	if (nr <= 0)	350✔
89	return 0;
90
91	if (start > UINT32_MAX - nr) /* overflow check */	350✔
92	return -ERANGE;
93
94	if (*range)	350✔
95	p = *range;
96	else {
97	range_new = new0(UIDRange, 1);	118✔
98	if (!range_new)	118✔
99	return -ENOMEM;
100
101	p = range_new;
102	}
103
104	if (!GREEDY_REALLOC(p->entries, p->n_entries + 1))	350✔
105	return -ENOMEM;
106
107	p->entries[p->n_entries++] = (UIDRangeEntry) {	350✔
108	.start = start,
109	.nr = nr,
110	};
111
112	if (coalesce)	350✔
113	uid_range_coalesce(p);	126✔
114
115	TAKE_PTR(range_new);	350✔
116	*range = p;	350✔
117
118	return 0;	350✔
119	}
120
121	int uid_range_add_str(UIDRange *range, const char s) {	10✔
122	uid_t start, end;	10✔
123	int r;	10✔
124
125	assert(range);	10✔
126	assert(s);	10✔
127
128	r = parse_uid_range(s, &start, &end);	10✔
129	if (r < 0)	10✔
130	return r;	10✔
131
132	return uid_range_add_internal(range, start, end - start + 1, /* coalesce = */ true);	10✔
133	}
134
135	int uid_range_next_lower(const UIDRange range, uid_t uid) {	187✔
136	uid_t closest = UID_INVALID, candidate;	187✔
137
138	assert(range);	187✔
139	assert(uid);	187✔
140
141	if (*uid == 0)	187✔
142	return -EBUSY;
143
144	candidate = *uid - 1;	187✔
145
146	for (size_t i = 0; i < range->n_entries; i++) {	233✔
147	uid_t begin, end;	187✔
148
149	begin = range->entries[i].start;	187✔
150	end = range->entries[i].start + range->entries[i].nr - 1;	187✔
151
152	if (candidate >= begin && candidate <= end) {	187✔
153	*uid = candidate;	141✔
154	return 1;	141✔
155	}
156
157	if (end < candidate)	46✔
158	closest = end;	45✔
159	}
160
161	if (closest == UID_INVALID)	46✔
162	return -EBUSY;
163
164	*uid = closest;	45✔
165	return 1;	45✔
166	}
167
168	bool uid_range_covers(const UIDRange *range, uid_t start, uid_t nr) {	215✔
169	if (nr == 0) /* empty range? always covered... */	215✔
170	return true;
171
172	if (start > UINT32_MAX - nr) /* range overflows? definitely not covered... */	214✔
173	return false;
174
175	if (!range)	211✔
176	return false;
177
178	FOREACH_ARRAY(i, range->entries, range->n_entries)	227✔
179	if (start >= i->start &&	215✔
180	start + nr <= i->start + i->nr)	209✔
181	return true;
182
183	return false;
184	}
185
186	int uid_map_read_one(FILE f, uid_t ret_base, uid_t ret_shift, uid_t ret_range) {	456✔
187	uid_t uid_base, uid_shift, uid_range;	456✔
188	int r;	456✔
189
190	assert(f);	456✔
191
192	errno = 0;	456✔
193	r = fscanf(f, UID_FMT " " UID_FMT " " UID_FMT "\n", &uid_base, &uid_shift, &uid_range);	456✔
194	if (r == EOF)	456✔
195	return errno_or_else(ENOMSG);	194✔
196	assert(r >= 0);	262✔
197	if (r != 3)	262✔
198	return -EBADMSG;
199	if (uid_range <= 0)	262✔
200	return -EBADMSG;
201
202	if (ret_base)	262✔
203	*ret_base = uid_base;	262✔
204	if (ret_shift)	262✔
205	*ret_shift = uid_shift;	262✔
206	if (ret_range)	262✔
207	*ret_range = uid_range;	220✔
208
209	return 0;
210	}
211
212	int uid_range_load_userns(const char path, UIDRangeUsernsMode mode, UIDRange *ret) {	159✔
213	_cleanup_(uid_range_freep) UIDRange *range = NULL;	×
214	_cleanup_fclose_ FILE *f = NULL;	159✔
215	int r;	159✔
216
217	/* If 'path' is NULL loads the UID range of the userns namespace we run. Otherwise load the data from
218	* the specified file (which can be either uid_map or gid_map, in case caller needs to deal with GID
219	* maps).
220	*
221	* To simplify things this will modify the passed array in case of later failure. */
222
223	assert(mode >= 0);	159✔
224	assert(mode < _UID_RANGE_USERNS_MODE_MAX);	159✔
225	assert(ret);	159✔
226
227	if (!path)	159✔
228	path = IN_SET(mode, UID_RANGE_USERNS_INSIDE, UID_RANGE_USERNS_OUTSIDE) ? "/proc/self/uid_map" : "/proc/self/gid_map";	142✔
229
230	f = fopen(path, "re");	159✔
231	if (!f) {	159✔
232	r = -errno;	×
233
234	if (r == -ENOENT && path_startswith(path, "/proc/"))	×
235	return proc_mounted() > 0 ? -EOPNOTSUPP : -ENOSYS;	×
236
237	return r;
238	}
239
240	range = new0(UIDRange, 1);	159✔
241	if (!range)	159✔
242	return -ENOMEM;
243
244	for (;;) {	144✔
245	uid_t uid_base, uid_shift, uid_range;	303✔
246
247	r = uid_map_read_one(f, &uid_base, &uid_shift, &uid_range);	303✔
248	if (r == -ENOMSG)	303✔
249	break;
250	if (r < 0)	144✔
251	return r;	×
252
253	r = uid_range_add_internal(	144✔
254	&range,
255	IN_SET(mode, UID_RANGE_USERNS_INSIDE, GID_RANGE_USERNS_INSIDE) ? uid_base : uid_shift,	144✔
256	uid_range,
257	/* coalesce = */ false);
258	if (r < 0)	144✔
259	return r;
260	}
261
262	uid_range_coalesce(range);	159✔
263
264	*ret = TAKE_PTR(range);	159✔
265	return 0;	159✔
266	}
267
268	int uid_range_load_userns_by_fd(int userns_fd, UIDRangeUsernsMode mode, UIDRange **ret) {	16✔
269	_cleanup_(sigkill_waitp) pid_t pid = 0;	16✔
270	int r;	16✔
271
272	assert(userns_fd >= 0);	16✔
273	assert(mode >= 0);	16✔
274	assert(mode < _UID_RANGE_USERNS_MODE_MAX);	16✔
275	assert(ret);	16✔
276
277	r = userns_enter_and_pin(userns_fd, &pid);	16✔
278	if (r < 0)	16✔
279	return r;
280
281	const char *p = procfs_file_alloca(	16✔
282	pid,
283	IN_SET(mode, UID_RANGE_USERNS_INSIDE, UID_RANGE_USERNS_OUTSIDE) ? "uid_map" : "gid_map");
284
285	return uid_range_load_userns(p, mode, ret);	16✔
286	}
287
288	bool uid_range_overlaps(const UIDRange *range, uid_t start, uid_t nr) {	4✔
289
290	if (!range)	4✔
291	return false;
292
293	/* Avoid overflow */
294	if (start > UINT32_MAX - nr)	4✔
295	nr = UINT32_MAX - start;	×
296
297	if (nr == 0)	4✔
298	return false;
299
300	FOREACH_ARRAY(entry, range->entries, range->n_entries)	4✔
301	if (start < entry->start + entry->nr &&	4✔
302	start + nr >= entry->start)	4✔
303	return true;
304
305	return false;
306	}
307
308	bool uid_range_equal(const UIDRange a, const UIDRange b) {	4✔
309	if (a == b)	4✔
310	return true;
311
312	if (!a \|\| !b)	4✔
313	return false;
314
315	if (a->n_entries != b->n_entries)	3✔
316	return false;
317
318	for (size_t i = 0; i < a->n_entries; i++) {	5✔
319	if (a->entries[i].start != b->entries[i].start)	3✔
320	return false;
321	if (a->entries[i].nr != b->entries[i].nr)	3✔
322	return false;
323	}
324
325	return true;
326	}
327
328	int uid_map_search_root(pid_t pid, UIDRangeUsernsMode mode, uid_t *ret) {	45✔
329	int r;	45✔
330
331	assert(pid_is_valid(pid));	45✔
332	assert(IN_SET(mode, UID_RANGE_USERNS_OUTSIDE, GID_RANGE_USERNS_OUTSIDE));	45✔
333
334	const char *p = procfs_file_alloca(pid, mode == UID_RANGE_USERNS_OUTSIDE ? "uid_map" : "gid_map");	66✔
335	_cleanup_fclose_ FILE *f = fopen(p, "re");	90✔
336	if (!f) {	45✔
337	if (errno != ENOENT)	×
338	return -errno;	×
339
340	r = proc_mounted();	×
341	if (r < 0)	×
342	return -ENOENT; /* original error, if we can't determine /proc/ state */
343
344	return r ? -ENOPKG : -ENOSYS;	×
345	}
346
347	for (;;) {	×
348	uid_t uid_base = UID_INVALID, uid_shift = UID_INVALID;	45✔
349
350	r = uid_map_read_one(f, &uid_base, &uid_shift, /* ret_uid_range= */ NULL);	45✔
351	if (r < 0)	45✔
352	return r;	45✔
353
354	if (uid_base == 0) {	42✔
355	if (ret)	42✔
356	*ret = uid_shift;	42✔
357	return 0;	42✔
358	}
359	}
360	}

systemd / systemd / 14554080340

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