mirror of
https://github.com/signalwire/freeswitch.git
synced 2025-08-13 09:36:46 +00:00
chlog: freetdm: channel/call variables moved to sigmsg
This commit is contained in:
David Yat Sin
@@ -62,10 +62,8 @@ struct tm *localtime_r(const time_t *clock, struct tm *result);
|
||||
ftdm_time_t time_last_throttle_log = 0;
|
||||
ftdm_time_t time_current_throttle_log = 0;
|
||||
|
||||
static ftdm_iterator_t *get_iterator(ftdm_iterator_type_t type, ftdm_iterator_t *iter);
|
||||
static ftdm_status_t ftdm_call_set_call_id(ftdm_channel_t *fchan, ftdm_caller_data_t *caller_data);
|
||||
static ftdm_status_t ftdm_call_clear_call_id(ftdm_caller_data_t *caller_data);
|
||||
static ftdm_status_t ftdm_channel_clear_vars(ftdm_channel_t *ftdmchan);
|
||||
static ftdm_status_t ftdm_channel_done(ftdm_channel_t *ftdmchan);
|
||||
|
||||
static int time_is_init = 0;
|
||||
@@ -2390,12 +2388,14 @@ FT_DECLARE(ftdm_status_t) _ftdm_channel_call_send_msg(const char *file, const ch
|
||||
#endif
|
||||
|
||||
ftdm_channel_lock(ftdmchan);
|
||||
ftdm_channel_save_event_data(ftdmchan);
|
||||
if (ftdmchan->span->send_msg) {
|
||||
status = ftdmchan->span->send_msg(ftdmchan, sigmsg);
|
||||
} else {
|
||||
status = FTDM_NOTIMPL;
|
||||
ftdm_log(FTDM_LOG_ERROR, "send_msg method not implemented in this span!\n");
|
||||
}
|
||||
ftdm_channel_clear_event_data(ftdmchan);
|
||||
ftdm_channel_unlock(ftdmchan);
|
||||
return status;
|
||||
}
|
||||
@@ -2450,13 +2450,12 @@ static ftdm_status_t _ftdm_channel_call_place_nl(const char *file, const char *f
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* in case of success, *before* unlocking the channel, we must set the call started flag and the call id
|
||||
* that is a guarantee that signaling modules expect from us */
|
||||
ftdm_set_flag(ftdmchan, FTDM_CHANNEL_CALL_STARTED);
|
||||
ftdm_call_set_call_id(ftdmchan, &ftdmchan->caller_data);
|
||||
if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_NONBLOCK)) {
|
||||
/* be aware this waiting unlocks the channel and locks it back when done */
|
||||
ftdm_wait_for_flag_cleared(ftdmchan, FTDM_CHANNEL_STATE_CHANGE, 100);
|
||||
ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_DIALING, 1);
|
||||
} else {
|
||||
ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_DIALING, 0);
|
||||
}
|
||||
|
||||
done:
|
||||
@@ -2633,7 +2632,7 @@ static ftdm_status_t ftdm_channel_done(ftdm_channel_t *ftdmchan)
|
||||
ftdm_buffer_destroy(&ftdmchan->pre_buffer);
|
||||
ftdmchan->pre_buffer_size = 0;
|
||||
ftdm_mutex_unlock(ftdmchan->pre_buffer_mutex);
|
||||
ftdm_channel_clear_vars(ftdmchan);
|
||||
|
||||
if (ftdmchan->hangup_timer) {
|
||||
ftdm_sched_cancel_timer(globals.timingsched, ftdmchan->hangup_timer);
|
||||
}
|
||||
@@ -4032,166 +4031,7 @@ done:
|
||||
return status;
|
||||
}
|
||||
|
||||
FT_DECLARE(void) ftdm_call_clear_data(ftdm_caller_data_t *caller_data)
|
||||
{
|
||||
ftdm_call_clear_vars(caller_data);
|
||||
memset(&caller_data->raw_data, 0, sizeof(caller_data->raw_data));
|
||||
caller_data->raw_data_len = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
FT_DECLARE(ftdm_status_t) ftdm_call_clear_vars(ftdm_caller_data_t *caller_data)
|
||||
{
|
||||
if (caller_data->variables) {
|
||||
hashtable_destroy(caller_data->variables);
|
||||
}
|
||||
caller_data->variables = NULL;
|
||||
return FTDM_SUCCESS;
|
||||
}
|
||||
|
||||
FT_DECLARE(ftdm_status_t) ftdm_call_remove_var(ftdm_caller_data_t *caller_data, const char *var_name)
|
||||
{
|
||||
if (caller_data->variables) {
|
||||
hashtable_remove(caller_data->variables, (void *)var_name);
|
||||
}
|
||||
|
||||
return FTDM_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
FT_DECLARE(ftdm_status_t) ftdm_call_add_var(ftdm_caller_data_t *caller_data, const char *var_name, const char *value)
|
||||
{
|
||||
char *t_name = 0, *t_val = 0;
|
||||
|
||||
if (!var_name || !value) {
|
||||
return FTDM_FAIL;
|
||||
}
|
||||
|
||||
if (!caller_data->variables) {
|
||||
/* initialize on first use */
|
||||
caller_data->variables = create_hashtable(16, ftdm_hash_hashfromstring, ftdm_hash_equalkeys);
|
||||
ftdm_assert_return(caller_data->variables, FTDM_FAIL, "Failed to create hash table\n");
|
||||
}
|
||||
|
||||
t_name = ftdm_strdup(var_name);
|
||||
t_val = ftdm_strdup(value);
|
||||
hashtable_insert(caller_data->variables, t_name, t_val, HASHTABLE_FLAG_FREE_KEY | HASHTABLE_FLAG_FREE_VALUE);
|
||||
return FTDM_SUCCESS;
|
||||
}
|
||||
|
||||
FT_DECLARE(const char *) ftdm_call_get_var(ftdm_caller_data_t *caller_data, const char *var_name)
|
||||
{
|
||||
const char *var = NULL;
|
||||
|
||||
if (!caller_data->variables || !var_name) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
var = (const char *)hashtable_search(((struct hashtable*)caller_data->variables), (void *)var_name);
|
||||
return var;
|
||||
}
|
||||
|
||||
FT_DECLARE(ftdm_iterator_t *) ftdm_call_get_var_iterator(const ftdm_caller_data_t *caller_data, ftdm_iterator_t *iter)
|
||||
{
|
||||
ftdm_hash_iterator_t *hashiter = NULL;
|
||||
hashiter = caller_data->variables == NULL ? NULL : hashtable_first(caller_data->variables);
|
||||
|
||||
if (hashiter == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!(iter = get_iterator(FTDM_ITERATOR_VARS, iter))) {
|
||||
return NULL;
|
||||
}
|
||||
iter->pvt.hashiter = hashiter;
|
||||
return iter;
|
||||
}
|
||||
|
||||
FT_DECLARE(ftdm_status_t) ftdm_call_get_current_var(ftdm_iterator_t *iter, const char **var_name, const char **var_val)
|
||||
{
|
||||
const void *key = NULL;
|
||||
void *val = NULL;
|
||||
|
||||
*var_name = NULL;
|
||||
*var_val = NULL;
|
||||
|
||||
ftdm_assert_return(iter && (iter->type == FTDM_ITERATOR_VARS) && iter->pvt.hashiter, FTDM_FAIL, "Cannot get variable from invalid iterator!\n");
|
||||
|
||||
hashtable_this(iter->pvt.hashiter, &key, NULL, &val);
|
||||
|
||||
*var_name = key;
|
||||
*var_val = val;
|
||||
|
||||
return FTDM_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
static ftdm_status_t ftdm_channel_clear_vars(ftdm_channel_t *ftdmchan)
|
||||
{
|
||||
ftdm_channel_lock(ftdmchan);
|
||||
|
||||
if (ftdmchan->variable_hash) {
|
||||
hashtable_destroy(ftdmchan->variable_hash);
|
||||
}
|
||||
ftdmchan->variable_hash = NULL;
|
||||
|
||||
ftdm_channel_unlock(ftdmchan);
|
||||
return FTDM_SUCCESS;
|
||||
}
|
||||
|
||||
FT_DECLARE(ftdm_status_t) ftdm_channel_add_var(ftdm_channel_t *ftdmchan, const char *var_name, const char *value)
|
||||
{
|
||||
char *t_name = 0, *t_val = 0;
|
||||
|
||||
ftdm_status_t status = FTDM_FAIL;
|
||||
|
||||
if (!var_name || !value) {
|
||||
return FTDM_FAIL;
|
||||
}
|
||||
|
||||
ftdm_channel_lock(ftdmchan);
|
||||
|
||||
if (!ftdmchan->variable_hash) {
|
||||
/* initialize on first use */
|
||||
ftdmchan->variable_hash = create_hashtable(16, ftdm_hash_hashfromstring, ftdm_hash_equalkeys);
|
||||
if (!ftdmchan->variable_hash) {
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
|
||||
t_name = ftdm_strdup(var_name);
|
||||
t_val = ftdm_strdup(value);
|
||||
|
||||
hashtable_insert(ftdmchan->variable_hash, t_name, t_val, HASHTABLE_FLAG_FREE_KEY | HASHTABLE_FLAG_FREE_VALUE);
|
||||
|
||||
status = FTDM_SUCCESS;
|
||||
|
||||
done:
|
||||
ftdm_channel_unlock(ftdmchan);
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
|
||||
FT_DECLARE(const char *) ftdm_channel_get_var(ftdm_channel_t *ftdmchan, const char *var_name)
|
||||
{
|
||||
const char *var = NULL;
|
||||
|
||||
ftdm_channel_lock(ftdmchan);
|
||||
|
||||
if (!ftdmchan->variable_hash || !var_name) {
|
||||
goto done;
|
||||
}
|
||||
|
||||
var = (const char *)hashtable_search(ftdmchan->variable_hash, (void *)var_name);
|
||||
|
||||
done:
|
||||
ftdm_channel_unlock(ftdmchan);
|
||||
|
||||
return var;
|
||||
}
|
||||
|
||||
static ftdm_iterator_t *get_iterator(ftdm_iterator_type_t type, ftdm_iterator_t *iter)
|
||||
FT_DECLARE(ftdm_iterator_t) *get_iterator(ftdm_iterator_type_t type, ftdm_iterator_t *iter)
|
||||
{
|
||||
int allocated = 0;
|
||||
if (iter) {
|
||||
@@ -4215,25 +4055,6 @@ static ftdm_iterator_t *get_iterator(ftdm_iterator_type_t type, ftdm_iterator_t
|
||||
return iter;
|
||||
}
|
||||
|
||||
FT_DECLARE(ftdm_iterator_t *) ftdm_channel_get_var_iterator(const ftdm_channel_t *ftdmchan, ftdm_iterator_t *iter)
|
||||
{
|
||||
ftdm_hash_iterator_t *hashiter = NULL;
|
||||
ftdm_channel_lock(ftdmchan);
|
||||
hashiter = ftdmchan->variable_hash == NULL ? NULL : hashtable_first(ftdmchan->variable_hash);
|
||||
ftdm_channel_unlock(ftdmchan);
|
||||
|
||||
|
||||
if (hashiter == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!(iter = get_iterator(FTDM_ITERATOR_VARS, iter))) {
|
||||
return NULL;
|
||||
}
|
||||
iter->pvt.hashiter = hashiter;
|
||||
return iter;
|
||||
}
|
||||
|
||||
FT_DECLARE(ftdm_iterator_t *) ftdm_span_get_chan_iterator(const ftdm_span_t *span, ftdm_iterator_t *iter)
|
||||
{
|
||||
if (!(iter = get_iterator(FTDM_ITERATOR_CHANS, iter))) {
|
||||
@@ -4244,24 +4065,6 @@ FT_DECLARE(ftdm_iterator_t *) ftdm_span_get_chan_iterator(const ftdm_span_t *spa
|
||||
return iter;
|
||||
}
|
||||
|
||||
FT_DECLARE(ftdm_status_t) ftdm_channel_get_current_var(ftdm_iterator_t *iter, const char **var_name, const char **var_val)
|
||||
{
|
||||
const void *key = NULL;
|
||||
void *val = NULL;
|
||||
|
||||
*var_name = NULL;
|
||||
*var_val = NULL;
|
||||
|
||||
ftdm_assert_return(iter && (iter->type == FTDM_ITERATOR_VARS) && iter->pvt.hashiter, FTDM_FAIL, "Cannot get variable from invalid iterator!\n");
|
||||
|
||||
hashtable_this(iter->pvt.hashiter, &key, NULL, &val);
|
||||
|
||||
*var_name = key;
|
||||
*var_val = val;
|
||||
|
||||
return FTDM_SUCCESS;
|
||||
}
|
||||
|
||||
FT_DECLARE(ftdm_iterator_t *) ftdm_iterator_next(ftdm_iterator_t *iter)
|
||||
{
|
||||
ftdm_assert_return(iter && iter->type, NULL, "Invalid iterator\n");
|
||||
@@ -5476,13 +5279,8 @@ static ftdm_status_t ftdm_span_trigger_signal(const ftdm_span_t *span, ftdm_sigm
|
||||
{
|
||||
ftdm_status_t status = span->signal_cb(sigmsg);
|
||||
if (sigmsg->channel) {
|
||||
ftdm_call_clear_data(&(sigmsg->channel->caller_data));
|
||||
}
|
||||
if (sigmsg->raw.autofree) {
|
||||
ftdm_safe_free(sigmsg->raw.data);
|
||||
sigmsg->raw.data = NULL;
|
||||
sigmsg->raw.len = 0;
|
||||
}
|
||||
ftdm_channel_clear_event_data(sigmsg->channel);
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
@@ -6221,6 +6019,71 @@ static ftdm_status_t ftdm_call_clear_call_id(ftdm_caller_data_t *caller_data)
|
||||
return FTDM_SUCCESS;
|
||||
}
|
||||
|
||||
FT_DECLARE(ftdm_status_t) ftdm_event_get_raw_data(ftdm_sigmsg_t *sigmsg, void **data, ftdm_size_t *datalen)
|
||||
{
|
||||
if (!sigmsg || !sigmsg->raw.len) {
|
||||
return FTDM_FAIL;
|
||||
}
|
||||
|
||||
*data = sigmsg->raw.data;
|
||||
*datalen = sigmsg->raw.len;
|
||||
|
||||
return FTDM_SUCCESS;
|
||||
}
|
||||
|
||||
FT_DECLARE(ftdm_status_t) ftdm_event_set_raw_data(ftdm_sigmsg_t *sigmsg, void *data, ftdm_size_t datalen, uint8_t autofree)
|
||||
{
|
||||
ftdm_assert_return(sigmsg, FTDM_FAIL, "Trying to set raw data on a NULL event\n");
|
||||
ftdm_assert_return(sigmsg->raw.len, FTDM_FAIL, "Overwriting existing raw data\n");
|
||||
|
||||
sigmsg->raw.data = ftdm_calloc(1, datalen);
|
||||
memcpy(sigmsg->raw.data, data, datalen);
|
||||
sigmsg->raw.len = datalen;
|
||||
sigmsg->raw.autofree = autofree;
|
||||
|
||||
return FTDM_SUCCESS;
|
||||
}
|
||||
|
||||
FT_DECLARE(ftdm_status_t) ftdm_channel_save_event_data(ftdm_channel_t *ftdmchan)
|
||||
{
|
||||
ftdm_assert_return(!ftdmchan->sigmsg, FTDM_FAIL, "Info from previous event was not cleared\n");
|
||||
if (ftdmchan->caller_data.sigmsg) {
|
||||
/* Copy sigmsg from user to internal copy so user can set new variables without race condition */
|
||||
ftdmchan->sigmsg = ftdm_calloc(1, sizeof(ftdm_sigmsg_t));
|
||||
memcpy(ftdmchan->sigmsg, ftdmchan->caller_data.sigmsg, sizeof(ftdm_sigmsg_t));
|
||||
|
||||
if (ftdmchan->caller_data.sigmsg->raw.data) {
|
||||
ftdm_event_set_raw_data(ftdmchan->sigmsg, ftdmchan->caller_data.sigmsg->raw.data, ftdmchan->caller_data.sigmsg->raw.len, 1);
|
||||
|
||||
if (ftdmchan->caller_data.sigmsg->raw.autofree) {
|
||||
ftdm_safe_free(ftdmchan->caller_data.sigmsg->raw.data);
|
||||
}
|
||||
}
|
||||
ftdmchan->caller_data.sigmsg = NULL;
|
||||
}
|
||||
return FTDM_SUCCESS;
|
||||
}
|
||||
|
||||
FT_DECLARE(ftdm_status_t) ftdm_channel_clear_event_data(ftdm_channel_t *ftdmchan)
|
||||
{
|
||||
if (!ftdmchan->sigmsg) {
|
||||
return FTDM_SUCCESS;
|
||||
}
|
||||
|
||||
if (ftdmchan->sigmsg->variables) {
|
||||
ftdm_event_clear_vars(ftdmchan->sigmsg);
|
||||
}
|
||||
|
||||
if (ftdmchan->sigmsg->raw.data && ftdmchan->sigmsg->raw.autofree) {
|
||||
ftdm_safe_free(ftdmchan->sigmsg->raw.data);
|
||||
ftdmchan->sigmsg->raw.data = NULL;
|
||||
ftdmchan->sigmsg->raw.len = 0;
|
||||
}
|
||||
|
||||
ftdm_safe_free(ftdmchan->sigmsg);
|
||||
ftdmchan->sigmsg = NULL;
|
||||
return FTDM_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user