Home | History | Annotate | Download | only in tcpdump
      1 /*-
      2  * Copyright (c) 2003, 2004 David Young.  All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions
      6  * are met:
      7  * 1. Redistributions of source code must retain the above copyright
      8  *    notice, this list of conditions and the following disclaimer.
      9  * 2. Redistributions in binary form must reproduce the above copyright
     10  *    notice, this list of conditions and the following disclaimer in the
     11  *    documentation and/or other materials provided with the distribution.
     12  * 3. The name of David Young may not be used to endorse or promote
     13  *    products derived from this software without specific prior
     14  *    written permission.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY DAVID YOUNG ``AS IS'' AND ANY
     17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
     18  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
     19  * PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL DAVID
     20  * YOUNG BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     21  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
     22  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
     24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
     25  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
     27  * OF SUCH DAMAGE.
     28  */
     29 
     30 #ifdef HAVE_CONFIG_H
     31 #include "config.h"
     32 #endif
     33 
     34 #include <stdlib.h>
     35 #include <string.h>
     36 #include <tcpdump-stdinc.h>
     37 
     38 #include "cpack.h"
     39 #include "extract.h"
     40 
     41 u_int8_t *
     42 cpack_next_boundary(u_int8_t *buf, u_int8_t *p, size_t alignment)
     43 {
     44 	size_t misalignment = (size_t)(p - buf) % alignment;
     45 
     46 	if (misalignment == 0)
     47 		return p;
     48 
     49 	return p + (alignment - misalignment);
     50 }
     51 
     52 /* Advance to the next wordsize boundary. Return NULL if fewer than
     53  * wordsize bytes remain in the buffer after the boundary.  Otherwise,
     54  * return a pointer to the boundary.
     55  */
     56 u_int8_t *
     57 cpack_align_and_reserve(struct cpack_state *cs, size_t wordsize)
     58 {
     59 	u_int8_t *next;
     60 
     61 	/* Ensure alignment. */
     62 	next = cpack_next_boundary(cs->c_buf, cs->c_next, wordsize);
     63 
     64 	/* Too little space for wordsize bytes? */
     65 	if (next - cs->c_buf + wordsize > cs->c_len)
     66 		return NULL;
     67 
     68 	return next;
     69 }
     70 
     71 /* Advance by N bytes without returning them. */
     72 int
     73 cpack_advance(struct cpack_state *cs, const size_t toskip)
     74 {
     75 	/* No space left? */
     76 	if (cs->c_next - cs->c_buf + toskip > cs->c_len)
     77 		return -1;
     78 	cs->c_next += toskip;
     79 	return 0;
     80 }
     81 
     82 int
     83 cpack_init(struct cpack_state *cs, u_int8_t *buf, size_t buflen)
     84 {
     85 	memset(cs, 0, sizeof(*cs));
     86 
     87 	cs->c_buf = buf;
     88 	cs->c_len = buflen;
     89 	cs->c_next = cs->c_buf;
     90 
     91 	return 0;
     92 }
     93 
     94 /* Unpack a 64-bit unsigned integer. */
     95 int
     96 cpack_uint64(struct cpack_state *cs, u_int64_t *u)
     97 {
     98 	u_int8_t *next;
     99 
    100 	if ((next = cpack_align_and_reserve(cs, sizeof(*u))) == NULL)
    101 		return -1;
    102 
    103 	*u = EXTRACT_LE_64BITS(next);
    104 
    105 	/* Move pointer past the u_int64_t. */
    106 	cs->c_next = next + sizeof(*u);
    107 	return 0;
    108 }
    109 
    110 /* Unpack a 32-bit unsigned integer. */
    111 int
    112 cpack_uint32(struct cpack_state *cs, u_int32_t *u)
    113 {
    114 	u_int8_t *next;
    115 
    116 	if ((next = cpack_align_and_reserve(cs, sizeof(*u))) == NULL)
    117 		return -1;
    118 
    119 	*u = EXTRACT_LE_32BITS(next);
    120 
    121 	/* Move pointer past the u_int32_t. */
    122 	cs->c_next = next + sizeof(*u);
    123 	return 0;
    124 }
    125 
    126 /* Unpack a 16-bit unsigned integer. */
    127 int
    128 cpack_uint16(struct cpack_state *cs, u_int16_t *u)
    129 {
    130 	u_int8_t *next;
    131 
    132 	if ((next = cpack_align_and_reserve(cs, sizeof(*u))) == NULL)
    133 		return -1;
    134 
    135 	*u = EXTRACT_LE_16BITS(next);
    136 
    137 	/* Move pointer past the u_int16_t. */
    138 	cs->c_next = next + sizeof(*u);
    139 	return 0;
    140 }
    141 
    142 /* Unpack an 8-bit unsigned integer. */
    143 int
    144 cpack_uint8(struct cpack_state *cs, u_int8_t *u)
    145 {
    146 	/* No space left? */
    147 	if ((size_t)(cs->c_next - cs->c_buf) >= cs->c_len)
    148 		return -1;
    149 
    150 	*u = *cs->c_next;
    151 
    152 	/* Move pointer past the u_int8_t. */
    153 	cs->c_next++;
    154 	return 0;
    155 }
    156