4aab5cb81ad2b79e0dbc521987d9ce846f424d52
[openssl.git] / ssl / packet_locl.h
1 /* ssl/packet_locl.h */
2 /*
3  * Written by Matt Caswell for the OpenSSL project.
4  */
5 /* ====================================================================
6  * Copyright (c) 2015 The OpenSSL Project.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in
17  *    the documentation and/or other materials provided with the
18  *    distribution.
19  *
20  * 3. All advertising materials mentioning features or use of this
21  *    software must display the following acknowledgment:
22  *    "This product includes software developed by the OpenSSL Project
23  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
24  *
25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26  *    endorse or promote products derived from this software without
27  *    prior written permission. For written permission, please contact
28  *    openssl-core@openssl.org.
29  *
30  * 5. Products derived from this software may not be called "OpenSSL"
31  *    nor may "OpenSSL" appear in their names without prior written
32  *    permission of the OpenSSL Project.
33  *
34  * 6. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by the OpenSSL Project
37  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
38  *
39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50  * OF THE POSSIBILITY OF SUCH DAMAGE.
51  * ====================================================================
52  *
53  * This product includes cryptographic software written by Eric Young
54  * (eay@cryptsoft.com).  This product includes software written by Tim
55  * Hudson (tjh@cryptsoft.com).
56  *
57  */
58
59 #ifndef HEADER_PACKET_LOCL_H
60 # define HEADER_PACKET_LOCL_H
61
62 # include <string.h>
63 # include <openssl/bn.h>
64 # include <openssl/buffer.h>
65 # include "e_os.h"
66
67 # ifdef __cplusplus
68 extern "C" {
69 # endif
70
71 typedef struct {
72     /* Pointer to the start of the buffer data */
73     unsigned char *start;
74
75     /* Pointer to the first byte after the end of the buffer data */
76     unsigned char *end;
77
78     /* Pointer to where we are currently reading from */
79     unsigned char *curr;
80 } PACKET;
81
82 /*
83  * Returns 1 if there are exactly |len| bytes left to be read from |pkt|
84  * and 0 otherwise
85  */
86 __owur static inline size_t PACKET_remaining(PACKET *pkt)
87 {
88     return (size_t)(pkt->end - pkt->curr);
89 }
90
91 /*
92  * Initialise a PACKET with |len| bytes held in |buf|. This does not make a
93  * copy of the data so |buf| must be present for the whole time that the PACKET
94  * is being used.
95  */
96 static inline int PACKET_buf_init(PACKET *pkt, unsigned char *buf, size_t len)
97 {
98     pkt->start = pkt->curr = buf;
99     pkt->end = pkt->start + len;
100
101     /* Sanity checks */
102     if (pkt->start > pkt->end
103             || pkt->curr < pkt->start
104             || pkt->curr > pkt->end
105             || len != (size_t)(pkt->end - pkt->start)) {
106         return 0;
107     }
108
109     return 1;
110 }
111
112 /*
113  * Peek ahead and initialize |subpkt| with the next |len| bytes read from |pkt|.
114  * Data is not copied: the |subpkt| packet will share its underlying buffer with
115  * the original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|.
116  */
117 __owur static inline int PACKET_peek_sub_packet(PACKET *pkt, PACKET *subpkt,
118                                                size_t len)
119 {
120     if (PACKET_remaining(pkt) < len)
121         return 0;
122
123     PACKET_buf_init(subpkt, pkt->curr, len);
124
125     return 1;
126 }
127
128 /*
129  * Initialize |subpkt| with the next |len| bytes read from |pkt|. Data is not
130  * copied: the |subpkt| packet will share its underlying buffer with the
131  * original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|.
132  */
133 __owur static inline int PACKET_get_sub_packet(PACKET *pkt, PACKET *subpkt,
134                                                size_t len)
135 {
136     if (!PACKET_peek_sub_packet(pkt, subpkt, len))
137         return 0;
138
139     pkt->curr += len;
140
141     return 1;
142 }
143
144 /* Peek ahead at 2 bytes in network order from |pkt| and store the value in
145  * |*data|
146  */
147 __owur static inline int PACKET_peek_net_2(PACKET *pkt, unsigned int *data)
148 {
149     if (PACKET_remaining(pkt) < 2)
150         return 0;
151
152     *data  = ((unsigned int)(*pkt->curr)) <<  8;
153     *data |= *(pkt->curr + 1);
154
155     return 1;
156 }
157
158 /* Equivalent of n2s */
159 /* Get 2 bytes in network order from |pkt| and store the value in |*data| */
160 __owur static inline int PACKET_get_net_2(PACKET *pkt, unsigned int *data)
161 {
162     if (!PACKET_peek_net_2(pkt, data))
163         return 0;
164
165     pkt->curr += 2;
166
167     return 1;
168 }
169
170 /* Peek ahead at 3 bytes in network order from |pkt| and store the value in
171  * |*data|
172  */
173 __owur static inline int PACKET_peek_net_3(PACKET *pkt, unsigned long *data)
174 {
175     if (PACKET_remaining(pkt) < 3)
176         return 0;
177
178     *data  = ((unsigned long)(*pkt->curr)) << 16;
179     *data |= ((unsigned long)(*pkt->curr + 1)) <<  8;
180     *data |= *pkt->curr + 2;
181
182     return 1;
183 }
184
185 /* Equivalent of n2l3 */
186 /* Get 3 bytes in network order from |pkt| and store the value in |*data| */
187 __owur static inline int PACKET_get_net_3(PACKET *pkt, unsigned long *data)
188 {
189     if (!PACKET_peek_net_3(pkt, data))
190         return 0;
191
192     pkt->curr += 3;
193
194     return 1;
195 }
196
197 /* Peek ahead at 4 bytes in network order from |pkt| and store the value in
198  * |*data|
199  */
200 __owur static inline int PACKET_peek_net_4(PACKET *pkt, unsigned long *data)
201 {
202     if (PACKET_remaining(pkt) < 4)
203         return 0;
204
205     *data  = ((unsigned long)(*pkt->curr)) << 24;
206     *data |= ((unsigned long)(*pkt->curr + 1)) << 16;
207     *data |= ((unsigned long)(*pkt->curr + 2)) <<  8;
208     *data |= *pkt->curr+3;
209
210     return 1;
211 }
212
213 /* Equivalent of n2l */
214 /* Get 4 bytes in network order from |pkt| and store the value in |*data| */
215 __owur static inline int PACKET_get_net_4(PACKET *pkt, unsigned long *data)
216 {
217     if (!PACKET_peek_net_4(pkt, data))
218         return 0;
219
220     pkt->curr += 4;
221
222     return 1;
223 }
224
225 /* Peek ahead at 1 byte from |pkt| and store the value in |*data| */
226 __owur static inline int PACKET_peek_1(PACKET *pkt, unsigned int *data)
227 {
228     if (!PACKET_remaining(pkt))
229         return 0;
230
231     *data = *pkt->curr;
232
233     return 1;
234 }
235
236 /* Get 1 byte from |pkt| and store the value in |*data| */
237 __owur static inline int PACKET_get_1(PACKET *pkt, unsigned int *data)
238 {
239     if (!PACKET_peek_1(pkt, data))
240         return 0;
241
242     pkt->curr++;
243
244     return 1;
245 }
246
247 /*
248  * Peek ahead at 4 bytes in reverse network order from |pkt| and store the value
249  * in |*data|
250  */
251 __owur static inline int PACKET_peek_4(PACKET *pkt, unsigned long *data)
252 {
253     if (PACKET_remaining(pkt) < 4)
254         return 0;
255
256     *data  = *pkt->curr;
257     *data |= ((unsigned long)(*pkt->curr + 1)) <<  8;
258     *data |= ((unsigned long)(*pkt->curr + 2)) << 16;
259     *data |= ((unsigned long)(*pkt->curr + 3)) << 24;
260
261     return 1;
262 }
263
264 /* Equivalent of c2l */
265 /*
266  * Get 4 bytes in reverse network order from |pkt| and store the value in
267  * |*data|
268  */
269 __owur static inline int PACKET_get_4(PACKET *pkt, unsigned long *data)
270 {
271     if (!PACKET_peek_4(pkt, data))
272         return 0;
273
274     pkt->curr += 4;
275
276     return 1;
277 }
278
279 /*
280  * Peek ahead at |len| bytes from the |pkt| and store a pointer to them in
281  * |*data|. This just points at the underlying buffer that |pkt| is using. The
282  * caller should not free this data directly (it will be freed when the
283  * underlying buffer gets freed
284  */
285 __owur static inline int PACKET_peek_bytes(PACKET *pkt, unsigned char **data,
286                                           size_t len)
287 {
288     if (PACKET_remaining(pkt) < len)
289         return 0;
290
291     *data = pkt->curr;
292
293     return 1;
294 }
295
296 /*
297  * Read |len| bytes from the |pkt| and store a pointer to them in |*data|. This
298  * just points at the underlying buffer that |pkt| is using. The caller should
299  * not free this data directly (it will be freed when the underlying buffer gets
300  * freed
301  */
302 __owur static inline int PACKET_get_bytes(PACKET *pkt, unsigned char **data,
303                                           size_t len)
304 {
305     if (!PACKET_peek_bytes(pkt, data, len))
306         return 0;
307
308     pkt->curr += len;
309
310     return 1;
311 }
312
313 /* Peek ahead at |len| bytes from |pkt| and copy them to |data| */
314 __owur static inline int PACKET_peek_copy_bytes(PACKET *pkt,
315                                                 unsigned char *data, size_t len)
316 {
317     if (PACKET_remaining(pkt) < len)
318         return 0;
319
320     memcpy(data, pkt->curr, len);
321
322     return 1;
323 }
324
325 /* Read |len| bytes from |pkt| and copy them to |data| */
326 __owur static inline int PACKET_copy_bytes(PACKET *pkt, unsigned char *data,
327                                           size_t len)
328 {
329     if (!PACKET_peek_copy_bytes(pkt, data, len))
330         return 0;
331
332     pkt->curr += len;
333
334     return 1;
335 }
336
337 /* Move the current reading position back |len| bytes */
338 __owur static inline int PACKET_back(PACKET *pkt, size_t len)
339 {
340     if (len > (size_t)(pkt->curr - pkt->start))
341         return 0;
342
343     pkt->curr -= len;
344
345     return 1;
346 }
347
348 /* Move the current reading position forward |len| bytes */
349 __owur static inline int PACKET_forward(PACKET *pkt, size_t len)
350 {
351     if (PACKET_remaining(pkt) < len)
352         return 0;
353
354     pkt->curr += len;
355
356     return 1;
357 }
358
359 /* Store a bookmark for the current reading position in |*bm| */
360 __owur static inline int PACKET_get_bookmark(PACKET *pkt, size_t *bm)
361 {
362     *bm = pkt->curr - pkt->start;
363
364     return 1;
365 }
366
367 /* Set the current reading position to the bookmark |bm| */
368 __owur static inline int PACKET_goto_bookmark(PACKET *pkt, size_t bm)
369 {
370     if (bm > (size_t)(pkt->end - pkt->start))
371         return 0;
372
373     pkt->curr = pkt->start + bm;
374
375     return 1;
376 }
377
378 /*
379  * Stores the total length of the packet we have in the underlying buffer in
380  * |*len|
381  */
382 __owur static inline int PACKET_length(PACKET *pkt, size_t *len)
383 {
384     *len = pkt->end - pkt->start;
385
386     return 1;
387 }
388
389 # ifdef __cplusplus
390 }
391 # endif
392
393 #endif /* HEADER_PACKET_LOCL_H */
394