1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/* NetworkManager -- Network link manager
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301 USA.
*
* (C) Copyright 2017 Red Hat, Inc.
*/
#include "nm-default.h"
#include "nm-hash-utils.h"
#include <stdint.h>
#include "nm-shared-utils.h"
#include "nm-random-utils.h"
/*****************************************************************************/
#define HASH_KEY_SIZE 16u
#define HASH_KEY_SIZE_GUINT ((HASH_KEY_SIZE + sizeof (guint) - 1) / sizeof (guint))
G_STATIC_ASSERT (sizeof (guint) * HASH_KEY_SIZE_GUINT >= HASH_KEY_SIZE);
static const guint8 *
_get_hash_key (void)
{
static const guint8 *volatile global_seed = NULL;
const guint8 *g;
g = global_seed;
if (G_UNLIKELY (g == NULL)) {
/* the returned hash is aligned to guin64, hence, it is save
* to use it as guint* or guint64* pointer. */
static union {
guint8 v8[HASH_KEY_SIZE];
} g_arr _nm_alignas (guint64);
static gsize g_lock;
if (g_once_init_enter (&g_lock)) {
nm_utils_random_bytes (g_arr.v8, sizeof (g_arr.v8));
g_atomic_pointer_compare_and_exchange (&global_seed, NULL, g_arr.v8);
g = g_arr.v8;
g_once_init_leave (&g_lock, 1);
} else {
g = global_seed;
nm_assert (g);
}
}
return g;
}
void
nm_hash_init (NMHashState *state, guint static_seed)
{
const guint8 *g;
guint seed[HASH_KEY_SIZE_GUINT];
nm_assert (state);
g = _get_hash_key ();
memcpy (seed, g, HASH_KEY_SIZE);
seed[0] ^= static_seed;
siphash24_init (&state->_state, (const guint8 *) seed);
}
guint
nm_hash_str (const char *str)
{
NMHashState h;
if (str) {
nm_hash_init (&h, 1867854211u);
nm_hash_update_str (&h, str);
} else
nm_hash_init (&h, 842995561u);
return nm_hash_complete (&h);
}
guint
nm_str_hash (gconstpointer str)
{
return nm_hash_str (str);
}
guint
nm_hash_ptr (gconstpointer ptr)
{
guint h;
h = ((const guint *) _get_hash_key ())[0];
if (sizeof (ptr) <= sizeof (guint))
h = h ^ ((guint) ((uintptr_t) ptr));
else
h = h ^ ((guint) (((guint64) (uintptr_t) ptr) >> 32)) ^ ((guint) ((uintptr_t) ptr));
return h ?: 2907677551u;
}
guint
nm_direct_hash (gconstpointer ptr)
{
return nm_hash_ptr (ptr);
}
|
