2 * Copyright (C) 2008-2014 Tobias Brunner
3 * Copyright (C) 2008 Martin Willi
4 * Hochschule fuer Technik Rapperswil
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>.
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
18 * @defgroup utils_i utils
25 #include <sys/types.h>
35 # include <arpa/inet.h>
36 # include <sys/socket.h>
38 # include <netinet/in.h>
43 * strongSwan program return codes
45 #define SS_RC_LIBSTRONGSWAN_INTEGRITY 64
46 #define SS_RC_DAEMON_INTEGRITY 65
47 #define SS_RC_INITIALIZATION_FAILED 66
49 #define SS_RC_FIRST SS_RC_LIBSTRONGSWAN_INTEGRITY
50 #define SS_RC_LAST SS_RC_INITIALIZATION_FAILED
53 * Number of bits in a byte
55 #define BITS_PER_BYTE 8
58 * Default length for various auxiliary text buffers
63 * General purpose boolean type.
69 # define _Bool signed char
70 # endif /* HAVE__BOOL */
74 # define __bool_true_false_are_defined 1
75 #endif /* HAVE_STDBOOL_H */
84 #include "utils/strerror.h"
87 * Directory separator character in paths on this platform
90 # define DIRECTORY_SEPARATOR "\\"
92 # define DIRECTORY_SEPARATOR "/"
96 * Initialize utility functions
101 * Deinitialize utility functions
106 * Helper function that compares two strings for equality
108 static inline bool streq(const char *x
, const char *y
)
110 return strcmp(x
, y
) == 0;
114 * Helper function that compares two strings for equality, length limited
116 static inline bool strneq(const char *x
, const char *y
, size_t len
)
118 return strncmp(x
, y
, len
) == 0;
122 * Helper function that checks if a string starts with a given prefix
124 static inline bool strpfx(const char *x
, const char *prefix
)
126 return strneq(x
, prefix
, strlen(prefix
));
130 * Helper function that compares two strings for equality ignoring case
132 static inline bool strcaseeq(const char *x
, const char *y
)
134 return strcasecmp(x
, y
) == 0;
138 * Helper function that compares two strings for equality ignoring case, length limited
140 static inline bool strncaseeq(const char *x
, const char *y
, size_t len
)
142 return strncasecmp(x
, y
, len
) == 0;
146 * Helper function that checks if a string starts with a given prefix
148 static inline bool strcasepfx(const char *x
, const char *prefix
)
150 return strncaseeq(x
, prefix
, strlen(prefix
));
154 * NULL-safe strdup variant
156 static inline char *strdupnull(const char *s
)
158 return s
? strdup(s
) : NULL
;
162 * Helper function that compares two binary blobs for equality
164 static inline bool memeq(const void *x
, const void *y
, size_t len
)
166 return memcmp(x
, y
, len
) == 0;
170 * Calling memcpy() with NULL pointers, even with n == 0, results in undefined
171 * behavior according to the C standard. This version is guaranteed to not
172 * access the pointers if n is 0.
174 static inline void *memcpy_noop(void *dst
, const void *src
, size_t n
)
176 return n
? memcpy(dst
, src
, n
) : dst
;
178 #define memcpy(d,s,n) memcpy_noop(d,s,n)
181 * Calling memmove() with NULL pointers, even with n == 0, results in undefined
182 * behavior according to the C standard. This version is guaranteed to not
183 * access the pointers if n is 0.
185 static inline void *memmove_noop(void *dst
, const void *src
, size_t n
)
187 return n
? memmove(dst
, src
, n
) : dst
;
189 #define memmove(d,s,n) memmove_noop(d,s,n)
192 * Calling memset() with a NULL pointer, even with n == 0, results in undefined
193 * behavior according to the C standard. This version is guaranteed to not
194 * access the pointer if n is 0.
196 static inline void *memset_noop(void *s
, int c
, size_t n
)
198 return n
? memset(s
, c
, n
) : s
;
200 #define memset(s,c,n) memset_noop(s,c,n)
203 * Macro gives back larger of two values.
205 #define max(x,y) ({ \
206 typeof(x) _x = (x); \
207 typeof(y) _y = (y); \
208 _x > _y ? _x : _y; })
211 * Macro gives back smaller of two values.
213 #define min(x,y) ({ \
214 typeof(x) _x = (x); \
215 typeof(y) _y = (y); \
216 _x < _y ? _x : _y; })
219 * Call destructor of an object, if object != NULL
221 #define DESTROY_IF(obj) if (obj) (obj)->destroy(obj)
224 * Call offset destructor of an object, if object != NULL
226 #define DESTROY_OFFSET_IF(obj, offset) if (obj) obj->destroy_offset(obj, offset);
229 * Call function destructor of an object, if object != NULL
231 #define DESTROY_FUNCTION_IF(obj, fn) if (obj) obj->destroy_function(obj, fn);
234 * Debug macro to follow control flow
236 #define POS printf("%s, line %d\n", __FILE__, __LINE__)
239 * Object allocation/initialization macro, using designated initializer.
241 #define INIT(this, ...) { (this) = malloc(sizeof(*(this))); \
242 *(this) = (typeof(*(this))){ __VA_ARGS__ }; }
245 * Method declaration/definition macro, providing private and public interface.
247 * Defines a method name with this as first parameter and a return value ret,
248 * and an alias for this method with a _ prefix, having the this argument
249 * safely casted to the public interface iface.
250 * _name is provided a function pointer, but will get optimized out by GCC.
252 #define METHOD(iface, name, ret, this, ...) \
253 static ret name(union {iface *_public; this;} \
254 __attribute__((transparent_union)), ##__VA_ARGS__); \
255 static typeof(name) *_##name = (typeof(name)*)name; \
256 static ret name(this, ##__VA_ARGS__)
259 * Same as METHOD(), but is defined for two public interfaces.
261 #define METHOD2(iface1, iface2, name, ret, this, ...) \
262 static ret name(union {iface1 *_public1; iface2 *_public2; this;} \
263 __attribute__((transparent_union)), ##__VA_ARGS__); \
264 static typeof(name) *_##name = (typeof(name)*)name; \
265 static ret name(this, ##__VA_ARGS__)
268 * Callback declaration/definition macro, allowing casted first parameter.
270 * This is very similar to METHOD, but instead of casting the first parameter
271 * to a public interface, it uses a void*. This allows type safe definition
272 * of a callback function, while using the real type for the first parameter.
274 #define CALLBACK(name, ret, param1, ...) \
275 static ret _cb_##name(union {void *_generic; param1;} \
276 __attribute__((transparent_union)), ##__VA_ARGS__); \
277 static typeof(_cb_##name) *name = (typeof(_cb_##name)*)_cb_##name; \
278 static ret _cb_##name(param1, ##__VA_ARGS__)
281 * This macro allows counting the number of arguments passed to a macro.
282 * Combined with the VA_ARGS_DISPATCH() macro this can be used to implement
283 * macro overloading based on the number of arguments.
284 * 0 to 10 arguments are currently supported.
286 #define VA_ARGS_NUM(...) _VA_ARGS_NUM(0,##__VA_ARGS__,10,9,8,7,6,5,4,3,2,1,0)
287 #define _VA_ARGS_NUM(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,NUM,...) NUM
290 * This macro can be used to dispatch a macro call based on the number of given
291 * arguments, for instance:
294 * #define MY_MACRO(...) VA_ARGS_DISPATCH(MY_MACRO, __VA_ARGS__)(__VA_ARGS__)
295 * #define MY_MACRO1(arg) one_arg(arg)
296 * #define MY_MACRO2(arg1,arg2) two_args(arg1,arg2)
299 * MY_MACRO() can now be called with either one or two arguments, which will
300 * resolve to one_arg(arg) or two_args(arg1,arg2), respectively.
302 #define VA_ARGS_DISPATCH(func, ...) _VA_ARGS_DISPATCH(func, VA_ARGS_NUM(__VA_ARGS__))
303 #define _VA_ARGS_DISPATCH(func, num) __VA_ARGS_DISPATCH(func, num)
304 #define __VA_ARGS_DISPATCH(func, num) func ## num
307 * Architecture independent bitfield definition helpers (at least with GCC).
309 * Defines a bitfield with a type t and a fixed size of bitfield members, e.g.:
310 * BITFIELD2(u_int8_t,
314 * The member defined first placed at bit 0.
316 #if BYTE_ORDER == LITTLE_ENDIAN
317 #define BITFIELD2(t, a, b,...) struct { t a; t b; __VA_ARGS__}
318 #define BITFIELD3(t, a, b, c,...) struct { t a; t b; t c; __VA_ARGS__}
319 #define BITFIELD4(t, a, b, c, d,...) struct { t a; t b; t c; t d; __VA_ARGS__}
320 #define BITFIELD5(t, a, b, c, d, e,...) struct { t a; t b; t c; t d; t e; __VA_ARGS__}
321 #elif BYTE_ORDER == BIG_ENDIAN
322 #define BITFIELD2(t, a, b,...) struct { t b; t a; __VA_ARGS__}
323 #define BITFIELD3(t, a, b, c,...) struct { t c; t b; t a; __VA_ARGS__}
324 #define BITFIELD4(t, a, b, c, d,...) struct { t d; t c; t b; t a; __VA_ARGS__}
325 #define BITFIELD5(t, a, b, c, d, e,...) struct { t e; t d; t c; t b; t a; __VA_ARGS__}
329 * Macro to allocate a sized type.
331 #define malloc_thing(thing) ((thing*)malloc(sizeof(thing)))
334 * Get the number of elements in an array
336 #define countof(array) (sizeof(array)/sizeof(array[0]))
339 * Ignore result of functions tagged with warn_unused_result attributes
341 #define ignore_result(call) { if(call){}; }
344 * Assign a function as a class method
346 #define ASSIGN(method, function) (method = (typeof(method))function)
351 #define UNDEFINED_TIME 0
354 * Maximum time since epoch causing wrap-around on Jan 19 03:14:07 UTC 2038
356 #define TIME_32_BIT_SIGNED_MAX 0x7fffffff
359 * define some missing fixed width int types on OpenSolaris.
360 * TODO: since the uintXX_t types are defined by the C99 standard we should
361 * probably use those anyway
363 #if defined __sun || defined WIN32
365 typedef uint8_t u_int8_t
;
366 typedef uint16_t u_int16_t
;
367 typedef uint32_t u_int32_t
;
368 typedef uint64_t u_int64_t
;
371 typedef enum status_t status_t
;
374 * Return values of function calls.
393 * The suggested operation is already done
403 * One of the arguments is invalid.
408 * Something could not be found.
413 * Error while parsing.
418 * Error while verifying.
423 * Object in invalid state.
428 * Destroy object which called method belongs to.
433 * Another call to the method is required.
439 * enum_names for type status_t.
441 extern enum_name_t
*status_names
;
443 typedef enum tty_escape_t tty_escape_t
;
446 * Excape codes for tty colors
449 /** text properties */
455 /** foreground colors */
466 /** background colors */
479 * Get the escape string for a given TTY color, empty string on non-tty fd
481 char* tty_escape_get(int fd
, tty_escape_t escape
);
484 * deprecated pluto style return value:
485 * error message, NULL for success
487 typedef const char *err_t
;
490 * Handle struct timeval like an own type.
492 typedef struct timeval timeval_t
;
495 * Handle struct timespec like an own type.
497 typedef struct timespec timespec_t
;
500 * Handle struct chunk_t like an own type.
502 typedef struct sockaddr sockaddr_t
;
505 * Same as memcpy, but XORs src into dst instead of copy
507 void memxor(u_int8_t dest
[], u_int8_t src
[], size_t n
);
510 * Safely overwrite n bytes of memory at ptr with zero, non-inlining variant.
512 void memwipe_noinline(void *ptr
, size_t n
);
515 * Safely overwrite n bytes of memory at ptr with zero, inlining variant.
517 static inline void memwipe_inline(void *ptr
, size_t n
)
519 volatile char *c
= (volatile char*)ptr
;
522 /* byte wise until long aligned */
523 for (i
= 0; (uintptr_t)&c
[i
] % sizeof(long) && i
< n
; i
++)
528 if (n
>= sizeof(long))
530 for (m
= n
- sizeof(long); i
<= m
; i
+= sizeof(long))
532 *(volatile long*)&c
[i
] = 0;
535 /* byte wise of the rest */
543 * Safely overwrite n bytes of memory at ptr with zero, auto-inlining variant.
545 static inline void memwipe(void *ptr
, size_t n
)
551 if (__builtin_constant_p(n
))
553 memwipe_inline(ptr
, n
);
557 memwipe_noinline(ptr
, n
);
562 * A variant of strstr with the characteristics of memchr, where haystack is not
563 * a null-terminated string but simply a memory area of length n.
565 void *memstr(const void *haystack
, const char *needle
, size_t n
);
568 * Replacement for memrchr(3) if it is not provided by the C library.
570 * @param s start of the memory area to search
571 * @param c character to search
572 * @param n length of memory area to search
573 * @return pointer to the found character or NULL
575 void *utils_memrchr(const void *s
, int c
, size_t n
);
578 #define memrchr(s,c,n) utils_memrchr(s,c,n)
582 * Translates the characters in the given string, searching for characters
583 * in 'from' and mapping them to characters in 'to'.
584 * The two characters sets 'from' and 'to' must contain the same number of
587 char *translate(char *str
, const char *from
, const char *to
);
590 * Replaces all occurrences of search in the given string with replace.
592 * Allocates memory only if anything is replaced in the string. The original
593 * string is also returned if any of the arguments are invalid (e.g. if search
594 * is empty or any of them are NULL).
596 * @param str original string
597 * @param search string to search for and replace
598 * @param replace string to replace found occurrences with
599 * @return allocated string, if anything got replaced, str otherwise
601 char *strreplace(const char *str
, const char *search
, const char *replace
);
604 * Portable function to wait for SIGINT/SIGTERM (or equivalent).
609 * Like dirname(3) returns the directory part of the given null-terminated
610 * pathname, up to but not including the final '/' (or '.' if no '/' is found).
611 * Trailing '/' are not counted as part of the pathname.
613 * The difference is that it does this in a thread-safe manner (i.e. it does not
614 * use static buffers) and does not modify the original path.
616 * @param path original pathname
617 * @return allocated directory component
619 char *path_dirname(const char *path
);
622 * Like basename(3) returns the filename part of the given null-terminated path,
623 * i.e. the part following the final '/' (or '.' if path is empty or NULL).
624 * Trailing '/' are not counted as part of the pathname.
626 * The difference is that it does this in a thread-safe manner (i.e. it does not
627 * use static buffers) and does not modify the original path.
629 * @param path original pathname
630 * @return allocated filename component
632 char *path_basename(const char *path
);
635 * Check if a given path is absolute.
637 * @param path path to check
638 * @return TRUE if absolute, FALSE if relative
640 bool path_absolute(const char *path
);
643 * Creates a directory and all required parent directories.
645 * @param path path to the new directory
646 * @param mode permissions of the new directory/directories
647 * @return TRUE on success
649 bool mkdir_p(const char *path
, mode_t mode
);
651 #ifndef HAVE_CLOSEFROM
653 * Close open file descriptors greater than or equal to lowfd.
655 * @param lowfd start closing file descriptors from here
657 void closefrom(int lowfd
);
661 * Get a timestamp from a monotonic time source.
663 * While the time()/gettimeofday() functions are affected by leap seconds
664 * and system time changes, this function returns ever increasing monotonic
667 * @param tv timeval struct receiving monotonic timestamps, or NULL
668 * @return monotonic timestamp in seconds
670 time_t time_monotonic(timeval_t
*tv
);
673 * Add the given number of milliseconds to the given timeval struct
675 * @param tv timeval struct to modify
676 * @param ms number of milliseconds
678 static inline void timeval_add_ms(timeval_t
*tv
, u_int ms
)
680 tv
->tv_usec
+= ms
* 1000;
681 while (tv
->tv_usec
>= 1000000 /* 1s */)
683 tv
->tv_usec
-= 1000000;
694 * No-Operation function
711 status_t
return_failed();
716 status_t
return_success();
719 * Write a 16-bit host order value in network order to an unaligned address.
721 * @param host host order 16-bit value
722 * @param network unaligned address to write network order value to
724 static inline void htoun16(void *network
, u_int16_t host
)
726 char *unaligned
= (char*)network
;
729 memcpy(unaligned
, &host
, sizeof(host
));
733 * Write a 32-bit host order value in network order to an unaligned address.
735 * @param host host order 32-bit value
736 * @param network unaligned address to write network order value to
738 static inline void htoun32(void *network
, u_int32_t host
)
740 char *unaligned
= (char*)network
;
743 memcpy((char*)unaligned
, &host
, sizeof(host
));
747 * Write a 64-bit host order value in network order to an unaligned address.
749 * @param host host order 64-bit value
750 * @param network unaligned address to write network order value to
752 static inline void htoun64(void *network
, u_int64_t host
)
754 char *unaligned
= (char*)network
;
757 host
= htobe64(host
);
758 memcpy((char*)unaligned
, &host
, sizeof(host
));
760 u_int32_t high_part
, low_part
;
762 high_part
= host
>> 32;
763 high_part
= htonl(high_part
);
764 low_part
= host
& 0xFFFFFFFFLL
;
765 low_part
= htonl(low_part
);
767 memcpy(unaligned
, &high_part
, sizeof(high_part
));
768 unaligned
+= sizeof(high_part
);
769 memcpy(unaligned
, &low_part
, sizeof(low_part
));
774 * Read a 16-bit value in network order from an unaligned address to host order.
776 * @param network unaligned address to read network order value from
777 * @return host order value
779 static inline u_int16_t
untoh16(void *network
)
781 char *unaligned
= (char*)network
;
784 memcpy(&tmp
, unaligned
, sizeof(tmp
));
789 * Read a 32-bit value in network order from an unaligned address to host order.
791 * @param network unaligned address to read network order value from
792 * @return host order value
794 static inline u_int32_t
untoh32(void *network
)
796 char *unaligned
= (char*)network
;
799 memcpy(&tmp
, unaligned
, sizeof(tmp
));
804 * Read a 64-bit value in network order from an unaligned address to host order.
806 * @param network unaligned address to read network order value from
807 * @return host order value
809 static inline u_int64_t
untoh64(void *network
)
811 char *unaligned
= (char*)network
;
816 memcpy(&tmp
, unaligned
, sizeof(tmp
));
819 u_int32_t high_part
, low_part
;
821 memcpy(&high_part
, unaligned
, sizeof(high_part
));
822 unaligned
+= sizeof(high_part
);
823 memcpy(&low_part
, unaligned
, sizeof(low_part
));
825 high_part
= ntohl(high_part
);
826 low_part
= ntohl(low_part
);
828 return (((u_int64_t
)high_part
) << 32) + low_part
;
833 * Get the padding required to make size a multiple of alignment
835 static inline size_t pad_len(size_t size
, size_t alignment
)
839 remainder
= size
% alignment
;
840 return remainder
? alignment
- remainder
: 0;
844 * Round up size to be multiple of alignment
846 static inline size_t round_up(size_t size
, size_t alignment
)
848 return size
+ pad_len(size
, alignment
);
852 * Round down size to be a multiple of alignment
854 static inline size_t round_down(size_t size
, size_t alignment
)
856 return size
- (size
% alignment
);
860 * Special type to count references
862 typedef u_int refcount_t
;
864 /* use __atomic* built-ins with GCC 4.7 and newer */
866 # if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6))
867 # define HAVE_GCC_ATOMIC_OPERATIONS
871 #ifdef HAVE_GCC_ATOMIC_OPERATIONS
873 #define ref_get(ref) __atomic_add_fetch(ref, 1, __ATOMIC_RELAXED)
874 /* The relaxed memory model works fine for increments as these (usually) don't
875 * change the state of refcounted objects. But here we have to ensure that we
876 * free the right stuff if ref counted objects are mutable. So we have to sync
877 * with other threads that call ref_put(). It would be sufficient to use
878 * __ATOMIC_RELEASE here and then call __atomic_thread_fence() with
879 * __ATOMIC_ACQUIRE if we reach 0, but since we don't have control over the use
880 * of ref_put() we have to make sure. */
881 #define ref_put(ref) (!__atomic_sub_fetch(ref, 1, __ATOMIC_ACQ_REL))
882 #define ref_cur(ref) __atomic_load_n(ref, __ATOMIC_RELAXED)
884 #define _cas_impl(ptr, oldval, newval) ({ typeof(oldval) _old = oldval; \
885 __atomic_compare_exchange_n(ptr, &_old, newval, FALSE, \
886 __ATOMIC_SEQ_CST, __ATOMIC_RELAXED); })
887 #define cas_bool(ptr, oldval, newval) _cas_impl(ptr, oldval, newval)
888 #define cas_ptr(ptr, oldval, newval) _cas_impl(ptr, oldval, newval)
890 #elif defined(HAVE_GCC_SYNC_OPERATIONS)
892 #define ref_get(ref) __sync_add_and_fetch(ref, 1)
893 #define ref_put(ref) (!__sync_sub_and_fetch(ref, 1))
894 #define ref_cur(ref) __sync_fetch_and_add(ref, 0)
896 #define cas_bool(ptr, oldval, newval) \
897 (__sync_bool_compare_and_swap(ptr, oldval, newval))
898 #define cas_ptr(ptr, oldval, newval) \
899 (__sync_bool_compare_and_swap(ptr, oldval, newval))
901 #else /* !HAVE_GCC_ATOMIC_OPERATIONS && !HAVE_GCC_SYNC_OPERATIONS */
904 * Get a new reference.
906 * Increments the reference counter atomically.
908 * @param ref pointer to ref counter
909 * @return new value of ref
911 refcount_t
ref_get(refcount_t
*ref
);
914 * Put back a unused reference.
916 * Decrements the reference counter atomically and
917 * says if more references available.
919 * @param ref pointer to ref counter
920 * @return TRUE if no more references counted
922 bool ref_put(refcount_t
*ref
);
925 * Get the current value of the reference counter.
927 * @param ref pointer to ref counter
928 * @return current value of ref
930 refcount_t
ref_cur(refcount_t
*ref
);
933 * Atomically replace value of ptr with newval if it currently equals oldval.
935 * @param ptr pointer to variable
936 * @param oldval old value of the variable
937 * @param newval new value set if possible
938 * @return TRUE if value equaled oldval and newval was written
940 bool cas_bool(bool *ptr
, bool oldval
, bool newval
);
943 * Atomically replace value of ptr with newval if it currently equals oldval.
945 * @param ptr pointer to variable
946 * @param oldval old value of the variable
947 * @param newval new value set if possible
948 * @return TRUE if value equaled oldval and newval was written
950 bool cas_ptr(void **ptr
, void *oldval
, void *newval
);
952 #endif /* HAVE_GCC_ATOMIC_OPERATIONS */
954 #ifndef HAVE_FMEMOPEN
956 # define HAVE_FMEMOPEN
957 # define HAVE_FMEMOPEN_FALLBACK
960 * fmemopen(3) fallback using BSD funopen.
962 * We could also provide one using fopencookie(), but should we have it we
963 * most likely have fmemopen().
965 * fseek() is currently not supported.
967 FILE *fmemopen(void *buf
, size_t size
, const char *mode
);
968 # endif /* FUNOPEN */
969 #endif /* FMEMOPEN */
972 * printf hook for time_t.
975 * time_t* time, bool utc
977 int time_printf_hook(printf_hook_data_t
*data
, printf_hook_spec_t
*spec
,
978 const void *const *args
);
981 * printf hook for time_t deltas.
984 * time_t* begin, time_t* end
986 int time_delta_printf_hook(printf_hook_data_t
*data
, printf_hook_spec_t
*spec
,
987 const void *const *args
);
990 * printf hook for memory areas.
993 * u_char *ptr, u_int len
995 int mem_printf_hook(printf_hook_data_t
*data
, printf_hook_spec_t
*spec
,
996 const void *const *args
);
998 #endif /** UTILS_H_ @}*/