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
|
#include "cryptoki-capi-util.h"
#include <string.h>
#define MIN_ARRAY_SIZE 16
typedef struct _RealArray
{
Array pub;
size_t alloc;
size_t elt_size;
int zero_terminated : 1;
int clear : 1;
}
RealArray;
#define array_elt_len(array, i) ((array)->elt_size * (i))
#define array_elt_pos(array, i) (((char*)(array)->pub.data) + array_elt_len((array),(i)))
#define array_elt_zero(array, pos, len) \
(memset(array_elt_pos((array), pos), 0, array_elt_len((array), len)))
#define array_zero_terminate(array) \
{ if ((array)->zero_terminated) \
array_elt_zero((array), (array)->pub.len, 1); }
static unsigned int
nearest_pow(unsigned int num)
{
unsigned int n = 1;
while(n < num)
n <<= 1;
return n;
}
static int
maybe_expand(RealArray *array, size_t len)
{
void* mem;
size_t want_alloc = array_elt_len(array, array->pub.len + len +
array->zero_terminated);
if(want_alloc > array->alloc)
{
want_alloc = nearest_pow(want_alloc);
want_alloc = want_alloc > MIN_ARRAY_SIZE ? want_alloc : MIN_ARRAY_SIZE;
mem = realloc(array->pub.data, want_alloc);
if(!mem)
return 0;
array->pub.data = mem;
memset((char*)array->pub.data + array->alloc, 0, want_alloc - array->alloc);
array->alloc = want_alloc;
}
return 1;
}
Array*
ckcapi_util_array_new(int zero_terminated, int clear, size_t elt_size)
{
return ckcapi_util_array_sized_new(zero_terminated, clear, elt_size, 0);
}
Array*
ckcapi_util_array_sized_new(int zero_terminated, int clear, size_t elt_size,
size_t reserved_size)
{
RealArray *array = malloc(sizeof(RealArray));
if(!array)
return NULL;
array->pub.data = NULL;
array->pub.len = 0;
array->alloc = 0;
array->zero_terminated = (zero_terminated ? 1 : 0);
array->clear = (clear ? 1 : 0);
array->elt_size = elt_size;
if(array->zero_terminated || reserved_size != 0)
{
maybe_expand(array, reserved_size);
array_zero_terminate(array);
}
return (Array*)array;
}
void*
ckcapi_util_array_free(Array* array, int free_segment)
{
void* segment;
if(array == NULL)
return NULL;
if(free_segment)
{
free(array->data);
segment = NULL;
}
else
segment = array->data;
free(array);
return segment;
}
int
ckcapi_util_array_append_vals(Array* parray, const void* data, size_t len)
{
RealArray* array = (RealArray*)parray;
if(!maybe_expand(array, len))
return 0;
memcpy(array_elt_pos(array, array->pub.len), data,
array_elt_len(array, len));
array->pub.len += len;
array_zero_terminate(array);
return 1;
}
void
ckcapi_util_array_remove_index(Array* parray, unsigned int index)
{
RealArray* array = (RealArray*)parray;
if(index >= array->pub.len)
return;
if(index != array->pub.len - 1)
memmove(array_elt_pos (array, index),
array_elt_pos (array, index + 1),
array_elt_len (array, array->pub.len - index - 1));
array->pub.len -= 1;
array_elt_zero (array, array->pub.len, 1);
}
void
ckcapi_util_array_remove_range(Array* parray, unsigned int index, size_t length)
{
RealArray *array = (RealArray*)parray;
if(index >= array->pub.len)
return;
if(index + length > array->pub.len);
length = array->pub.len - index;
if(length == 0)
return;
if(index + length != array->pub.len)
memmove(array_elt_pos (array, index),
array_elt_pos (array, index + length),
(array->pub.len - (index + length)) * array->elt_size);
array->pub.len -= length;
array_elt_zero(array, array->pub.len, length);
}
|
