/*! \note Returns the channel in the chanspy_ds locked as well as the chanspy_ds locked */
static struct chanspy_ds *setup_chanspy_ds(struct ast_channel *chan, struct chanspy_ds *chanspy_ds)
{
struct ast_datastore *datastore = NULL;
ast_mutex_lock(&chanspy_ds->lock);
if (!(datastore = ast_channel_datastore_alloc(&chanspy_ds_info, chanspy_ds->unique_id))) {
ast_mutex_unlock(&chanspy_ds->lock);
chanspy_ds = chanspy_ds_free(chanspy_ds);
ast_channel_unlock(chan);
return NULL;
}
chanspy_ds->chan = chan;
datastore->data = chanspy_ds;
ast_channel_datastore_add(chan, datastore);
return chanspy_ds;
}
int initSubContext (OOCTXT* pctxt, OOCTXT* psrc)
{
/* ast_mutex_lock(&pctxt->pLock); */
int stat = ASN_OK;
ast_mutex_lock(&psrc->pLock);
memset (pctxt, 0, sizeof(OOCTXT));
pctxt->pTypeMemHeap = psrc->pTypeMemHeap;
memHeapAddRef (&pctxt->pTypeMemHeap);
pctxt->pMsgMemHeap = psrc->pMsgMemHeap;
memHeapAddRef (&pctxt->pMsgMemHeap);
pctxt->flags = psrc->flags;
pctxt->buffer.dynamic = TRUE;
pctxt->buffer.byteIndex = 0;
pctxt->buffer.bitOffset = 8;
ast_mutex_unlock(&psrc->pLock);
/* ast_mutex_unlock(&pctxt->pLock); */
return stat;
}
static void *__ast_alloc_region(size_t size, const enum func_type which, const char *file, int lineno, const char *func, unsigned int cache)
{
struct ast_region *reg;
unsigned int *fence;
int hash;
if (!(reg = malloc(size + sizeof(*reg) + sizeof(*fence)))) {
astmm_log("Memory Allocation Failure - '%d' bytes at %s %s() line %d\n",
(int) size, file, func, lineno);
return NULL;
}
reg->len = size;
reg->cache = cache;
reg->lineno = lineno;
reg->which = which;
reg->bt = backtrace_enabled ? ast_bt_create() : NULL;
ast_copy_string(reg->file, file, sizeof(reg->file));
ast_copy_string(reg->func, func, sizeof(reg->func));
/*
* Init lower fence.
*
* We use the bytes just preceeding reg->data and not reg->fence
* because there is likely to be padding between reg->fence and
* reg->data for reg->data alignment.
*/
fence = (unsigned int *) (reg->data - sizeof(*fence));
*fence = FENCE_MAGIC;
/* Init higher fence. */
fence = (unsigned int *) (reg->data + reg->len);
put_unaligned_uint32(fence, FENCE_MAGIC);
hash = HASH(reg->data);
ast_mutex_lock(®lock);
AST_LIST_NEXT(reg, node) = regions[hash];
regions[hash] = reg;
ast_mutex_unlock(®lock);
return reg->data;
}
static int pickdown_channel(struct ast_channel *chan, void *pattern)
{
int ret = 0;
struct ast_module_user *u;
struct ast_channel *cur;
u = ast_module_user_add(chan);
cur = find_matching_channel(chan, pattern, AST_STATE_RINGING);
if (cur) {
ast_verbose(VERBOSE_PREFIX_3
"Channel %s hung up ringing channel %s\n",
chan->name, cur->name);
pbx_builtin_setvar_helper(chan, "PICKDOWN_CHANNEL", cur->name);
ast_softhangup_nolock(cur, AST_SOFTHANGUP_DEV);
ast_mutex_unlock(&cur->lock);
} else {
pbx_builtin_setvar_helper(chan, "PICKDOWN_CHANNEL", "");
}
ast_module_user_remove(u);
return(ret);
}
long ast_sched_when(struct sched_context *con,int id)
{
struct sched *s;
long secs;
DEBUG(ast_log(LOG_DEBUG, "ast_sched_when()\n"));
ast_mutex_lock(&con->lock);
s=con->schedq;
while (s!=NULL) {
if (s->id==id) break;
s=s->next;
}
secs=-1;
if (s!=NULL) {
struct timeval now = ast_tvnow();
secs=s->when.tv_sec-now.tv_sec;
}
ast_mutex_unlock(&con->lock);
return secs;
}
void ast_image_unregister(struct ast_imager *img)
{
struct ast_imager *i, *prev = NULL;
ast_mutex_lock(&listlock);
i = list;
while(i) {
if (i == img) {
if (prev)
prev->next = i->next;
else
list = i->next;
break;
}
prev = i;
i = i->next;
}
ast_mutex_unlock(&listlock);
if (i && (option_verbose > 1))
ast_verbose(VERBOSE_PREFIX_2 "Unregistered format '%s' (%s)\n", img->name, img->desc);
}
int ast_sched_wait(struct sched_context *con)
{
/*
* Return the number of milliseconds
* until the next scheduled event
*/
int ms;
DEBUG(ast_log(LOG_DEBUG, "ast_sched_wait()\n"));
ast_mutex_lock(&con->lock);
if (!con->schedq) {
ms = -1;
} else {
ms = ast_tvdiff_ms(con->schedq->when, ast_tvnow());
if (ms < 0)
ms = 0;
}
ast_mutex_unlock(&con->lock);
return ms;
}
/*! \brief Helper function to not deadlock when queueing the hangup frame */
static void bridge_queue_hangup(struct bridge_pvt *p, struct ast_channel *us)
{
struct ast_channel *other = (p->input == us ? p->output : p->input);
while (other && ast_channel_trylock(other)) {
ast_mutex_unlock(&p->lock);
do {
CHANNEL_DEADLOCK_AVOIDANCE(us);
} while (ast_mutex_trylock(&p->lock));
other = (p->input == us ? p->output : p->input);
}
/* We basically queue the frame up on the other channel if present */
if (other) {
ast_queue_hangup(other);
ast_channel_unlock(other);
}
return;
}
int ooGenerateOutgoingCallToken (char *callToken, size_t size)
{
char aCallToken[200];
int ret = 0;
ast_mutex_lock(&newCallLock);
sprintf (aCallToken, "ooh323c_o_%d", counter++);
if (counter > OO_MAX_CALL_TOKEN)
counter = 1;
ast_mutex_unlock(&newCallLock);
if ((strlen(aCallToken)+1) < size)
strcpy (callToken, aCallToken);
else {
ret = OO_FAILED;
}
return ret;
}
int astdb_init(void)
{
ast_cond_init(&dbcond, NULL);
if (ast_pthread_create_background(&syncthread, NULL, db_sync_thread, NULL)) {
return -1;
}
ast_mutex_lock(&dblock);
/* Ignore check_return warning from Coverity for dbinit below */
dbinit();
ast_mutex_unlock(&dblock);
ast_cli_register_multiple(cli_database, ARRAY_LEN(cli_database));
ast_manager_register_xml("DBGet", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_dbget);
ast_manager_register_xml("DBPut", EVENT_FLAG_SYSTEM, manager_dbput);
ast_manager_register_xml("DBDel", EVENT_FLAG_SYSTEM, manager_dbdel);
ast_manager_register_xml("DBDelTree", EVENT_FLAG_SYSTEM, manager_dbdeltree);
ast_register_atexit(astdb_shutdown);
return 0;
}
int ooAddCallToList(OOH323CallData *call)
{
ast_mutex_lock(&callListLock);
if(!gH323ep.callList)
{
gH323ep.callList = call;
call->next = NULL;
call->prev = NULL;
}
else{
call->next = gH323ep.callList;
call->prev = NULL;
gH323ep.callList->prev = call;
gH323ep.callList = call;
}
ast_mutex_unlock(&callListLock);
return OO_OK;
}
static int
sccp_show_devices(int fd, int argc, char * argv[])
{
sccp_device_t * d;
ast_cli(fd, "NAME ADDRESS MAC \n");
ast_cli(fd, "================ =============== ================\n");
ast_mutex_lock(&devicelock);
d = devices;
while(d) {
ast_cli(fd, "%-16s %-15s %-16s\n",// %-10s %-16s %c%c %-10s\n",
d->description,
(d->session) ? d->session->in_addr : "--",
d->id
);
d = d->next;
}
ast_mutex_unlock(&devicelock);
return RESULT_SUCCESS;
}
static struct ast_filestream *gsm_rewrite(FILE *f, const char *comment)
{
/* We don't have any header to read or anything really, but
if we did, it would go here. We also might want to check
and be sure it's a valid file. */
struct ast_filestream *tmp;
if ((tmp = malloc(sizeof(struct ast_filestream)))) {
memset(tmp, 0, sizeof(struct ast_filestream));
if (ast_mutex_lock(&gsm_lock)) {
ast_log(LOG_WARNING, "Unable to lock gsm list\n");
free(tmp);
return NULL;
}
tmp->f = f;
glistcnt++;
ast_mutex_unlock(&gsm_lock);
ast_update_use_count();
} else
ast_log(LOG_WARNING, "Out of memory\n");
return tmp;
}
/*--- ast_enum_init: Initialize the ENUM support subsystem */
int ast_enum_init(void)
{
struct ast_config *cfg;
struct enum_search *s, *sl;
struct ast_variable *v;
/* Destroy existing list */
ast_mutex_lock(&enumlock);
s = toplevs;
while(s) {
sl = s;
s = s->next;
free(sl);
}
toplevs = NULL;
cfg = ast_config_load("enum.conf");
if (cfg) {
sl = NULL;
v = ast_variable_browse(cfg, "general");
while(v) {
if (!strcasecmp(v->name, "search")) {
s = enum_newtoplev(v->value);
if (s) {
if (sl)
sl->next = s;
else
toplevs = s;
sl = s;
}
}
v = v->next;
}
ast_config_destroy(cfg);
} else {
toplevs = enum_newtoplev(TOPLEV);
}
enumver++;
ast_mutex_unlock(&enumlock);
return 0;
}
static int pthread_timer_open(void)
{
struct pthread_timer *timer;
int fd;
int i;
if (!(timer = ao2_alloc(sizeof(*timer), pthread_timer_destructor))) {
errno = ENOMEM;
return -1;
}
timer->pipe[PIPE_READ] = timer->pipe[PIPE_WRITE] = -1;
timer->state = TIMER_STATE_IDLE;
if (pipe(timer->pipe)) {
ao2_ref(timer, -1);
return -1;
}
for (i = 0; i < ARRAY_LEN(timer->pipe); ++i) {
int flags = fcntl(timer->pipe[i], F_GETFL);
flags |= O_NONBLOCK;
fcntl(timer->pipe[i], F_SETFL, flags);
}
ao2_lock(pthread_timers);
if (!ao2_container_count(pthread_timers)) {
ast_mutex_lock(&timing_thread.lock);
ast_cond_signal(&timing_thread.cond);
ast_mutex_unlock(&timing_thread.lock);
}
ao2_link(pthread_timers, timer);
ao2_unlock(pthread_timers);
fd = timer->pipe[PIPE_READ];
ao2_ref(timer, -1);
return fd;
}
static int odbc_log(struct ast_cdr *cdr)
{
int res = 0;
char timestr[150];
ast_mutex_lock(&odbc_lock);
build_query(cdr, timestr, sizeof(timestr));
if (connected) {
res = odbc_do_query();
if (res < 0) {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Reconnecting to dsn %s\n", dsn);
odbc_disconnect();
res = odbc_init();
if (res < 0) {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: %s has gone away!\n", dsn);
odbc_disconnect();
} else {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Trying Query again!\n");
SQLFreeHandle(SQL_HANDLE_STMT, ODBC_stmt);
build_query(cdr, timestr, sizeof(timestr)); /* what a waste. If we have to reconnect, we have to build a new query */
res = odbc_do_query();
if (res < 0) {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Query FAILED Call not logged!\n");
}
}
}
} else {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Query FAILED Call not logged!\n");
}
SQLFreeHandle(SQL_HANDLE_STMT, ODBC_stmt);
ast_mutex_unlock(&odbc_lock);
return 0;
}
static int odbc_unload_module(void)
{
ast_mutex_lock(&odbc_lock);
if (connected) {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Disconnecting from %s\n", dsn);
SQLFreeHandle(SQL_HANDLE_STMT, ODBC_stmt);
SQLDisconnect(ODBC_con);
SQLFreeHandle(SQL_HANDLE_DBC, ODBC_con);
SQLFreeHandle(SQL_HANDLE_ENV, ODBC_env);
connected = 0;
}
if (dsn && dsn_alloc) {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: free dsn\n");
free(dsn);
dsn = NULL;
dsn_alloc = 0;
}
if (username && username_alloc) {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: free username\n");
free(username);
username = NULL;
username_alloc = 0;
}
if (password && password_alloc) {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: free password\n");
free(password);
password = NULL;
password_alloc = 0;
}
loguniqueid = 0;
ast_cdr_unregister(name);
ast_mutex_unlock(&odbc_lock);
return 0;
}
int ast_sched_del(struct sched_context *con, int id)
{
/*
* Delete the schedule entry with number
* "id". It's nearly impossible that there
* would be two or more in the list with that
* id.
*/
struct sched *last=NULL, *s;
DEBUG(ast_log(LOG_DEBUG, "ast_sched_del()\n"));
ast_mutex_lock(&con->lock);
s = con->schedq;
while(s) {
if (s->id == id) {
if (last)
last->next = s->next;
else
con->schedq = s->next;
con->schedcnt--;
sched_release(con, s);
break;
}
last = s;
s = s->next;
}
#ifdef DUMP_SCHEDULER
/* Dump contents of the context while we have the lock so nothing gets screwed up by accident. */
ast_sched_dump(con);
#endif
ast_mutex_unlock(&con->lock);
if (!s) {
ast_log(LOG_NOTICE, "Attempted to delete nonexistent schedule entry %d!\n", id);
#ifdef DO_CRASH
CRASH;
#endif
return -1;
} else
return 0;
}
// process outgoing frames for the channel, playing either normal conference audio,
// or requested sounds
static int process_outgoing( struct ast_conf_member *member, int samples )
{
int res;
struct ast_frame *cf = NULL;
ast_mutex_lock(&member->lock);
cf=get_outgoing_frame( member->conf, member, samples ) ;
ast_mutex_unlock(&member->lock);
/*
ast_log(LOG_WARNING,
"OURGen: samples %d - conf %s - speak: %d - format: %d\n",
samples, member->chan->name, member->is_speaking , cf->frametype
);
*/
// if there's no frames exit the loop.
if( cf == NULL ) {
ast_log( LOG_ERROR, "Nothing to write to the conference, channel => %s\n", member->channel_name ) ;
return 0;
}
// send the voice frame
res = ast_write( member->chan, cf );
if ( ( res != 0) )
{
// log 'dropped' outgoing frame
ast_log( LOG_ERROR, "unable to write voice frame to channel, channel => %s, samples %d \n", member->channel_name, samples ) ;
}
// clean up frame
ast_frfree(cf);
return 0;
}
static int unload_module(void)
{
/* Aquire control before doing anything to the module itself. */
ast_mutex_lock(&pgsql_lock);
if (pgsqlConn) {
PQfinish(pgsqlConn);
pgsqlConn = NULL;
};
ast_cli_unregister_multiple(cli_realtime, sizeof(cli_realtime) / sizeof(struct ast_cli_entry));
ast_config_engine_deregister(&pgsql_engine);
if (option_verbose) {
ast_verbose("Postgresql RealTime unloaded.\n");
}
ast_module_user_hangup_all();
/* Unlock so something else can destroy the lock. */
ast_mutex_unlock(&pgsql_lock);
return 0;
}
static int show_keys(int fd, int argc, char *argv[])
{
struct ast_key *key;
char sum[16 * 2 + 1];
int count_keys = 0;
ast_mutex_lock(&keylock);
key = keys;
ast_cli(fd, "%-18s %-8s %-16s %-33s\n", "Key Name", "Type", "Status", "Sum");
while(key) {
md52sum(sum, key->digest);
ast_cli(fd, "%-18s %-8s %-16s %-33s\n", key->name,
(key->ktype & 0xf) == AST_KEY_PUBLIC ? "PUBLIC" : "PRIVATE",
key->ktype & KEY_NEEDS_PASSCODE ? "[Needs Passcode]" : "[Loaded]", sum);
key = key->next;
count_keys++;
}
ast_mutex_unlock(&keylock);
ast_cli(fd, "%d known RSA keys.\n", count_keys);
return RESULT_SUCCESS;
}
static void conf_play(struct ast_conference *conf, int sound)
{
unsigned char *data;
int len;
ast_mutex_lock(&conflock);
switch(sound) {
case ENTER:
data = enter;
len = sizeof(enter);
break;
case LEAVE:
data = leave;
len = sizeof(leave);
break;
default:
data = NULL;
len = 0;
}
if (data)
careful_write(conf->fd, data, len);
ast_mutex_unlock(&conflock);
}
/*!
* \internal
* \brief Delay freeing a region block.
*
* \param freed Already freed region blocks storage.
* \param reg Region block to be freed.
*
* \return Nothing
*/
static void region_free(struct ast_freed_regions *freed, struct ast_region *reg)
{
struct ast_region *old;
region_data_wipe(reg);
ast_mutex_lock(®lock);
old = freed->regions[freed->index];
freed->regions[freed->index] = reg;
++freed->index;
if (ARRAY_LEN(freed->regions) <= freed->index) {
freed->index = 0;
}
ast_mutex_unlock(®lock);
if (old) {
region_data_check(old);
old->bt = ast_bt_destroy(old->bt);
free(old);
}
}
static int load_config(int reload)
{
struct ast_config *cfg;
struct ast_variable *var;
int res = -1;
strcpy(format, "");
strcpy(master, "");
ast_mutex_lock(&lock);
if((cfg = ast_config_load("cdr_custom.conf"))) {
var = ast_variable_browse(cfg, "mappings");
while(var) {
if (!ast_strlen_zero(var->name) && !ast_strlen_zero(var->value)) {
if (strlen(var->value) > (sizeof(format) - 1))
ast_log(LOG_WARNING, "Format string too long, will be truncated, at line %d\n", var->lineno);
ast_copy_string(format, var->value, sizeof(format) - 1);
strcat(format,"\n");
snprintf(master, sizeof(master),"%s/%s/%s", ast_config_AST_LOG_DIR, name, var->name);
if (var->next) {
ast_log(LOG_NOTICE, "Sorry, only one mapping is supported at this time, mapping '%s' will be ignored at line %d.\n", var->next->name, var->next->lineno);
break;
}
} else
ast_log(LOG_NOTICE, "Mapping must have both filename and format at line %d\n", var->lineno);
var = var->next;
}
ast_config_destroy(cfg);
res = 0;
} else {
if (reload)
ast_log(LOG_WARNING, "Failed to reload configuration file.\n");
else
ast_log(LOG_WARNING, "Failed to load configuration file. Module not activated.\n");
}
ast_mutex_unlock(&lock);
return res;
}
/*!
* \internal
* \brief Get key value specified by family/key.
*
* Gets the value associated with the specified \a family and \a key, and
* stores it, either into the fixed sized buffer specified by \a buffer
* and \a bufferlen, or as a heap allocated string if \a bufferlen is -1.
*
* \note If \a bufferlen is -1, \a buffer points to heap allocated memory
* and must be freed by calling ast_free().
*
* \retval -1 An error occurred
* \retval 0 Success
*/
static int db_get_common(const char *family, const char *key, char **buffer, int bufferlen)
{
const unsigned char *result;
char fullkey[MAX_DB_FIELD];
size_t fullkey_len;
int res = 0;
if (strlen(family) + strlen(key) + 2 > sizeof(fullkey) - 1) {
ast_log(LOG_WARNING, "Family and key length must be less than %zu bytes\n", sizeof(fullkey) - 3);
return -1;
}
fullkey_len = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, key);
ast_mutex_lock(&dblock);
if (sqlite3_bind_text(get_stmt, 1, fullkey, fullkey_len, SQLITE_STATIC) != SQLITE_OK) {
ast_log(LOG_WARNING, "Couldn't bind key to stmt: %s\n", sqlite3_errmsg(astdb));
res = -1;
} else if (sqlite3_step(get_stmt) != SQLITE_ROW) {
ast_debug(1, "Unable to find key '%s' in family '%s'\n", key, family);
res = -1;
} else if (!(result = sqlite3_column_text(get_stmt, 0))) {
ast_log(LOG_WARNING, "Couldn't get value\n");
res = -1;
} else {
const char *value = (const char *) result;
if (bufferlen == -1) {
*buffer = ast_strdup(value);
} else {
ast_copy_string(*buffer, value, bufferlen);
}
}
sqlite3_reset(get_stmt);
ast_mutex_unlock(&dblock);
return res;
}
static int ast_db_sqliteput(char *family, char *key, char *value)
{
int res = 0;
char *zErr = 0;
ast_mutex_lock(&sqlite_lock);
res=sqlite_exec_printf(db, "DELETE FROM astdb WHERE astfamily='%q' AND astkey='%q'", NULL, NULL, &zErr, family, key);
if (res != SQLITE_BUSY && res != SQLITE_LOCKED)
usleep(200);
if (zErr) {
ast_log(LOG_ERROR, "sqliteput: %s\n", zErr);
free(zErr);
}
res=sqlite_exec_printf(db, "INSERT INTO astdb (astfamily,astkey,astvalue) VALUES ('%q','%q','%q')", NULL, NULL, &zErr, family, key, value);
if (res != SQLITE_BUSY && res != SQLITE_LOCKED) {
usleep(200);
}
if (zErr) {
ast_log(LOG_ERROR, "sqliteput: %s\n", zErr);
free(zErr);
}
ast_mutex_unlock(&sqlite_lock);
return res;
}
static int
sccp_show_channel(int fd, int argc, char * argv[])
{
sccp_channel_t * c;
ast_cli(fd, "ID LINE DEVICE TR CALLED \n");
ast_cli(fd, "===== ========== ================ == ========== \n");
ast_mutex_lock(&chanlock);
c = chans;
while(c) {
ast_cli(fd, "%.5d %-10s %-16s %c%c %-10s\n",
c->callid,
c->line->name,
c->line->device->description,
(c->isOutgoing) ? 'O' : 'I',
(c->isRinging) ? 'R' : '-',
c->calledPartyNumber);
c = c->lnext;
}
ast_mutex_unlock(&chanlock);
return RESULT_SUCCESS;
}
void freeContext (OOCTXT* pctxt)
{
ASN1BOOL saveBuf;
ast_mutex_lock(&pctxt->pLock);
saveBuf = (pctxt->flags & ASN1SAVEBUF) != 0;
if (pctxt->buffer.dynamic && pctxt->buffer.data) {
if (saveBuf) {
memHeapMarkSaved (&pctxt->pMsgMemHeap, pctxt->buffer.data, TRUE);
}
else {
memHeapFreePtr (&pctxt->pMsgMemHeap, pctxt->buffer.data);
}
}
errFreeParms (&pctxt->errInfo);
memHeapRelease (&pctxt->pTypeMemHeap);
memHeapRelease (&pctxt->pMsgMemHeap);
ast_mutex_unlock(&pctxt->pLock);
ast_mutex_destroy(&pctxt->pLock);
}
/*! \brief unregister codec translator */
int ast_unregister_translator(struct ast_translator *t)
{
char tmp[80];
struct ast_translator *u, *ul = NULL;
ast_mutex_lock(&list_lock);
u = list;
while(u) {
if (u == t) {
if (ul)
ul->next = u->next;
else
list = u->next;
if (option_verbose > 1)
ast_verbose(VERBOSE_PREFIX_2 "Unregistered translator '%s' from format %s to %s\n", term_color(tmp, t->name, COLOR_MAGENTA, COLOR_BLACK, sizeof(tmp)), ast_getformatname(1 << t->srcfmt), ast_getformatname(1 << t->dstfmt));
break;
}
ul = u;
u = u->next;
}
rebuild_matrix(0);
ast_mutex_unlock(&list_lock);
return (u ? 0 : -1);
}
static int stop_monitor_action(struct mansession *s, struct message *m)
{
struct ast_channel *c = NULL;
char *name = astman_get_header(m, "Channel");
int res;
if (ast_strlen_zero(name)) {
astman_send_error(s, m, "No channel specified");
return 0;
}
c = ast_get_channel_by_name_locked(name);
if (!c) {
astman_send_error(s, m, "No such channel");
return 0;
}
res = ast_monitor_stop(c, 1);
ast_mutex_unlock(&c->lock);
if (res) {
astman_send_error(s, m, "Could not stop monitoring channel");
return 0;
}
astman_send_ack(s, m, "Stopped monitoring channel");
return 0;
}
