sipwise
/
rtpengine
mirror of https://github.com/sipwise/rtpengine.git
1
0
Fork 0
Code Issues Releases Wiki Activity

C99 inlining rules

Browse Source
pull/6/head
Richard Fuchs 11 years ago
parent 5faf5e6d7d
commit 05e429c610
18 changed files with 232 additions and 203 deletions
Show Stats Download Patch File Download Diff File

83
daemon/aux.h
Unescape View File

@ -17,6 +17,7 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
#include "compat.h"
@ -57,8 +58,8 @@ typedef int (*parse_func)(char **, void **, void *);
GList *g_list_link(GList *, GList *); GList *g_list_link(GList *, GList *);
int pcre_multi_match(pcre *, pcre_extra *, const char *, unsigned int, parse_func, void *, GQueue *); int pcre_multi_match(pcre *, pcre_extra *, const char *, unsigned int, parse_func, void *, GQueue *);
static inline void strmove(char **, char **); INLINE void strmove(char **, char **);
static inline void strdupfree(char **, const char *); INLINE void strdupfree(char **, const char *);
#if !GLIB_CHECK_VERSION(2,14,0) #if !GLIB_CHECK_VERSION(2,14,0)
@ -68,64 +69,64 @@ void g_queue_clear(GQueue *);
#endif #endif
#if !GLIB_CHECK_VERSION(2,32,0) #if !GLIB_CHECK_VERSION(2,32,0)
static inline int g_hash_table_contains(GHashTable *h, const void *k) { INLINE int g_hash_table_contains(GHashTable *h, const void *k) {
return g_hash_table_lookup(h, k) ? 1 : 0; return g_hash_table_lookup(h, k) ? 1 : 0;
} }
#endif #endif
static inline void g_queue_move(GQueue *dst, GQueue *src) { INLINE void g_queue_move(GQueue *dst, GQueue *src) {
GList *l; GList *l;
while ((l = g_queue_pop_head_link(src))) while ((l = g_queue_pop_head_link(src)))
g_queue_push_tail_link(dst, l); g_queue_push_tail_link(dst, l);
} }
static inline void g_queue_truncate(GQueue *q, unsigned int len) { INLINE void g_queue_truncate(GQueue *q, unsigned int len) {
while (q->length > len) while (q->length > len)
g_queue_pop_tail(q); g_queue_pop_tail(q);
} }
static inline void strmove(char **d, char **s) { INLINE void strmove(char **d, char **s) {
if (*d) if (*d)
free(*d); free(*d);
*d = *s; *d = *s;
*s = strdup(""); *s = strdup("");
} }
static inline void strdupfree(char **d, const char *s) { INLINE void strdupfree(char **d, const char *s) {
if (*d) if (*d)
free(*d); free(*d);
*d = strdup(s); *d = strdup(s);
} }
static inline void nonblock(int fd) { INLINE void nonblock(int fd) {
fcntl(fd, F_SETFL, O_NONBLOCK); fcntl(fd, F_SETFL, O_NONBLOCK);
} }
static inline void reuseaddr(int fd) { INLINE void reuseaddr(int fd) {
int one = 1; int one = 1;
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)); setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
} }
static inline void ipv6only(int fd, int yn) { INLINE void ipv6only(int fd, int yn) {
setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &yn, sizeof(yn)); setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &yn, sizeof(yn));
} }
static inline int bit_array_isset(unsigned long *name, unsigned int bit) { INLINE int bit_array_isset(unsigned long *name, unsigned int bit) {
return name[(bit) / (sizeof(long) * 8)] & (1UL << ((bit) % (sizeof(long) * 8))); return name[(bit) / (sizeof(long) * 8)] & (1UL << ((bit) % (sizeof(long) * 8)));
} }
static inline void bit_array_set(unsigned long *name, unsigned int bit) { INLINE void bit_array_set(unsigned long *name, unsigned int bit) {
name[(bit) / (sizeof(long) * 8)] |= 1UL << ((bit) % (sizeof(long) * 8)); name[(bit) / (sizeof(long) * 8)] |= 1UL << ((bit) % (sizeof(long) * 8));
} }
static inline void bit_array_clear(unsigned long *name, unsigned int bit) { INLINE void bit_array_clear(unsigned long *name, unsigned int bit) {
name[(bit) / (sizeof(long) * 8)] &= ~(1UL << ((bit) % (sizeof(long) * 8))); name[(bit) / (sizeof(long) * 8)] &= ~(1UL << ((bit) % (sizeof(long) * 8)));
} }
static inline char chrtoupper(char x) { INLINE char chrtoupper(char x) {
return x & 0xdf; return x & 0xdf;
} }
static inline void swap_ptrs(void *a, void *b) { INLINE void swap_ptrs(void *a, void *b) {
void *t, **aa, **bb; void *t, **aa, **bb;
aa = a; aa = a;
bb = b; bb = b;
@ -134,14 +135,14 @@ static inline void swap_ptrs(void *a, void *b) {
*bb = t; *bb = t;
} }
static inline void in4_to_6(struct in6_addr *o, u_int32_t ip) { INLINE void in4_to_6(struct in6_addr *o, u_int32_t ip) {
o->s6_addr32[0] = 0; o->s6_addr32[0] = 0;
o->s6_addr32[1] = 0; o->s6_addr32[1] = 0;
o->s6_addr32[2] = htonl(0xffff); o->s6_addr32[2] = htonl(0xffff);
o->s6_addr32[3] = ip; o->s6_addr32[3] = ip;
} }
static inline void smart_ntop(char *o, struct in6_addr *a, size_t len) { INLINE void smart_ntop(char *o, struct in6_addr *a, size_t len) {
const char *r; const char *r;
if (IN6_IS_ADDR_V4MAPPED(a)) if (IN6_IS_ADDR_V4MAPPED(a))
@ -153,7 +154,7 @@ static inline void smart_ntop(char *o, struct in6_addr *a, size_t len) {
*o = '\0'; *o = '\0';
} }
static inline char *smart_ntop_p(char *o, struct in6_addr *a, size_t len) { INLINE char *smart_ntop_p(char *o, struct in6_addr *a, size_t len) {
int l; int l;
if (IN6_IS_ADDR_V4MAPPED(a)) { if (IN6_IS_ADDR_V4MAPPED(a)) {
@ -175,7 +176,7 @@ static inline char *smart_ntop_p(char *o, struct in6_addr *a, size_t len) {
} }
} }
static inline void smart_ntop_port(char *o, struct sockaddr_in6 *a, size_t len) { INLINE void smart_ntop_port(char *o, struct sockaddr_in6 *a, size_t len) {
char *e; char *e;
e = smart_ntop_p(o, &a->sin6_addr, len); e = smart_ntop_p(o, &a->sin6_addr, len);
@ -186,7 +187,7 @@ static inline void smart_ntop_port(char *o, struct sockaddr_in6 *a, size_t len)
sprintf(e, ":%hu", ntohs(a->sin6_port)); sprintf(e, ":%hu", ntohs(a->sin6_port));
} }
static inline int smart_pton(int af, char *src, void *dst) { INLINE int smart_pton(int af, char *src, void *dst) {
char *p; char *p;
int ret; int ret;
@ -201,7 +202,7 @@ static inline int smart_pton(int af, char *src, void *dst) {
return inet_pton(af, src, dst); return inet_pton(af, src, dst);
} }
static inline int strmemcmp(const void *mem, int len, const char *str) { INLINE int strmemcmp(const void *mem, int len, const char *str) {
int l = strlen(str); int l = strlen(str);
if (l < len) if (l < len)
return -1; return -1;
@ -211,7 +212,7 @@ static inline int strmemcmp(const void *mem, int len, const char *str) {
} }
/* XXX replace with better source of randomness */ /* XXX replace with better source of randomness */
static inline void random_string(unsigned char *buf, int len) { INLINE void random_string(unsigned char *buf, int len) {
while (len--) while (len--)
*buf++ = random() % 0x100; *buf++ = random() % 0x100;
} }
@ -269,60 +270,60 @@ typedef pthread_cond_t cond_t;
static inline int __debug_mutex_init(mutex_t *m, const char *file, unsigned int line) { INLINE int __debug_mutex_init(mutex_t *m, const char *file, unsigned int line) {
mylog(LOG_DEBUG, "mutex_init(%p) at %s:%u", m, file, line); mylog(LOG_DEBUG, "mutex_init(%p) at %s:%u", m, file, line);
return pthread_mutex_init(m, NULL); return pthread_mutex_init(m, NULL);
} }
static inline int __debug_mutex_destroy(mutex_t *m, const char *file, unsigned int line) { INLINE int __debug_mutex_destroy(mutex_t *m, const char *file, unsigned int line) {
mylog(LOG_DEBUG, "mutex_destroy(%p) at %s:%u", m, file, line); mylog(LOG_DEBUG, "mutex_destroy(%p) at %s:%u", m, file, line);
return pthread_mutex_destroy(m); return pthread_mutex_destroy(m);
} }
static inline int __debug_mutex_lock(mutex_t *m, const char *file, unsigned int line) { INLINE int __debug_mutex_lock(mutex_t *m, const char *file, unsigned int line) {
int ret; int ret;
mylog(LOG_DEBUG, "mutex_lock(%p) at %s:%u ...", m, file, line); mylog(LOG_DEBUG, "mutex_lock(%p) at %s:%u ...", m, file, line);
ret = pthread_mutex_lock(m); ret = pthread_mutex_lock(m);
mylog(LOG_DEBUG, "mutex_lock(%p) at %s:%u returning %i", m, file, line, ret); mylog(LOG_DEBUG, "mutex_lock(%p) at %s:%u returning %i", m, file, line, ret);
return ret; return ret;
} }
static inline int __debug_mutex_trylock(mutex_t *m, const char *file, unsigned int line) { INLINE int __debug_mutex_trylock(mutex_t *m, const char *file, unsigned int line) {
int ret; int ret;
mylog(LOG_DEBUG, "mutex_trylock(%p) at %s:%u ...", m, file, line); mylog(LOG_DEBUG, "mutex_trylock(%p) at %s:%u ...", m, file, line);
ret = pthread_mutex_trylock(m); ret = pthread_mutex_trylock(m);
mylog(LOG_DEBUG, "mutex_trylock(%p) at %s:%u returning %i", m, file, line, ret); mylog(LOG_DEBUG, "mutex_trylock(%p) at %s:%u returning %i", m, file, line, ret);
return ret; return ret;
} }
static inline int __debug_mutex_unlock(mutex_t *m, const char *file, unsigned int line) { INLINE int __debug_mutex_unlock(mutex_t *m, const char *file, unsigned int line) {
mylog(LOG_DEBUG, "mutex_unlock(%p) at %s:%u", m, file, line); mylog(LOG_DEBUG, "mutex_unlock(%p) at %s:%u", m, file, line);
return pthread_mutex_unlock(m); return pthread_mutex_unlock(m);
} }
static inline int __debug_rwlock_init(rwlock_t *m, const char *file, unsigned int line) { INLINE int __debug_rwlock_init(rwlock_t *m, const char *file, unsigned int line) {
mylog(LOG_DEBUG, "rwlock_init(%p) at %s:%u", m, file, line); mylog(LOG_DEBUG, "rwlock_init(%p) at %s:%u", m, file, line);
return pthread_rwlock_init(m, NULL); return pthread_rwlock_init(m, NULL);
} }
static inline int __debug_rwlock_destroy(rwlock_t *m, const char *file, unsigned int line) { INLINE int __debug_rwlock_destroy(rwlock_t *m, const char *file, unsigned int line) {
mylog(LOG_DEBUG, "rwlock_destroy(%p) at %s:%u", m, file, line); mylog(LOG_DEBUG, "rwlock_destroy(%p) at %s:%u", m, file, line);
return pthread_rwlock_destroy(m); return pthread_rwlock_destroy(m);
} }
static inline int __debug_rwlock_lock_r(rwlock_t *m, const char *file, unsigned int line) { INLINE int __debug_rwlock_lock_r(rwlock_t *m, const char *file, unsigned int line) {
int ret; int ret;
mylog(LOG_DEBUG, "rwlock_lock_r(%p) at %s:%u ...", m, file, line); mylog(LOG_DEBUG, "rwlock_lock_r(%p) at %s:%u ...", m, file, line);
ret = pthread_rwlock_rdlock(m); ret = pthread_rwlock_rdlock(m);
mylog(LOG_DEBUG, "rwlock_lock_r(%p) at %s:%u returning %i", m, file, line, ret); mylog(LOG_DEBUG, "rwlock_lock_r(%p) at %s:%u returning %i", m, file, line, ret);
return ret; return ret;
} }
static inline int __debug_rwlock_lock_w(rwlock_t *m, const char *file, unsigned int line) { INLINE int __debug_rwlock_lock_w(rwlock_t *m, const char *file, unsigned int line) {
int ret; int ret;
mylog(LOG_DEBUG, "rwlock_lock_w(%p) at %s:%u ...", m, file, line); mylog(LOG_DEBUG, "rwlock_lock_w(%p) at %s:%u ...", m, file, line);
ret = pthread_rwlock_wrlock(m); ret = pthread_rwlock_wrlock(m);
mylog(LOG_DEBUG, "rwlock_lock_w(%p) at %s:%u returning %i", m, file, line, ret); mylog(LOG_DEBUG, "rwlock_lock_w(%p) at %s:%u returning %i", m, file, line, ret);
return ret; return ret;
} }
static inline int __debug_rwlock_unlock_r(rwlock_t *m, const char *file, unsigned int line) { INLINE int __debug_rwlock_unlock_r(rwlock_t *m, const char *file, unsigned int line) {
mylog(LOG_DEBUG, "rwlock_unlock_r(%p) at %s:%u", m, file, line); mylog(LOG_DEBUG, "rwlock_unlock_r(%p) at %s:%u", m, file, line);
return pthread_rwlock_unlock(m); return pthread_rwlock_unlock(m);
} }
static inline int __debug_rwlock_unlock_w(rwlock_t *m, const char *file, unsigned int line) { INLINE int __debug_rwlock_unlock_w(rwlock_t *m, const char *file, unsigned int line) {
mylog(LOG_DEBUG, "rwlock_unlock_w(%p) at %s:%u", m, file, line); mylog(LOG_DEBUG, "rwlock_unlock_w(%p) at %s:%u", m, file, line);
return pthread_rwlock_unlock(m); return pthread_rwlock_unlock(m);
} }
@ -341,7 +342,7 @@ void thread_create_detach(void (*)(void *), void *);
static inline int rlim(int res, rlim_t val) { INLINE int rlim(int res, rlim_t val) {
struct rlimit rlim; struct rlimit rlim;
ZERO(rlim); ZERO(rlim);
@ -349,7 +350,7 @@ static inline int rlim(int res, rlim_t val) {
return setrlimit(res, &rlim); return setrlimit(res, &rlim);
} }
static inline int is_addr_unspecified(const struct in6_addr *a) { INLINE int is_addr_unspecified(const struct in6_addr *a) {
if (a->s6_addr32[0]) if (a->s6_addr32[0])
return 0; return 0;
if (a->s6_addr32[1]) if (a->s6_addr32[1])
@ -362,23 +363,23 @@ static inline int is_addr_unspecified(const struct in6_addr *a) {
} }
/* checks if at least one of the flags is set */ /* checks if at least one of the flags is set */
static inline int bf_isset(const unsigned int *u, unsigned int f) { INLINE int bf_isset(const unsigned int *u, unsigned int f) {
if ((*u & f)) if ((*u & f))
return -1; return -1;
return 0; return 0;
} }
static inline void bf_set(unsigned int *u, unsigned int f) { INLINE void bf_set(unsigned int *u, unsigned int f) {
*u |= f; *u |= f;
} }
static inline void bf_clear(unsigned int *u, unsigned int f) { INLINE void bf_clear(unsigned int *u, unsigned int f) {
*u &= ~f; *u &= ~f;
} }
static inline void bf_xset(unsigned int *u, unsigned int f, int cond) { INLINE void bf_xset(unsigned int *u, unsigned int f, int cond) {
bf_clear(u, f); bf_clear(u, f);
bf_set(u, cond ? f : 0); bf_set(u, cond ? f : 0);
} }
/* works only for single flags */ /* works only for single flags */
static inline void bf_copy(unsigned int *u, unsigned int f, const unsigned int *s, unsigned int g) { INLINE void bf_copy(unsigned int *u, unsigned int f, const unsigned int *s, unsigned int g) {
/* a good compiler will optimize out the calls to log2() */ /* a good compiler will optimize out the calls to log2() */
*u &= ~f; *u &= ~f;
if (f >= g) if (f >= g)
@ -387,7 +388,7 @@ static inline void bf_copy(unsigned int *u, unsigned int f, const unsigned int *
*u |= (*s & g) >> (int) (log2(g) - log2(f)); *u |= (*s & g) >> (int) (log2(g) - log2(f));
} }
/* works for multiple flags */ /* works for multiple flags */
static inline void bf_copy_same(unsigned int *u, const unsigned int *s, unsigned int g) { INLINE void bf_copy_same(unsigned int *u, const unsigned int *s, unsigned int g) {
bf_copy(u, g, s, g); bf_copy(u, g, s, g);
} }

120
daemon/bencode.h
Unescape View File

@ -12,8 +12,10 @@
# define BENCODE_MALLOC pkg_malloc # define BENCODE_MALLOC pkg_malloc
# define BENCODE_FREE pkg_free # define BENCODE_FREE pkg_free
# endif # endif
# define INLINE static inline
#else #else
/* rtpengine */ /* rtpengine */
# include "compat.h"
# include "str.h" # include "str.h"
# ifndef BENCODE_MALLOC # ifndef BENCODE_MALLOC
# define BENCODE_MALLOC malloc # define BENCODE_MALLOC malloc
@ -92,7 +94,7 @@ bencode_item_t *bencode_list(bencode_buffer_t *buf);
void bencode_buffer_destroy_add(bencode_buffer_t *buf, free_func_t, void *); void bencode_buffer_destroy_add(bencode_buffer_t *buf, free_func_t, void *);
/* Returns the buffer associated with an item, or NULL if pointer given is NULL */ /* Returns the buffer associated with an item, or NULL if pointer given is NULL */
static inline bencode_buffer_t *bencode_item_buffer(bencode_item_t *); INLINE bencode_buffer_t *bencode_item_buffer(bencode_item_t *);
@ -107,29 +109,29 @@ static inline bencode_buffer_t *bencode_item_buffer(bencode_item_t *);
* Also, the function does not reorder keys into lexicographical order; keys will be encoded in * Also, the function does not reorder keys into lexicographical order; keys will be encoded in
* the same order as they've been added. The key must a null-terminated string. * the same order as they've been added. The key must a null-terminated string.
* The value to be added must not have been previously linked into any other dictionary or list. */ * The value to be added must not have been previously linked into any other dictionary or list. */
static inline bencode_item_t *bencode_dictionary_add(bencode_item_t *dict, const char *key, bencode_item_t *val); INLINE bencode_item_t *bencode_dictionary_add(bencode_item_t *dict, const char *key, bencode_item_t *val);
/* Identical to bencode_dictionary_add() but doesn't require the key string to be null-terminated */ /* Identical to bencode_dictionary_add() but doesn't require the key string to be null-terminated */
bencode_item_t *bencode_dictionary_add_len(bencode_item_t *dict, const char *key, int keylen, bencode_item_t *val); bencode_item_t *bencode_dictionary_add_len(bencode_item_t *dict, const char *key, int keylen, bencode_item_t *val);
/* Convenience function to add a string value to a dictionary, possibly duplicated into the /* Convenience function to add a string value to a dictionary, possibly duplicated into the
* bencode_buffer_t object. */ * bencode_buffer_t object. */
static inline bencode_item_t *bencode_dictionary_add_string(bencode_item_t *dict, const char *key, const char *val); INLINE bencode_item_t *bencode_dictionary_add_string(bencode_item_t *dict, const char *key, const char *val);
static inline bencode_item_t *bencode_dictionary_add_string_dup(bencode_item_t *dict, const char *key, const char *val); INLINE bencode_item_t *bencode_dictionary_add_string_dup(bencode_item_t *dict, const char *key, const char *val);
/* Ditto, but for a "str" object */ /* Ditto, but for a "str" object */
static inline bencode_item_t *bencode_dictionary_add_str(bencode_item_t *dict, const char *key, const str *val); INLINE bencode_item_t *bencode_dictionary_add_str(bencode_item_t *dict, const char *key, const str *val);
static inline bencode_item_t *bencode_dictionary_add_str_dup(bencode_item_t *dict, const char *key, const str *val); INLINE bencode_item_t *bencode_dictionary_add_str_dup(bencode_item_t *dict, const char *key, const str *val);
/* Ditto, but adds a string created through an iovec array to the dictionary. See /* Ditto, but adds a string created through an iovec array to the dictionary. See
* bencode_string_iovec(). */ * bencode_string_iovec(). */
static inline bencode_item_t *bencode_dictionary_add_iovec(bencode_item_t *dict, const char *key, INLINE bencode_item_t *bencode_dictionary_add_iovec(bencode_item_t *dict, const char *key,
const struct iovec *iov, int iov_cnt, int str_len); const struct iovec *iov, int iov_cnt, int str_len);
/* Convenience functions to add the respective (newly created) objects to a dictionary */ /* Convenience functions to add the respective (newly created) objects to a dictionary */
static inline bencode_item_t *bencode_dictionary_add_integer(bencode_item_t *dict, const char *key, long long int val); INLINE bencode_item_t *bencode_dictionary_add_integer(bencode_item_t *dict, const char *key, long long int val);
static inline bencode_item_t *bencode_dictionary_add_dictionary(bencode_item_t *dict, const char *key); INLINE bencode_item_t *bencode_dictionary_add_dictionary(bencode_item_t *dict, const char *key);
static inline bencode_item_t *bencode_dictionary_add_list(bencode_item_t *dict, const char *key); INLINE bencode_item_t *bencode_dictionary_add_list(bencode_item_t *dict, const char *key);
@ -142,9 +144,9 @@ static inline bencode_item_t *bencode_dictionary_add_list(bencode_item_t *dict,
bencode_item_t *bencode_list_add(bencode_item_t *list, bencode_item_t *item); bencode_item_t *bencode_list_add(bencode_item_t *list, bencode_item_t *item);
/* Convenience function to add the respective (newly created) objects to a list */ /* Convenience function to add the respective (newly created) objects to a list */
static inline bencode_item_t *bencode_list_add_string(bencode_item_t *list, const char *s); INLINE bencode_item_t *bencode_list_add_string(bencode_item_t *list, const char *s);
static inline bencode_item_t *bencode_list_add_list(bencode_item_t *list); INLINE bencode_item_t *bencode_list_add_list(bencode_item_t *list);
static inline bencode_item_t *bencode_list_add_dictionary(bencode_item_t *list); INLINE bencode_item_t *bencode_list_add_dictionary(bencode_item_t *list);
@ -161,17 +163,17 @@ bencode_item_t *bencode_string_len(bencode_buffer_t *buf, const char *s, int len
/* Creates a new byte-string object. The given string must be null-terminated. Otherwise identical /* Creates a new byte-string object. The given string must be null-terminated. Otherwise identical
* to bencode_string_len(). */ * to bencode_string_len(). */
static inline bencode_item_t *bencode_string(bencode_buffer_t *buf, const char *s); INLINE bencode_item_t *bencode_string(bencode_buffer_t *buf, const char *s);
/* Creates a new byte-string object from a "str" object. The string does not have to be null- /* Creates a new byte-string object from a "str" object. The string does not have to be null-
* terminated. */ * terminated. */
static inline bencode_item_t *bencode_str(bencode_buffer_t *buf, const str *s); INLINE bencode_item_t *bencode_str(bencode_buffer_t *buf, const str *s);
/* Identical to the above three functions, but copies the string into the bencode_buffer_t object. /* Identical to the above three functions, but copies the string into the bencode_buffer_t object.
* Thus, the given string doesn't have to remain valid and accessible afterwards. */ * Thus, the given string doesn't have to remain valid and accessible afterwards. */
bencode_item_t *bencode_string_len_dup(bencode_buffer_t *buf, const char *s, int len); bencode_item_t *bencode_string_len_dup(bencode_buffer_t *buf, const char *s, int len);
static inline bencode_item_t *bencode_string_dup(bencode_buffer_t *buf, const char *s); INLINE bencode_item_t *bencode_string_dup(bencode_buffer_t *buf, const char *s);
static inline bencode_item_t *bencode_str_dup(bencode_buffer_t *buf, const str *s); INLINE bencode_item_t *bencode_str_dup(bencode_buffer_t *buf, const str *s);
/* Creates a new byte-string object from an iovec array. The created object has different internal /* Creates a new byte-string object from an iovec array. The created object has different internal
* semantics (not a BENCODE_STRING, but a BENCODE_IOVEC) and must not be treated like other string * semantics (not a BENCODE_STRING, but a BENCODE_IOVEC) and must not be treated like other string
@ -183,11 +185,11 @@ bencode_item_t *bencode_string_iovec(bencode_buffer_t *buf, const struct iovec *
/* Convenience function to compare a string object to a regular C string. Returns 2 if object /* Convenience function to compare a string object to a regular C string. Returns 2 if object
* isn't a string object, otherwise returns according to strcmp(). */ * isn't a string object, otherwise returns according to strcmp(). */
static inline int bencode_strcmp(bencode_item_t *a, const char *b); INLINE int bencode_strcmp(bencode_item_t *a, const char *b);
/* Converts the string object "in" into a str object "out". Returns "out" on success, or NULL on /* Converts the string object "in" into a str object "out". Returns "out" on success, or NULL on
* error ("in" was NULL or not a string object). */ * error ("in" was NULL or not a string object). */
static inline str *bencode_get_str(bencode_item_t *in, str *out); INLINE str *bencode_get_str(bencode_item_t *in, str *out);
@ -295,10 +297,10 @@ bencode_item_t *bencode_decode(bencode_buffer_t *buf, const char *s, int len);
/* Identical to bencode_decode(), but returns successfully only if the type of the decoded object match /* Identical to bencode_decode(), but returns successfully only if the type of the decoded object match
* "expect". */ * "expect". */
static inline bencode_item_t *bencode_decode_expect(bencode_buffer_t *buf, const char *s, int len, bencode_type_t expect); INLINE bencode_item_t *bencode_decode_expect(bencode_buffer_t *buf, const char *s, int len, bencode_type_t expect);
/* Identical to bencode_decode_expect() but takes a "str" argument. */ /* Identical to bencode_decode_expect() but takes a "str" argument. */
static inline bencode_item_t *bencode_decode_expect_str(bencode_buffer_t *buf, const str *s, bencode_type_t expect); INLINE bencode_item_t *bencode_decode_expect_str(bencode_buffer_t *buf, const str *s, bencode_type_t expect);
@ -309,7 +311,7 @@ static inline bencode_item_t *bencode_decode_expect_str(bencode_buffer_t *buf, c
/* Searches the given dictionary object for the given key and returns the respective value. Returns /* Searches the given dictionary object for the given key and returns the respective value. Returns
* NULL if the given object isn't a dictionary or if the key doesn't exist. The key must be a * NULL if the given object isn't a dictionary or if the key doesn't exist. The key must be a
* null-terminated string. */ * null-terminated string. */
static inline bencode_item_t *bencode_dictionary_get(bencode_item_t *dict, const char *key); INLINE bencode_item_t *bencode_dictionary_get(bencode_item_t *dict, const char *key);
/* Identical to bencode_dictionary_get() but doesn't require the key to be null-terminated. */ /* Identical to bencode_dictionary_get() but doesn't require the key to be null-terminated. */
bencode_item_t *bencode_dictionary_get_len(bencode_item_t *dict, const char *key, int key_len); bencode_item_t *bencode_dictionary_get_len(bencode_item_t *dict, const char *key, int key_len);
@ -318,31 +320,31 @@ bencode_item_t *bencode_dictionary_get_len(bencode_item_t *dict, const char *key
* returns it as a pointer to the string itself. Returns NULL if the value is of some other type. The * returns it as a pointer to the string itself. Returns NULL if the value is of some other type. The
* returned string is NOT null-terminated. Length of the string is returned in *len, which must be a * returned string is NOT null-terminated. Length of the string is returned in *len, which must be a
* valid pointer. The returned string will be valid until dict's bencode_buffer_t object is destroyed. */ * valid pointer. The returned string will be valid until dict's bencode_buffer_t object is destroyed. */
static inline char *bencode_dictionary_get_string(bencode_item_t *dict, const char *key, int *len); INLINE char *bencode_dictionary_get_string(bencode_item_t *dict, const char *key, int *len);
/* Identical to bencode_dictionary_get_string() but fills in a "str" struct. Returns str->s, which /* Identical to bencode_dictionary_get_string() but fills in a "str" struct. Returns str->s, which
* may be NULL. */ * may be NULL. */
static inline char *bencode_dictionary_get_str(bencode_item_t *dict, const char *key, str *str); INLINE char *bencode_dictionary_get_str(bencode_item_t *dict, const char *key, str *str);
/* Looks up the given key in the dictionary and compares the corresponding value to the given /* Looks up the given key in the dictionary and compares the corresponding value to the given
* null-terminated string. Returns 2 if the key isn't found or if the value isn't a string, otherwise * null-terminated string. Returns 2 if the key isn't found or if the value isn't a string, otherwise
* returns according to strcmp(). */ * returns according to strcmp(). */
static inline int bencode_dictionary_get_strcmp(bencode_item_t *dict, const char *key, const char *str); INLINE int bencode_dictionary_get_strcmp(bencode_item_t *dict, const char *key, const char *str);
/* Identical to bencode_dictionary_get() but returns the string in a newly allocated buffer (using the /* Identical to bencode_dictionary_get() but returns the string in a newly allocated buffer (using the
* BENCODE_MALLOC function), which remains valid even after bencode_buffer_t is destroyed. */ * BENCODE_MALLOC function), which remains valid even after bencode_buffer_t is destroyed. */
static inline char *bencode_dictionary_get_string_dup(bencode_item_t *dict, const char *key, int *len); INLINE char *bencode_dictionary_get_string_dup(bencode_item_t *dict, const char *key, int *len);
/* Combines bencode_dictionary_get_str() and bencode_dictionary_get_string_dup(). Fills in a "str" /* Combines bencode_dictionary_get_str() and bencode_dictionary_get_string_dup(). Fills in a "str"
* struct, but copies the string into a newly allocated buffer. Returns str->s. */ * struct, but copies the string into a newly allocated buffer. Returns str->s. */
static inline char *bencode_dictionary_get_str_dup(bencode_item_t *dict, const char *key, str *str); INLINE char *bencode_dictionary_get_str_dup(bencode_item_t *dict, const char *key, str *str);
/* Identical to bencode_dictionary_get_string() but expects an integer object. The parameter "defval" /* Identical to bencode_dictionary_get_string() but expects an integer object. The parameter "defval"
* specified which value should be returned if the key is not found or if the value is not an integer. */ * specified which value should be returned if the key is not found or if the value is not an integer. */
static inline long long int bencode_dictionary_get_integer(bencode_item_t *dict, const char *key, long long int defval); INLINE long long int bencode_dictionary_get_integer(bencode_item_t *dict, const char *key, long long int defval);
/* Identical to bencode_dictionary_get(), but returns the object only if its type matches "expect". */ /* Identical to bencode_dictionary_get(), but returns the object only if its type matches "expect". */
static inline bencode_item_t *bencode_dictionary_get_expect(bencode_item_t *dict, const char *key, bencode_type_t expect); INLINE bencode_item_t *bencode_dictionary_get_expect(bencode_item_t *dict, const char *key, bencode_type_t expect);
@ -350,89 +352,89 @@ static inline bencode_item_t *bencode_dictionary_get_expect(bencode_item_t *dict
/**************************/ /**************************/
static inline bencode_buffer_t *bencode_item_buffer(bencode_item_t *i) { INLINE bencode_buffer_t *bencode_item_buffer(bencode_item_t *i) {
if (!i) if (!i)
return NULL; return NULL;
return i->buffer; return i->buffer;
} }
static inline bencode_item_t *bencode_string(bencode_buffer_t *buf, const char *s) { INLINE bencode_item_t *bencode_string(bencode_buffer_t *buf, const char *s) {
return bencode_string_len(buf, s, strlen(s)); return bencode_string_len(buf, s, strlen(s));
} }
static inline bencode_item_t *bencode_string_dup(bencode_buffer_t *buf, const char *s) { INLINE bencode_item_t *bencode_string_dup(bencode_buffer_t *buf, const char *s) {
return bencode_string_len_dup(buf, s, strlen(s)); return bencode_string_len_dup(buf, s, strlen(s));
} }
static inline bencode_item_t *bencode_str(bencode_buffer_t *buf, const str *s) { INLINE bencode_item_t *bencode_str(bencode_buffer_t *buf, const str *s) {
return bencode_string_len(buf, s->s, s->len); return bencode_string_len(buf, s->s, s->len);
} }
static inline bencode_item_t *bencode_str_dup(bencode_buffer_t *buf, const str *s) { INLINE bencode_item_t *bencode_str_dup(bencode_buffer_t *buf, const str *s) {
return bencode_string_len_dup(buf, s->s, s->len); return bencode_string_len_dup(buf, s->s, s->len);
} }
static inline bencode_item_t *bencode_dictionary_add(bencode_item_t *dict, const char *key, bencode_item_t *val) { INLINE bencode_item_t *bencode_dictionary_add(bencode_item_t *dict, const char *key, bencode_item_t *val) {
if (!key) if (!key)
return NULL; return NULL;
return bencode_dictionary_add_len(dict, key, strlen(key), val); return bencode_dictionary_add_len(dict, key, strlen(key), val);
} }
static inline bencode_item_t *bencode_dictionary_add_string(bencode_item_t *dict, const char *key, const char *val) { INLINE bencode_item_t *bencode_dictionary_add_string(bencode_item_t *dict, const char *key, const char *val) {
if (!val) if (!val)
return NULL; return NULL;
return bencode_dictionary_add(dict, key, bencode_string(bencode_item_buffer(dict), val)); return bencode_dictionary_add(dict, key, bencode_string(bencode_item_buffer(dict), val));
} }
static inline bencode_item_t *bencode_dictionary_add_string_dup(bencode_item_t *dict, const char *key, const char *val) { INLINE bencode_item_t *bencode_dictionary_add_string_dup(bencode_item_t *dict, const char *key, const char *val) {
if (!val) if (!val)
return NULL; return NULL;
return bencode_dictionary_add(dict, key, bencode_string_dup(bencode_item_buffer(dict), val)); return bencode_dictionary_add(dict, key, bencode_string_dup(bencode_item_buffer(dict), val));
} }
static inline bencode_item_t *bencode_dictionary_add_str(bencode_item_t *dict, const char *key, const str *val) { INLINE bencode_item_t *bencode_dictionary_add_str(bencode_item_t *dict, const char *key, const str *val) {
if (!val) if (!val)
return NULL; return NULL;
return bencode_dictionary_add(dict, key, bencode_str(bencode_item_buffer(dict), val)); return bencode_dictionary_add(dict, key, bencode_str(bencode_item_buffer(dict), val));
} }
static inline bencode_item_t *bencode_dictionary_add_str_dup(bencode_item_t *dict, const char *key, const str *val) { INLINE bencode_item_t *bencode_dictionary_add_str_dup(bencode_item_t *dict, const char *key, const str *val) {
if (!val) if (!val)
return NULL; return NULL;
return bencode_dictionary_add(dict, key, bencode_str_dup(bencode_item_buffer(dict), val)); return bencode_dictionary_add(dict, key, bencode_str_dup(bencode_item_buffer(dict), val));
} }
static inline bencode_item_t *bencode_dictionary_add_integer(bencode_item_t *dict, const char *key, long long int val) { INLINE bencode_item_t *bencode_dictionary_add_integer(bencode_item_t *dict, const char *key, long long int val) {
return bencode_dictionary_add(dict, key, bencode_integer(bencode_item_buffer(dict), val)); return bencode_dictionary_add(dict, key, bencode_integer(bencode_item_buffer(dict), val));
} }
static inline bencode_item_t *bencode_dictionary_add_dictionary(bencode_item_t *dict, const char *key) { INLINE bencode_item_t *bencode_dictionary_add_dictionary(bencode_item_t *dict, const char *key) {
return bencode_dictionary_add(dict, key, bencode_dictionary(bencode_item_buffer(dict))); return bencode_dictionary_add(dict, key, bencode_dictionary(bencode_item_buffer(dict)));
} }
static inline bencode_item_t *bencode_dictionary_add_list(bencode_item_t *dict, const char *key) { INLINE bencode_item_t *bencode_dictionary_add_list(bencode_item_t *dict, const char *key) {
return bencode_dictionary_add(dict, key, bencode_list(bencode_item_buffer(dict))); return bencode_dictionary_add(dict, key, bencode_list(bencode_item_buffer(dict)));
} }
static inline bencode_item_t *bencode_list_add_string(bencode_item_t *list, const char *s) { INLINE bencode_item_t *bencode_list_add_string(bencode_item_t *list, const char *s) {
return bencode_list_add(list, bencode_string(bencode_item_buffer(list), s)); return bencode_list_add(list, bencode_string(bencode_item_buffer(list), s));
} }
static inline bencode_item_t *bencode_list_add_list(bencode_item_t *list) { INLINE bencode_item_t *bencode_list_add_list(bencode_item_t *list) {
return bencode_list_add(list, bencode_list(bencode_item_buffer(list))); return bencode_list_add(list, bencode_list(bencode_item_buffer(list)));
} }
static inline bencode_item_t *bencode_list_add_dictionary(bencode_item_t *list) { INLINE bencode_item_t *bencode_list_add_dictionary(bencode_item_t *list) {
return bencode_list_add(list, bencode_dictionary(bencode_item_buffer(list))); return bencode_list_add(list, bencode_dictionary(bencode_item_buffer(list)));
} }
static inline bencode_item_t *bencode_dictionary_get(bencode_item_t *dict, const char *key) { INLINE bencode_item_t *bencode_dictionary_get(bencode_item_t *dict, const char *key) {
if (!key) if (!key)
return NULL; return NULL;
return bencode_dictionary_get_len(dict, key, strlen(key)); return bencode_dictionary_get_len(dict, key, strlen(key));
} }
static inline char *bencode_dictionary_get_string(bencode_item_t *dict, const char *key, int *len) { INLINE char *bencode_dictionary_get_string(bencode_item_t *dict, const char *key, int *len) {
bencode_item_t *val; bencode_item_t *val;
val = bencode_dictionary_get(dict, key); val = bencode_dictionary_get(dict, key);
if (!val || val->type != BENCODE_STRING) if (!val || val->type != BENCODE_STRING)
@ -441,14 +443,14 @@ static inline char *bencode_dictionary_get_string(bencode_item_t *dict, const ch
return val->iov[1].iov_base; return val->iov[1].iov_base;
} }
static inline char *bencode_dictionary_get_str(bencode_item_t *dict, const char *key, str *str) { INLINE char *bencode_dictionary_get_str(bencode_item_t *dict, const char *key, str *str) {
str->s = bencode_dictionary_get_string(dict, key, &str->len); str->s = bencode_dictionary_get_string(dict, key, &str->len);
if (!str->s) if (!str->s)
str->len = 0; str->len = 0;
return str->s; return str->s;
} }
static inline char *bencode_dictionary_get_string_dup(bencode_item_t *dict, const char *key, int *len) { INLINE char *bencode_dictionary_get_string_dup(bencode_item_t *dict, const char *key, int *len) {
const char *s; const char *s;
char *ret; char *ret;
s = bencode_dictionary_get_string(dict, key, len); s = bencode_dictionary_get_string(dict, key, len);
@ -461,12 +463,12 @@ static inline char *bencode_dictionary_get_string_dup(bencode_item_t *dict, cons
return ret; return ret;
} }
static inline char *bencode_dictionary_get_str_dup(bencode_item_t *dict, const char *key, str *str) { INLINE char *bencode_dictionary_get_str_dup(bencode_item_t *dict, const char *key, str *str) {
str->s = bencode_dictionary_get_string_dup(dict, key, &str->len); str->s = bencode_dictionary_get_string_dup(dict, key, &str->len);
return str->s; return str->s;
} }
static inline long long int bencode_dictionary_get_integer(bencode_item_t *dict, const char *key, long long int defval) { INLINE long long int bencode_dictionary_get_integer(bencode_item_t *dict, const char *key, long long int defval) {
bencode_item_t *val; bencode_item_t *val;
val = bencode_dictionary_get(dict, key); val = bencode_dictionary_get(dict, key);
if (!val || val->type != BENCODE_INTEGER) if (!val || val->type != BENCODE_INTEGER)
@ -474,7 +476,7 @@ static inline long long int bencode_dictionary_get_integer(bencode_item_t *dict,
return val->value; return val->value;
} }
static inline bencode_item_t *bencode_decode_expect(bencode_buffer_t *buf, const char *s, int len, bencode_type_t expect) { INLINE bencode_item_t *bencode_decode_expect(bencode_buffer_t *buf, const char *s, int len, bencode_type_t expect) {
bencode_item_t *ret; bencode_item_t *ret;
ret = bencode_decode(buf, s, len); ret = bencode_decode(buf, s, len);
if (!ret || ret->type != expect) if (!ret || ret->type != expect)
@ -482,22 +484,22 @@ static inline bencode_item_t *bencode_decode_expect(bencode_buffer_t *buf, const
return ret; return ret;
} }
static inline bencode_item_t *bencode_decode_expect_str(bencode_buffer_t *buf, const str *s, bencode_type_t expect) { INLINE bencode_item_t *bencode_decode_expect_str(bencode_buffer_t *buf, const str *s, bencode_type_t expect) {
return bencode_decode_expect(buf, s->s, s->len, expect); return bencode_decode_expect(buf, s->s, s->len, expect);
} }
static inline bencode_item_t *bencode_dictionary_get_expect(bencode_item_t *dict, const char *key, bencode_type_t expect) { INLINE bencode_item_t *bencode_dictionary_get_expect(bencode_item_t *dict, const char *key, bencode_type_t expect) {
bencode_item_t *ret; bencode_item_t *ret;
ret = bencode_dictionary_get(dict, key); ret = bencode_dictionary_get(dict, key);
if (!ret || ret->type != expect) if (!ret || ret->type != expect)
return NULL; return NULL;
return ret; return ret;
} }
static inline str *bencode_collapse_str(bencode_item_t *root, str *out) { INLINE str *bencode_collapse_str(bencode_item_t *root, str *out) {
out->s = bencode_collapse(root, &out->len); out->s = bencode_collapse(root, &out->len);
return out; return out;
} }
static inline int bencode_strcmp(bencode_item_t *a, const char *b) { INLINE int bencode_strcmp(bencode_item_t *a, const char *b) {
int len; int len;
if (a->type != BENCODE_STRING) if (a->type != BENCODE_STRING)
return 2; return 2;
@ -508,7 +510,7 @@ static inline int bencode_strcmp(bencode_item_t *a, const char *b) {
return 1; return 1;
return memcmp(a->iov[1].iov_base, b, len); return memcmp(a->iov[1].iov_base, b, len);
} }
static inline int bencode_dictionary_get_strcmp(bencode_item_t *dict, const char *key, const char *str) { INLINE int bencode_dictionary_get_strcmp(bencode_item_t *dict, const char *key, const char *str) {
bencode_item_t *i; bencode_item_t *i;
i = bencode_dictionary_get(dict, key); i = bencode_dictionary_get(dict, key);
if (!i) if (!i)
@ -516,7 +518,7 @@ static inline int bencode_dictionary_get_strcmp(bencode_item_t *dict, const char
return bencode_strcmp(i, str); return bencode_strcmp(i, str);
} }
static inline str *bencode_get_str(bencode_item_t *in, str *out) { INLINE str *bencode_get_str(bencode_item_t *in, str *out) {
if (!in || in->type != BENCODE_STRING) if (!in || in->type != BENCODE_STRING)
return NULL; return NULL;
out->s = in->iov[1].iov_base; out->s = in->iov[1].iov_base;
@ -524,7 +526,7 @@ static inline str *bencode_get_str(bencode_item_t *in, str *out) {
return out; return out;
} }
static inline bencode_item_t *bencode_dictionary_add_iovec(bencode_item_t *dict, const char *key, INLINE bencode_item_t *bencode_dictionary_add_iovec(bencode_item_t *dict, const char *key,
const struct iovec *iov, int iov_cnt, int str_len) const struct iovec *iov, int iov_cnt, int str_len)
{ {
return bencode_dictionary_add(dict, key, bencode_string_iovec(bencode_item_buffer(dict), iov, iov_cnt, str_len)); return bencode_dictionary_add(dict, key, bencode_string_iovec(bencode_item_buffer(dict), iov, iov_cnt, str_len));

23
daemon/call.h
Unescape View File

@ -9,6 +9,7 @@
#include <time.h> #include <time.h>
#include <pcre.h> #include <pcre.h>
#include <openssl/x509.h> #include <openssl/x509.h>
#include "compat.h"
@ -369,7 +370,7 @@ const struct transport_protocol *transport_protocol(const str *s);
static inline void *call_malloc(struct call *c, size_t l) { INLINE void *call_malloc(struct call *c, size_t l) {
void *ret; void *ret;
mutex_lock(&c->buffer_lock); mutex_lock(&c->buffer_lock);
ret = call_buffer_alloc(&c->buffer, l); ret = call_buffer_alloc(&c->buffer, l);
@ -377,7 +378,7 @@ static inline void *call_malloc(struct call *c, size_t l) {
return ret; return ret;
} }
static inline char *call_strdup_len(struct call *c, const char *s, unsigned int len) { INLINE char *call_strdup_len(struct call *c, const char *s, unsigned int len) {
char *r; char *r;
r = call_malloc(c, len + 1); r = call_malloc(c, len + 1);
memcpy(r, s, len); memcpy(r, s, len);
@ -385,12 +386,12 @@ static inline char *call_strdup_len(struct call *c, const char *s, unsigned int
return r; return r;
} }
static inline char *call_strdup(struct call *c, const char *s) { INLINE char *call_strdup(struct call *c, const char *s) {
if (!s) if (!s)
return NULL; return NULL;
return call_strdup_len(c, s, strlen(s)); return call_strdup_len(c, s, strlen(s));
} }
static inline str *call_str_cpy_len(struct call *c, str *out, const char *in, int len) { INLINE str *call_str_cpy_len(struct call *c, str *out, const char *in, int len) {
if (!in) { if (!in) {
*out = STR_NULL; *out = STR_NULL;
return out; return out;
@ -399,33 +400,33 @@ static inline str *call_str_cpy_len(struct call *c, str *out, const char *in, in
out->len = len; out->len = len;
return out; return out;
} }
static inline str *call_str_cpy(struct call *c, str *out, const str *in) { INLINE str *call_str_cpy(struct call *c, str *out, const str *in) {
return call_str_cpy_len(c, out, in ? in->s : NULL, in ? in->len : 0); return call_str_cpy_len(c, out, in ? in->s : NULL, in ? in->len : 0);
} }
static inline str *call_str_cpy_c(struct call *c, str *out, const char *in) { INLINE str *call_str_cpy_c(struct call *c, str *out, const char *in) {
return call_str_cpy_len(c, out, in, in ? strlen(in) : 0); return call_str_cpy_len(c, out, in, in ? strlen(in) : 0);
} }
static inline str *call_str_dup(struct call *c, const str *in) { INLINE str *call_str_dup(struct call *c, const str *in) {
str *out; str *out;
out = call_malloc(c, sizeof(*out)); out = call_malloc(c, sizeof(*out));
call_str_cpy_len(c, out, in->s, in->len); call_str_cpy_len(c, out, in->s, in->len);
return out; return out;
} }
static inline str *call_str_init_dup(struct call *c, char *s) { INLINE str *call_str_init_dup(struct call *c, char *s) {
str t; str t;
str_init(&t, s); str_init(&t, s);
return call_str_dup(c, &t); return call_str_dup(c, &t);
} }
static inline int callmaster_has_ipv6(struct callmaster *m) { INLINE int callmaster_has_ipv6(struct callmaster *m) {
return is_addr_unspecified(&m->conf.ipv6) ? 0 : 1; return is_addr_unspecified(&m->conf.ipv6) ? 0 : 1;
} }
static inline void callmaster_exclude_port(struct callmaster *m, u_int16_t p) { INLINE void callmaster_exclude_port(struct callmaster *m, u_int16_t p) {
/* XXX atomic bit field? */ /* XXX atomic bit field? */
mutex_lock(&m->portlock); mutex_lock(&m->portlock);
bit_array_set(m->ports_used, p); bit_array_set(m->ports_used, p);
mutex_unlock(&m->portlock); mutex_unlock(&m->portlock);
} }
static inline struct packet_stream *packet_stream_sink(struct packet_stream *ps) { INLINE struct packet_stream *packet_stream_sink(struct packet_stream *ps) {
struct packet_stream *ret; struct packet_stream *ret;
ret = ps->rtp_sink; ret = ps->rtp_sink;
if (!ret) if (!ret)

10
daemon/compat.h
Unescape View File

@ -0,0 +1,10 @@
#ifndef __COMPAT_H__
#define __COMPAT_H__
#if __DEBUG
# define INLINE static inline
#else
# define INLINE static inline __attribute__((always_inline))
#endif
#endif

3
daemon/cookie_cache.c
Unescape View File

@ -3,13 +3,14 @@
#include <time.h> #include <time.h>
#include <glib.h> #include <glib.h>
#include "compat.h"
#include "aux.h" #include "aux.h"
#include "poller.h" #include "poller.h"
#include "str.h" #include "str.h"
static const char *cookie_in_use = "MAGIC"; static const char *cookie_in_use = "MAGIC";
static inline void cookie_cache_state_init(struct cookie_cache_state *s) { INLINE void cookie_cache_state_init(struct cookie_cache_state *s) {
s->cookies = g_hash_table_new(str_hash, str_equal); s->cookies = g_hash_table_new(str_hash, str_equal);
s->chunks = g_string_chunk_new(4 * 1024); s->chunks = g_string_chunk_new(4 * 1024);
} }

21
daemon/crypto.h
Unescape View File

@ -5,6 +5,7 @@
#include <sys/types.h> #include <sys/types.h>
#include <glib.h> #include <glib.h>
#include "compat.h"
#include "str.h" #include "str.h"
@ -92,36 +93,36 @@ extern const int num_crypto_suites;
const struct crypto_suite *crypto_find_suite(const str *); const struct crypto_suite *crypto_find_suite(const str *);
int crypto_gen_session_key(struct crypto_context *, str *, unsigned char, int); int crypto_gen_session_key(struct crypto_context *, str *, unsigned char, int);
static inline int crypto_encrypt_rtp(struct crypto_context *c, struct rtp_header *rtp, INLINE int crypto_encrypt_rtp(struct crypto_context *c, struct rtp_header *rtp,
str *payload, u_int64_t index) str *payload, u_int64_t index)
{ {
return c->params.crypto_suite->encrypt_rtp(c, rtp, payload, index); return c->params.crypto_suite->encrypt_rtp(c, rtp, payload, index);
} }
static inline int crypto_decrypt_rtp(struct crypto_context *c, struct rtp_header *rtp, INLINE int crypto_decrypt_rtp(struct crypto_context *c, struct rtp_header *rtp,
str *payload, u_int64_t index) str *payload, u_int64_t index)
{ {
return c->params.crypto_suite->decrypt_rtp(c, rtp, payload, index); return c->params.crypto_suite->decrypt_rtp(c, rtp, payload, index);
} }
static inline int crypto_encrypt_rtcp(struct crypto_context *c, struct rtcp_packet *rtcp, INLINE int crypto_encrypt_rtcp(struct crypto_context *c, struct rtcp_packet *rtcp,
str *payload, u_int64_t index) str *payload, u_int64_t index)
{ {
return c->params.crypto_suite->encrypt_rtcp(c, rtcp, payload, index); return c->params.crypto_suite->encrypt_rtcp(c, rtcp, payload, index);
} }
static inline int crypto_decrypt_rtcp(struct crypto_context *c, struct rtcp_packet *rtcp, INLINE int crypto_decrypt_rtcp(struct crypto_context *c, struct rtcp_packet *rtcp,
str *payload, u_int64_t index) str *payload, u_int64_t index)
{ {
return c->params.crypto_suite->decrypt_rtcp(c, rtcp, payload, index); return c->params.crypto_suite->decrypt_rtcp(c, rtcp, payload, index);
} }
static inline int crypto_init_session_key(struct crypto_context *c) { INLINE int crypto_init_session_key(struct crypto_context *c) {
return c->params.crypto_suite->session_key_init(c); return c->params.crypto_suite->session_key_init(c);
} }
static inline void crypto_params_cleanup(struct crypto_params *p) { INLINE void crypto_params_cleanup(struct crypto_params *p) {
if (p->mki) if (p->mki)
free(p->mki); free(p->mki);
p->mki = NULL; p->mki = NULL;
} }
static inline void crypto_cleanup(struct crypto_context *c) { INLINE void crypto_cleanup(struct crypto_context *c) {
if (!c->params.crypto_suite) if (!c->params.crypto_suite)
return; return;
if (c->params.crypto_suite->session_key_cleanup) if (c->params.crypto_suite->session_key_cleanup)
@ -129,11 +130,11 @@ static inline void crypto_cleanup(struct crypto_context *c) {
c->have_session_key = 0; c->have_session_key = 0;
crypto_params_cleanup(&c->params); crypto_params_cleanup(&c->params);
} }
static inline void crypto_reset(struct crypto_context *c) { INLINE void crypto_reset(struct crypto_context *c) {
crypto_cleanup(c); crypto_cleanup(c);
c->last_index = 0; c->last_index = 0;
} }
static inline void crypto_params_copy(struct crypto_params *o, const struct crypto_params *i) { INLINE void crypto_params_copy(struct crypto_params *o, const struct crypto_params *i) {
crypto_params_cleanup(o); crypto_params_cleanup(o);
*o = *i; *o = *i;
if (o->mki_len > 255) if (o->mki_len > 255)
@ -143,7 +144,7 @@ static inline void crypto_params_copy(struct crypto_params *o, const struct cryp
memcpy(o->mki, i->mki, i->mki_len); memcpy(o->mki, i->mki, i->mki_len);
} }
} }
static inline void crypto_init(struct crypto_context *c, const struct crypto_params *p) { INLINE void crypto_init(struct crypto_context *c, const struct crypto_params *p) {
crypto_cleanup(c); crypto_cleanup(c);
crypto_params_copy(&c->params, p); crypto_params_copy(&c->params, p);
} }

7
daemon/dtls.h
Unescape View File

@ -8,6 +8,7 @@
#include <openssl/ssl.h> #include <openssl/ssl.h>
#include <openssl/bio.h> #include <openssl/bio.h>
#include "compat.h"
#include "str.h" #include "str.h"
#include "obj.h" #include "obj.h"
@ -70,7 +71,7 @@ void dtls_connection_cleanup(struct dtls_connection *);
static inline void __dtls_hash(const struct dtls_hash_func *hash_func, X509 *cert, unsigned char *out, INLINE void __dtls_hash(const struct dtls_hash_func *hash_func, X509 *cert, unsigned char *out,
unsigned int bufsize) unsigned int bufsize)
{ {
unsigned int n; unsigned int n;
@ -81,11 +82,11 @@ static inline void __dtls_hash(const struct dtls_hash_func *hash_func, X509 *cer
} }
#define dtls_hash(hash_func, cert, outbuf) __dtls_hash(hash_func, cert, outbuf, sizeof(outbuf)) #define dtls_hash(hash_func, cert, outbuf) __dtls_hash(hash_func, cert, outbuf, sizeof(outbuf))
static inline void dtls_fingerprint_hash(struct dtls_fingerprint *fp, X509 *cert) { INLINE void dtls_fingerprint_hash(struct dtls_fingerprint *fp, X509 *cert) {
__dtls_hash(fp->hash_func, cert, fp->digest, sizeof(fp->digest)); __dtls_hash(fp->hash_func, cert, fp->digest, sizeof(fp->digest));
} }
static inline int is_dtls(const str *s) { INLINE int is_dtls(const str *s) {
const unsigned char *b = (const void *) s->s; const unsigned char *b = (const void *) s->s;
if (s->len < 1) if (s->len < 1)

7
daemon/log.h
Unescape View File

@ -4,6 +4,7 @@
#include <syslog.h> #include <syslog.h>
#include <glib.h> #include <glib.h>
#include "compat.h"
@ -38,7 +39,7 @@ void ilog(int prio, const char *fmt, ...)__attribute__ ((format (printf, 2, 3)))
static inline void log_info_clear() { INLINE void log_info_clear() {
switch (log_info.e) { switch (log_info.e) {
case LOG_INFO_NONE: case LOG_INFO_NONE:
return; return;
@ -51,14 +52,14 @@ static inline void log_info_clear() {
} }
log_info.e = LOG_INFO_NONE; log_info.e = LOG_INFO_NONE;
} }
static inline void log_info_call(struct call *c) { INLINE void log_info_call(struct call *c) {
log_info_clear(); log_info_clear();
if (!c) if (!c)
return; return;
log_info.e = LOG_INFO_CALL; log_info.e = LOG_INFO_CALL;
log_info.u.call = __obj_get((void *) c); log_info.u.call = __obj_get((void *) c);
} }
static inline void log_info_stream_fd(struct stream_fd *sfd) { INLINE void log_info_stream_fd(struct stream_fd *sfd) {
log_info_clear(); log_info_clear();
if (!sfd) if (!sfd)
return; return;

37
daemon/obj.h
Unescape View File

@ -8,6 +8,7 @@
#include <string.h> #include <string.h>
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include "compat.h"
@ -51,17 +52,17 @@ struct obj {
#define obj_get_o(a) __obj_get(a,__FILE__,__LINE__) #define obj_get_o(a) __obj_get(a,__FILE__,__LINE__)
#define obj_put_o(a) __obj_put(a,__FILE__,__LINE__) #define obj_put_o(a) __obj_put(a,__FILE__,__LINE__)
static inline void __obj_init(struct obj *o, unsigned int size, void (*free_func)(void *), INLINE void __obj_init(struct obj *o, unsigned int size, void (*free_func)(void *),
const char *type, const char *file, unsigned int line); const char *type, const char *file, unsigned int line);
static inline void *__obj_alloc(unsigned int size, void (*free_func)(void *), INLINE void *__obj_alloc(unsigned int size, void (*free_func)(void *),
const char *type, const char *file, unsigned int line); const char *type, const char *file, unsigned int line);
static inline void *__obj_alloc0(unsigned int size, void (*free_func)(void *), INLINE void *__obj_alloc0(unsigned int size, void (*free_func)(void *),
const char *type, const char *file, unsigned int line); const char *type, const char *file, unsigned int line);
static inline struct obj *__obj_hold(struct obj *o, INLINE struct obj *__obj_hold(struct obj *o,
const char *type, const char *file, unsigned int line); const char *type, const char *file, unsigned int line);
static inline void *__obj_get(struct obj *o, INLINE void *__obj_get(struct obj *o,
const char *type, const char *file, unsigned int line); const char *type, const char *file, unsigned int line);
static inline void __obj_put(struct obj *o,, INLINE void __obj_put(struct obj *o,,
const char *type, const char *file, unsigned int line); const char *type, const char *file, unsigned int line);
#else #else
@ -75,12 +76,12 @@ static inline void __obj_put(struct obj *o,,
#define obj_get_o(a) __obj_get(a) #define obj_get_o(a) __obj_get(a)
#define obj_put_o(a) __obj_put(a) #define obj_put_o(a) __obj_put(a)
static inline void __obj_init(struct obj *o, unsigned int size, void (*free_func)(void *)); INLINE void __obj_init(struct obj *o, unsigned int size, void (*free_func)(void *));
static inline void *__obj_alloc(unsigned int size, void (*free_func)(void *)); INLINE void *__obj_alloc(unsigned int size, void (*free_func)(void *));
static inline void *__obj_alloc0(unsigned int size, void (*free_func)(void *)); INLINE void *__obj_alloc0(unsigned int size, void (*free_func)(void *));
static inline struct obj *__obj_hold(struct obj *o); INLINE struct obj *__obj_hold(struct obj *o);
static inline void *__obj_get(struct obj *o); INLINE void *__obj_get(struct obj *o);
static inline void __obj_put(struct obj *o); INLINE void __obj_put(struct obj *o);
#endif #endif
@ -90,7 +91,7 @@ static inline void __obj_put(struct obj *o);
static inline void __obj_init(struct obj *o, unsigned int size, void (*free_func)(void *) INLINE void __obj_init(struct obj *o, unsigned int size, void (*free_func)(void *)
#if OBJ_DEBUG #if OBJ_DEBUG
, const char *type, const char *file, unsigned int line , const char *type, const char *file, unsigned int line
#endif #endif
@ -105,7 +106,7 @@ static inline void __obj_init(struct obj *o, unsigned int size, void (*free_func
o->size = size; o->size = size;
} }
static inline void *__obj_alloc(unsigned int size, void (*free_func)(void *) INLINE void *__obj_alloc(unsigned int size, void (*free_func)(void *)
#if OBJ_DEBUG #if OBJ_DEBUG
, const char *type, const char *file, unsigned int line , const char *type, const char *file, unsigned int line
#endif #endif
@ -121,7 +122,7 @@ static inline void *__obj_alloc(unsigned int size, void (*free_func)(void *)
return r; return r;
} }
static inline void *__obj_alloc0(unsigned int size, void (*free_func)(void *) INLINE void *__obj_alloc0(unsigned int size, void (*free_func)(void *)
#if OBJ_DEBUG #if OBJ_DEBUG
, const char *type, const char *file, unsigned int line , const char *type, const char *file, unsigned int line
#endif #endif
@ -137,7 +138,7 @@ static inline void *__obj_alloc0(unsigned int size, void (*free_func)(void *)
return r; return r;
} }
static inline struct obj *__obj_hold(struct obj *o INLINE struct obj *__obj_hold(struct obj *o
#if OBJ_DEBUG #if OBJ_DEBUG
, const char *file, unsigned int line , const char *file, unsigned int line
#endif #endif
@ -155,7 +156,7 @@ static inline struct obj *__obj_hold(struct obj *o
return o; return o;
} }
static inline void *__obj_get(struct obj *o INLINE void *__obj_get(struct obj *o
#if OBJ_DEBUG #if OBJ_DEBUG
, const char *file, unsigned int line , const char *file, unsigned int line
#endif #endif
@ -167,7 +168,7 @@ static inline void *__obj_get(struct obj *o
); );
} }
static inline void __obj_put(struct obj *o INLINE void __obj_put(struct obj *o
#if OBJ_DEBUG #if OBJ_DEBUG
, const char *file, unsigned int line , const char *file, unsigned int line
#endif #endif

7
daemon/redis.h
Unescape View File

@ -5,6 +5,7 @@
#include <sys/types.h> #include <sys/types.h>
#include "compat.h"
@ -24,17 +25,17 @@ extern void (*redis_wipe_mod)(struct redis *);
static inline void redis_update(struct call *c, struct redis *r) { INLINE void redis_update(struct call *c, struct redis *r) {
if (!redis_update_mod) if (!redis_update_mod)
return; return;
redis_update_mod(c, r); redis_update_mod(c, r);
} }
static inline void redis_delete(struct call *c, struct redis *r) { INLINE void redis_delete(struct call *c, struct redis *r) {
if (!redis_delete_mod) if (!redis_delete_mod)
return; return;
redis_delete_mod(c, r); redis_delete_mod(c, r);
} }
static inline int redis_restore(struct callmaster *m, struct redis *r) { INLINE int redis_restore(struct callmaster *m, struct redis *r) {
if (!redis_restore_mod) if (!redis_restore_mod)
return 0; return 0;
return redis_restore_mod(m, r); return redis_restore_mod(m, r);

3
daemon/rtcp.c
Unescape View File

@ -5,6 +5,7 @@
#include <sys/types.h> #include <sys/types.h>
#include <glib.h> #include <glib.h>
#include "compat.h"
#include "str.h" #include "str.h"
#include "call.h" #include "call.h"
#include "log.h" #include "log.h"
@ -330,7 +331,7 @@ int rtcp_avpf2avp(str *s) {
} }
static inline int check_session_keys(struct crypto_context *c) { INLINE int check_session_keys(struct crypto_context *c) {
str s; str s;
const char *err; const char *err;

3
daemon/rtp.c
Unescape View File

@ -4,6 +4,7 @@
#include <arpa/inet.h> #include <arpa/inet.h>
#include <glib.h> #include <glib.h>
#include "compat.h"
#include "str.h" #include "str.h"
#include "crypto.h" #include "crypto.h"
#include "log.h" #include "log.h"
@ -19,7 +20,7 @@ struct rtp_extension {
static inline int check_session_keys(struct crypto_context *c) { INLINE int check_session_keys(struct crypto_context *c) {
str s; str s;
const char *err; const char *err;

13
daemon/sdp.c
Unescape View File

@ -6,6 +6,7 @@
#include <arpa/inet.h> #include <arpa/inet.h>
#include <math.h> #include <math.h>
#include "compat.h"
#include "call.h" #include "call.h"
#include "log.h" #include "log.h"
#include "str.h" #include "str.h"
@ -194,7 +195,7 @@ static str ice_foundation_str_alt;
static inline struct sdp_attribute *attr_get_by_id(struct sdp_attributes *a, int id) { INLINE struct sdp_attribute *attr_get_by_id(struct sdp_attributes *a, int id) {
return g_hash_table_lookup(a->id_hash, &id); return g_hash_table_lookup(a->id_hash, &id);
} }
@ -209,7 +210,7 @@ static struct sdp_attribute *attr_get_by_id_m_s(struct sdp_media *m, int id) {
/* hack hack */ /* hack hack */
static inline int inet_pton_str(int af, str *src, void *dst) { INLINE int inet_pton_str(int af, str *src, void *dst) {
char *s = src->s; char *s = src->s;
char p; char p;
int ret; int ret;
@ -278,7 +279,7 @@ static int parse_address(struct network_address *address) {
&address->address_type, &address->address); &address->address_type, &address->address);
} }
static inline int extract_token(char **sp, char *end, str *out) { INLINE int extract_token(char **sp, char *end, str *out) {
char *space; char *space;
out->s = *sp; out->s = *sp;
@ -1076,7 +1077,7 @@ struct sdp_chopper *sdp_chopper_new(str *input) {
return c; return c;
} }
static void chopper_append(struct sdp_chopper *c, const char *s, int len) { INLINE void chopper_append(struct sdp_chopper *c, const char *s, int len) {
struct iovec *iov; struct iovec *iov;
g_array_set_size(c->iov, ++c->iov_num); g_array_set_size(c->iov, ++c->iov_num);
@ -1085,10 +1086,10 @@ static void chopper_append(struct sdp_chopper *c, const char *s, int len) {
iov->iov_len = len; iov->iov_len = len;
c->str_len += len; c->str_len += len;
} }
static inline void chopper_append_c(struct sdp_chopper *c, const char *s) { INLINE void chopper_append_c(struct sdp_chopper *c, const char *s) {
chopper_append(c, s, strlen(s)); chopper_append(c, s, strlen(s));
} }
static inline void chopper_append_str(struct sdp_chopper *c, const str *s) { INLINE void chopper_append_str(struct sdp_chopper *c, const str *s) {
chopper_append(c, s->s, s->len); chopper_append(c, s->s, s->len);
} }

10
daemon/str.c
Unescape View File

@ -1,5 +1,6 @@
#include "str.h" #include "str.h"
#include <assert.h> #include <assert.h>
#include <stdarg.h>
guint str_hash(gconstpointer ss) { guint str_hash(gconstpointer ss) {
const str *s = ss; const str *s = ss;
@ -30,3 +31,12 @@ guint str_hash(gconstpointer ss) {
gboolean str_equal(gconstpointer a, gconstpointer b) { gboolean str_equal(gconstpointer a, gconstpointer b) {
return str_cmp_str((str *) a, (str *) b) == 0; return str_cmp_str((str *) a, (str *) b) == 0;
} }
str *__str_sprintf(const char *fmt, ...) {
str *ret;
va_list ap;
va_start(ap, fmt);
ret = __str_vsprintf(fmt, ap);
va_end(ap);
return ret;
}

77
daemon/str.h
Unescape View File

@ -7,6 +7,7 @@
#include <stdarg.h> #include <stdarg.h>
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#include "compat.h"
@ -28,42 +29,42 @@ typedef struct _str str;
/* returns pointer to end of str (s->s + s->len) */ /* returns pointer to end of str (s->s + s->len) */
static inline char *str_end(const str *s); INLINE char *str_end(const str *s);
/* returns pointer to first occurence of "c" in s */ /* returns pointer to first occurence of "c" in s */
static inline char *str_chr(const str *s, int c); INLINE char *str_chr(const str *s, int c);
/* sets "out" to point to first occurence of c in s. adjusts len also */ /* sets "out" to point to first occurence of c in s. adjusts len also */
static inline str *str_chr_str(str *out, const str *s, int c); INLINE str *str_chr_str(str *out, const str *s, int c);
/* compares a str to a regular string */ /* compares a str to a regular string */
static inline int str_cmp(const str *a, const char *b); INLINE int str_cmp(const str *a, const char *b);
/* compares a str to a non-null-terminated string */ /* compares a str to a non-null-terminated string */
static inline int str_cmp_len(const str *a, const char *b, int len); INLINE int str_cmp_len(const str *a, const char *b, int len);
/* compares two str objects */ /* compares two str objects */
static inline int str_cmp_str(const str *a, const str *b); INLINE int str_cmp_str(const str *a, const str *b);
/* compares two str objects, allows either to be NULL */ /* compares two str objects, allows either to be NULL */
static inline int str_cmp_str0(const str *a, const str *b); INLINE int str_cmp_str0(const str *a, const str *b);
/* inits a str object from a regular string. returns out */ /* inits a str object from a regular string. returns out */
static inline str *str_init(str *out, char *s); INLINE str *str_init(str *out, char *s);
/* inits a str object from any binary string. returns out */ /* inits a str object from any binary string. returns out */
static inline str *str_init_len(str *out, char *s, int len); INLINE str *str_init_len(str *out, char *s, int len);
static inline str *str_init_len_assert_len(str *out, char *s, int buflen, int len); INLINE str *str_init_len_assert_len(str *out, char *s, int buflen, int len);
#define str_init_len_assert(out, s, len) str_init_len_assert_len(out, s, sizeof(s), len) #define str_init_len_assert(out, s, len) str_init_len_assert_len(out, s, sizeof(s), len)
/* returns new str object allocated with malloc, including buffer */ /* returns new str object allocated with malloc, including buffer */
static inline str *str_dup(const str *s); INLINE str *str_dup(const str *s);
/* returns new str object allocated from chunk, including buffer */ /* returns new str object allocated from chunk, including buffer */
static inline str *str_chunk_insert(GStringChunk *c, const str *s); INLINE str *str_chunk_insert(GStringChunk *c, const str *s);
/* shifts pointer by len chars and decrements len. returns -1 if buffer too short, 0 otherwise */ /* shifts pointer by len chars and decrements len. returns -1 if buffer too short, 0 otherwise */
static inline int str_shift(str *s, int len); INLINE int str_shift(str *s, int len);
/* binary compares str object with memory chunk of equal size */ /* binary compares str object with memory chunk of equal size */
static inline int str_memcmp(const str *s, void *m); INLINE int str_memcmp(const str *s, void *m);
/* asprintf() analogs */ /* asprintf() analogs */
#define str_sprintf(fmt, a...) __str_sprintf(STR_MALLOC_PADDING fmt, a) #define str_sprintf(fmt, a...) __str_sprintf(STR_MALLOC_PADDING fmt, a)
#define str_vsprintf(fmt, a) __str_vsprintf(STR_MALLOC_PADDING fmt, a) #define str_vsprintf(fmt, a) __str_vsprintf(STR_MALLOC_PADDING fmt, a)
/* creates a new empty GString that has mem allocated for a new str object */ /* creates a new empty GString that has mem allocated for a new str object */
static inline GString *g_string_new_str(void); INLINE GString *g_string_new_str(void);
/* frees the GString object and returns the new str object */ /* frees the GString object and returns the new str object */
static inline str *g_string_free_str(GString *gs); INLINE str *g_string_free_str(GString *gs);
/* for GHashTables */ /* for GHashTables */
guint str_hash(gconstpointer s); guint str_hash(gconstpointer s);
@ -73,31 +74,31 @@ gboolean str_equal(gconstpointer a, gconstpointer b);
static inline str *str_chunk_insert(GStringChunk *c, const str *s) { INLINE str *str_chunk_insert(GStringChunk *c, const str *s) {
str *i; str *i;
i = (void *) g_string_chunk_insert_len(c, (void *) s, sizeof(*s)); i = (void *) g_string_chunk_insert_len(c, (void *) s, sizeof(*s));
i->s = g_string_chunk_insert_len(c, s->s, s->len); i->s = g_string_chunk_insert_len(c, s->s, s->len);
return i; return i;
} }
static inline char *str_end(const str *s) { INLINE char *str_end(const str *s) {
return s->s + s->len; return s->s + s->len;
} }
static inline int str_shift(str *s, int len) { INLINE int str_shift(str *s, int len) {
if (s->len < len) if (s->len < len)
return -1; return -1;
s->s += len; s->s += len;
s->len -= len; s->len -= len;
return 0; return 0;
} }
static inline char *str_chr(const str *s, int c) { INLINE char *str_chr(const str *s, int c) {
return memchr(s->s, c, s->len); return memchr(s->s, c, s->len);
} }
static inline str *str_chr_str(str *out, const str *s, int c) { INLINE str *str_chr_str(str *out, const str *s, int c) {
out->s = str_chr(s, c); out->s = str_chr(s, c);
out->len = out->s ? (s->len - (out->s - s->s)) : 0; out->len = out->s ? (s->len - (out->s - s->s)) : 0;
return out; return out;
} }
static inline int str_cmp_len(const str *a, const char *b, int l) { INLINE int str_cmp_len(const str *a, const char *b, int l) {
if (a->len < l) if (a->len < l)
return -1; return -1;
if (a->len > l) if (a->len > l)
@ -106,10 +107,10 @@ static inline int str_cmp_len(const str *a, const char *b, int l) {
return 0; return 0;
return memcmp(a->s, b, l); return memcmp(a->s, b, l);
} }
static inline int str_cmp(const str *a, const char *b) { INLINE int str_cmp(const str *a, const char *b) {
return str_cmp_len(a, b, strlen(b)); return str_cmp_len(a, b, strlen(b));
} }
static inline int str_cmp_str(const str *a, const str *b) { INLINE int str_cmp_str(const str *a, const str *b) {
if (a->len < b->len) if (a->len < b->len)
return -1; return -1;
if (a->len > b->len) if (a->len > b->len)
@ -118,7 +119,7 @@ static inline int str_cmp_str(const str *a, const str *b) {
return 0; return 0;
return memcmp(a->s, b->s, a->len); return memcmp(a->s, b->s, a->len);
} }
static inline int str_cmp_str0(const str *a, const str *b) { INLINE int str_cmp_str0(const str *a, const str *b) {
if (!a) { if (!a) {
if (!b) if (!b)
return 0; return 0;
@ -133,21 +134,21 @@ static inline int str_cmp_str0(const str *a, const str *b) {
} }
return str_cmp_str(a, b); return str_cmp_str(a, b);
} }
static inline str *str_init(str *out, char *s) { INLINE str *str_init(str *out, char *s) {
out->s = s; out->s = s;
out->len = s ? strlen(s) : 0; out->len = s ? strlen(s) : 0;
return out; return out;
} }
static inline str *str_init_len(str *out, char *s, int len) { INLINE str *str_init_len(str *out, char *s, int len) {
out->s = s; out->s = s;
out->len = len; out->len = len;
return out; return out;
} }
static inline str *str_init_len_assert_len(str *out, char *s, int buflen, int len) { INLINE str *str_init_len_assert_len(str *out, char *s, int buflen, int len) {
assert(buflen >= len); assert(buflen >= len);
return str_init_len(out, s, len); return str_init_len(out, s, len);
} }
static inline str *str_dup(const str *s) { INLINE str *str_dup(const str *s) {
str *r; str *r;
r = malloc(sizeof(*r) + s->len + 1); r = malloc(sizeof(*r) + s->len + 1);
r->s = ((char *) r) + sizeof(*r); r->s = ((char *) r) + sizeof(*r);
@ -158,7 +159,7 @@ static inline str *str_dup(const str *s) {
} }
#define STR_MALLOC_PADDING "xxxxxxxxxxxxxxxx" #define STR_MALLOC_PADDING "xxxxxxxxxxxxxxxx"
static inline str *__str_vsprintf(const char *fmt, va_list ap) { INLINE str *__str_vsprintf(const char *fmt, va_list ap) {
char *r; char *r;
int l, pl; int l, pl;
str *ret; str *ret;
@ -173,17 +174,9 @@ static inline str *__str_vsprintf(const char *fmt, va_list ap) {
ret->len = l - pl; ret->len = l - pl;
return ret; return ret;
} }
static inline str *__str_sprintf(const char *fmt, ...) __attribute__((format(printf,1,2))); str *__str_sprintf(const char *fmt, ...) __attribute__((format(printf,1,2)));
static inline str *__str_sprintf(const char *fmt, ...) {
str *ret;
va_list ap;
va_start(ap, fmt);
ret = __str_vsprintf(fmt, ap);
va_end(ap);
return ret;
}
static inline GString *g_string_new_str(void) { INLINE GString *g_string_new_str(void) {
int pl; int pl;
GString *ret; GString *ret;
@ -193,7 +186,7 @@ static inline GString *g_string_new_str(void) {
g_string_append_len(ret, STR_MALLOC_PADDING, pl); g_string_append_len(ret, STR_MALLOC_PADDING, pl);
return ret; return ret;
} }
static inline str *g_string_free_str(GString *gs) { INLINE str *g_string_free_str(GString *gs) {
str *ret; str *ret;
int pl; int pl;
@ -206,7 +199,7 @@ static inline str *g_string_free_str(GString *gs) {
g_string_free(gs, FALSE); g_string_free(gs, FALSE);
return ret; return ret;
} }
static inline int str_memcmp(const str *s, void *m) { INLINE int str_memcmp(const str *s, void *m) {
return memcmp(s->s, m, s->len); return memcmp(s->s, m, s->len);
} }

3
daemon/streambuf.h
Unescape View File

@ -8,6 +8,7 @@
#include <glib.h> #include <glib.h>
#include <stdarg.h> #include <stdarg.h>
#include "compat.h"
#include "str.h" #include "str.h"
@ -34,7 +35,7 @@ unsigned int streambuf_bufsize(struct streambuf *);
void streambuf_printf(struct streambuf *, const char *, ...) __attribute__ ((format (printf, 2, 3))); void streambuf_printf(struct streambuf *, const char *, ...) __attribute__ ((format (printf, 2, 3)));
void streambuf_vprintf(struct streambuf *, const char *, va_list); void streambuf_vprintf(struct streambuf *, const char *, va_list);
void streambuf_write(struct streambuf *, const char *, unsigned int); void streambuf_write(struct streambuf *, const char *, unsigned int);
static inline void streambuf_write_str(struct streambuf *b, str *s) { INLINE void streambuf_write_str(struct streambuf *b, str *s) {
streambuf_write(b, s->s, s->len); streambuf_write(b, s->s, s->len);
} }

5
daemon/stun.c
Unescape View File

@ -7,6 +7,7 @@
#include <openssl/hmac.h> #include <openssl/hmac.h>
#include <glib.h> #include <glib.h>
#include "compat.h"
#include "str.h" #include "str.h"
#include "aux.h" #include "aux.h"
#include "log.h" #include "log.h"
@ -196,7 +197,7 @@ static void output_init(struct msghdr *mh, struct iovec *iov, struct sockaddr_in
memcpy(&hdr->transaction, transaction, sizeof(hdr->transaction)); memcpy(&hdr->transaction, transaction, sizeof(hdr->transaction));
} }
static inline void __output_add(struct msghdr *mh, struct tlv *tlv, unsigned int len, u_int16_t code, INLINE void __output_add(struct msghdr *mh, struct tlv *tlv, unsigned int len, u_int16_t code,
void *append, unsigned int append_len) void *append, unsigned int append_len)
{ {
struct iovec *iov; struct iovec *iov;
@ -404,7 +405,7 @@ static int stun_binding_success(int fd, struct header *req, struct stun_attrs *a
return 0; return 0;
} }
static inline int u_int16_t_arr_len(u_int16_t *arr) { INLINE int u_int16_t_arr_len(u_int16_t *arr) {
int i; int i;
for (i = 0; arr[i] != 0xffff; i++) for (i = 0; arr[i] != 0xffff; i++)
; ;

3
daemon/stun.h
Unescape View File

@ -4,6 +4,7 @@
#include <string.h> #include <string.h>
#include <arpa/inet.h> #include <arpa/inet.h>
#include "compat.h"
#include "call.h" #include "call.h"
#include "str.h" #include "str.h"
@ -11,7 +12,7 @@
#define STUN_COOKIE 0x2112A442UL #define STUN_COOKIE 0x2112A442UL
static inline int is_stun(const str *s) { INLINE int is_stun(const str *s) {
const unsigned char *b = (const void *) s->s; const unsigned char *b = (const void *) s->s;
const u_int32_t *u; const u_int32_t *u;

Write Preview
Loading…
Cancel
Save