22648815823

Committed 03 Mar 2026 11:47PM UTC coverage: 72.603% (+0.3%) from 72.342%

Build # 22648815823

Build Type

push

github

Committed by

yuwata

Commit Message

udevadm: fix --help text for udevadm test-builtin

Coverage Stats

316021 of 435275 relevant lines covered (72.6%)

1244520.48 hits per line

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

85.11

/src/basic/dirent-util.c

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

#include <fcntl.h>
#include <sys/stat.h>

#include "dirent-util.h"
#include "path-util.h"
#include "stat-util.h"
#include "string-util.h"

int dirent_ensure_type(int dir_fd, struct dirent *de) {
        int r;

        assert(dir_fd >= 0);
        assert(de);

        if (de->d_type != DT_UNKNOWN)
                return 0;

        if (dot_or_dot_dot(de->d_name)) {
                de->d_type = DT_DIR;
                return 0;
        }

        /* Let's ask only for the type, nothing else. */
        struct statx sx;
        r = xstatx_full(dir_fd,
                        de->d_name,
                        AT_SYMLINK_NOFOLLOW|AT_NO_AUTOMOUNT,
                        /* xstatx_flags= */ 0,
                        /* mandatory_mask= */ STATX_TYPE,
                        /* optional_mask= */ STATX_INO,
                        /* mandatory_attributes= */ 0,
                        &sx);
        if (r < 0)
                return r;

        assert(FLAGS_SET(sx.stx_mask, STATX_TYPE));
        de->d_type = IFTODT(sx.stx_mode);

        /* If the inode is passed too, update the field, i.e. report most recent data */
        if (FLAGS_SET(sx.stx_mask, STATX_INO))
                de->d_ino = sx.stx_ino;

        return 0;
}

bool dirent_is_file(const struct dirent *de) {
        assert(de);

        if (!IN_SET(de->d_type, DT_REG, DT_LNK, DT_UNKNOWN))
                return false;

        if (hidden_or_backup_file(de->d_name))
                return false;

        return true;
}

bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
        assert(de);

        if (!IN_SET(de->d_type, DT_REG, DT_LNK, DT_UNKNOWN))
                return false;

        if (de->d_name[0] == '.')
                return false;

        if (!suffix)
                return true;

        return endswith(de->d_name, suffix);
}

struct dirent* readdir_ensure_type(DIR *d) {
        int r;

        assert(d);

        /* Like readdir(), but fills in .d_type if it is DT_UNKNOWN */

        for (;;) {
                struct dirent *de;

                errno = 0;
                de = readdir(d);
                if (!de)
                        return NULL;

                r = dirent_ensure_type(dirfd(d), de);
                if (r >= 0)
                        return de;
                if (r != -ENOENT) {
                        errno = -r; /* We want to be compatible with readdir(), hence propagate error via errno here */
                        return NULL;
                }

                /* Vanished by now? Then skip immediately to next */
        }
}

struct dirent* readdir_no_dot(DIR *d) {
        assert(d);

        for (;;) {
                struct dirent *de;

                de = readdir_ensure_type(d);
                if (!de || !dot_or_dot_dot(de->d_name))
                        return de;
        }
}

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include <fcntl.h>
4	#include <sys/stat.h>
5
6	#include "dirent-util.h"
7	#include "path-util.h"
8	#include "stat-util.h"
9	#include "string-util.h"
10
11	int dirent_ensure_type(int dir_fd, struct dirent *de) {	11,866,504✔
12	int r;	11,866,504✔
13
14	assert(dir_fd >= 0);	11,866,504✔
15	assert(de);	11,866,504✔
16
17	if (de->d_type != DT_UNKNOWN)	11,866,504✔
18	return 0;	11,866,504✔
19
20	if (dot_or_dot_dot(de->d_name)) {	2✔
21	de->d_type = DT_DIR;	1✔
22	return 0;	1✔
23	}
24
25	/* Let's ask only for the type, nothing else. */
26	struct statx sx;	1✔
27	r = xstatx_full(dir_fd,	1✔
28	de->d_name,
29	AT_SYMLINK_NOFOLLOW\|AT_NO_AUTOMOUNT,
30	/* xstatx_flags= */ 0,
31	/* mandatory_mask= */ STATX_TYPE,
32	/* optional_mask= */ STATX_INO,
33	/* mandatory_attributes= */ 0,
34	&sx);
35	if (r < 0)	1✔
36	return r;
37
38	assert(FLAGS_SET(sx.stx_mask, STATX_TYPE));	×
39	de->d_type = IFTODT(sx.stx_mode);	×
40
41	/* If the inode is passed too, update the field, i.e. report most recent data */
42	if (FLAGS_SET(sx.stx_mask, STATX_INO))	×
43	de->d_ino = sx.stx_ino;	×
44
45	return 0;
46	}
47
48	bool dirent_is_file(const struct dirent *de) {	18,279✔
49	assert(de);	18,279✔
50
51	if (!IN_SET(de->d_type, DT_REG, DT_LNK, DT_UNKNOWN))	18,279✔
52	return false;
53
54	if (hidden_or_backup_file(de->d_name))	15,305✔
55	return false;	5✔
56
57	return true;
58	}
59
60	bool dirent_is_file_with_suffix(const struct dirent de, const char suffix) {	12✔
61	assert(de);	12✔
62
63	if (!IN_SET(de->d_type, DT_REG, DT_LNK, DT_UNKNOWN))	12✔
64	return false;
65
66	if (de->d_name[0] == '.')	11✔
67	return false;
68
69	if (!suffix)	9✔
70	return true;
71
72	return endswith(de->d_name, suffix);	6✔
73	}
74
75	struct dirent* readdir_ensure_type(DIR *d) {	12,617,021✔
76	int r;	12,617,021✔
77
78	assert(d);	12,617,021✔
79
80	/* Like readdir(), but fills in .d_type if it is DT_UNKNOWN */
81
82	for (;;) {	12,617,021✔
83	struct dirent *de;	12,617,021✔
84
85	errno = 0;	12,617,021✔
86	de = readdir(d);	12,617,021✔
87	if (!de)	12,617,021✔
88	return NULL;
89
90	r = dirent_ensure_type(dirfd(d), de);	11,866,126✔
91	if (r >= 0)	11,866,126✔
92	return de;
93	if (r != -ENOENT) {	×
94	errno = -r; /* We want to be compatible with readdir(), hence propagate error via errno here */	×
95	return NULL;	×
96	}
97
98	/* Vanished by now? Then skip immediately to next */
99	}
100	}
101
102	struct dirent* readdir_no_dot(DIR *d) {	150,672✔
103	assert(d);	150,672✔
104
105	for (;;) {	187,863✔
106	struct dirent *de;	187,863✔
107
108	de = readdir_ensure_type(d);	187,863✔
109	if (!de \|\| !dot_or_dot_dot(de->d_name))	187,863✔
110	return de;	150,672✔
111	}
112	}

systemd / systemd / 22648815823

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