15263807472

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

#include <stdlib.h>
#include <string.h>
#include <sys/sysmacros.h>

#include "hash-funcs.h"
#include "path-util.h"
#include "siphash24.h"
#include "strv.h"

void string_hash_func(const char *p, struct siphash *state) {
        siphash24_compress(p, strlen(p) + 1, state);
}

DEFINE_HASH_OPS(string_hash_ops,
                char, string_hash_func, string_compare_func);
DEFINE_HASH_OPS_WITH_KEY_DESTRUCTOR(
                string_hash_ops_free,
                char, string_hash_func, string_compare_func, free);
DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
                string_hash_ops_value_free,
                char, string_hash_func, string_compare_func,
                void, free);
DEFINE_HASH_OPS_FULL(
                string_hash_ops_free_free,
                char, string_hash_func, string_compare_func, free,
                void, free);
DEFINE_HASH_OPS_FULL(
                string_hash_ops_free_strv_free,
                char, string_hash_func, string_compare_func, free,
                char*, strv_free);

void path_hash_func(const char *q, struct siphash *state) {
        bool add_slash = false;

        assert(q);
        assert(state);

        /* Calculates a hash for a path in a way this duplicate inner slashes don't make a differences, and also
         * whether there's a trailing slash or not. This fits well with the semantics of path_compare(), which does
         * similar checks and also doesn't care for trailing slashes. Note that relative and absolute paths (i.e. those
         * which begin in a slash or not) will hash differently though. */

        /* if path is absolute, add one "/" to the hash. */
        if (path_is_absolute(q))
                siphash24_compress_byte('/', state);

        for (;;) {
                const char *e;
                int r;

                r = path_find_first_component(&q, true, &e);
                if (r == 0)
                        return;

                if (add_slash)
                        siphash24_compress_byte('/', state);

                if (r < 0) {
                        /* if a component is invalid, then add remaining part as a string. */
                        string_hash_func(q, state);
                        return;
                }

                /* Add this component to the hash. */
                siphash24_compress(e, r, state);

                add_slash = true;
        }
}

DEFINE_HASH_OPS(path_hash_ops,
                char, path_hash_func, path_compare);
DEFINE_HASH_OPS_WITH_KEY_DESTRUCTOR(
                path_hash_ops_free,
                char, path_hash_func, path_compare, free);
DEFINE_HASH_OPS_FULL(
                path_hash_ops_free_free,
                char, path_hash_func, path_compare, free,
                void, free);

void trivial_hash_func(const void *p, struct siphash *state) {
        siphash24_compress_typesafe(p, state);
}

int trivial_compare_func(const void *a, const void *b) {
        return CMP(a, b);
}

DEFINE_HASH_OPS(trivial_hash_ops,
                void, trivial_hash_func, trivial_compare_func);
DEFINE_HASH_OPS_WITH_KEY_DESTRUCTOR(
                trivial_hash_ops_free,
                void, trivial_hash_func, trivial_compare_func, free);
DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
                trivial_hash_ops_value_free,
                void, trivial_hash_func, trivial_compare_func,
                void, free);
DEFINE_HASH_OPS_FULL(
                trivial_hash_ops_free_free,
                void, trivial_hash_func, trivial_compare_func, free,
                void, free);

void uint64_hash_func(const uint64_t *p, struct siphash *state) {
        siphash24_compress_typesafe(*p, state);
}

int uint64_compare_func(const uint64_t *a, const uint64_t *b) {
        return CMP(*a, *b);
}

DEFINE_HASH_OPS(uint64_hash_ops,
                uint64_t, uint64_hash_func, uint64_compare_func);
DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
                uint64_hash_ops_value_free,
                uint64_t, uint64_hash_func, uint64_compare_func,
                void, free);

#if SIZEOF_DEV_T != 8
void devt_hash_func(const dev_t *p, struct siphash *state) {
        siphash24_compress_typesafe(*p, state);
}
#endif

int devt_compare_func(const dev_t *a, const dev_t *b) {
        int r;

        r = CMP(major(*a), major(*b));
        if (r != 0)
                return r;

        return CMP(minor(*a), minor(*b));
}

