From dbc9edcaac6ec1d2059f4c5bcd27cca6c266f5bf Mon Sep 17 00:00:00 2001 From: markster Date: Wed, 13 Aug 2003 15:25:16 +0000 Subject: Totally revamp thread debugging to support locating and removing deadlocks git-svn-id: http://svn.digium.com/svn/asterisk/trunk@1310 f38db490-d61c-443f-a65b-d21fe96a405b --- channels/chan_agent.c | 192 ++++++++++++------------- channels/chan_alsa.c | 14 +- channels/chan_iax.c | 260 +++++++++++++++++----------------- channels/chan_iax2.c | 308 ++++++++++++++++++++--------------------- channels/chan_local.c | 98 ++++++------- channels/chan_mgcp.c | 96 ++++++------- channels/chan_modem.c | 64 ++++----- channels/chan_modem_aopen.c | 14 +- channels/chan_modem_bestdata.c | 14 +- channels/chan_modem_i4l.c | 14 +- channels/chan_nbs.c | 10 +- channels/chan_oss.c | 14 +- channels/chan_phone.c | 78 +++++------ channels/chan_sip.c | 288 +++++++++++++++++++------------------- channels/chan_vofr.c | 62 ++++----- channels/chan_vpb.c | 104 +++++++------- channels/chan_zap.c | 214 ++++++++++++++-------------- channels/chan_zap_old.c | 166 +++++++++++----------- 18 files changed, 1007 insertions(+), 1003 deletions(-) (limited to 'channels') diff --git a/channels/chan_agent.c b/channels/chan_agent.c index 53dd4e7e9..74155d0a8 100755 --- a/channels/chan_agent.c +++ b/channels/chan_agent.c @@ -81,13 +81,13 @@ static int wrapuptime; static int ackcall; static int usecnt =0; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; /* Protect the interface list (of sip_pvt's) */ -static pthread_mutex_t agentlock = AST_MUTEX_INITIALIZER; +static ast_mutex_t agentlock = AST_MUTEX_INITIALIZER; static struct agent_pvt { - pthread_mutex_t lock; /* Channel private lock */ + ast_mutex_t lock; /* Channel private lock */ int dead; /* Poised for destruction? */ int pending; /* Not a real agent -- just pending a match */ int abouttograb; /* About to grab */ @@ -102,7 +102,7 @@ static struct agent_pvt { char agent[AST_MAX_AGENT]; /* Agent ID */ char password[AST_MAX_AGENT]; /* Password for Agent login */ char name[AST_MAX_AGENT]; - pthread_mutex_t app_lock; /* Synchronization between owning applications */ + ast_mutex_t app_lock; /* Synchronization between owning applications */ volatile pthread_t owning_app; /* Owning application thread id */ volatile int app_sleep_cond; /* Sleep condition for the login app */ struct ast_channel *owner; /* Agent */ @@ -168,8 +168,8 @@ static struct agent_pvt *add_agent(char *agent, int pending) if (p) { memset(p, 0, sizeof(struct agent_pvt)); strncpy(p->agent, tmp, sizeof(p->agent) -1); - ast_pthread_mutex_init( &p->lock ); - ast_pthread_mutex_init( &p->app_lock ); + ast_mutex_init( &p->lock ); + ast_mutex_init( &p->app_lock ); p->owning_app = -1; p->app_sleep_cond = 1; p->group = group; @@ -204,7 +204,7 @@ static int agent_cleanup(struct agent_pvt *p) chan->pvt->pvt = NULL; p->app_sleep_cond = 1; /* Release ownership of the agent to other threads (presumably running the login app). */ - ast_pthread_mutex_unlock(&p->app_lock); + ast_mutex_unlock(&p->app_lock); if (chan) ast_channel_free(chan); if (p->dead) @@ -226,7 +226,7 @@ static struct ast_frame *agent_read(struct ast_channel *ast) struct ast_frame *f = NULL; static struct ast_frame null_frame = { AST_FRAME_NULL, }; static struct ast_frame answer_frame = { AST_FRAME_CONTROL, AST_CONTROL_ANSWER }; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (p->chan) { p->chan->pvt->rawreadformat = ast->pvt->rawreadformat; f = ast_read(p->chan); @@ -270,7 +270,7 @@ static struct ast_frame *agent_read(struct ast_channel *ast) f = NULL; } CLEANUP(ast,p); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return f; } @@ -278,28 +278,28 @@ static int agent_write(struct ast_channel *ast, struct ast_frame *f) { struct agent_pvt *p = ast->pvt->pvt; int res = -1; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (p->chan) { p->chan->pvt->rawwriteformat = ast->pvt->rawwriteformat; res = ast_write(p->chan, f); } else res = 0; CLEANUP(ast, p); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return res; } static int agent_fixup(struct ast_channel *oldchan, struct ast_channel *newchan) { struct agent_pvt *p = newchan->pvt->pvt; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (p->owner != oldchan) { ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return -1; } p->owner = newchan; - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return 0; } @@ -307,12 +307,12 @@ static int agent_indicate(struct ast_channel *ast, int condition) { struct agent_pvt *p = ast->pvt->pvt; int res = -1; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (p->chan) res = ast_indicate(p->chan, condition); else res = 0; - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return res; } @@ -320,12 +320,12 @@ static int agent_digit(struct ast_channel *ast, char digit) { struct agent_pvt *p = ast->pvt->pvt; int res = -1; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (p->chan) res = p->chan->pvt->send_digit(p->chan, digit); else res = 0; - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return res; } @@ -333,7 +333,7 @@ static int agent_call(struct ast_channel *ast, char *dest, int timeout) { struct agent_pvt *p = ast->pvt->pvt; int res = -1; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (!p->chan) { if (p->pending) { ast_log(LOG_DEBUG, "Pretending to dial on pending agent\n"); @@ -343,7 +343,7 @@ static int agent_call(struct ast_channel *ast, char *dest, int timeout) ast_log(LOG_NOTICE, "Whoa, they hung up between alloc and call... what are the odds of that?\n"); res = -1; } - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return res; } else if (strlen(p->loginchan)) { time(&p->start); @@ -352,7 +352,7 @@ static int agent_call(struct ast_channel *ast, char *dest, int timeout) ast_verbose(VERBOSE_PREFIX_3 "outgoing agentcall, to agent '%s', on '%s'\n", p->agent, p->chan->name); res = ast_call(p->chan, p->loginchan, 0); CLEANUP(ast,p); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return res; } ast_verbose( VERBOSE_PREFIX_3 "agent_call, call to agent '%s' call on '%s'\n", p->agent, p->chan->name); @@ -385,7 +385,7 @@ static int agent_call(struct ast_channel *ast, char *dest, int timeout) ast_setstate(ast, AST_STATE_UP); } CLEANUP(ast,p); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return res; } @@ -393,7 +393,7 @@ static int agent_hangup(struct ast_channel *ast) { struct agent_pvt *p = ast->pvt->pvt; int howlong = 0; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); p->owner = NULL; ast->pvt->pvt = NULL; p->app_sleep_cond = 1; @@ -415,38 +415,38 @@ static int agent_hangup(struct ast_channel *ast) strcpy(p->loginchan, ""); } } else if (p->dead) { - ast_pthread_mutex_lock(&p->chan->lock); + ast_mutex_lock(&p->chan->lock); ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT); - ast_pthread_mutex_unlock(&p->chan->lock); + ast_mutex_unlock(&p->chan->lock); } else { - ast_pthread_mutex_lock(&p->chan->lock); + ast_mutex_lock(&p->chan->lock); ast_moh_start(p->chan, p->moh); - ast_pthread_mutex_unlock(&p->chan->lock); + ast_mutex_unlock(&p->chan->lock); } } #if 0 - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); /* Release ownership of the agent to other threads (presumably running the login app). */ - ast_pthread_mutex_unlock(&p->app_lock); + ast_mutex_unlock(&p->app_lock); } else if (p->dead) { /* Go ahead and lose it */ - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); /* Release ownership of the agent to other threads (presumably running the login app). */ - ast_pthread_mutex_unlock(&p->app_lock); + ast_mutex_unlock(&p->app_lock); } else { - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); /* Release ownership of the agent to other threads (presumably running the login app). */ - ast_pthread_mutex_unlock(&p->app_lock); + ast_mutex_unlock(&p->app_lock); } #endif - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); /* Release ownership of the agent to other threads (presumably running the login app). */ - ast_pthread_mutex_unlock(&p->app_lock); + ast_mutex_unlock(&p->app_lock); if (p->pending) { - ast_pthread_mutex_lock(&agentlock); + ast_mutex_lock(&agentlock); agent_unlink(p); - ast_pthread_mutex_unlock(&agentlock); + ast_mutex_unlock(&agentlock); } if (p->abouttograb) { /* Let the "about to grab" thread know this isn't valid anymore, and let it @@ -456,11 +456,11 @@ static int agent_hangup(struct ast_channel *ast) free(p); } else if (p->chan) { /* Not dead -- check availability now */ - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); /* check_availability(p, 1); */ /* Store last disconnect time */ gettimeofday(&p->lastdisc, NULL); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); } return 0; } @@ -473,7 +473,7 @@ static int agent_cont_sleep( void *data ) p = (struct agent_pvt *)data; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); res = p->app_sleep_cond; if (p->lastdisc.tv_sec) { gettimeofday(&tv, NULL); @@ -481,7 +481,7 @@ static int agent_cont_sleep( void *data ) (tv.tv_usec - p->lastdisc.tv_usec) / 1000 > p->wrapuptime) res = 1; } - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); #if 0 if( !res ) ast_log( LOG_DEBUG, "agent_cont_sleep() returning %d\n", res ); @@ -534,9 +534,9 @@ static struct ast_channel *agent_new(struct agent_pvt *p, int state) tmp->pvt->indicate = agent_indicate; tmp->pvt->fixup = agent_fixup; p->owner = tmp; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); tmp->priority = 1; /* Wake up and wait for other applications (by definition the login app) @@ -547,13 +547,13 @@ static struct ast_channel *agent_new(struct agent_pvt *p, int state) * implemented in the kernel for this. */ p->app_sleep_cond = 0; - if( pthread_mutex_trylock(&p->app_lock) ) + if( ast_mutex_trylock(&p->app_lock) ) { if (p->chan) { ast_queue_frame(p->chan, &null_frame, 1); - ast_pthread_mutex_unlock(&p->lock); /* For other thread to read the condition. */ - ast_pthread_mutex_lock(&p->app_lock); - ast_pthread_mutex_lock(&p->lock); + ast_mutex_unlock(&p->lock); /* For other thread to read the condition. */ + ast_mutex_lock(&p->app_lock); + ast_mutex_lock(&p->lock); } if( !p->chan ) { @@ -562,8 +562,8 @@ static struct ast_channel *agent_new(struct agent_pvt *p, int state) tmp->pvt->pvt = NULL; p->app_sleep_cond = 1; ast_channel_free( tmp ); - ast_pthread_mutex_unlock(&p->lock); /* For other thread to read the condition. */ - ast_pthread_mutex_unlock(&p->app_lock); + ast_mutex_unlock(&p->lock); /* For other thread to read the condition. */ + ast_mutex_unlock(&p->app_lock); return NULL; } } @@ -596,7 +596,7 @@ static int read_agent_config(void) ast_log(LOG_NOTICE, "No agent configuration found -- agent support disabled\n"); return 0; } - ast_pthread_mutex_lock(&agentlock); + ast_mutex_lock(&agentlock); p = agents; while(p) { p->dead = 1; @@ -648,7 +648,7 @@ static int read_agent_config(void) pl = p; p = pn; } - ast_pthread_mutex_unlock(&agentlock); + ast_mutex_unlock(&agentlock); ast_destroy(cfg); return 0; } @@ -660,28 +660,28 @@ static int check_availability(struct agent_pvt *newlyavailable, int needlock) int res; ast_log(LOG_DEBUG, "Checking availability of '%s'\n", newlyavailable->agent); if (needlock) - ast_pthread_mutex_lock(&agentlock); + ast_mutex_lock(&agentlock); p = agents; while(p) { if (p == newlyavailable) { p = p->next; continue; } - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (!p->abouttograb && p->pending && ((p->group && (newlyavailable->group & p->group)) || !strcmp(p->agent, newlyavailable->agent))) { ast_log(LOG_DEBUG, "Call '%s' looks like a winner for agent '%s'\n", p->owner->name, newlyavailable->agent); /* We found a pending call, time to merge */ chan = agent_new(newlyavailable, AST_STATE_DOWN); parent = p->owner; p->abouttograb = 1; - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); break; } - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); p = p->next; } if (needlock) - ast_pthread_mutex_unlock(&agentlock); + ast_mutex_unlock(&agentlock); if (parent && chan) { ast_log( LOG_DEBUG, "Playing beep, lang '%s'\n", newlyavailable->chan->language); res = ast_streamfile(newlyavailable->chan, "beep", newlyavailable->chan->language); @@ -697,10 +697,10 @@ static int check_availability(struct agent_pvt *newlyavailable, int needlock) ast_setstate(chan, AST_STATE_UP); /* Go ahead and mark the channel as a zombie so that masquerade will destroy it for us, and we need not call ast_hangup */ - ast_pthread_mutex_lock(&parent->lock); + ast_mutex_lock(&parent->lock); chan->zombie = 1; ast_channel_masquerade(parent, chan); - ast_pthread_mutex_unlock(&parent->lock); + ast_mutex_unlock(&parent->lock); p->abouttograb = 0; } else { ast_log(LOG_DEBUG, "Sneaky, parent disappeared in the mean time...\n"); @@ -732,10 +732,10 @@ static struct ast_channel *agent_request(char *type, int format, void *data) } /* Check actual logged in agents first */ - ast_pthread_mutex_lock(&agentlock); + ast_mutex_lock(&agentlock); p = agents; while(p) { - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (!p->pending && ((groupmatch && (p->group & groupmatch)) || !strcmp(data, p->agent)) && !p->lastdisc.tv_sec && !strlen(p->loginchan)) { /* Agent must be registered, but not have any active call, and not be in a waiting state */ @@ -749,17 +749,17 @@ static struct ast_channel *agent_request(char *type, int format, void *data) chan = agent_new(p, AST_STATE_DOWN); } if (chan) { - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); break; } } - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); p = p->next; } if (!p) { p = agents; while(p) { - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (!p->pending && ((groupmatch && (p->group & groupmatch)) || !strcmp(data, p->agent)) && !p->lastdisc.tv_sec) { /* Agent must be registered, but not have any active call, and not be in a waiting state */ @@ -773,11 +773,11 @@ static struct ast_channel *agent_request(char *type, int format, void *data) chan = agent_new(p, AST_STATE_DOWN); } if (chan) { - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); break; } } - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); p = p->next; } } @@ -793,7 +793,7 @@ static struct ast_channel *agent_request(char *type, int format, void *data) ast_log(LOG_WARNING, "Weird... Fix this to drop the unused pending agent\n"); } } - ast_pthread_mutex_unlock(&agentlock); + ast_mutex_unlock(&agentlock); return chan; } @@ -816,10 +816,10 @@ static int agents_show(int fd, int argc, char **argv) if (argc != 2) return RESULT_SHOWUSAGE; - ast_pthread_mutex_lock(&agentlock); + ast_mutex_lock(&agentlock); p = agents; while(p) { - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (p->pending) { if (p->group) ast_cli(fd, "-- Pending call to group %d\n", powerof(p->group)); @@ -851,10 +851,10 @@ static int agents_show(int fd, int argc, char **argv) ast_cli(fd, "%-12.12s %s%s%s%s\n", p->agent, username, location, talkingto, moh); } - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); p = p->next; } - ast_pthread_mutex_unlock(&agentlock); + ast_mutex_unlock(&agentlock); return RESULT_SUCCESS; } @@ -917,14 +917,14 @@ static int __login_exec(struct ast_channel *chan, void *data, int callbackmode) } while (!res && (tries < 3)) { /* Check for password */ - ast_pthread_mutex_lock(&agentlock); + ast_mutex_lock(&agentlock); p = agents; while(p) { if (!strcmp(p->agent, user) && !p->pending) strncpy(xpass, p->password, sizeof(xpass) - 1); p = p->next; } - ast_pthread_mutex_unlock(&agentlock); + ast_mutex_unlock(&agentlock); if (!res) { if (strlen(xpass)) res = ast_app_getdata(chan, "agent-pass", pass, sizeof(pass) - 1, 0); @@ -938,10 +938,10 @@ static int __login_exec(struct ast_channel *chan, void *data, int callbackmode) #endif /* Check again for accuracy */ - ast_pthread_mutex_lock(&agentlock); + ast_mutex_lock(&agentlock); p = agents; while(p) { - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (!strcmp(p->agent, user) && !strcmp(p->password, pass) && !p->pending) { if (!p->chan) { @@ -992,8 +992,8 @@ static int __login_exec(struct ast_channel *chan, void *data, int callbackmode) res = ast_waitstream(chan, ""); if (!res) res = ast_safe_sleep(chan, 1000); - ast_pthread_mutex_unlock(&p->lock); - ast_pthread_mutex_unlock(&agentlock); + ast_mutex_unlock(&p->lock); + ast_mutex_unlock(&agentlock); } else if (!res) { /* check if the moh class was changed with setmusiconhold */ if (*(chan->musicclass)) @@ -1011,19 +1011,19 @@ static int __login_exec(struct ast_channel *chan, void *data, int callbackmode) p->chan = chan; p->acknowledged = 1; check_availability(p, 0); - ast_pthread_mutex_unlock(&p->lock); - ast_pthread_mutex_unlock(&agentlock); + ast_mutex_unlock(&p->lock); + ast_mutex_unlock(&agentlock); while (res >= 0) { - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (p->chan != chan) res = -1; - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); /* Yield here so other interested threads can kick in. */ sched_yield(); if (res) break; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (p->lastdisc.tv_sec) { gettimeofday(&tv, NULL); if ((tv.tv_sec - p->lastdisc.tv_sec) * 1000 + @@ -1033,25 +1033,25 @@ static int __login_exec(struct ast_channel *chan, void *data, int callbackmode) check_availability(p, 1); } } - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); /* Synchronize channel ownership between call to agent and itself. */ - pthread_mutex_lock( &p->app_lock ); - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock( &p->app_lock ); + ast_mutex_lock(&p->lock); p->owning_app = pthread_self(); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); res = ast_safe_sleep_conditional( chan, 1000, agent_cont_sleep, p ); - pthread_mutex_unlock( &p->app_lock ); + ast_mutex_unlock( &p->app_lock ); sched_yield(); } - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (res && p->owner) ast_log(LOG_WARNING, "Huh? We broke out when there was still an owner?\n"); /* Log us off if appropriate */ if (p->chan == chan) p->chan = NULL; p->acknowledged = 0; - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Agent '%s' logged out\n", p->agent); manager_event(EVENT_FLAG_AGENT, "Agentlogoff", @@ -1062,22 +1062,22 @@ static int __login_exec(struct ast_channel *chan, void *data, int callbackmode) free(p); } else { - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); p = NULL; } res = -1; } else { - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); errmsg = "agent-alreadyon"; p = NULL; } break; } - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); p = p->next; } if (!p) - ast_pthread_mutex_unlock(&agentlock); + ast_mutex_unlock(&agentlock); if (!res) res = ast_app_getdata(chan, errmsg, user, sizeof(user) - 1, 0); @@ -1127,7 +1127,7 @@ int unload_module() ast_unregister_application(app); ast_unregister_application(app2); ast_channel_unregister(type); - if (!ast_pthread_mutex_lock(&agentlock)) { + if (!ast_mutex_lock(&agentlock)) { /* Hangup all interfaces if they have an owner */ p = agents; while(p) { @@ -1136,7 +1136,7 @@ int unload_module() p = p->next; } agents = NULL; - ast_pthread_mutex_unlock(&agentlock); + ast_mutex_unlock(&agentlock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; @@ -1147,9 +1147,9 @@ int unload_module() int usecount() { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } diff --git a/channels/chan_alsa.c b/channels/chan_alsa.c index dfbce5722..e7ec368b4 100755 --- a/channels/chan_alsa.c +++ b/channels/chan_alsa.c @@ -71,7 +71,7 @@ static int silencethreshold = 1000; static char digits[80] = ""; static char text2send[80] = ""; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; static char *type = "Console"; static char *desc = "ALSA Console Channel Driver"; @@ -518,9 +518,9 @@ static int alsa_hangup(struct ast_channel *c) c->pvt->pvt = NULL; alsa.owner = NULL; ast_verbose( " << Hangup on console >> \n"); - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt--; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); needhangup = 0; needanswer = 0; if (hookstate) { @@ -807,9 +807,9 @@ static struct ast_channel *alsa_new(struct chan_alsa_pvt *p, int state) strncpy(tmp->language, language, sizeof(tmp->language)-1); p->owner = tmp; ast_setstate(tmp, state); - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); if (state != AST_STATE_DOWN) { if (ast_pbx_start(tmp)) { @@ -1103,9 +1103,9 @@ char *description() int usecount() { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } diff --git a/channels/chan_iax.c b/channels/chan_iax.c index b9869916a..1d1c354bb 100755 --- a/channels/chan_iax.c +++ b/channels/chan_iax.c @@ -91,7 +91,7 @@ static int tos = 0; static int expirey = AST_DEFAULT_REG_EXPIRE; static int usecnt; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; int (*iax_regfunk)(char *username, int onoff) = NULL; @@ -384,17 +384,17 @@ static struct ast_iax_queue { struct ast_iax_frame *head; struct ast_iax_frame *tail; int count; - pthread_mutex_t lock; + ast_mutex_t lock; } iaxq; static struct ast_user_list { struct iax_user *users; - pthread_mutex_t lock; + ast_mutex_t lock; } userl; static struct ast_peer_list { struct iax_peer *peers; - pthread_mutex_t lock; + ast_mutex_t lock; } peerl; /* Extension exists */ @@ -426,7 +426,7 @@ static struct iax_dpcache { struct iax_dpcache *peer; /* For linking in peers */ } *dpcache; -static pthread_mutex_t dpcache_lock; +static ast_mutex_t dpcache_lock; #ifdef DEBUG_SUPPORT static void showframe(struct ast_iax_frame *f, struct ast_iax_full_hdr *fhi, int rx, struct sockaddr_in *sin) @@ -541,7 +541,7 @@ static void showframe(struct ast_iax_frame *f, struct ast_iax_full_hdr *fhi, int /* XXX We probably should use a mutex when working with this XXX */ static struct chan_iax_pvt *iaxs[AST_IAX_MAX_CALLS]; -static pthread_mutex_t iaxsl[AST_IAX_MAX_CALLS]; +static ast_mutex_t iaxsl[AST_IAX_MAX_CALLS]; static int send_command(struct chan_iax_pvt *, char, int, unsigned int, char *, int, int); static int send_command_immediate(struct chan_iax_pvt *, char, int, unsigned int, char *, int, int); @@ -767,14 +767,14 @@ static int find_callno(short callno, short dcallno ,struct sockaddr_in *sin, int if (new <= NEW_ALLOW) { /* Look for an existing connection first */ for (x=0;(res < 0) && (x= NEW_ALLOW)) { @@ -785,9 +785,9 @@ static int find_callno(short callno, short dcallno ,struct sockaddr_in *sin, int ast_log(LOG_WARNING, "Unable to accept more calls\n"); return -1; } - ast_pthread_mutex_lock(&iaxsl[x]); + ast_mutex_lock(&iaxsl[x]); iaxs[x] = new_iax(); - ast_pthread_mutex_unlock(&iaxsl[x]); + ast_mutex_unlock(&iaxsl[x]); if (iaxs[x]) { if (option_debug) ast_log(LOG_DEBUG, "Creating new call structure %d\n", x); @@ -818,19 +818,19 @@ static int iax_queue_frame(int callno, struct ast_frame *f) /* Assumes lock for callno is already held... */ for (;;) { pass++; - if (!pthread_mutex_trylock(&iaxsl[callno])) { + if (!ast_mutex_trylock(&iaxsl[callno])) { ast_log(LOG_WARNING, "Lock is not held on pass %d of iax_queue_frame\n", pass); CRASH; } if (iaxs[callno] && iaxs[callno]->owner) { - if (pthread_mutex_trylock(&iaxs[callno]->owner->lock)) { + if (ast_mutex_trylock(&iaxs[callno]->owner->lock)) { /* Avoid deadlock by pausing and trying again */ - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); usleep(1); - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); } else { ast_queue_frame(iaxs[callno]->owner, f, 0); - ast_pthread_mutex_unlock(&iaxs[callno]->owner->lock); + ast_mutex_unlock(&iaxs[callno]->owner->lock); break; } } else @@ -879,9 +879,9 @@ static int do_deliver(void *data) struct ast_iax_frame *fr = data; int callno = fr->callno; int res; - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); res = __do_deliver(data); - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); return res; } @@ -963,10 +963,10 @@ static int iax_predestroy(int callno) { struct ast_channel *c; struct chan_iax_pvt *pvt; - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); pvt = iaxs[callno]; if (!pvt) { - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); return -1; } if (!pvt->alreadygone) { @@ -990,23 +990,23 @@ static int iax_predestroy(int callno) c->_softhangup |= AST_SOFTHANGUP_DEV; c->pvt->pvt = NULL; pvt->owner = NULL; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt--; if (usecnt < 0) ast_log(LOG_WARNING, "Usecnt < 0???\n"); - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); } - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); return 0; } static int iax_predestroy_nolock(int callno) { int res; - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); res = iax_predestroy(callno); - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); return res; } @@ -1017,7 +1017,7 @@ static void iax_destroy(int callno) struct ast_channel *owner; retry: - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); pvt = iaxs[callno]; iaxs[callno] = NULL; @@ -1026,9 +1026,9 @@ retry: else owner = NULL; if (owner) { - if (pthread_mutex_trylock(&owner->lock)) { + if (ast_mutex_trylock(&owner->lock)) { ast_log(LOG_NOTICE, "Avoiding IAX destroy deadlock\n"); - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); usleep(1); goto retry; } @@ -1070,16 +1070,16 @@ retry: free(pvt); } if (owner) { - ast_pthread_mutex_unlock(&owner->lock); + ast_mutex_unlock(&owner->lock); } - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); } static void iax_destroy_nolock(int callno) { /* Actually it's easier to unlock, kill it, and relock */ - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); iax_destroy(callno); - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); } @@ -1093,7 +1093,7 @@ static int attempt_transmit(void *data) int callno = f->callno; /* Make sure this call is still active */ if (callno > -1) - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); if ((f->callno > -1) && iaxs[f->callno]) { if ((f->retries < 0) /* Already ACK'd */ || (f->retries >= max_retries) /* Too many attempts */) { @@ -1146,11 +1146,11 @@ static int attempt_transmit(void *data) freeme++; } if (callno > -1) - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); /* Do not try again */ if (freeme) { /* Don't attempt delivery, just remove it from the queue */ - ast_pthread_mutex_lock(&iaxq.lock); + ast_mutex_lock(&iaxq.lock); if (f->prev) f->prev->next = f->next; else @@ -1160,7 +1160,7 @@ static int attempt_transmit(void *data) else iaxq.tail = f->prev; iaxq.count--; - ast_pthread_mutex_unlock(&iaxq.lock); + ast_mutex_unlock(&iaxq.lock); /* Free the frame */ ast_frfree(f->f); f->retrans = -1; @@ -1228,7 +1228,7 @@ static int iax_show_cache(int fd, int argc, char *argv[]) int x,y; struct timeval tv; gettimeofday(&tv, NULL); - ast_pthread_mutex_lock(&dpcache_lock); + ast_mutex_lock(&dpcache_lock); dp = dpcache; ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags"); while(dp) { @@ -1270,7 +1270,7 @@ static int iax_show_cache(int fd, int argc, char *argv[]) ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp); dp = dp->next; } - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); return RESULT_SUCCESS; } @@ -1453,7 +1453,7 @@ static int iax_transmit(struct ast_iax_frame *fr) /* By setting this to 0, the network thread will send it for us, and queue retransmission if necessary */ fr->sentyet = 0; - ast_pthread_mutex_lock(&iaxq.lock); + ast_mutex_lock(&iaxq.lock); if (!iaxq.head) { /* Empty queue */ iaxq.head = fr; @@ -1465,7 +1465,7 @@ static int iax_transmit(struct ast_iax_frame *fr) iaxq.tail = fr; } iaxq.count++; - ast_pthread_mutex_unlock(&iaxq.lock); + ast_mutex_unlock(&iaxq.lock); /* Wake up the network thread */ pthread_kill(netthreadid, SIGURG); return 0; @@ -1512,7 +1512,7 @@ static int create_addr(struct sockaddr_in *sin, int *capability, int *sendani, i if (maxtime) *maxtime = 0; sin->sin_family = AF_INET; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); p = peerl.peers; while(p) { if (!strcasecmp(p->name, peer)) { @@ -1539,7 +1539,7 @@ static int create_addr(struct sockaddr_in *sin, int *capability, int *sendani, i } p = p->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); if (!p && !found) { hp = gethostbyname(peer); if (hp) { @@ -1560,13 +1560,13 @@ static int auto_congest(void *nothing) { int callno = (int)(long)(nothing); struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_CONGESTION }; - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); if (iaxs[callno]) { iaxs[callno]->initid = -1; iax_queue_frame(callno, &f); ast_log(LOG_NOTICE, "Auto-congesting call due to slow response\n"); } - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); return 0; } @@ -1683,7 +1683,7 @@ static int iax_hangup(struct ast_channel *c) int callno; if (pvt) { callno = pvt->callno; - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); ast_log(LOG_DEBUG, "We're hanging up %s now...\n", c->name); alreadygone = pvt->alreadygone; /* Send the hangup unless we have had a transmission error or are already gone */ @@ -1696,7 +1696,7 @@ static int iax_hangup(struct ast_channel *c) ast_log(LOG_DEBUG, "Really destroying %s now...\n", c->name); iax_destroy_nolock(callno); } - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); } if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Hungup '%s'\n", c->name); @@ -1886,7 +1886,7 @@ static int iax_getpeername(struct sockaddr_in sin, char *host, int len) { struct iax_peer *peer; int res = 0; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peer = peerl.peers; while(peer) { if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) && @@ -1897,7 +1897,7 @@ static int iax_getpeername(struct sockaddr_in sin, char *host, int len) } peer = peer->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); return res; } @@ -1950,9 +1950,9 @@ static struct ast_channel *ast_iax_new(struct chan_iax_pvt *i, int state, int ca i->owner = tmp; i->capability = capability; ast_setstate(tmp, state); - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); if (state != AST_STATE_DOWN) { if (ast_pbx_start(tmp)) { @@ -2142,14 +2142,14 @@ static int iax_show_users(int fd, int argc, char *argv[]) struct iax_user *user; if (argc != 3) return RESULT_SHOWUSAGE; - ast_pthread_mutex_lock(&userl.lock); + ast_mutex_lock(&userl.lock); ast_cli(fd, FORMAT, "Username", "Secret", "Authen", "Def.Context", "A/C"); for(user=userl.users;user;user=user->next) { ast_cli(fd, FORMAT, user->name, user->secret, user->methods, user->contexts ? user->contexts->context : context, user->ha ? "Yes" : "No"); } - ast_pthread_mutex_unlock(&userl.lock); + ast_mutex_unlock(&userl.lock); return RESULT_SUCCESS; #undef FORMAT } @@ -2162,7 +2162,7 @@ static int iax_show_peers(int fd, int argc, char *argv[]) char name[256] = ""; if (argc != 3) return RESULT_SHOWUSAGE; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); ast_cli(fd, FORMAT2, "Name/Username", "Host", " ", "Mask", "Port", "Status"); for (peer = peerl.peers;peer;peer = peer->next) { char nm[20]; @@ -2189,7 +2189,7 @@ static int iax_show_peers(int fd, int argc, char *argv[]) nm, ntohs(peer->addr.sin_port), status); } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); return RESULT_SUCCESS; #undef FORMAT #undef FORMAT2 @@ -2236,7 +2236,7 @@ static int iax_show_registry(int fd, int argc, char *argv[]) char perceived[80]; if (argc != 3) return RESULT_SHOWUSAGE; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); ast_cli(fd, FORMAT2, "Host", "Username", "Perceived", "Refresh", "State"); for (reg = registrations;reg;reg = reg->next) { snprintf(host, sizeof(host), "%s:%d", inet_ntoa(reg->addr.sin_addr), ntohs(reg->addr.sin_port)); @@ -2247,7 +2247,7 @@ static int iax_show_registry(int fd, int argc, char *argv[]) ast_cli(fd, FORMAT, host, reg->username, perceived, reg->refresh, regstate2str(reg->regstate)); } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); return RESULT_SUCCESS; #undef FORMAT #undef FORMAT2 @@ -2263,7 +2263,7 @@ static int iax_show_channels(int fd, int argc, char *argv[]) return RESULT_SHOWUSAGE; ast_cli(fd, FORMAT2, "Peer", "Username", "ID (Lo/Rem)", "Seq (Tx/Rx)", "Lag", "Jitter", "Format"); for (x=0;xaddr.sin_addr), strlen(iaxs[x]->username) ? iaxs[x]->username : "(None)", @@ -2274,7 +2274,7 @@ static int iax_show_channels(int fd, int argc, char *argv[]) iaxs[x]->voiceformat); numchans++; } - ast_pthread_mutex_unlock(&iaxsl[x]); + ast_mutex_unlock(&iaxsl[x]); } ast_cli(fd, "%d active IAX channel(s)\n", numchans); return RESULT_SUCCESS; @@ -2499,7 +2499,7 @@ static int check_access(int callno, struct sockaddr_in *sin, char *orequest, int inet_ntoa(sin->sin_addr), version); return res; } - ast_pthread_mutex_lock(&userl.lock); + ast_mutex_lock(&userl.lock); /* Search the userlist for a compatible entry, and fill in the rest */ user = userl.users; while(user) { @@ -2541,7 +2541,7 @@ static int check_access(int callno, struct sockaddr_in *sin, char *orequest, int } user = user->next; } - ast_pthread_mutex_unlock(&userl.lock); + ast_mutex_unlock(&userl.lock); return res; } @@ -2860,7 +2860,7 @@ static int authenticate_reply(struct chan_iax_pvt *p, struct sockaddr_in *sin, c /* Normal password authentication */ res = authenticate(p->challenge, override, okey, methods, requeststr, sizeof(requeststr), sin); } else { - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peer = peerl.peers; while(peer) { if ((!strlen(p->peer) || !strcmp(p->peer, peer->name)) @@ -2876,7 +2876,7 @@ static int authenticate_reply(struct chan_iax_pvt *p, struct sockaddr_in *sin, c } peer = peer->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); } if (strlen(requeststr)) requeststr[strlen(requeststr)-1] = '\0'; @@ -2983,7 +2983,7 @@ static int complete_dpreply(struct chan_iax_pvt *pvt, char *orequest) } var = strsep(&stringp, ";"); } - ast_pthread_mutex_lock(&dpcache_lock); + ast_mutex_lock(&dpcache_lock); prev = NULL; dp = pvt->dpentries; while(dp) { @@ -3009,7 +3009,7 @@ static int complete_dpreply(struct chan_iax_pvt *pvt, char *orequest) prev = dp; dp = dp->peer; } - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); return 0; } @@ -3063,7 +3063,7 @@ static int complete_transfer(int callno, char *orequest) pvt->last = 0; pvt->lastsent = 0; pvt->pingtime = DEFAULT_RETRY_TIME; - ast_pthread_mutex_lock(&iaxq.lock); + ast_mutex_lock(&iaxq.lock); for (cur = iaxq.head; cur ; cur = cur->next) { /* We must cancel any packets that would have been transmitted because now we're talking to someone new. It's okay, they @@ -3071,7 +3071,7 @@ static int complete_transfer(int callno, char *orequest) if (callno == cur->callno) cur->retries = -1; } - ast_pthread_mutex_unlock(&iaxq.lock); + ast_mutex_unlock(&iaxq.lock); return 0; } @@ -3353,12 +3353,12 @@ static int auto_hangup(void *nothing) { /* Called from IAX thread only, without iaxs lock */ int callno = (int)(long)(nothing); - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); if (iaxs[callno]) { iaxs[callno]->autoid = -1; send_command_final(iaxs[callno], AST_FRAME_IAX, AST_IAX_COMMAND_HANGUP, 0, "Timeout", strlen("Timeout") + 1, -1); } - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); return 0; } @@ -3380,7 +3380,7 @@ static int iax_vnak(int callno) static void vnak_retransmit(int callno, int last) { struct ast_iax_frame *f; - ast_pthread_mutex_lock(&iaxq.lock); + ast_mutex_lock(&iaxq.lock); f = iaxq.head; while(f) { /* Send a copy immediately */ @@ -3390,7 +3390,7 @@ static void vnak_retransmit(int callno, int last) } f = f->next; } - ast_pthread_mutex_unlock(&iaxq.lock); + ast_mutex_unlock(&iaxq.lock); } static int iax_poke_peer_s(void *data) @@ -3460,7 +3460,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) fr.callno = find_callno(ntohs(mh->callno) & ~AST_FLAG_FULL, dcallno, &sin, new); if (fr.callno > 0) - ast_pthread_mutex_lock(&iaxsl[fr.callno]); + ast_mutex_lock(&iaxsl[fr.callno]); if ((fr.callno < 0) || !iaxs[fr.callno]) { /* A call arrived for a non-existant destination. Unless it's an "inval" @@ -3475,7 +3475,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) ); } if (fr.callno > 0) - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } if (((f.subclass != AST_IAX_COMMAND_TXCNT) && @@ -3515,7 +3515,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) /* Send a VNAK requesting retransmission */ iax_vnak(fr.callno); } - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } } else { @@ -3531,7 +3531,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) /* A full frame */ if (res < sizeof(struct ast_iax_full_hdr)) { ast_log(LOG_WARNING, "midget packet received (%d of %d min)\n", res, sizeof(struct ast_iax_full_hdr)); - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } f.datalen = res - sizeof(struct ast_iax_full_hdr); @@ -3553,13 +3553,13 @@ static int socket_read(int *id, int fd, short events, void *cbdata) ast_log(LOG_DEBUG, "Ooh, voice format changed to %d\n", f.subclass); if (iaxs[fr.callno]->owner) { int orignative; - ast_pthread_mutex_lock(&iaxs[fr.callno]->owner->lock); + ast_mutex_lock(&iaxs[fr.callno]->owner->lock); orignative = iaxs[fr.callno]->owner->nativeformats; iaxs[fr.callno]->owner->nativeformats = f.subclass; if (iaxs[fr.callno]->owner->readformat) ast_set_read_format(iaxs[fr.callno]->owner, iaxs[fr.callno]->owner->readformat); iaxs[fr.callno]->owner->nativeformats = orignative; - ast_pthread_mutex_unlock(&iaxs[fr.callno]->owner->lock); + ast_mutex_unlock(&iaxs[fr.callno]->owner->lock); } } } @@ -3579,7 +3579,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) switch(f.subclass) { case AST_IAX_COMMAND_ACK: /* Ack the packet with the given timestamp */ - ast_pthread_mutex_lock(&iaxq.lock); + ast_mutex_lock(&iaxq.lock); for (cur = iaxq.head; cur ; cur = cur->next) { /* If it's our call, and our timestamp, mark -1 retries */ if ((fr.callno == cur->callno) && (fr.seqno == cur->seqno)) { @@ -3592,7 +3592,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) } } } - ast_pthread_mutex_unlock(&iaxq.lock); + ast_mutex_unlock(&iaxq.lock); break; case AST_IAX_COMMAND_QUELCH: if (iaxs[fr.callno]->state & IAX_STATE_STARTED) @@ -3605,13 +3605,13 @@ static int socket_read(int *id, int fd, short events, void *cbdata) case AST_IAX_COMMAND_TXACC: if (iaxs[fr.callno]->transferring == TRANSFER_BEGIN) { /* Ack the packet with the given timestamp */ - ast_pthread_mutex_lock(&iaxq.lock); + ast_mutex_lock(&iaxq.lock); for (cur = iaxq.head; cur ; cur = cur->next) { /* Cancel any outstanding txcnt's */ if ((fr.callno == cur->callno) && (cur->transfer)) cur->retries = -1; } - ast_pthread_mutex_unlock(&iaxq.lock); + ast_mutex_unlock(&iaxq.lock); snprintf(rel1, sizeof(rel1), "callno=%d;", iaxs[fr.callno]->callno); send_command(iaxs[fr.callno], AST_FRAME_IAX, AST_IAX_COMMAND_TXREADY, 0, rel1, strlen(rel1) + 1, -1); iaxs[fr.callno]->transferring = TRANSFER_READY; @@ -3745,7 +3745,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) ast_set_read_format(iaxs[fr.callno]->owner, iaxs[fr.callno]->owner->readformat); } } - ast_pthread_mutex_lock(&dpcache_lock); + ast_mutex_lock(&dpcache_lock); dp = iaxs[fr.callno]->dpentries; while(dp) { if (!(dp->flags & CACHE_FLAG_TRANSMITTED)) { @@ -3753,7 +3753,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) } dp = dp->peer; } - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); break; case AST_IAX_COMMAND_POKE: /* Send back a pong packet with the original timestamp */ @@ -4030,7 +4030,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) ast_log(LOG_DEBUG, "Unknown IAX command %d on %d/%d\n", f.subclass, fr.callno, iaxs[fr.callno]->peercallno); } /* Don't actually pass these frames along */ - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } } else { @@ -4041,13 +4041,13 @@ static int socket_read(int *id, int fd, short events, void *cbdata) else { ast_log(LOG_WARNING, "Received mini frame before first full voice frame\n "); iax_vnak(fr.callno); - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } f.datalen = res - sizeof(struct ast_iax_mini_hdr); if (f.datalen < 0) { ast_log(LOG_WARNING, "Datalen < 0?\n"); - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } if (f.datalen) @@ -4058,7 +4058,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) } /* Don't pass any packets until we're started */ if (!(iaxs[fr.callno]->state & IAX_STATE_STARTED)) { - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } /* Common things */ @@ -4090,7 +4090,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) schedule_delivery(iaxfrdup2(&fr, 0), 1); #endif /* Always run again */ - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } @@ -4209,12 +4209,12 @@ static struct ast_channel *iax_request(char *type, int format, void *data) ast_log(LOG_WARNING, "Unable to create call\n"); return NULL; } - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); /* Keep track of sendani flag */ iaxs[callno]->sendani = sendani; iaxs[callno]->maxtime = maxtime; c = ast_iax_new(iaxs[callno], AST_STATE_DOWN, capability); - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); if (c) { /* Choose a format we can live with */ if (c->nativeformats & format) @@ -4245,7 +4245,7 @@ static void *network_thread(void *ignore) for(;;) { /* Go through the queue, sending messages which have not yet been sent, and scheduling retransmissions if appropriate */ - ast_pthread_mutex_lock(&iaxq.lock); + ast_mutex_lock(&iaxq.lock); f = iaxq.head; while(f) { freeme = NULL; @@ -4281,7 +4281,7 @@ static void *network_thread(void *ignore) if (freeme) ast_iax_frame_free(freeme); } - ast_pthread_mutex_unlock(&iaxq.lock); + ast_mutex_unlock(&iaxq.lock); res = ast_sched_wait(sched); if ((res > 1000) || (res < 0)) res = 1000; @@ -4316,7 +4316,7 @@ static struct iax_peer *build_peer(char *name, struct ast_variable *v) int format; int found=0; prev = NULL; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peer = peerl.peers; while(peer) { if (!strcasecmp(peer->name, name)) { @@ -4333,9 +4333,9 @@ static struct iax_peer *build_peer(char *name, struct ast_variable *v) } else { peerl.peers = peer->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); } else { - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); peer = malloc(sizeof(struct iax_peer)); memset(peer, 0, sizeof(struct iax_peer)); peer->expire = -1; @@ -4507,7 +4507,7 @@ static void delete_users(void){ struct iax_registry *reg, *regl; /* Delete all users */ - ast_pthread_mutex_lock(&userl.lock); + ast_mutex_lock(&userl.lock); for (user=userl.users;user;) { ast_free_ha(user->ha); free_context(user->contexts); @@ -4516,7 +4516,7 @@ static void delete_users(void){ free(userlast); } userl.users=NULL; - ast_pthread_mutex_unlock(&userl.lock); + ast_mutex_unlock(&userl.lock); for (reg = registrations;reg;) { regl = reg; @@ -4526,30 +4526,30 @@ static void delete_users(void){ free(regl); } registrations = NULL; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); for (peer=peerl.peers;peer;) { /* Assume all will be deleted, and we'll find out for sure later */ peer->delme = 1; peer = peer->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); } static void prune_peers(void){ /* Prune peers who still are supposed to be deleted */ struct iax_peer *peer, *peerlast, *peernext; int x; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peerlast = NULL; for (peer=peerl.peers;peer;) { peernext = peer->next; if (peer->delme) { for (x=0;xpeerpoke == peer)) { iax_destroy(x); } - ast_pthread_mutex_unlock(&iaxsl[x]); + ast_mutex_unlock(&iaxsl[x]); } /* Delete it, it needs to disappear */ if (peer->expire > -1) @@ -4567,7 +4567,7 @@ static void prune_peers(void){ peerlast = peer; peer=peernext; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); } @@ -4675,19 +4675,19 @@ static int set_config(char *config_file, struct sockaddr_in* sin){ if (!strcasecmp(utype, "user") || !strcasecmp(utype, "friend")) { user = build_user(cat, ast_variable_browse(cfg, cat)); if (user) { - ast_pthread_mutex_lock(&userl.lock); + ast_mutex_lock(&userl.lock); user->next = userl.users; userl.users = user; - ast_pthread_mutex_unlock(&userl.lock); + ast_mutex_unlock(&userl.lock); } } if (!strcasecmp(utype, "peer") || !strcasecmp(utype, "friend")) { peer = build_peer(cat, ast_variable_browse(cfg, cat)); if (peer) { - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peer->next = peerl.peers; peerl.peers = peer; - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); } } else if (strcasecmp(utype, "user")) { ast_log(LOG_WARNING, "Unknown type '%s' for '%s' in %s\n", utype, cat, config_file); @@ -4736,12 +4736,12 @@ static int cache_get_callno(char *data) for (x=0;xdproot)) { - ast_pthread_mutex_unlock(&iaxsl[x]); + ast_mutex_unlock(&iaxsl[x]); return x; } - ast_pthread_mutex_unlock(&iaxsl[x]); + ast_mutex_unlock(&iaxsl[x]); } } /* No match found, we need to create a new one */ @@ -4779,7 +4779,7 @@ static int cache_get_callno(char *data) ast_log(LOG_WARNING, "Unable to create call\n"); return -1; } - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); strncpy(iaxs[callno]->dproot, data, sizeof(iaxs[callno]->dproot)-1); iaxs[callno]->capability = IAX_CAPABILITY_FULLBANDWIDTH; MYSNPRINTF "exten=TBD;"); @@ -4800,7 +4800,7 @@ static int cache_get_callno(char *data) ast_verbose(VERBOSE_PREFIX_3 "Calling TBD using options '%s'\n", requeststr); /* Start the call going */ send_command(iaxs[callno], AST_FRAME_IAX, AST_IAX_COMMAND_NEW, 0, requeststr, strlen(requeststr) + 1, -1); - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); return callno; } @@ -4895,7 +4895,7 @@ static struct iax_dpcache *find_cache(struct ast_channel *chan, char *data, char /* Okay, now we wait */ timeout = iaxdefaulttimeout * 1000; /* Temporarily unlock */ - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); /* Defer any dtmf */ if (chan) old = ast_channel_defer_dtmf(chan); @@ -4919,7 +4919,7 @@ static struct iax_dpcache *find_cache(struct ast_channel *chan, char *data, char if (!timeout) { ast_log(LOG_WARNING, "Timeout waiting for %s exten %s\n", data, exten); } - ast_pthread_mutex_lock(&dpcache_lock); + ast_mutex_lock(&dpcache_lock); dp->waiters[x] = -1; close(com[1]); close(com[0]); @@ -4961,13 +4961,13 @@ static int iax_exists(struct ast_channel *chan, char *context, char *exten, int #endif if (priority != 1) return 0; - ast_pthread_mutex_lock(&dpcache_lock); + ast_mutex_lock(&dpcache_lock); dp = find_cache(chan, data, context, exten, priority); if (dp) { if (dp->flags & CACHE_FLAG_EXISTS) res= 1; } - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); if (!dp) { ast_log(LOG_WARNING, "Unable to make DP cache\n"); } @@ -4983,13 +4983,13 @@ static int iax_canmatch(struct ast_channel *chan, char *context, char *exten, in #endif if (priority != 1) return 0; - ast_pthread_mutex_lock(&dpcache_lock); + ast_mutex_lock(&dpcache_lock); dp = find_cache(chan, data, context, exten, priority); if (dp) { if (dp->flags & CACHE_FLAG_CANEXIST) res= 1; } - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); if (!dp) { ast_log(LOG_WARNING, "Unable to make DP cache\n"); } @@ -5005,13 +5005,13 @@ static int iax_matchmore(struct ast_channel *chan, char *context, char *exten, i #endif if (priority != 1) return 0; - ast_pthread_mutex_lock(&dpcache_lock); + ast_mutex_lock(&dpcache_lock); dp = find_cache(chan, data, context, exten, priority); if (dp) { if (dp->flags & CACHE_FLAG_MATCHMORE) res= 1; } - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); if (!dp) { ast_log(LOG_WARNING, "Unable to make DP cache\n"); } @@ -5030,7 +5030,7 @@ static int iax_exec(struct ast_channel *chan, char *context, char *exten, int pr #endif if (priority != 1) return -1; - ast_pthread_mutex_lock(&dpcache_lock); + ast_mutex_lock(&dpcache_lock); dp = find_cache(chan, data, context, exten, priority); if (dp) { if (dp->flags & CACHE_FLAG_EXISTS) { @@ -5046,12 +5046,12 @@ static int iax_exec(struct ast_channel *chan, char *context, char *exten, int pr if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Executing Dial('%s')\n", req); } else { - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); ast_log(LOG_WARNING, "Can't execute non-existant extension '%s[@%s]' in data '%s'\n", exten, context, data); return -1; } } - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); dial = pbx_findapp("Dial"); if (dial) { pbx_exec(chan, dial, req, newstack); @@ -5089,7 +5089,7 @@ int load_module(void) sin.sin_addr.s_addr = INADDR_ANY; for (x=0;xnext) iax_do_register(reg); - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); for (peer = peerl.peers; peer; peer = peer->next) iax_poke_peer(peer); - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); return res; } @@ -5192,9 +5192,9 @@ int unload_module() int usecount() { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } diff --git a/channels/chan_iax2.c b/channels/chan_iax2.c index 83f4723af..b6feec094 100755 --- a/channels/chan_iax2.c +++ b/channels/chan_iax2.c @@ -107,7 +107,7 @@ static int expirey = IAX_DEFAULT_REG_EXPIRE; static int timingfd = -1; /* Timing file descriptor */ static int usecnt; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; int (*iax2_regfunk)(char *username, int onoff) = NULL; @@ -397,17 +397,17 @@ static struct ast_iax2_queue { struct iax_frame *head; struct iax_frame *tail; int count; - pthread_mutex_t lock; + ast_mutex_t lock; } iaxq; static struct ast_user_list { struct iax2_user *users; - pthread_mutex_t lock; + ast_mutex_t lock; } userl; static struct ast_peer_list { struct iax2_peer *peers; - pthread_mutex_t lock; + ast_mutex_t lock; } peerl; /* Extension exists */ @@ -439,7 +439,7 @@ static struct iax2_dpcache { struct iax2_dpcache *peer; /* For linking in peers */ } *dpcache; -static pthread_mutex_t dpcache_lock; +static ast_mutex_t dpcache_lock; static void iax_debug_output(const char *data) { @@ -453,7 +453,7 @@ static void iax_error_output(const char *data) /* XXX We probably should use a mutex when working with this XXX */ static struct chan_iax2_pvt *iaxs[IAX_MAX_CALLS]; -static pthread_mutex_t iaxsl[IAX_MAX_CALLS]; +static ast_mutex_t iaxsl[IAX_MAX_CALLS]; static struct timeval lastused[IAX_MAX_CALLS]; @@ -531,7 +531,7 @@ static int iax2_getpeername(struct sockaddr_in sin, char *host, int len, int loc struct iax2_peer *peer; int res = 0; if (lockpeer) - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peer = peerl.peers; while(peer) { if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) && @@ -543,7 +543,7 @@ static int iax2_getpeername(struct sockaddr_in sin, char *host, int len, int loc peer = peer->next; } if (lockpeer) - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); return res; } @@ -692,7 +692,7 @@ static int make_trunk(unsigned short callno, int locked) } gettimeofday(&now, NULL); for (x=TRUNK_CALL_START;x MIN_REUSE_TIME)) { iaxs[x] = iaxs[callno]; iaxs[x]->callno = x; @@ -705,13 +705,13 @@ static int make_trunk(unsigned short callno, int locked) iaxs[x]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, (void *)x); iaxs[x]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)x); if (locked) - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); res = x; if (!locked) - ast_pthread_mutex_unlock(&iaxsl[x]); + ast_mutex_unlock(&iaxsl[x]); break; } - ast_pthread_mutex_unlock(&iaxsl[x]); + ast_mutex_unlock(&iaxsl[x]); } if (x >= IAX_MAX_CALLS - 1) { ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n"); @@ -732,33 +732,33 @@ static int find_callno(unsigned short callno, unsigned short dcallno, struct soc if (new <= NEW_ALLOW) { /* Look for an existing connection first */ for (x=1;(res < 1) && (x= NEW_ALLOW)) { gettimeofday(&now, NULL); for (x=1;x MIN_REUSE_TIME)) break; - ast_pthread_mutex_unlock(&iaxsl[x]); + ast_mutex_unlock(&iaxsl[x]); } /* We've still got lock held if we found a spot */ if (x >= TRUNK_CALL_START) { @@ -766,7 +766,7 @@ static int find_callno(unsigned short callno, unsigned short dcallno, struct soc return -1; } iaxs[x] = new_iax(sin, lockpeer); - ast_pthread_mutex_unlock(&iaxsl[x]); + ast_mutex_unlock(&iaxsl[x]); update_max_nontrunk(); if (iaxs[x]) { if (option_debug) @@ -805,19 +805,19 @@ static int iax2_queue_frame(int callno, struct ast_frame *f) /* Assumes lock for callno is already held... */ for (;;) { pass++; - if (!pthread_mutex_trylock(&iaxsl[callno])) { + if (!ast_mutex_trylock(&iaxsl[callno])) { ast_log(LOG_WARNING, "Lock is not held on pass %d of iax2_queue_frame\n", pass); CRASH; } if (iaxs[callno] && iaxs[callno]->owner) { - if (pthread_mutex_trylock(&iaxs[callno]->owner->lock)) { + if (ast_mutex_trylock(&iaxs[callno]->owner->lock)) { /* Avoid deadlock by pausing and trying again */ - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); usleep(1); - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); } else { ast_queue_frame(iaxs[callno]->owner, f, 0); - ast_pthread_mutex_unlock(&iaxs[callno]->owner->lock); + ast_mutex_unlock(&iaxs[callno]->owner->lock); break; } } else @@ -864,9 +864,9 @@ static int do_deliver(void *data) struct iax_frame *fr = data; int callno = fr->callno; int res; - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); res = __do_deliver(data); - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); return res; } @@ -944,10 +944,10 @@ static int iax2_predestroy(int callno) { struct ast_channel *c; struct chan_iax2_pvt *pvt; - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); pvt = iaxs[callno]; if (!pvt) { - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); return -1; } if (!pvt->alreadygone) { @@ -972,23 +972,23 @@ static int iax2_predestroy(int callno) c->pvt->pvt = NULL; ast_queue_hangup(c, 0); pvt->owner = NULL; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt--; if (usecnt < 0) ast_log(LOG_WARNING, "Usecnt < 0???\n"); - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); } - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); return 0; } static int iax2_predestroy_nolock(int callno) { int res; - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); res = iax2_predestroy(callno); - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); return res; } @@ -999,7 +999,7 @@ static void iax2_destroy(int callno) struct ast_channel *owner; retry: - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); pvt = iaxs[callno]; gettimeofday(&lastused[callno], NULL); @@ -1008,9 +1008,9 @@ retry: else owner = NULL; if (owner) { - if (pthread_mutex_trylock(&owner->lock)) { + if (ast_mutex_trylock(&owner->lock)) { ast_log(LOG_NOTICE, "Avoiding IAX destroy deadlock\n"); - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); usleep(1); goto retry; } @@ -1053,18 +1053,18 @@ retry: free(pvt); } if (owner) { - ast_pthread_mutex_unlock(&owner->lock); + ast_mutex_unlock(&owner->lock); } - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); if (callno & 0x4000) update_max_trunk(); } static void iax2_destroy_nolock(int callno) { /* Actually it's easier to unlock, kill it, and relock */ - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); iax2_destroy(callno); - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); } static int update_packet(struct iax_frame *f) @@ -1088,7 +1088,7 @@ static int attempt_transmit(void *data) int callno = f->callno; /* Make sure this call is still active */ if (callno) - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); if ((f->callno) && iaxs[f->callno]) { if ((f->retries < 0) /* Already ACK'd */ || (f->retries >= max_retries) /* Too many attempts */) { @@ -1143,11 +1143,11 @@ static int attempt_transmit(void *data) freeme++; } if (callno) - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); /* Do not try again */ if (freeme) { /* Don't attempt delivery, just remove it from the queue */ - ast_pthread_mutex_lock(&iaxq.lock); + ast_mutex_lock(&iaxq.lock); if (f->prev) f->prev->next = f->next; else @@ -1157,7 +1157,7 @@ static int attempt_transmit(void *data) else iaxq.tail = f->prev; iaxq.count--; - ast_pthread_mutex_unlock(&iaxq.lock); + ast_mutex_unlock(&iaxq.lock); f->retrans = -1; /* Free the IAX frame */ iax2_frame_free(f); @@ -1224,7 +1224,7 @@ static int iax2_show_cache(int fd, int argc, char *argv[]) int x,y; struct timeval tv; gettimeofday(&tv, NULL); - ast_pthread_mutex_lock(&dpcache_lock); + ast_mutex_lock(&dpcache_lock); dp = dpcache; ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags"); while(dp) { @@ -1266,7 +1266,7 @@ static int iax2_show_cache(int fd, int argc, char *argv[]) ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp); dp = dp->next; } - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); return RESULT_SUCCESS; } @@ -1449,7 +1449,7 @@ static int iax2_transmit(struct iax_frame *fr) /* By setting this to 0, the network thread will send it for us, and queue retransmission if necessary */ fr->sentyet = 0; - ast_pthread_mutex_lock(&iaxq.lock); + ast_mutex_lock(&iaxq.lock); if (!iaxq.head) { /* Empty queue */ iaxq.head = fr; @@ -1461,7 +1461,7 @@ static int iax2_transmit(struct iax_frame *fr) iaxq.tail = fr; } iaxq.count++; - ast_pthread_mutex_unlock(&iaxq.lock); + ast_mutex_unlock(&iaxq.lock); /* Wake up the network thread */ pthread_kill(netthreadid, SIGURG); return 0; @@ -1510,7 +1510,7 @@ static int create_addr(struct sockaddr_in *sin, int *capability, int *sendani, i if (trunk) *trunk = 0; sin->sin_family = AF_INET; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); p = peerl.peers; while(p) { if (!strcasecmp(p->name, peer)) { @@ -1543,7 +1543,7 @@ static int create_addr(struct sockaddr_in *sin, int *capability, int *sendani, i } p = p->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); if (!p && !found) { hp = gethostbyname(peer); if (hp) { @@ -1564,13 +1564,13 @@ static int auto_congest(void *nothing) { int callno = (int)(long)(nothing); struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_CONGESTION }; - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); if (iaxs[callno]) { iaxs[callno]->initid = -1; iax2_queue_frame(callno, &f); ast_log(LOG_NOTICE, "Auto-congesting call due to slow response\n"); } - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); return 0; } @@ -1718,7 +1718,7 @@ static int iax2_hangup(struct ast_channel *c) int callno; if (pvt) { callno = pvt->callno; - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); ast_log(LOG_DEBUG, "We're hanging up %s now...\n", c->name); alreadygone = pvt->alreadygone; /* Send the hangup unless we have had a transmission error or are already gone */ @@ -1731,7 +1731,7 @@ static int iax2_hangup(struct ast_channel *c) ast_log(LOG_DEBUG, "Really destroying %s now...\n", c->name); iax2_destroy_nolock(callno); } - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); } if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Hungup '%s'\n", c->name); @@ -1965,7 +1965,7 @@ static int iax2_getpeertrunk(struct sockaddr_in sin) { struct iax2_peer *peer; int res = 0; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peer = peerl.peers; while(peer) { if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) && @@ -1975,7 +1975,7 @@ static int iax2_getpeertrunk(struct sockaddr_in sin) } peer = peer->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); return res; } @@ -2027,9 +2027,9 @@ static struct ast_channel *ast_iax2_new(struct chan_iax2_pvt *i, int state, int i->owner = tmp; i->capability = capability; ast_setstate(tmp, state); - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); if (state != AST_STATE_DOWN) { if (ast_pbx_start(tmp)) { @@ -2309,14 +2309,14 @@ static int iax2_show_users(int fd, int argc, char *argv[]) struct iax2_user *user; if (argc != 3) return RESULT_SHOWUSAGE; - ast_pthread_mutex_lock(&userl.lock); + ast_mutex_lock(&userl.lock); ast_cli(fd, FORMAT, "Username", "Secret", "Authen", "Def.Context", "A/C"); for(user=userl.users;user;user=user->next) { ast_cli(fd, FORMAT2, user->name, user->secret, user->authmethods, user->contexts ? user->contexts->context : context, user->ha ? "Yes" : "No"); } - ast_pthread_mutex_unlock(&userl.lock); + ast_mutex_unlock(&userl.lock); return RESULT_SUCCESS; #undef FORMAT #undef FORMAT2 @@ -2337,7 +2337,7 @@ static int iax2_show_peers(int fd, int argc, char *argv[]) } else return RESULT_SHOWUSAGE; } - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); ast_cli(fd, FORMAT2, "Name/Username", "Host", " ", "Mask", "Port", "Status"); for (peer = peerl.peers;peer;peer = peer->next) { char nm[20]; @@ -2366,7 +2366,7 @@ static int iax2_show_peers(int fd, int argc, char *argv[]) nm, ntohs(peer->addr.sin_port), peer->trunk ? "(T)" : " ", status); } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); return RESULT_SUCCESS; #undef FORMAT #undef FORMAT2 @@ -2413,7 +2413,7 @@ static int iax2_show_registry(int fd, int argc, char *argv[]) char perceived[80]; if (argc != 3) return RESULT_SHOWUSAGE; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); ast_cli(fd, FORMAT2, "Host", "Username", "Perceived", "Refresh", "State"); for (reg = registrations;reg;reg = reg->next) { snprintf(host, sizeof(host), "%s:%d", inet_ntoa(reg->addr.sin_addr), ntohs(reg->addr.sin_port)); @@ -2424,7 +2424,7 @@ static int iax2_show_registry(int fd, int argc, char *argv[]) ast_cli(fd, FORMAT, host, reg->username, perceived, reg->refresh, regstate2str(reg->regstate)); } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); return RESULT_SUCCESS; #undef FORMAT #undef FORMAT2 @@ -2440,7 +2440,7 @@ static int iax2_show_channels(int fd, int argc, char *argv[]) return RESULT_SHOWUSAGE; ast_cli(fd, FORMAT2, "Peer", "Username", "ID (Lo/Rem)", "Seq (Tx/Rx)", "Lag", "Jitter", "Format"); for (x=0;xaddr.sin_addr), strlen(iaxs[x]->username) ? iaxs[x]->username : "(None)", @@ -2451,7 +2451,7 @@ static int iax2_show_channels(int fd, int argc, char *argv[]) iaxs[x]->voiceformat); numchans++; } - ast_pthread_mutex_unlock(&iaxsl[x]); + ast_mutex_unlock(&iaxsl[x]); } ast_cli(fd, "%d active IAX channel(s)\n", numchans); return RESULT_SUCCESS; @@ -2654,7 +2654,7 @@ static int check_access(int callno, struct sockaddr_in *sin, struct iax_ies *ies inet_ntoa(sin->sin_addr), version); return res; } - ast_pthread_mutex_lock(&userl.lock); + ast_mutex_lock(&userl.lock); /* Search the userlist for a compatible entry, and fill in the rest */ user = userl.users; while(user) { @@ -2699,7 +2699,7 @@ static int check_access(int callno, struct sockaddr_in *sin, struct iax_ies *ies } user = user->next; } - ast_pthread_mutex_unlock(&userl.lock); + ast_mutex_unlock(&userl.lock); iaxs[callno]->trunk = iax2_getpeertrunk(*sin); return res; } @@ -2970,7 +2970,7 @@ static int authenticate_reply(struct chan_iax2_pvt *p, struct sockaddr_in *sin, /* Normal password authentication */ res = authenticate(p->challenge, override, okey, authmethods, &ied, sin); } else { - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peer = peerl.peers; while(peer) { if ((!strlen(p->peer) || !strcmp(p->peer, peer->name)) @@ -2986,7 +2986,7 @@ static int authenticate_reply(struct chan_iax2_pvt *p, struct sockaddr_in *sin, } peer = peer->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); } if (!res) res = send_command(p, AST_FRAME_IAX, IAX_COMMAND_AUTHREP, 0, ied.buf, ied.pos, -1); @@ -3058,7 +3058,7 @@ static int complete_dpreply(struct chan_iax2_pvt *pvt, struct iax_ies *ies) expirey = ies->refresh; if (ies->dpstatus & IAX_DPSTATUS_MATCHMORE) matchmore = CACHE_FLAG_MATCHMORE; - ast_pthread_mutex_lock(&dpcache_lock); + ast_mutex_lock(&dpcache_lock); prev = NULL; dp = pvt->dpentries; while(dp) { @@ -3084,7 +3084,7 @@ static int complete_dpreply(struct chan_iax2_pvt *pvt, struct iax_ies *ies) prev = dp; dp = dp->peer; } - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); return 0; } @@ -3123,7 +3123,7 @@ static int complete_transfer(int callno, struct iax_ies *ies) pvt->last = 0; pvt->lastsent = 0; pvt->pingtime = DEFAULT_RETRY_TIME; - ast_pthread_mutex_lock(&iaxq.lock); + ast_mutex_lock(&iaxq.lock); for (cur = iaxq.head; cur ; cur = cur->next) { /* We must cancel any packets that would have been transmitted because now we're talking to someone new. It's okay, they @@ -3131,7 +3131,7 @@ static int complete_transfer(int callno, struct iax_ies *ies) if (callno == cur->callno) cur->retries = -1; } - ast_pthread_mutex_unlock(&iaxq.lock); + ast_mutex_unlock(&iaxq.lock); return 0; } @@ -3395,14 +3395,14 @@ static int auto_hangup(void *nothing) /* Called from IAX thread only, without iaxs lock */ int callno = (int)(long)(nothing); struct iax_ie_data ied; - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); if (iaxs[callno]) { iaxs[callno]->autoid = -1; memset(&ied, 0, sizeof(ied)); iax_ie_append_str(&ied, IAX_IE_CAUSE, "Timeout"); send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, ied.buf, ied.pos, -1); } - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); return 0; } @@ -3427,7 +3427,7 @@ static int iax2_vnak(int callno) static void vnak_retransmit(int callno, int last) { struct iax_frame *f; - ast_pthread_mutex_lock(&iaxq.lock); + ast_mutex_lock(&iaxq.lock); f = iaxq.head; while(f) { /* Send a copy immediately */ @@ -3437,7 +3437,7 @@ static void vnak_retransmit(int callno, int last) } f = f->next; } - ast_pthread_mutex_unlock(&iaxq.lock); + ast_mutex_unlock(&iaxq.lock); } static int iax2_poke_peer_s(void *data) @@ -3472,7 +3472,7 @@ static int send_trunk(struct iax2_peer *peer) /* Search through trunked calls for a match with this peer */ for (x=TRUNK_CALL_START;xaddr.sin_addr), ntohs(iaxs[x]->addr.sin_port), iaxs[x]->addr.sin_family); @@ -3500,7 +3500,7 @@ static int send_trunk(struct iax2_peer *peer) if (!firstcall) firstcall = x; } - ast_pthread_mutex_unlock(&iaxsl[x]); + ast_mutex_unlock(&iaxsl[x]); } if (calls) { /* We're actually sending a frame, so fill the meta trunk header and meta header */ @@ -3548,12 +3548,12 @@ static int timing_read(int *id, int fd, short events, void *cbdata) res = read(fd, buf, sizeof(buf)); if (res < 1) { ast_log(LOG_WARNING, "Unable to read from timing fd\n"); - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); return 1; } } /* For each peer that supports trunking... */ - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peer = peerl.peers; while(peer) { if (peer->trunk) { @@ -3566,7 +3566,7 @@ static int timing_read(int *id, int fd, short events, void *cbdata) } peer = peer->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); if (iaxtrunkdebug) ast_verbose("Ending trunk processing with %d peers and %d calls processed\n", processed, totalcalls); iaxtrunkdebug =0; @@ -3634,14 +3634,14 @@ static int socket_read(int *id, int fd, short events, void *cbdata) ts = ntohl(mth->ts); res -= (sizeof(struct ast_iax2_meta_hdr) + sizeof(struct ast_iax2_meta_trunk_hdr)); ptr = mth->data; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peer = peerl.peers; while(peer) { if (!inaddrcmp(&peer->addr, &sin)) break; peer = peer->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); if (!peer) { ast_log(LOG_WARNING, "Unable to accept trunked packet from '%s:%d': No matching peer\n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port)); return 1; @@ -3660,7 +3660,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) break; fr.callno = find_callno(ntohs(mte->callno) & ~IAX_FLAG_FULL, 0, &sin, NEW_PREVENT, 1); if (fr.callno) { - ast_pthread_mutex_lock(&iaxsl[fr.callno]); + ast_mutex_lock(&iaxsl[fr.callno]); /* If it's a valid call, deliver the contents. If not, we drop it, since we don't have a scallno to use for an INVAL */ /* Process as a mini frame */ @@ -3703,7 +3703,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) ast_log(LOG_WARNING, "Received trunked frame before first full voice frame\n "); iax2_vnak(fr.callno); } - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); } ptr += len; res -= len; @@ -3739,7 +3739,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) fr.callno = find_callno(ntohs(mh->callno) & ~IAX_FLAG_FULL, dcallno, &sin, new, 1); if (fr.callno > 0) - ast_pthread_mutex_lock(&iaxsl[fr.callno]); + ast_mutex_lock(&iaxsl[fr.callno]); if (!fr.callno || !iaxs[fr.callno]) { /* A call arrived for a non-existant destination. Unless it's an "inval" @@ -3754,7 +3754,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) ); } if (fr.callno > 0) - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } if (!inaddrcmp(&sin, &iaxs[fr.callno]->addr) && !minivid) @@ -3798,7 +3798,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) /* Send a VNAK requesting retransmission */ iax2_vnak(fr.callno); } - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } } else { @@ -3814,7 +3814,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) /* A full frame */ if (res < sizeof(struct ast_iax2_full_hdr)) { ast_log(LOG_WARNING, "midget packet received (%d of %d min)\n", res, sizeof(struct ast_iax2_full_hdr)); - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } f.datalen = res - sizeof(struct ast_iax2_full_hdr); @@ -3838,7 +3838,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) /* Ack the packet with the given timestamp */ if (option_debug) ast_log(LOG_DEBUG, "Cancelling transmission of packet %d\n", x); - ast_pthread_mutex_lock(&iaxq.lock); + ast_mutex_lock(&iaxq.lock); for (cur = iaxq.head; cur ; cur = cur->next) { /* If it's our call, and our timestamp, mark -1 retries */ if ((fr.callno == cur->callno) && (x == cur->oseqno)) { @@ -3851,14 +3851,14 @@ static int socket_read(int *id, int fd, short events, void *cbdata) } } } - ast_pthread_mutex_unlock(&iaxq.lock); + ast_mutex_unlock(&iaxq.lock); } /* Note how much we've received acknowledgement for */ if (iaxs[fr.callno]) iaxs[fr.callno]->rseqno = fr.iseqno; else { /* Stop processing now */ - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } } else @@ -3869,7 +3869,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) ((f.subclass != IAX_COMMAND_TXACC) && (f.subclass != IAX_COMMAND_TXCNT)))) { /* Only messages we accept from a transfer host are TXACC and TXCNT */ - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } @@ -3877,7 +3877,7 @@ static int socket_read(int *id, int fd, short events, void *cbdata) if (f.frametype == AST_FRAME_IAX) { if (iax_parse_ies(&ies, buf + sizeof(struct ast_iax2_full_hdr), f.datalen)) { ast_log(LOG_WARNING, "undecodable frame received\n"); - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } f.data = NULL; @@ -3897,10 +3897,10 @@ static int socket_read(int *id, int fd, short events, void *cbdata) if (iaxs[fr.callno]->owner) { int orignative; retryowner: - if (pthread_mutex_trylock(&iaxs[fr.callno]->owner->lock)) { - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + if (ast_mutex_trylock(&iaxs[fr.callno]->owner->lock)) { + ast_mutex_unlock(&iaxsl[fr.callno]); usleep(1); - ast_pthread_mutex_lock(&iaxsl[fr.callno]); + ast_mutex_lock(&iaxsl[fr.callno]); if (iaxs[fr.callno] && iaxs[fr.callno]->owner) goto retryowner; } if (iaxs[fr.callno]) { @@ -3910,11 +3910,11 @@ retryowner: if (iaxs[fr.callno]->owner->readformat) ast_set_read_format(iaxs[fr.callno]->owner, iaxs[fr.callno]->owner->readformat); iaxs[fr.callno]->owner->nativeformats = orignative; - ast_pthread_mutex_unlock(&iaxs[fr.callno]->owner->lock); + ast_mutex_unlock(&iaxs[fr.callno]->owner->lock); } } else { ast_log(LOG_DEBUG, "Neat, somebody took away the channel at a magical time but i found it!\n"); - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } } @@ -3954,13 +3954,13 @@ retryowner: case IAX_COMMAND_TXACC: if (iaxs[fr.callno]->transferring == TRANSFER_BEGIN) { /* Ack the packet with the given timestamp */ - ast_pthread_mutex_lock(&iaxq.lock); + ast_mutex_lock(&iaxq.lock); for (cur = iaxq.head; cur ; cur = cur->next) { /* Cancel any outstanding txcnt's */ if ((fr.callno == cur->callno) && (cur->transfer)) cur->retries = -1; } - ast_pthread_mutex_unlock(&iaxq.lock); + ast_mutex_unlock(&iaxq.lock); memset(&ied1, 0, sizeof(ied1)); iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[fr.callno]->callno); send_command(iaxs[fr.callno], AST_FRAME_IAX, IAX_COMMAND_TXREADY, 0, ied1.buf, ied1.pos, -1); @@ -4125,7 +4125,7 @@ retryowner: ast_set_read_format(iaxs[fr.callno]->owner, iaxs[fr.callno]->owner->readformat); } } - ast_pthread_mutex_lock(&dpcache_lock); + ast_mutex_lock(&dpcache_lock); dp = iaxs[fr.callno]->dpentries; while(dp) { if (!(dp->flags & CACHE_FLAG_TRANSMITTED)) { @@ -4133,7 +4133,7 @@ retryowner: } dp = dp->peer; } - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); break; case IAX_COMMAND_POKE: /* Send back a pong packet with the original timestamp */ @@ -4430,7 +4430,7 @@ retryowner: if (iaxs[fr.callno] && iaxs[fr.callno]->aseqno != iaxs[fr.callno]->iseqno) send_command_immediate(iaxs[fr.callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr.ts, NULL, 0,fr.iseqno); } - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } /* Unless this is an ACK or INVAL frame, ack it */ @@ -4443,7 +4443,7 @@ retryowner: else { ast_log(LOG_WARNING, "Received mini frame before first full voice frame\n "); iax2_vnak(fr.callno); - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } f.datalen = res - sizeof(struct ast_iax2_video_hdr); @@ -4460,13 +4460,13 @@ retryowner: else { ast_log(LOG_WARNING, "Received mini frame before first full voice frame\n "); iax2_vnak(fr.callno); - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } f.datalen = res - sizeof(struct ast_iax2_mini_hdr); if (f.datalen < 0) { ast_log(LOG_WARNING, "Datalen < 0?\n"); - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } if (f.datalen) @@ -4477,7 +4477,7 @@ retryowner: } /* Don't pass any packets until we're started */ if (!(iaxs[fr.callno]->state & IAX_STATE_STARTED)) { - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } /* Common things */ @@ -4509,7 +4509,7 @@ retryowner: schedule_delivery(iaxfrdup2(&fr), 1, updatehistory); #endif /* Always run again */ - ast_pthread_mutex_unlock(&iaxsl[fr.callno]); + ast_mutex_unlock(&iaxsl[fr.callno]); return 1; } @@ -4632,7 +4632,7 @@ static struct ast_channel *iax2_request(char *type, int format, void *data) ast_log(LOG_WARNING, "Unable to create call\n"); return NULL; } - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); /* If this is a trunk, update it now */ iaxs[callno]->trunk = trunk; if (trunk) @@ -4642,7 +4642,7 @@ static struct ast_channel *iax2_request(char *type, int format, void *data) iaxs[callno]->maxtime = maxtime; iaxs[callno]->notransfer = notransfer; c = ast_iax2_new(iaxs[callno], AST_STATE_DOWN, capability); - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); if (c) { /* Choose a format we can live with */ if (c->nativeformats & format) @@ -4675,7 +4675,7 @@ static void *network_thread(void *ignore) for(;;) { /* Go through the queue, sending messages which have not yet been sent, and scheduling retransmissions if appropriate */ - ast_pthread_mutex_lock(&iaxq.lock); + ast_mutex_lock(&iaxq.lock); f = iaxq.head; while(f) { freeme = NULL; @@ -4708,7 +4708,7 @@ static void *network_thread(void *ignore) if (freeme) iax_frame_free(freeme); } - ast_pthread_mutex_unlock(&iaxq.lock); + ast_mutex_unlock(&iaxq.lock); res = ast_sched_wait(sched); if ((res > 1000) || (res < 0)) res = 1000; @@ -4755,7 +4755,7 @@ static struct iax2_peer *build_peer(char *name, struct ast_variable *v) int format; int found=0; prev = NULL; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peer = peerl.peers; while(peer) { if (!strcasecmp(peer->name, name)) { @@ -4772,9 +4772,9 @@ static struct iax2_peer *build_peer(char *name, struct ast_variable *v) } else { peerl.peers = peer->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); } else { - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); peer = malloc(sizeof(struct iax2_peer)); memset(peer, 0, sizeof(struct iax2_peer)); peer->expire = -1; @@ -4967,7 +4967,7 @@ static void delete_users(void){ struct iax2_registry *reg, *regl; /* Delete all users */ - ast_pthread_mutex_lock(&userl.lock); + ast_mutex_lock(&userl.lock); for (user=userl.users;user;) { ast_free_ha(user->ha); free_context(user->contexts); @@ -4976,7 +4976,7 @@ static void delete_users(void){ free(userlast); } userl.users=NULL; - ast_pthread_mutex_unlock(&userl.lock); + ast_mutex_unlock(&userl.lock); for (reg = registrations;reg;) { regl = reg; @@ -4986,30 +4986,30 @@ static void delete_users(void){ free(regl); } registrations = NULL; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); for (peer=peerl.peers;peer;) { /* Assume all will be deleted, and we'll find out for sure later */ peer->delme = 1; peer = peer->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); } static void prune_peers(void){ /* Prune peers who still are supposed to be deleted */ struct iax2_peer *peer, *peerlast, *peernext; int x; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peerlast = NULL; for (peer=peerl.peers;peer;) { peernext = peer->next; if (peer->delme) { for (x=0;xpeerpoke == peer)) { iax2_destroy(x); } - ast_pthread_mutex_unlock(&iaxsl[x]); + ast_mutex_unlock(&iaxsl[x]); } /* Delete it, it needs to disappear */ if (peer->expire > -1) @@ -5027,7 +5027,7 @@ static void prune_peers(void){ peerlast = peer; peer=peernext; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); } static void set_timing(void) @@ -5157,19 +5157,19 @@ static int set_config(char *config_file, struct sockaddr_in* sin){ if (!strcasecmp(utype, "user") || !strcasecmp(utype, "friend")) { user = build_user(cat, ast_variable_browse(cfg, cat)); if (user) { - ast_pthread_mutex_lock(&userl.lock); + ast_mutex_lock(&userl.lock); user->next = userl.users; userl.users = user; - ast_pthread_mutex_unlock(&userl.lock); + ast_mutex_unlock(&userl.lock); } } if (!strcasecmp(utype, "peer") || !strcasecmp(utype, "friend")) { peer = build_peer(cat, ast_variable_browse(cfg, cat)); if (peer) { - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peer->next = peerl.peers; peerl.peers = peer; - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); } } else if (strcasecmp(utype, "user")) { ast_log(LOG_WARNING, "Unknown type '%s' for '%s' in %s\n", utype, cat, config_file); @@ -5220,12 +5220,12 @@ static int cache_get_callno(char *data) for (x=0;xdproot)) { - ast_pthread_mutex_unlock(&iaxsl[x]); + ast_mutex_unlock(&iaxsl[x]); return x; } - ast_pthread_mutex_unlock(&iaxsl[x]); + ast_mutex_unlock(&iaxsl[x]); } } memset(&ied, 0, sizeof(ied)); @@ -5264,7 +5264,7 @@ static int cache_get_callno(char *data) ast_log(LOG_WARNING, "Unable to create call\n"); return -1; } - ast_pthread_mutex_lock(&iaxsl[callno]); + ast_mutex_lock(&iaxsl[callno]); strncpy(iaxs[callno]->dproot, data, sizeof(iaxs[callno]->dproot)-1); iaxs[callno]->capability = IAX_CAPABILITY_FULLBANDWIDTH; @@ -5286,7 +5286,7 @@ static int cache_get_callno(char *data) #endif /* Start the call going */ send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1); - ast_pthread_mutex_unlock(&iaxsl[callno]); + ast_mutex_unlock(&iaxsl[callno]); return callno; } @@ -5380,7 +5380,7 @@ static struct iax2_dpcache *find_cache(struct ast_channel *chan, char *data, cha /* Okay, now we wait */ timeout = iaxdefaulttimeout * 1000; /* Temporarily unlock */ - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); /* Defer any dtmf */ if (chan) old = ast_channel_defer_dtmf(chan); @@ -5404,7 +5404,7 @@ static struct iax2_dpcache *find_cache(struct ast_channel *chan, char *data, cha if (!timeout) { ast_log(LOG_WARNING, "Timeout waiting for %s exten %s\n", data, exten); } - ast_pthread_mutex_lock(&dpcache_lock); + ast_mutex_lock(&dpcache_lock); dp->waiters[x] = -1; close(com[1]); close(com[0]); @@ -5446,13 +5446,13 @@ static int iax2_exists(struct ast_channel *chan, char *context, char *exten, int #endif if (priority != 1) return 0; - ast_pthread_mutex_lock(&dpcache_lock); + ast_mutex_lock(&dpcache_lock); dp = find_cache(chan, data, context, exten, priority); if (dp) { if (dp->flags & CACHE_FLAG_EXISTS) res= 1; } - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); if (!dp) { ast_log(LOG_WARNING, "Unable to make DP cache\n"); } @@ -5468,13 +5468,13 @@ static int iax2_canmatch(struct ast_channel *chan, char *context, char *exten, i #endif if (priority != 1) return 0; - ast_pthread_mutex_lock(&dpcache_lock); + ast_mutex_lock(&dpcache_lock); dp = find_cache(chan, data, context, exten, priority); if (dp) { if (dp->flags & CACHE_FLAG_CANEXIST) res= 1; } - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); if (!dp) { ast_log(LOG_WARNING, "Unable to make DP cache\n"); } @@ -5490,13 +5490,13 @@ static int iax2_matchmore(struct ast_channel *chan, char *context, char *exten, #endif if (priority != 1) return 0; - ast_pthread_mutex_lock(&dpcache_lock); + ast_mutex_lock(&dpcache_lock); dp = find_cache(chan, data, context, exten, priority); if (dp) { if (dp->flags & CACHE_FLAG_MATCHMORE) res= 1; } - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); if (!dp) { ast_log(LOG_WARNING, "Unable to make DP cache\n"); } @@ -5515,7 +5515,7 @@ static int iax2_exec(struct ast_channel *chan, char *context, char *exten, int p #endif if (priority != 1) return -1; - ast_pthread_mutex_lock(&dpcache_lock); + ast_mutex_lock(&dpcache_lock); dp = find_cache(chan, data, context, exten, priority); if (dp) { if (dp->flags & CACHE_FLAG_EXISTS) { @@ -5531,12 +5531,12 @@ static int iax2_exec(struct ast_channel *chan, char *context, char *exten, int p if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Executing Dial('%s')\n", req); } else { - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); ast_log(LOG_WARNING, "Can't execute non-existant extension '%s[@%s]' in data '%s'\n", exten, context, data); return -1; } } - ast_pthread_mutex_unlock(&dpcache_lock); + ast_mutex_unlock(&dpcache_lock); dial = pbx_findapp("Dial"); if (dial) { pbx_exec(chan, dial, req, newstack); @@ -5587,7 +5587,7 @@ int load_module(void) #endif for (x=0;xnext) iax2_do_register(reg); - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); for (peer = peerl.peers; peer; peer = peer->next) iax2_poke_peer(peer); - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); return res; } @@ -5690,9 +5690,9 @@ int unload_module() int usecount() { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } diff --git a/channels/chan_local.c b/channels/chan_local.c index 662cf7c0c..7889d0fa3 100755 --- a/channels/chan_local.c +++ b/channels/chan_local.c @@ -49,15 +49,15 @@ static char *tdesc = "Local Proxy Channel Driver"; static int capability = -1; static int usecnt =0; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; #define IS_OUTBOUND(a,b) (a == b->chan ? 1 : 0) /* Protect the interface list (of sip_pvt's) */ -static pthread_mutex_t locallock = AST_MUTEX_INITIALIZER; +static ast_mutex_t locallock = AST_MUTEX_INITIALIZER; static struct local_pvt { - pthread_mutex_t lock; /* Channel private lock */ + ast_mutex_t lock; /* Channel private lock */ char context[AST_MAX_EXTENSION]; /* Context to call */ char exten[AST_MAX_EXTENSION]; /* Extension to call */ int reqformat; /* Requested format */ @@ -84,25 +84,25 @@ retrylock: if (p->cancelqueue) { /* We had a glare on the hangup. Forget all this business, return and destroy p. */ - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); free(p); return -1; } - if (pthread_mutex_trylock(&other->lock)) { + if (ast_mutex_trylock(&other->lock)) { /* Failed to lock. Release main lock and try again */ - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); if (us) - ast_pthread_mutex_unlock(&us->lock); + ast_mutex_unlock(&us->lock); /* Wait just a bit */ usleep(1); /* Only we can destroy ourselves, so we can't disappear here */ if (us) - ast_pthread_mutex_lock(&us->lock); - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&us->lock); + ast_mutex_lock(&p->lock); goto retrylock; } ast_queue_frame(other, f, 0); - ast_pthread_mutex_unlock(&other->lock); + ast_mutex_unlock(&other->lock); p->glaredetect = 0; return 0; } @@ -112,14 +112,14 @@ static int local_answer(struct ast_channel *ast) struct local_pvt *p = ast->pvt->pvt; int isoutbound = IS_OUTBOUND(ast, p); int res = -1; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (isoutbound) { /* Pass along answer since somebody answered us */ struct ast_frame answer = { AST_FRAME_CONTROL, AST_CONTROL_ANSWER }; res = local_queue_frame(p, isoutbound, &answer, ast); } else ast_log(LOG_WARNING, "Huh? Local is being asked to answer?\n"); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return res; } @@ -130,19 +130,19 @@ static void check_bridge(struct local_pvt *p, int isoutbound) if (isoutbound && p->chan && p->chan->bridge && p->owner) { /* Masquerade bridged channel into owner */ /* Lock other side first */ - ast_pthread_mutex_lock(&p->chan->bridge->lock); - ast_pthread_mutex_lock(&p->owner->lock); + ast_mutex_lock(&p->chan->bridge->lock); + ast_mutex_lock(&p->owner->lock); ast_channel_masquerade(p->owner, p->chan->bridge); - ast_pthread_mutex_unlock(&p->owner->lock); - ast_pthread_mutex_unlock(&p->chan->bridge->lock); + ast_mutex_unlock(&p->owner->lock); + ast_mutex_unlock(&p->chan->bridge->lock); p->alreadymasqed = 1; } else if (!isoutbound && p->owner && p->owner->bridge && p->chan) { /* Masquerade bridged channel into chan */ - ast_pthread_mutex_lock(&p->owner->bridge->lock); - ast_pthread_mutex_lock(&p->chan->lock); + ast_mutex_lock(&p->owner->bridge->lock); + ast_mutex_lock(&p->chan->lock); ast_channel_masquerade(p->chan, p->owner->bridge); - ast_pthread_mutex_unlock(&p->chan->lock); - ast_pthread_mutex_unlock(&p->owner->bridge->lock); + ast_mutex_unlock(&p->chan->lock); + ast_mutex_unlock(&p->owner->bridge->lock); p->alreadymasqed = 1; } } @@ -161,27 +161,27 @@ static int local_write(struct ast_channel *ast, struct ast_frame *f) /* Just queue for delivery to the other side */ - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); res = local_queue_frame(p, isoutbound, f, ast); check_bridge(p, isoutbound); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return res; } static int local_fixup(struct ast_channel *oldchan, struct ast_channel *newchan) { struct local_pvt *p = newchan->pvt->pvt; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if ((p->owner != oldchan) && (p->chan != oldchan)) { ast_log(LOG_WARNING, "old channel wasn't %p but was %p/%p\n", oldchan, p->owner, p->chan); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return -1; } if (p->owner == oldchan) p->owner = newchan; else p->chan = newchan; - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return 0; } @@ -192,10 +192,10 @@ static int local_indicate(struct ast_channel *ast, int condition) struct ast_frame f = { AST_FRAME_CONTROL, }; int isoutbound = IS_OUTBOUND(ast, p); /* Queue up a frame representing the indication as a control frame */ - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); f.subclass = condition; res = local_queue_frame(p, isoutbound, &f, ast); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return res; } @@ -205,10 +205,10 @@ static int local_digit(struct ast_channel *ast, char digit) int res = -1; struct ast_frame f = { AST_FRAME_DTMF, }; int isoutbound = IS_OUTBOUND(ast, p); - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); f.subclass = digit; res = local_queue_frame(p, isoutbound, &f, ast); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return res; } @@ -231,7 +231,7 @@ static int local_call(struct ast_channel *ast, char *dest, int timeout) static void local_destroy(struct local_pvt *p) { struct local_pvt *cur, *prev = NULL; - ast_pthread_mutex_lock(&locallock); + ast_mutex_lock(&locallock); cur = locals; while(cur) { if (cur == p) { @@ -245,7 +245,7 @@ static void local_destroy(struct local_pvt *p) prev = cur; cur = cur->next; } - ast_pthread_mutex_unlock(&locallock); + ast_mutex_unlock(&locallock); if (!cur) ast_log(LOG_WARNING, "Unable ot find local '%s@%s' in local list\n", p->exten, p->context); } @@ -258,7 +258,7 @@ static int local_hangup(struct ast_channel *ast) struct local_pvt *cur, *prev=NULL; struct ast_channel *ochan = NULL; int glaredetect; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (isoutbound) p->chan = NULL; else @@ -272,9 +272,9 @@ static int local_hangup(struct ast_channel *ast) let local_queue do it. */ if (p->glaredetect) p->cancelqueue = 1; - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); /* Remove from list */ - ast_pthread_mutex_lock(&locallock); + ast_mutex_lock(&locallock); cur = locals; while(cur) { if (cur == p) { @@ -287,7 +287,7 @@ static int local_hangup(struct ast_channel *ast) prev = cur; cur = cur->next; } - ast_pthread_mutex_unlock(&locallock); + ast_mutex_unlock(&locallock); /* And destroy */ if (!glaredetect) free(p); @@ -298,7 +298,7 @@ static int local_hangup(struct ast_channel *ast) ochan = p->chan; else local_queue_frame(p, isoutbound, &f, NULL); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); if (ochan) ast_hangup(ochan); return 0; @@ -311,7 +311,7 @@ static struct local_pvt *local_alloc(char *data, int format) tmp = malloc(sizeof(struct local_pvt)); if (tmp) { memset(tmp, 0, sizeof(struct local_pvt)); - ast_pthread_mutex_init(&tmp->lock); + ast_mutex_init(&tmp->lock); strncpy(tmp->exten, data, sizeof(tmp->exten) - 1); c = strchr(tmp->exten, '@'); if (c) { @@ -327,10 +327,10 @@ static struct local_pvt *local_alloc(char *data, int format) tmp = NULL; } else { /* Add to list */ - ast_pthread_mutex_lock(&locallock); + ast_mutex_lock(&locallock); tmp->next = locals; locals = tmp; - ast_pthread_mutex_unlock(&locallock); + ast_mutex_unlock(&locallock); } } @@ -389,9 +389,9 @@ static struct ast_channel *local_new(struct local_pvt *p, int state) tmp2->pvt->fixup = local_fixup; p->owner = tmp; p->chan = tmp2; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); strncpy(tmp->context, p->context, sizeof(tmp->context)-1); strncpy(tmp2->context, p->context, sizeof(tmp2->context)-1); @@ -420,17 +420,17 @@ static int locals_show(int fd, int argc, char **argv) if (argc != 2) return RESULT_SHOWUSAGE; - ast_pthread_mutex_lock(&locallock); + ast_mutex_lock(&locallock); p = locals; while(p) { - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); ast_cli(fd, "%s -- %s@%s\n", p->owner ? p->owner->name : "", p->exten, p->context); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); p = p->next; } if (!locals) ast_cli(fd, "No local channels in use\n"); - ast_pthread_mutex_unlock(&locallock); + ast_mutex_unlock(&locallock); return RESULT_SUCCESS; } @@ -464,7 +464,7 @@ int unload_module() /* First, take us out of the channel loop */ ast_cli_unregister(&cli_show_locals); ast_channel_unregister(type); - if (!ast_pthread_mutex_lock(&locallock)) { + if (!ast_mutex_lock(&locallock)) { /* Hangup all interfaces if they have an owner */ p = locals; while(p) { @@ -473,7 +473,7 @@ int unload_module() p = p->next; } locals = NULL; - ast_pthread_mutex_unlock(&locallock); + ast_mutex_unlock(&locallock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; @@ -484,9 +484,9 @@ int unload_module() int usecount() { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } diff --git a/channels/chan_mgcp.c b/channels/chan_mgcp.c index 691483ea8..19045e85b 100755 --- a/channels/chan_mgcp.c +++ b/channels/chan_mgcp.c @@ -142,7 +142,7 @@ static int adsi = 0; static int usecnt =0; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; static int oseq; /* Wait up to 16 seconds for first digit (FXO logic) */ @@ -156,9 +156,9 @@ static int matchdigittimeout = 3000; /* Protect the monitoring thread, so only one process can kill or start it, and not when it's doing something critical. */ -static pthread_mutex_t netlock = AST_MUTEX_INITIALIZER; +static ast_mutex_t netlock = AST_MUTEX_INITIALIZER; -static pthread_mutex_t monlock = AST_MUTEX_INITIALIZER; +static ast_mutex_t monlock = AST_MUTEX_INITIALIZER; /* This is the thread for the monitor which checks for input on the channels which are not currently in use. */ @@ -219,7 +219,7 @@ struct mgcp_message { #define SUB_ALT 1 struct mgcp_subchannel { - pthread_mutex_t lock; + ast_mutex_t lock; int id; struct ast_channel *owner; struct mgcp_endpoint *parent; @@ -247,7 +247,7 @@ struct mgcp_subchannel { #define TYPE_LINE 2 struct mgcp_endpoint { - pthread_mutex_t lock; + ast_mutex_t lock; char name[80]; struct mgcp_subchannel *sub; /* pointer to our current connection, channel and stuff */ char accountcode[80]; @@ -307,7 +307,7 @@ static struct mgcp_gateway { struct mgcp_gateway *next; } *gateways; -static pthread_mutex_t gatelock = AST_MUTEX_INITIALIZER; +static ast_mutex_t gatelock = AST_MUTEX_INITIALIZER; static int mgcpsock = -1; @@ -526,7 +526,7 @@ static int mgcp_hangup(struct ast_channel *ast) if ((p->dtmfinband) && (p->dsp != NULL)){ ast_dsp_free(p->dsp); } - ast_pthread_mutex_lock(&sub->lock); + ast_mutex_lock(&sub->lock); sub->owner = NULL; if (strlen(sub->cxident)) { @@ -581,7 +581,7 @@ static int mgcp_hangup(struct ast_channel *ast) transmit_notify_request(sub, "vmwi(-)"); } } - ast_pthread_mutex_unlock(&sub->lock); + ast_mutex_unlock(&sub->lock); return 0; } @@ -592,7 +592,7 @@ static int mgcp_show_endpoints(int fd, int argc, char *argv[]) int hasendpoints = 0; if (argc != 3) return RESULT_SHOWUSAGE; - ast_pthread_mutex_lock(&gatelock); + ast_mutex_lock(&gatelock); g = gateways; while(g) { e = g->endpoints; @@ -607,7 +607,7 @@ static int mgcp_show_endpoints(int fd, int argc, char *argv[]) } g = g->next; } - ast_pthread_mutex_unlock(&gatelock); + ast_mutex_unlock(&gatelock); return RESULT_SUCCESS; } @@ -644,7 +644,7 @@ static int mgcp_audit_endpoint(int fd, int argc, char *argv[]) gname++; if ((c = strrchr(gname, ']'))) *c = '\0'; - ast_pthread_mutex_lock(&gatelock); + ast_mutex_lock(&gatelock); g = gateways; while(g) { if (!strcasecmp(g->name, gname)) { @@ -666,7 +666,7 @@ static int mgcp_audit_endpoint(int fd, int argc, char *argv[]) if (!found) { ast_cli(fd, " << Could not find endpoint >> "); } - ast_pthread_mutex_unlock(&gatelock); + ast_mutex_unlock(&gatelock); return RESULT_SUCCESS; } @@ -731,9 +731,9 @@ static struct ast_frame *mgcp_read(struct ast_channel *ast) { struct ast_frame *fr; struct mgcp_subchannel *sub = ast->pvt->pvt; - ast_pthread_mutex_lock(&sub->lock); + ast_mutex_lock(&sub->lock); fr = mgcp_rtp_read(sub); - ast_pthread_mutex_unlock(&sub->lock); + ast_mutex_unlock(&sub->lock); return fr; } @@ -756,11 +756,11 @@ static int mgcp_write(struct ast_channel *ast, struct ast_frame *frame) } } if (sub) { - ast_pthread_mutex_lock(&sub->lock); + ast_mutex_lock(&sub->lock); if (sub->rtp) { res = ast_rtp_write(sub->rtp, frame); } - ast_pthread_mutex_unlock(&sub->lock); + ast_mutex_unlock(&sub->lock); } return res; } @@ -892,9 +892,9 @@ static struct ast_channel *mgcp_new(struct mgcp_subchannel *sub, int state) if (i->amaflags) tmp->amaflags = i->amaflags; sub->owner = tmp; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); tmp->callgroup = i->callgroup; tmp->pickupgroup = i->pickupgroup; @@ -987,13 +987,13 @@ static int rtpready(struct ast_rtp *rtp, struct ast_frame *f, void *data) { /* Just deliver the audio directly */ struct mgcp_endpoint *p = data; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (p->owner) { /* Generally, you lock in the order channel lock, followed by private lock. Since here we are doing the reverse, there is the possibility of deadlock. As a result, in the case of a deadlock, we simply fail out here. */ - if (!pthread_mutex_trylock(&p->owner->lock)) { + if (!ast_mutex_trylock(&p->owner->lock)) { if (f->frametype == AST_FRAME_VOICE) { if (f->subclass != p->owner->nativeformats) { ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass); @@ -1006,10 +1006,10 @@ static int rtpready(struct ast_rtp *rtp, struct ast_frame *f, void *data) } } ast_queue_frame(p->owner, f, 0); - pthread_mutex_unlock(&p->owner->lock); + ast_mutex_unlock(&p->owner->lock); } } - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return 0; } #endif @@ -1032,7 +1032,7 @@ static struct mgcp_subchannel *find_subchannel(char *name, int msgid, struct soc *at = '\0'; at++; } - ast_pthread_mutex_lock(&gatelock); + ast_mutex_lock(&gatelock); if (at && (at[0] == '[')) { at++; c = strrchr(at, ']'); @@ -1086,7 +1086,7 @@ static struct mgcp_subchannel *find_subchannel(char *name, int msgid, struct soc } g = g->next; } - ast_pthread_mutex_unlock(&gatelock); + ast_mutex_unlock(&gatelock); if (!sub) { if (name) { if (g) @@ -1724,7 +1724,7 @@ static void handle_response(struct mgcp_subchannel *sub, int result, int ident) static void start_rtp(struct mgcp_subchannel *sub) { - ast_pthread_mutex_lock(&sub->lock); + ast_mutex_lock(&sub->lock); /* Allocate the RTP now */ sub->rtp = ast_rtp_new(sched, io, 1, 0); if (sub->rtp && sub->owner) @@ -1739,7 +1739,7 @@ static void start_rtp(struct mgcp_subchannel *sub) snprintf(sub->callid, sizeof(sub->callid), "%08x%s", rand(), sub->txident); /* Transmit the connection create */ transmit_connect_with_sdp(sub, NULL); - ast_pthread_mutex_unlock(&sub->lock); + ast_mutex_unlock(&sub->lock); } static void *mgcp_ss(void *data) @@ -2479,9 +2479,9 @@ static void *do_monitor(void *data) /* Check for interfaces needing to be killed */ /* Don't let anybody kill us right away. Nobody should lock the interface list and wait for the monitor list, but the other way around is okay. */ - ast_pthread_mutex_lock(&monlock); + ast_mutex_lock(&monlock); /* Lock the network interface */ - ast_pthread_mutex_lock(&netlock); + ast_mutex_lock(&netlock); p = packets; while(p) { /* Handle any retransmissions */ @@ -2519,17 +2519,17 @@ static void *do_monitor(void *data) #endif /* Okay, now that we know what to do, release the network lock */ - ast_pthread_mutex_unlock(&netlock); + ast_mutex_unlock(&netlock); /* And from now on, we're okay to be killed, so release the monitor lock as well */ - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); pthread_testcancel(); /* Wait for sched or io */ res = ast_sched_wait(sched); res = ast_io_wait(io, res); - ast_pthread_mutex_lock(&monlock); + ast_mutex_lock(&monlock); if (res >= 0) ast_sched_runq(sched); - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); } /* Never reached */ return NULL; @@ -2541,12 +2541,12 @@ static int restart_monitor(void) /* If we're supposed to be stopped -- stay stopped */ if (monitor_thread == -2) return 0; - if (ast_pthread_mutex_lock(&monlock)) { + if (ast_mutex_lock(&monlock)) { ast_log(LOG_WARNING, "Unable to lock monitor\n"); return -1; } if (monitor_thread == pthread_self()) { - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); ast_log(LOG_WARNING, "Cannot kill myself\n"); return -1; } @@ -2556,12 +2556,12 @@ static int restart_monitor(void) } else { /* Start a new monitor */ if (pthread_create(&monitor_thread, NULL, do_monitor, NULL) < 0) { - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); ast_log(LOG_ERROR, "Unable to start monitor thread.\n"); return -1; } } - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); return 0; } @@ -2932,10 +2932,10 @@ int load_module() if (option_verbose > 2) { ast_verbose(VERBOSE_PREFIX_3 "Added gateway '%s'\n", g->name); } - ast_pthread_mutex_lock(&gatelock); + ast_mutex_lock(&gatelock); g->next = gateways; gateways = g; - ast_pthread_mutex_unlock(&gatelock); + ast_mutex_unlock(&gatelock); } } cat = ast_category_browse(cfg, cat); @@ -2954,7 +2954,7 @@ int load_module() if (!ntohs(bindaddr.sin_port)) bindaddr.sin_port = ntohs(DEFAULT_MGCP_PORT); bindaddr.sin_family = AF_INET; - pthread_mutex_lock(&netlock); + ast_mutex_lock(&netlock); if (mgcpsock > -1) close(mgcpsock); mgcpsock = socket(AF_INET, SOCK_DGRAM, 0); @@ -2977,7 +2977,7 @@ int load_module() ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos); } } - pthread_mutex_unlock(&netlock); + ast_mutex_unlock(&netlock); ast_destroy(cfg); /* Make sure we can register our mgcp channel type */ @@ -3015,7 +3015,7 @@ int unload_module() struct mgcp_endpoint *p, *pl; /* First, take us out of the channel loop */ ast_channel_unregister(type); - if (!ast_pthread_mutex_lock(&gatelock)) { + if (!ast_mutex_lock(&gatelock)) { /* Hangup all interfaces if they have an owner */ p = iflist; while(p) { @@ -3024,25 +3024,25 @@ int unload_module() p = p->next; } iflist = NULL; - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; } - if (!ast_pthread_mutex_lock(&monlock)) { + if (!ast_mutex_lock(&monlock)) { if (monitor_thread) { pthread_cancel(monitor_thread); pthread_kill(monitor_thread, SIGURG); pthread_join(monitor_thread, NULL); } monitor_thread = -2; - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; } - if (!ast_pthread_mutex_lock(&iflock)) { + if (!ast_mutex_lock(&iflock)) { /* Destroy all the interfaces and free their memory */ p = iflist; while(p) { @@ -3052,7 +3052,7 @@ int unload_module() free(pl); } iflist = NULL; - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; @@ -3064,9 +3064,9 @@ int unload_module() int usecount() { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } diff --git a/channels/chan_modem.c b/channels/chan_modem.c index 900eb0ad5..b62002679 100755 --- a/channels/chan_modem.c +++ b/channels/chan_modem.c @@ -71,14 +71,14 @@ static int baudrate = 115200; static int stripmsd = 0; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; /* Protect the interface list (of ast_modem_pvt's) */ -static pthread_mutex_t iflock = AST_MUTEX_INITIALIZER; +static ast_mutex_t iflock = AST_MUTEX_INITIALIZER; /* Protect the monitoring thread, so only one process can kill or start it, and not when it's doing something critical. */ -static pthread_mutex_t monlock = AST_MUTEX_INITIALIZER; +static ast_mutex_t monlock = AST_MUTEX_INITIALIZER; /* This is the thread for the monitor which checks for input on the channels which are not currently in use. */ @@ -421,11 +421,11 @@ static int modem_hangup(struct ast_channel *ast) memset(p->cid, 0, sizeof(p->cid)); memset(p->dnid, 0, sizeof(p->dnid)); ((struct ast_modem_pvt *)(ast->pvt->pvt))->owner = NULL; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt--; if (usecnt < 0) ast_log(LOG_WARNING, "Usecnt < 0???\n"); - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); if (option_verbose > 2) ast_verbose( VERBOSE_PREFIX_3 "Hungup '%s'\n", ast->name); @@ -525,9 +525,9 @@ struct ast_channel *ast_modem_new(struct ast_modem_pvt *i, int state) if (strlen(i->dnid)) strncpy(tmp->exten, i->dnid, sizeof(tmp->exten) - 1); i->owner = tmp; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); if (state != AST_STATE_DOWN) { if (ast_pbx_start(tmp)) { @@ -570,14 +570,14 @@ static void *do_monitor(void *data) for(;;) { /* Don't let anybody kill us right away. Nobody should lock the interface list and wait for the monitor list, but the other way around is okay. */ - if (ast_pthread_mutex_lock(&monlock)) { + if (ast_mutex_lock(&monlock)) { ast_log(LOG_ERROR, "Unable to grab monitor lock\n"); return NULL; } /* Lock the interface list */ - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { ast_log(LOG_ERROR, "Unable to grab interface lock\n"); - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); return NULL; } /* Build the stuff we're going to select on, that is the socket of every @@ -600,10 +600,10 @@ static void *do_monitor(void *data) i = i->next; } /* Okay, now that we know what to do, release the interface lock */ - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); /* And from now on, we're okay to be killed, so release the monitor lock as well */ - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); #if 0 ast_log(LOG_DEBUG, "In monitor, n=%d, pid=%d\n", n, getpid()); #endif @@ -618,7 +618,7 @@ static void *do_monitor(void *data) } /* Alright, lock the interface list again, and let's look and see what has happened */ - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { ast_log(LOG_WARNING, "Unable to lock the interface list\n"); continue; } @@ -634,7 +634,7 @@ static void *do_monitor(void *data) } i=i->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } /* Never reached */ return NULL; @@ -646,12 +646,12 @@ static int restart_monitor() /* If we're supposed to be stopped -- stay stopped */ if (monitor_thread == -2) return 0; - if (ast_pthread_mutex_lock(&monlock)) { + if (ast_mutex_lock(&monlock)) { ast_log(LOG_WARNING, "Unable to lock monitor\n"); return -1; } if (monitor_thread == pthread_self()) { - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); ast_log(LOG_WARNING, "Cannot kill myself\n"); return -1; } @@ -663,11 +663,11 @@ static int restart_monitor() } /* Start a new monitor */ if (pthread_create(&monitor_thread, NULL, do_monitor, NULL) < 0) { - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); ast_log(LOG_ERROR, "Unable to start monitor thread.\n"); return -1; } - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); return 0; } @@ -762,7 +762,7 @@ static struct ast_channel *modem_request(char *type, int format, void *data) } /* Search for an unowned channel */ - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { ast_log(LOG_ERROR, "Unable to lock interface list???\n"); return NULL; } @@ -799,7 +799,7 @@ static struct ast_channel *modem_request(char *type, int format, void *data) if (!p) ast_log(LOG_WARNING, "Requested device '%s' does not exist\n", dev); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return tmp; } @@ -852,7 +852,7 @@ int load_module() ast_log(LOG_ERROR, "Unable to load config %s\n", config); return -1; } - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { /* It's a little silly to lock it, but we mind as well just to be sure */ ast_log(LOG_ERROR, "Unable to lock interface list???\n"); return -1; @@ -869,7 +869,7 @@ int load_module() } else { ast_log(LOG_ERROR, "Unable to register channel '%s'\n", v->value); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); unload_module(); return -1; } @@ -881,7 +881,7 @@ int load_module() if (ast_load_resource(driver)) { ast_log(LOG_ERROR, "Failed to load driver %s\n", driver); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); unload_module(); return -1; } @@ -915,7 +915,7 @@ int load_module() } v = v->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); if (ast_channel_register(type, tdesc, /* XXX Don't know our types -- maybe we should register more than one XXX */ AST_FORMAT_SLINEAR, modem_request)) { ast_log(LOG_ERROR, "Unable to register channel class %s\n", type); @@ -934,7 +934,7 @@ int unload_module() struct ast_modem_pvt *p, *pl; /* First, take us out of the channel loop */ ast_channel_unregister(type); - if (!ast_pthread_mutex_lock(&iflock)) { + if (!ast_mutex_lock(&iflock)) { /* Hangup all interfaces if they have an owner */ p = iflist; while(p) { @@ -943,24 +943,24 @@ int unload_module() p = p->next; } iflist = NULL; - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; } - if (!ast_pthread_mutex_lock(&monlock)) { + if (!ast_mutex_lock(&monlock)) { if (monitor_thread > -1) { pthread_cancel(monitor_thread); pthread_join(monitor_thread, NULL); } monitor_thread = -2; - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; } - if (!ast_pthread_mutex_lock(&iflock)) { + if (!ast_mutex_lock(&iflock)) { /* Destroy all the interfaces and free their memory */ p = iflist; while(p) { @@ -973,7 +973,7 @@ int unload_module() free(pl); } iflist = NULL; - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; @@ -985,9 +985,9 @@ int unload_module() int usecount(void) { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } diff --git a/channels/chan_modem_aopen.c b/channels/chan_modem_aopen.c index 3aa1978af..4222e85cd 100755 --- a/channels/chan_modem_aopen.c +++ b/channels/chan_modem_aopen.c @@ -34,7 +34,7 @@ static char *breakcmd = "\0x10\0x03"; static char *desc = "A/Open (Rockwell Chipset) ITU-2 VoiceModem Driver"; static int usecnt; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; static char *aopen_idents[] = { /* Identify A/Open Modem */ @@ -363,17 +363,17 @@ static char *aopen_identify(struct ast_modem_pvt *p) static void aopen_incusecnt(void) { - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); } static void aopen_decusecnt(void) { - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); } @@ -457,9 +457,9 @@ static struct ast_modem_driver aopen_driver = int usecount(void) { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } diff --git a/channels/chan_modem_bestdata.c b/channels/chan_modem_bestdata.c index 90cc87828..10732dca7 100755 --- a/channels/chan_modem_bestdata.c +++ b/channels/chan_modem_bestdata.c @@ -39,7 +39,7 @@ static char *breakcmd = "\020!"; static char *desc = "BestData (Conexant V.90 Chipset) VoiceModem Driver"; static int usecnt; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; static char *bestdata_idents[] = { /* Identify BestData Modem */ @@ -439,17 +439,17 @@ static char *bestdata_identify(struct ast_modem_pvt *p) static void bestdata_incusecnt(void) { - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); } static void bestdata_decusecnt(void) { - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); } @@ -570,9 +570,9 @@ static struct ast_modem_driver bestdata_driver = int usecount(void) { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } diff --git a/channels/chan_modem_i4l.c b/channels/chan_modem_i4l.c index 857188277..c011a9fc8 100755 --- a/channels/chan_modem_i4l.c +++ b/channels/chan_modem_i4l.c @@ -34,7 +34,7 @@ static char *breakcmd = "\0x10\0x14\0x10\0x3"; static char *desc = "ISDN4Linux Emulated Modem Driver"; static int usecnt; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; static char *i4l_idents[] = { /* Identify ISDN4Linux Driver */ @@ -476,17 +476,17 @@ static char *i4l_identify(struct ast_modem_pvt *p) static void i4l_incusecnt(void) { - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); } static void i4l_decusecnt(void) { - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); } @@ -597,9 +597,9 @@ static struct ast_modem_driver i4l_driver = int usecount(void) { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } diff --git a/channels/chan_nbs.c b/channels/chan_nbs.c index f366f976e..0cf50f56c 100755 --- a/channels/chan_nbs.c +++ b/channels/chan_nbs.c @@ -41,7 +41,7 @@ static int usecnt =0; /* Only linear is allowed */ static int prefformat = AST_FORMAT_SLINEAR; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; static char context[AST_MAX_EXTENSION] = "default"; @@ -215,9 +215,9 @@ static struct ast_channel *nbs_new(struct nbs_pvt *i, int state) strncpy(tmp->exten, "s", sizeof(tmp->exten) - 1); strcpy(tmp->language, ""); i->owner = tmp; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); if (state != AST_STATE_DOWN) { if (ast_pbx_start(tmp)) { @@ -276,9 +276,9 @@ int unload_module() int usecount() { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } diff --git a/channels/chan_oss.c b/channels/chan_oss.c index 376f5e059..28f20d485 100755 --- a/channels/chan_oss.c +++ b/channels/chan_oss.c @@ -64,7 +64,7 @@ static int silencesuppression = 0; static int silencethreshold = 1000; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; static char *type = "Console"; static char *desc = "OSS Console Channel Driver"; @@ -490,9 +490,9 @@ static int oss_hangup(struct ast_channel *c) c->pvt->pvt = NULL; oss.owner = NULL; ast_verbose( " << Hangup on console >> \n"); - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt--; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); if (hookstate) { if (autoanswer) { /* Assume auto-hangup too */ @@ -712,9 +712,9 @@ static struct ast_channel *oss_new(struct chan_oss_pvt *p, int state) strncpy(tmp->language, language, sizeof(tmp->language)-1); p->owner = tmp; ast_setstate(tmp, state); - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); if (state != AST_STATE_DOWN) { if (ast_pbx_start(tmp)) { @@ -1029,9 +1029,9 @@ char *description() int usecount() { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } diff --git a/channels/chan_phone.c b/channels/chan_phone.c index 80232c3c8..5ae642a1f 100755 --- a/channels/chan_phone.c +++ b/channels/chan_phone.c @@ -56,14 +56,14 @@ static int silencesupression = 0; static int prefformat = AST_FORMAT_G723_1 | AST_FORMAT_SLINEAR | AST_FORMAT_ULAW; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; /* Protect the interface list (of phone_pvt's) */ -static pthread_mutex_t iflock = AST_MUTEX_INITIALIZER; +static ast_mutex_t iflock = AST_MUTEX_INITIALIZER; /* Protect the monitoring thread, so only one process can kill or start it, and not when it's doing something critical. */ -static pthread_mutex_t monlock = AST_MUTEX_INITIALIZER; +static ast_mutex_t monlock = AST_MUTEX_INITIALIZER; /* This is the thread for the monitor which checks for input on the channels which are not currently in use. */ @@ -221,11 +221,11 @@ static int phone_hangup(struct ast_channel *ast) p->dialtone = 0; memset(p->ext, 0, sizeof(p->ext)); ((struct phone_pvt *)(ast->pvt->pvt))->owner = NULL; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt--; if (usecnt < 0) ast_log(LOG_WARNING, "Usecnt < 0???\n"); - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); if (option_verbose > 2) ast_verbose( VERBOSE_PREFIX_3 "Hungup '%s'\n", ast->name); @@ -640,9 +640,9 @@ static struct ast_channel *phone_new(struct phone_pvt *i, int state, char *conte if (strlen(i->callerid)) tmp->callerid = strdup(i->callerid); i->owner = tmp; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); if (state != AST_STATE_DOWN) { if (state == AST_STATE_RING) { @@ -695,9 +695,9 @@ static void phone_check_exception(struct phone_pvt *i) phone_new(i, AST_STATE_RING, i->context); /* No need to restart monitor, we are the monitor */ if (i->owner) { - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt--; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); } } else if (!ast_canmatch_extension(NULL, i->context, i->ext, 1, i->callerid)) { @@ -707,9 +707,9 @@ static void phone_check_exception(struct phone_pvt *i) /* Check the default, too... */ phone_new(i, AST_STATE_RING, "default"); if (i->owner) { - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt--; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); } /* XXX This should probably be justified better XXX */ @@ -732,9 +732,9 @@ static void phone_check_exception(struct phone_pvt *i) if (i->mode == MODE_IMMEDIATE) { phone_new(i, AST_STATE_RING, i->context); } else if (i->mode == MODE_DIALTONE) { - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); /* Reset the extension */ i->ext[0] = '\0'; @@ -747,9 +747,9 @@ static void phone_check_exception(struct phone_pvt *i) } } else { if (i->dialtone) { - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt--; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); } memset(i->ext, 0, sizeof(i->ext)); @@ -793,14 +793,14 @@ static void *do_monitor(void *data) for(;;) { /* Don't let anybody kill us right away. Nobody should lock the interface list and wait for the monitor list, but the other way around is okay. */ - if (ast_pthread_mutex_lock(&monlock)) { + if (ast_mutex_lock(&monlock)) { ast_log(LOG_ERROR, "Unable to grab monitor lock\n"); return NULL; } /* Lock the interface list */ - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { ast_log(LOG_ERROR, "Unable to grab interface lock\n"); - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); return NULL; } /* Build the stuff we're going to select on, that is the socket of every @@ -834,10 +834,10 @@ static void *do_monitor(void *data) i = i->next; } /* Okay, now that we know what to do, release the interface lock */ - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); /* And from now on, we're okay to be killed, so release the monitor lock as well */ - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); /* Wait indefinitely for something to happen */ if (dotone) { /* If we're ready to recycle the time, set it to 30 ms */ @@ -866,7 +866,7 @@ static void *do_monitor(void *data) continue; /* Alright, lock the interface list again, and let's look and see what has happened */ - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { ast_log(LOG_WARNING, "Unable to lock the interface list\n"); continue; } @@ -888,7 +888,7 @@ static void *do_monitor(void *data) } i=i->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } /* Never reached */ return NULL; @@ -900,12 +900,12 @@ static int restart_monitor() /* If we're supposed to be stopped -- stay stopped */ if (monitor_thread == -2) return 0; - if (ast_pthread_mutex_lock(&monlock)) { + if (ast_mutex_lock(&monlock)) { ast_log(LOG_WARNING, "Unable to lock monitor\n"); return -1; } if (monitor_thread == pthread_self()) { - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); ast_log(LOG_WARNING, "Cannot kill myself\n"); return -1; } @@ -917,11 +917,11 @@ static int restart_monitor() } /* Start a new monitor */ if (pthread_create(&monitor_thread, NULL, do_monitor, NULL) < 0) { - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); ast_log(LOG_ERROR, "Unable to start monitor thread.\n"); return -1; } - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); return 0; } @@ -997,7 +997,7 @@ static struct ast_channel *phone_request(char *type, int format, void *data) return NULL; } /* Search for an unowned channel */ - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { ast_log(LOG_ERROR, "Unable to lock interface list???\n"); return NULL; } @@ -1011,7 +1011,7 @@ static struct ast_channel *phone_request(char *type, int format, void *data) } p = p->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); restart_monitor(); return tmp; } @@ -1053,7 +1053,7 @@ int load_module() ast_log(LOG_ERROR, "Unable to load config %s\n", config); return -1; } - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { /* It's a little silly to lock it, but we mind as well just to be sure */ ast_log(LOG_ERROR, "Unable to lock interface list???\n"); return -1; @@ -1070,7 +1070,7 @@ int load_module() } else { ast_log(LOG_ERROR, "Unable to register channel '%s'\n", v->value); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); unload_module(); return -1; } @@ -1118,7 +1118,7 @@ int load_module() } v = v->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); /* Make sure we can register our Adtranphone channel type */ if (ast_channel_register(type, tdesc, AST_FORMAT_G723_1 | AST_FORMAT_SLINEAR | AST_FORMAT_ULAW, phone_request)) { @@ -1140,7 +1140,7 @@ int unload_module() struct phone_pvt *p, *pl; /* First, take us out of the channel loop */ ast_channel_unregister(type); - if (!ast_pthread_mutex_lock(&iflock)) { + if (!ast_mutex_lock(&iflock)) { /* Hangup all interfaces if they have an owner */ p = iflist; while(p) { @@ -1149,24 +1149,24 @@ int unload_module() p = p->next; } iflist = NULL; - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; } - if (!ast_pthread_mutex_lock(&monlock)) { + if (!ast_mutex_lock(&monlock)) { if (monitor_thread > -1) { pthread_cancel(monitor_thread); pthread_join(monitor_thread, NULL); } monitor_thread = -2; - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; } - if (!ast_pthread_mutex_lock(&iflock)) { + if (!ast_mutex_lock(&iflock)) { /* Destroy all the interfaces and free their memory */ p = iflist; while(p) { @@ -1179,7 +1179,7 @@ int unload_module() free(pl); } iflist = NULL; - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; @@ -1191,9 +1191,9 @@ int unload_module() int usecount() { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } diff --git a/channels/chan_sip.c b/channels/chan_sip.c index a1b9adc6b..b4602275a 100755 --- a/channels/chan_sip.c +++ b/channels/chan_sip.c @@ -100,16 +100,16 @@ static int srvlookup = 0; static int pedanticsipchecking = 0; static int usecnt =0; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; /* Protect the interface list (of sip_pvt's) */ -static pthread_mutex_t iflock = AST_MUTEX_INITIALIZER; +static ast_mutex_t iflock = AST_MUTEX_INITIALIZER; /* Protect the monitoring thread, so only one process can kill or start it, and not when it's doing something critical. */ -static pthread_mutex_t netlock = AST_MUTEX_INITIALIZER; +static ast_mutex_t netlock = AST_MUTEX_INITIALIZER; -static pthread_mutex_t monlock = AST_MUTEX_INITIALIZER; +static ast_mutex_t monlock = AST_MUTEX_INITIALIZER; /* This is the thread for the monitor which checks for input on the channels which are not currently in use. */ @@ -168,7 +168,7 @@ struct sip_route { }; static struct sip_pvt { - pthread_mutex_t lock; /* Channel private lock */ + ast_mutex_t lock; /* Channel private lock */ char callid[80]; /* Global CallID */ char randdata[80]; /* Random data */ unsigned int ocseq; /* Current outgoing seqno */ @@ -319,12 +319,12 @@ struct sip_peer { static struct ast_user_list { struct sip_user *users; - pthread_mutex_t lock; + ast_mutex_t lock; } userl = { NULL, AST_MUTEX_INITIALIZER }; static struct ast_peer_list { struct sip_peer *peers; - pthread_mutex_t lock; + ast_mutex_t lock; } peerl = { NULL, AST_MUTEX_INITIALIZER }; @@ -337,7 +337,7 @@ static struct ast_peer_list { #define REG_STATE_NOAUTH 6 struct sip_registry { - pthread_mutex_t lock; /* Channel private lock */ + ast_mutex_t lock; /* Channel private lock */ struct sockaddr_in addr; /* Who we connect to for registration purposes */ char username[80]; /* Who we are registering as */ char authuser[80]; /* Who we *authenticate* as */ @@ -405,7 +405,7 @@ static int retrans_pkt(void *data) { struct sip_pkt *pkt=data; int res = 0; - ast_pthread_mutex_lock(&pkt->owner->lock); + ast_mutex_lock(&pkt->owner->lock); if (1 /* !p->owner->needdestroy */) { if (pkt->retrans < MAX_RETRANS) { pkt->retrans++; @@ -425,7 +425,7 @@ static int retrans_pkt(void *data) ast_queue_hangup(pkt->owner->owner, 1); } else { /* If no owner, destroy now */ - ast_pthread_mutex_unlock(&pkt->owner->lock); + ast_mutex_unlock(&pkt->owner->lock); sip_destroy(pkt->owner); pkt = NULL; } @@ -438,13 +438,13 @@ static int retrans_pkt(void *data) ast_queue_hangup(pkt->owner->owner, 1); } else { /* If no owner, destroy now */ - ast_pthread_mutex_unlock(&pkt->owner->lock); + ast_mutex_unlock(&pkt->owner->lock); sip_destroy(pkt->owner); pkt=NULL; } } if (pkt) - ast_pthread_mutex_unlock(&pkt->owner->lock); + ast_mutex_unlock(&pkt->owner->lock); return res; } @@ -611,7 +611,7 @@ static int create_addr(struct sip_pvt *r, char *peer) char host[256], *hostn; r->sa.sin_family = AF_INET; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); p = peerl.peers; while(p) { if (!strcasecmp(p->name, peer)) { @@ -668,7 +668,7 @@ static int create_addr(struct sip_pvt *r, char *peer) } p = p->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); if (!p && !found) { if ((port=strchr(peer, ':'))) { *port='\0'; @@ -710,16 +710,16 @@ static int create_addr(struct sip_pvt *r, char *peer) static int auto_congest(void *nothing) { struct sip_pvt *p = nothing; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); p->initid = -1; if (p->owner) { - if (!pthread_mutex_trylock(&p->owner->lock)) { + if (!ast_mutex_trylock(&p->owner->lock)) { ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name); ast_queue_control(p->owner, AST_CONTROL_CONGESTION, 0); - ast_pthread_mutex_unlock(&p->owner->lock); + ast_mutex_unlock(&p->owner->lock); } } - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return 0; } @@ -856,11 +856,11 @@ static void __sip_destroy(struct sip_pvt *p, int lockowner) /* Unlink us from the owner if we have one */ if (p->owner) { if (lockowner) - ast_pthread_mutex_lock(&p->owner->lock); + ast_mutex_lock(&p->owner->lock); ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name); p->owner->pvt->pvt = NULL; if (lockowner) - ast_pthread_mutex_unlock(&p->owner->lock); + ast_mutex_unlock(&p->owner->lock); } cur = iflist; while(cur) { @@ -894,7 +894,7 @@ static int find_user(struct sip_pvt *fup, int event) char name[256] = ""; struct sip_user *u; strncpy(name, fup->username, sizeof(name) - 1); - ast_pthread_mutex_lock(&userl.lock); + ast_mutex_lock(&userl.lock); u = userl.users; while(u) { if (!strcasecmp(u->name, name)) { @@ -904,7 +904,7 @@ static int find_user(struct sip_pvt *fup, int event) } if (!u) { ast_log(LOG_DEBUG, "%s is not a local user\n", name); - ast_pthread_mutex_unlock(&userl.lock); + ast_mutex_unlock(&userl.lock); return 0; } if(event == 0) { @@ -917,22 +917,22 @@ static int find_user(struct sip_pvt *fup, int event) if (u->incominglimit > 0 ) { if (u->inUse >= u->incominglimit) { ast_log(LOG_ERROR, "Call from user '%s' rejected due to usage limit of %d\n", u->name, u->incominglimit); - ast_pthread_mutex_unlock(&userl.lock); + ast_mutex_unlock(&userl.lock); return -1; } } u->inUse++; ast_log(LOG_DEBUG, "Call from user '%s' is %d out of %d\n", u->name, u->inUse, u->incominglimit); } - ast_pthread_mutex_unlock(&userl.lock); + ast_mutex_unlock(&userl.lock); return 0; } static void sip_destroy(struct sip_pvt *p) { - ast_pthread_mutex_lock(&iflock); + ast_mutex_lock(&iflock); __sip_destroy(p, 1); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req); @@ -949,13 +949,13 @@ static int sip_hangup(struct ast_channel *ast) ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n"); return 0; } - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); ast_log(LOG_DEBUG, "find_user(%s)\n", p->username); find_user(p, 0); /* Determine how to disconnect */ if (p->owner != ast) { ast_log(LOG_WARNING, "Huh? We aren't the owner?\n"); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return 0; } if (!ast || (ast->_state != AST_STATE_UP)) @@ -992,7 +992,7 @@ static int sip_hangup(struct ast_channel *ast) } } p->needdestroy = needdestroy; - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return 0; } @@ -1035,7 +1035,7 @@ static int sip_write(struct ast_channel *ast, struct ast_frame *frame) return -1; } if (p) { - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (p->rtp) { if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) { transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0); @@ -1043,11 +1043,11 @@ static int sip_write(struct ast_channel *ast, struct ast_frame *frame) } res = ast_rtp_write(p->rtp, frame); } - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); } } else if (frame->frametype == AST_FRAME_VIDEO) { if (p) { - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (p->vrtp) { if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) { transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0); @@ -1055,7 +1055,7 @@ static int sip_write(struct ast_channel *ast, struct ast_frame *frame) } res = ast_rtp_write(p->vrtp, frame); } - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); } } else if (frame->frametype == AST_FRAME_IMAGE) { return 0; @@ -1070,14 +1070,14 @@ static int sip_write(struct ast_channel *ast, struct ast_frame *frame) static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan) { struct sip_pvt *p = newchan->pvt->pvt; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); if (p->owner != oldchan) { ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return -1; } p->owner = newchan; - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return 0; } @@ -1220,9 +1220,9 @@ static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title) if (strlen(i->language)) strncpy(tmp->language, i->language, sizeof(tmp->language)-1); i->owner = tmp; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); strncpy(tmp->context, i->context, sizeof(tmp->context)-1); strncpy(tmp->exten, i->exten, sizeof(tmp->exten)-1); @@ -1370,9 +1370,9 @@ static struct ast_frame *sip_read(struct ast_channel *ast) { struct ast_frame *fr; struct sip_pvt *p = ast->pvt->pvt; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); fr = sip_rtp_read(ast, p); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return fr; } @@ -1427,7 +1427,7 @@ static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useg if (p->vrtp) ast_rtp_setnat(p->vrtp, p->nat); } - ast_pthread_mutex_init(&p->lock); + ast_mutex_init(&p->lock); if (sin) { memcpy(&p->sa, sin, sizeof(p->sa)); @@ -1450,10 +1450,10 @@ static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useg strncpy(p->context, context, sizeof(p->context) - 1); strncpy(p->fromdomain, fromdomain, sizeof(p->fromdomain) - 1); /* Add to list */ - ast_pthread_mutex_lock(&iflock); + ast_mutex_lock(&iflock); p->next = iflist; iflist = p; - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); if (option_debug) ast_log(LOG_DEBUG, "Allocating new SIP call for %s\n", callid); return p; @@ -1506,22 +1506,22 @@ static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *si ast_log(LOG_WARNING, "Call missing call ID from '%s'\n", inet_ntoa(sin->sin_addr)); return NULL; } - ast_pthread_mutex_lock(&iflock); + ast_mutex_lock(&iflock); p = iflist; while(p) { if (!strcmp(p->callid, callid) && (!pedanticsipchecking || !strlen(p->theirtag) || !strcmp(p->theirtag, tag))) { /* Found the call */ - ast_pthread_mutex_lock(&p->lock); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_lock(&p->lock); + ast_mutex_unlock(&iflock); return p; } p = p->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); p = sip_alloc(callid, sin, 1); if (p) - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); return p; } @@ -1923,11 +1923,15 @@ static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, struct s tmp = __get_header(orig, field, &start); if (strlen(tmp)) { if (!copied && p->nat) { +#ifdef THE_SIP_AUTHORS_CAN_SUCK_MY_GONADS /* SLD: FIXME: Nice try, but the received= should not have a port */ /* SLD: FIXME: See RFC2543 BNF in Section 6.40.5 */ + /* MAS: Yup, RFC says you can't do it. No way to indicate PAT... + good job fellas. */ if (ntohs(p->recv.sin_port) != DEFAULT_SIP_PORT) snprintf(new, sizeof(new), "%s;received=%s:%d", tmp, inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port)); else +#endif snprintf(new, sizeof(new), "%s;received=%s", tmp, inet_ntoa(p->recv.sin_addr)); add_header(req, field, new); } else { @@ -2759,9 +2763,9 @@ static int sip_reregister(void *data) static int sip_do_register(struct sip_registry *r) { int res; - ast_pthread_mutex_lock(&r->lock); + ast_mutex_lock(&r->lock); res=transmit_register(r, "REGISTER", NULL); - ast_pthread_mutex_unlock(&r->lock); + ast_mutex_unlock(&r->lock); return res; } @@ -2771,7 +2775,7 @@ static int sip_reg_timeout(void *data) struct sip_registry *r=data; struct sip_pvt *p; int res; - ast_pthread_mutex_lock(&r->lock); + ast_mutex_lock(&r->lock); ast_log(LOG_NOTICE, "Registration for '%s@%s' timed out, trying again\n", r->username, inet_ntoa(r->addr.sin_addr)); if (r->call) { /* Unlink us, destroy old call. Locking is not relevent here because all this happens @@ -2784,7 +2788,7 @@ static int sip_reg_timeout(void *data) r->regstate=REG_STATE_UNREGISTERED; r->timeout = -1; res=transmit_register(r, "REGISTER", NULL); - ast_pthread_mutex_unlock(&r->lock); + ast_mutex_unlock(&r->lock); return 0; } @@ -3326,7 +3330,7 @@ static int register_verify(struct sip_pvt *p, struct sockaddr_in *sin, struct si *c = '\0'; strncpy(p->exten, name, sizeof(p->exten) - 1); build_contact(p); - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peer = peerl.peers; while(peer) { if (!strcasecmp(peer->name, name) && peer->dynamic) { @@ -3347,7 +3351,7 @@ static int register_verify(struct sip_pvt *p, struct sockaddr_in *sin, struct si } peer = peer->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); if (!res) { ast_device_state_changed("SIP/%s", peer->name); } @@ -3492,19 +3496,19 @@ static int get_refer_info(struct sip_pvt *p, struct sip_request *oreq) strncpy(p->refer_contact, "", sizeof(p->refer_contact) - 1); strncpy(p->remote_party_id, "", sizeof(p->remote_party_id) - 1); p->refer_call = NULL; - ast_pthread_mutex_lock(&iflock); + ast_mutex_lock(&iflock); /* Search interfaces and find the match */ p2 = iflist; while(p2) { if (!strcmp(p2->callid, tmp5)) { /* Go ahead and lock it before returning */ - ast_pthread_mutex_lock(&p2->lock); + ast_mutex_lock(&p2->lock); p->refer_call = p2; break; } p2 = p2->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); if (p->refer_call) return 0; else @@ -3633,7 +3637,7 @@ static int check_user(struct sip_pvt *p, struct sip_request *req, char *cmd, cha strncpy(p->callerid, of, sizeof(p->callerid) - 1); if (!strlen(of)) return 0; - ast_pthread_mutex_lock(&userl.lock); + ast_mutex_lock(&userl.lock); user = userl.users; while(user) { if (!strcasecmp(user->name, of)) { @@ -3670,10 +3674,10 @@ static int check_user(struct sip_pvt *p, struct sip_request *req, char *cmd, cha } user = user->next; } - ast_pthread_mutex_unlock(&userl.lock); + ast_mutex_unlock(&userl.lock); if (!user) { /* If we didn't find a user match, check for peers */ - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peer = peerl.peers; while(peer) { if (!inaddrcmp(&peer->addr, &p->recv) || @@ -3705,7 +3709,7 @@ static int check_user(struct sip_pvt *p, struct sip_request *req, char *cmd, cha } peer = peer->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); } return res; } @@ -3750,7 +3754,7 @@ static int sip_show_inuse(int fd, int argc, char *argv[]) { char used[80]; if (argc != 3) return RESULT_SHOWUSAGE; - ast_pthread_mutex_lock(&userl.lock); + ast_mutex_lock(&userl.lock); user = userl.users; ast_cli(fd, FORMAT, "Username", "inUse", "Limit"); for(user=userl.users;user;user=user->next) { @@ -3761,7 +3765,7 @@ static int sip_show_inuse(int fd, int argc, char *argv[]) { snprintf(used, sizeof(used), "%d", user->inUse); ast_cli(fd, FORMAT2, user->name, used, limits); } - ast_pthread_mutex_unlock(&userl.lock); + ast_mutex_unlock(&userl.lock); return RESULT_SUCCESS; #undef FORMAT #undef FORMAT2 @@ -3774,13 +3778,13 @@ static int sip_show_users(int fd, int argc, char *argv[]) struct sip_user *user; if (argc != 3) return RESULT_SHOWUSAGE; - ast_pthread_mutex_lock(&userl.lock); + ast_mutex_lock(&userl.lock); ast_cli(fd, FORMAT, "Username", "Secret", "Authen", "Def.Context", "A/C"); for(user=userl.users;user;user=user->next) { ast_cli(fd, FORMAT, user->name, user->secret, user->methods, user->context,user->ha ? "Yes" : "No"); } - ast_pthread_mutex_unlock(&userl.lock); + ast_mutex_unlock(&userl.lock); return RESULT_SUCCESS; #undef FORMAT } @@ -3793,7 +3797,7 @@ static int sip_show_peers(int fd, int argc, char *argv[]) char name[256] = ""; if (argc != 3) return RESULT_SHOWUSAGE; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); ast_cli(fd, FORMAT2, "Name/username", "Host", " ", "Mask", "Port", "Status"); for (peer = peerl.peers;peer;peer = peer->next) { char nm[20] = ""; @@ -3820,7 +3824,7 @@ static int sip_show_peers(int fd, int argc, char *argv[]) nm, ntohs(peer->addr.sin_port), status); } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); return RESULT_SUCCESS; #undef FORMAT #undef FORMAT2 @@ -3856,14 +3860,14 @@ static int sip_show_registry(int fd, int argc, char *argv[]) char host[80]; if (argc != 3) return RESULT_SHOWUSAGE; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); ast_cli(fd, FORMAT2, "Host", "Username", "Refresh", "State"); for (reg = registrations;reg;reg = reg->next) { snprintf(host, sizeof(host), "%s:%d", inet_ntoa(reg->addr.sin_addr), ntohs(reg->addr.sin_port)); ast_cli(fd, FORMAT, host, reg->username, reg->refresh, regstate2str(reg->regstate)); } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); return RESULT_SUCCESS; #undef FORMAT #undef FORMAT2 @@ -3877,7 +3881,7 @@ static int sip_show_channels(int fd, int argc, char *argv[]) int numchans = 0; if (argc != 3) return RESULT_SHOWUSAGE; - ast_pthread_mutex_lock(&iflock); + ast_mutex_lock(&iflock); cur = iflist; ast_cli(fd, FORMAT2, "Peer", "User/ANR", "Call ID", "Seq (Tx/Rx)", "Lag", "Jitter", "Format"); while (cur) { @@ -3893,7 +3897,7 @@ static int sip_show_channels(int fd, int argc, char *argv[]) } cur = cur->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); ast_cli(fd, "%d active SIP channel(s)\n", numchans); return RESULT_SUCCESS; #undef FORMAT @@ -3905,7 +3909,7 @@ static char *complete_sipch(char *line, char *word, int pos, int state) int which=0; struct sip_pvt *cur; char *c = NULL; - ast_pthread_mutex_lock(&iflock); + ast_mutex_lock(&iflock); cur = iflist; while(cur) { if (!strncasecmp(word, cur->callid, strlen(word))) { @@ -3916,7 +3920,7 @@ static char *complete_sipch(char *line, char *word, int pos, int state) } cur = cur->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return c; } @@ -3926,7 +3930,7 @@ static int sip_show_channel(int fd, int argc, char *argv[]) char tmp[256]; if (argc != 4) return RESULT_SHOWUSAGE; - ast_pthread_mutex_lock(&iflock); + ast_mutex_lock(&iflock); cur = iflist; while(cur) { if (!strcasecmp(cur->callid, argv[3])) { @@ -3950,7 +3954,7 @@ static int sip_show_channel(int fd, int argc, char *argv[]) } cur = cur->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); if (!cur) ast_cli(fd, "No such SIP Call ID '%s'\n", argv[3]); return RESULT_SUCCESS; @@ -4643,7 +4647,7 @@ static int handle_request(struct sip_pvt *p, struct sip_request *req, struct soc build_route(p, req, 0); if (c) { /* Pre-lock the call */ - ast_pthread_mutex_lock(&c->lock); + ast_mutex_lock(&c->lock); } } @@ -4660,10 +4664,10 @@ static int handle_request(struct sip_pvt *p, struct sip_request *req, struct soc if (ast_pbx_start(c)) { ast_log(LOG_WARNING, "Failed to start PBX :(\n"); /* Unlock locks so ast_hangup can do its magic */ - ast_pthread_mutex_unlock(&c->lock); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&c->lock); + ast_mutex_unlock(&p->lock); ast_hangup(c); - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); transmit_response_reliable(p, "503 Unavailable", req); c = NULL; } @@ -4672,16 +4676,16 @@ static int handle_request(struct sip_pvt *p, struct sip_request *req, struct soc transmit_response_reliable(p, "503 Unavailable", req); p->alreadygone = 1; /* Unlock locks so ast_hangup can do its magic */ - ast_pthread_mutex_unlock(&c->lock); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&c->lock); + ast_mutex_unlock(&p->lock); ast_hangup(c); - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); c = NULL; } else { - ast_pthread_mutex_unlock(&c->lock); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&c->lock); + ast_mutex_unlock(&p->lock); ast_hangup(c); - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); c = NULL; } break; @@ -4720,7 +4724,7 @@ static int handle_request(struct sip_pvt *p, struct sip_request *req, struct soc if (p->refer_call) { ast_log(LOG_DEBUG,"202 Accepted (supervised)\n"); attempt_transfer(p, p->refer_call); - ast_pthread_mutex_unlock(&p->refer_call->lock); + ast_mutex_unlock(&p->refer_call->lock); p->refer_call = NULL; } else { ast_log(LOG_DEBUG,"202 Accepted (blind)\n"); @@ -4909,26 +4913,26 @@ static int sipsock_read(int *id, int fd, short events, void *ignore) return 1; } /* Process request, with netlock held */ - ast_pthread_mutex_lock(&netlock); + ast_mutex_lock(&netlock); p = find_call(&req, &sin); if (p) { retrylock: /* Go ahead and lock the owner if it has one -- we may need it */ - if (p->owner && pthread_mutex_trylock(&p->owner->lock)) { + if (p->owner && ast_mutex_trylock(&p->owner->lock)) { ast_log(LOG_DEBUG, "Failed to grab lock, trying again...\n"); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); /* Sleep infintismly short amount of time */ usleep(1); - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); goto retrylock; } memcpy(&p->recv, &sin, sizeof(p->recv)); handle_request(p, &req, &sin); if (p->owner) - ast_pthread_mutex_unlock(&p->owner->lock); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->owner->lock); + ast_mutex_unlock(&p->lock); } - ast_pthread_mutex_unlock(&netlock); + ast_mutex_unlock(&netlock); return 1; } @@ -4945,19 +4949,19 @@ static int sip_send_mwi_to_peer(struct sip_peer *peer) /* Return now if it's the same thing we told them last time */ if (((newmsgs << 8) | (oldmsgs)) == peer->lastmsgssent) { - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); return 0; } p = sip_alloc(NULL, NULL, 0); if (!p) { ast_log(LOG_WARNING, "Unable to build sip pvt data for MWI\n"); - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); return -1; } strncpy(name, peer->name, sizeof(name) - 1); peer->lastmsgssent = ((newmsgs << 8) | (oldmsgs)); - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); if (create_addr(p, name)) { /* Maybe they're not registered, etc. */ sip_destroy(p); @@ -4994,29 +4998,29 @@ static void *do_monitor(void *data) /* From here on out, we die whenever asked */ for(;;) { /* Check for interfaces needing to be killed */ - ast_pthread_mutex_lock(&iflock); + ast_mutex_lock(&iflock); restartsearch: sip = iflist; while(sip) { - ast_pthread_mutex_lock(&sip->lock); + ast_mutex_lock(&sip->lock); if (sip->needdestroy && !sip->packets) { - ast_pthread_mutex_unlock(&sip->lock); + ast_mutex_unlock(&sip->lock); __sip_destroy(sip, 1); goto restartsearch; } - ast_pthread_mutex_unlock(&sip->lock); + ast_mutex_unlock(&sip->lock); sip = sip->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); /* Don't let anybody kill us right away. Nobody should lock the interface list and wait for the monitor list, but the other way around is okay. */ - ast_pthread_mutex_lock(&monlock); + ast_mutex_lock(&monlock); /* Lock the network interface */ - ast_pthread_mutex_lock(&netlock); + ast_mutex_lock(&netlock); /* Okay, now that we know what to do, release the network lock */ - ast_pthread_mutex_unlock(&netlock); + ast_mutex_unlock(&netlock); /* And from now on, we're okay to be killed, so release the monitor lock as well */ - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); pthread_testcancel(); /* Wait for sched or io */ res = ast_sched_wait(sched); @@ -5026,10 +5030,10 @@ restartsearch: if (fastrestart) res = 1; res = ast_io_wait(io, res); - ast_pthread_mutex_lock(&monlock); + ast_mutex_lock(&monlock); if (res >= 0) ast_sched_runq(sched); - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peer = peerl.peers; time(&t); fastrestart = 0; @@ -5048,9 +5052,9 @@ restartsearch: if (!peer) { /* Reset where we come from */ lastpeernum = -1; - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); } - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); } /* Never reached */ return NULL; @@ -5062,12 +5066,12 @@ static int restart_monitor(void) /* If we're supposed to be stopped -- stay stopped */ if (monitor_thread == -2) return 0; - if (ast_pthread_mutex_lock(&monlock)) { + if (ast_mutex_lock(&monlock)) { ast_log(LOG_WARNING, "Unable to lock monitor\n"); return -1; } if (monitor_thread == pthread_self()) { - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); ast_log(LOG_WARNING, "Cannot kill myself\n"); return -1; } @@ -5077,12 +5081,12 @@ static int restart_monitor(void) } else { /* Start a new monitor */ if (pthread_create(&monitor_thread, NULL, do_monitor, NULL) < 0) { - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); ast_log(LOG_ERROR, "Unable to start monitor thread.\n"); return -1; } } - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); return 0; } @@ -5176,7 +5180,7 @@ static int sip_devicestate(void *data) ext = NULL; } - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); p = peerl.peers; while (p) { if (!strcasecmp(p->name, host)) { @@ -5191,7 +5195,7 @@ static int sip_devicestate(void *data) } p = p->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); if (!p && !found) { hp = gethostbyname(host); if (hp) @@ -5344,7 +5348,7 @@ static struct sip_peer *build_peer(char *name, struct ast_variable *v) int format; int found=0; prev = NULL; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peer = peerl.peers; while(peer) { if (!strcasecmp(peer->name, name)) { @@ -5361,9 +5365,9 @@ static struct sip_peer *build_peer(char *name, struct ast_variable *v) } else { peerl.peers = peer->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); } else { - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); peer = malloc(sizeof(struct sip_peer)); memset(peer, 0, sizeof(struct sip_peer)); peer->expire = -1; @@ -5637,19 +5641,19 @@ static int reload_config(void) if (!strcasecmp(utype, "user") || !strcasecmp(utype, "friend")) { user = build_user(cat, ast_variable_browse(cfg, cat)); if (user) { - ast_pthread_mutex_lock(&userl.lock); + ast_mutex_lock(&userl.lock); user->next = userl.users; userl.users = user; - ast_pthread_mutex_unlock(&userl.lock); + ast_mutex_unlock(&userl.lock); } } if (!strcasecmp(utype, "peer") || !strcasecmp(utype, "friend")) { peer = build_peer(cat, ast_variable_browse(cfg, cat)); if (peer) { - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peer->next = peerl.peers; peerl.peers = peer; - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); } } else if (strcasecmp(utype, "user")) { ast_log(LOG_WARNING, "Unknown type '%s' for '%s' in %s\n", utype, cat, "sip.conf"); @@ -5673,7 +5677,7 @@ static int reload_config(void) if (!ntohs(bindaddr.sin_port)) bindaddr.sin_port = ntohs(DEFAULT_SIP_PORT); bindaddr.sin_family = AF_INET; - pthread_mutex_lock(&netlock); + ast_mutex_lock(&netlock); if ((sipsock > -1) && (ntohs(bindaddr.sin_port) != oldport)) { close(sipsock); sipsock = -1; @@ -5706,7 +5710,7 @@ static int reload_config(void) } } } - pthread_mutex_unlock(&netlock); + ast_mutex_unlock(&netlock); ast_destroy(cfg); return 0; @@ -5787,14 +5791,14 @@ int load_module() ast_log(LOG_WARNING, "Unable to create I/O context\n"); } - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); for (peer = peerl.peers; peer; peer = peer->next) sip_poke_peer(peer); for (reg = registrations; reg; reg = reg->next) sip_do_register(reg); - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); /* And start the monitor for the first time */ restart_monitor(); @@ -5809,7 +5813,7 @@ static void delete_users(void) struct sip_registry *reg, *regl; /* Delete all users */ - ast_pthread_mutex_lock(&userl.lock); + ast_mutex_lock(&userl.lock); for (user=userl.users;user;) { ast_free_ha(user->ha); userlast = user; @@ -5817,7 +5821,7 @@ static void delete_users(void) free(userlast); } userl.users=NULL; - ast_pthread_mutex_unlock(&userl.lock); + ast_mutex_unlock(&userl.lock); for (reg = registrations;reg;) { regl = reg; @@ -5827,20 +5831,20 @@ static void delete_users(void) free(regl); } registrations = NULL; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); for (peer=peerl.peers;peer;) { /* Assume all will be deleted, and we'll find out for sure later */ peer->delme = 1; peer = peer->next; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); } static void prune_peers(void) { /* Prune peers who still are supposed to be deleted */ struct sip_peer *peer, *peerlast, *peernext; - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); peerlast = NULL; for (peer=peerl.peers;peer;) { peernext = peer->next; @@ -5861,7 +5865,7 @@ static void prune_peers(void) peerlast = peer; peer=peernext; } - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); } int reload(void) @@ -5876,10 +5880,10 @@ int reload(void) restart_monitor(); for (reg = registrations; reg; reg = reg->next) sip_do_register(reg); - ast_pthread_mutex_lock(&peerl.lock); + ast_mutex_lock(&peerl.lock); for (peer = peerl.peers; peer; peer = peer->next) sip_poke_peer(peer); - ast_pthread_mutex_unlock(&peerl.lock); + ast_mutex_unlock(&peerl.lock); return 0; } @@ -5889,7 +5893,7 @@ int unload_module() /* First, take us out of the channel loop */ ast_channel_unregister(type); - if (!ast_pthread_mutex_lock(&iflock)) { + if (!ast_mutex_lock(&iflock)) { /* Hangup all interfaces if they have an owner */ p = iflist; while(p) { @@ -5898,25 +5902,25 @@ int unload_module() p = p->next; } iflist = NULL; - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; } - if (!ast_pthread_mutex_lock(&monlock)) { + if (!ast_mutex_lock(&monlock)) { if (monitor_thread) { pthread_cancel(monitor_thread); pthread_kill(monitor_thread, SIGURG); pthread_join(monitor_thread, NULL); } monitor_thread = -2; - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; } - if (!ast_pthread_mutex_lock(&iflock)) { + if (!ast_mutex_lock(&iflock)) { /* Destroy all the interfaces and free their memory */ p = iflist; while(p) { @@ -5926,7 +5930,7 @@ int unload_module() free(pl); } iflist = NULL; - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; @@ -5938,9 +5942,9 @@ int unload_module() int usecount() { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } diff --git a/channels/chan_vofr.c b/channels/chan_vofr.c index 4cbc71f2b..37d8a1f52 100755 --- a/channels/chan_vofr.c +++ b/channels/chan_vofr.c @@ -53,14 +53,14 @@ static char context[AST_MAX_EXTENSION] = "default"; static char language[MAX_LANGUAGE] = ""; static int usecnt =0; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; /* Protect the interface list (of vofr_pvt's) */ -static pthread_mutex_t iflock = AST_MUTEX_INITIALIZER; +static ast_mutex_t iflock = AST_MUTEX_INITIALIZER; /* Protect the monitoring thread, so only one process can kill or start it, and not when it's doing something critical. */ -static pthread_mutex_t monlock = AST_MUTEX_INITIALIZER; +static ast_mutex_t monlock = AST_MUTEX_INITIALIZER; /* This is the thread for the monitor which checks for input on the channels which are not currently in use. */ @@ -457,11 +457,11 @@ static int vofr_hangup(struct ast_channel *ast) ast->state = AST_STATE_DOWN; ((struct vofr_pvt *)(ast->pvt->pvt))->owner = NULL; ((struct vofr_pvt *)(ast->pvt->pvt))->ringgothangup = 0; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt--; if (usecnt < 0) ast_log(LOG_WARNING, "Usecnt < 0???\n"); - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); if (option_verbose > 2) ast_verbose( VERBOSE_PREFIX_3 "Hungup '%s'\n", ast->name); @@ -826,9 +826,9 @@ static struct ast_channel *vofr_new(struct vofr_pvt *i, int state) if (strlen(i->language)) strncpy(tmp->language, i->language, sizeof(tmp->language)-1); i->owner = tmp; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); strncpy(tmp->context, i->context, sizeof(tmp->context)-1); if (state != AST_STATE_DOWN) { @@ -916,14 +916,14 @@ static void *do_monitor(void *data) for(;;) { /* Don't let anybody kill us right away. Nobody should lock the interface list and wait for the monitor list, but the other way around is okay. */ - if (ast_pthread_mutex_lock(&monlock)) { + if (ast_mutex_lock(&monlock)) { ast_log(LOG_ERROR, "Unable to grab monitor lock\n"); return NULL; } /* Lock the interface list */ - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { ast_log(LOG_ERROR, "Unable to grab interface lock\n"); - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); return NULL; } /* Build the stuff we're going to select on, that is the socket of every @@ -947,10 +947,10 @@ static void *do_monitor(void *data) i = i->next; } /* Okay, now that we know what to do, release the interface lock */ - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); /* And from now on, we're okay to be killed, so release the monitor lock as well */ - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); pthread_testcancel(); /* Wait indefinitely for something to happen */ res = ast_select(n + 1, &rfds, NULL, NULL, NULL); @@ -963,7 +963,7 @@ static void *do_monitor(void *data) } /* Alright, lock the interface list again, and let's look and see what has happened */ - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { ast_log(LOG_WARNING, "Unable to lock the interface list\n"); continue; } @@ -987,7 +987,7 @@ static void *do_monitor(void *data) } i=i->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } /* Never reached */ return NULL; @@ -999,12 +999,12 @@ static int restart_monitor(void) /* If we're supposed to be stopped -- stay stopped */ if (monitor_thread == -2) return 0; - if (ast_pthread_mutex_lock(&monlock)) { + if (ast_mutex_lock(&monlock)) { ast_log(LOG_WARNING, "Unable to lock monitor\n"); return -1; } if (monitor_thread == pthread_self()) { - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); ast_log(LOG_WARNING, "Cannot kill myself\n"); return -1; } @@ -1014,12 +1014,12 @@ static int restart_monitor(void) } else { /* Start a new monitor */ if (pthread_create(&monitor_thread, NULL, do_monitor, NULL) < 0) { - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); ast_log(LOG_ERROR, "Unable to start monitor thread.\n"); return -1; } } - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); return 0; } @@ -1119,7 +1119,7 @@ static struct ast_channel *vofr_request(char *type, int format, void *data) return NULL; } /* Search for an unowned channel */ - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { ast_log(LOG_ERROR, "Unable to lock interface list???\n"); return NULL; } @@ -1131,7 +1131,7 @@ static struct ast_channel *vofr_request(char *type, int format, void *data) } p = p->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); restart_monitor(); return tmp; } @@ -1148,7 +1148,7 @@ int load_module() ast_log(LOG_ERROR, "Unable to load config %s\n", config); return -1; } - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { /* It's a little silly to lock it, but we mind as well just to be sure */ ast_log(LOG_ERROR, "Unable to lock interface list???\n"); return -1; @@ -1165,7 +1165,7 @@ int load_module() } else { ast_log(LOG_ERROR, "Unable to register channel '%s'\n", v->value); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); unload_module(); return -1; } @@ -1176,7 +1176,7 @@ int load_module() } v = v->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); /* Make sure we can register our AdtranVoFR channel type */ if (ast_channel_register(type, tdesc, AST_FORMAT_G723_1, vofr_request)) { ast_log(LOG_ERROR, "Unable to register channel class %s\n", type); @@ -1195,7 +1195,7 @@ int unload_module() struct vofr_pvt *p, *pl; /* First, take us out of the channel loop */ ast_channel_unregister(type); - if (!ast_pthread_mutex_lock(&iflock)) { + if (!ast_mutex_lock(&iflock)) { /* Hangup all interfaces if they have an owner */ p = iflist; while(p) { @@ -1204,25 +1204,25 @@ int unload_module() p = p->next; } iflist = NULL; - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; } - if (!ast_pthread_mutex_lock(&monlock)) { + if (!ast_mutex_lock(&monlock)) { if (monitor_thread) { pthread_cancel(monitor_thread); pthread_kill(monitor_thread, SIGURG); pthread_join(monitor_thread, NULL); } monitor_thread = -2; - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; } - if (!ast_pthread_mutex_lock(&iflock)) { + if (!ast_mutex_lock(&iflock)) { /* Destroy all the interfaces and free their memory */ p = iflist; while(p) { @@ -1235,7 +1235,7 @@ int unload_module() free(pl); } iflist = NULL; - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; @@ -1247,9 +1247,9 @@ int unload_module() int usecount() { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } diff --git a/channels/chan_vpb.c b/channels/chan_vpb.c index 7c7353bab..74f6c4ea8 100755 --- a/channels/chan_vpb.c +++ b/channels/chan_vpb.c @@ -71,14 +71,14 @@ static int silencesupression = 0; static const int prefformat = AST_FORMAT_ALAW | AST_FORMAT_SLINEAR | AST_FORMAT_ULAW | AST_FORMAT_ADPCM; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; /* Protect the interface list (of vpb_pvt's) */ -static pthread_mutex_t iflock = AST_MUTEX_INITIALIZER; +static ast_mutex_t iflock = AST_MUTEX_INITIALIZER; /* Protect the monitoring thread, so only one process can kill or start it, and not when it's doing something critical. */ -static pthread_mutex_t monlock = AST_MUTEX_INITIALIZER; +static ast_mutex_t monlock = AST_MUTEX_INITIALIZER; /* This is the thread for the monitor which checks for input on the channels which are not currently in use. */ @@ -110,11 +110,11 @@ static struct vpb_bridge_t { struct ast_frame **fo; int flags; - pthread_mutex_t lock; + ast_mutex_t lock; pthread_cond_t cond; } bridges[VPB_MAX_BRIDGES]; /* Bridges...*/ -static pthread_mutex_t bridge_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t bridge_lock = AST_MUTEX_INITIALIZER; static struct vpb_pvt { @@ -148,7 +148,7 @@ static struct vpb_pvt { int lastgrunt; - pthread_mutex_t lock; + ast_mutex_t lock; int stopreads; /* Stop reading...*/ pthread_t readthread; /* For monitoring read channel. One per owned channel. */ @@ -166,7 +166,7 @@ static int vpb_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, /* Bridge channels, check if we can. I believe we always can, so find a slot.*/ - ast_pthread_mutex_lock(&bridge_lock); { + ast_mutex_lock(&bridge_lock); { for (i = 0; i < len; i++) if (!bridges[i].inuse) break; @@ -180,7 +180,7 @@ static int vpb_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, pthread_mutex_init(&bridges[i].lock, NULL); pthread_cond_init(&bridges[i].cond, NULL); } - } ast_pthread_mutex_unlock(&bridge_lock); + } ast_mutex_unlock(&bridge_lock); if (i == len) { ast_log(LOG_WARNING, "Failed to bridge %s and %s!\n", c0->name, c1->name); @@ -188,13 +188,13 @@ static int vpb_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, } else { /* Set bridge pointers. You don't want to take these locks while holding bridge lock.*/ - ast_pthread_mutex_lock(&p0->lock); { + ast_mutex_lock(&p0->lock); { p0->bridge = &bridges[i]; - } ast_pthread_mutex_unlock(&p0->lock); + } ast_mutex_unlock(&p0->lock); - ast_pthread_mutex_lock(&p1->lock); { + ast_mutex_lock(&p1->lock); { p1->bridge = &bridges[i]; - } ast_pthread_mutex_unlock(&p1->lock); + } ast_mutex_unlock(&p1->lock); if (option_verbose > 4) ast_verbose(VERBOSE_PREFIX_3 @@ -213,19 +213,19 @@ static int vpb_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, vpb_bridge(p0->handle, p1->handle, VPB_BRIDGE_OFF, 0); - ast_pthread_mutex_lock(&bridge_lock); { + ast_mutex_lock(&bridge_lock); { bridges[i].inuse = 0; pthread_mutex_destroy(&bridges[i].lock); pthread_cond_destroy(&bridges[i].cond); - } ast_pthread_mutex_unlock(&bridge_lock); + } ast_mutex_unlock(&bridge_lock); - ast_pthread_mutex_lock(&p0->lock); { + ast_mutex_lock(&p0->lock); { p0->bridge = NULL; - } ast_pthread_mutex_unlock(&p0->lock); + } ast_mutex_unlock(&p0->lock); - ast_pthread_mutex_lock(&p1->lock); { + ast_mutex_lock(&p1->lock); { p1->bridge = NULL; - } ast_pthread_mutex_unlock(&p1->lock); + } ast_mutex_unlock(&p1->lock); if (option_verbose > 4) @@ -318,7 +318,7 @@ static inline int monitor_handle_owned(struct vpb_pvt *p, VPB_EVENT *e) ast_verbose(VERBOSE_PREFIX_3 " handle_owned: putting frame: [%d=>%d], bridge=%p\n", f.frametype, f.subclass, (void *)p->bridge); - ast_pthread_mutex_lock(&p->lock); { + ast_mutex_lock(&p->lock); { if (p->bridge) { /* Check what happened, see if we need to report it. */ switch (f.frametype) { case AST_FRAME_DTMF: @@ -350,12 +350,12 @@ static inline int monitor_handle_owned(struct vpb_pvt *p, VPB_EVENT *e) if (p->bridge->rc) *p->bridge->rc = p->owner; - ast_pthread_mutex_lock(&p->bridge->lock); { + ast_mutex_lock(&p->bridge->lock); { pthread_cond_signal(&p->bridge->cond); - } ast_pthread_mutex_unlock(&p->bridge->lock); + } ast_mutex_unlock(&p->bridge->lock); } } - } ast_pthread_mutex_unlock(&p->lock); + } ast_mutex_unlock(&p->lock); if (endbridge) return 0; @@ -450,8 +450,8 @@ static void *do_monitor(void *unused) goto end_loop; str[0] = 0; - ast_pthread_mutex_lock(&monlock), - ast_pthread_mutex_lock(&iflock); { + ast_mutex_lock(&monlock), + ast_mutex_lock(&iflock); { struct vpb_pvt *p = iflist; /* Find the pvt structure */ vpb_translate_event(&e, str); @@ -480,8 +480,8 @@ static void *do_monitor(void *unused) monitor_handle_notowned(p, &e); done: (void)0; - } ast_pthread_mutex_unlock(&iflock); - ast_pthread_mutex_unlock(&monlock); + } ast_mutex_unlock(&iflock); + ast_mutex_unlock(&monlock); end_loop: tcounter += VPB_WAIT_TIMEOUT; /* Ok, not quite but will suffice. */ @@ -499,7 +499,7 @@ static int restart_monitor(void) /* If we're supposed to be stopped -- stay stopped */ if (mthreadactive == -2) return 0; - ast_pthread_mutex_lock(&monlock); { + ast_mutex_lock(&monlock); { if (monitor_thread == pthread_self()) { ast_log(LOG_WARNING, "Cannot kill myself\n"); error = -1; @@ -531,7 +531,7 @@ static int restart_monitor(void) #endif } done: (void)0; - } ast_pthread_mutex_unlock(&monlock); + } ast_mutex_unlock(&monlock); return error; } @@ -744,18 +744,18 @@ static int vpb_hangup(struct ast_channel *ast) ast_setstate(ast,AST_STATE_DOWN); - ast_pthread_mutex_lock(&p->lock); { + ast_mutex_lock(&p->lock); { p->lastinput = p->lastoutput = -1; p->ext[0] = 0; p->owner = NULL; p->dialtone = 0; p->calling = 0; ast->pvt->pvt = NULL; - } ast_pthread_mutex_unlock(&p->lock); + } ast_mutex_unlock(&p->lock); - ast_pthread_mutex_lock(&usecnt_lock); { + ast_mutex_lock(&usecnt_lock); { usecnt--; - } ast_pthread_mutex_unlock(&usecnt_lock); + } ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); /* Stop thread doing reads. */ @@ -913,7 +913,7 @@ static void *do_chanreads(void *pvt) p->lastinput = fmt; } - ast_pthread_mutex_lock(&p->lock); { + ast_mutex_lock(&p->lock); { if (p->bridge) if (p->bridge->c0 == p->owner && (p->bridge->flags & AST_BRIDGE_REC_CHANNEL_0)) @@ -925,7 +925,7 @@ static void *do_chanreads(void *pvt) bridgerec = 0; else bridgerec = 1; - } ast_pthread_mutex_unlock(&p->lock); + } ast_mutex_unlock(&p->lock); if (state == AST_STATE_UP && bridgerec) { /* Read only if up and not bridged, or a bridge for which we can read. */ @@ -941,9 +941,9 @@ static void *do_chanreads(void *pvt) fr->datalen = readlen; fr->offset = AST_FRIENDLY_OFFSET; - ast_pthread_mutex_lock(&p->lock); { + ast_mutex_lock(&p->lock); { if (p->owner) ast_queue_frame(p->owner, fr, 0); - } ast_pthread_mutex_unlock(&p->lock); + } ast_mutex_unlock(&p->lock); } else p->stopreads = 1; @@ -1009,9 +1009,9 @@ static struct ast_channel *vpb_new(struct vpb_pvt *i, int state, char *context) i->lastinput = i->lastoutput = -1; i->lastgrunt = tcounter; /* Assume at least one grunt tone seen now. */ - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); if (state != AST_STATE_DOWN) if (ast_pbx_start(tmp)) { @@ -1047,7 +1047,7 @@ static struct ast_channel *vpb_request(char *type, int format, void *data) if (!s) s = ""; /* Search for an unowned channel */ - ast_pthread_mutex_lock(&iflock); { + ast_mutex_lock(&iflock); { p = iflist; while(p) { if (strncmp(s, p->dev + 4, sizeof p->dev) == 0) @@ -1057,7 +1057,7 @@ static struct ast_channel *vpb_request(char *type, int format, void *data) } p = p->next; } - } ast_pthread_mutex_unlock(&iflock); + } ast_mutex_unlock(&iflock); if (option_verbose > 2) @@ -1114,7 +1114,7 @@ int load_module() vpb_seterrormode(VPB_DEVELOPMENT); - ast_pthread_mutex_lock(&iflock); { + ast_mutex_lock(&iflock); { v = ast_variable_browse(cfg, "interfaces"); while(v) { /* Create the interface list */ @@ -1176,7 +1176,7 @@ int load_module() gruntdetect_timeout = 1000; done: (void)0; - } ast_pthread_mutex_unlock(&iflock); + } ast_mutex_unlock(&iflock); ast_destroy(cfg); @@ -1205,7 +1205,7 @@ int unload_module() /* First, take us out of the channel loop */ ast_channel_unregister(type); - ast_pthread_mutex_lock(&iflock); { + ast_mutex_lock(&iflock); { /* Hangup all interfaces if they have an owner */ p = iflist; while(p) { @@ -1214,17 +1214,17 @@ int unload_module() p = p->next; } iflist = NULL; - } ast_pthread_mutex_unlock(&iflock); + } ast_mutex_unlock(&iflock); - ast_pthread_mutex_lock(&monlock); { + ast_mutex_lock(&monlock); { if (mthreadactive > -1) { pthread_cancel(monitor_thread); pthread_join(monitor_thread, NULL); } mthreadactive = -2; - } ast_pthread_mutex_unlock(&monlock); + } ast_mutex_unlock(&monlock); - ast_pthread_mutex_lock(&iflock); { + ast_mutex_lock(&iflock); { /* Destroy all the interfaces and free their memory */ while(iflist) { @@ -1238,11 +1238,11 @@ int unload_module() free(p); } iflist = NULL; - } ast_pthread_mutex_unlock(&iflock); + } ast_mutex_unlock(&iflock); - ast_pthread_mutex_lock(&bridge_lock); { + ast_mutex_lock(&bridge_lock); { memset(bridges, 0, sizeof bridges); - } ast_pthread_mutex_unlock(&bridge_lock); + } ast_mutex_unlock(&bridge_lock); pthread_mutex_destroy(&bridge_lock); tcounter = 0; @@ -1253,9 +1253,9 @@ int unload_module() int usecount() { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } diff --git a/channels/chan_zap.c b/channels/chan_zap.c index 382890e05..09a2db606 100755 --- a/channels/chan_zap.c +++ b/channels/chan_zap.c @@ -200,14 +200,14 @@ static int gendigittimeout = 8000; static int matchdigittimeout = 3000; static int usecnt =0; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; /* Protect the interface list (of zt_pvt's) */ -static pthread_mutex_t iflock = AST_MUTEX_INITIALIZER; +static ast_mutex_t iflock = AST_MUTEX_INITIALIZER; /* Protect the monitoring thread, so only one process can kill or start it, and not when it's doing something critical. */ -static pthread_mutex_t monlock = AST_MUTEX_INITIALIZER; +static ast_mutex_t monlock = AST_MUTEX_INITIALIZER; /* This is the thread for the monitor which checks for input on the channels which are not currently in use. */ @@ -260,7 +260,7 @@ static int r2prot = -1; #ifdef ZAPATA_PRI struct zt_pri { pthread_t master; /* Thread of master */ - pthread_mutex_t lock; /* Mutex */ + ast_mutex_t lock; /* Mutex */ char idleext[AST_MAX_EXTENSION]; /* Where to idle extra calls */ char idlecontext[AST_MAX_EXTENSION]; /* What context to use for idle */ char idledial[AST_MAX_EXTENSION]; /* What to dial before dumping */ @@ -299,7 +299,7 @@ static int pritype = PRI_CPE; static inline void pri_rel(struct zt_pri *pri) { - ast_pthread_mutex_unlock(&pri->lock); + ast_mutex_unlock(&pri->lock); } static int switchtype = PRI_SWITCH_NI2; @@ -337,7 +337,7 @@ struct zt_subchannel { #define MAX_SLAVES 4 static struct zt_pvt { - pthread_mutex_t lock; + ast_mutex_t lock; struct ast_channel *owner; /* Our current active owner (if applicable) */ /* Up to three channels can be associated with this call */ @@ -457,12 +457,12 @@ static inline int pri_grab(struct zt_pvt *pvt, struct zt_pri *pri) int res; /* Grab the lock first */ do { - res = pthread_mutex_trylock(&pri->lock); + res = ast_mutex_trylock(&pri->lock); if (res) { - ast_pthread_mutex_unlock(&pvt->lock); + ast_mutex_unlock(&pvt->lock); /* Release the lock and try again */ usleep(1); - ast_pthread_mutex_lock(&pvt->lock); + ast_mutex_lock(&pvt->lock); } } while(res); /* Then break the select */ @@ -1490,7 +1490,7 @@ static int zt_hangup(struct ast_channel *ast) return 0; } - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); index = zt_get_index(ast, p, 1); @@ -1726,17 +1726,17 @@ static int zt_hangup(struct ast_channel *ast) p->callwaitingrepeat = 0; p->cidcwexpire = 0; ast->pvt->pvt = NULL; - ast_pthread_mutex_unlock(&p->lock); - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_unlock(&p->lock); + ast_mutex_lock(&usecnt_lock); usecnt--; if (usecnt < 0) ast_log(LOG_WARNING, "Usecnt < 0???\n"); - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); if (option_verbose > 2) ast_verbose( VERBOSE_PREFIX_3 "Hungup '%s'\n", ast->name); - ast_pthread_mutex_lock(&iflock); + ast_mutex_lock(&iflock); tmp = iflist; prev = NULL; if (p->destroy) { @@ -1750,7 +1750,7 @@ static int zt_hangup(struct ast_channel *ast) } } } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return 0; } @@ -1761,13 +1761,13 @@ static int zt_answer(struct ast_channel *ast) int index; int oldstate = ast->_state; ast_setstate(ast, AST_STATE_UP); - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); index = zt_get_index(ast, p, 0); if (index < 0) index = SUB_REAL; /* nothing to do if a radio channel */ if (p->radio) { - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return 0; } switch(p->sig) { @@ -1823,13 +1823,13 @@ static int zt_answer(struct ast_channel *ast) break; #endif case 0: - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return 0; default: ast_log(LOG_WARNING, "Don't know how to answer signalling %d (channel %d)\n", p->sig, p->channel); res = -1; } - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return res; } @@ -2061,8 +2061,8 @@ static int zt_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, /* cant do pseudo-channels here */ if ((!p0->sig) || (!p1->sig)) return -2; - ast_pthread_mutex_lock(&c0->lock); - ast_pthread_mutex_lock(&c1->lock); + ast_mutex_lock(&c0->lock); + ast_mutex_lock(&c1->lock); op0 = p0 = c0->pvt->pvt; op1 = p1 = c1->pvt->pvt; ofd1 = c0->fds[0]; @@ -2076,12 +2076,12 @@ static int zt_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, - ast_pthread_mutex_lock(&p0->lock); - if (pthread_mutex_trylock(&p1->lock)) { + ast_mutex_lock(&p0->lock); + if (ast_mutex_trylock(&p1->lock)) { /* Don't block, due to potential for deadlock */ - ast_pthread_mutex_unlock(&p0->lock); - ast_pthread_mutex_unlock(&c0->lock); - ast_pthread_mutex_unlock(&c1->lock); + ast_mutex_unlock(&p0->lock); + ast_mutex_unlock(&c0->lock); + ast_mutex_unlock(&c1->lock); ast_log(LOG_NOTICE, "Avoiding deadlock...\n"); return -3; } @@ -2184,11 +2184,11 @@ static int zt_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, t1 = p0->subs[SUB_REAL].inthreeway; t2 = p1->subs[SUB_REAL].inthreeway; - ast_pthread_mutex_unlock(&p0->lock); - ast_pthread_mutex_unlock(&p1->lock); + ast_mutex_unlock(&p0->lock); + ast_mutex_unlock(&p1->lock); - ast_pthread_mutex_unlock(&c0->lock); - ast_pthread_mutex_unlock(&c1->lock); + ast_mutex_unlock(&c0->lock); + ast_mutex_unlock(&c1->lock); /* Native bridge failed */ if ((!master || !slave) && !nothingok) { @@ -2205,16 +2205,16 @@ static int zt_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, for (;;) { /* Here's our main loop... Start by locking things, looking for private parts, and then balking if anything is wrong */ - ast_pthread_mutex_lock(&c0->lock); - ast_pthread_mutex_lock(&c1->lock); + ast_mutex_lock(&c0->lock); + ast_mutex_lock(&c1->lock); p0 = c0->pvt->pvt; p1 = c1->pvt->pvt; if (op0 == p0) i1 = zt_get_index(c0, p0, 1); if (op1 == p1) i2 = zt_get_index(c1, p1, 1); - ast_pthread_mutex_unlock(&c0->lock); - ast_pthread_mutex_unlock(&c1->lock); + ast_mutex_unlock(&c0->lock); + ast_mutex_unlock(&c1->lock); if ((op0 != p0) || (op1 != p1) || (ofd1 != c0->fds[0]) || (ofd2 != c1->fds[0]) || @@ -2984,7 +2984,7 @@ struct ast_frame *zt_exception(struct ast_channel *ast) int index; struct ast_frame *f; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); index = zt_get_index(ast, p, 1); @@ -3062,7 +3062,7 @@ struct ast_frame *zt_exception(struct ast_channel *ast) ast_log(LOG_WARNING, "Don't know how to absorb event %s\n", event2str(res)); } f = &p->subs[index].f; - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return f; } if (!p->radio) ast_log(LOG_DEBUG, "Exception on %d, channel %d\n", ast->fds[0],p->channel); @@ -3070,11 +3070,11 @@ struct ast_frame *zt_exception(struct ast_channel *ast) if (ast != p->owner) { ast_log(LOG_WARNING, "We're %s, not %s\n", ast->name, p->owner->name); f = &p->subs[index].f; - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return f; } f = zt_handle_event(ast); - ast_pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return f; } @@ -3087,7 +3087,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) struct ast_frame *f; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); index = zt_get_index(ast, p, 0); @@ -3103,7 +3103,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) /* Hang up if we don't really exist */ if (index < 0) { ast_log(LOG_WARNING, "We dont exist?\n"); - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return NULL; } @@ -3125,11 +3125,11 @@ struct ast_frame *zt_read(struct ast_channel *ast) { p->subs[index].f.subclass = AST_CONTROL_RADIO_UNKEY; } - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return &p->subs[index].f; } if (p->ringt == 1) { - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return NULL; } else if (p->ringt > 0) @@ -3141,7 +3141,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) p->subs[index].f.frametype = AST_FRAME_CONTROL; p->subs[index].f.subclass = AST_CONTROL_RINGING; ast_setstate(ast, AST_STATE_RINGING); - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return &p->subs[index].f; } @@ -3156,7 +3156,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) p->subs[index].f.frametype = AST_FRAME_CONTROL; p->subs[index].f.subclass = AST_CONTROL_ANSWER; ast_setstate(ast, AST_STATE_UP); - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return &p->subs[index].f; } @@ -3177,7 +3177,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) } } else { ast_log(LOG_WARNING, "Don't know how to read frames in format %d\n", ast->pvt->rawreadformat); - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return NULL; } readbuf = ((unsigned char *)p->subs[index].buffer) + AST_FRIENDLY_OFFSET; @@ -3189,18 +3189,18 @@ struct ast_frame *zt_read(struct ast_channel *ast) if (res == -1) { if (errno == EAGAIN) { /* Return "NULL" frame if there is nobody there */ - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return &p->subs[index].f; } else ast_log(LOG_WARNING, "zt_rec: %s\n", strerror(errno)); } - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return NULL; } if (res != (p->subs[index].linear ? READ_SIZE * 2 : READ_SIZE)) { ast_log(LOG_DEBUG, "Short read (%d/%d), must be an event...\n", res, p->subs[index].linear ? READ_SIZE * 2 : READ_SIZE); f = zt_handle_event(ast); - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return f; } if (p->tdd) { /* if in TDD mode, see if we receive that */ @@ -3219,7 +3219,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) p->subs[index].f.data = p->subs[index].buffer + AST_FRIENDLY_OFFSET; p->subs[index].f.datalen = 1; *((char *) p->subs[index].f.data) = c; - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return &p->subs[index].f; } } @@ -3354,7 +3354,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) f = &p->subs[index].f; } #endif - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return f; } @@ -3621,9 +3621,9 @@ static struct ast_channel *zt_new(struct zt_pvt *i, int state, int startpbx, int } i->subs[index].owner = tmp; ast_setstate(tmp, state); - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); strncpy(tmp->context, i->context, sizeof(tmp->context)-1); /* Copy call forward info */ @@ -4484,7 +4484,7 @@ static void *do_monitor(void *data) #endif for(;;) { /* Lock the interface list */ - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { ast_log(LOG_ERROR, "Unable to grab interface lock\n"); return NULL; } @@ -4515,7 +4515,7 @@ static void *do_monitor(void *data) i = i->next; } /* Okay, now that we know what to do, release the interface lock */ - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); pthread_testcancel(); /* Wait at least a second for something to happen */ @@ -4531,7 +4531,7 @@ static void *do_monitor(void *data) } /* Alright, lock the interface list again, and let's look and see what has happened */ - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { ast_log(LOG_WARNING, "Unable to lock the interface list\n"); continue; } @@ -4649,7 +4649,7 @@ static void *do_monitor(void *data) } i=i->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } /* Never reached */ return NULL; @@ -4664,12 +4664,12 @@ static int restart_monitor(void) /* If we're supposed to be stopped -- stay stopped */ if (monitor_thread == -2) return 0; - if (ast_pthread_mutex_lock(&monlock)) { + if (ast_mutex_lock(&monlock)) { ast_log(LOG_WARNING, "Unable to lock monitor\n"); return -1; } if (monitor_thread == pthread_self()) { - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); ast_log(LOG_WARNING, "Cannot kill myself\n"); return -1; } @@ -4685,7 +4685,7 @@ static int restart_monitor(void) } else { /* Start a new monitor */ if (pthread_create(&monitor_thread, &attr, do_monitor, NULL) < 0) { - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); ast_log(LOG_ERROR, "Unable to start monitor thread.\n"); return -1; } @@ -4693,7 +4693,7 @@ static int restart_monitor(void) #if 0 printf("Created thread %ld detached in restart monitor\n", monitor_thread); #endif - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); return 0; } @@ -5006,7 +5006,7 @@ static struct zt_pvt *mkintf(int channel, int signalling, int radio) tmp->propconfno = -1; } tmp->transfer = transfer; - ast_pthread_mutex_init(&tmp->lock); + ast_mutex_init(&tmp->lock); strncpy(tmp->language, language, sizeof(tmp->language)-1); strncpy(tmp->musicclass, musicclass, sizeof(tmp->musicclass)-1); strncpy(tmp->context, context, sizeof(tmp->context)-1); @@ -5211,7 +5211,7 @@ static struct ast_channel *zt_request(char *type, int format, void *data) channelmatch = x; } /* Search for an unowned channel */ - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { ast_log(LOG_ERROR, "Unable to lock interface list???\n"); return NULL; } @@ -5270,7 +5270,7 @@ static struct ast_channel *zt_request(char *type, int format, void *data) else p = p->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); restart_monitor(); return tmp; } @@ -5457,7 +5457,7 @@ static void *pri_dchannel(void *vpri) FD_SET(pri->fd, &rfds); FD_SET(pri->fd, &efds); time(&t); - ast_pthread_mutex_lock(&pri->lock); + ast_mutex_lock(&pri->lock); if (pri->resetting && pri->up) { if (!pri->resetchannel) pri_check_restart(pri); @@ -5561,12 +5561,12 @@ static void *pri_dchannel(void *vpri) tv.tv_sec = 60; tv.tv_usec = 0; } - pthread_mutex_unlock(&pri->lock); + ast_mutex_unlock(&pri->lock); e = NULL; res = ast_select(pri->fd + 1, &rfds, NULL, &efds, &tv); - ast_pthread_mutex_lock(&pri->lock); + ast_mutex_lock(&pri->lock); if (!res) { /* Just a timeout, run the scheduler */ e = pri_schedule_run(pri->pri); @@ -5606,21 +5606,21 @@ static void *pri_dchannel(void *vpri) if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "B-channel %d restarted on span %d\n", chan, pri->span); - ast_pthread_mutex_lock(&pri->pvt[chan]->lock); + ast_mutex_lock(&pri->pvt[chan]->lock); /* Force soft hangup if appropriate */ if (pri->pvt[chan]->owner) pri->pvt[chan]->owner->_softhangup |= AST_SOFTHANGUP_DEV; - ast_pthread_mutex_unlock(&pri->pvt[chan]->lock); + ast_mutex_unlock(&pri->pvt[chan]->lock); } } else { if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_2 "Restart on requested on entire span %d\n", pri->span); for (x=1;x <= pri->channels;x++) if ((x != pri->dchannel) && pri->pvt[x]) { - ast_pthread_mutex_lock(&pri->pvt[x]->lock); + ast_mutex_lock(&pri->pvt[x]->lock); if (pri->pvt[x]->owner) pri->pvt[x]->owner->_softhangup |= AST_SOFTHANGUP_DEV; - ast_pthread_mutex_unlock(&pri->pvt[x]->lock); + ast_mutex_unlock(&pri->pvt[x]->lock); } } break; @@ -5876,7 +5876,7 @@ static void *pri_dchannel(void *vpri) if (chan) { chan = pri_fixup(pri, chan, e->hangup.call); if (chan) { - ast_pthread_mutex_lock(&pri->pvt[chan]->lock); + ast_mutex_lock(&pri->pvt[chan]->lock); if (!pri->pvt[chan]->alreadyhungup) { /* we're calling here zt_hangup so once we get there we need to clear p->call after calling pri_hangup */ pri->pvt[chan]->alreadyhungup = 1; @@ -5894,7 +5894,7 @@ static void *pri_dchannel(void *vpri) pri_reset(pri->pri, chan); pri->pvt[chan]->resetting = 1; } - ast_pthread_mutex_unlock(&pri->pvt[chan]->lock); + ast_mutex_unlock(&pri->pvt[chan]->lock); } else { ast_log(LOG_WARNING, "Hangup on bad channel %d\n", e->hangup.channel); } @@ -5915,7 +5915,7 @@ static void *pri_dchannel(void *vpri) if (chan) { chan = pri_fixup(pri, chan, e->hangup.call); if (chan) { - ast_pthread_mutex_lock(&pri->pvt[chan]->lock); + ast_mutex_lock(&pri->pvt[chan]->lock); if (pri->pvt[chan]->owner) { pri->pvt[chan]->owner->_softhangup |= AST_SOFTHANGUP_DEV; if (option_verbose > 2) @@ -5927,7 +5927,7 @@ static void *pri_dchannel(void *vpri) pri_reset(pri->pri, chan); pri->pvt[chan]->resetting = 1; } - ast_pthread_mutex_unlock(&pri->pvt[chan]->lock); + ast_mutex_unlock(&pri->pvt[chan]->lock); } else { ast_log(LOG_WARNING, "Hangup REQ on bad channel %d\n", e->hangup.channel); } @@ -5945,14 +5945,14 @@ static void *pri_dchannel(void *vpri) if (chan) { chan = pri_fixup(pri, chan, e->hangup.call); if (chan) { - ast_pthread_mutex_lock(&pri->pvt[chan]->lock); + ast_mutex_lock(&pri->pvt[chan]->lock); pri->pvt[chan]->call = NULL; pri->pvt[chan]->resetting = 0; if (pri->pvt[chan]->owner) { if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Channel %d, span %d got hangup ACK\n", chan, pri->span); } - ast_pthread_mutex_unlock(&pri->pvt[chan]->lock); + ast_mutex_unlock(&pri->pvt[chan]->lock); } } break; @@ -5968,7 +5968,7 @@ static void *pri_dchannel(void *vpri) for (x=1;x<=pri->channels;x++) { if (pri->pvt[x] && pri->pvt[x]->resetting) { chan = x; - ast_pthread_mutex_lock(&pri->pvt[chan]->lock); + ast_mutex_lock(&pri->pvt[chan]->lock); ast_log(LOG_DEBUG, "Assuming restart ack is really for channel %d span %d\n", chan, pri->span); if (pri->pvt[chan]->owner) { ast_log(LOG_WARNING, "Got restart ack on channel %d with owner\n", chan); @@ -5977,7 +5977,7 @@ static void *pri_dchannel(void *vpri) pri->pvt[chan]->resetting = 0; if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "B-channel %d successfully restarted on span %d\n", chan, pri->span); - ast_pthread_mutex_unlock(&pri->pvt[chan]->lock); + ast_mutex_unlock(&pri->pvt[chan]->lock); if (pri->resetting) pri_check_restart(pri); break; @@ -5993,7 +5993,7 @@ static void *pri_dchannel(void *vpri) } if ((chan >= 1) && (chan <= pri->channels)) { if (pri->pvt[chan]) { - ast_pthread_mutex_lock(&pri->pvt[chan]->lock); + ast_mutex_lock(&pri->pvt[chan]->lock); if (pri->pvt[chan]->owner) { ast_log(LOG_WARNING, "Got restart ack on channel %d with owner\n", chan); pri->pvt[chan]->owner->_softhangup |= AST_SOFTHANGUP_DEV; @@ -6001,7 +6001,7 @@ static void *pri_dchannel(void *vpri) pri->pvt[chan]->resetting = 0; if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "B-channel %d successfully restarted on span %d\n", chan, pri->span); - ast_pthread_mutex_unlock(&pri->pvt[chan]->lock); + ast_mutex_unlock(&pri->pvt[chan]->lock); if (pri->resetting) pri_check_restart(pri); } @@ -6031,7 +6031,7 @@ static void *pri_dchannel(void *vpri) if (option_debug) ast_log(LOG_DEBUG, "Got event %s (%d) on D-channel for span %d\n", event2str(x), x, pri->span); } - pthread_mutex_unlock(&pri->lock); + ast_mutex_unlock(&pri->lock); } /* Never reached */ return NULL; @@ -6302,7 +6302,7 @@ static int zap_show_channels(int fd, int argc, char **argv) if (argc != 3) return RESULT_SHOWUSAGE; - ast_pthread_mutex_lock(&iflock); + ast_mutex_lock(&iflock); ast_cli(fd, FORMAT2, "Chan. Num.", "Extension", "Context", "Language", "MusicOnHold"); tmp = iflist; @@ -6310,7 +6310,7 @@ static int zap_show_channels(int fd, int argc, char **argv) ast_cli(fd, FORMAT, tmp->channel, tmp->exten, tmp->context, tmp->language, tmp->musicclass); tmp = tmp->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return RESULT_SUCCESS; #undef FORMAT #undef FORMAT2 @@ -6327,7 +6327,7 @@ static int zap_show_channel(int fd, int argc, char **argv) return RESULT_SHOWUSAGE; channel = atoi(argv[3]); - ast_pthread_mutex_lock(&iflock); + ast_mutex_lock(&iflock); tmp = iflist; while (tmp) { if (tmp->channel == channel) { @@ -6392,14 +6392,14 @@ static int zap_show_channel(int fd, int argc, char **argv) ast_cli(fd, "Actual Confmute: %s\n", x ? "Yes" : "No"); } #endif - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return RESULT_SUCCESS; } tmp = tmp->next; } ast_cli(fd, "Unable to find given channel %d\n", channel); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return RESULT_FAILURE; } @@ -6457,7 +6457,7 @@ int load_module() } - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { /* It's a little silly to lock it, but we mind as well just to be sure */ ast_log(LOG_ERROR, "Unable to lock interface list???\n"); return -1; @@ -6469,7 +6469,7 @@ int load_module() if (cur_signalling < 0) { ast_log(LOG_ERROR, "Signalling must be specified before any channels are.\n"); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); unload_module(); return -1; } @@ -6486,7 +6486,7 @@ int load_module() } else { ast_log(LOG_ERROR, "Syntax error parsing '%s' at '%s'\n", v->value, chan); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); unload_module(); return -1; } @@ -6504,7 +6504,7 @@ int load_module() } else { ast_log(LOG_ERROR, "Unable to register channel '%s'\n", v->value); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); unload_module(); return -1; } @@ -6738,7 +6738,7 @@ int load_module() else { ast_log(LOG_ERROR, "Unknown switchtype '%s'\n", v->value); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); unload_module(); return -1; } @@ -6755,7 +6755,7 @@ int load_module() ast_log(LOG_WARNING, "Ignoring %s\n", v->name); v = v->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); /* Make sure we can register our Zap channel type */ if (ast_channel_register(type, tdesc, AST_FORMAT_SLINEAR | AST_FORMAT_ULAW, zt_request)) { ast_log(LOG_ERROR, "Unable to register channel class %s\n", type); @@ -6814,7 +6814,7 @@ int unload_module() ast_cli_unregister(&cli_show_channels); ast_cli_unregister(&cli_show_channel); ast_cli_unregister(&cli_destroy_channel); - if (!ast_pthread_mutex_lock(&iflock)) { + if (!ast_mutex_lock(&iflock)) { /* Hangup all interfaces if they have an owner */ p = iflist; while(p) { @@ -6823,25 +6823,25 @@ int unload_module() p = p->next; } iflist = NULL; - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; } - if (!ast_pthread_mutex_lock(&monlock)) { + if (!ast_mutex_lock(&monlock)) { if (monitor_thread) { pthread_cancel(monitor_thread); pthread_kill(monitor_thread, SIGURG); pthread_join(monitor_thread, NULL); } monitor_thread = -2; - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; } - if (!ast_pthread_mutex_lock(&iflock)) { + if (!ast_mutex_lock(&iflock)) { /* Destroy all the interfaces and free their memory */ p = iflist; while(p) { @@ -6857,7 +6857,7 @@ int unload_module() free(pl); } iflist = NULL; - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; @@ -6937,7 +6937,7 @@ static int reload_zt(void) } - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { /* It's a little silly to lock it, but we mind as well just to be sure */ ast_log(LOG_ERROR, "Unable to lock interface list???\n"); return -1; @@ -6959,7 +6959,7 @@ static int reload_zt(void) if (cur_signalling < 0) { ast_log(LOG_ERROR, "Signalling must be specified before any channels are.\n"); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return -1; } stringp=v->value; @@ -6973,7 +6973,7 @@ static int reload_zt(void) } else { ast_log(LOG_ERROR, "Syntax error parsing '%s' at '%s'\n", v->value, chan); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return -1; } if (finish < start) { @@ -6990,7 +6990,7 @@ static int reload_zt(void) } else { ast_log(LOG_ERROR, "Unable to register channel '%s'\n", v->value); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return -1; } } @@ -7094,7 +7094,7 @@ static int reload_zt(void) else { ast_log(LOG_ERROR, "Unknown switchtype '%s'\n", v->value); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return -1; } } else if (!strcasecmp(v->name, "minunused")) { @@ -7116,7 +7116,7 @@ static int reload_zt(void) if (tmp->destroy) { if (destroy_channel(prev, tmp, 0)) { ast_log(LOG_ERROR, "Unable to destroy chan_zap channel %d\n", tmp->channel); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return -1; } tmp = tmp->next; @@ -7126,7 +7126,7 @@ static int reload_zt(void) } } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); ast_destroy(cfg); #if 0 @@ -7270,9 +7270,9 @@ int reload(void) int usecount() { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } diff --git a/channels/chan_zap_old.c b/channels/chan_zap_old.c index 79324cadf..c81b6e5c6 100755 --- a/channels/chan_zap_old.c +++ b/channels/chan_zap_old.c @@ -188,14 +188,14 @@ static int gendigittimeout = 8000; static int matchdigittimeout = 3000; static int usecnt =0; -static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; +static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; /* Protect the interface list (of zt_pvt's) */ -static pthread_mutex_t iflock = AST_MUTEX_INITIALIZER; +static ast_mutex_t iflock = AST_MUTEX_INITIALIZER; /* Protect the monitoring thread, so only one process can kill or start it, and not when it's doing something critical. */ -static pthread_mutex_t monlock = AST_MUTEX_INITIALIZER; +static ast_mutex_t monlock = AST_MUTEX_INITIALIZER; /* This is the thread for the monitor which checks for input on the channels which are not currently in use. */ @@ -245,7 +245,7 @@ static int r2prot = -1; #ifdef ZAPATA_PRI struct zt_pri { pthread_t master; /* Thread of master */ - pthread_mutex_t lock; /* Mutex */ + ast_mutex_t lock; /* Mutex */ char idleext[AST_MAX_EXTENSION]; /* Where to idle extra calls */ char idlecontext[AST_MAX_EXTENSION]; /* What context to use for idle */ char idledial[AST_MAX_EXTENSION]; /* What to dial before dumping */ @@ -285,7 +285,7 @@ static inline int pri_grab(struct zt_pri *pri) { int res; /* Grab the lock first */ - res = ast_pthread_mutex_lock(&pri->lock); + res = ast_mutex_lock(&pri->lock); if (res) return res; /* Then break the select */ @@ -295,7 +295,7 @@ static inline int pri_grab(struct zt_pri *pri) static inline void pri_rel(struct zt_pri *pri) { - ast_pthread_mutex_unlock(&pri->lock); + ast_mutex_unlock(&pri->lock); } static int switchtype = PRI_SWITCH_NI2; @@ -334,7 +334,7 @@ struct zt_subchannel { #define MAX_SLAVES 4 static struct zt_pvt { - pthread_mutex_t lock; + ast_mutex_t lock; struct ast_channel *owner; /* Our current active owner (if applicable) */ /* Up to three channels can be associated with this call */ @@ -1502,16 +1502,16 @@ static int zt_hangup(struct ast_channel *ast) p->callwaitingrepeat = 0; ast->pvt->pvt = NULL; ast_setstate(ast, AST_STATE_DOWN); - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt--; if (usecnt < 0) ast_log(LOG_WARNING, "Usecnt < 0???\n"); - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); if (option_verbose > 2) ast_verbose( VERBOSE_PREFIX_3 "Hungup '%s'\n", ast->name); - ast_pthread_mutex_lock(&iflock); + ast_mutex_lock(&iflock); tmp = iflist; prev = NULL; if (p->destroy) { @@ -1525,7 +1525,7 @@ static int zt_hangup(struct ast_channel *ast) } } } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return 0; } @@ -1809,8 +1809,8 @@ static int zt_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, /* cant do pseudo-channels here */ if ((!p0->sig) || (!p1->sig)) return -2; - ast_pthread_mutex_lock(&c0->lock); - ast_pthread_mutex_lock(&c1->lock); + ast_mutex_lock(&c0->lock); + ast_mutex_lock(&c1->lock); op0 = p0 = c0->pvt->pvt; op1 = p1 = c1->pvt->pvt; ofd1 = c0->fds[0]; @@ -1824,12 +1824,12 @@ static int zt_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, - ast_pthread_mutex_lock(&p0->lock); - if (pthread_mutex_trylock(&p1->lock)) { + ast_mutex_lock(&p0->lock); + if (ast_mutex_trylock(&p1->lock)) { /* Don't block, due to potential for deadlock */ - ast_pthread_mutex_unlock(&p0->lock); - ast_pthread_mutex_unlock(&c0->lock); - ast_pthread_mutex_unlock(&c1->lock); + ast_mutex_unlock(&p0->lock); + ast_mutex_unlock(&c0->lock); + ast_mutex_unlock(&c1->lock); ast_log(LOG_NOTICE, "Avoiding deadlock...\n"); return -3; } @@ -1923,11 +1923,11 @@ static int zt_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, t1 = p0->subs[SUB_REAL].inthreeway; t2 = p1->subs[SUB_REAL].inthreeway; - ast_pthread_mutex_unlock(&p0->lock); - ast_pthread_mutex_unlock(&p1->lock); + ast_mutex_unlock(&p0->lock); + ast_mutex_unlock(&p1->lock); - ast_pthread_mutex_unlock(&c0->lock); - ast_pthread_mutex_unlock(&c1->lock); + ast_mutex_unlock(&c0->lock); + ast_mutex_unlock(&c1->lock); /* Native bridge failed */ if ((!master || !slave) && !nothingok) @@ -1939,16 +1939,16 @@ static int zt_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, for (;;) { /* Here's our main loop... Start by locking things, looking for private parts, and then balking if anything is wrong */ - ast_pthread_mutex_lock(&c0->lock); - ast_pthread_mutex_lock(&c1->lock); + ast_mutex_lock(&c0->lock); + ast_mutex_lock(&c1->lock); p0 = c0->pvt->pvt; p1 = c1->pvt->pvt; if (op0 == p0) i1 = zt_get_index(c0, p0, 1); if (op1 == p1) i2 = zt_get_index(c1, p1, 1); - ast_pthread_mutex_unlock(&c0->lock); - ast_pthread_mutex_unlock(&c1->lock); + ast_mutex_unlock(&c0->lock); + ast_mutex_unlock(&c1->lock); if ((op0 != p0) || (op1 != p1) || (ofd1 != c0->fds[0]) || (ofd2 != c1->fds[0]) || @@ -2709,7 +2709,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) struct ast_frame *f; - ast_pthread_mutex_lock(&p->lock); + ast_mutex_lock(&p->lock); index = zt_get_index(ast, p, 0); @@ -2725,7 +2725,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) /* Hang up if we don't really exist */ if (index < 0) { ast_log(LOG_WARNING, "We dont exist?\n"); - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return NULL; } @@ -2747,11 +2747,11 @@ struct ast_frame *zt_read(struct ast_channel *ast) { p->subs[index].f.subclass = AST_CONTROL_RADIO_UNKEY; } - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return &p->subs[index].f; } if (p->ringt == 1) { - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return NULL; } else if (p->ringt > 0) @@ -2763,7 +2763,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) p->subs[index].f.frametype = AST_FRAME_CONTROL; p->subs[index].f.subclass = AST_CONTROL_RINGING; ast_setstate(ast, AST_STATE_RINGING); - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return &p->subs[index].f; } @@ -2778,7 +2778,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) p->subs[index].f.frametype = AST_FRAME_CONTROL; p->subs[index].f.subclass = AST_CONTROL_ANSWER; ast_setstate(ast, AST_STATE_UP); - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return &p->subs[index].f; } @@ -2822,7 +2822,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) p->subs[index].f.subclass = AST_CONTROL_ANSWER; ast_setstate(ast, AST_STATE_UP); } - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return &p->subs[index].f; } @@ -2843,7 +2843,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) } } else { ast_log(LOG_WARNING, "Don't know how to read frames in format %d\n", ast->pvt->rawreadformat); - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return NULL; } readbuf = ((unsigned char *)p->subs[index].buffer) + AST_FRIENDLY_OFFSET; @@ -2854,7 +2854,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) if (res < 0) { if (res == -1) ast_log(LOG_WARNING, "zt_rec: %s\n", strerror(errno)); - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return NULL; } if (res != READ_SIZE) { @@ -2884,7 +2884,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) } p->callwaitcas = 0; /* Return NULL */ - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return &p->subs[index].f; } else { strncpy(p->subs[index].dtmfq + strlen(p->subs[index].dtmfq), zap_dtmfbuf(p->subs[index].z), sizeof(p->subs[index].dtmfq) - strlen(p->subs[index].dtmfq)-1); @@ -2892,7 +2892,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) } } } else { - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return zt_handle_event(ast); } if (strlen(p->subs[index].dtmfq)) { @@ -2916,12 +2916,12 @@ struct ast_frame *zt_read(struct ast_channel *ast) ast_log(LOG_DEBUG, "Fax already handled\n"); p->subs[index].f.frametype = AST_FRAME_NULL; p->subs[index].f.subclass = 0; - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return &p->subs[index].f; } p->subs[index].f.frametype = AST_FRAME_DTMF; } - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return &p->subs[index].f; } if (p->tdd) { /* if in TDD mode, see if we receive that */ @@ -2940,7 +2940,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) p->subs[index].f.data = p->subs[index].buffer + AST_FRIENDLY_OFFSET; p->subs[index].f.datalen = 1; *((char *) p->subs[index].f.data) = c; - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return &p->subs[index].f; } } @@ -2998,7 +2998,7 @@ struct ast_frame *zt_read(struct ast_channel *ast) } } else f = &p->subs[index].f; - pthread_mutex_unlock(&p->lock); + ast_mutex_unlock(&p->lock); return f; } @@ -3240,9 +3240,9 @@ static struct ast_channel *zt_new(struct zt_pvt *i, int state, int startpbx, int } i->subs[index].owner = tmp; ast_setstate(tmp, state); - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); usecnt++; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); ast_update_use_count(); strncpy(tmp->context, i->context, sizeof(tmp->context)-1); /* Copy call forward info */ @@ -4018,7 +4018,7 @@ static void *do_monitor(void *data) #endif for(;;) { /* Lock the interface list */ - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { ast_log(LOG_ERROR, "Unable to grab interface lock\n"); return NULL; } @@ -4049,7 +4049,7 @@ static void *do_monitor(void *data) i = i->next; } /* Okay, now that we know what to do, release the interface lock */ - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); pthread_testcancel(); /* Wait at least a second for something to happen */ @@ -4065,7 +4065,7 @@ static void *do_monitor(void *data) } /* Alright, lock the interface list again, and let's look and see what has happened */ - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { ast_log(LOG_WARNING, "Unable to lock the interface list\n"); continue; } @@ -4183,7 +4183,7 @@ static void *do_monitor(void *data) } i=i->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } /* Never reached */ return NULL; @@ -4198,12 +4198,12 @@ static int restart_monitor(void) /* If we're supposed to be stopped -- stay stopped */ if (monitor_thread == -2) return 0; - if (ast_pthread_mutex_lock(&monlock)) { + if (ast_mutex_lock(&monlock)) { ast_log(LOG_WARNING, "Unable to lock monitor\n"); return -1; } if (monitor_thread == pthread_self()) { - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); ast_log(LOG_WARNING, "Cannot kill myself\n"); return -1; } @@ -4219,7 +4219,7 @@ static int restart_monitor(void) } else { /* Start a new monitor */ if (pthread_create(&monitor_thread, &attr, do_monitor, NULL) < 0) { - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); ast_log(LOG_ERROR, "Unable to start monitor thread.\n"); return -1; } @@ -4227,7 +4227,7 @@ static int restart_monitor(void) #if 0 printf("Created thread %ld detached in restart monitor\n", monitor_thread); #endif - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); return 0; } @@ -4729,7 +4729,7 @@ static struct ast_channel *zt_request(char *type, int format, void *data) channelmatch = x; } /* Search for an unowned channel */ - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { ast_log(LOG_ERROR, "Unable to lock interface list???\n"); return NULL; } @@ -4788,7 +4788,7 @@ static struct ast_channel *zt_request(char *type, int format, void *data) } p = p->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); restart_monitor(); return tmp; } @@ -4992,7 +4992,7 @@ static void *pri_dchannel(void *vpri) FD_SET(pri->fd, &rfds); FD_SET(pri->fd, &efds); time(&t); - ast_pthread_mutex_lock(&pri->lock); + ast_mutex_lock(&pri->lock); if (pri->resetting && pri->up) { /* Look for a resetable channel and go */ if ((t - pri->lastreset) > 0) { @@ -5111,12 +5111,12 @@ static void *pri_dchannel(void *vpri) tv.tv_sec = 60; tv.tv_usec = 0; } - pthread_mutex_unlock(&pri->lock); + ast_mutex_unlock(&pri->lock); e = NULL; res = ast_select(pri->fd + 1, &rfds, NULL, &efds, &tv); - ast_pthread_mutex_lock(&pri->lock); + ast_mutex_lock(&pri->lock); if (!res) { /* Just a timeout, run the scheduler */ e = pri_schedule_run(pri->pri); @@ -5421,7 +5421,7 @@ static void *pri_dchannel(void *vpri) if (option_debug) ast_log(LOG_DEBUG, "Got event %s (%d) on D-channel for span %d\n", event2str(x), x, pri->span); } - pthread_mutex_unlock(&pri->lock); + ast_mutex_unlock(&pri->lock); } /* Never reached */ return NULL; @@ -5690,7 +5690,7 @@ static int zap_show_channels(int fd, int argc, char **argv) if (argc != 3) return RESULT_SHOWUSAGE; - ast_pthread_mutex_lock(&iflock); + ast_mutex_lock(&iflock); ast_cli(fd, FORMAT2, "Chan. Num.", "Extension", "Context", "Language", "MusicOnHold"); tmp = iflist; @@ -5698,7 +5698,7 @@ static int zap_show_channels(int fd, int argc, char **argv) ast_cli(fd, FORMAT, tmp->channel, tmp->exten, tmp->context, tmp->language, tmp->musicclass); tmp = tmp->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return RESULT_SUCCESS; #undef FORMAT #undef FORMAT2 @@ -5714,7 +5714,7 @@ static int zap_show_channel(int fd, int argc, char **argv) return RESULT_SHOWUSAGE; channel = atoi(argv[3]); - ast_pthread_mutex_lock(&iflock); + ast_mutex_lock(&iflock); tmp = iflist; while (tmp) { if (tmp->channel == channel) { @@ -5764,14 +5764,14 @@ static int zap_show_channel(int fd, int argc, char **argv) ast_cli(fd, "\n"); } #endif - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return RESULT_SUCCESS; } tmp = tmp->next; } ast_cli(fd, "Unable to find given channel %d\n", channel); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return RESULT_FAILURE; } @@ -5829,7 +5829,7 @@ int load_module() } - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { /* It's a little silly to lock it, but we mind as well just to be sure */ ast_log(LOG_ERROR, "Unable to lock interface list???\n"); return -1; @@ -5841,7 +5841,7 @@ int load_module() if (cur_signalling < 0) { ast_log(LOG_ERROR, "Signalling must be specified before any channels are.\n"); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); unload_module(); return -1; } @@ -5858,7 +5858,7 @@ int load_module() } else { ast_log(LOG_ERROR, "Syntax error parsing '%s' at '%s'\n", v->value, chan); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); unload_module(); return -1; } @@ -5876,7 +5876,7 @@ int load_module() } else { ast_log(LOG_ERROR, "Unable to register channel '%s'\n", v->value); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); unload_module(); return -1; } @@ -6066,7 +6066,7 @@ int load_module() else { ast_log(LOG_ERROR, "Unknown switchtype '%s'\n", v->value); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); unload_module(); return -1; } @@ -6081,7 +6081,7 @@ int load_module() ast_log(LOG_DEBUG, "Ignoring %s\n", v->name); v = v->next; } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); /* Make sure we can register our Zap channel type */ if (ast_channel_register(type, tdesc, AST_FORMAT_SLINEAR | AST_FORMAT_ULAW, zt_request)) { ast_log(LOG_ERROR, "Unable to register channel class %s\n", type); @@ -6140,7 +6140,7 @@ int unload_module() ast_cli_unregister(&cli_show_channels); ast_cli_unregister(&cli_show_channel); ast_cli_unregister(&cli_destroy_channel); - if (!ast_pthread_mutex_lock(&iflock)) { + if (!ast_mutex_lock(&iflock)) { /* Hangup all interfaces if they have an owner */ p = iflist; while(p) { @@ -6149,25 +6149,25 @@ int unload_module() p = p->next; } iflist = NULL; - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; } - if (!ast_pthread_mutex_lock(&monlock)) { + if (!ast_mutex_lock(&monlock)) { if (monitor_thread) { pthread_cancel(monitor_thread); pthread_kill(monitor_thread, SIGURG); pthread_join(monitor_thread, NULL); } monitor_thread = -2; - ast_pthread_mutex_unlock(&monlock); + ast_mutex_unlock(&monlock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; } - if (!ast_pthread_mutex_lock(&iflock)) { + if (!ast_mutex_lock(&iflock)) { /* Destroy all the interfaces and free their memory */ p = iflist; while(p) { @@ -6183,7 +6183,7 @@ int unload_module() free(pl); } iflist = NULL; - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); } else { ast_log(LOG_WARNING, "Unable to lock the monitor\n"); return -1; @@ -6262,7 +6262,7 @@ static int reload_zt(void) } - if (ast_pthread_mutex_lock(&iflock)) { + if (ast_mutex_lock(&iflock)) { /* It's a little silly to lock it, but we mind as well just to be sure */ ast_log(LOG_ERROR, "Unable to lock interface list???\n"); return -1; @@ -6284,7 +6284,7 @@ static int reload_zt(void) if (cur_signalling < 0) { ast_log(LOG_ERROR, "Signalling must be specified before any channels are.\n"); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return -1; } stringp=v->value; @@ -6298,7 +6298,7 @@ static int reload_zt(void) } else { ast_log(LOG_ERROR, "Syntax error parsing '%s' at '%s'\n", v->value, chan); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return -1; } if (finish < start) { @@ -6315,7 +6315,7 @@ static int reload_zt(void) } else { ast_log(LOG_ERROR, "Unable to register channel '%s'\n", v->value); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return -1; } } @@ -6417,7 +6417,7 @@ static int reload_zt(void) else { ast_log(LOG_ERROR, "Unknown switchtype '%s'\n", v->value); ast_destroy(cfg); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return -1; } } else if (!strcasecmp(v->name, "minunused")) { @@ -6439,7 +6439,7 @@ static int reload_zt(void) if (tmp->destroy) { if (destroy_channel(prev, tmp, 0)) { ast_log(LOG_ERROR, "Unable to destroy chan_zap channel %d\n", tmp->channel); - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); return -1; } tmp = tmp->next; @@ -6449,7 +6449,7 @@ static int reload_zt(void) } } - ast_pthread_mutex_unlock(&iflock); + ast_mutex_unlock(&iflock); ast_destroy(cfg); #if 0 @@ -6593,9 +6593,9 @@ int reload(void) int usecount() { int res; - ast_pthread_mutex_lock(&usecnt_lock); + ast_mutex_lock(&usecnt_lock); res = usecnt; - ast_pthread_mutex_unlock(&usecnt_lock); + ast_mutex_unlock(&usecnt_lock); return res; } -- cgit v1.2.3