From: Russell Bryant Date: Wed, 30 Apr 2008 16:30:01 +0000 (+0000) Subject: Merge changes from team/russell/iax2_find_callno and iax2_find_callno_1.4 X-Git-Tag: 1.4.20-rc1~4 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=5f1f3ed47374e0e7b444f85c0c4a83226b49ad24;p=thirdparty%2Fasterisk.git Merge changes from team/russell/iax2_find_callno and iax2_find_callno_1.4 These changes address a critical performance issue introduced in the latest release. The fix for the latest security issue included a change that made Asterisk randomly choose call numbers to make them more difficult to guess by attackers. However, due to some inefficient (this is by far, an understatement) code, when Asterisk chose high call numbers, chan_iax2 became unusable after just a small number of calls. On a small embedded platform, it would not be able to handle a single call. On my Intel Core 2 Duo @ 2.33 GHz, I couldn't run more than about 16 IAX2 channels. Ouch. These changes address some performance issues of the find_callno() function that have bothered me for a very long time. On every incoming media frame, it iterated through every possible call number trying to find a matching active call. This involved a mutex lock and unlock for each call number checked. So, if the random call number chosen was 20000, then every media frame would cause 20000 locks and unlocks. Previously, this problem was not as obvious since Asterisk always chose the lowest call number it could. A second container for IAX2 pvt structs has been added. It is an astobj2 hash table. When we know the remote side's call number, the pvt goes into the hash table with a hash value of the remote side's call number. Then, lookups for incoming media frames are a very fast hash lookup instead of an absolutely insane array traversal. In a quick test, I was able to get more than 3600% more IAX2 channels on my machine with these changes. git-svn-id: https://origsvn.digium.com/svn/asterisk/branches/1.4@114891 65c4cc65-6c06-0410-ace0-fbb531ad65f3 --- diff --git a/channels/chan_iax2.c b/channels/chan_iax2.c index deec4c0695..4fd32533e7 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 0000000000..2f42fdd39c --- /dev/null +++ b/include/asterisk/dlinkedlists.h @@ -0,0 +1,974 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 2007, Digium, Inc. + * + * Steve Murphy + * + * Doubly-Linked List Macros-- + * Based on linkedlists.h (to the point of plagiarism!), which is by: + * + * Mark Spencer + * Kevin P. Fleming + * + * 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 */