DEFINE_HASH_OPS(devt_hash_ops, dev_t, devt_hash_func, devt_compare_func);

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include <stdlib.h>
4	#include <string.h>
5	#include <sys/sysmacros.h>
6
7	#include "hash-funcs.h"
8	#include "path-util.h"
9	#include "siphash24.h"
10	#include "strv.h"
11
12	void string_hash_func(const char p, struct siphash state) {	88,359,862✔
13	siphash24_compress(p, strlen(p) + 1, state);	88,359,862✔
14	}	88,359,862✔
15
16	DEFINE_HASH_OPS(string_hash_ops,
17	char, string_hash_func, string_compare_func);
18	DEFINE_HASH_OPS_WITH_KEY_DESTRUCTOR(	518,955✔
19	string_hash_ops_free,
20	char, string_hash_func, string_compare_func, free);
21	DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(	28,371✔
22	string_hash_ops_value_free,
23	char, string_hash_func, string_compare_func,
24	void, free);
25	DEFINE_HASH_OPS_FULL(	23,399,804✔
26	string_hash_ops_free_free,
27	char, string_hash_func, string_compare_func, free,
28	void, free);
29	DEFINE_HASH_OPS_FULL(	531,330✔
30	string_hash_ops_free_strv_free,
31	char, string_hash_func, string_compare_func, free,
32	char*, strv_free);
33
34	void path_hash_func(const char q, struct siphash state) {	22,669,789✔
35	bool add_slash = false;	22,669,789✔
36
37	assert(q);	22,669,789✔
38	assert(state);	22,669,789✔
39
40	/* Calculates a hash for a path in a way this duplicate inner slashes don't make a differences, and also
41	* whether there's a trailing slash or not. This fits well with the semantics of path_compare(), which does
42	* similar checks and also doesn't care for trailing slashes. Note that relative and absolute paths (i.e. those
43	* which begin in a slash or not) will hash differently though. */
44
45	/* if path is absolute, add one "/" to the hash. */
46	if (path_is_absolute(q))	22,669,789✔
47	siphash24_compress_byte('/', state);	17,868,366✔
48
49	for (;;) {	218,580,933✔
50	const char *e;	120,625,361✔
51	int r;	120,625,361✔
52
53	r = path_find_first_component(&q, true, &e);	120,625,361✔
54	if (r == 0)	120,625,361✔
55	return;	22,669,789✔
56
57	if (add_slash)	97,955,708✔
58	siphash24_compress_byte('/', state);	75,357,110✔
59
60	if (r < 0) {	97,955,708✔
61	/* if a component is invalid, then add remaining part as a string. */
62	string_hash_func(q, state);	136✔
63	return;	136✔
64	}
65
66	/* Add this component to the hash. */
67	siphash24_compress(e, r, state);	97,955,572✔
68
69	add_slash = true;	97,955,572✔
70	}
71	}
72
73	DEFINE_HASH_OPS(path_hash_ops,
74	char, path_hash_func, path_compare);
75	DEFINE_HASH_OPS_WITH_KEY_DESTRUCTOR(	1,257,368✔
76	path_hash_ops_free,
77	char, path_hash_func, path_compare, free);
78	DEFINE_HASH_OPS_FULL(	94,662✔
79	path_hash_ops_free_free,
80	char, path_hash_func, path_compare, free,
81	void, free);
82
83	void trivial_hash_func(const void p, struct siphash state) {	27,201,339✔
84	siphash24_compress_typesafe(p, state);	27,201,339✔
85	}	27,201,339✔
86
87	int trivial_compare_func(const void a, const void b) {	15,515,311✔
88	return CMP(a, b);	15,515,311✔
89	}
90
91	DEFINE_HASH_OPS(trivial_hash_ops,
92	void, trivial_hash_func, trivial_compare_func);
93	DEFINE_HASH_OPS_WITH_KEY_DESTRUCTOR(	8,655✔
94	trivial_hash_ops_free,
95	void, trivial_hash_func, trivial_compare_func, free);
96	DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(	5,833✔
97	trivial_hash_ops_value_free,
98	void, trivial_hash_func, trivial_compare_func,
99	void, free);
100	DEFINE_HASH_OPS_FULL(	3,374✔
101	trivial_hash_ops_free_free,
102	void, trivial_hash_func, trivial_compare_func, free,
103	void, free);
104
105	void uint64_hash_func(const uint64_t p, struct siphash state) {	29,112,743✔
106	siphash24_compress_typesafe(*p, state);	29,112,743✔
107	}	29,112,743✔
108
109	int uint64_compare_func(const uint64_t a, const uint64_t b) {	25,028,100✔
110	return CMP(a, b);	25,028,100✔
111	}
112
113	DEFINE_HASH_OPS(uint64_hash_ops,
114	uint64_t, uint64_hash_func, uint64_compare_func);
115	DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(	31,873✔
116	uint64_hash_ops_value_free,
117	uint64_t, uint64_hash_func, uint64_compare_func,
118	void, free);
119
120	#if SIZEOF_DEV_T != 8
121	void devt_hash_func(const dev_t p, struct siphash state) {
122	siphash24_compress_typesafe(*p, state);
123	}
124	#endif
125
126	int devt_compare_func(const dev_t a, const dev_t b) {	22✔
127	int r;	22✔
128
129	r = CMP(major(a), major(b));	22✔
130	if (r != 0)	22✔
UNCOV 131	return r;	×
132
133	return CMP(minor(a), minor(b));	22✔
134	}
135
136	DEFINE_HASH_OPS(devt_hash_ops, dev_t, devt_hash_func, devt_compare_func);

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