e5e4a10c0d974744259c55ffec9298b5e7669c29
[strongswan.git] / src / libstrongswan / utils.h
1 /*
2 * Copyright (C) 2008-2011 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 (this); })
127
128 /**
129 * Method declaration/definition macro, providing private and public interface.
130 *
131 * Defines a method name with this as first parameter and a return value ret,
132 * and an alias for this method with a _ prefix, having the this argument
133 * safely casted to the public interface iface.
134 * _name is provided a function pointer, but will get optimized out by GCC.
135 */
136 #define METHOD(iface, name, ret, this, ...) \
137 static ret name(union {iface *_public; this;} \
138 __attribute__((transparent_union)), ##__VA_ARGS__); \
139 static const typeof(name) *_##name = (const typeof(name)*)name; \
140 static ret name(this, ##__VA_ARGS__)
141
142 /**
143 * Same as METHOD(), but is defined for two public interfaces.
144 */
145 #define METHOD2(iface1, iface2, name, ret, this, ...) \
146 static ret name(union {iface1 *_public1; iface2 *_public2; this;} \
147 __attribute__((transparent_union)), ##__VA_ARGS__); \
148 static const typeof(name) *_##name = (const typeof(name)*)name; \
149 static ret name(this, ##__VA_ARGS__)
150
151 /**
152 * Architecture independent bitfield definition helpers (at least with GCC).
153 *
154 * Defines a bitfield with a type t and a fixed size of bitfield members, e.g.:
155 * BITFIELD2(u_int8_t,
156 * low: 4,
157 * high: 4,
158 * ) flags;
159 * The member defined first placed at bit 0.
160 */
161 #if BYTE_ORDER == LITTLE_ENDIAN
162 #define BITFIELD2(t, a, b,...) struct { t a; t b; __VA_ARGS__}
163 #define BITFIELD3(t, a, b, c,...) struct { t a; t b; t c; __VA_ARGS__}
164 #define BITFIELD4(t, a, b, c, d,...) struct { t a; t b; t c; t d; __VA_ARGS__}
165 #define BITFIELD5(t, a, b, c, d, e,...) struct { t a; t b; t c; t d; t e; __VA_ARGS__}
166 #elif BYTE_ORDER == BIG_ENDIAN
167 #define BITFIELD2(t, a, b,...) struct { t b; t a; __VA_ARGS__}
168 #define BITFIELD3(t, a, b, c,...) struct { t c; t b; t a; __VA_ARGS__}
169 #define BITFIELD4(t, a, b, c, d,...) struct { t d; t c; t b; t a; __VA_ARGS__}
170 #define BITFIELD5(t, a, b, c, d, e,...) struct { t e; t d; t c; t b; t a; __VA_ARGS__}
171 #endif
172
173 /**
174 * Macro to allocate a sized type.
175 */
176 #define malloc_thing(thing) ((thing*)malloc(sizeof(thing)))
177
178 /**
179 * Get the number of elements in an array
180 */
181 #define countof(array) (sizeof(array)/sizeof(array[0]))
182
183 /**
184 * Ignore result of functions tagged with warn_unused_result attributes
185 */
186 #define ignore_result(call) { if(call){}; }
187
188 /**
189 * Assign a function as a class method
190 */
191 #define ASSIGN(method, function) (method = (typeof(method))function)
192
193 /**
194 * time_t not defined
195 */
196 #define UNDEFINED_TIME 0
197
198 /**
199 * Maximum time since epoch causing wrap-around on Jan 19 03:14:07 UTC 2038
200 */
201 #define TIME_32_BIT_SIGNED_MAX 0x7fffffff
202
203 /**
204 * General purpose boolean type.
205 */
206 #ifdef HAVE_STDBOOL_H
207 # include <stdbool.h>
208 #else
209 # ifndef HAVE__BOOL
210 # define _Bool signed char
211 # endif /* HAVE__BOOL */
212 # define bool _Bool
213 # define false 0
214 # define true 1
215 # define __bool_true_false_are_defined 1
216 #endif /* HAVE_STDBOOL_H */
217 #ifndef FALSE
218 # define FALSE false
219 #endif /* FALSE */
220 #ifndef TRUE
221 # define TRUE true
222 #endif /* TRUE */
223
224 /**
225 * define some missing fixed width int types on OpenSolaris.
226 * TODO: since the uintXX_t types are defined by the C99 standard we should
227 * probably use those anyway
228 */
229 #ifdef __sun
230 #include <stdint.h>
231 typedef uint8_t u_int8_t;
232 typedef uint16_t u_int16_t;
233 typedef uint32_t u_int32_t;
234 typedef uint64_t u_int64_t;
235 #endif
236
237 typedef enum status_t status_t;
238
239 /**
240 * Return values of function calls.
241 */
242 enum status_t {
243 /**
244 * Call succeeded.
245 */
246 SUCCESS,
247
248 /**
249 * Call failed.
250 */
251 FAILED,
252
253 /**
254 * Out of resources.
255 */
256 OUT_OF_RES,
257
258 /**
259 * The suggested operation is already done
260 */
261 ALREADY_DONE,
262
263 /**
264 * Not supported.
265 */
266 NOT_SUPPORTED,
267
268 /**
269 * One of the arguments is invalid.
270 */
271 INVALID_ARG,
272
273 /**
274 * Something could not be found.
275 */
276 NOT_FOUND,
277
278 /**
279 * Error while parsing.
280 */
281 PARSE_ERROR,
282
283 /**
284 * Error while verifying.
285 */
286 VERIFY_ERROR,
287
288 /**
289 * Object in invalid state.
290 */
291 INVALID_STATE,
292
293 /**
294 * Destroy object which called method belongs to.
295 */
296 DESTROY_ME,
297
298 /**
299 * Another call to the method is required.
300 */
301 NEED_MORE,
302 };
303
304 /**
305 * enum_names for type status_t.
306 */
307 extern enum_name_t *status_names;
308
309 /**
310 * deprecated pluto style return value:
311 * error message, NULL for success
312 */
313 typedef const char *err_t;
314
315 /**
316 * Handle struct timeval like an own type.
317 */
318 typedef struct timeval timeval_t;
319
320 /**
321 * Handle struct timespec like an own type.
322 */
323 typedef struct timespec timespec_t;
324
325 /**
326 * Handle struct chunk_t like an own type.
327 */
328 typedef struct sockaddr sockaddr_t;
329
330 /**
331 * Clone a data to a newly allocated buffer
332 */
333 void *clalloc(void *pointer, size_t size);
334
335 /**
336 * Same as memcpy, but XORs src into dst instead of copy
337 */
338 void memxor(u_int8_t dest[], u_int8_t src[], size_t n);
339
340 /**
341 * Safely overwrite n bytes of memory at ptr with zero, non-inlining variant.
342 */
343 void memwipe_noinline(void *ptr, size_t n);
344
345 /**
346 * Safely overwrite n bytes of memory at ptr with zero, inlining variant.
347 */
348 static inline void memwipe_inline(void *ptr, size_t n)
349 {
350 volatile char *c = (volatile char*)ptr;
351 size_t m, i;
352
353 /* byte wise until long aligned */
354 for (i = 0; (uintptr_t)&c[i] % sizeof(long) && i < n; i++)
355 {
356 c[i] = 0;
357 }
358 /* word wise */
359 if (n >= sizeof(long))
360 {
361 for (m = n - sizeof(long); i <= m; i += sizeof(long))
362 {
363 *(volatile long*)&c[i] = 0;
364 }
365 }
366 /* byte wise of the rest */
367 for (; i < n; i++)
368 {
369 c[i] = 0;
370 }
371 }
372
373 /**
374 * Safely overwrite n bytes of memory at ptr with zero, auto-inlining variant.
375 */
376 static inline void memwipe(void *ptr, size_t n)
377 {
378 if (__builtin_constant_p(n))
379 {
380 memwipe_inline(ptr, n);
381 }
382 else
383 {
384 memwipe_noinline(ptr, n);
385 }
386 }
387
388 /**
389 * A variant of strstr with the characteristics of memchr, where haystack is not
390 * a null-terminated string but simply a memory area of length n.
391 */
392 void *memstr(const void *haystack, const char *needle, size_t n);
393
394 /**
395 * Translates the characters in the given string, searching for characters
396 * in 'from' and mapping them to characters in 'to'.
397 * The two characters sets 'from' and 'to' must contain the same number of
398 * characters.
399 */
400 char *translate(char *str, const char *from, const char *to);
401
402 /**
403 * Creates a directory and all required parent directories.
404 *
405 * @param path path to the new directory
406 * @param mode permissions of the new directory/directories
407 * @return TRUE on success
408 */
409 bool mkdir_p(const char *path, mode_t mode);
410
411 #ifndef HAVE_CLOSEFROM
412 /**
413 * Close open file descriptors greater than or equal to lowfd.
414 *
415 * @param lowfd start closing file descriptoros from here
416 */
417 void closefrom(int lowfd);
418 #endif
419
420 /**
421 * Get a timestamp from a monotonic time source.
422 *
423 * While the time()/gettimeofday() functions are affected by leap seconds
424 * and system time changes, this function returns ever increasing monotonic
425 * time stamps.
426 *
427 * @param tv timeval struct receiving monotonic timestamps, or NULL
428 * @return monotonic timestamp in seconds
429 */
430 time_t time_monotonic(timeval_t *tv);
431
432 /**
433 * returns null
434 */
435 void *return_null();
436
437 /**
438 * No-Operation function
439 */
440 void nop();
441
442 /**
443 * returns TRUE
444 */
445 bool return_true();
446
447 /**
448 * returns FALSE
449 */
450 bool return_false();
451
452 /**
453 * returns FAILED
454 */
455 status_t return_failed();
456
457 /**
458 * Write a 16-bit host order value in network order to an unaligned address.
459 *
460 * @param host host order 16-bit value
461 * @param network unaligned address to write network order value to
462 */
463 static inline void htoun16(void *network, u_int16_t host)
464 {
465 char *unaligned = (char*)network;
466
467 host = htons(host);
468 memcpy(unaligned, &host, sizeof(host));
469 }
470
471 /**
472 * Write a 32-bit host order value in network order to an unaligned address.
473 *
474 * @param host host order 32-bit value
475 * @param network unaligned address to write network order value to
476 */
477 static inline void htoun32(void *network, u_int32_t host)
478 {
479 char *unaligned = (char*)network;
480
481 host = htonl(host);
482 memcpy((char*)unaligned, &host, sizeof(host));
483 }
484
485 /**
486 * Write a 64-bit host order value in network order to an unaligned address.
487 *
488 * @param host host order 64-bit value
489 * @param network unaligned address to write network order value to
490 */
491 static inline void htoun64(void *network, u_int64_t host)
492 {
493 char *unaligned = (char*)network;
494
495 #ifdef be64toh
496 host = htobe64(host);
497 memcpy((char*)unaligned, &host, sizeof(host));
498 #else
499 u_int32_t high_part, low_part;
500
501 high_part = host >> 32;
502 high_part = htonl(high_part);
503 low_part = host & 0xFFFFFFFFLL;
504 low_part = htonl(low_part);
505
506 memcpy(unaligned, &high_part, sizeof(high_part));
507 unaligned += sizeof(high_part);
508 memcpy(unaligned, &low_part, sizeof(low_part));
509 #endif
510 }
511
512 /**
513 * Read a 16-bit value in network order from an unaligned address to host order.
514 *
515 * @param network unaligned address to read network order value from
516 * @return host order value
517 */
518 static inline u_int16_t untoh16(void *network)
519 {
520 char *unaligned = (char*)network;
521 u_int16_t tmp;
522
523 memcpy(&tmp, unaligned, sizeof(tmp));
524 return ntohs(tmp);
525 }
526
527 /**
528 * Read a 32-bit value in network order from an unaligned address to host order.
529 *
530 * @param network unaligned address to read network order value from
531 * @return host order value
532 */
533 static inline u_int32_t untoh32(void *network)
534 {
535 char *unaligned = (char*)network;
536 u_int32_t tmp;
537
538 memcpy(&tmp, unaligned, sizeof(tmp));
539 return ntohl(tmp);
540 }
541
542 /**
543 * Read a 64-bit value in network order from an unaligned address to host order.
544 *
545 * @param network unaligned address to read network order value from
546 * @return host order value
547 */
548 static inline u_int64_t untoh64(void *network)
549 {
550 char *unaligned = (char*)network;
551
552 #ifdef be64toh
553 u_int64_t tmp;
554
555 memcpy(&tmp, unaligned, sizeof(tmp));
556 return be64toh(tmp);
557 #else
558 u_int32_t high_part, low_part;
559
560 memcpy(&high_part, unaligned, sizeof(high_part));
561 unaligned += sizeof(high_part);
562 memcpy(&low_part, unaligned, sizeof(low_part));
563
564 high_part = ntohl(high_part);
565 low_part = ntohl(low_part);
566
567 return (((u_int64_t)high_part) << 32) + low_part;
568 #endif
569 }
570
571 /**
572 * Special type to count references
573 */
574 typedef volatile u_int refcount_t;
575
576
577 #ifdef HAVE_GCC_ATOMIC_OPERATIONS
578
579 #define ref_get(ref) {__sync_fetch_and_add(ref, 1); }
580 #define ref_put(ref) (!__sync_sub_and_fetch(ref, 1))
581
582 #else /* !HAVE_GCC_ATOMIC_OPERATIONS */
583
584 /**
585 * Get a new reference.
586 *
587 * Increments the reference counter atomic.
588 *
589 * @param ref pointer to ref counter
590 */
591 void ref_get(refcount_t *ref);
592
593 /**
594 * Put back a unused reference.
595 *
596 * Decrements the reference counter atomic and
597 * says if more references available.
598 *
599 * @param ref pointer to ref counter
600 * @return TRUE if no more references counted
601 */
602 bool ref_put(refcount_t *ref);
603
604 #endif /* HAVE_GCC_ATOMIC_OPERATIONS */
605
606 /**
607 * printf hook for time_t.
608 *
609 * Arguments are:
610 * time_t* time, bool utc
611 */
612 int time_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
613 const void *const *args);
614
615 /**
616 * printf hook for time_t deltas.
617 *
618 * Arguments are:
619 * time_t* begin, time_t* end
620 */
621 int time_delta_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
622 const void *const *args);
623
624 /**
625 * printf hook for memory areas.
626 *
627 * Arguments are:
628 * u_char *ptr, int len
629 */
630 int mem_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
631 const void *const *args);
632
633 #endif /** UTILS_H_ @}*/