src/libstrongswan/utils.h

   1 /*
   2  * Copyright (C) 2008-2010 Tobias Brunner
   3  * Copyright (C) 2008 Martin Willi
   4  * Hochschule fuer Technik Rapperswil
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2 of the License, or (at your
   9  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * for more details.
  15  */
  16
  17 /**
  18  * @defgroup utils utils
  19  * @{ @ingroup libstrongswan
  20  */
  21
  22 #ifndef UTILS_H_
  23 #define UTILS_H_
  24
  25 #include <sys/types.h>
  26 #include <stdlib.h>
  27 #include <stddef.h>
  28 #include <sys/time.h>
  29 #include <arpa/inet.h>
  30 #include <string.h>
  31
  32 #include "enum.h"
  33
  34 /**
  35  * strongSwan program return codes
  36  */
  37 #define SS_RC_LIBSTRONGSWAN_INTEGRITY   64
  38 #define SS_RC_DAEMON_INTEGRITY                  65
  39 #define SS_RC_INITIALIZATION_FAILED             66
  40
  41 #define SS_RC_FIRST     SS_RC_LIBSTRONGSWAN_INTEGRITY
  42 #define SS_RC_LAST      SS_RC_INITIALIZATION_FAILED
  43
  44 /**
  45  * Number of bits in a byte
  46  */
  47 #define BITS_PER_BYTE 8
  48
  49 /**
  50  * Default length for various auxiliary text buffers
  51  */
  52 #define BUF_LEN 512
  53
  54 /**
  55  * Macro compares two strings for equality
  56  */
  57 #define streq(x,y) (strcmp(x, y) == 0)
  58
  59 /**
  60  * Macro compares two strings for equality, length limited
  61  */
  62 #define strneq(x,y,len) (strncmp(x, y, len) == 0)
  63
  64 /**
  65  * Macro compares two strings for equality ignoring case
  66  */
  67 #define strcaseeq(x,y) (strcasecmp(x, y) == 0)
  68
  69 /**
  70  * Macro compares two strings for equality ignoring case, length limited
  71  */
  72 #define strncaseeq(x,y,len) (strncasecmp(x, y, len) == 0)
  73
  74 /**
  75  * NULL-safe strdup variant
  76  */
  77 #define strdupnull(x) ({ char *_x = x; _x ? strdup(_x) : NULL; })
  78
  79 /**
  80  * Macro compares two binary blobs for equality
  81  */
  82 #define memeq(x,y,len) (memcmp(x, y, len) == 0)
  83
  84 /**
  85  * Macro gives back larger of two values.
  86  */
  87 #define max(x,y) ({ \
  88         typeof(x) _x = (x); \
  89         typeof(y) _y = (y); \
  90         _x > _y ? _x : _y; })
  91
  92
  93 /**
  94  * Macro gives back smaller of two values.
  95  */
  96 #define min(x,y) ({ \
  97         typeof(x) _x = (x); \
  98         typeof(y) _y = (y); \
  99         _x < _y ? _x : _y; })
 100
 101 /**
 102  * Call destructor of an object, if object != NULL
 103  */
 104 #define DESTROY_IF(obj) if (obj) (obj)->destroy(obj)
 105
 106 /**
 107  * Call offset destructor of an object, if object != NULL
 108  */
 109 #define DESTROY_OFFSET_IF(obj, offset) if (obj) obj->destroy_offset(obj, offset);
 110
 111 /**
 112  * Call function destructor of an object, if object != NULL
 113  */
 114 #define DESTROY_FUNCTION_IF(obj, fn) if (obj) obj->destroy_function(obj, fn);
 115
 116 /**
 117  * Debug macro to follow control flow
 118  */
 119 #define POS printf("%s, line %d\n", __FILE__, __LINE__)
 120
 121 /**
 122  * Object allocation/initialization macro, using designated initializer.
 123  */
 124 #define INIT(this, ...) { (this) = malloc(sizeof(*this)); \
 125                                                   *(this) = (typeof(*this)){ __VA_ARGS__ }; }
 126
 127 /**
 128  * Method declaration/definition macro, providing private and public interface.
 129  *
 130  * Defines a method name with this as first parameter and a return value ret,
 131  * and an alias for this method with a _ prefix, having the this argument
 132  * safely casted to the public interface iface.
 133  * _name is provided a function pointer, but will get optimized out by GCC.
 134  */
 135 #define METHOD(iface, name, ret, this, ...) \
 136         static ret name(union {iface *_public; this;} \
 137         __attribute__((transparent_union)), ##__VA_ARGS__); \
 138         static const typeof(name) *_##name = (const typeof(name)*)name; \
 139         static ret name(this, ##__VA_ARGS__)
 140
 141 /**
 142  * Same as METHOD(), but is defined for two public interfaces.
 143  */
 144 #define METHOD2(iface1, iface2, name, ret, this, ...) \
 145         static ret name(union {iface1 *_public1; iface2 *_public2; this;} \
 146         __attribute__((transparent_union)), ##__VA_ARGS__); \
 147         static const typeof(name) *_##name = (const typeof(name)*)name; \
 148         static ret name(this, ##__VA_ARGS__)
 149
 150 /**
 151  * Architecture independent bitfield definition helpers (at least with GCC).
 152  *
 153  * Defines a bitfield with a type t and a fixed size of bitfield members, e.g.:
 154  * BITFIELD2(u_int8_t,
 155  *     low: 4,
 156  *     high: 4,
 157  * ) flags;
 158  * The member defined first placed at bit 0.
 159  */
 160 #if BYTE_ORDER == LITTLE_ENDIAN
 161 #define BITFIELD2(t, a, b,...)                  struct { t a; t b; __VA_ARGS__}
 162 #define BITFIELD3(t, a, b, c,...)               struct { t a; t b; t c; __VA_ARGS__}
 163 #define BITFIELD4(t, a, b, c, d,...)    struct { t a; t b; t c; t d; __VA_ARGS__}
 164 #define BITFIELD5(t, a, b, c, d, e,...) struct { t a; t b; t c; t d; t e; __VA_ARGS__}
 165 #elif BYTE_ORDER == BIG_ENDIAN
 166 #define BITFIELD2(t, a, b,...)                  struct { t b; t a; __VA_ARGS__}
 167 #define BITFIELD3(t, a, b, c,...)               struct { t c; t b; t a; __VA_ARGS__}
 168 #define BITFIELD4(t, a, b, c, d,...)    struct { t d; t c; t b; t a; __VA_ARGS__}
 169 #define BITFIELD5(t, a, b, c, d, e,...) struct { t e; t d; t c; t b; t a; __VA_ARGS__}
 170 #endif
 171
 172 /**
 173  * Macro to allocate a sized type.
 174  */
 175 #define malloc_thing(thing) ((thing*)malloc(sizeof(thing)))
 176
 177 /**
 178  * Get the number of elements in an array
 179  */
 180 #define countof(array) (sizeof(array)/sizeof(array[0]))
 181
 182 /**
 183  * Ignore result of functions tagged with warn_unused_result attributes
 184  */
 185 #define ignore_result(call) { if(call){}; }
 186
 187 /**
 188  * Assign a function as a class method
 189  */
 190 #define ASSIGN(method, function) (method = (typeof(method))function)
 191
 192 /**
 193  * time_t not defined
 194  */
 195 #define UNDEFINED_TIME 0
 196
 197 /**
 198  * Maximum time since epoch causing wrap-around on Jan 19 03:14:07 UTC 2038
 199  */
 200 #define TIME_32_BIT_SIGNED_MAX  0x7fffffff
 201
 202 /**
 203  * General purpose boolean type.
 204  */
 205 #ifdef HAVE_STDBOOL_H
 206 # include <stdbool.h>
 207 #else
 208 # ifndef HAVE__BOOL
 209 #  define _Bool signed char
 210 # endif /* HAVE__BOOL */
 211 # define bool _Bool
 212 # define false 0
 213 # define true 1
 214 # define __bool_true_false_are_defined 1
 215 #endif /* HAVE_STDBOOL_H */
 216 #ifndef FALSE
 217 # define FALSE false
 218 #endif /* FALSE */
 219 #ifndef TRUE
 220 # define TRUE  true
 221 #endif /* TRUE */
 222
 223 /**
 224  * define some missing fixed width int types on OpenSolaris.
 225  * TODO: since the uintXX_t types are defined by the C99 standard we should
 226  * probably use those anyway
 227  */
 228 #ifdef __sun
 229         #include <stdint.h>
 230         typedef uint8_t         u_int8_t;
 231         typedef uint16_t        u_int16_t;
 232         typedef uint32_t        u_int32_t;
 233         typedef uint64_t        u_int64_t;
 234 #endif
 235
 236 typedef enum status_t status_t;
 237
 238 /**
 239  * Return values of function calls.
 240  */
 241 enum status_t {
 242         /**
 243          * Call succeeded.
 244          */
 245         SUCCESS,
 246
 247         /**
 248          * Call failed.
 249          */
 250         FAILED,
 251
 252         /**
 253          * Out of resources.
 254          */
 255         OUT_OF_RES,
 256
 257         /**
 258          * The suggested operation is already done
 259          */
 260         ALREADY_DONE,
 261
 262         /**
 263          * Not supported.
 264          */
 265         NOT_SUPPORTED,
 266
 267         /**
 268          * One of the arguments is invalid.
 269          */
 270         INVALID_ARG,
 271
 272         /**
 273          * Something could not be found.
 274          */
 275         NOT_FOUND,
 276
 277         /**
 278          * Error while parsing.
 279          */
 280         PARSE_ERROR,
 281
 282         /**
 283          * Error while verifying.
 284          */
 285         VERIFY_ERROR,
 286
 287         /**
 288          * Object in invalid state.
 289          */
 290         INVALID_STATE,
 291
 292         /**
 293          * Destroy object which called method belongs to.
 294          */
 295         DESTROY_ME,
 296
 297         /**
 298          * Another call to the method is required.
 299          */
 300         NEED_MORE,
 301 };
 302
 303 /**
 304  * enum_names for type status_t.
 305  */
 306 extern enum_name_t *status_names;
 307
 308 /**
 309  * deprecated pluto style return value:
 310  * error message, NULL for success
 311  */
 312 typedef const char *err_t;
 313
 314 /**
 315  * Handle struct timeval like an own type.
 316  */
 317 typedef struct timeval timeval_t;
 318
 319 /**
 320  * Handle struct timespec like an own type.
 321  */
 322 typedef struct timespec timespec_t;
 323
 324 /**
 325  * Handle struct chunk_t like an own type.
 326  */
 327 typedef struct sockaddr sockaddr_t;
 328
 329 /**
 330  * Clone a data to a newly allocated buffer
 331  */
 332 void *clalloc(void *pointer, size_t size);
 333
 334 /**
 335  * Same as memcpy, but XORs src into dst instead of copy
 336  */
 337 void memxor(u_int8_t dest[], u_int8_t src[], size_t n);
 338
 339 /**
 340  * Safely overwrite n bytes of memory at ptr with zero, non-inlining variant.
 341  */
 342 void memwipe_noinline(void *ptr, size_t n);
 343
 344 /**
 345  * Safely overwrite n bytes of memory at ptr with zero, inlining variant.
 346  */
 347 static inline void memwipe_inline(void *ptr, size_t n)
 348 {
 349         volatile char *c = (volatile char*)ptr;
 350         int m, i;
 351
 352         /* byte wise until long aligned */
 353         for (i = 0; (uintptr_t)&c % sizeof(long) && i < n; i++)
 354         {
 355                 c[i] = 0;
 356         }
 357         /* word wize */
 358         for (m = n - sizeof(long); i <= m; i += sizeof(long))
 359         {
 360                 *(volatile long*)&c[i] = 0;
 361         }
 362         /* byte wise of the rest */
 363         for (; i < n; i++)
 364         {
 365                 c[i] = 0;
 366         }
 367 }
 368
 369 /**
 370  * Safely overwrite n bytes of memory at ptr with zero, auto-inlining variant.
 371  */
 372 static inline void memwipe(void *ptr, size_t n)
 373 {
 374         if (__builtin_constant_p(n))
 375         {
 376                 memwipe_inline(ptr, n);
 377         }
 378         else
 379         {
 380                 memwipe_noinline(ptr, n);
 381         }
 382 }
 383
 384 /**
 385  * A variant of strstr with the characteristics of memchr, where haystack is not
 386  * a null-terminated string but simply a memory area of length n.
 387  */
 388 void *memstr(const void *haystack, const char *needle, size_t n);
 389
 390 /**
 391  * Translates the characters in the given string, searching for characters
 392  * in 'from' and mapping them to characters in 'to'.
 393  * The two characters sets 'from' and 'to' must contain the same number of
 394  * characters.
 395  */
 396 char *translate(char *str, const char *from, const char *to);
 397
 398 /**
 399  * Creates a directory and all required parent directories.
 400  *
 401  * @param path          path to the new directory
 402  * @param mode          permissions of the new directory/directories
 403  * @return                      TRUE on success
 404  */
 405 bool mkdir_p(const char *path, mode_t mode);
 406
 407 /**
 408  * Get a timestamp from a monotonic time source.
 409  *
 410  * While the time()/gettimeofday() functions are affected by leap seconds
 411  * and system time changes, this function returns ever increasing monotonic
 412  * time stamps.
 413  *
 414  * @param tv            timeval struct receiving monotonic timestamps, or NULL
 415  * @return                      monotonic timestamp in seconds
 416  */
 417 time_t time_monotonic(timeval_t *tv);
 418
 419 /**
 420  * returns null
 421  */
 422 void *return_null();
 423
 424 /**
 425  * No-Operation function
 426  */
 427 void nop();
 428
 429 /**
 430  * returns TRUE
 431  */
 432 bool return_true();
 433
 434 /**
 435  * returns FALSE
 436  */
 437 bool return_false();
 438
 439 /**
 440  * returns FAILED
 441  */
 442 status_t return_failed();
 443
 444 /**
 445  * Write a 16-bit host order value in network order to an unaligned address.
 446  *
 447  * @param host          host order 16-bit value
 448  * @param network       unaligned address to write network order value to
 449  */
 450 static inline void htoun16(void *network, u_int16_t host)
 451 {
 452         char *unaligned = (char*)network;
 453
 454         host = htons(host);
 455         memcpy(unaligned, &host, sizeof(host));
 456 }
 457
 458 /**
 459  * Write a 32-bit host order value in network order to an unaligned address.
 460  *
 461  * @param host          host order 32-bit value
 462  * @param network       unaligned address to write network order value to
 463  */
 464 static inline void htoun32(void *network, u_int32_t host)
 465 {
 466         char *unaligned = (char*)network;
 467
 468         host = htonl(host);
 469         memcpy((char*)unaligned, &host, sizeof(host));
 470 }
 471
 472 /**
 473  * Read a 16-bit value in network order from an unaligned address to host order.
 474  *
 475  * @param network       unaligned address to read network order value from
 476  * @return                      host order value
 477  */
 478 static inline u_int16_t untoh16(void *network)
 479 {
 480         char *unaligned = (char*)network;
 481         u_int16_t tmp;
 482
 483         memcpy(&tmp, unaligned, sizeof(tmp));
 484         return ntohs(tmp);
 485 }
 486
 487 /**
 488  * Read a 32-bit value in network order from an unaligned address to host order.
 489  *
 490  * @param network       unaligned address to read network order value from
 491  * @return                      host order value
 492  */
 493 static inline u_int32_t untoh32(void *network)
 494 {
 495         char *unaligned = (char*)network;
 496         u_int32_t tmp;
 497
 498         memcpy(&tmp, unaligned, sizeof(tmp));
 499         return ntohl(tmp);
 500 }
 501
 502 /**
 503  * Special type to count references
 504  */
 505 typedef volatile u_int refcount_t;
 506
 507
 508 #ifdef HAVE_GCC_ATOMIC_OPERATIONS
 509
 510 #define ref_get(ref) {__sync_fetch_and_add(ref, 1); }
 511 #define ref_put(ref) (!__sync_sub_and_fetch(ref, 1))
 512
 513 #else /* !HAVE_GCC_ATOMIC_OPERATIONS */
 514
 515 /**
 516  * Get a new reference.
 517  *
 518  * Increments the reference counter atomic.
 519  *
 520  * @param ref   pointer to ref counter
 521  */
 522 void ref_get(refcount_t *ref);
 523
 524 /**
 525  * Put back a unused reference.
 526  *
 527  * Decrements the reference counter atomic and
 528  * says if more references available.
 529  *
 530  * @param ref   pointer to ref counter
 531  * @return              TRUE if no more references counted
 532  */
 533 bool ref_put(refcount_t *ref);
 534
 535 #endif /* HAVE_GCC_ATOMIC_OPERATIONS */
 536
 537 /**
 538  * printf hook for time_t.
 539  *
 540  * Arguments are:
 541  *      time_t* time, bool utc
 542  */
 543 int time_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
 544                                          const void *const *args);
 545
 546 /**
 547  * printf hook for time_t deltas.
 548  *
 549  * Arguments are:
 550  *      time_t* begin, time_t* end
 551  */
 552 int time_delta_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
 553                                                    const void *const *args);
 554
 555 /**
 556  * printf hook for memory areas.
 557  *
 558  * Arguments are:
 559  *      u_char *ptr, int len
 560  */
 561 int mem_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
 562                                         const void *const *args);
 563
 564 #endif /** UTILS_H_ @}*/