1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 Copyright 2014 Michal Schmidt
8 #include "hash-funcs.h"
11 void string_hash_func(const void *p
, struct siphash
*state
) {
12 siphash24_compress(p
, strlen(p
) + 1, state
);
15 int string_compare_func(const void *a
, const void *b
) {
19 const struct hash_ops string_hash_ops
= {
20 .hash
= string_hash_func
,
21 .compare
= string_compare_func
24 void path_hash_func(const void *p
, struct siphash
*state
) {
31 /* Calculates a hash for a path in a way this duplicate inner slashes don't make a differences, and also
32 * whether there's a trailing slash or not. This fits well with the semantics of path_compare(), which does
33 * similar checks and also doesn't care for trailing slashes. Note that relative and absolute paths (i.e. those
34 * which begin in a slash or not) will hash differently though. */
37 if (n
> 0) { /* Eat up initial slashes, and add one "/" to the hash for all of them */
38 siphash24_compress(q
, 1, state
);
43 /* Determine length of next component */
45 if (n
== 0) /* Reached the end? */
48 /* Add this component to the hash and skip over it */
49 siphash24_compress(q
, n
, state
);
52 /* How many slashes follow this component? */
54 if (q
[n
] == 0) /* Is this a trailing slash? If so, we are at the end, and don't care about the slashes anymore */
57 /* We are not add the end yet. Hash exactly one slash for all of the ones we just encountered. */
58 siphash24_compress(q
, 1, state
);
63 int path_compare_func(const void *a
, const void *b
) {
64 return path_compare(a
, b
);
67 const struct hash_ops path_hash_ops
= {
68 .hash
= path_hash_func
,
69 .compare
= path_compare_func
72 void trivial_hash_func(const void *p
, struct siphash
*state
) {
73 siphash24_compress(&p
, sizeof(p
), state
);
76 int trivial_compare_func(const void *a
, const void *b
) {
77 return a
< b
? -1 : (a
> b
? 1 : 0);
80 const struct hash_ops trivial_hash_ops
= {
81 .hash
= trivial_hash_func
,
82 .compare
= trivial_compare_func
85 void uint64_hash_func(const void *p
, struct siphash
*state
) {
86 siphash24_compress(p
, sizeof(uint64_t), state
);
89 int uint64_compare_func(const void *_a
, const void *_b
) {
91 a
= *(const uint64_t*) _a
;
92 b
= *(const uint64_t*) _b
;
93 return a
< b
? -1 : (a
> b
? 1 : 0);
96 const struct hash_ops uint64_hash_ops
= {
97 .hash
= uint64_hash_func
,
98 .compare
= uint64_compare_func
101 #if SIZEOF_DEV_T != 8
102 void devt_hash_func(const void *p
, struct siphash
*state
) {
103 siphash24_compress(p
, sizeof(dev_t
), state
);
106 int devt_compare_func(const void *_a
, const void *_b
) {
108 a
= *(const dev_t
*) _a
;
109 b
= *(const dev_t
*) _b
;
110 return a
< b
? -1 : (a
> b
? 1 : 0);
113 const struct hash_ops devt_hash_ops
= {
114 .hash
= devt_hash_func
,
115 .compare
= devt_compare_func