ed61895ee973f4a9f86e938a21104a1fd26957c1
[strongswan.git] / 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 * A variant of strstr with the characteristics of memchr, where haystack is not
341 * a null-terminated string but simply a memory area of length n.
342 */
343 void *memstr(const void *haystack, const char *needle, size_t n);
344
345 /**
346 * Translates the characters in the given string, searching for characters
347 * in 'from' and mapping them to characters in 'to'.
348 * The two characters sets 'from' and 'to' must contain the same number of
349 * characters.
350 */
351 char *translate(char *str, const char *from, const char *to);
352
353 /**
354 * Creates a directory and all required parent directories.
355 *
356 * @param path path to the new directory
357 * @param mode permissions of the new directory/directories
358 * @return TRUE on success
359 */
360 bool mkdir_p(const char *path, mode_t mode);
361
362 /**
363 * Get a timestamp from a monotonic time source.
364 *
365 * While the time()/gettimeofday() functions are affected by leap seconds
366 * and system time changes, this function returns ever increasing monotonic
367 * time stamps.
368 *
369 * @param tv timeval struct receiving monotonic timestamps, or NULL
370 * @return monotonic timestamp in seconds
371 */
372 time_t time_monotonic(timeval_t *tv);
373
374 /**
375 * returns null
376 */
377 void *return_null();
378
379 /**
380 * No-Operation function
381 */
382 void nop();
383
384 /**
385 * returns TRUE
386 */
387 bool return_true();
388
389 /**
390 * returns FALSE
391 */
392 bool return_false();
393
394 /**
395 * returns FAILED
396 */
397 status_t return_failed();
398
399 /**
400 * Write a 16-bit host order value in network order to an unaligned address.
401 *
402 * @param host host order 16-bit value
403 * @param network unaligned address to write network order value to
404 */
405 static inline void htoun16(void *network, u_int16_t host)
406 {
407 char *unaligned = (char*)network;
408
409 host = htons(host);
410 memcpy(unaligned, &host, sizeof(host));
411 }
412
413 /**
414 * Write a 32-bit host order value in network order to an unaligned address.
415 *
416 * @param host host order 32-bit value
417 * @param network unaligned address to write network order value to
418 */
419 static inline void htoun32(void *network, u_int32_t host)
420 {
421 char *unaligned = (char*)network;
422
423 host = htonl(host);
424 memcpy((char*)unaligned, &host, sizeof(host));
425 }
426
427 /**
428 * Read a 16-bit value in network order from an unaligned address to host order.
429 *
430 * @param network unaligned address to read network order value from
431 * @return host order value
432 */
433 static inline u_int16_t untoh16(void *network)
434 {
435 char *unaligned = (char*)network;
436 u_int16_t tmp;
437
438 memcpy(&tmp, unaligned, sizeof(tmp));
439 return ntohs(tmp);
440 }
441
442 /**
443 * Read a 32-bit value in network order from an unaligned address to host order.
444 *
445 * @param network unaligned address to read network order value from
446 * @return host order value
447 */
448 static inline u_int32_t untoh32(void *network)
449 {
450 char *unaligned = (char*)network;
451 u_int32_t tmp;
452
453 memcpy(&tmp, unaligned, sizeof(tmp));
454 return ntohl(tmp);
455 }
456
457 /**
458 * Special type to count references
459 */
460 typedef volatile u_int refcount_t;
461
462
463 #ifdef HAVE_GCC_ATOMIC_OPERATIONS
464
465 #define ref_get(ref) {__sync_fetch_and_add(ref, 1); }
466 #define ref_put(ref) (!__sync_sub_and_fetch(ref, 1))
467
468 #else /* !HAVE_GCC_ATOMIC_OPERATIONS */
469
470 /**
471 * Get a new reference.
472 *
473 * Increments the reference counter atomic.
474 *
475 * @param ref pointer to ref counter
476 */
477 void ref_get(refcount_t *ref);
478
479 /**
480 * Put back a unused reference.
481 *
482 * Decrements the reference counter atomic and
483 * says if more references available.
484 *
485 * @param ref pointer to ref counter
486 * @return TRUE if no more references counted
487 */
488 bool ref_put(refcount_t *ref);
489
490 #endif /* HAVE_GCC_ATOMIC_OPERATIONS */
491
492 /**
493 * printf hook for time_t.
494 *
495 * Arguments are:
496 * time_t* time, bool utc
497 */
498 int time_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
499 const void *const *args);
500
501 /**
502 * printf hook for time_t deltas.
503 *
504 * Arguments are:
505 * time_t* begin, time_t* end
506 */
507 int time_delta_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
508 const void *const *args);
509
510 /**
511 * printf hook for memory areas.
512 *
513 * Arguments are:
514 * u_char *ptr, int len
515 */
516 int mem_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
517 const void *const *args);
518
519 #endif /** UTILS_H_ @}*/