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