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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2016-2018 The TokTok team.
* Copyright © 2013 Tox project.
* Copyright © 2013 plutooo
*/
/**
* Utilities.
*/
#ifndef _XOPEN_SOURCE
#define _XOPEN_SOURCE 600
#endif /* _XOPEN_SOURCE */
#include "util.h"
#include <stdlib.h>
#include <string.h>
#include "ccompat.h"
#include "mem.h"
bool is_power_of_2(uint64_t x)
{
return x != 0 && (x & (~x + 1)) == x;
}
void free_uint8_t_pointer_array(const Memory *mem, uint8_t **ary, size_t n_items)
{
if (ary == nullptr) {
return;
}
for (size_t i = 0; i < n_items; ++i) {
if (ary[i] != nullptr) {
mem_delete(mem, ary[i]);
}
}
mem_delete(mem, ary);
}
uint16_t data_checksum(const uint8_t *data, uint32_t length)
{
uint8_t checksum[2] = {0};
uint16_t check;
for (uint32_t i = 0; i < length; ++i) {
checksum[i % 2] ^= data[i];
}
memcpy(&check, checksum, sizeof(check));
return check;
}
int create_recursive_mutex(pthread_mutex_t *mutex)
{
pthread_mutexattr_t attr;
if (pthread_mutexattr_init(&attr) != 0) {
return -1;
}
if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) != 0) {
pthread_mutexattr_destroy(&attr);
return -1;
}
/* Create queue mutex */
if (pthread_mutex_init(mutex, &attr) != 0) {
pthread_mutexattr_destroy(&attr);
return -1;
}
pthread_mutexattr_destroy(&attr);
return 0;
}
bool memeq(const uint8_t *a, size_t a_size, const uint8_t *b, size_t b_size)
{
return a_size == b_size && memcmp(a, b, a_size) == 0;
}
uint8_t *memdup(const uint8_t *data, size_t data_size)
{
if (data == nullptr || data_size == 0) {
return nullptr;
}
uint8_t *copy = (uint8_t *)malloc(data_size);
if (copy != nullptr) {
memcpy(copy, data, data_size);
}
return copy;
}
void memzero(uint8_t *data, size_t data_size)
{
if (data == nullptr || data_size == 0) {
return;
}
memset(data, 0, data_size);
}
int16_t max_s16(int16_t a, int16_t b)
{
return a > b ? a : b;
}
int32_t max_s32(int32_t a, int32_t b)
{
return a > b ? a : b;
}
int64_t max_s64(int64_t a, int64_t b)
{
return a > b ? a : b;
}
int16_t min_s16(int16_t a, int16_t b)
{
return a < b ? a : b;
}
int32_t min_s32(int32_t a, int32_t b)
{
return a < b ? a : b;
}
int64_t min_s64(int64_t a, int64_t b)
{
return a < b ? a : b;
}
uint8_t max_u08(uint8_t a, uint8_t b)
{
return a > b ? a : b;
}
uint16_t max_u16(uint16_t a, uint16_t b)
{
return a > b ? a : b;
}
uint32_t max_u32(uint32_t a, uint32_t b)
{
return a > b ? a : b;
}
uint64_t max_u64(uint64_t a, uint64_t b)
{
return a > b ? a : b;
}
uint16_t min_u16(uint16_t a, uint16_t b)
{
return a < b ? a : b;
}
uint32_t min_u32(uint32_t a, uint32_t b)
{
return a < b ? a : b;
}
uint64_t min_u64(uint64_t a, uint64_t b)
{
return a < b ? a : b;
}
int cmp_uint(uint64_t a, uint64_t b)
{
return (a > b ? 1 : 0) - (a < b ? 1 : 0);
}
uint32_t jenkins_one_at_a_time_hash(const uint8_t *key, size_t len)
{
uint32_t hash = 0;
for (uint32_t i = 0; i < len; ++i) {
hash += key[i];
hash += (uint32_t)((uint64_t)hash << 10);
hash ^= hash >> 6;
}
hash += (uint32_t)((uint64_t)hash << 3);
hash ^= hash >> 11;
hash += (uint32_t)((uint64_t)hash << 15);
return hash;
}
|
