15263807472

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

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

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

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

        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. */
        if (statx(dir_fd, de->d_name, AT_SYMLINK_NOFOLLOW|AT_NO_AUTOMOUNT, STATX_TYPE, &sx) < 0)
                return -errno;

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

systemd / systemd / 15263807472

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