trunnel-impl.h (10511B)
1 /* trunnel-impl.h -- copied from Trunnel v1.5.3 2 * https://gitweb.torproject.org/trunnel.git 3 * You probably shouldn't edit this file. 4 */ 5 /* trunnel-impl.h -- Implementation helpers for trunnel, included by 6 * generated trunnel files 7 * 8 * Copyright 2014-2019, The Tor Project, Inc. 9 * See license at the end of this file for copying information. 10 */ 11 12 #ifndef TRUNNEL_IMPL_H_INCLUDED_ 13 #define TRUNNEL_IMPL_H_INCLUDED_ 14 #ifdef TRUNNEL_LOCAL_H 15 #include "trunnel-local.h" 16 #endif 17 #include "trunnel.h" 18 #include <assert.h> 19 #include <string.h> 20 #include <stdlib.h> 21 22 #if defined(_MSC_VER) && (_MSC_VER < 1600) 23 #define uint8_t unsigned char 24 #define uint16_t unsigned short 25 #define uint32_t unsigned int 26 #define uint64_t unsigned __int64 27 #define inline __inline 28 #else 29 #include <stdint.h> 30 #endif 31 32 #ifdef _WIN32 33 uint32_t trunnel_htonl(uint32_t a); 34 uint32_t trunnel_ntohl(uint32_t a); 35 uint16_t trunnel_htons(uint16_t a); 36 uint16_t trunnel_ntohs(uint16_t a); 37 #else 38 #include <arpa/inet.h> 39 #define trunnel_htonl(x) htonl(x) 40 #define trunnel_htons(x) htons(x) 41 #define trunnel_ntohl(x) ntohl(x) 42 #define trunnel_ntohs(x) ntohs(x) 43 #endif 44 uint64_t trunnel_htonll(uint64_t a); 45 uint64_t trunnel_ntohll(uint64_t a); 46 47 #ifndef trunnel_assert 48 #define trunnel_assert(x) assert(x) 49 #endif 50 51 static inline void 52 trunnel_set_uint64(void *p, uint64_t v) { 53 memcpy(p, &v, 8); 54 } 55 static inline void 56 trunnel_set_uint32(void *p, uint32_t v) { 57 memcpy(p, &v, 4); 58 } 59 static inline void 60 trunnel_set_uint16(void *p, uint16_t v) { 61 memcpy(p, &v, 2); 62 } 63 static inline void 64 trunnel_set_uint8(void *p, uint8_t v) { 65 memcpy(p, &v, 1); 66 } 67 68 static inline uint64_t 69 trunnel_get_uint64(const void *p) { 70 uint64_t x; 71 memcpy(&x, p, 8); 72 return x; 73 } 74 static inline uint32_t 75 trunnel_get_uint32(const void *p) { 76 uint32_t x; 77 memcpy(&x, p, 4); 78 return x; 79 } 80 static inline uint16_t 81 trunnel_get_uint16(const void *p) { 82 uint16_t x; 83 memcpy(&x, p, 2); 84 return x; 85 } 86 static inline uint8_t 87 trunnel_get_uint8(const void *p) { 88 return *(const uint8_t*)p; 89 } 90 91 92 #ifdef TRUNNEL_DEBUG_FAILING_ALLOC 93 extern int trunnel_provoke_alloc_failure; 94 95 static inline void * 96 trunnel_malloc(size_t n) 97 { 98 if (trunnel_provoke_alloc_failure) { 99 if (--trunnel_provoke_alloc_failure == 0) 100 return NULL; 101 } 102 return malloc(n); 103 } 104 static inline void * 105 trunnel_calloc(size_t a, size_t b) 106 { 107 if (trunnel_provoke_alloc_failure) { 108 if (--trunnel_provoke_alloc_failure == 0) 109 return NULL; 110 } 111 return calloc(a,b); 112 } 113 static inline char * 114 trunnel_strdup(const char *s) 115 { 116 if (trunnel_provoke_alloc_failure) { 117 if (--trunnel_provoke_alloc_failure == 0) 118 return NULL; 119 } 120 return strdup(s); 121 } 122 #else 123 #ifndef trunnel_malloc 124 #define trunnel_malloc(x) (malloc((x))) 125 #endif 126 #ifndef trunnel_calloc 127 #define trunnel_calloc(a,b) (calloc((a),(b))) 128 #endif 129 #ifndef trunnel_strdup 130 #define trunnel_strdup(s) (strdup((s))) 131 #endif 132 #endif 133 134 #ifndef trunnel_realloc 135 #define trunnel_realloc(a,b) realloc((a),(b)) 136 #endif 137 138 #ifndef trunnel_free_ 139 #define trunnel_free_(x) (free(x)) 140 #endif 141 #define trunnel_free(x) ((x) ? (trunnel_free_(x),0) : (0)) 142 143 #ifndef trunnel_abort 144 #define trunnel_abort() abort() 145 #endif 146 147 #ifndef trunnel_memwipe 148 #define trunnel_memwipe(mem, len) ((void)0) 149 #define trunnel_wipestr(s) ((void)0) 150 #else 151 #define trunnel_wipestr(s) do { \ 152 if (s) \ 153 trunnel_memwipe(s, strlen(s)); \ 154 } while (0) 155 #endif 156 157 /* ====== dynamic arrays ======== */ 158 159 #ifdef NDEBUG 160 #define TRUNNEL_DYNARRAY_GET(da, n) \ 161 ((da)->elts_[(n)]) 162 #else 163 /** Return the 'n'th element of 'da'. */ 164 #define TRUNNEL_DYNARRAY_GET(da, n) \ 165 (((n) >= (da)->n_ ? (trunnel_abort(),0) : 0), (da)->elts_[(n)]) 166 #endif 167 168 /** Change the 'n'th element of 'da' to 'v'. */ 169 #define TRUNNEL_DYNARRAY_SET(da, n, v) do { \ 170 trunnel_assert((n) < (da)->n_); \ 171 (da)->elts_[(n)] = (v); \ 172 } while (0) 173 174 /** Expand the dynamic array 'da' of 'elttype' so that it can hold at least 175 * 'howmanymore' elements than its current capacity. Always tries to increase 176 * the length of the array. On failure, run the code in 'on_fail' and goto 177 * trunnel_alloc_failed. */ 178 #define TRUNNEL_DYNARRAY_EXPAND(elttype, da, howmanymore, on_fail) do { \ 179 elttype *newarray; \ 180 newarray = trunnel_dynarray_expand(&(da)->allocated_, \ 181 (da)->elts_, (howmanymore), \ 182 sizeof(elttype)); \ 183 if (newarray == NULL) { \ 184 on_fail; \ 185 goto trunnel_alloc_failed; \ 186 } \ 187 (da)->elts_ = newarray; \ 188 } while (0) 189 190 /** Add 'v' to the end of the dynamic array 'da' of 'elttype', expanding it if 191 * necessary. code in 'on_fail' and goto trunnel_alloc_failed. */ 192 #define TRUNNEL_DYNARRAY_ADD(elttype, da, v, on_fail) do { \ 193 if ((da)->n_ == (da)->allocated_) { \ 194 TRUNNEL_DYNARRAY_EXPAND(elttype, da, 1, on_fail); \ 195 } \ 196 (da)->elts_[(da)->n_++] = (v); \ 197 } while (0) 198 199 /** Return the number of elements in 'da'. */ 200 #define TRUNNEL_DYNARRAY_LEN(da) ((da)->n_) 201 202 /** Remove all storage held by 'da' and set it to be empty. Does not free 203 * storage held by the elements themselves. */ 204 #define TRUNNEL_DYNARRAY_CLEAR(da) do { \ 205 trunnel_free((da)->elts_); \ 206 (da)->elts_ = NULL; \ 207 (da)->n_ = (da)->allocated_ = 0; \ 208 } while (0) 209 210 /** Remove all storage held by 'da' and set it to be empty. Does not free 211 * storage held by the elements themselves. */ 212 #define TRUNNEL_DYNARRAY_WIPE(da) do { \ 213 trunnel_memwipe((da)->elts_, (da)->allocated_ * sizeof((da)->elts_[0])); \ 214 } while (0) 215 216 /** Helper: wraps or implements an OpenBSD-style reallocarray. Behaves 217 * as realloc(a, x*y), but verifies that no overflow will occur in the 218 * multiplication. Returns NULL on failure. */ 219 #ifndef trunnel_reallocarray 220 void *trunnel_reallocarray(void *a, size_t x, size_t y); 221 #endif 222 223 /** Helper to expand a dynamic array. Behaves as TRUNNEL_DYNARRAY_EXPAND(), 224 * taking the array of elements in 'ptr', a pointer to thethe current number 225 * of allocated elements in allocated_p, the minimum numbeer of elements to 226 * add in 'howmanymore', and the size of a single element in 'eltsize'. 227 * 228 * On success, adjust *allocated_p, and return the new value for the array of 229 * elements. On failure, adjust nothing and return NULL. 230 */ 231 void *trunnel_dynarray_expand(size_t *allocated_p, void *ptr, 232 size_t howmanymore, size_t eltsize); 233 234 /** Type for a function to free members of a dynarray of pointers. */ 235 typedef void (*trunnel_free_fn_t)(void *); 236 237 /** 238 * Helper to change the length of a dynamic array. Takes pointers to the 239 * current allocated and n fields of the array in 'allocated_p' and 'len_p', 240 * and the current array of elements in 'ptr'; takes the length of a single 241 * element in 'eltsize'. Changes the length to 'newlen'. If 'newlen' is 242 * greater than the current length, pads the new elements with 0. If newlen 243 * is less than the current length, and free_fn is non-NULL, treat the 244 * array as an array of void *, and invoke free_fn() on each removed element. 245 * 246 * On success, adjust *allocated_p and *len_p, and return the new value for 247 * the array of elements. On failure, adjust nothing, set *errcode_ptr to 1, 248 * and return NULL. 249 */ 250 void *trunnel_dynarray_setlen(size_t *allocated_p, size_t *len_p, 251 void *ptr, size_t newlen, 252 size_t eltsize, trunnel_free_fn_t free_fn, 253 uint8_t *errcode_ptr); 254 255 /** 256 * Helper: return a pointer to the value of 'str' as a NUL-terminated string. 257 * Might have to reallocate the storage for 'str' in order to fit in the final 258 * NUL character. On allocation failure, return NULL. 259 */ 260 const char *trunnel_string_getstr(trunnel_string_t *str); 261 262 /** 263 * Helper: change the contents of 'str' to hold the 'len'-byte string in 264 * 'inp'. Adjusts the storage to have a terminating NUL that doesn't count 265 * towards the length of the string. On success, return 0. On failure, set 266 * *errcode_ptr to 1 and return -1. 267 */ 268 int trunnel_string_setstr0(trunnel_string_t *str, const char *inp, size_t len, 269 uint8_t *errcode_ptr); 270 271 /** 272 * As trunnel_dynarray_setlen, but adjusts a string rather than a dynamic 273 * array, and ensures that the new string is NUL-terminated. 274 */ 275 int trunnel_string_setlen(trunnel_string_t *str, size_t newlen, 276 uint8_t *errcode_ptr); 277 278 #endif 279 280 281 /* 282 Copyright 2014 The Tor Project, Inc. 283 284 Redistribution and use in source and binary forms, with or without 285 modification, are permitted provided that the following conditions are 286 met: 287 288 * Redistributions of source code must retain the above copyright 289 notice, this list of conditions and the following disclaimer. 290 291 * Redistributions in binary form must reproduce the above 292 copyright notice, this list of conditions and the following disclaimer 293 in the documentation and/or other materials provided with the 294 distribution. 295 296 * Neither the names of the copyright owners nor the names of its 297 contributors may be used to endorse or promote products derived from 298 this software without specific prior written permission. 299 300 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 301 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 302 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 303 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 304 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 305 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 306 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 307 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 308 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 309 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 310 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 311 */