/*! \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; }