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>
32 # include "compat/windows.h"
35 # include <arpa/inet.h>
36 # include <sys/socket.h>
38 # include <netinet/in.h>
44 * strongSwan program return codes
46 #define SS_RC_LIBSTRONGSWAN_INTEGRITY 64
47 #define SS_RC_DAEMON_INTEGRITY 65
48 #define SS_RC_INITIALIZATION_FAILED 66
50 #define SS_RC_FIRST SS_RC_LIBSTRONGSWAN_INTEGRITY
51 #define SS_RC_LAST SS_RC_INITIALIZATION_FAILED
54 * Number of bits in a byte
56 #define BITS_PER_BYTE 8
59 * Default length for various auxiliary text buffers
64 * Build assertion macro for integer expressions, evaluates to 0
66 #define BUILD_ASSERT(x) (sizeof(char[(x) ? 0 : -1]))
69 * Build time check to assert a is an array, evaluates to 0
71 * The address of an array element has a pointer type, which is not compatible
74 #define BUILD_ASSERT_ARRAY(a) \
75 BUILD_ASSERT(!__builtin_types_compatible_p(typeof(a), typeof(&(a)[0])))
78 * General purpose boolean type.
84 # define _Bool signed char
85 # endif /* HAVE__BOOL */
89 # define __bool_true_false_are_defined 1
90 #endif /* HAVE_STDBOOL_H */
99 #include "utils/strerror.h"
101 # include "compat/apple.h"
105 * Directory separator character in paths on this platform
108 # define DIRECTORY_SEPARATOR "\\"
110 # define DIRECTORY_SEPARATOR "/"
114 * Initialize utility functions
119 * Deinitialize utility functions
124 * Helper function that compares two strings for equality
126 static inline bool streq(const char *x
, const char *y
)
128 return strcmp(x
, y
) == 0;
132 * Helper function that compares two strings for equality, length limited
134 static inline bool strneq(const char *x
, const char *y
, size_t len
)
136 return strncmp(x
, y
, len
) == 0;
140 * Helper function that checks if a string starts with a given prefix
142 static inline bool strpfx(const char *x
, const char *prefix
)
144 return strneq(x
, prefix
, strlen(prefix
));
148 * Helper function that compares two strings for equality ignoring case
150 static inline bool strcaseeq(const char *x
, const char *y
)
152 return strcasecmp(x
, y
) == 0;
156 * Helper function that compares two strings for equality ignoring case, length limited
158 static inline bool strncaseeq(const char *x
, const char *y
, size_t len
)
160 return strncasecmp(x
, y
, len
) == 0;
164 * Helper function that checks if a string starts with a given prefix
166 static inline bool strcasepfx(const char *x
, const char *prefix
)
168 return strncaseeq(x
, prefix
, strlen(prefix
));
172 * NULL-safe strdup variant
174 static inline char *strdupnull(const char *s
)
176 return s
? strdup(s
) : NULL
;
180 * Helper function that compares two binary blobs for equality
182 static inline bool memeq(const void *x
, const void *y
, size_t len
)
184 return memcmp(x
, y
, len
) == 0;
188 * Same as memeq(), but with a constant runtime, safe for cryptographic use.
190 bool memeq_const(const void *x
, const void *y
, size_t len
);
193 * Calling memcpy() with NULL pointers, even with n == 0, results in undefined
194 * behavior according to the C standard. This version is guaranteed to not
195 * access the pointers if n is 0.
197 static inline void *memcpy_noop(void *dst
, const void *src
, size_t n
)
199 return n
? memcpy(dst
, src
, n
) : dst
;
204 #define memcpy(d,s,n) memcpy_noop(d,s,n)
207 * Calling memmove() with NULL pointers, even with n == 0, results in undefined
208 * behavior according to the C standard. This version is guaranteed to not
209 * access the pointers if n is 0.
211 static inline void *memmove_noop(void *dst
, const void *src
, size_t n
)
213 return n
? memmove(dst
, src
, n
) : dst
;
218 #define memmove(d,s,n) memmove_noop(d,s,n)
221 * Calling memset() with a NULL pointer, even with n == 0, results in undefined
222 * behavior according to the C standard. This version is guaranteed to not
223 * access the pointer if n is 0.
225 static inline void *memset_noop(void *s
, int c
, size_t n
)
227 return n
? memset(s
, c
, n
) : s
;
232 #define memset(s,c,n) memset_noop(s,c,n)
235 * Macro gives back larger of two values.
237 #define max(x,y) ({ \
238 typeof(x) _x = (x); \
239 typeof(y) _y = (y); \
240 _x > _y ? _x : _y; })
243 * Macro gives back smaller of two values.
245 #define min(x,y) ({ \
246 typeof(x) _x = (x); \
247 typeof(y) _y = (y); \
248 _x < _y ? _x : _y; })
251 * Call destructor of an object, if object != NULL
253 #define DESTROY_IF(obj) if (obj) (obj)->destroy(obj)
256 * Call offset destructor of an object, if object != NULL
258 #define DESTROY_OFFSET_IF(obj, offset) if (obj) obj->destroy_offset(obj, offset);
261 * Call function destructor of an object, if object != NULL
263 #define DESTROY_FUNCTION_IF(obj, fn) if (obj) obj->destroy_function(obj, fn);
266 * Debug macro to follow control flow
268 #define POS printf("%s, line %d\n", __FILE__, __LINE__)
271 * Object allocation/initialization macro, using designated initializer.
273 #define INIT(this, ...) { (this) = malloc(sizeof(*(this))); \
274 *(this) = (typeof(*(this))){ __VA_ARGS__ }; }
277 * Aligning version of INIT().
279 * The returned pointer must be freed using free_align(), not free().
281 * @param this object to allocate/initialize
282 * @param align alignment for allocation, in bytes
283 * @param ... initializer
285 #define INIT_ALIGN(this, align, ...) { \
286 (this) = malloc_align(sizeof(*(this)), align); \
287 *(this) = (typeof(*(this))){ __VA_ARGS__ }; }
290 * Object allocation/initialization macro, with extra allocated bytes at tail.
292 * The extra space gets zero-initialized.
294 * @param this pointer to object to allocate memory for
295 * @param extra number of bytes to allocate at end of this
296 * @param ... initializer
298 #define INIT_EXTRA(this, extra, ...) { \
299 typeof(extra) _extra = (extra); \
300 (this) = malloc(sizeof(*(this)) + _extra); \
301 *(this) = (typeof(*(this))){ __VA_ARGS__ }; \
302 memset((this) + 1, 0, _extra); }
305 * Aligning version of INIT_EXTRA().
307 * The returned pointer must be freed using free_align(), not free().
309 * @param this object to allocate/initialize
310 * @param extra number of bytes to allocate at end of this
311 * @param align alignment for allocation, in bytes
312 * @param ... initializer
314 #define INIT_EXTRA_ALIGN(this, extra, align, ...) { \
315 typeof(extra) _extra = (extra); \
316 (this) = malloc_align(sizeof(*(this)) + _extra, align); \
317 *(this) = (typeof(*(this))){ __VA_ARGS__ }; \
318 memset((this) + 1, 0, _extra); }
321 * Method declaration/definition macro, providing private and public interface.
323 * Defines a method name with this as first parameter and a return value ret,
324 * and an alias for this method with a _ prefix, having the this argument
325 * safely casted to the public interface iface.
326 * _name is provided a function pointer, but will get optimized out by GCC.
328 #define METHOD(iface, name, ret, this, ...) \
329 static ret name(union {iface *_public; this;} \
330 __attribute__((transparent_union)), ##__VA_ARGS__); \
331 static typeof(name) *_##name = (typeof(name)*)name; \
332 static ret name(this, ##__VA_ARGS__)
335 * Same as METHOD(), but is defined for two public interfaces.
337 #define METHOD2(iface1, iface2, name, ret, this, ...) \
338 static ret name(union {iface1 *_public1; iface2 *_public2; this;} \
339 __attribute__((transparent_union)), ##__VA_ARGS__); \
340 static typeof(name) *_##name = (typeof(name)*)name; \
341 static ret name(this, ##__VA_ARGS__)
344 * Callback declaration/definition macro, allowing casted first parameter.
346 * This is very similar to METHOD, but instead of casting the first parameter
347 * to a public interface, it uses a void*. This allows type safe definition
348 * of a callback function, while using the real type for the first parameter.
350 #define CALLBACK(name, ret, param1, ...) \
351 static ret _cb_##name(union {void *_generic; param1;} \
352 __attribute__((transparent_union)), ##__VA_ARGS__); \
353 static typeof(_cb_##name) *name = (typeof(_cb_##name)*)_cb_##name; \
354 static ret _cb_##name(param1, ##__VA_ARGS__)
357 * This macro allows counting the number of arguments passed to a macro.
358 * Combined with the VA_ARGS_DISPATCH() macro this can be used to implement
359 * macro overloading based on the number of arguments.
360 * 0 to 10 arguments are currently supported.
362 #define VA_ARGS_NUM(...) _VA_ARGS_NUM(0,##__VA_ARGS__,10,9,8,7,6,5,4,3,2,1,0)
363 #define _VA_ARGS_NUM(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,NUM,...) NUM
366 * This macro can be used to dispatch a macro call based on the number of given
367 * arguments, for instance:
370 * #define MY_MACRO(...) VA_ARGS_DISPATCH(MY_MACRO, __VA_ARGS__)(__VA_ARGS__)
371 * #define MY_MACRO1(arg) one_arg(arg)
372 * #define MY_MACRO2(arg1,arg2) two_args(arg1,arg2)
375 * MY_MACRO() can now be called with either one or two arguments, which will
376 * resolve to one_arg(arg) or two_args(arg1,arg2), respectively.
378 #define VA_ARGS_DISPATCH(func, ...) _VA_ARGS_DISPATCH(func, VA_ARGS_NUM(__VA_ARGS__))
379 #define _VA_ARGS_DISPATCH(func, num) __VA_ARGS_DISPATCH(func, num)
380 #define __VA_ARGS_DISPATCH(func, num) func ## num
383 * Architecture independent bitfield definition helpers (at least with GCC).
385 * Defines a bitfield with a type t and a fixed size of bitfield members, e.g.:
386 * BITFIELD2(u_int8_t,
390 * The member defined first placed at bit 0.
392 #if BYTE_ORDER == LITTLE_ENDIAN
393 #define BITFIELD2(t, a, b,...) struct { t a; t b; __VA_ARGS__}
394 #define BITFIELD3(t, a, b, c,...) struct { t a; t b; t c; __VA_ARGS__}
395 #define BITFIELD4(t, a, b, c, d,...) struct { t a; t b; t c; t d; __VA_ARGS__}
396 #define BITFIELD5(t, a, b, c, d, e,...) struct { t a; t b; t c; t d; t e; __VA_ARGS__}
397 #elif BYTE_ORDER == BIG_ENDIAN
398 #define BITFIELD2(t, a, b,...) struct { t b; t a; __VA_ARGS__}
399 #define BITFIELD3(t, a, b, c,...) struct { t c; t b; t a; __VA_ARGS__}
400 #define BITFIELD4(t, a, b, c, d,...) struct { t d; t c; t b; t a; __VA_ARGS__}
401 #define BITFIELD5(t, a, b, c, d, e,...) struct { t e; t d; t c; t b; t a; __VA_ARGS__}
405 * Macro to allocate a sized type.
407 #define malloc_thing(thing) ((thing*)malloc(sizeof(thing)))
410 * Get the number of elements in an array
412 #define countof(array) (sizeof(array)/sizeof((array)[0]) \
413 + BUILD_ASSERT_ARRAY(array))
416 * Ignore result of functions tagged with warn_unused_result attributes
418 #define ignore_result(call) { if(call){}; }
421 * Assign a function as a class method
423 #define ASSIGN(method, function) (method = (typeof(method))function)
428 #define UNDEFINED_TIME 0
431 * Maximum time since epoch causing wrap-around on Jan 19 03:14:07 UTC 2038
433 #define TIME_32_BIT_SIGNED_MAX 0x7fffffff
436 * define some missing fixed width int types on OpenSolaris.
437 * TODO: since the uintXX_t types are defined by the C99 standard we should
438 * probably use those anyway
440 #if defined __sun || defined WIN32
442 typedef uint8_t u_int8_t
;
443 typedef uint16_t u_int16_t
;
444 typedef uint32_t u_int32_t
;
445 typedef uint64_t u_int64_t
;
450 * 128 bit wide signed integer, if supported
452 typedef __int128 int128_t
;
454 * 128 bit wide unsigned integer, if supported
456 typedef unsigned __int128 u_int128_t
;
458 # define MAX_INT_TYPE int128_t
459 # define MAX_UINT_TYPE u_int128_t
461 # define MAX_INT_TYPE int64_t
462 # define MAX_UINT_TYPE u_int64_t
465 typedef enum status_t status_t
;
468 * Return values of function calls.
487 * The suggested operation is already done
497 * One of the arguments is invalid.
502 * Something could not be found.
507 * Error while parsing.
512 * Error while verifying.
517 * Object in invalid state.
522 * Destroy object which called method belongs to.
527 * Another call to the method is required.
533 * enum_names for type status_t.
535 extern enum_name_t
*status_names
;
537 typedef enum tty_escape_t tty_escape_t
;
540 * Excape codes for tty colors
543 /** text properties */
549 /** foreground colors */
560 /** background colors */
573 * Get the escape string for a given TTY color, empty string on non-tty fd
575 char* tty_escape_get(int fd
, tty_escape_t escape
);
578 * deprecated pluto style return value:
579 * error message, NULL for success
581 typedef const char *err_t
;
584 * Handle struct timeval like an own type.
586 typedef struct timeval timeval_t
;
589 * Handle struct timespec like an own type.
591 typedef struct timespec timespec_t
;
594 * Handle struct chunk_t like an own type.
596 typedef struct sockaddr sockaddr_t
;
599 * malloc(), but returns aligned memory.
601 * The returned pointer must be freed using free_align(), not free().
603 * @param size size of allocated data
604 * @param align alignment, up to 255 bytes, usually a power of 2
605 * @return allocated hunk, aligned to align bytes
607 void* malloc_align(size_t size
, u_int8_t align
);
610 * Free a hunk allocated by malloc_align().
612 * @param ptr hunk to free
614 void free_align(void *ptr
);
617 * Same as memcpy, but XORs src into dst instead of copy
619 void memxor(u_int8_t dest
[], u_int8_t src
[], size_t n
);
622 * Safely overwrite n bytes of memory at ptr with zero, non-inlining variant.
624 void memwipe_noinline(void *ptr
, size_t n
);
627 * Safely overwrite n bytes of memory at ptr with zero, inlining variant.
629 static inline void memwipe_inline(void *ptr
, size_t n
)
631 volatile char *c
= (volatile char*)ptr
;
634 /* byte wise until long aligned */
635 for (i
= 0; (uintptr_t)&c
[i
] % sizeof(long) && i
< n
; i
++)
640 if (n
>= sizeof(long))
642 for (m
= n
- sizeof(long); i
<= m
; i
+= sizeof(long))
644 *(volatile long*)&c
[i
] = 0;
647 /* byte wise of the rest */
655 * Safely overwrite n bytes of memory at ptr with zero, auto-inlining variant.
657 static inline void memwipe(void *ptr
, size_t n
)
663 if (__builtin_constant_p(n
))
665 memwipe_inline(ptr
, n
);
669 memwipe_noinline(ptr
, n
);
674 * A variant of strstr with the characteristics of memchr, where haystack is not
675 * a null-terminated string but simply a memory area of length n.
677 void *memstr(const void *haystack
, const char *needle
, size_t n
);
680 * Replacement for memrchr(3) if it is not provided by the C library.
682 * @param s start of the memory area to search
683 * @param c character to search
684 * @param n length of memory area to search
685 * @return pointer to the found character or NULL
687 void *utils_memrchr(const void *s
, int c
, size_t n
);
690 #define memrchr(s,c,n) utils_memrchr(s,c,n)
694 * Translates the characters in the given string, searching for characters
695 * in 'from' and mapping them to characters in 'to'.
696 * The two characters sets 'from' and 'to' must contain the same number of
699 char *translate(char *str
, const char *from
, const char *to
);
702 * Replaces all occurrences of search in the given string with replace.
704 * Allocates memory only if anything is replaced in the string. The original
705 * string is also returned if any of the arguments are invalid (e.g. if search
706 * is empty or any of them are NULL).
708 * @param str original string
709 * @param search string to search for and replace
710 * @param replace string to replace found occurrences with
711 * @return allocated string, if anything got replaced, str otherwise
713 char *strreplace(const char *str
, const char *search
, const char *replace
);
716 * Portable function to wait for SIGINT/SIGTERM (or equivalent).
721 * Like dirname(3) returns the directory part of the given null-terminated
722 * pathname, up to but not including the final '/' (or '.' if no '/' is found).
723 * Trailing '/' are not counted as part of the pathname.
725 * The difference is that it does this in a thread-safe manner (i.e. it does not
726 * use static buffers) and does not modify the original path.
728 * @param path original pathname
729 * @return allocated directory component
731 char *path_dirname(const char *path
);
734 * Like basename(3) returns the filename part of the given null-terminated path,
735 * i.e. the part following the final '/' (or '.' if path is empty or NULL).
736 * Trailing '/' are not counted as part of the pathname.
738 * The difference is that it does this in a thread-safe manner (i.e. it does not
739 * use static buffers) and does not modify the original path.
741 * @param path original pathname
742 * @return allocated filename component
744 char *path_basename(const char *path
);
747 * Check if a given path is absolute.
749 * @param path path to check
750 * @return TRUE if absolute, FALSE if relative
752 bool path_absolute(const char *path
);
755 * Creates a directory and all required parent directories.
757 * @param path path to the new directory
758 * @param mode permissions of the new directory/directories
759 * @return TRUE on success
761 bool mkdir_p(const char *path
, mode_t mode
);
763 #ifndef HAVE_CLOSEFROM
765 * Close open file descriptors greater than or equal to lowfd.
767 * @param lowfd start closing file descriptors from here
769 void closefrom(int lowfd
);
773 * Get a timestamp from a monotonic time source.
775 * While the time()/gettimeofday() functions are affected by leap seconds
776 * and system time changes, this function returns ever increasing monotonic
779 * @param tv timeval struct receiving monotonic timestamps, or NULL
780 * @return monotonic timestamp in seconds
782 time_t time_monotonic(timeval_t
*tv
);
785 * Add the given number of milliseconds to the given timeval struct
787 * @param tv timeval struct to modify
788 * @param ms number of milliseconds
790 static inline void timeval_add_ms(timeval_t
*tv
, u_int ms
)
792 tv
->tv_usec
+= ms
* 1000;
793 while (tv
->tv_usec
>= 1000000 /* 1s */)
795 tv
->tv_usec
-= 1000000;
806 * No-Operation function
823 status_t
return_failed();
828 status_t
return_success();
831 * Write a 16-bit host order value in network order to an unaligned address.
833 * @param host host order 16-bit value
834 * @param network unaligned address to write network order value to
836 static inline void htoun16(void *network
, u_int16_t host
)
838 char *unaligned
= (char*)network
;
841 memcpy(unaligned
, &host
, sizeof(host
));
845 * Write a 32-bit host order value in network order to an unaligned address.
847 * @param host host order 32-bit value
848 * @param network unaligned address to write network order value to
850 static inline void htoun32(void *network
, u_int32_t host
)
852 char *unaligned
= (char*)network
;
855 memcpy((char*)unaligned
, &host
, sizeof(host
));
859 * Write a 64-bit host order value in network order to an unaligned address.
861 * @param host host order 64-bit value
862 * @param network unaligned address to write network order value to
864 static inline void htoun64(void *network
, u_int64_t host
)
866 char *unaligned
= (char*)network
;
869 host
= htobe64(host
);
870 memcpy((char*)unaligned
, &host
, sizeof(host
));
872 u_int32_t high_part
, low_part
;
874 high_part
= host
>> 32;
875 high_part
= htonl(high_part
);
876 low_part
= host
& 0xFFFFFFFFLL
;
877 low_part
= htonl(low_part
);
879 memcpy(unaligned
, &high_part
, sizeof(high_part
));
880 unaligned
+= sizeof(high_part
);
881 memcpy(unaligned
, &low_part
, sizeof(low_part
));
886 * Read a 16-bit value in network order from an unaligned address to host order.
888 * @param network unaligned address to read network order value from
889 * @return host order value
891 static inline u_int16_t
untoh16(void *network
)
893 char *unaligned
= (char*)network
;
896 memcpy(&tmp
, unaligned
, sizeof(tmp
));
901 * Read a 32-bit value in network order from an unaligned address to host order.
903 * @param network unaligned address to read network order value from
904 * @return host order value
906 static inline u_int32_t
untoh32(void *network
)
908 char *unaligned
= (char*)network
;
911 memcpy(&tmp
, unaligned
, sizeof(tmp
));
916 * Read a 64-bit value in network order from an unaligned address to host order.
918 * @param network unaligned address to read network order value from
919 * @return host order value
921 static inline u_int64_t
untoh64(void *network
)
923 char *unaligned
= (char*)network
;
928 memcpy(&tmp
, unaligned
, sizeof(tmp
));
931 u_int32_t high_part
, low_part
;
933 memcpy(&high_part
, unaligned
, sizeof(high_part
));
934 unaligned
+= sizeof(high_part
);
935 memcpy(&low_part
, unaligned
, sizeof(low_part
));
937 high_part
= ntohl(high_part
);
938 low_part
= ntohl(low_part
);
940 return (((u_int64_t
)high_part
) << 32) + low_part
;
945 * Get the padding required to make size a multiple of alignment
947 static inline size_t pad_len(size_t size
, size_t alignment
)
951 remainder
= size
% alignment
;
952 return remainder
? alignment
- remainder
: 0;
956 * Round up size to be multiple of alignment
958 static inline size_t round_up(size_t size
, size_t alignment
)
960 return size
+ pad_len(size
, alignment
);
964 * Round down size to be a multiple of alignment
966 static inline size_t round_down(size_t size
, size_t alignment
)
968 return size
- (size
% alignment
);
972 * Special type to count references
974 typedef u_int refcount_t
;
976 /* use __atomic* built-ins with GCC 4.7 and newer */
978 # if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6))
979 # define HAVE_GCC_ATOMIC_OPERATIONS
983 #ifdef HAVE_GCC_ATOMIC_OPERATIONS
985 #define ref_get(ref) __atomic_add_fetch(ref, 1, __ATOMIC_RELAXED)
986 /* The relaxed memory model works fine for increments as these (usually) don't
987 * change the state of refcounted objects. But here we have to ensure that we
988 * free the right stuff if ref counted objects are mutable. So we have to sync
989 * with other threads that call ref_put(). It would be sufficient to use
990 * __ATOMIC_RELEASE here and then call __atomic_thread_fence() with
991 * __ATOMIC_ACQUIRE if we reach 0, but since we don't have control over the use
992 * of ref_put() we have to make sure. */
993 #define ref_put(ref) (!__atomic_sub_fetch(ref, 1, __ATOMIC_ACQ_REL))
994 #define ref_cur(ref) __atomic_load_n(ref, __ATOMIC_RELAXED)
996 #define _cas_impl(ptr, oldval, newval) ({ typeof(oldval) _old = oldval; \
997 __atomic_compare_exchange_n(ptr, &_old, newval, FALSE, \
998 __ATOMIC_SEQ_CST, __ATOMIC_RELAXED); })
999 #define cas_bool(ptr, oldval, newval) _cas_impl(ptr, oldval, newval)
1000 #define cas_ptr(ptr, oldval, newval) _cas_impl(ptr, oldval, newval)
1002 #elif defined(HAVE_GCC_SYNC_OPERATIONS)
1004 #define ref_get(ref) __sync_add_and_fetch(ref, 1)
1005 #define ref_put(ref) (!__sync_sub_and_fetch(ref, 1))
1006 #define ref_cur(ref) __sync_fetch_and_add(ref, 0)
1008 #define cas_bool(ptr, oldval, newval) \
1009 (__sync_bool_compare_and_swap(ptr, oldval, newval))
1010 #define cas_ptr(ptr, oldval, newval) \
1011 (__sync_bool_compare_and_swap(ptr, oldval, newval))
1013 #else /* !HAVE_GCC_ATOMIC_OPERATIONS && !HAVE_GCC_SYNC_OPERATIONS */
1016 * Get a new reference.
1018 * Increments the reference counter atomically.
1020 * @param ref pointer to ref counter
1021 * @return new value of ref
1023 refcount_t
ref_get(refcount_t
*ref
);
1026 * Put back a unused reference.
1028 * Decrements the reference counter atomically and
1029 * says if more references available.
1031 * @param ref pointer to ref counter
1032 * @return TRUE if no more references counted
1034 bool ref_put(refcount_t
*ref
);
1037 * Get the current value of the reference counter.
1039 * @param ref pointer to ref counter
1040 * @return current value of ref
1042 refcount_t
ref_cur(refcount_t
*ref
);
1045 * Atomically replace value of ptr with newval if it currently equals oldval.
1047 * @param ptr pointer to variable
1048 * @param oldval old value of the variable
1049 * @param newval new value set if possible
1050 * @return TRUE if value equaled oldval and newval was written
1052 bool cas_bool(bool *ptr
, bool oldval
, bool newval
);
1055 * Atomically replace value of ptr with newval if it currently equals oldval.
1057 * @param ptr pointer to variable
1058 * @param oldval old value of the variable
1059 * @param newval new value set if possible
1060 * @return TRUE if value equaled oldval and newval was written
1062 bool cas_ptr(void **ptr
, void *oldval
, void *newval
);
1064 #endif /* HAVE_GCC_ATOMIC_OPERATIONS */
1066 #ifndef HAVE_FMEMOPEN
1067 # ifdef HAVE_FUNOPEN
1068 # define HAVE_FMEMOPEN
1069 # define HAVE_FMEMOPEN_FALLBACK
1072 * fmemopen(3) fallback using BSD funopen.
1074 * We could also provide one using fopencookie(), but should we have it we
1075 * most likely have fmemopen().
1077 * fseek() is currently not supported.
1079 FILE *fmemopen(void *buf
, size_t size
, const char *mode
);
1080 # endif /* FUNOPEN */
1081 #endif /* FMEMOPEN */
1084 * printf hook for time_t.
1087 * time_t* time, bool utc
1089 int time_printf_hook(printf_hook_data_t
*data
, printf_hook_spec_t
*spec
,
1090 const void *const *args
);
1093 * printf hook for time_t deltas.
1096 * time_t* begin, time_t* end
1098 int time_delta_printf_hook(printf_hook_data_t
*data
, printf_hook_spec_t
*spec
,
1099 const void *const *args
);
1102 * printf hook for memory areas.
1105 * u_char *ptr, u_int len
1107 int mem_printf_hook(printf_hook_data_t
*data
, printf_hook_spec_t
*spec
,
1108 const void *const *args
);
1110 #endif /** UTILS_H_ @}*/