1 /* 2 * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson 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 the author may not be used to endorse or promote products 13 * derived from this software without specific prior written permission. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 #ifndef UTIL_INTERNAL_H_INCLUDED_ 27 #define UTIL_INTERNAL_H_INCLUDED_ 28 29 #include "event2/event-config.h" 30 #include "evconfig-private.h" 31 32 #include <errno.h> 33 34 /* For EVUTIL_ASSERT */ 35 #include "log-internal.h" 36 #include <stdio.h> 37 #include <stdlib.h> 38 #ifdef EVENT__HAVE_SYS_SOCKET_H 39 #include <sys/socket.h> 40 #endif 41 #ifdef EVENT__HAVE_SYS_EVENTFD_H 42 #include <sys/eventfd.h> 43 #endif 44 #include "event2/util.h" 45 46 #include "time-internal.h" 47 #include "ipv6-internal.h" 48 49 #ifdef __cplusplus 50 extern "C" { 51 #endif 52 53 /* If we need magic to say "inline", get it for free internally. */ 54 #ifdef EVENT__inline 55 #define inline EVENT__inline 56 #endif 57 #ifdef EVENT____func__ 58 #define __func__ EVENT____func__ 59 #endif 60 61 /* A good no-op to use in macro definitions. */ 62 #define EVUTIL_NIL_STMT_ ((void)0) 63 /* A no-op that tricks the compiler into thinking a condition is used while 64 * definitely not making any code for it. Used to compile out asserts while 65 * avoiding "unused variable" warnings. The "!" forces the compiler to 66 * do the sizeof() on an int, in case "condition" is a bitfield value. 67 */ 68 #define EVUTIL_NIL_CONDITION_(condition) do { \ 69 (void)sizeof(!(condition)); \ 70 } while(0) 71 72 /* Internal use only: macros to match patterns of error codes in a 73 cross-platform way. We need these macros because of two historical 74 reasons: first, nonblocking IO functions are generally written to give an 75 error on the "blocked now, try later" case, so sometimes an error from a 76 read, write, connect, or accept means "no error; just wait for more 77 data," and we need to look at the error code. Second, Windows defines 78 a different set of error codes for sockets. */ 79 80 #ifndef _WIN32 81 82 #if EAGAIN == EWOULDBLOCK 83 #define EVUTIL_ERR_IS_EAGAIN(e) \ 84 ((e) == EAGAIN) 85 #else 86 #define EVUTIL_ERR_IS_EAGAIN(e) \ 87 ((e) == EAGAIN || (e) == EWOULDBLOCK) 88 #endif 89 90 /* True iff e is an error that means a read/write operation can be retried. */ 91 #define EVUTIL_ERR_RW_RETRIABLE(e) \ 92 ((e) == EINTR || EVUTIL_ERR_IS_EAGAIN(e)) 93 /* True iff e is an error that means an connect can be retried. */ 94 #define EVUTIL_ERR_CONNECT_RETRIABLE(e) \ 95 ((e) == EINTR || (e) == EINPROGRESS) 96 /* True iff e is an error that means a accept can be retried. */ 97 #define EVUTIL_ERR_ACCEPT_RETRIABLE(e) \ 98 ((e) == EINTR || EVUTIL_ERR_IS_EAGAIN(e) || (e) == ECONNABORTED) 99 100 /* True iff e is an error that means the connection was refused */ 101 #define EVUTIL_ERR_CONNECT_REFUSED(e) \ 102 ((e) == ECONNREFUSED) 103 104 #else 105 /* Win32 */ 106 107 #define EVUTIL_ERR_IS_EAGAIN(e) \ 108 ((e) == WSAEWOULDBLOCK || (e) == EAGAIN) 109 110 #define EVUTIL_ERR_RW_RETRIABLE(e) \ 111 ((e) == WSAEWOULDBLOCK || \ 112 (e) == WSAEINTR) 113 114 #define EVUTIL_ERR_CONNECT_RETRIABLE(e) \ 115 ((e) == WSAEWOULDBLOCK || \ 116 (e) == WSAEINTR || \ 117 (e) == WSAEINPROGRESS || \ 118 (e) == WSAEINVAL) 119 120 #define EVUTIL_ERR_ACCEPT_RETRIABLE(e) \ 121 EVUTIL_ERR_RW_RETRIABLE(e) 122 123 #define EVUTIL_ERR_CONNECT_REFUSED(e) \ 124 ((e) == WSAECONNREFUSED) 125 126 #endif 127 128 /* Arguments for shutdown() */ 129 #ifdef SHUT_RD 130 #define EVUTIL_SHUT_RD SHUT_RD 131 #else 132 #define EVUTIL_SHUT_RD 0 133 #endif 134 #ifdef SHUT_WR 135 #define EVUTIL_SHUT_WR SHUT_WR 136 #else 137 #define EVUTIL_SHUT_WR 1 138 #endif 139 #ifdef SHUT_BOTH 140 #define EVUTIL_SHUT_BOTH SHUT_BOTH 141 #else 142 #define EVUTIL_SHUT_BOTH 2 143 #endif 144 145 /* Helper: Verify that all the elements in 'dlist' are internally consistent. 146 * Checks for circular lists and bad prev/next pointers. 147 * 148 * Example usage: 149 * EVUTIL_ASSERT_LIST_OK(eventlist, event, ev_next); 150 */ 151 #define EVUTIL_ASSERT_LIST_OK(dlist, type, field) do { \ 152 struct type *elm1, *elm2, **nextp; \ 153 if (LIST_EMPTY((dlist))) \ 154 break; \ 155 \ 156 /* Check list for circularity using Floyd's */ \ 157 /* 'Tortoise and Hare' algorithm */ \ 158 elm1 = LIST_FIRST((dlist)); \ 159 elm2 = LIST_NEXT(elm1, field); \ 160 while (elm1 && elm2) { \ 161 EVUTIL_ASSERT(elm1 != elm2); \ 162 elm1 = LIST_NEXT(elm1, field); \ 163 elm2 = LIST_NEXT(elm2, field); \ 164 if (!elm2) \ 165 break; \ 166 EVUTIL_ASSERT(elm1 != elm2); \ 167 elm2 = LIST_NEXT(elm2, field); \ 168 } \ 169 \ 170 /* Now check next and prev pointers for consistency. */ \ 171 nextp = &LIST_FIRST((dlist)); \ 172 elm1 = LIST_FIRST((dlist)); \ 173 while (elm1) { \ 174 EVUTIL_ASSERT(*nextp == elm1); \ 175 EVUTIL_ASSERT(nextp == elm1->field.le_prev); \ 176 nextp = &LIST_NEXT(elm1, field); \ 177 elm1 = *nextp; \ 178 } \ 179 } while (0) 180 181 /* Helper: Verify that all the elements in a TAILQ are internally consistent. 182 * Checks for circular lists and bad prev/next pointers. 183 * 184 * Example usage: 185 * EVUTIL_ASSERT_TAILQ_OK(activelist, event, ev_active_next); 186 */ 187 #define EVUTIL_ASSERT_TAILQ_OK(tailq, type, field) do { \ 188 struct type *elm1, *elm2, **nextp; \ 189 if (TAILQ_EMPTY((tailq))) \ 190 break; \ 191 \ 192 /* Check list for circularity using Floyd's */ \ 193 /* 'Tortoise and Hare' algorithm */ \ 194 elm1 = TAILQ_FIRST((tailq)); \ 195 elm2 = TAILQ_NEXT(elm1, field); \ 196 while (elm1 && elm2) { \ 197 EVUTIL_ASSERT(elm1 != elm2); \ 198 elm1 = TAILQ_NEXT(elm1, field); \ 199 elm2 = TAILQ_NEXT(elm2, field); \ 200 if (!elm2) \ 201 break; \ 202 EVUTIL_ASSERT(elm1 != elm2); \ 203 elm2 = TAILQ_NEXT(elm2, field); \ 204 } \ 205 \ 206 /* Now check next and prev pointers for consistency. */ \ 207 nextp = &TAILQ_FIRST((tailq)); \ 208 elm1 = TAILQ_FIRST((tailq)); \ 209 while (elm1) { \ 210 EVUTIL_ASSERT(*nextp == elm1); \ 211 EVUTIL_ASSERT(nextp == elm1->field.tqe_prev); \ 212 nextp = &TAILQ_NEXT(elm1, field); \ 213 elm1 = *nextp; \ 214 } \ 215 EVUTIL_ASSERT(nextp == (tailq)->tqh_last); \ 216 } while (0) 217 218 /* Locale-independent replacements for some ctypes functions. Use these 219 * when you care about ASCII's notion of character types, because you are about 220 * to send those types onto the wire. 221 */ 222 int EVUTIL_ISALPHA_(char c); 223 int EVUTIL_ISALNUM_(char c); 224 int EVUTIL_ISSPACE_(char c); 225 int EVUTIL_ISDIGIT_(char c); 226 int EVUTIL_ISXDIGIT_(char c); 227 int EVUTIL_ISPRINT_(char c); 228 int EVUTIL_ISLOWER_(char c); 229 int EVUTIL_ISUPPER_(char c); 230 char EVUTIL_TOUPPER_(char c); 231 char EVUTIL_TOLOWER_(char c); 232 233 /** Remove all trailing horizontal whitespace (space or tab) from the end of a 234 * string */ 235 void evutil_rtrim_lws_(char *); 236 237 238 /** Helper macro. If we know that a given pointer points to a field in a 239 structure, return a pointer to the structure itself. Used to implement 240 our half-baked C OO. Example: 241 242 struct subtype { 243 int x; 244 struct supertype common; 245 int y; 246 }; 247 ... 248 void fn(struct supertype *super) { 249 struct subtype *sub = EVUTIL_UPCAST(super, struct subtype, common); 250 ... 251 } 252 */ 253 #define EVUTIL_UPCAST(ptr, type, field) \ 254 ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) 255 256 /* As open(pathname, flags, mode), except that the file is always opened with 257 * the close-on-exec flag set. (And the mode argument is mandatory.) 258 */ 259 int evutil_open_closeonexec_(const char *pathname, int flags, unsigned mode); 260 261 int evutil_read_file_(const char *filename, char **content_out, size_t *len_out, 262 int is_binary); 263 264 int evutil_socket_connect_(evutil_socket_t *fd_ptr, struct sockaddr *sa, int socklen); 265 266 int evutil_socket_finished_connecting_(evutil_socket_t fd); 267 268 int evutil_ersatz_socketpair_(int, int , int, evutil_socket_t[]); 269 270 int evutil_resolve_(int family, const char *hostname, struct sockaddr *sa, 271 ev_socklen_t *socklen, int port); 272 273 const char *evutil_getenv_(const char *name); 274 275 /* Structure to hold the state of our weak random number generator. 276 */ 277 struct evutil_weakrand_state { 278 ev_uint32_t seed; 279 }; 280 281 #define EVUTIL_WEAKRAND_MAX EV_INT32_MAX 282 283 /* Initialize the state of a week random number generator based on 'seed'. If 284 * the seed is 0, construct a new seed based on not-very-strong platform 285 * entropy, like the PID and the time of day. 286 * 287 * This function, and the other evutil_weakrand* functions, are meant for 288 * speed, not security or statistical strength. If you need a RNG which an 289 * attacker can't predict, or which passes strong statistical tests, use the 290 * evutil_secure_rng* functions instead. 291 */ 292 ev_uint32_t evutil_weakrand_seed_(struct evutil_weakrand_state *state, ev_uint32_t seed); 293 /* Return a pseudorandom value between 0 and EVUTIL_WEAKRAND_MAX inclusive. 294 * Updates the state in 'seed' as needed -- this value must be protected by a 295 * lock. 296 */ 297 ev_int32_t evutil_weakrand_(struct evutil_weakrand_state *seed); 298 /* Return a pseudorandom value x such that 0 <= x < top. top must be no more 299 * than EVUTIL_WEAKRAND_MAX. Updates the state in 'seed' as needed -- this 300 * value must be proteced by a lock */ 301 ev_int32_t evutil_weakrand_range_(struct evutil_weakrand_state *seed, ev_int32_t top); 302 303 /* Evaluates to the same boolean value as 'p', and hints to the compiler that 304 * we expect this value to be false. */ 305 #if defined(__GNUC__) && __GNUC__ >= 3 /* gcc 3.0 or later */ 306 #define EVUTIL_UNLIKELY(p) __builtin_expect(!!(p),0) 307 #else 308 #define EVUTIL_UNLIKELY(p) (p) 309 #endif 310 311 /* Replacement for assert() that calls event_errx on failure. */ 312 #ifdef NDEBUG 313 #define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) 314 #define EVUTIL_FAILURE_CHECK(cond) 0 315 #else 316 #define EVUTIL_ASSERT(cond) \ 317 do { \ 318 if (EVUTIL_UNLIKELY(!(cond))) { \ 319 event_errx(EVENT_ERR_ABORT_, \ 320 "%s:%d: Assertion %s failed in %s", \ 321 __FILE__,__LINE__,#cond,__func__); \ 322 /* In case a user-supplied handler tries to */ \ 323 /* return control to us, log and abort here. */ \ 324 (void)fprintf(stderr, \ 325 "%s:%d: Assertion %s failed in %s", \ 326 __FILE__,__LINE__,#cond,__func__); \ 327 abort(); \ 328 } \ 329 } while (0) 330 #define EVUTIL_FAILURE_CHECK(cond) EVUTIL_UNLIKELY(cond) 331 #endif 332 333 #ifndef EVENT__HAVE_STRUCT_SOCKADDR_STORAGE 334 /* Replacement for sockaddr storage that we can use internally on platforms 335 * that lack it. It is not space-efficient, but neither is sockaddr_storage. 336 */ 337 struct sockaddr_storage { 338 union { 339 struct sockaddr ss_sa; 340 struct sockaddr_in ss_sin; 341 struct sockaddr_in6 ss_sin6; 342 char ss_padding[128]; 343 } ss_union; 344 }; 345 #define ss_family ss_union.ss_sa.sa_family 346 #endif 347 348 /* Internal addrinfo error code. This one is returned from only from 349 * evutil_getaddrinfo_common_, when we are sure that we'll have to hit a DNS 350 * server. */ 351 #define EVUTIL_EAI_NEED_RESOLVE -90002 352 353 struct evdns_base; 354 struct evdns_getaddrinfo_request; 355 typedef struct evdns_getaddrinfo_request* (*evdns_getaddrinfo_fn)( 356 struct evdns_base *base, 357 const char *nodename, const char *servname, 358 const struct evutil_addrinfo *hints_in, 359 void (*cb)(int, struct evutil_addrinfo *, void *), void *arg); 360 361 void evutil_set_evdns_getaddrinfo_fn_(evdns_getaddrinfo_fn fn); 362 363 struct evutil_addrinfo *evutil_new_addrinfo_(struct sockaddr *sa, 364 ev_socklen_t socklen, const struct evutil_addrinfo *hints); 365 struct evutil_addrinfo *evutil_addrinfo_append_(struct evutil_addrinfo *first, 366 struct evutil_addrinfo *append); 367 void evutil_adjust_hints_for_addrconfig_(struct evutil_addrinfo *hints); 368 int evutil_getaddrinfo_common_(const char *nodename, const char *servname, 369 struct evutil_addrinfo *hints, struct evutil_addrinfo **res, int *portnum); 370 371 int evutil_getaddrinfo_async_(struct evdns_base *dns_base, 372 const char *nodename, const char *servname, 373 const struct evutil_addrinfo *hints_in, 374 void (*cb)(int, struct evutil_addrinfo *, void *), void *arg); 375 376 /** Return true iff sa is a looback address. (That is, it is 127.0.0.1/8, or 377 * ::1). */ 378 int evutil_sockaddr_is_loopback_(const struct sockaddr *sa); 379 380 381 /** 382 Formats a sockaddr sa into a string buffer of size outlen stored in out. 383 Returns a pointer to out. Always writes something into out, so it's safe 384 to use the output of this function without checking it for NULL. 385 */ 386 const char *evutil_format_sockaddr_port_(const struct sockaddr *sa, char *out, size_t outlen); 387 388 int evutil_hex_char_to_int_(char c); 389 390 391 void evutil_free_secure_rng_globals_(void); 392 void evutil_free_globals_(void); 393 394 #ifdef _WIN32 395 HMODULE evutil_load_windows_system_library_(const TCHAR *library_name); 396 #endif 397 398 #ifndef EV_SIZE_FMT 399 #if defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__) 400 #define EV_U64_FMT "%I64u" 401 #define EV_I64_FMT "%I64d" 402 #define EV_I64_ARG(x) ((__int64)(x)) 403 #define EV_U64_ARG(x) ((unsigned __int64)(x)) 404 #else 405 #define EV_U64_FMT "%llu" 406 #define EV_I64_FMT "%lld" 407 #define EV_I64_ARG(x) ((long long)(x)) 408 #define EV_U64_ARG(x) ((unsigned long long)(x)) 409 #endif 410 #endif 411 412 #ifdef _WIN32 413 #define EV_SOCK_FMT EV_I64_FMT 414 #define EV_SOCK_ARG(x) EV_I64_ARG((x)) 415 #else 416 #define EV_SOCK_FMT "%d" 417 #define EV_SOCK_ARG(x) (x) 418 #endif 419 420 #if defined(__STDC__) && defined(__STDC_VERSION__) 421 #if (__STDC_VERSION__ >= 199901L) 422 #define EV_SIZE_FMT "%zu" 423 #define EV_SSIZE_FMT "%zd" 424 #define EV_SIZE_ARG(x) (x) 425 #define EV_SSIZE_ARG(x) (x) 426 #endif 427 #endif 428 429 #ifndef EV_SIZE_FMT 430 #if (EVENT__SIZEOF_SIZE_T <= EVENT__SIZEOF_LONG) 431 #define EV_SIZE_FMT "%lu" 432 #define EV_SSIZE_FMT "%ld" 433 #define EV_SIZE_ARG(x) ((unsigned long)(x)) 434 #define EV_SSIZE_ARG(x) ((long)(x)) 435 #else 436 #define EV_SIZE_FMT EV_U64_FMT 437 #define EV_SSIZE_FMT EV_I64_FMT 438 #define EV_SIZE_ARG(x) EV_U64_ARG(x) 439 #define EV_SSIZE_ARG(x) EV_I64_ARG(x) 440 #endif 441 #endif 442 443 evutil_socket_t evutil_socket_(int domain, int type, int protocol); 444 evutil_socket_t evutil_accept4_(evutil_socket_t sockfd, struct sockaddr *addr, 445 ev_socklen_t *addrlen, int flags); 446 447 /* used by one of the test programs.. */ 448 EVENT2_EXPORT_SYMBOL 449 int evutil_make_internal_pipe_(evutil_socket_t fd[2]); 450 evutil_socket_t evutil_eventfd_(unsigned initval, int flags); 451 452 #ifdef SOCK_NONBLOCK 453 #define EVUTIL_SOCK_NONBLOCK SOCK_NONBLOCK 454 #else 455 #define EVUTIL_SOCK_NONBLOCK 0x4000000 456 #endif 457 #ifdef SOCK_CLOEXEC 458 #define EVUTIL_SOCK_CLOEXEC SOCK_CLOEXEC 459 #else 460 #define EVUTIL_SOCK_CLOEXEC 0x80000000 461 #endif 462 #ifdef EFD_NONBLOCK 463 #define EVUTIL_EFD_NONBLOCK EFD_NONBLOCK 464 #else 465 #define EVUTIL_EFD_NONBLOCK 0x4000 466 #endif 467 #ifdef EFD_CLOEXEC 468 #define EVUTIL_EFD_CLOEXEC EFD_CLOEXEC 469 #else 470 #define EVUTIL_EFD_CLOEXEC 0x8000 471 #endif 472 473 void evutil_memclear_(void *mem, size_t len); 474 475 #ifdef __cplusplus 476 } 477 #endif 478 479 #endif 480