Enhance PACKET readability
[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 the number of bytes remaining to be read in the PACKET
84  */
85 __owur static inline size_t PACKET_remaining(PACKET *pkt)
86 {
87     return (size_t)(pkt->end - pkt->curr);
88 }
89
90 /*
91  * Initialise a PACKET with |len| bytes held in |buf|. This does not make a
92  * copy of the data so |buf| must be present for the whole time that the PACKET
93  * is being used.
94  */
95 static inline int PACKET_buf_init(PACKET *pkt, unsigned char *buf, size_t len)
96 {
97     pkt->start = pkt->curr = buf;
98     pkt->end = pkt->start + len;
99
100     /* Sanity checks */
101     if (pkt->start > pkt->end
102             || pkt->curr < pkt->start
103             || pkt->curr > pkt->end
104             || len != (size_t)(pkt->end - pkt->start)) {
105         return 0;
106     }
107
108     return 1;
109 }
110
111 /*
112  * Peek ahead and initialize |subpkt| with the next |len| bytes read from |pkt|.
113  * Data is not copied: the |subpkt| packet will share its underlying buffer with
114  * the original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|.
115  */
116 __owur static inline int PACKET_peek_sub_packet(PACKET *pkt, PACKET *subpkt,
117                                                size_t len)
118 {
119     if (PACKET_remaining(pkt) < len)
120         return 0;
121
122     PACKET_buf_init(subpkt, pkt->curr, len);
123
124     return 1;
125 }
126
127 /*
128  * Initialize |subpkt| with the next |len| bytes read from |pkt|. Data is not
129  * copied: the |subpkt| packet will share its underlying buffer with the
130  * original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|.
131  */
132 __owur static inline int PACKET_get_sub_packet(PACKET *pkt, PACKET *subpkt,
133                                                size_t len)
134 {
135     if (!PACKET_peek_sub_packet(pkt, subpkt, len))
136         return 0;
137
138     pkt->curr += len;
139
140     return 1;
141 }
142
143 /* Peek ahead at 2 bytes in network order from |pkt| and store the value in
144  * |*data|
145  */
146 __owur static inline int PACKET_peek_net_2(PACKET *pkt, unsigned int *data)
147 {
148     if (PACKET_remaining(pkt) < 2)
149         return 0;
150
151     *data  = ((unsigned int)(*pkt->curr)) <<  8;
152     *data |= *(pkt->curr + 1);
153
154     return 1;
155 }
156
157 /* Equivalent of n2s */
158 /* Get 2 bytes in network order from |pkt| and store the value in |*data| */
159 __owur static inline int PACKET_get_net_2(PACKET *pkt, unsigned int *data)
160 {
161     if (!PACKET_peek_net_2(pkt, data))
162         return 0;
163
164     pkt->curr += 2;
165
166     return 1;
167 }
168
169 /* Peek ahead at 3 bytes in network order from |pkt| and store the value in
170  * |*data|
171  */
172 __owur static inline int PACKET_peek_net_3(PACKET *pkt, unsigned long *data)
173 {
174     if (PACKET_remaining(pkt) < 3)
175         return 0;
176
177     *data  = ((unsigned long)(*pkt->curr)) << 16;
178     *data |= ((unsigned long)(*(pkt->curr + 1))) <<  8;
179     *data |= *(pkt->curr + 2);
180
181     return 1;
182 }
183
184 /* Equivalent of n2l3 */
185 /* Get 3 bytes in network order from |pkt| and store the value in |*data| */
186 __owur static inline int PACKET_get_net_3(PACKET *pkt, unsigned long *data)
187 {
188     if (!PACKET_peek_net_3(pkt, data))
189         return 0;
190
191     pkt->curr += 3;
192
193     return 1;
194 }
195
196 /* Peek ahead at 4 bytes in network order from |pkt| and store the value in
197  * |*data|
198  */
199 __owur static inline int PACKET_peek_net_4(PACKET *pkt, unsigned long *data)
200 {
201     if (PACKET_remaining(pkt) < 4)
202         return 0;
203
204     *data  = ((unsigned long)(*pkt->curr)) << 24;
205     *data |= ((unsigned long)(*(pkt->curr + 1))) << 16;
206     *data |= ((unsigned long)(*(pkt->curr + 2))) <<  8;
207     *data |= *(pkt->curr+3);
208
209     return 1;
210 }
211
212 /* Equivalent of n2l */
213 /* Get 4 bytes in network order from |pkt| and store the value in |*data| */
214 __owur static inline int PACKET_get_net_4(PACKET *pkt, unsigned long *data)
215 {
216     if (!PACKET_peek_net_4(pkt, data))
217         return 0;
218
219     pkt->curr += 4;
220
221     return 1;
222 }
223
224 /* Peek ahead at 1 byte from |pkt| and store the value in |*data| */
225 __owur static inline int PACKET_peek_1(PACKET *pkt, unsigned int *data)
226 {
227     if (!PACKET_remaining(pkt))
228         return 0;
229
230     *data = *pkt->curr;
231
232     return 1;
233 }
234
235 /* Get 1 byte from |pkt| and store the value in |*data| */
236 __owur static inline int PACKET_get_1(PACKET *pkt, unsigned int *data)
237 {
238     if (!PACKET_peek_1(pkt, data))
239         return 0;
240
241     pkt->curr++;
242
243     return 1;
244 }
245
246 /*
247  * Peek ahead at 4 bytes in reverse network order from |pkt| and store the value
248  * in |*data|
249  */
250 __owur static inline int PACKET_peek_4(PACKET *pkt, unsigned long *data)
251 {
252     if (PACKET_remaining(pkt) < 4)
253         return 0;
254
255     *data  = *pkt->curr;
256     *data |= ((unsigned long)(*(pkt->curr + 1))) <<  8;
257     *data |= ((unsigned long)(*(pkt->curr + 2))) << 16;
258     *data |= ((unsigned long)(*(pkt->curr + 3))) << 24;
259
260     return 1;
261 }
262
263 /* Equivalent of c2l */
264 /*
265  * Get 4 bytes in reverse network order from |pkt| and store the value in
266  * |*data|
267  */
268 __owur static inline int PACKET_get_4(PACKET *pkt, unsigned long *data)
269 {
270     if (!PACKET_peek_4(pkt, data))
271         return 0;
272
273     pkt->curr += 4;
274
275     return 1;
276 }
277
278 /*
279  * Peek ahead at |len| bytes from the |pkt| and store a pointer to them in
280  * |*data|. This just points at the underlying buffer that |pkt| is using. The
281  * caller should not free this data directly (it will be freed when the
282  * underlying buffer gets freed
283  */
284 __owur static inline int PACKET_peek_bytes(PACKET *pkt, unsigned char **data,
285                                           size_t len)
286 {
287     if (PACKET_remaining(pkt) < len)
288         return 0;
289
290     *data = pkt->curr;
291
292     return 1;
293 }
294
295 /*
296  * Read |len| bytes from the |pkt| and store a pointer to them in |*data|. This
297  * just points at the underlying buffer that |pkt| is using. The caller should
298  * not free this data directly (it will be freed when the underlying buffer gets
299  * freed
300  */
301 __owur static inline int PACKET_get_bytes(PACKET *pkt, unsigned char **data,
302                                           size_t len)
303 {
304     if (!PACKET_peek_bytes(pkt, data, len))
305         return 0;
306
307     pkt->curr += len;
308
309     return 1;
310 }
311
312 /* Peek ahead at |len| bytes from |pkt| and copy them to |data| */
313 __owur static inline int PACKET_peek_copy_bytes(PACKET *pkt,
314                                                 unsigned char *data, size_t len)
315 {
316     if (PACKET_remaining(pkt) < len)
317         return 0;
318
319     memcpy(data, pkt->curr, len);
320
321     return 1;
322 }
323
324 /* Read |len| bytes from |pkt| and copy them to |data| */
325 __owur static inline int PACKET_copy_bytes(PACKET *pkt, unsigned char *data,
326                                           size_t len)
327 {
328     if (!PACKET_peek_copy_bytes(pkt, data, len))
329         return 0;
330
331     pkt->curr += len;
332
333     return 1;
334 }
335
336 /* Move the current reading position back |len| bytes */
337 __owur static inline int PACKET_back(PACKET *pkt, size_t len)
338 {
339     if (len > (size_t)(pkt->curr - pkt->start))
340         return 0;
341
342     pkt->curr -= len;
343
344     return 1;
345 }
346
347 /* Move the current reading position forward |len| bytes */
348 __owur static inline int PACKET_forward(PACKET *pkt, size_t len)
349 {
350     if (PACKET_remaining(pkt) < len)
351         return 0;
352
353     pkt->curr += len;
354
355     return 1;
356 }
357
358 /* Store a bookmark for the current reading position in |*bm| */
359 __owur static inline int PACKET_get_bookmark(PACKET *pkt, size_t *bm)
360 {
361     *bm = pkt->curr - pkt->start;
362
363     return 1;
364 }
365
366 /* Set the current reading position to the bookmark |bm| */
367 __owur static inline int PACKET_goto_bookmark(PACKET *pkt, size_t bm)
368 {
369     if (bm > (size_t)(pkt->end - pkt->start))
370         return 0;
371
372     pkt->curr = pkt->start + bm;
373
374     return 1;
375 }
376
377 /*
378  * Stores the total length of the packet we have in the underlying buffer in
379  * |*len|
380  */
381 __owur static inline int PACKET_length(PACKET *pkt, size_t *len)
382 {
383     *len = pkt->end - pkt->start;
384
385     return 1;
386 }
387
388 # ifdef __cplusplus
389 }
390 # endif
391
392 #endif /* HEADER_PACKET_LOCL_H */
393