diff options
| -rw-r--r-- | channels/chan_iax2.c | 371 | ||||
| -rw-r--r-- | include/asterisk/dlinkedlists.h | 974 |
2 files changed, 1222 insertions, 123 deletions
diff --git a/channels/chan_iax2.c b/channels/chan_iax2.c index deec4c069..4fd32533e 100644 --- a/channels/chan_iax2.c +++ b/channels/chan_iax2.c @@ -95,6 +95,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$") #include "asterisk/netsock.h" #include "asterisk/stringfields.h" #include "asterisk/linkedlists.h" +#include "asterisk/dlinkedlists.h" #include "asterisk/astobj2.h" #include "iax2.h" @@ -622,6 +623,8 @@ struct chan_iax2_pvt { int frames_dropped; /*! received frame count: (just for stats) */ int frames_received; + + AST_DLLIST_ENTRY(chan_iax2_pvt) entry; }; static struct ast_iax2_queue { @@ -809,6 +812,17 @@ static struct chan_iax2_pvt *iaxs[IAX_MAX_CALLS]; static ast_mutex_t iaxsl[ARRAY_LEN(iaxs)]; static struct timeval lastused[ARRAY_LEN(iaxs)]; +/*! + * \brief Another container of iax2_pvt structures + * + * Active IAX2 pvt structs are also stored in this container, if they are a part + * of an active call where we know the remote side's call number. The reason + * for this is that incoming media frames do not contain our call number. So, + * instead of having to iterate the entire iaxs array, we use this container to + * look up calls where the remote side is using a given call number. + */ +static struct ao2_container *iax_peercallno_pvts; + /* Flag to use with trunk calls, keeping these calls high up. It halves our effective use but keeps the division between trunked and non-trunked better. */ #define TRUNK_CALL_START ARRAY_LEN(iaxs) / 2 @@ -1183,16 +1197,179 @@ static int iax2_getpeername(struct sockaddr_in sin, char *host, int len) return res; } +static void iax2_destroy_helper(struct chan_iax2_pvt *pvt) +{ + /* Decrement AUTHREQ count if needed */ + if (ast_test_flag(pvt, IAX_MAXAUTHREQ)) { + struct iax2_user *user; + struct iax2_user tmp_user = { + .name = pvt->username, + }; + + user = ao2_find(users, &tmp_user, OBJ_POINTER); + if (user) { + ast_atomic_fetchadd_int(&user->curauthreq, -1); + user = user_unref(user); + } + + ast_clear_flag(pvt, IAX_MAXAUTHREQ); + } + + /* No more pings or lagrq's */ + AST_SCHED_DEL(sched, pvt->pingid); + AST_SCHED_DEL(sched, pvt->lagid); + AST_SCHED_DEL(sched, pvt->autoid); + AST_SCHED_DEL(sched, pvt->authid); + AST_SCHED_DEL(sched, pvt->initid); + AST_SCHED_DEL(sched, pvt->jbid); +} + +static void store_by_peercallno(struct chan_iax2_pvt *pvt) +{ + if (!pvt->peercallno) { + ast_log(LOG_ERROR, "This should not be called without a peer call number.\n"); + return; + } + + ao2_link(iax_peercallno_pvts, pvt); +} + +static void remove_by_peercallno(struct chan_iax2_pvt *pvt) +{ + if (!pvt->peercallno) { + ast_log(LOG_ERROR, "This should not be called without a peer call number.\n"); + return; + } + + ao2_unlink(iax_peercallno_pvts, pvt); +} + +static void update_max_trunk(void) +{ + int max = TRUNK_CALL_START; + int x; + + /* XXX Prolly don't need locks here XXX */ + for (x = TRUNK_CALL_START; x < ARRAY_LEN(iaxs) - 1; x++) { + if (iaxs[x]) { + max = x + 1; + } + } + + maxtrunkcall = max; + if (option_debug && iaxdebug) + ast_log(LOG_DEBUG, "New max trunk callno is %d\n", max); +} + +static void iax2_frame_free(struct iax_frame *fr) +{ + AST_SCHED_DEL(sched, fr->retrans); + iax_frame_free(fr); +} + +static void iax2_destroy(int callno) +{ + struct chan_iax2_pvt *pvt; + struct ast_channel *owner; + +retry: + pvt = iaxs[callno]; + gettimeofday(&lastused[callno], NULL); + + owner = pvt ? pvt->owner : NULL; + + if (owner) { + if (ast_mutex_trylock(&owner->lock)) { + ast_log(LOG_NOTICE, "Avoiding IAX destroy deadlock\n"); + ast_mutex_unlock(&iaxsl[callno]); + usleep(1); + ast_mutex_lock(&iaxsl[callno]); + goto retry; + } + } + if (!owner) { + iaxs[callno] = NULL; + } + + if (pvt) { + if (!owner) { + pvt->owner = NULL; + } else { + /* If there's an owner, prod it to give up */ + /* It is ok to use ast_queue_hangup() here instead of iax2_queue_hangup() + * because we already hold the owner channel lock. */ + ast_queue_hangup(owner); + } + + if (pvt->peercallno) { + remove_by_peercallno(pvt); + } + + if (!owner) { + ao2_ref(pvt, -1); + pvt = NULL; + } + } + + if (owner) { + ast_mutex_unlock(&owner->lock); + } + + if (callno & 0x4000) { + update_max_trunk(); + } +} + +static void pvt_destructor(void *obj) +{ + struct chan_iax2_pvt *pvt = obj; + struct iax_frame *cur = NULL; + + iax2_destroy_helper(pvt); + + /* Already gone */ + ast_set_flag(pvt, IAX_ALREADYGONE); + + AST_LIST_LOCK(&iaxq.queue); + AST_LIST_TRAVERSE(&iaxq.queue, cur, list) { + /* Cancel any pending transmissions */ + if (cur->callno == pvt->callno) { + cur->retries = -1; + } + } + AST_LIST_UNLOCK(&iaxq.queue); + + if (pvt->reg) { + pvt->reg->callno = 0; + } + + if (!pvt->owner) { + jb_frame frame; + if (pvt->vars) { + ast_variables_destroy(pvt->vars); + pvt->vars = NULL; + } + + while (jb_getall(pvt->jb, &frame) == JB_OK) { + iax2_frame_free(frame.data); + } + + jb_destroy(pvt->jb); + ast_string_field_free_memory(pvt); + } +} + static struct chan_iax2_pvt *new_iax(struct sockaddr_in *sin, const char *host) { struct chan_iax2_pvt *tmp; jb_conf jbconf; - if (!(tmp = ast_calloc(1, sizeof(*tmp)))) + if (!(tmp = ao2_alloc(sizeof(*tmp), pvt_destructor))) { return NULL; + } if (ast_string_field_init(tmp, 32)) { - free(tmp); + ao2_ref(tmp, -1); tmp = NULL; return NULL; } @@ -1261,23 +1438,6 @@ static int match(struct sockaddr_in *sin, unsigned short callno, unsigned short return 0; } -static void update_max_trunk(void) -{ - int max = TRUNK_CALL_START; - int x; - - /* XXX Prolly don't need locks here XXX */ - for (x = TRUNK_CALL_START; x < ARRAY_LEN(iaxs) - 1; x++) { - if (iaxs[x]) { - max = x + 1; - } - } - - maxtrunkcall = max; - if (option_debug && iaxdebug) - ast_log(LOG_DEBUG, "New max trunk callno is %d\n", max); -} - static void update_max_nontrunk(void) { int max = 1; @@ -1349,6 +1509,28 @@ static int __find_callno(unsigned short callno, unsigned short dcallno, struct s char host[80]; if (new <= NEW_ALLOW) { + if (callno) { + struct chan_iax2_pvt *pvt; + struct chan_iax2_pvt tmp_pvt = { + .callno = dcallno, + .peercallno = callno, + /* hack!! */ + .frames_received = full_frame, + }; + + memcpy(&tmp_pvt.addr, sin, sizeof(tmp_pvt.addr)); + + if ((pvt = ao2_find(iax_peercallno_pvts, &tmp_pvt, OBJ_POINTER))) { + if (return_locked) { + ast_mutex_lock(&iaxsl[pvt->callno]); + } + res = pvt->callno; + ao2_ref(pvt, -1); + pvt = NULL; + return res; + } + } + /* Look for an existing connection first */ for (x = 1; !res && x < maxnontrunkcall; x++) { ast_mutex_lock(&iaxsl[x]); @@ -1431,6 +1613,10 @@ static int __find_callno(unsigned short callno, unsigned short dcallno, struct s ast_string_field_set(iaxs[x], accountcode, accountcode); ast_string_field_set(iaxs[x], mohinterpret, mohinterpret); ast_string_field_set(iaxs[x], mohsuggest, mohsuggest); + + if (iaxs[x]->peercallno) { + store_by_peercallno(iaxs[x]); + } } else { ast_log(LOG_WARNING, "Out of resources\n"); ast_mutex_unlock(&iaxsl[x]); @@ -1453,12 +1639,6 @@ static int find_callno_locked(unsigned short callno, unsigned short dcallno, str return __find_callno(callno, dcallno, sin, new, sockfd, 1, full_frame); } -static void iax2_frame_free(struct iax_frame *fr) -{ - AST_SCHED_DEL(sched, fr->retrans); - iax_frame_free(fr); -} - /*! * \brief Queue a frame to a call's owning asterisk channel * @@ -1923,32 +2103,6 @@ static int send_packet(struct iax_frame *f) return res; } -static void iax2_destroy_helper(struct chan_iax2_pvt *pvt) -{ - /* Decrement AUTHREQ count if needed */ - if (ast_test_flag(pvt, IAX_MAXAUTHREQ)) { - struct iax2_user *user; - struct iax2_user tmp_user = { - .name = pvt->username, - }; - - user = ao2_find(users, &tmp_user, OBJ_POINTER); - if (user) { - ast_atomic_fetchadd_int(&user->curauthreq, -1); - user_unref(user); - } - - ast_clear_flag(pvt, IAX_MAXAUTHREQ); - } - /* No more pings or lagrq's */ - AST_SCHED_DEL(sched, pvt->pingid); - AST_SCHED_DEL(sched, pvt->lagid); - AST_SCHED_DEL(sched, pvt->autoid); - AST_SCHED_DEL(sched, pvt->authid); - AST_SCHED_DEL(sched, pvt->initid); - AST_SCHED_DEL(sched, pvt->jbid); -} - /*! * \note Since this function calls iax2_queue_hangup(), the pvt struct * for the given call number may disappear during its execution. @@ -1974,76 +2128,6 @@ static int iax2_predestroy(int callno) return 0; } -static void iax2_destroy(int callno) -{ - struct chan_iax2_pvt *pvt; - struct iax_frame *cur; - struct ast_channel *owner; - -retry: - pvt = iaxs[callno]; - gettimeofday(&lastused[callno], NULL); - - owner = pvt ? pvt->owner : NULL; - - if (owner) { - if (ast_mutex_trylock(&owner->lock)) { - ast_log(LOG_NOTICE, "Avoiding IAX destroy deadlock\n"); - ast_mutex_unlock(&iaxsl[callno]); - usleep(1); - ast_mutex_lock(&iaxsl[callno]); - goto retry; - } - } - if (!owner) - iaxs[callno] = NULL; - if (pvt) { - if (!owner) - pvt->owner = NULL; - iax2_destroy_helper(pvt); - - /* Already gone */ - ast_set_flag(pvt, IAX_ALREADYGONE); - - if (owner) { - /* If there's an owner, prod it to give up */ - /* It is ok to use ast_queue_hangup() here instead of iax2_queue_hangup() - * because we already hold the owner channel lock. */ - ast_queue_hangup(owner); - } - - AST_LIST_LOCK(&iaxq.queue); - AST_LIST_TRAVERSE(&iaxq.queue, cur, list) { - /* Cancel any pending transmissions */ - if (cur->callno == pvt->callno) - cur->retries = -1; - } - AST_LIST_UNLOCK(&iaxq.queue); - - if (pvt->reg) - pvt->reg->callno = 0; - if (!owner) { - jb_frame frame; - if (pvt->vars) { - ast_variables_destroy(pvt->vars); - pvt->vars = NULL; - } - - while (jb_getall(pvt->jb, &frame) == JB_OK) - iax2_frame_free(frame.data); - jb_destroy(pvt->jb); - /* gotta free up the stringfields */ - ast_string_field_free_memory(pvt); - free(pvt); - } - } - if (owner) { - ast_mutex_unlock(&owner->lock); - } - if (callno & 0x4000) - update_max_trunk(); -} - static int update_packet(struct iax_frame *f) { /* Called with iaxsl lock held, and iaxs[callno] non-NULL */ @@ -5741,7 +5825,13 @@ static int complete_transfer(int callno, struct iax_ies *ies) pvt->rseqno = 0; pvt->iseqno = 0; pvt->aseqno = 0; + + if (pvt->peercallno) { + remove_by_peercallno(pvt); + } pvt->peercallno = peercallno; + store_by_peercallno(pvt); + pvt->transferring = TRANSFER_NONE; pvt->svoiceformat = -1; pvt->voiceformat = 0; @@ -7077,8 +7167,18 @@ static int socket_process(struct iax2_thread *thread) if (!inaddrcmp(&sin, &iaxs[fr->callno]->addr) && !minivid && f.subclass != IAX_COMMAND_TXCNT && /* for attended transfer */ - f.subclass != IAX_COMMAND_TXACC) /* for attended transfer */ - iaxs[fr->callno]->peercallno = (unsigned short)(ntohs(mh->callno) & ~IAX_FLAG_FULL); + f.subclass != IAX_COMMAND_TXACC) { /* for attended transfer */ + unsigned short new_peercallno; + + new_peercallno = (unsigned short) (ntohs(mh->callno) & ~IAX_FLAG_FULL); + if (new_peercallno && new_peercallno != iaxs[fr->callno]->peercallno) { + if (iaxs[fr->callno]->peercallno) { + remove_by_peercallno(iaxs[fr->callno]); + } + iaxs[fr->callno]->peercallno = new_peercallno; + store_by_peercallno(iaxs[fr->callno]); + } + } if (ntohs(mh->callno) & IAX_FLAG_FULL) { if (option_debug && iaxdebug) ast_log(LOG_DEBUG, "Received packet %d, (%d, %d)\n", fh->oseqno, f.frametype, f.subclass); @@ -10873,6 +10973,7 @@ static int __unload_module(void) ao2_ref(peers, -1); ao2_ref(users, -1); + ao2_ref(iax_peercallno_pvts, -1); return 0; } @@ -10893,6 +10994,24 @@ static int peer_set_sock_cb(void *obj, void *arg, int flags) return 0; } +static int pvt_hash_cb(const void *obj, const int flags) +{ + const struct chan_iax2_pvt *pvt = obj; + + return pvt->peercallno; +} + +static int pvt_cmp_cb(void *obj, void *arg, int flags) +{ + struct chan_iax2_pvt *pvt = obj, *pvt2 = arg; + + /* The frames_received field is used to hold whether we're matching + * against a full frame or not ... */ + + return match(&pvt2->addr, pvt2->peercallno, pvt2->callno, pvt, + pvt2->frames_received) ? CMP_MATCH : 0; +} + /*! \brief Load IAX2 module, load configuraiton ---*/ static int load_module(void) { @@ -10909,6 +11028,12 @@ static int load_module(void) ao2_ref(peers, -1); return AST_MODULE_LOAD_FAILURE; } + iax_peercallno_pvts = ao2_container_alloc(IAX_MAX_CALLS, pvt_hash_cb, pvt_cmp_cb); + if (!iax_peercallno_pvts) { + ao2_ref(peers, -1); + ao2_ref(users, -1); + return AST_MODULE_LOAD_FAILURE; + } ast_custom_function_register(&iaxpeer_function); diff --git a/include/asterisk/dlinkedlists.h b/include/asterisk/dlinkedlists.h new file mode 100644 index 000000000..2f42fdd39 --- /dev/null +++ b/include/asterisk/dlinkedlists.h @@ -0,0 +1,974 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 2007, Digium, Inc. + * + * Steve Murphy <murf@digium.com> + * + * Doubly-Linked List Macros-- + * Based on linkedlists.h (to the point of plagiarism!), which is by: + * + * Mark Spencer <markster@digium.com> + * Kevin P. Fleming <kpfleming@digium.com> + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +#ifndef ASTERISK_DLINKEDLISTS_H +#define ASTERISK_DLINKEDLISTS_H + +#include "asterisk/lock.h" + +/*! + \file dlinkedlists.h + \brief A set of macros to manage doubly-linked lists. +*/ + +/*! + \brief Locks a list. + \param head This is a pointer to the list head structure + + This macro attempts to place an exclusive lock in the + list head structure pointed to by head. + \retval 0 on success + \retval non-zero on failure +*/ +#define AST_DLLIST_LOCK(head) \ + ast_mutex_lock(&(head)->lock) + +/*! + \brief Write locks a list. + \param head This is a pointer to the list head structure + + This macro attempts to place an exclusive write lock in the + list head structure pointed to by head. + \retval 0 on success + \retval non-zero on failure +*/ +#define AST_RWDLLIST_WRLOCK(head) \ + ast_rwlock_wrlock(&(head)->lock) + +/*! + \brief Read locks a list. + \param head This is a pointer to the list head structure + + This macro attempts to place a read lock in the + list head structure pointed to by head. + \retval 0 on success + \retval non-zero on failure +*/ +#define AST_RWDLLIST_RDLOCK(head) \ + ast_rwlock_rdlock(&(head)->lock) + +/*! + \brief Locks a list, without blocking if the list is locked. + \param head This is a pointer to the list head structure + + This macro attempts to place an exclusive lock in the + list head structure pointed to by head. + \retval 0 on success + \retval non-zero on failure +*/ +#define AST_DLLIST_TRYLOCK(head) \ + ast_mutex_trylock(&(head)->lock) + +/*! + \brief Write locks a list, without blocking if the list is locked. + \param head This is a pointer to the list head structure + + This macro attempts to place an exclusive write lock in the + list head structure pointed to by head. + \retval 0 on success + \retval non-zero on failure +*/ +#define AST_RWDLLIST_TRYWRLOCK(head) \ + ast_rwlock_trywrlock(&(head)->lock) + +/*! + \brief Read locks a list, without blocking if the list is locked. + \param head This is a pointer to the list head structure + + This macro attempts to place a read lock in the + list head structure pointed to by head. + \retval 0 on success + \retval non-zero on failure +*/ +#define AST_RWDLLIST_TRYRDLOCK(head) \ + ast_rwlock_tryrdlock(&(head)->lock) + +/*! + \brief Attempts to unlock a list. + \param head This is a pointer to the list head structure + + This macro attempts to remove an exclusive lock from the + list head structure pointed to by head. If the list + was not locked by this thread, this macro has no effect. +*/ +#define AST_DLLIST_UNLOCK(head) \ + ast_mutex_unlock(&(head)->lock) + +/*! + \brief Attempts to unlock a read/write based list. + \param head This is a pointer to the list head structure + + This macro attempts to remove a read or write lock from the + list head structure pointed to by head. If the list + was not locked by this thread, this macro has no effect. +*/ +#define AST_RWDLLIST_UNLOCK(head) \ + ast_rwlock_unlock(&(head)->lock) + +/*! + \brief Defines a structure to be used to hold a list of specified type. + \param name This will be the name of the defined structure. + \param type This is the type of each list entry. + + This macro creates a structure definition that can be used + to hold a list of the entries of type \a type. It does not actually + declare (allocate) a structure; to do that, either follow this + macro with the desired name of the instance you wish to declare, + or use the specified \a name to declare instances elsewhere. + + Example usage: + \code + static AST_DLLIST_HEAD(entry_list, entry) entries; + \endcode + + This would define \c struct \c entry_list, and declare an instance of it named + \a entries, all intended to hold a list of type \c struct \c entry. +*/ +#define AST_DLLIST_HEAD(name, type) \ +struct name { \ + struct type *first; \ + struct type *last; \ + ast_mutex_t lock; \ +} + +/*! + \brief Defines a structure to be used to hold a read/write list of specified type. + \param name This will be the name of the defined structure. + \param type This is the type of each list entry. + + This macro creates a structure definition that can be used + to hold a list of the entries of type \a type. It does not actually + declare (allocate) a structure; to do that, either follow this + macro with the desired name of the instance you wish to declare, + or use the specified \a name to declare instances elsewhere. + + Example usage: + \code + static AST_RWDLLIST_HEAD(entry_list, entry) entries; + \endcode + + This would define \c struct \c entry_list, and declare an instance of it named + \a entries, all intended to hold a list of type \c struct \c entry. +*/ +#define AST_RWDLLIST_HEAD(name, type) \ +struct name { \ + struct type *first; \ + struct type *last; \ + ast_rwlock_t lock; \ +} + +/*! + \brief Defines a structure to be used to hold a list of specified type (with no lock). + \param name This will be the name of the defined structure. + \param type This is the type of each list entry. + + This macro creates a structure definition that can be used + to hold a list of the entries of type \a type. It does not actually + declare (allocate) a structure; to do that, either follow this + macro with the desired name of the instance you wish to declare, + or use the specified \a name to declare instances elsewhere. + + Example usage: + \code + static AST_DLLIST_HEAD_NOLOCK(entry_list, entry) entries; + \endcode + + This would define \c struct \c entry_list, and declare an instance of it named + \a entries, all intended to hold a list of type \c struct \c entry. +*/ +#define AST_DLLIST_HEAD_NOLOCK(name, type) \ +struct name { \ + struct type *first; \ + struct type *last; \ +} + +/*! + \brief Defines initial values for a declaration of AST_DLLIST_HEAD +*/ +#define AST_DLLIST_HEAD_INIT_VALUE { \ + .first = NULL, \ + .last = NULL, \ + .lock = AST_MUTEX_INIT_VALUE, \ + } + +/*! + \brief Defines initial values for a declaration of AST_RWDLLIST_HEAD +*/ +#define AST_RWDLLIST_HEAD_INIT_VALUE { \ + .first = NULL, \ + .last = NULL, \ + .lock = AST_RWLOCK_INIT_VALUE, \ + } + +/*! + \brief Defines initial values for a declaration of AST_DLLIST_HEAD_NOLOCK +*/ +#define AST_DLLIST_HEAD_NOLOCK_INIT_VALUE { \ + .first = NULL, \ + .last = NULL, \ + } + +/*! + \brief Defines a structure to be used to hold a list of specified type, statically initialized. + \param name This will be the name of the defined structure. + \param type This is the type of each list entry. + + This macro creates a structure definition that can be used + to hold a list of the entries of type \a type, and allocates an instance + of it, initialized to be empty. + + Example usage: + \code + static AST_DLLIST_HEAD_STATIC(entry_list, entry); + \endcode + + This would define \c struct \c entry_list, intended to hold a list of + type \c struct \c entry. +*/ +#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) +#define AST_DLLIST_HEAD_STATIC(name, type) \ +struct name { \ + struct type *first; \ + struct type *last; \ + ast_mutex_t lock; \ +} name; \ +static void __attribute__ ((constructor)) __init_##name(void) \ +{ \ + AST_DLLIST_HEAD_INIT(&name); \ +} \ +static void __attribute__ ((destructor)) __fini_##name(void) \ +{ \ + AST_DLLIST_HEAD_DESTROY(&name); \ +} \ +struct __dummy_##name +#else +#define AST_DLLIST_HEAD_STATIC(name, type) \ +struct name { \ + struct type *first; \ + struct type *last; \ + ast_mutex_t lock; \ +} name = AST_DLLIST_HEAD_INIT_VALUE +#endif + +/*! + \brief Defines a structure to be used to hold a read/write list of specified type, statically initialized. + \param name This will be the name of the defined structure. + \param type This is the type of each list entry. + + This macro creates a structure definition that can be used + to hold a list of the entries of type \a type, and allocates an instance + of it, initialized to be empty. + + Example usage: + \code + static AST_RWDLLIST_HEAD_STATIC(entry_list, entry); + \endcode + + This would define \c struct \c entry_list, intended to hold a list of + type \c struct \c entry. +*/ +#ifndef AST_RWLOCK_INIT_VALUE +#define AST_RWDLLIST_HEAD_STATIC(name, type) \ +struct name { \ + struct type *first; \ + struct type *last; \ + ast_rwlock_t lock; \ +} name; \ +static void __attribute__ ((constructor)) __init_##name(void) \ +{ \ + AST_RWDLLIST_HEAD_INIT(&name); \ +} \ +static void __attribute__ ((destructor)) __fini_##name(void) \ +{ \ + AST_RWDLLIST_HEAD_DESTROY(&name); \ +} \ +struct __dummy_##name +#else +#define AST_RWDLLIST_HEAD_STATIC(name, type) \ +struct name { \ + struct type *first; \ + struct type *last; \ + ast_rwlock_t lock; \ +} name = AST_RWDLLIST_HEAD_INIT_VALUE +#endif + +/*! + \brief Defines a structure to be used to hold a list of specified type, statically initialized. + + This is the same as AST_DLLIST_HEAD_STATIC, except without the lock included. +*/ +#define AST_DLLIST_HEAD_NOLOCK_STATIC(name, type) \ +struct name { \ + struct type *first; \ + struct type *last; \ +} name = AST_DLLIST_HEAD_NOLOCK_INIT_VALUE + +/*! + \brief Initializes a list head structure with a specified first entry. + \param head This is a pointer to the list head structure + \param entry pointer to the list entry that will become the head of the list + + This macro initializes a list head structure by setting the head + entry to the supplied value and recreating the embedded lock. +*/ +#define AST_DLLIST_HEAD_SET(head, entry) do { \ + (head)->first = (entry); \ + (head)->last = (entry); \ + ast_mutex_init(&(head)->lock); \ +} while (0) + +/*! + \brief Initializes an rwlist head structure with a specified first entry. + \param head This is a pointer to the list head structure + \param entry pointer to the list entry that will become the head of the list + + This macro initializes a list head structure by setting the head + entry to the supplied value and recreating the embedded lock. +*/ +#define AST_RWDLLIST_HEAD_SET(head, entry) do { \ + (head)->first = (entry); \ + (head)->last = (entry); \ + ast_rwlock_init(&(head)->lock); \ +} while (0) + +/*! + \brief Initializes a list head structure with a specified first entry. + \param head This is a pointer to the list head structure + \param entry pointer to the list entry that will become the head of the list + + This macro initializes a list head structure by setting the head + entry to the supplied value. +*/ +#define AST_DLLIST_HEAD_SET_NOLOCK(head, entry) do { \ + (head)->first = (entry); \ + (head)->last = (entry); \ +} while (0) + +/*! + \brief Declare previous/forward links inside a list entry. + \param type This is the type of each list entry. + + This macro declares a structure to be used to doubly link list entries together. + It must be used inside the definition of the structure named in + \a type, as follows: + + \code + struct list_entry { + ... + AST_DLLIST_ENTRY(list_entry) list; + } + \endcode + + The field name \a list here is arbitrary, and can be anything you wish. +*/ +#define AST_DLLIST_ENTRY(type) \ +struct { \ + struct type *prev; \ + struct type *next; \ +} + +#define AST_RWDLLIST_ENTRY AST_DLLIST_ENTRY + +/*! + \brief Returns the first entry contained in a list. + \param head This is a pointer to the list head structure + */ +#define AST_DLLIST_FIRST(head) ((head)->first) + +#define AST_RWDLLIST_FIRST AST_DLLIST_FIRST + +/*! + \brief Returns the last entry contained in a list. + \param head This is a pointer to the list head structure + */ +#define AST_DLLIST_LAST(head) ((head)->last) + +#define AST_RWDLLIST_LAST AST_DLLIST_LAST + +/*! + \brief Returns the next entry in the list after the given entry. + \param elm This is a pointer to the current entry. + \param field This is the name of the field (declared using AST_DLLIST_ENTRY()) + used to link entries of this list together. +*/ +#define AST_DLLIST_NEXT(elm, field) ((elm)->field.next) + +#define AST_RWDLLIST_NEXT AST_DLLIST_NEXT + +/*! + \brief Returns the previous entry in the list before the given entry. + \param elm This is a pointer to the current entry. + \param field This is the name of the field (declared using AST_DLLIST_ENTRY()) + used to link entries of this list together. +*/ +#define AST_DLLIST_PREV(elm, field) ((elm)->field.prev) + +#define AST_RWDLLIST_PREV AST_DLLIST_PREV + +/*! + \brief Checks whether the specified list contains any entries. + \param head This is a pointer to the list head structure + + \return non-zero if the list has entries + \return zero if not. + */ +#define AST_DLLIST_EMPTY(head) (AST_DLLIST_FIRST(head) == NULL) + +#define AST_RWDLLIST_EMPTY AST_DLLIST_EMPTY + +/*! + \brief Loops over (traverses) the entries in a list. + \param head This is a pointer to the list head structure + \param var This is the name of the variable that will hold a pointer to the + current list entry on each iteration. It must be declared before calling + this macro. + \param field This is the name of the field (declared using AST_DLLIST_ENTRY()) + used to link entries of this list together. + + This macro is use to loop over (traverse) the entries in a list. It uses a + \a for loop, and supplies the enclosed code with a pointer to each list + entry as it loops. It is typically used as follows: + \code + static AST_DLLIST_HEAD(entry_list, list_entry) entries; + ... + struct list_entry { + ... + AST_DLLIST_ENTRY(list_entry) list; + } + ... + struct list_entry *current; + ... + AST_DLLIST_TRAVERSE(&entries, current, list) { + (do something with current here) + } + \endcode + \warning If you modify the forward-link pointer contained in the \a current entry while + inside the loop, the behavior will be unpredictable. At a minimum, the following + macros will modify the forward-link pointer, and should not be used inside + AST_DLLIST_TRAVERSE() against the entry pointed to by the \a current pointer without + careful consideration of their consequences: + \li AST_DLLIST_NEXT() (when used as an lvalue) + \li AST_DLLIST_INSERT_AFTER() + \li AST_DLLIST_INSERT_HEAD() + \li AST_DLLIST_INSERT_TAIL() +*/ +#define AST_DLLIST_TRAVERSE(head,var,field) \ + for((var) = (head)->first; (var); (var) = (var)->field.next) + +#define AST_RWDLLIST_TRAVERSE AST_DLLIST_TRAVERSE + +/*! + \brief Loops over (traverses) the entries in a list in reverse order, starting at the end. + \param head This is a pointer to the list head structure + \param var This is the name of the variable that will hold a pointer to the + current list entry on each iteration. It must be declared before calling + this macro. + \param field This is the name of the field (declared using AST_DLLIST_ENTRY()) + used to link entries of this list together. + + This macro is use to loop over (traverse) the entries in a list in reverse order. It uses a + \a for loop, and supplies the enclosed code with a pointer to each list + entry as it loops. It is typically used as follows: + \code + static AST_DLLIST_HEAD(entry_list, list_entry) entries; + ... + struct list_entry { + ... + AST_DLLIST_ENTRY(list_entry) list; + } + ... + struct list_entry *current; + ... + AST_DLLIST_TRAVERSE_BACKWARDS(&entries, current, list) { + (do something with current here) + } + \endcode + \warning If you modify the forward-link pointer contained in the \a current entry while + inside the loop, the behavior will be unpredictable. At a minimum, the following + macros will modify the forward-link pointer, and should not be used inside + AST_DLLIST_TRAVERSE() against the entry pointed to by the \a current pointer without + careful consideration of their consequences: + \li AST_DLLIST_PREV() (when used as an lvalue) + \li AST_DLLIST_INSERT_BEFORE() + \li AST_DLLIST_INSERT_HEAD() + \li AST_DLLIST_INSERT_TAIL() +*/ +#define AST_DLLIST_TRAVERSE_BACKWARDS(head,var,field) \ + for((var) = (head)->last; (var); (var) = (var)->field.prev) + +#define AST_RWDLLIST_TRAVERSE_BACKWARDS AST_DLLIST_TRAVERSE_BACKWARDS + +/*! + \brief Loops safely over (traverses) the entries in a list. + \param head This is a pointer to the list head structure + \param var This is the name of the variable that will hold a pointer to the + current list entry on each iteration. It must be declared before calling + this macro. + \param field This is the name of the field (declared using AST_DLLIST_ENTRY()) + used to link entries of this list together. + + This macro is used to safely loop over (traverse) the entries in a list. It + uses a \a for loop, and supplies the enclosed code with a pointer to each list + entry as it loops. It is typically used as follows: + + \code + static AST_DLLIST_HEAD(entry_list, list_entry) entries; + ... + struct list_entry { + ... + AST_DLLIST_ENTRY(list_entry) list; + } + ... + struct list_entry *current; + ... + AST_DLLIST_TRAVERSE_SAFE_BEGIN(&entries, current, list) { + (do something with current here) + } + AST_DLLIST_TRAVERSE_SAFE_END; + \endcode + + It differs from AST_DLLIST_TRAVERSE() in that the code inside the loop can modify + (or even free, after calling AST_DLLIST_REMOVE_CURRENT()) the entry pointed to by + the \a current pointer without affecting the loop traversal. +*/ +#define AST_DLLIST_TRAVERSE_SAFE_BEGIN(head, var, field) { \ + typeof((head)) __list_head = head; \ + typeof(__list_head->first) __list_next; \ + typeof(__list_head->first) __list_prev = NULL; \ + typeof(__list_head->first) __new_prev = NULL; \ + for ((var) = __list_head->first, __new_prev = (var), \ + __list_next = (var) ? (var)->field.next : NULL; \ + (var); \ + __list_prev = __new_prev, (var) = __list_next, \ + __new_prev = (var), \ + __list_next = (var) ? (var)->field.next : NULL \ + ) + +#define AST_RWDLLIST_TRAVERSE_SAFE_BEGIN AST_DLLIST_TRAVERSE_SAFE_BEGIN + +/*! + \brief Loops safely over (traverses) the entries in a list. + \param head This is a pointer to the list head structure + \param var This is the name of the variable that will hold a pointer to the + current list entry on each iteration. It must be declared before calling + this macro. + \param field This is the name of the field (declared using AST_DLLIST_ENTRY()) + used to link entries of this list together. + + This macro is used to safely loop over (traverse) the entries in a list. It + uses a \a for loop, and supplies the enclosed code with a pointer to each list + entry as it loops. It is typically used as follows: + + \code + static AST_DLLIST_HEAD(entry_list, list_entry) entries; + ... + struct list_entry { + ... + AST_DLLIST_ENTRY(list_entry) list; + } + ... + struct list_entry *current; + ... + AST_DLLIST_TRAVERSE_SAFE_BEGIN(&entries, current, list) { + (do something with current here) + } + AST_DLLIST_TRAVERSE_SAFE_END; + \endcode + + It differs from AST_DLLIST_TRAVERSE() in that the code inside the loop can modify + (or even free, after calling AST_DLLIST_REMOVE_CURRENT()) the entry pointed to by + the \a current pointer without affecting the loop traversal. +*/ +#define AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_BEGIN(head, var, field) { \ + typeof((head)) __list_head = head; \ + typeof(__list_head->first) __list_next; \ + typeof(__list_head->first) __list_prev = NULL; \ + typeof(__list_head->first) __new_prev = NULL; \ + for ((var) = __list_head->last, __new_prev = (var), \ + __list_next = NULL, __list_prev = (var) ? (var)->field.prev : NULL; \ + (var); \ + __list_next = __new_prev, (var) = __list_prev, \ + __new_prev = (var), \ + __list_prev = (var) ? (var)->field.prev : NULL \ + ) + +#define AST_RWDLLIST_TRAVERSE_BACKWARDS_SAFE_BEGIN AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_BEGIN + +/*! + \brief Removes the \a current entry from a list during a traversal. + \param field This is the name of the field (declared using AST_DLLIST_ENTRY()) + used to link entries of this list together. + + \note This macro can \b only be used inside an AST_DLLIST_TRAVERSE_SAFE_BEGIN() + block; it is used to unlink the current entry from the list without affecting + the list traversal (and without having to re-traverse the list to modify the + previous entry, if any). + */ +#define AST_DLLIST_REMOVE_CURRENT(field) do { \ + __new_prev->field.next = NULL; \ + __new_prev->field.prev = NULL; \ + if (__list_next) \ + __new_prev = __list_prev; \ + else \ + __new_prev = NULL; \ + if (__list_prev) { \ + if (__list_next) \ + __list_next->field.prev = __list_prev; \ + __list_prev->field.next = __list_next; \ + } else { \ + __list_head->first = __list_next; \ + if (__list_next) \ + __list_next->field.prev = NULL; \ + } \ + if (!__list_next) \ + __list_head->last = __list_prev; \ + } while (0) + +#define AST_RWDLLIST_REMOVE_CURRENT AST_DLLIST_REMOVE_CURRENT + +#define AST_DLLIST_MOVE_CURRENT(newhead, field) do { \ + typeof ((newhead)->first) __list_cur = __new_prev; \ + AST_DLLIST_REMOVE_CURRENT(field); \ + AST_DLLIST_INSERT_TAIL((newhead), __list_cur, field); \ + } while (0) + +#define AST_RWDLLIST_MOVE_CURRENT AST_DLLIST_MOVE_CURRENT + +#define AST_DLLIST_MOVE_CURRENT_BACKWARDS(newhead, field) do { \ + typeof ((newhead)->first) __list_cur = __new_prev; \ + if (!__list_next) { \ + AST_DLLIST_REMOVE_CURRENT(field); \ + __new_prev = NULL; \ + AST_DLLIST_INSERT_HEAD((newhead), __list_cur, field); \ + } else { \ + AST_DLLIST_REMOVE_CURRENT(field); \ + AST_DLLIST_INSERT_HEAD((newhead), __list_cur, field); \ + }} while (0) + +#define AST_RWDLLIST_MOVE_CURRENT_BACKWARDS AST_DLLIST_MOVE_CURRENT + +/*! + \brief Inserts a list entry before the current entry during a traversal. + \param elm This is a pointer to the entry to be inserted. + \param field This is the name of the field (declared using AST_DLLIST_ENTRY()) + used to link entries of this list together. + + \note This macro can \b only be used inside an AST_DLLIST_TRAVERSE_SAFE_BEGIN() + block. + */ +#define AST_DLLIST_INSERT_BEFORE_CURRENT(elm, field) do { \ + if (__list_prev) { \ + (elm)->field.next = __list_prev->field.next; \ + (elm)->field.prev = __list_prev; \ + if (__list_prev->field.next) \ + __list_prev->field.next->field.prev = (elm); \ + __list_prev->field.next = (elm); \ + } else { \ + (elm)->field.next = __list_head->first; \ + __list_head->first->field.prev = (elm); \ + (elm)->field.prev = NULL; \ + __list_head->first = (elm); \ + } \ +} while (0) + +#define AST_RWDLLIST_INSERT_BEFORE_CURRENT AST_DLLIST_INSERT_BEFORE_CURRENT + +/*! + \brief Inserts a list entry after the current entry during a backwards traversal. Since + this is a backwards traversal, this will insert the entry AFTER the current + element. Since this is a backwards traveral, though, this would be BEFORE + the current entry in traversal order. Confusing? + \param elm This is a pointer to the entry to be inserted. + \param field This is the name of the field (declared using AST_DLLIST_ENTRY()) + used to link entries of this list together. + + \note This macro can \b only be used inside an AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_BEGIN() + block. If you use this with the AST_DLLIST_TRAVERSE_SAFE_BEGIN(), be prepared for + strange things! + */ +#define AST_DLLIST_INSERT_BEFORE_CURRENT_BACKWARDS(elm, field) do { \ + if (__list_next) { \ + (elm)->field.next = __list_next; \ + (elm)->field.prev = __new_prev; \ + __new_prev->field.next = (elm); \ + __list_next->field.prev = (elm); \ + } else { \ + (elm)->field.prev = __list_head->last; \ + (elm)->field.next = NULL; \ + __list_head->last->field.next = (elm); \ + __list_head->last = (elm); \ + } \ +} while (0) + +#define AST_RWDLLIST_INSERT_BEFORE_CURRENT_BACKWARDS AST_DLLIST_INSERT_BEFORE_CURRENT_BACKWARDS + +/*! + \brief Closes a safe loop traversal block. + */ +#define AST_DLLIST_TRAVERSE_SAFE_END } + +#define AST_RWDLLIST_TRAVERSE_SAFE_END AST_DLLIST_TRAVERSE_SAFE_END + +/*! + \brief Closes a safe loop traversal block. + */ +#define AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_END } + +#define AST_RWDLLIST_TRAVERSE_BACKWARDS_SAFE_END AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_END + +/*! + \brief Initializes a list head structure. + \param head This is a pointer to the list head structure + + This macro initializes a list head structure by setting the head + entry to \a NULL (empty list) and recreating the embedded lock. +*/ +#define AST_DLLIST_HEAD_INIT(head) { \ + (head)->first = NULL; \ + (head)->last = NULL; \ + ast_mutex_init(&(head)->lock); \ +} + +/*! + \brief Initializes an rwlist head structure. + \param head This is a pointer to the list head structure + + This macro initializes a list head structure by setting the head + entry to \a NULL (empty list) and recreating the embedded lock. +*/ +#define AST_RWDLLIST_HEAD_INIT(head) { \ + (head)->first = NULL; \ + (head)->last = NULL; \ + ast_rwlock_init(&(head)->lock); \ +} + +/*! + \brief Destroys a list head structure. + \param head This is a pointer to the list head structure + + This macro destroys a list head structure by setting the head + entry to \a NULL (empty list) and destroying the embedded lock. + It does not free the structure from memory. +*/ +#define AST_DLLIST_HEAD_DESTROY(head) { \ + (head)->first = NULL; \ + (head)->last = NULL; \ + ast_mutex_destroy(&(head)->lock); \ +} + +/*! + \brief Destroys an rwlist head structure. + \param head This is a pointer to the list head structure + + This macro destroys a list head structure by setting the head + entry to \a NULL (empty list) and destroying the embedded lock. + It does not free the structure from memory. +*/ +#define AST_RWDLLIST_HEAD_DESTROY(head) { \ + (head)->first = NULL; \ + (head)->last = NULL; \ + ast_rwlock_destroy(&(head)->lock); \ +} + +/*! + \brief Initializes a list head structure. + \param head This is a pointer to the list head structure + + This macro initializes a list head structure by setting the head + entry to \a NULL (empty list). There is no embedded lock handling + with this macro. +*/ +#define AST_DLLIST_HEAD_INIT_NOLOCK(head) { \ + (head)->first = NULL; \ + (head)->last = NULL; \ +} + +/*! + \brief Inserts a list entry after a given entry. + \param head This is a pointer to the list head structure + \param listelm This is a pointer to the entry after which the new entry should + be inserted. + \param elm This is a pointer to the entry to be inserted. + \param field This is the name of the field (declared using AST_DLLIST_ENTRY()) + used to link entries of this list together. + */ +#define AST_DLLIST_INSERT_AFTER(head, listelm, elm, field) do { \ + (elm)->field.next = (listelm)->field.next; \ + (elm)->field.prev = (listelm); \ + if ((listelm)->field.next) \ + (listelm)->field.next->field.prev = (elm); \ + (listelm)->field.next = (elm); \ + if ((head)->last == (listelm)) \ + (head)->last = (elm); \ +} while (0) + +#define AST_RWDLLIST_INSERT_AFTER AST_DLLIST_INSERT_AFTER + +/*! + \brief Inserts a list entry before a given entry. + \param head This is a pointer to the list head structure + \param listelm This is a pointer to the entry before which the new entry should + be inserted. + \param elm This is a pointer to the entry to be inserted. + \param field This is the name of the field (declared using AST_DLLIST_ENTRY()) + used to link entries of this list together. + */ +#define AST_DLLIST_INSERT_BEFORE(head, listelm, elm, field) do { \ + (elm)->field.next = (listelm); \ + (elm)->field.prev = (listelm)->field.prev; \ + if ((listelm)->field.prev) \ + (listelm)->field.prev->field.next = (elm); \ + (listelm)->field.prev = (elm); \ + if ((head)->first == (listelm)) \ + (head)->first = (elm); \ +} while (0) + +#define AST_RWDLLIST_INSERT_BEFORE AST_DLLIST_INSERT_BEFORE + +/*! + \brief Inserts a list entry at the head of a list. + \param head This is a pointer to the list head structure + \param elm This is a pointer to the entry to be inserted. + \param field This is the name of the field (declared using AST_DLLIST_ENTRY()) + used to link entries of this list together. + */ +#define AST_DLLIST_INSERT_HEAD(head, elm, field) do { \ + (elm)->field.next = (head)->first; \ + if ((head)->first) \ + (head)->first->field.prev = (elm); \ + (elm)->field.prev = NULL; \ + (head)->first = (elm); \ + if (!(head)->last) \ + (head)->last = (elm); \ +} while (0) + +#define AST_RWDLLIST_INSERT_HEAD AST_DLLIST_INSERT_HEAD + +/*! + \brief Appends a list entry to the tail of a list. + \param head This is a pointer to the list head structure + \param elm This is a pointer to the entry to be appended. + \param field This is the name of the field (declared using AST_DLLIST_ENTRY()) + used to link entries of this list together. + + Note: The link field in the appended entry is \b not modified, so if it is + actually the head of a list itself, the entire list will be appended + temporarily (until the next AST_DLLIST_INSERT_TAIL is performed). + */ +#define AST_DLLIST_INSERT_TAIL(head, elm, field) do { \ + if (!(head)->first) { \ + (head)->first = (elm); \ + (head)->last = (elm); \ + (elm)->field.next = NULL; \ + (elm)->field.prev = NULL; \ + } else { \ + (head)->last->field.next = (elm); \ + (elm)->field.prev = (head)->last; \ + (elm)->field.next = NULL; \ + (head)->last = (elm); \ + } \ +} while (0) + +#define AST_RWDLLIST_INSERT_TAIL AST_DLLIST_INSERT_TAIL + +/*! + \brief Appends a whole list to the tail of a list. + \param head This is a pointer to the list head structure + \param list This is a pointer to the list to be appended. + \param field This is the name of the field (declared using AST_DLLIST_ENTRY()) + used to link entries of this list together. + + Note: The source list (the \a list parameter) will be empty after + calling this macro (the list entries are \b moved to the target list). + */ +#define AST_DLLIST_APPEND_DLLIST(head, list, field) do { \ + if (!(head)->first) { \ + (head)->first = (list)->first; \ + (head)->last = (list)->last; \ + } else { \ + (head)->last->field.next = (list)->first; \ + (list)->first->field.prev = (head)->last; \ + (head)->last = (list)->last; \ + } \ + (list)->first = NULL; \ + (list)->last = NULL; \ +} while (0) + +#define AST_RWDLLIST_APPEND_DLLIST AST_DLLIST_APPEND_DLLIST + +/*! + \brief Removes and returns the head entry from a list. + \param head This is a pointer to the list head structure + \param field This is the name of the field (declared using AST_DLLIST_ENTRY()) + used to link entries of this list together. + + Removes the head entry from the list, and returns a pointer to it. + This macro is safe to call on an empty list. + */ +#define AST_DLLIST_REMOVE_HEAD(head, field) ({ \ + typeof((head)->first) cur = (head)->first; \ + if (cur) { \ + (head)->first = cur->field.next; \ + if (cur->field.next) \ + cur->field.next->field.prev = NULL; \ + cur->field.next = NULL; \ + if ((head)->last == cur) \ + (head)->last = NULL; \ + } \ + cur; \ + }) + +#define AST_RWDLLIST_REMOVE_HEAD AST_DLLIST_REMOVE_HEAD + +/*! + \brief Removes a specific entry from a list. + \param head This is a pointer to the list head structure + \param elm This is a pointer to the entry to be removed. + \param field This is the name of the field (declared using AST_DLLIST_ENTRY()) + used to link entries of this list together. + \warning The removed entry is \b not freed nor modified in any way. + */ +#define AST_DLLIST_REMOVE(head, elm, field) ({ \ + __typeof(elm) __res = (elm); \ + if ((head)->first == (elm)) { \ + (head)->first = (elm)->field.next; \ + if ((elm)->field.next) \ + (elm)->field.next->field.prev = NULL; \ + if ((head)->last == (elm)) \ + (head)->last = NULL; \ + } else { \ + (elm)->field.prev->field.next = (elm)->field.next; \ + if ((elm)->field.next) \ + (elm)->field.next->field.prev = (elm)->field.prev; \ + if ((head)->last == (elm)) \ + (head)->last = (elm)->field.prev; \ + } \ + (elm)->field.next = NULL; \ + (elm)->field.prev = NULL; \ + (__res); \ +}) + +#define AST_RWDLLIST_REMOVE AST_DLLIST_REMOVE + +#endif /* _ASTERISK_DLINKEDLISTS_H */ |