bool cConfigItem_hour_interval::setParamFromValueStr(string value_str) {
if(!param_from || !param_to ||
value_str.empty()) {
return(false);
}
const char *value = value_str.c_str();
if(value) {
string fromTo = reg_replace(value, "([0-9]+)[- ]*([0-9]+)", "$1-$2", __FILE__, __LINE__);
if(fromTo.empty()) {
*param_from = *param_to = atoi(value);
if(*param_from < 0 || *param_from > 23) {
*param_from = -1;
*param_to = -1;
}
} else {
sscanf(fromTo.c_str(), "%i-%i", param_from, param_to);
if(*param_from < 0 || *param_from > 23 ||
*param_to < 0 || *param_to > 23) {
*param_from = -1;
*param_to = -1;
}
}
return(true);
}
return(false);
}
/* get esqk information from contact header and save this in call cell
*/
int get_esqk_in_contact(char *contact_esgwri, ESCT *call_cell){
char *contact_esqk_aux;
str pattern_contact_esqk, replacement_contact_esqk;
str pt_contact_esqk;
int len_contact_esgwri = strlen(contact_esgwri);
contact_esqk_aux = pkg_malloc(sizeof (char)*len_contact_esgwri + 1);
if (contact_esqk_aux == NULL) {
LM_ERR("no more pkg memory\n");
return -1;
}
memset(contact_esqk_aux, 0,len_contact_esgwri + 1);
pt_contact_esqk.s = contact_esqk_aux;
pt_contact_esqk.len = len_contact_esgwri;
pattern_contact_esqk.s = "Asserted-Identity:=<(sips?:)*[+]*1?([-0-9]+)@";
pattern_contact_esqk.len = strlen(pattern_contact_esqk.s);
replacement_contact_esqk.s = "\\2";
replacement_contact_esqk.len = strlen(replacement_contact_esqk.s);
if (reg_replace(pattern_contact_esqk.s, replacement_contact_esqk.s, contact_esgwri, &pt_contact_esqk) != 1) {
LM_ERR("****** PATTERN ESQK NAO OK \n");
pkg_free(contact_esqk_aux);
pkg_free(contact_esgwri);
if (strlen(call_cell->lro) <= 1){
pkg_free(call_cell->callid);
pkg_free(call_cell);
}
return -1;
}
pt_contact_esqk.len = strlen(pt_contact_esqk.s);
call_cell->esqk = pkg_malloc(sizeof (char)* pt_contact_esqk.len + 1);
if (call_cell->esqk == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
memcpy(call_cell->esqk, pt_contact_esqk.s, pt_contact_esqk.len);
call_cell->esqk[pt_contact_esqk.len] = 0;
LM_DBG ("CONTEUDO TRANS REPLY ESQK %.*s \n", pt_contact_esqk.len, pt_contact_esqk.s);
pkg_free(contact_esqk_aux);
return 1;
}
/* get lro information from contact header and save this in call cell
*/
int get_lro_in_contact(char *contact_lro, ESCT *call_cell) {
char *contact_lro_aux;
str pattern_contact_lro, replacement_contact_lro;
str pt_contact_lro;
int len_contact_lro = strlen(contact_lro);
contact_lro_aux = pkg_malloc(sizeof (char)*len_contact_lro + 1);
if (contact_lro_aux == NULL) {
LM_ERR("no more pkg memory\n");
return -1;
}
memset(contact_lro_aux, 0,len_contact_lro + 1);
pt_contact_lro.s = contact_lro_aux;
pt_contact_lro.len = len_contact_lro;
pattern_contact_lro.s = "(sips?:)*+?1?([-0-9]+)@";
pattern_contact_lro.len = strlen(pattern_contact_lro.s);
replacement_contact_lro.s = "\\2";
replacement_contact_lro.len = strlen(replacement_contact_lro.s);
if (reg_replace(pattern_contact_lro.s, replacement_contact_lro.s, contact_lro, &pt_contact_lro) != 1) {
LM_ERR("****** PATTERN LRO NAO OK \n");
pkg_free(contact_lro_aux);
pkg_free(contact_lro);
return 1;
}
pt_contact_lro.len = strlen(pt_contact_lro.s);
call_cell->lro = pkg_malloc(sizeof (char)* pt_contact_lro.len + 1);
if (call_cell->lro == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
memcpy(call_cell->lro, pt_contact_lro.s, pt_contact_lro.len);
call_cell->lro[pt_contact_lro.len] = 0;
call_cell->disposition = "none";
LM_DBG ("CONTEUDO TRANS REPLY LRO %.*s \n", pt_contact_lro.len, pt_contact_lro.s);
pkg_free(contact_lro_aux);
pkg_free(contact_lro);
return 1;
}
/*
* Makes enum query on name. On success, rewrites user part and
* replaces Request-URI.
*/
int do_query(struct sip_msg* _msg, char *user, char *name, str *service) {
char uri[MAX_URI_SIZE];
char new_uri[MAX_URI_SIZE];
unsigned int priority, curr_prio, first;
qvalue_t q;
struct rdata* head;
struct rdata* l;
struct naptr_rdata* naptr;
str pattern, replacement, result, new_result;
head = get_record(name, T_NAPTR);
if (head == 0) {
LM_DBG("No NAPTR record found for %s.\n", name);
return -1;
}
naptr_sort(&head);
q = MAX_Q - 10;
curr_prio = 0;
first = 1;
for (l = head; l; l = l->next) {
if (l->type != T_NAPTR) continue; /*should never happen*/
naptr = (struct naptr_rdata*)l->rdata;
if (naptr == 0) {
LM_ERR("Null rdata in DNS response\n");
continue;
}
LM_DBG("ENUM query on %s: order %u, pref %u, flen %u, flags '%.*s', "
"slen %u, services '%.*s', rlen %u, regexp '%.*s'\n",
name, naptr->order, naptr->pref,
naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags),
naptr->services_len,
(int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len,
(int)(naptr->regexp_len), ZSW(naptr->regexp));
if (sip_match(naptr, service) == 0) continue;
if (parse_naptr_regexp(&(naptr->regexp[0]), naptr->regexp_len,
&pattern, &replacement) < 0) {
LM_ERR("Parsing of NAPTR regexp failed\n");
continue;
}
result.s = &(uri[0]);
result.len = MAX_URI_SIZE;
/* Avoid making copies of pattern and replacement */
pattern.s[pattern.len] = (char)0;
replacement.s[replacement.len] = (char)0;
if (reg_replace(pattern.s, replacement.s, user, &result) < 0) {
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
LM_ERR("Regexp replace failed\n");
continue;
}
LM_DBG("Resulted in replacement: '%.*s'\n", result.len, ZSW(result.s));
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
if (param.len > 0) {
if (result.len + param.len > MAX_URI_SIZE - 1) {
LM_ERR("URI is too long\n");
continue;
}
new_result.s = &(new_uri[0]);
new_result.len = MAX_URI_SIZE;
if (add_uri_param(&result, ¶m, &new_result) == 0) {
LM_ERR("Parsing of URI <%.*s> failed\n",
result.len, result.s);
continue;
}
if (new_result.len > 0) {
result = new_result;
}
}
if (first) {
if (set_ruri(_msg, &result) == -1) {
goto done;
}
set_ruri_q(q);
first = 0;
curr_prio = ((naptr->order) << 16) + naptr->pref;
} else {
priority = ((naptr->order) << 16) + naptr->pref;
if (priority > curr_prio) {
q = q - 10;
curr_prio = priority;
}
if (append_branch(_msg, &result, 0, 0, q, 0, 0) == -1) {
goto done;
}
}
}
done:
free_rdata_list(head);
return first ? -1 : 1;
}
/*
* Check if from user is a valid enum based user, and check to make sure
* that the src_ip == an srv record that maps to the enum from user.
*/
int is_from_user_enum_2(struct sip_msg* _msg, char* _suffix, char* _service)
{
struct ip_addr addr;
struct hostent* he;
unsigned short zp;
unsigned short proto;
char *user_s;
int user_len, i, j;
char name[MAX_DOMAIN_SIZE];
char uri[MAX_URI_SIZE];
struct sip_uri *furi;
struct sip_uri luri;
struct rdata* head;
str* suffix;
str* service;
struct rdata* l;
struct naptr_rdata* naptr;
str pattern, replacement, result;
char string[17];
if (parse_from_header(_msg) < 0) {
LM_ERR("Failed to parse From header\n");
return -1;
}
if(_msg->from==NULL || get_from(_msg)==NULL) {
LM_DBG("No From header\n");
return -1;
}
if ((furi = parse_from_uri(_msg)) == NULL) {
LM_ERR("Failed to parse From URI\n");
return -1;
}
suffix = (str*)_suffix;
service = (str*)_service;
if (is_e164(&(furi->user)) == -1) {
LM_ERR("From URI user is not an E164 number\n");
return -1;
}
/* assert: the from user is a valid formatted e164 string */
user_s = furi->user.s;
user_len = furi->user.len;
j = 0;
for (i = user_len - 1; i > 0; i--) {
name[j] = user_s[i];
name[j + 1] = '.';
j = j + 2;
}
memcpy(name + j, suffix->s, suffix->len + 1);
head = get_record(name, T_NAPTR);
if (head == 0) {
LM_DBG("No NAPTR record found for %s.\n", name);
return -3;
}
/* we have the naptr records, loop and find an srv record with */
/* same ip address as source ip address, if we do then true is returned */
for (l = head; l; l = l->next) {
if (l->type != T_NAPTR) continue; /*should never happen*/
naptr = (struct naptr_rdata*)l->rdata;
if (naptr == 0) {
LM_ERR("Null rdata in DNS response\n");
free_rdata_list(head);
return -4;
}
LM_DBG("ENUM query on %s: order %u, pref %u, flen %u, flags "
"'%.*s', slen %u, services '%.*s', rlen %u, "
"regexp '%.*s'\n",
name, naptr->order, naptr->pref,
naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags), naptr->services_len,
(int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len,
(int)(naptr->regexp_len), ZSW(naptr->regexp));
if (sip_match(naptr, service) != 0) {
if (parse_naptr_regexp(&(naptr->regexp[0]), naptr->regexp_len,
&pattern, &replacement) < 0) {
free_rdata_list(head); /*clean up*/
LM_ERR("Parsing of NAPTR regexp failed\n");
return -5;
}
#ifdef LATER
if ((pattern.len == 4) && (strncmp(pattern.s, "^.*$", 4) == 0)) {
LM_DBG("Resulted in replacement: '%.*s'\n",
replacement.len, ZSW(replacement.s));
retval = set_uri(_msg, replacement.s, replacement.len);
free_rdata_list(head); /*clean up*/
return retval;
}
#endif
result.s = &(uri[0]);
result.len = MAX_URI_SIZE;
/* Avoid making copies of pattern and replacement */
pattern.s[pattern.len] = (char)0;
replacement.s[replacement.len] = (char)0;
/* We have already checked the size of
_msg->parsed_uri.user.s */
memcpy(&(string[0]), user_s, user_len);
string[user_len] = (char)0;
if (reg_replace(pattern.s, replacement.s, &(string[0]),
&result) < 0) {
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
LM_ERR("Regexp replace failed\n");
free_rdata_list(head); /*clean up*/
return -6;
}
LM_DBG("Resulted in replacement: '%.*s'\n",
result.len, ZSW(result.s));
if(parse_uri(result.s, result.len, &luri) < 0)
{
LM_ERR("Parsing of URI <%.*s> failed\n",
result.len, result.s);
free_rdata_list(head); /*clean up*/
return -7;
}
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
zp = 0;
proto = PROTO_NONE;
he = sip_resolvehost(&luri.host, &zp, &proto,
(luri.type==SIPS_URI_T)?1:0 , 0);
hostent2ip_addr(&addr, he, 0);
if(ip_addr_cmp(&addr, &_msg->rcv.src_ip))
{
free_rdata_list(head);
return(1);
}
}
}
free_rdata_list(head); /*clean up*/
LM_DBG("FAIL\n");
/* must not have found the record */
return(-8);
}
int enum_pv_query_3(struct sip_msg* _msg, char* _sp, char* _suffix,
char* _service)
{
char *user_s;
int user_len, i, j, first;
char name[MAX_DOMAIN_SIZE];
char uri[MAX_URI_SIZE];
char new_uri[MAX_URI_SIZE];
unsigned int priority, curr_prio;
qvalue_t q;
char tostring[17];
struct rdata* head;
struct rdata* l;
struct naptr_rdata* naptr;
str pattern, replacement, result, new_result;
str *suffix, *service;
char string[17];
pv_spec_t *sp;
pv_value_t pv_val;
sp = (pv_spec_t *)_sp;
suffix = (str*)_suffix;
service = (str*)_service;
/*
* Get R-URI user to tostring
*/
if (parse_sip_msg_uri(_msg) < 0) {
LM_ERR("R-URI parsing failed\n");
return -1;
}
user_s = _msg->parsed_uri.user.s;
user_len = _msg->parsed_uri.user.len;
memcpy(&(tostring[0]), user_s, user_len);
tostring[user_len] = (char)0;
/*
* Get E.164 number from pseudo variable
*/
if (sp && (pv_get_spec_value(_msg, sp, &pv_val) == 0)) {
if (pv_val.flags & PV_VAL_STR) {
if (pv_val.rs.len == 0 || pv_val.rs.s == NULL) {
LM_DBG("Missing E.164 number\n");
return -1;
}
} else {
LM_DBG("Pseudo variable value is not string\n");
return -1;
}
} else {
LM_DBG("Cannot get pseudo variable value\n");
return -1;
}
if (is_e164(&(pv_val.rs)) == -1) {
LM_ERR("pseudo variable does not contain an E164 number\n");
return -1;
}
user_s = pv_val.rs.s;
user_len = pv_val.rs.len;
memcpy(&(string[0]), user_s, user_len);
string[user_len] = (char)0;
j = 0;
for (i = user_len - 1; i > 0; i--) {
name[j] = user_s[i];
name[j + 1] = '.';
j = j + 2;
}
memcpy(name + j, suffix->s, suffix->len + 1);
head = get_record(name, T_NAPTR);
if (head == 0) {
LM_DBG("No NAPTR record found for %s.\n", name);
return -1;
}
naptr_sort(&head);
q = MAX_Q - 10;
curr_prio = 0;
first = 1;
for (l = head; l; l = l->next) {
if (l->type != T_NAPTR) continue; /*should never happen*/
naptr = (struct naptr_rdata*)l->rdata;
if (naptr == 0) {
LM_ERR("Null rdata in DNS response\n");
continue;
}
LM_DBG("ENUM query on %s: order %u, pref %u, flen %u, flags "
"'%.*s', slen %u, services '%.*s', rlen %u, "
"regexp '%.*s'\n",
name, naptr->order, naptr->pref,
naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags),
naptr->services_len,
(int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len,
(int)(naptr->regexp_len), ZSW(naptr->regexp));
if (sip_match(naptr, service) == 0) continue;
if (parse_naptr_regexp(&(naptr->regexp[0]), naptr->regexp_len,
&pattern, &replacement) < 0) {
LM_ERR("Parsing of NAPTR regexp failed\n");
continue;
}
result.s = &(uri[0]);
result.len = MAX_URI_SIZE;
/* Avoid making copies of pattern and replacement */
pattern.s[pattern.len] = (char)0;
replacement.s[replacement.len] = (char)0;
if (reg_replace(pattern.s, replacement.s, &(tostring[0]),
&result) < 0) {
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
LM_ERR("Regexp replace failed\n");
continue;
}
LM_DBG("Resulted in replacement: '%.*s'\n",
result.len, ZSW(result.s));
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
if (param.len > 0) {
if (result.len + param.len > MAX_URI_SIZE - 1) {
LM_ERR("URI is too long\n");
continue;
}
new_result.s = &(new_uri[0]);
new_result.len = MAX_URI_SIZE;
if (add_uri_param(&result, ¶m, &new_result) == 0) {
LM_ERR("Parsing of URI <%.*s> failed\n",
result.len, result.s);
continue;
}
if (new_result.len > 0) {
result = new_result;
}
}
if (first) {
if (set_ruri(_msg, &result) == -1) {
goto done;
}
set_ruri_q(q);
first = 0;
curr_prio = ((naptr->order) << 16) + naptr->pref;
} else {
priority = ((naptr->order) << 16) + naptr->pref;
if (priority > curr_prio) {
q = q - 10;
curr_prio = priority;
}
if (append_branch(_msg, &result, 0, 0, q, 0, 0) == -1) {
goto done;
}
}
}
done:
free_rdata_list(head);
return first ? -1 : 1;
}
int dp_can_connect_str(str *domain, int rec_level) {
struct rdata* head;
struct rdata* l;
struct naptr_rdata* naptr;
struct naptr_rdata* next_naptr;
int ret;
str newdomain;
char uri[MAX_URI_SIZE];
struct avp_stack stack;
int last_order = -1;
int failed = 0;
int found_anything = 0;
str pattern, replacement, result;
stack_reset(&stack);
/* If we're in a recursive call, set the domain-replacement */
if ( rec_level > 0 ) {
stack_push(&stack, domain_replacement_name.s.s, domain->s);
stack.succeeded = 0;
}
if (rec_level > MAX_DDDS_RECURSIONS) {
LM_ERR("too many indirect NAPTRs. Aborting at %.*s.\n", domain->len,
ZSW(domain->s));
return(DP_DDDS_RET_DNSERROR);
}
LM_INFO("looking up Domain itself: %.*s\n",domain->len, ZSW(domain->s));
ret = check_rule(domain,"D2P+sip:dom", 11, &stack);
if (ret == 1) {
LM_INFO("found a match on domain itself\n");
stack_to_avp(&stack);
return(DP_DDDS_RET_POSITIVE);
} else if (ret == 0) {
LM_INFO("no match on domain itself.\n");
stack_reset(&stack);
/* If we're in a recursive call, set the domain-replacement */
if ( rec_level > 0 ) {
stack_push(&stack, domain_replacement_name.s.s, (char *) domain->s);
stack.succeeded = 0;
}
} else {
return(DP_DDDS_RET_DNSERROR); /* actually: DB error */
}
LM_INFO("doing DDDS with %.*s\n",domain->len, ZSW(domain->s));
head = get_record(domain->s, T_NAPTR, RES_ONLY_TYPE);
if (head == 0) {
LM_NOTICE("no NAPTR record found for %.*s.\n",
domain->len, ZSW(domain->s));
return(DP_DDDS_RET_NOTFOUND);
}
LM_DBG("found the following NAPTRs: \n");
for (l = head; l; l = l->next) {
if (l->type != T_NAPTR) {
LM_DBG("found non-NAPTR record.\n");
continue; /*should never happen*/
}
naptr = (struct naptr_rdata*)l->rdata;
if (naptr == 0) {
LM_CRIT("null rdata\n");
continue;
}
LM_DBG("order %u, pref %u, flen %u, flags '%.*s', slen %u, "
"services '%.*s', rlen %u, regexp '%.*s', repl '%s'\n",
naptr->order, naptr->pref,
naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags),
naptr->services_len,
(int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len,
(int)(naptr->regexp_len), ZSW(naptr->regexp),
ZSW(naptr->repl)
);
}
LM_DBG("sorting...\n");
naptr_sort(&head);
for (l = head; l; l = l->next) {
if (l->type != T_NAPTR) continue; /*should never happen*/
naptr = (struct naptr_rdata*)l->rdata;
if (naptr == 0) {
LM_CRIT("null rdata\n");
continue;
}
LM_DBG("considering order %u, pref %u, flen %u, flags '%.*s', slen %u, "
"services '%.*s', rlen %u, regexp '%.*s', repl '%s'\n",
naptr->order, naptr->pref,
naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags),
naptr->services_len,
(int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len,
(int)(naptr->regexp_len), ZSW(naptr->regexp),
ZSW(naptr->repl)
);
/*
* New order? then we check whether the had success during the last one.
* If yes, we can leave the loop.
*/
if (last_order != naptr->order) {
last_order = naptr->order;
failed = 0;
if (stack_succeeded(&stack)) {
LM_INFO("we don't need to consider further orders "
"(starting with %d).\n",last_order);
break;
}
} else if (failed) {
LM_INFO("order %d has already failed.\n",last_order);
continue;
}
/*
* NAPTRs we don't care about
*/
if (!IS_D2PNAPTR(naptr))
continue;
/*
* once we've been here, don't return DP_DDDS_RET_NOTFOUND
*/
found_anything = 1;
next_naptr = NULL;
if (l->next && (l->next->type == T_NAPTR)) {
next_naptr = (struct naptr_rdata*)l->next->rdata;
}
/*
* Non-terminal?
*/
if ((naptr->services_len == 7) && !strncasecmp("D2P+SIP", naptr->services,7) && (naptr->flags_len == 0)){
LM_INFO("found non-terminal NAPTR\n");
/*
* This needs to be the only record with this order.
*/
if (next_naptr && (next_naptr->order == naptr->order) && IS_D2PNAPTR(next_naptr)) {
LM_ERR("non-terminal NAPTR needs to be the only one "
"with this order %.*s.\n", domain->len, ZSW(domain->s));
return(DP_DDDS_RET_DNSERROR);
}
newdomain.s = naptr->repl;
newdomain.len = strlen(naptr->repl);
ret = dp_can_connect_str(&newdomain, rec_level + 1);
if (ret == DP_DDDS_RET_POSITIVE) /* succeeded, we're done. */
return(ret);
if (ret == DP_DDDS_RET_NEGATIVE) /* found rules, did not work */
continue; /* look for more rules */
if (ret == DP_DDDS_RET_DNSERROR) /* errors during lookup */
return(ret); /* report them */
if (ret == DP_DDDS_RET_NOTFOUND) /* no entries in linked domain? */
return(ret); /* ok, fine. go with that */
continue; /* not reached */
}
/*
* wrong kind of terminal
*/
if ((naptr->flags_len != 1) || (tolower(naptr->flags[0]) != 'u')) {
LM_ERR("terminal NAPTR needs flag = 'u' and not '%.*s'.\n",
(int)naptr->flags_len, ZSW(naptr->flags));
/*
* It's not that clear what we should do now: Ignore this records or regard it as failed.
* We go with "ignore" for now.
*/
continue;
}
if (parse_naptr_regexp(&(naptr->regexp[0]), naptr->regexp_len,
&pattern, &replacement) < 0) {
LM_ERR("parsing of NAPTR regexp failed\n");
continue;
}
result.s = &(uri[0]);
result.len = MAX_URI_SIZE;
/* Avoid making copies of pattern and replacement */
pattern.s[pattern.len] = (char)0;
replacement.s[replacement.len] = (char)0;
if (reg_replace(pattern.s, replacement.s, domain->s,
&result) < 0) {
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
LM_ERR("regexp replace failed\n");
continue;
}
LM_INFO("resulted in replacement: '%.*s'\n", result.len, ZSW(result.s));
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
ret = check_rule(&result,naptr->services,naptr->services_len, &stack);
if (ret == 1) {
LM_INFO("positive return\n");
} else if (ret == 0) {
LM_INFO("check_rule failed.\n");
stack_reset(&stack);
/* If we're in a recursive call, set the domain-replacement */
if ( rec_level > 0 ) {
stack_push(&stack, domain_replacement_name.s.s, (char *) domain->s);
stack.succeeded = 0;
}
failed = 1;
} else {
return(DP_DDDS_RET_DNSERROR);
}
}
if (stack_succeeded(&stack)) {
LM_INFO("calling stack_to_avp.\n");
stack_to_avp(&stack);
return(DP_DDDS_RET_POSITIVE);
}
LM_INFO("returning %d.\n",
(found_anything ? DP_DDDS_RET_NEGATIVE : DP_DDDS_RET_NOTFOUND));
return( found_anything ? DP_DDDS_RET_NEGATIVE : DP_DDDS_RET_NOTFOUND );
}
/* get esgwri or ert information from contact header and save this in call cell
*/
int get_esgwri_ert_in_contact(char *contact_esgwri, ESCT *call_cell){
char *contact_routing_aux;
str pattern_contact_routing, replacement_contact_routing;
str pt_contact_routing;
int len_contact_routing;
char *contact_routing;
char *pt_aux;
char *p_aux;
char *srid_aux, *resn_aux, *npa_aux;
char *pt_a, *pt_b;
str pattern_contact_ert, replacement_contact_ert;
char *p = strstr(contact_esgwri, "P-Asserted-Identity");
len_contact_routing = p - contact_esgwri -1;
contact_routing = pkg_malloc(sizeof (char)*len_contact_routing);
if (contact_routing == NULL) {
LM_ERR("no more pkg memory\n");
return -1;
}
memset(contact_routing, 0, len_contact_routing);
p_aux = contact_esgwri;
p_aux++;
memcpy(contact_routing, p_aux, len_contact_routing-1 );
pkg_free(contact_esgwri);
contact_routing_aux = pkg_malloc(sizeof (char)*len_contact_routing);
if (contact_routing_aux == NULL) {
LM_ERR("no more pkg memory\n");
return -1;
}
memset(contact_routing_aux, 0,len_contact_routing);
pt_contact_routing.s = contact_routing_aux;
pt_contact_routing.len = len_contact_routing - 1;
pattern_contact_routing.s = "^(sips?):[+]*([-0-9]+)@";
pattern_contact_routing.len = strlen(pattern_contact_routing.s);
replacement_contact_routing.s = "\\2";
replacement_contact_routing.len = strlen(replacement_contact_routing.s);
if (reg_replace(pattern_contact_routing.s, replacement_contact_routing.s, contact_routing, &pt_contact_routing) == 1) {
LM_DBG ("TRANS REPLY ESGWRI %s \n",contact_routing);
call_cell->esgwri = contact_routing;
call_cell->disposition = "processes";
pkg_free(contact_routing_aux);
}else{
pattern_contact_ert.s = "^(sips?):([A-Z0-9.]*)@";
pattern_contact_ert.len = strlen(pattern_contact_ert.s);
replacement_contact_ert.s = "\\2";
replacement_contact_ert.len = strlen(replacement_contact_ert.s);
if (reg_replace(pattern_contact_ert.s, replacement_contact_ert.s, contact_routing, &pt_contact_routing) != 1) {
LM_ERR("****** PATTERN ERT NAO OK \n");
pkg_free(contact_routing_aux);
pkg_free(contact_routing);
return 0;
}
LM_DBG ("CONTEUDO TRANS REPLY ERT %.*s \n", pt_contact_routing.len, pt_contact_routing.s);
pt_aux = pt_contact_routing.s;
pt_a = strchr(pt_aux,'.');
int len_srid = pt_a - pt_contact_routing.s;
srid_aux = pkg_malloc(sizeof (char)*len_srid + 1);
if (srid_aux == NULL) {
LM_ERR("no more pkg memory\n");
return -1;
}
memcpy(srid_aux, pt_aux, len_srid);
srid_aux[len_srid] = 0;
pt_aux += len_srid + 1;
pt_b = strchr(pt_aux,'.');
int len_resn = pt_b - pt_aux ;
resn_aux = pkg_malloc(sizeof (char)*len_resn + 1);
if (resn_aux == NULL) {
LM_ERR("no more pkg memory\n");
return -1;
}
memcpy(resn_aux, pt_aux, len_resn);
resn_aux[len_resn] = 0;
pt_aux += len_resn + 1;
int len_npa = pt_contact_routing.len - len_srid - len_resn;
npa_aux = pkg_malloc(sizeof (char)*len_npa + 1);
if (npa_aux == NULL) {
LM_ERR("no more pkg memory\n");
return -1;
}
npa_aux[len_npa] = 0;
memcpy(npa_aux, pt_aux, len_npa);
LM_DBG ("CONTEUDO TRANS REPLY SRID %s \n",srid_aux);
LM_DBG ("CONTEUDO TRANS REPLY RESN %s \n",resn_aux);
LM_DBG ("CONTEUDO TRANS REPLY NPA %s \n",npa_aux);
int npa = atoi(npa_aux);
int resn = atoi(resn_aux);
int srid_len = strlen(srid_aux);
call_cell->ert_npa = npa;
call_cell->ert_resn = resn;
call_cell->ert_srid = pkg_malloc(sizeof (char)* srid_len + 1);
if (call_cell->ert_srid == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
strcpy(call_cell->ert_srid, srid_aux);
call_cell->ert_srid[srid_len] = 0;
call_cell->disposition = "processes";
pkg_free(contact_routing_aux);
pkg_free(contact_routing);
pkg_free(srid_aux);
pkg_free(resn_aux);
pkg_free(npa_aux);
}
return 1;
}
/*
* get parsed data extract from esrResponse and save in calls_eme struct:
* - source
* .organizationname
* .hostname
* .nenaid
* .contact
* .certuri
* - vpc
* .organizationname
* .hostname
* .nenaid
* .contact
* .certuri
* - esqk
* - callid
* - lro
* - result
* - datetimestamp
*/
int treat_parse_esrResponse(struct sip_msg *msg, ESCT *call_cell, PARSED *parsed, int proxy_role){
char *p;
int vsp_addr_len;
char *vsp_addr = "@vsp.com";
str pattern_lro, replacement_lro;
str pt_lro;
char *lro_aux;
call_cell->esgwri = empty;
call_cell->ert_srid = empty;
call_cell->ert_npa = 0;
call_cell->ert_resn = 0;
call_cell->esgw = empty;
call_cell->lro = empty;
call_cell->disposition = empty;
LM_DBG(" --- TREAT PARSE ESRRESPONSE...");
call_cell->source->organizationname = parsed->destination->organizationname;
call_cell->source->hostname = parsed->destination->hostname;
call_cell->source->nenaid = parsed->destination->nenaid;
call_cell->source->contact = parsed->destination->contact;
call_cell->source->certuri = parsed->destination->certuri;
call_cell->vpc->organizationname = parsed->vpc->organizationname;
call_cell->vpc->hostname = parsed->vpc->hostname;
call_cell->vpc->nenaid = parsed->vpc->nenaid;
call_cell->vpc->contact = parsed->vpc->contact;
call_cell->vpc->certuri = parsed->vpc->certuri;
call_cell->esqk = parsed->esqk;
call_cell->callid = parsed->callid;
call_cell->datetimestamp = parsed->datetimestamp;
call_cell->result = parsed->result;
if (parsed->esgwri != empty && strlen(parsed->esgwri) > 0) {
call_cell->esgwri = parsed->esgwri;
call_cell->ert_npa = 0;
call_cell->ert_resn = 0;
call_cell->ert_srid = "";
char *r = strstr(call_cell->esgwri, "@");
r++;
int tam_esgw = call_cell->esgwri + strlen(call_cell->esgwri) - r;
call_cell->esgw = pkg_malloc(sizeof (char)*tam_esgw + 1);
if (call_cell->esgw == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
memcpy(call_cell->esgw, r, tam_esgw);
call_cell->esgw[tam_esgw] = 0;
LM_DBG(" --- ESGW:%s \n", call_cell->esgw);
if (parsed->ert->selectiveRoutingID != empty)
pkg_free(parsed->ert->selectiveRoutingID);
if (parsed->ert->routingESN != empty)
pkg_free(parsed->ert->routingESN);
if (parsed->ert->npa != empty)
pkg_free(parsed->ert->npa);
} else {
if ((parsed->ert->selectiveRoutingID != empty) && (parsed->ert->routingESN != empty) && (parsed->ert->npa != empty)) {
int npa = atoi(parsed->ert->npa);
int resn = atoi(parsed->ert->routingESN);
call_cell->ert_npa = npa;
call_cell->ert_resn = resn;
call_cell->ert_srid = parsed->ert->selectiveRoutingID;
if (proxy_role == 4){
// in opensips as redirect role, consider esgwri as joint selectiveRoutingID + routingESN + npa + @vsp_address in contact headers in 300 response
// get source ip address that send INVITE
vsp_addr = ip_addr2a(&msg->rcv.src_ip);
vsp_addr_len = strlen(vsp_addr);
int esgw_len = strlen(parsed->ert->selectiveRoutingID) + strlen(parsed->ert->routingESN) + strlen(parsed->ert->npa) + vsp_addr_len + 4;
p = pkg_malloc(sizeof (char)*esgw_len);
if (p == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
call_cell->esgwri = p;
memcpy(p, parsed->ert->selectiveRoutingID, strlen(parsed->ert->selectiveRoutingID));
p += strlen(parsed->ert->selectiveRoutingID);
*p = '.';
p++;
memcpy(p, parsed->ert->routingESN, strlen(parsed->ert->routingESN));
p += strlen(parsed->ert->routingESN);
*p = '.';
p++;
memcpy(p, parsed->ert->npa, strlen(parsed->ert->npa));
p += strlen(parsed->ert->npa);
*p = '@';
p++;
memcpy(p, vsp_addr, vsp_addr_len);
p += vsp_addr_len;
*p = 0;
}else{
call_cell->esgwri = "";
}
pkg_free(parsed->ert->routingESN);
pkg_free(parsed->ert->npa);
}
}
if (parsed-> lro!= empty ) {
// extarct only contigency number in lro
LM_DBG( "LRO %s \n", parsed-> lro);
int len_lro = strlen(parsed->lro);
lro_aux = pkg_malloc(sizeof (char)*len_lro + 1);
if (lro_aux == NULL) {
LM_ERR("no more pkg memory\n");
return -1;
}
memset(lro_aux, 0, len_lro + 1);
pt_lro.s = lro_aux;
pt_lro.len = len_lro;
pattern_lro.s = "(tel:)*[+]*([-0-9]+)";
pattern_lro.len = strlen(pattern_lro.s);
replacement_lro.s = "\\2";
replacement_lro.len = strlen(replacement_lro.s);
if (reg_replace(pattern_lro.s, replacement_lro.s, parsed->lro, &pt_lro) != 1) {
LM_ERR("****** PATTERN LRO NAO OK \n");
pkg_free(lro_aux);
goto end;
}
pt_lro.len = strlen(pt_lro.s);
LM_DBG("****** PATTERN LRO OK II %.*s\n",pt_lro.len,pt_lro.s);
call_cell->lro = pkg_malloc(sizeof (char)*pt_lro.len+1);
if (call_cell->lro == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
memcpy(call_cell->lro, pt_lro.s, pt_lro.len);
call_cell->lro[pt_lro.len] = 0;
pkg_free(lro_aux);
pkg_free(parsed->lro);
}
end:
pkg_free(parsed->ert);
pkg_free(parsed->vpc);
pkg_free(parsed->destination);
pkg_free(parsed);
return 1;
}
int enum_query_2(struct sip_msg* _msg, char* _suffix, char* _service)
{
char *user_s;
int user_len, i, j, first;
char name[MAX_DOMAIN_SIZE];
char uri[MAX_URI_SIZE];
char new_uri[MAX_URI_SIZE];
unsigned int priority, curr_prio;
qvalue_t q;
struct rdata* head;
struct rdata* l;
struct naptr_rdata* naptr;
str pattern, replacement, result, new_result;
char string[17];
str *suffix, *service;
suffix = (str*)_suffix;
service = (str*)_service;
if (parse_sip_msg_uri(_msg) < 0) {
LOG(L_ERR, "enum_query(): uri parsing failed\n");
return -1;
}
if (is_e164(&(_msg->parsed_uri.user)) == -1) {
LOG(L_ERR, "enum_query(): uri user is not an E164 number\n");
return -1;
}
user_s = _msg->parsed_uri.user.s;
user_len = _msg->parsed_uri.user.len;
memcpy(&(string[0]), user_s, user_len);
string[user_len] = (char)0;
j = 0;
for (i = user_len - 1; i > 0; i--) {
name[j] = user_s[i];
name[j + 1] = '.';
j = j + 2;
}
memcpy(name + j, suffix->s, suffix->len + 1);
head = get_record(name, T_NAPTR);
if (head == 0) {
DBG("enum_query(): No NAPTR record found for %s.\n", name);
return -1;
}
naptr_sort(&head);
q = MAX_Q - 10;
curr_prio = 0;
first = 1;
for (l = head; l; l = l->next) {
if (l->type != T_NAPTR) continue; /*should never happen*/
naptr = (struct naptr_rdata*)l->rdata;
if (naptr == 0) {
LOG(L_CRIT, "enum_query: BUG: null rdata\n");
continue;
}
DBG("enum_query(): order %u, pref %u, flen %u, flags '%.*s', slen %u, "
"services '%.*s', rlen %u, regexp '%.*s'\n", naptr->order, naptr->pref,
naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags),
naptr->services_len,
(int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len,
(int)(naptr->regexp_len), ZSW(naptr->regexp));
if (sip_match(naptr, service) == 0) continue;
if (parse_naptr_regexp(&(naptr->regexp[0]), naptr->regexp_len,
&pattern, &replacement) < 0) {
LOG(L_ERR, "enum_query(): parsing of NAPTR regexp failed\n");
continue;
}
result.s = &(uri[0]);
result.len = MAX_URI_SIZE;
/* Avoid making copies of pattern and replacement */
pattern.s[pattern.len] = (char)0;
replacement.s[replacement.len] = (char)0;
if (reg_replace(pattern.s, replacement.s, &(string[0]),
&result) < 0) {
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
LOG(L_ERR, "enum_query(): regexp replace failed\n");
continue;
}
DBG("enum_query(): resulted in replacement: '%.*s'\n",
result.len, ZSW(result.s));
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
if (param.len > 0) {
if (result.len + param.len > MAX_URI_SIZE - 1) {
LOG(L_ERR, "ERROR: enum_query(): URI is too long\n");
continue;
}
new_result.s = &(new_uri[0]);
new_result.len = MAX_URI_SIZE;
if (add_uri_param(&result, ¶m, &new_result) == 0) {
LOG(L_ERR, "ERROR: enum_query(): Parsing of URI failed\n");
continue;
}
if (new_result.len > 0) {
result = new_result;
}
}
if (first) {
if (rewrite_uri(_msg, &result) == -1) {
goto done;
}
set_ruri_q(q);
first = 0;
curr_prio = ((naptr->order) << 16) + naptr->pref;
} else {
priority = ((naptr->order) << 16) + naptr->pref;
if (priority > curr_prio) {
q = q - 10;
curr_prio = priority;
}
if (append_branch(_msg, &result, 0, q, 0, 0) == -1) {
goto done;
}
}
}
done:
free_rdata_list(head);
return first ? -1 : 1;
}
/*
* - source
* .organizationname
* .hostname
* .nenaid
* .contact
* .certuri
* - vpc
* .organizationname
* .hostname
* .nenaid
* .contact
* .certuri
* - esqk
* - callid
* - lro
* - result
* - datetimestamp
*/
int treat_parse_esrResponse(struct sip_msg *msg, ESCT *call_cell , NENA *call_cell_vpc, NENA *call_cell_source, PARSED *parsed, int proxy_role){
char *p;
int vsp_addr_len;
char *vsp_addr = "@vsp.com";
str pattern_lro, replacement_lro;
str pt_lro;
char *lro_aux;
call_cell->vpc = call_cell_vpc;
call_cell->source = call_cell_source;
call_cell_source->organizationname = empty;
call_cell_source->hostname = empty;
call_cell_source->nenaid = empty;
call_cell_source->contact = empty;
call_cell_source->certuri = empty;
call_cell_vpc->organizationname = empty;
call_cell_vpc->hostname = empty;
call_cell_vpc->nenaid = empty;
call_cell_vpc->contact = empty;
call_cell_vpc->certuri = empty;
call_cell->esgwri = empty;
call_cell->ert_srid = empty;
call_cell->ert_npa = 0;
call_cell->ert_resn = 0;
call_cell->esqk = empty;
call_cell->esgw = empty;
call_cell->lro = empty;
call_cell->disposition = empty;
call_cell->datetimestamp = empty;
LM_DBG(" --- TREAT PARSE ESRRESPONSE...");
if (parsed->destination->organizationname != NULL) {
char* field = pkg_malloc(sizeof (char)*strlen(parsed->destination->organizationname)+1);
if (field == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
strcpy(field, parsed->destination->organizationname);
call_cell_source->organizationname = field;
}
if (parsed->destination->hostname != NULL ) {
char* field = pkg_malloc(sizeof (char)*strlen(parsed->destination->hostname)+1);
if (field == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
strcpy(field, parsed->destination->hostname);
call_cell_source->hostname = field;
}
if (parsed->destination->nenaid != NULL ) {
char* field = pkg_malloc(sizeof (char)*strlen(parsed->destination->nenaid)+1);
if (field == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
strcpy(field, parsed->destination->nenaid);
call_cell_source->nenaid = field;
}
if (parsed->destination->contact != NULL ) {
char* field = pkg_malloc(sizeof (char)*strlen(parsed->destination->contact)+1);
if (field == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
strcpy(field, parsed->destination->contact);
call_cell_source->contact = field;
}
if (parsed->destination->certuri != NULL ) {
char* field = pkg_malloc(sizeof (char)*strlen(parsed->destination->certuri)+1);
if (field == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
strcpy(field, parsed->destination->certuri);
call_cell_source->certuri = field;
}
if (parsed->vpc->organizationname != NULL ) {
char* field = pkg_malloc(sizeof (char)*strlen(parsed->vpc->organizationname)+1);
if (field == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
strcpy(field, parsed->vpc->organizationname);
call_cell_vpc->organizationname = field;
}
if (parsed->vpc->hostname != NULL ) {
char* field = pkg_malloc(sizeof (char)*strlen(parsed->vpc->hostname)+1);
if (field == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
strcpy(field, parsed->vpc->hostname);
call_cell_vpc->hostname = field;
}
if (parsed->vpc->nenaid != NULL ) {
char* field = pkg_malloc(sizeof (char)*strlen(parsed->vpc->nenaid)+1);
if (field == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
strcpy(field, parsed->vpc->nenaid);
call_cell_vpc->nenaid = field;
}
if (parsed->vpc->contact != NULL ) {
char* field = pkg_malloc(sizeof (char)*strlen(parsed->vpc->contact)+1);
if (field == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
strcpy(field, parsed->vpc->contact);
call_cell_vpc->contact = field;
}
if (parsed->vpc->certuri != NULL ) {
char* field = pkg_malloc(sizeof (char)*strlen(parsed->vpc->certuri)+1);
if (field == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
strcpy(field, parsed->vpc->certuri);
call_cell_vpc->certuri = field;
}
if (parsed-> esqk!= NULL ) {
call_cell->esqk = pkg_malloc(sizeof (char)*strlen(parsed->esqk)+1);
if (call_cell->esqk == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
strcpy(call_cell->esqk, parsed->esqk);
}
call_cell->callid = pkg_malloc(sizeof (char)*strlen(parsed->callid)+1);
if (call_cell->callid == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
strcpy(call_cell->callid, parsed->callid);
if (parsed->esgwri != NULL && strlen(parsed->esgwri) > 0) {
call_cell->esgwri = pkg_malloc(sizeof (char)*strlen(parsed->esgwri));
if (call_cell->esgwri == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
strcpy(call_cell->esgwri, parsed->esgwri);
call_cell->ert_npa = 0;
call_cell->ert_resn = 0;
call_cell->ert_srid = "";
call_cell->esgw = strstr(call_cell->esgwri, "@");
call_cell->esgw ++;
} else {
if ((parsed->ert->selectiveRoutingID != NULL) && (parsed->ert->routingESN != NULL) && (parsed->ert->npa != NULL)) {
int npa = atoi(parsed->ert->npa);
int resn = atoi(parsed->ert->routingESN);
int srid_len = strlen(parsed->ert->selectiveRoutingID);
call_cell->ert_npa = npa;
call_cell->ert_resn = resn;
call_cell->ert_srid = pkg_malloc(sizeof (char)* srid_len + 1);
if (call_cell->ert_srid == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
strcpy(call_cell->ert_srid, parsed->ert->selectiveRoutingID);
//call_cell->ert_srid[srid_len] = 0;
if (proxy_role == 4){
// get source ip address that send INVITE
vsp_addr = ip_addr2a(&msg->rcv.src_ip);
vsp_addr_len = strlen(vsp_addr);
int esgw_len = strlen(parsed->ert->selectiveRoutingID) + strlen(parsed->ert->routingESN) + strlen(parsed->ert->npa) + vsp_addr_len + 4;
p = pkg_malloc(sizeof (char)*esgw_len);
if (p == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
call_cell->esgwri = p;
memcpy(p, parsed->ert->selectiveRoutingID, strlen(parsed->ert->selectiveRoutingID));
p += strlen(parsed->ert->selectiveRoutingID);
*p = '.';
p++;
memcpy(p, parsed->ert->routingESN, strlen(parsed->ert->routingESN));
p += strlen(parsed->ert->routingESN);
*p = '.';
p++;
memcpy(p, parsed->ert->npa, strlen(parsed->ert->npa));
p += strlen(parsed->ert->npa);
*p = '@';
p++;
memcpy(p, vsp_addr, vsp_addr_len);
p += vsp_addr_len;
*p = 0;
}else{
call_cell->esgwri = "";
}
}
}
if (parsed-> lro!= NULL ) {
LM_DBG( "LRO %s \n", parsed-> lro);
int len_lro = strlen(parsed->lro);
lro_aux = pkg_malloc(sizeof (char)*len_lro + 1);
if (lro_aux == NULL) {
LM_ERR("no more pkg memory\n");
return -1;
}
memset(lro_aux, 0, len_lro + 1);
pt_lro.s = lro_aux;
pt_lro.len = len_lro;
pattern_lro.s = "(tel:)*[+]*([-0-9]+)";
pattern_lro.len = strlen(pattern_lro.s);
replacement_lro.s = "\\2";
replacement_lro.len = strlen(replacement_lro.s);
if (reg_replace(pattern_lro.s, replacement_lro.s, parsed->lro, &pt_lro) != 1) {
LM_ERR("****** PATTERN LRO NAO OK \n");
pkg_free(lro_aux);
return -1;
}
pt_lro.len = strlen(pt_lro.s);
LM_DBG("****** PATTERN LRO OK II %.*s\n",pt_lro.len,pt_lro.s);
call_cell->lro = pkg_malloc(sizeof (char)*pt_lro.len+1);
if (call_cell->lro == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
memcpy(call_cell->lro, pt_lro.s, pt_lro.len);
pkg_free(lro_aux);
}
if (parsed->datetimestamp != NULL ) {
call_cell->datetimestamp = pkg_malloc(sizeof (char)*strlen(parsed->datetimestamp)+1);
if (call_cell->datetimestamp == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
strcpy(call_cell->datetimestamp, parsed->datetimestamp);
}
call_cell->result = pkg_malloc(sizeof (char)*strlen(parsed->result)+1);
if (call_cell->result == NULL) {
LM_ERR("--------------------------------------------------no more shm memory\n");
return -1;
}
strcpy(call_cell->result, parsed->result);
return 1;
}
