]> pd.if.org Git - zpackage/blob - crypto/buffer.c
expand zpm man page
[zpackage] / crypto / buffer.c
1 #define _POSIX_C_SOURCE 200809L
2
3 #include <string.h>
4 #include <errno.h>
5
6 #include "tlse.h"
7 #include "buffer.h"
8
9 void tls_buffer_init(struct tls_buffer *buffer, size_t initial) {
10         buffer->buffer = 0;
11         buffer->len = 0;
12         buffer->size = 0;
13         buffer->error = 0;
14         if (initial) {
15                 errno = 0;
16                 buffer->buffer = malloc(initial);
17                 if (buffer->buffer) {
18                         memset(buffer->buffer, 0, initial);
19                         buffer->size = initial;
20                 } else {
21                         buffer->error = errno;
22                 }
23         }
24 }
25
26 void tls_buffer_compact(struct tls_buffer *b) {
27         void *new;
28
29         if (b->error || b->size == b->len) {
30                 return;
31         }
32
33         errno = 0;
34         new = realloc(b->buffer, b->len);
35
36         if (new == NULL) {
37                 b->error = errno;
38                 return;
39         }
40
41         b->buffer = new;
42         return;
43 }
44
45 /* makes sure there's at least need bytes free */
46 void tls_buffer_expand(struct tls_buffer *buf, size_t need) {
47         size_t want;
48
49         if (buf->error) {
50                 return;
51         }
52
53         want = buf->len + need;
54
55         if (want <= buf->size) {
56                 return;
57         }
58
59         errno = 0;
60         char *new = realloc(buf->buffer, want);
61         if (new) {
62                 buf->buffer = new;
63                 buf->size = want;
64                 memset(buf->buffer + buf->len, 0, buf->size - buf->len);
65         } else {
66                 buf->error = errno;
67         }
68 }
69
70 void tls_buffer_free(struct tls_buffer *buffer) {
71         /* TODO only zero out memory if it's "secure" buffer */
72         if (buffer->buffer && buffer->len) {
73                 memset(buffer->buffer, 0, buffer->len);
74         }
75         free(buffer->buffer);
76         tls_buffer_init(buffer, 0);
77 }
78
79 void tls_buffer_set(struct tls_buffer *buffer, int ch) {
80         /* TODO only zero out memory if it's "secure" buffer */
81         if (buffer->buffer && buffer->size) {
82                 memset(buffer->buffer, ch, buffer->size);
83         }
84 }
85
86 void tls_buffer_append(struct tls_buffer *buffer, const unsigned char *bytes, size_t n) {
87         tls_buffer_expand(buffer, n);
88
89         if (buffer->error || !bytes) {
90                 return;
91         }
92
93         memcpy(buffer->buffer + buffer->len, bytes, n);
94         buffer->len += n;
95 }
96
97 void tls_buffer_append16(struct tls_buffer *buffer, uint16_t n) {
98         tls_buffer_expand(buffer, 2);
99
100         if (buffer->error) {
101                 return;
102         }
103
104         buffer->buffer[buffer->len++] = (n >> 8) & 0xff;
105         buffer->buffer[buffer->len++] = n & 0xff;
106 }
107
108 void tls_buffer_append24(struct tls_buffer *buffer, uint32_t n) {
109         tls_buffer_expand(buffer, 3);
110
111         if (buffer->error) {
112                 return;
113         }
114
115         buffer->buffer[buffer->len++] = (n >> 16) & 0xff;
116         buffer->buffer[buffer->len++] = (n >> 8) & 0xff;
117         buffer->buffer[buffer->len++] = n & 0xff;
118 }
119
120 void tls_buffer_append_byte(struct tls_buffer *buffer, uint8_t n) {
121         tls_buffer_expand(buffer, 1);
122
123         if (buffer->error) {
124                 return;
125         }
126
127         buffer->buffer[buffer->len++] = n & 0xff;
128 }
129
130 void tls_buffer_write16(struct tls_buffer *buffer, uint16_t n, size_t at) {
131         if (at+2 > buffer->size) {
132                 tls_buffer_expand(buffer, at+2 - buffer->size);
133         }
134
135         if (buffer->error) {
136                 return;
137         }
138
139         buffer->buffer[at] = (n >> 8) & 0xff;
140         buffer->buffer[at+1] = n & 0xff;
141
142         if (at+2 > buffer->len) {
143                 buffer->len = at + 2;
144         }
145 }
146
147 uint16_t tls_buffer_read16(struct tls_buffer *buffer, size_t at) {
148         uint16_t res = 0;
149
150         if (buffer->error || at+2 < buffer->len) {
151                 return 0;
152         }
153
154         res = (buffer->buffer[at] << 8) + buffer->buffer[at+1];
155         return res;
156 }
157
158 uint64_t tls_buffer_readbe(struct tls_buffer *buffer, int bytes, size_t at) {
159         uint16_t res = 0;
160         int i;
161
162         if (buffer->error || at+bytes < buffer->len) {
163                 return 0;
164         }
165
166         for (i=0; i<bytes; i++) {
167                 res <<= 8;
168                 res += buffer->buffer[at+i];
169         }
170
171         return res;
172 }
173
174 void tls_buffer_writebe(struct tls_buffer *buffer, int bytes, size_t at, uint64_t val) {
175         int i;
176         if (at+bytes > buffer->size) {
177                 tls_buffer_expand(buffer, at+bytes - buffer->size);
178         }
179
180         if (buffer->error) {
181                 return;
182         }
183
184         for (i=bytes-1; i>=0; i--) {
185                 buffer->buffer[at+i] = val & 0xff;
186                 val >>= 8;
187         }
188
189         return;
190 }
191
192
193 void tls_buffer_shift(struct tls_buffer *buffer, size_t n) {
194         if (buffer->error) {
195                 return;
196         }
197
198         if (buffer->len < n) {
199                 n = buffer->len;
200         }
201
202         if (n) {
203                 memmove(buffer->buffer, buffer->buffer + n, buffer->len - n);
204                 memset(buffer->buffer + buffer->len - n, 0, n);
205 #if 0
206                 fprintf(stderr, "memmove(%p, %p, %zu)\n", buffer->buffer,
207                                 buffer->buffer+n, buffer->len - n);
208                 fprintf(stderr, "memset(%p, %d, %zu)\n", buffer->buffer+n,
209                                 0, n);
210 #endif
211
212                 buffer->len -= n;
213         }
214 }
215
216 /* make room at the beginning */
217 void tls_buffer_unshift(struct tls_buffer *buffer, size_t n) {
218         tls_buffer_expand(buffer, n);
219
220         if (buffer->error) {
221                 return;
222         }
223
224         memmove(buffer->buffer + n, buffer->buffer, n);
225         memset(buffer->buffer, 0, n);
226 }
227
228 #if 0
229 uint32_t tls_buffer_next3(struct tls_buffer_reader *rb) {
230         uint32_t r;
231
232         r = tls_buffer_readbe(rb, 3, rb->cursor);
233         rb->cursor += 3;
234         return r;
235 }
236
237 uint16_t tls_buffer_next2(struct tls_buffer_reader *rb) {
238         uint16_t r;
239
240         r = tls_buffer_readbe(rb, 2, rb->cursor);
241         rb->cursor += 2;
242         return r;
243 }
244
245 uint8_t tls_buffer_next(struct tls_buffer_reader *rb) {
246         uint16_t r;
247
248         r = tls_buffer_readbe(rb, 2, rb->cursor);
249         rb->cursor += 2;
250
251 }
252
253 void tls_buffer_nextn(struct tls_buffer_reader *rb, unsigned char *b, size_t n) {
254         tls_buffer_read(rb, b, n, rb->cursor);
255         rb->cursor += n;
256 }
257 #endif