b2b_sca_record_t* b2b_sca_search_record_safe(int hash_index, str *shared_line)
{
b2b_sca_record_t *record;
record = b2b_sca_htable[hash_index].first;
while(record && (record->shared_line.len != shared_line->len ||
strncmp(record->shared_line.s, shared_line->s, shared_line->len) != 0)) {
b2b_sca_print_record(record);
record = record->next;
}
return record;
}
static int load_sca_info_from_db(void)
{
db_res_t * res = NULL;
db_val_t * values;
db_row_t * rows;
int i, j, nr_rows;
unsigned int valid_record;
unsigned int n_result_cols = 0;
unsigned int shared_line_col, watchers_col;
unsigned int app_shared_entity_col[MAX_APPEARANCE_INDEX];
unsigned int app_call_state_col[MAX_APPEARANCE_INDEX];
unsigned int app_call_info_uri_col[MAX_APPEARANCE_INDEX];
unsigned int app_call_info_appearance_uri_col[MAX_APPEARANCE_INDEX];
unsigned int app_b2bl_key_col[MAX_APPEARANCE_INDEX];
db_key_t q_cols[SCA_TABLE_TOTAL_COL_NO];
str shared_line, watchers_csv;
//str_lst_t *watchers;
//unsigned int size, watcher_size, watchers_no;
//unsigned int size;
unsigned int hash_index;
//char *p;
b2b_sca_record_t *record;
b2b_sca_call_t *call;
unsigned int shared_entity, appearance_index, call_state;
str call_info_uri, call_info_apperance_uri, b2bl_key;
b2bl_cb_ctx_t *cb_params;
if(use_sca_table()) return -1;
q_cols[shared_line_col = n_result_cols++] = &shared_line_column;
q_cols[watchers_col = n_result_cols++] = &watchers_column;
for (i=0; i<MAX_APPEARANCE_INDEX; i++) {
q_cols[app_shared_entity_col[i] = n_result_cols++] = &app_shared_entity_column[i];
q_cols[app_call_state_col[i] = n_result_cols++] = &app_call_state_column[i];
q_cols[app_call_info_uri_col[i] = n_result_cols++] = &app_call_info_uri_column[i];
q_cols[app_call_info_appearance_uri_col[i] = n_result_cols++] =
&app_call_info_appearance_uri_column[i];
q_cols[app_b2bl_key_col[i] = n_result_cols++] = &app_b2bl_key_column[i];
}
/* select the whole tabel and all the columns */
if (DB_CAPABILITY(sca_dbf, DB_CAP_FETCH)) {
if(sca_dbf.query(sca_db_handle, 0, 0, 0, q_cols, 0,
SCA_TABLE_TOTAL_COL_NO, 0, 0) < 0) {
LM_ERR("Error while querying (fetch) database\n");
return -1;
}
if(sca_dbf.fetch_result(sca_db_handle, &res, SCA_FETCH_SIZE)<0){
LM_ERR("fetching rows failed\n");
return -1;
}
} else {
if(sca_dbf.query(sca_db_handle, 0, 0, 0, q_cols, 0,
SCA_TABLE_TOTAL_COL_NO, 0, &res) < 0) {
LM_ERR("Error while querying database\n");
return -1;
}
}
nr_rows = RES_ROW_N(res);
do {
LM_DBG("loading [%i] records from db\n", nr_rows);
rows = RES_ROWS(res);
/* for every row/record */
for(i=0; i<nr_rows; i++){
values = ROW_VALUES(rows + i);
if (VAL_NULL(values+shared_line_col) || VAL_NULL(values+watchers_col)) {
LM_ERR("columns [%.*s] or/and [%.*s] cannot be null -> skipping\n",
shared_line_column.len, shared_line_column.s,
watchers_column.len, watchers_column.s);
continue;
}
shared_line.s = (char*)values[shared_line_col].val.string_val;
shared_line.len = strlen(shared_line.s);
watchers_csv.s = (char*)values[watchers_col].val.string_val;
watchers_csv.len = strlen(watchers_csv.s);
record = restore_record(&shared_line, &watchers_csv);
if (record == NULL)
goto error;
hash_index = core_hash(&shared_line, NULL, b2b_sca_hsize);
j = 0;
while (j < MAX_APPEARANCE_INDEX) {
if( VAL_NULL(values + app_shared_entity_col[j]) ||
VAL_NULL(values + app_call_state_col[j]) ||
VAL_NULL(values + app_call_info_uri_col[j]) ||
VAL_NULL(values + app_call_info_appearance_uri_col[j]) ||
VAL_NULL(values + app_b2bl_key_col[j]) ) {
goto cont;
}
appearance_index = j + 1;
/* 1 - get shared_entity */
shared_entity = values[app_shared_entity_col[j]].val.int_val;
if (shared_entity!=0 && shared_entity!=1) {
LM_ERR("Unexpected shared_entity [%d] "
"for shared_line [%.*s]\n",
shared_entity, shared_line.len, shared_line.s);
goto cont;
}
/* 2 - get call_state */
call_state = values[app_call_state_col[j]].val.int_val;
if (call_state == IDLE_STATE) {
LM_DBG("empty call[%d]\n", appearance_index);
goto cont;
}
if (call_state > MAX_INDEX_STATE) {
LM_ERR("Unexpected call_state [%d] for shared_line [%.*s]\n",
call_state, shared_line.len, shared_line.s);
goto cont;
}
/* 3 - get call_info_uri */
call_info_uri.s =
(char*)values[app_call_info_uri_col[j]].val.string_val;
if (call_info_uri.s)
call_info_uri.len = strlen(call_info_uri.s);
else {
LM_ERR("Missing call_info_uri for shared_line [%.*s][%d]\n",
shared_line.len, shared_line.s, appearance_index);
goto cont;
}
LM_DBG("call_info_uri=[%.*s]\n",
call_info_uri.len, call_info_uri.s);
/* 4 - get call_info_apperance_uri */
call_info_apperance_uri.s =
(char*)
values[app_call_info_appearance_uri_col[j]].val.string_val;
if (call_info_apperance_uri.s)
call_info_apperance_uri.len =
strlen(call_info_apperance_uri.s);
else {
LM_ERR("Missing call_info_apperance_uri for "
"shared_line [%.*s][%d]\n",
shared_line.len, shared_line.s, appearance_index);
goto cont;
}
LM_DBG("call_info_apperance_uri=[%.*s]\n",
call_info_apperance_uri.len, call_info_apperance_uri.s);
/* 5 - get b2bl_key */
b2bl_key.s = (char*)values[app_b2bl_key_col[j]].val.string_val;
if (b2bl_key.s) {
b2bl_key.len = strlen(b2bl_key.s);
if (b2bl_key.len > B2BL_MAX_KEY_LEN) {
LM_ERR("buffer overflow on b2bl_key [%.*s]"
" for shared_line [%.*s][%d]\n",
b2bl_key.len, b2bl_key.s,
shared_line.len, shared_line.s,
appearance_index);
goto cont;
}
LM_DBG("b2bl_key=[%.*s]\n", b2bl_key.len, b2bl_key.s);
} else {
LM_ERR("Missing b2bl_key for shared_line [%.*s][1]\n",
shared_line.len, shared_line.s);
goto cont;
}
/* restore the call */
call = restore_call(record, appearance_index,
shared_entity, call_state,
&call_info_uri, &call_info_apperance_uri);
if (call == NULL) {
goto error;
}
/* update record */
if (0!=b2b_sca_update_call_record_key(call, &b2bl_key)) {
LM_ERR("Unable to update b2bl_key [%.*s]\n",
b2bl_key.len, b2bl_key.s);
shm_free(call);
call = NULL;
record->call[appearance_index-1] = NULL;
goto cont;
}
/* Prepare b2b_logic callback params. */
cb_params = build_cb_params(hash_index,
&shared_line, appearance_index);
if (cb_params == NULL) {
LM_ERR("Unable to build cb_params\n");
goto error;
}
/* re-register callbacks */
if(b2bl_api.register_cb(&b2bl_key, &sca_logic_notify, cb_params,
B2B_RE_INVITE_CB|B2B_CONFIRMED_CB|B2B_DESTROY_CB) != 0){
LM_ERR("Unable register b2b cb\n");
shm_free(call);
call = NULL;
record->call[appearance_index-1] = NULL;
goto cont;
}
cont:
j++;
}
valid_record = j = 0;
while (j < MAX_APPEARANCE_INDEX) {
if (record->call[j]) {
valid_record = 1;
goto check_valid_record;
}
j++;
}
check_valid_record:
if (valid_record) {
b2b_sca_print_record(record);
insert_record(hash_index, record);
} else {
LM_DBG("removing the record from db!\n");
delete_sca_info_from_db(record);
}
LM_DBG("Done\n");
}
/* any more data to be fetched ?*/
if (DB_CAPABILITY(sca_dbf, DB_CAP_FETCH)) {
if (sca_dbf.fetch_result(sca_db_handle, &res, SCA_FETCH_SIZE)<0) {
LM_ERR("fetching more rows failed\n");
goto error;
}
nr_rows = RES_ROW_N(res);
} else {
nr_rows = 0;
}
}while (nr_rows>0);
sca_dbf.free_result(sca_db_handle, res);
return 0;
error:
sca_dbf.free_result(sca_db_handle, res);
return -1;
}
int sca_bridge_request(struct sip_msg* msg, str* p1, str* p2)
{
pv_value_t pv_val;
str shared_line = {NULL, 0};
str publish_hdr = {NULL, 0};
int method_value, ret;
//int entity_no;
unsigned int hash_index;
b2b_sca_record_t *record = NULL;
b2b_sca_call_t *call;
unsigned int appearance;
if (p1 && (pv_get_spec_value(msg, (pv_spec_t *)p1, &pv_val) == 0)) {
if (pv_val.flags & PV_VAL_STR) {
LM_DBG("got shared_line:'%.*s'\n", pv_val.rs.len, pv_val.rs.s);
shared_line = pv_val.rs;
} else {
LM_ERR("Unable to get shared_line from PV that is not a string\n");
return -1;
}
} else {
LM_ERR("Unable to get shared_line from pv:%p\n", p1);
return -1;
}
/* Get the hash index for the shared line. */
hash_index = core_hash(&shared_line, NULL, b2b_sca_hsize);
LM_DBG("got hash_index=[%d] for shared line [%.*s]\n",
hash_index, shared_line.len, shared_line.s);
if (parse_headers(msg, HDR_EOH_F, 0) < 0) {
LM_ERR("failed to parse message\n");
return -1;
}
method_value = msg->first_line.u.request.method_value;
if (method_value != METHOD_INVITE) {
LM_ERR("nonINVITE [%d] cannot bridge a call\n", method_value);
return -1;
}
ret = tmb.t_newtran(msg);
if(ret < 1) {
if(ret == 0) {
LM_DBG("It is a retransmission, drop\n");
tmb.unref_cell(tmb.t_gett());
} else {
LM_ERR("Error when creating tm transaction\n");
}
return 0;
}
if (!msg->call_info) {
LM_ERR("No 'Call-Info' header\n");
return -1;
}
/* Extract required appearance from the received request */
appearance = get_app_index(msg);
if (appearance==0) return -1;
lock_get(&b2b_sca_htable[hash_index].lock);
record = b2b_sca_search_record_safe(hash_index, &shared_line);
if (record == NULL) {
lock_release(&b2b_sca_htable[hash_index].lock);
LM_ERR("record not found for shared line [%.*s] on hash index [%d]\n",
shared_line.len, shared_line.s, hash_index);
// FIXME:
/* Build an empty PUBLISH header */
//if (build_publish_call_info_header(NULL, &publish_hdr) != 0) {
// LM_ERR("Unable to build PUBLISH Call-Info header\n");
//}
goto error;
}
b2b_sca_print_record(record);
call = b2b_sca_search_call_safe(record, appearance);
if (call == NULL) goto error;
if (call->call_state != HELD_STATE) {
LM_ERR("Improper call state [%d] for bridging\n", call->call_state);
goto error;
}
/* What will happen if the b2b_logic entity doesn't exist anymore? */
LM_DBG("*** BRIDGING THE REQUEST to entity [%d] on tuple [%.*s]\n",
call->shared_entity, call->b2bl_key.len, call->b2bl_key.s);
ret = b2bl_api.bridge_msg(msg, &call->b2bl_key, call->shared_entity);
if (ret != 0) {
/* FIXME:
* handle the error here */
LM_ERR("*** got ret [%d]\n", ret);
goto error;
}
LM_DBG("*** got ret [%d]\n", ret);
/* Set the state back to active */
call->call_state = ACTIVE_STATE;
/* Reset the shared_entity */
call->shared_entity = 0;
/* Prepare PUBLISH Call-Info header. */
if (build_publish_call_info_header(record, &publish_hdr) != 0) {
lock_release(&b2b_sca_htable[hash_index].lock);
LM_ERR("Unable to build PUBLISH Call-Info header\n");
return B2B_FOLLOW_SCENARIO_CB_RET;
}
/* Save the record to db. */
if (push_sca_info_to_db(record, appearance, 1) != 0)
LM_ERR("db out of synch\n");
/* Notify the watchers. */
sca_publish(record, &publish_hdr);
lock_release(&b2b_sca_htable[hash_index].lock);
return 1;
error:
lock_release(&b2b_sca_htable[hash_index].lock);
if (publish_hdr.s && publish_hdr.s != publish_call_info_hdr_buf)
pkg_free(publish_hdr.s);
return -1;
}
int sca_logic_notify(b2bl_cb_params_t *params, unsigned int b2b_event)
{
int on_hold = 0;
int sdp_session_num = 0, sdp_stream_num;
sdp_session_cell_t* sdp_session;
sdp_stream_cell_t* sdp_stream;
struct sip_msg *msg = params->msg;
b2bl_cb_ctx_t *cb_params = params->param;
str *shared_line;
unsigned int hash_index, appearance;
b2b_sca_record_t *record;
b2b_sca_call_t *call = NULL;
str publish_hdr;
unsigned int call_info_appearance;
unsigned int call_info_appearance_state = 0;
struct hdr_field *call_info;
struct call_info_body *callinfo_b;
struct to_body *call_info_b;
struct to_param *param;
if (b2b_sca_shutdown_completed) return B2B_FOLLOW_SCENARIO_CB_RET;
if (params == NULL) {
LM_ERR("callback event [%d] without cb params\n", b2b_event);
return B2B_DROP_MSG_CB_RET;
}
shared_line = &cb_params->shared_line;
hash_index = cb_params->hash_index;
appearance = cb_params->appearance;
LM_DBG("*** GOT NOTIFICATION TYPE [%d] WITH cb_params [%p]->[%.*s] appearance [%d] on hash index [%d]"
" for b2bl entity [%d]\n",
b2b_event, cb_params, shared_line->len, shared_line->s,
appearance, hash_index, params->entity);
if (msg && msg->call_info) {
if (0 == parse_call_info_header(msg)) {
call_info = msg->call_info;
if (call_info) {
LM_DBG("BODY=[%p]->[%.*s] sibling=[%p]\n", call_info,
call_info->body.len, call_info->body.s, call_info->sibling);
callinfo_b = call_info->parsed;
while (callinfo_b) {
call_info_b = &(callinfo_b->call_info_body);
LM_DBG(". body=[%.*s] param_lst=[%p] last_param=[%p]\n",
call_info_b->body.len, call_info_b->body.s,
call_info_b->param_lst, call_info_b->last_param);
param = call_info_b->param_lst;
while (param) {
LM_DBG(".. [%p]->[%d] [%.*s]=[%.*s]->[%p]\n",
param, param->type, param->name.len, param->name.s,
param->value.len, param->value.s, param->next);
if (param->name.len==APPEARANCE_INDEX_LEN &&
strncmp(APPEARANCE_INDEX_STR,
param->name.s, APPEARANCE_INDEX_LEN)==0) {
if (strno2int(¶m->value,&call_info_appearance)<0) {
LM_ERR("bad appearance-index [%.*s]\n",
param->value.len, param->value.s);
return -1;
}
if (appearance != call_info_appearance) {
LM_ERR("got appearance[%d] while expecting[%d]\n",
call_info_appearance, appearance);
goto next_callinfo_b;
} else {
LM_DBG("*** GOT APP-INDEX [%d]\n",
call_info_appearance);
}
} else if (param->name.len==APPEARANCE_STATE_LEN &&
strncmp(APPEARANCE_STATE_STR,
param->name.s, APPEARANCE_STATE_LEN)==0) {
LM_DBG("*** GOT APP-STATE [%.*s]\n",
param->value.len, param->value.s);
if (param->value.len == strlen(APP_STATE_HELD_PRIVATE) &&
strncmp(param->value.s,
app_state[HELD_PRIVATE_STATE].s,
param->value.len)==0) {
call_info_appearance_state = HELD_PRIVATE_STATE;
}
}
param=param->next;
}
goto handle_appearance;
next_callinfo_b:
callinfo_b = callinfo_b->next;
}
call_info = call_info->sibling;
}
} else {
LM_ERR("Unable to parse Call-Info header\n");
return B2B_DROP_MSG_CB_RET;
}
}
handle_appearance:
lock_get(&b2b_sca_htable[hash_index].lock);
record = b2b_sca_search_record_safe(hash_index, shared_line);
if (record == NULL) {
lock_release(&b2b_sca_htable[hash_index].lock);
LM_ERR("record not found for shared line [%.*s] on hash index [%d]\n",
shared_line->len, shared_line->s, hash_index);
return B2B_DROP_MSG_CB_RET;
}
b2b_sca_print_record(record);
switch(b2b_event){
case B2B_DESTROY_CB:
/* Destroy the sca index record */
shm_free(params->param);
b2b_sca_delete_call_record(hash_index, record, appearance);
break;
case B2B_RE_INVITE_CB:
case B2B_CONFIRMED_CB:
call = b2b_sca_search_call_safe(record, appearance);
if (call == NULL) {
LM_ERR("call record not found for shared line [%.*s] with index [%d]\n",
shared_line->len, shared_line->s, appearance);
lock_release(&b2b_sca_htable[hash_index].lock);
return B2B_DROP_MSG_CB_RET;
}
if (0 == parse_sdp(msg)) {
sdp_session = get_sdp_session(msg, sdp_session_num);
if(!sdp_session) break;
sdp_stream_num = 0;
for(;;) {
sdp_stream = get_sdp_stream(msg, sdp_session_num, sdp_stream_num);
if(!sdp_stream) break;
if(sdp_stream->media.len==AUDIO_STR_LEN &&
strncmp(sdp_stream->media.s,AUDIO_STR,AUDIO_STR_LEN)==0 &&
sdp_stream->is_on_hold) {
on_hold = 1;
break;
}
sdp_stream_num++;
}
sdp_session_num++;
}
if (on_hold) {
if (call_info_appearance_state)
call->call_state = HELD_PRIVATE_STATE;
else
call->call_state = HELD_STATE;
} else {
call->call_state = ACTIVE_STATE;
}
break;
default:
LM_ERR("Unexpected event\n");
}
/* Prepare PUBLISH Call-Info header. */
if (build_publish_call_info_header(record, &publish_hdr) != 0) {
lock_release(&b2b_sca_htable[hash_index].lock);
LM_ERR("Unable to build PUBLISH Call-Info header\n");
return B2B_FOLLOW_SCENARIO_CB_RET;
}
/* Save the record to db. */
if (push_sca_info_to_db(record, appearance, 1) != 0)
LM_ERR("DB out of synch\n");
/* Notify the watchers. */
sca_publish(record, &publish_hdr);
b2b_sca_delete_record_if_empty(record, hash_index);
lock_release(&b2b_sca_htable[hash_index].lock);
if (publish_hdr.s != publish_call_info_hdr_buf)
pkg_free(publish_hdr.s);
return B2B_FOLLOW_SCENARIO_CB_RET;
}
