int pres_process_body(publ_info_t* publ, str** fin_body, int ver, str** tuple_param)
{
xmlDocPtr doc= NULL;
xmlNodePtr node= NULL;
char* tuple_id= NULL, *person_id= NULL;
int tuple_id_len= 0;
char buf[50];
str* body= NULL;
int alloc_tuple= 0;
str* tuple= NULL;
doc= xmlParseMemory(publ->body->s, publ->body->len );
if(doc== NULL)
{
LM_ERR("while parsing xml memory\n");
goto error;
}
node= xmlDocGetNodeByName(doc, "tuple", NULL);
if(node == NULL)
{
LM_ERR("while extracting tuple node\n");
goto error;
}
tuple= *(tuple_param);
tuple_id= xmlNodeGetAttrContentByName(node, "id");
if(tuple_id== NULL)
{
if(tuple== NULL) // generate a tuple_id
{
tuple_id= buf;
tuple_id_len= sprintf(tuple_id, "%p", publ);
tuple_id[tuple_id_len]= '\0';
tuple=(str*)pkg_malloc(sizeof(str));
if(tuple== NULL)
{
LM_ERR("No more memory\n");
goto error;
}
tuple->s= (char*)pkg_malloc(tuple_id_len* sizeof(char));
if(tuple->s== NULL)
{
LM_ERR("NO more memory\n");
goto error;
}
memcpy(tuple->s, tuple_id, tuple_id_len);
tuple->len= tuple_id_len;
*tuple_param= tuple;
alloc_tuple= 1;
LM_DBG("allocated tuple_id\n\n");
}
else
{
tuple_id= buf;
tuple_id_len= tuple->len;
memcpy(tuple_id, tuple->s, tuple_id_len);
tuple_id[tuple_id_len]= '\0';
}
/* add tuple id */
if(!xmlNewProp(node, BAD_CAST "id", BAD_CAST tuple_id))
{
LM_ERR("while extracting xml"
" node\n");
goto error;
}
}
else
{
if(tuple== NULL)
{
strcpy(buf, tuple_id);
xmlFree(tuple_id);
tuple_id= buf;
tuple_id_len= strlen(tuple_id);
tuple=(str*)pkg_malloc(sizeof(str));
if(tuple== NULL)
{
LM_ERR("No more memory\n");
goto error;
}
tuple->s= (char*)pkg_malloc(tuple_id_len* sizeof(char));
if(tuple->s== NULL)
{
LM_ERR("NO more memory\n");
goto error;
}
memcpy(tuple->s, tuple_id, tuple_id_len);
tuple->len= tuple_id_len;
*tuple_param= tuple;
alloc_tuple= 1;
}
}
node= xmlDocGetNodeByName(doc, "person", NULL);
if(node)
{
LM_DBG("found person node\n");
person_id= xmlNodeGetAttrContentByName(node, "id");
if(person_id== NULL)
{
if(!xmlNewProp(node, BAD_CAST "id", BAD_CAST tuple_id))
{
LM_ERR("while extracting xml"
" node\n");
goto error;
}
}
else
{
xmlFree(person_id);
}
}
body= (str*)pkg_malloc(sizeof(str));
if(body== NULL)
{
LM_ERR("NO more memory left\n");
goto error;
}
memset(body, 0, sizeof(str));
xmlDocDumpFormatMemory(doc,(xmlChar**)(void*)&body->s, &body->len, 1);
if(body->s== NULL || body->len== 0)
{
LM_ERR("while dumping xml format\n");
goto error;
}
xmlFreeDoc(doc);
doc= NULL;
*fin_body= body;
xmlMemoryDump();
xmlCleanupParser();
return 1;
error:
if(doc)
xmlFreeDoc(doc);
if(body)
pkg_free(body);
if(tuple && alloc_tuple)
{
if(tuple->s)
pkg_free(tuple->s);
pkg_free(tuple);
tuple= NULL;
}
return -1;
}
xmlNodePtr get_rule_node(subs_t* subs, xmlDocPtr xcap_tree)
{
str w_uri = {0, 0};
char* id = NULL, *domain = NULL, *time_cont= NULL;
int apply_rule = -1;
xmlNodePtr ruleset_node = NULL, node1= NULL, node2= NULL;
xmlNodePtr cond_node = NULL, except_node = NULL;
xmlNodePtr identity_node = NULL;
xmlNodePtr iden_child;
xmlNodePtr validity_node, time_node;
time_t t_init, t_fin, t;
int valid= 0;
uandd_to_uri(subs->from_user, subs->from_domain, &w_uri);
if (w_uri.s == NULL) {
LM_ERR("while creating uri\n");
return NULL;
}
ruleset_node = xmlDocGetNodeByName(xcap_tree, "ruleset", NULL);
if (ruleset_node == NULL) {
LM_DBG("ruleset_node NULL\n");
goto error;
}
for (node1 = ruleset_node->children; node1; node1 = node1->next) {
if (xmlStrcasecmp(node1->name, (unsigned char*)"text") == 0)
continue;
/* process conditions */
LM_DBG("node1->name= %s\n", node1->name);
cond_node = xmlNodeGetChildByName(node1, "conditions");
if(cond_node == NULL) {
LM_DBG("cond node NULL\n");
goto error;
}
LM_DBG("cond_node->name= %s\n", cond_node->name);
validity_node = xmlNodeGetChildByName(cond_node, "validity");
if (validity_node != NULL) {
LM_DBG("found validity tag\n");
t= time(NULL);
/* search all from-until pair */
for (time_node = validity_node->children; time_node;
time_node = time_node->next) {
if (xmlStrcasecmp(time_node->name, (unsigned char*)"from")!= 0)
continue;
time_cont= (char*)xmlNodeGetContent(time_node);
t_init= xml_parse_dateTime(time_cont);
xmlFree(time_cont);
if (t_init< 0) {
LM_ERR("failed to parse xml dateTime\n");
goto error;
}
if (t< t_init) {
LM_DBG("the lower time limit is not respected\n");
continue;
}
time_node= time_node->next;
while (1) {
if (time_node == NULL) {
LM_ERR("bad formatted xml doc:until child not found in"
" validity pair\n");
goto error;
}
if( xmlStrcasecmp(time_node->name,
(unsigned char*)"until")== 0)
break;
time_node= time_node->next;
}
time_cont = (char*)xmlNodeGetContent(time_node);
t_fin= xml_parse_dateTime(time_cont);
xmlFree(time_cont);
if (t_fin< 0) {
LM_ERR("failed to parse xml dateTime\n");
goto error;
}
if (t <= t_fin) {
LM_DBG("the rule is active at this time\n");
valid= 1;
}
}
if (!valid) {
LM_DBG("the rule is not active at this time\n");
continue;
}
}
identity_node = xmlNodeGetChildByName(cond_node, "identity");
if (identity_node == NULL) {
LM_ERR("didn't find identity tag\n");
goto error;
}
iden_child = xmlNodeGetChildByName(identity_node, "one");
if(iden_child) {
for (node2 = identity_node->children; node2; node2 = node2->next) {
if(xmlStrcasecmp(node2->name, (unsigned char*)"one")!= 0)
continue;
id = xmlNodeGetAttrContentByName(node2, "id");
if(id== NULL) {
LM_ERR("while extracting attribute\n");
goto error;
}
if ((strlen(id)== w_uri.len &&
(strncmp(id, w_uri.s, w_uri.len)==0))) {
apply_rule = 1;
xmlFree(id);
break;
}
xmlFree(id);
}
}
/* search for many node*/
iden_child = xmlNodeGetChildByName(identity_node, "many");
if (iden_child) {
domain = NULL;
for (node2 = identity_node->children; node2; node2 = node2->next) {
if (xmlStrcasecmp(node2->name, (unsigned char*)"many") != 0)
continue;
domain = xmlNodeGetAttrContentByName(node2, "domain");
if(domain == NULL) {
LM_DBG("No domain attribute to many\n");
} else {
LM_DBG("<many domain= %s>\n", domain);
if((strlen(domain)!= subs->from_domain.len &&
strncmp(domain, subs->from_domain.s,
subs->from_domain.len) )) {
xmlFree(domain);
continue;
}
}
xmlFree(domain);
apply_rule = 1;
if (node2->children == NULL) /* there is no exception */
break;
for (except_node = node2->children; except_node;
except_node= except_node->next) {
if(xmlStrcasecmp(except_node->name,
(unsigned char*)"except"))
continue;
id = xmlNodeGetAttrContentByName(except_node, "id");
if (id != NULL) {
if((strlen(id)- 1== w_uri.len &&
(strncmp(id, w_uri.s, w_uri.len)==0))) {
xmlFree(id);
apply_rule = 0;
break;
}
xmlFree(id);
} else {
domain = NULL;
domain = xmlNodeGetAttrContentByName(except_node,
"domain");
if(domain!=NULL) {
LM_DBG("Found except domain= %s\n- strlen(domain)= %d\n",
domain, (int)strlen(domain));
if (strlen(domain)==subs->from_domain.len &&
(strncmp(domain,subs->from_domain.s ,
subs->from_domain.len)==0)) {
LM_DBG("except domain match\n");
xmlFree(domain);
apply_rule = 0;
break;
}
xmlFree(domain);
}
}
}
if (apply_rule == 1) /* if a match was found no need to keep searching*/
break;
}
}
if (apply_rule ==1)
break;
}
LM_DBG("apply_rule= %d\n", apply_rule);
if(w_uri.s!=NULL)
pkg_free(w_uri.s);
if( !apply_rule || !node1)
return NULL;
return node1;
error:
if(w_uri.s)
pkg_free(w_uri.s);
return NULL;
}
str* agregate_xmls(str* pres_user, str* pres_domain, str** body_array, int n)
{
int i, j= 0, append ;
xmlNodePtr p_root= NULL, new_p_root= NULL ;
xmlDocPtr* xml_array ;
xmlNodePtr node = NULL;
xmlNodePtr add_node = NULL ;
str *body= NULL;
char* id= NULL, *tuple_id = NULL;
xml_array = (xmlDocPtr*)pkg_malloc( (n+2)*sizeof(xmlDocPtr));
if(xml_array== NULL)
{
LM_ERR("while alocating memory");
return NULL;
}
memset(xml_array, 0, (n+2)*sizeof(xmlDocPtr)) ;
for(i=0; i<n; i++)
{
if(body_array[i] == NULL )
continue;
xml_array[j] = NULL;
xml_array[j] = xmlParseMemory( body_array[i]->s, body_array[i]->len );
if( xml_array[j]== NULL)
{
LM_ERR("while parsing xml body message\n");
goto error;
}
j++;
}
if(j== 0) /* no body */
{
if(xml_array)
pkg_free(xml_array);
return NULL;
}
j--;
p_root = xmlDocGetNodeByName( xml_array[j], "presence", NULL);
if(p_root ==NULL)
{
LM_ERR("while geting the xml_tree root\n");
goto error;
}
for(i= j-1; i>=0; i--)
{
new_p_root= xmlDocGetNodeByName( xml_array[i], "presence", NULL);
if(new_p_root ==NULL)
{
LM_ERR("while geting the xml_tree root\n");
goto error;
}
append= 1;
node= xmlNodeGetChildByName(new_p_root, "tuple");
if(node != NULL)
{
tuple_id= xmlNodeGetAttrContentByName(node, "id");
if(tuple_id== NULL)
{
LM_ERR("while extracting tuple id\n");
goto error;
}
for (node = p_root->children; node!=NULL; node = node->next)
{
if( xmlStrcasecmp(node->name,(unsigned char*)"text")==0)
continue;
if( xmlStrcasecmp(node->name,(unsigned char*)"tuple")==0)
{
id = xmlNodeGetAttrContentByName(node, "id");
if(id== NULL)
{
LM_ERR("while extracting tuple id\n");
goto error;
}
if(xmlStrcasecmp((unsigned char*)tuple_id,
(unsigned char*)id )== 0)
{
append = 0;
xmlFree(id);
break;
}
xmlFree(id);
}
}
xmlFree(tuple_id);
tuple_id= NULL;
}
if(append)
{
for(node= new_p_root->children; node; node= node->next)
{
add_node= xmlCopyNode(node, 1);
if(add_node== NULL)
{
LM_ERR("while copying node\n");
goto error;
}
if(xmlAddChild(p_root, add_node)== NULL)
{
LM_ERR("while adding child\n");
goto error;
}
}
}
}
body = (str*)pkg_malloc(sizeof(str));
if(body == NULL)
{
ERR_MEM(PKG_MEM_STR);
}
xmlDocDumpFormatMemory(xml_array[j],(xmlChar**)(void*)&body->s,
&body->len, 1);
for(i=0; i<=j; i++)
{
if(xml_array[i]!=NULL)
xmlFreeDoc( xml_array[i]);
}
if(xml_array!=NULL)
pkg_free(xml_array);
xmlCleanupParser();
xmlMemoryDump();
return body;
error:
if(xml_array!=NULL)
{
for(i=0; i<=j; i++)
{
if(xml_array[i]!=NULL)
xmlFreeDoc( xml_array[i]);
}
pkg_free(xml_array);
}
if(tuple_id)
xmlFree(tuple_id);
if(body)
pkg_free(body);
return NULL;
}
static int load_scenario(b2b_scenario_t** scenario_list,char* filename)
{
xmlDocPtr doc;
xmlNodePtr node;
b2b_scenario_t* scenario = NULL;
str attr;
xmlNodePtr rules_node, rule_node, request_node;
int request_id = 0;
b2b_rule_t* rule_struct = NULL;
doc = xmlParseFile(filename);
if(doc == NULL)
{
LM_ERR("Failed to parse xml file\n");
return -1;
}
scenario = (b2b_scenario_t*)pkg_malloc(sizeof(b2b_scenario_t));
if(scenario == NULL)
{
LM_ERR("No more private memory\n");
xmlFreeDoc(doc);
return -1;
}
memset(scenario, 0, sizeof(b2b_scenario_t));
/* analyze the scenario document and descompose so that
* applying it will be more efficient */
/* extract scenario_id and param no */
scenario->id.s = (char*)xmlNodeGetAttrContentByName(doc->children, "id");
if(scenario->id.s == NULL)
{
LM_ERR("XML scenario document not well formed. No id attribute found"
" for root node\n");
pkg_free(scenario);
return -1;
}
scenario->id.len = strlen(scenario->id.s);
LM_DBG("Loaded scenario with id = [%.*s]\n", scenario->id.len, scenario->id.s);
attr.s = (char*)xmlNodeGetAttrContentByName(doc->children, "param");
if(attr.s == NULL)
{
LM_ERR("XML scenario document not well formed. No id attribute found"
" for root node\n");
return -1;
}
attr.len = strlen(attr.s);
if( str2int(&attr, &scenario->param_no) < 0)
{
LM_ERR("Failed to parse id attribute for scenario node. It must be an integer.\n");
xmlFree(attr.s);
pkg_free(scenario);
return -1;
}
xmlFree(attr.s);
/* extract init node */
scenario->init_node = xmlDocGetNodeByName(doc, "init", NULL);
if(scenario->init_node == NULL)
{
LM_ERR("Wrong formatted xml doc. Didn't find an init node\n");
goto error;
}
node = xmlNodeGetChildByName(scenario->init_node, "use_init_sdp");
if(node)
{
scenario->use_init_sdp = 1;
}
/* go through the rules */
node = xmlDocGetNodeByName(doc, "rules", NULL);
if(node == NULL)
{
LM_DBG("No rules defined\n");
goto done;
}
rules_node = xmlNodeGetChildByName(node, "request");
if(rules_node == NULL)
{
LM_DBG("No request rules defined\n");
goto after_req_rules;
}
for(request_node= rules_node->children; request_node; request_node = request_node->next)
{
if(xmlStrcasecmp(request_node->name, (unsigned char*)"text") == 0)
continue;
attr.s = (char*)request_node->name;
attr.len = strlen(attr.s);
request_id = b2b_get_request_id(&attr);
if(request_id < 0)
{
LM_ERR("Bad scenario document. A rule defined for a not supported"
" request type [%s]\n", request_node->name);
goto error;
}
for(rule_node= request_node->children; rule_node; rule_node = rule_node->next)
{
if(xmlStrcasecmp(rule_node->name, (unsigned char*)"rule")!= 0)
continue;
rule_struct = (b2b_rule_t*)pkg_malloc(sizeof(b2b_rule_t));
if(rule_struct == NULL)
{
LM_ERR("No more memory\n");
goto error;
}
memset(rule_struct, 0, sizeof(b2b_rule_t));
rule_struct->next = scenario->request_rules[request_id];
scenario->request_rules[request_id] = rule_struct;
attr.s = (char*)xmlNodeGetAttrContentByName(rule_node, "id");
if(attr.s == NULL)
{
LM_ERR("Bad scenario document. No id attribute for 'rule' node\n");
goto error;
}
attr.len = strlen(attr.s);
if(str2int(&attr, &rule_struct->id)< 0)
{
LM_ERR("Bad scenario document. rules_no subschild for request rule not an integer\n");
xmlFree(attr.s);
goto error;
}
xmlFree(attr.s);
rule_struct->cond_state = -1;
/* extract conditional state if present */
rule_struct->cond_node = xmlNodeGetChildByName(rule_node, "condition");
if(rule_struct->cond_node)
{
/* extract the condition state if any */
attr.s = (char*)xmlNodeGetNodeContentByName(rule_struct->cond_node, "state", NULL);
if(attr.s)
{
attr.len = strlen(attr.s);
if(str2int(&attr, (unsigned int*)&rule_struct->cond_state)< 0)
{
LM_ERR("Bad scenario. Cond state must be an integer [%s]\n",attr.s);
xmlFree(attr.s);
goto error;
}
xmlFree(attr.s);
}
}
node = xmlNodeGetChildByName(rule_node, "action");
if(node == NULL)
{
LM_ERR("Bad scenario document. A rule needs an action node\n");
goto error;
}
rule_struct->action_node = node;
}
}
after_req_rules:
/* TODO - Analyze if there are actions for replies */
LM_DBG("scenario_id = %.*s\n", scenario->id.len, scenario->id.s);
done:
scenario->doc = doc;
scenario->next = *scenario_list;
*scenario_list = scenario;
return 0;
error:
if(doc)
xmlFree(doc);
if(scenario)
{
int i;
b2b_rule_t* prev;
for(i = 0; i< B2B_METHODS_NO; i++)
{
rule_struct = scenario->request_rules[i];
while(rule_struct)
{
prev = rule_struct;
rule_struct = rule_struct->next;
pkg_free(prev);
}
}
rule_struct = scenario->reply_rules;
while(rule_struct)
{
prev = rule_struct;
rule_struct = rule_struct->next;
pkg_free(prev);
}
if(scenario->id.s)
xmlFree(scenario->id.s);
pkg_free(scenario);
}
return -1;
}
int parse_pidf(char *pidf_body, str *contact_str, str *basic_str, str *status_str,
str *location_str, str *site_str, str *floor_str, str *room_str,
double *xp, double *yp, double *radiusp,
str *packet_loss_str, double *priorityp, time_t *expiresp,
int *prescapsp)
{
int flags = 0;
xmlDocPtr doc = NULL;
xmlNodePtr presenceNode = NULL;
xmlNodePtr prescapsNode = NULL;
char *presence = NULL;
char *sipuri = NULL;
char *contact = NULL;
char *basic = NULL;
char *status = NULL;
char *location = NULL;
char *site = NULL;
char *floor = NULL;
char *room = NULL;
char *x = NULL;
char *y = NULL;
char *radius = NULL;
char *packet_loss = NULL;
char *priority_str = NULL;
char *expires_str = NULL;
int prescaps = 0;
doc = event_body_parse(pidf_body);
if (!doc) {
return flags;
}
presenceNode = xmlDocGetNodeByName(doc, "presence", NULL);
presence = xmlDocGetNodeContentByName(doc, "presence", NULL);
contact = xmlDocGetNodeContentByName(doc, "contact", NULL);
basic = xmlDocGetNodeContentByName(doc, "basic", NULL);
status = xmlDocGetNodeContentByName(doc, "status", NULL);
location = xmlDocGetNodeContentByName(doc, "loc", NULL);
site = xmlDocGetNodeContentByName(doc, "site", NULL);
floor = xmlDocGetNodeContentByName(doc, "floor", NULL);
room = xmlDocGetNodeContentByName(doc, "room", NULL);
x = xmlDocGetNodeContentByName(doc, "x", NULL);
y = xmlDocGetNodeContentByName(doc, "y", NULL);
radius = xmlDocGetNodeContentByName(doc, "radius", NULL);
packet_loss = xmlDocGetNodeContentByName(doc, "packet-loss", NULL);
priority_str = xmlDocGetNodeContentByName(doc, "priority", NULL);
expires_str = xmlDocGetNodeContentByName(doc, "expires", NULL);
prescapsNode = xmlDocGetNodeByName(doc, "prescaps", NULL);
if (presenceNode)
sipuri = xmlNodeGetAttrContentByName(presenceNode, "entity");
LOG(L_INFO, "parse_pidf: sipuri=%p:%s contact=%p:%s basic=%p:%s location=%p:%s\n",
sipuri, sipuri, contact, contact, basic, basic, location, location);
LOG(L_INFO, "parse_pidf: site=%p:%s floor=%p:%s room=%p:%s\n",
site, site, floor, floor, room, room);
LOG(L_INFO, "parse_pidf: x=%p:%s y=%p:%s radius=%p:%s\n",
x, x, y, y, radius, radius);
if (packet_loss)
LOG(L_INFO, "packet_loss=%p:%s\n", packet_loss, packet_loss);
if (contact_str && contact) {
contact_str->len = strlen(contact);
contact_str->s = strdup(contact);
flags |= PARSE_PIDF_CONTACT;
}
if (basic_str && basic) {
basic_str->len = strlen(basic);
basic_str->s = strdup(basic);
flags |= PARSE_PIDF_BASIC;
}
if (status_str && status) {
status_str->len = strlen(status);
status_str->s = strdup(status);
flags |= PARSE_PIDF_STATUS;
}
if (location_str && location) {
location_str->len = strlen(location);
location_str->s = strdup(location);
flags |= PARSE_PIDF_LOC;
}
if (site_str && site) {
site_str->len = strlen(site);
site_str->s = strdup(site);
flags |= PARSE_PIDF_SITE;
}
if (floor_str && floor) {
floor_str->len = strlen(floor);
floor_str->s = strdup(floor);
flags |= PARSE_PIDF_FLOOR;
}
if (room_str && room) {
room_str->len = strlen(room);
room_str->s = strdup(room);
flags |= PARSE_PIDF_ROOM;
}
if (xp && x) {
*xp = strtod(x, NULL);
flags |= PARSE_PIDF_X;
}
if (yp && y) {
*yp = strtod(y, NULL);
flags |= PARSE_PIDF_Y;
}
if (radiusp && radius) {
*radiusp = strtod(radius, NULL);
flags |= PARSE_PIDF_RADIUS;
}
if (packet_loss_str && packet_loss) {
packet_loss_str->len = strlen(packet_loss);
packet_loss_str->s = strdup(packet_loss);
flags |= PARSE_PIDF_PACKET_LOSS;
}
if (expiresp && expires_str) {
*expiresp = act_time + strtod(expires_str, NULL);
flags |= PARSE_PIDF_EXPIRES;
}
if (priorityp && priority_str) {
*priorityp = strtod(priority_str, NULL);
flags |= PARSE_PIDF_PRIORITY;
}
if (prescapsNode) {
int i;
for (i = 0; i < 4; i++) {
const char *prescap_name = prescap_names[i];
xmlNodePtr prescap_node = xmlNodeGetNodeByName(prescapsNode, prescap_name, NULL);
const char *prescap_str = xmlNodeGetNodeContentByName(prescapsNode, prescap_name, NULL);
if (prescap_str && (strcasecmp(prescap_str, "true") == 0))
prescaps |= (1 << i);
LOG(L_INFO, "parse_pidf: prescap=%s node=%p value=%s\n", prescap_name, prescap_node, prescap_str);
}
LOG(L_INFO, "parse_pidf: prescaps=%x\n", prescaps);
}
if (prescapsp) {
*prescapsp = prescaps;
flags |= PARSE_PIDF_PRESCAPS;
}
return flags;
}
str* get_final_notify_body( subs_t *subs, str* notify_body, xmlNodePtr rule_node)
{
xmlNodePtr transf_node = NULL, node = NULL, dont_provide = NULL;
xmlNodePtr doc_root = NULL, doc_node = NULL, provide_node = NULL;
xmlNodePtr all_node = NULL;
xmlDocPtr doc= NULL;
char name[15];
char service_uri_scheme[10];
int i= 0, found = 0;
str* new_body = NULL;
char* class_cont = NULL, *occurence_ID= NULL, *service_uri= NULL;
char* deviceID = NULL;
char* content = NULL;
char all_name[20];
strcpy(all_name, "all-");
new_body = (str*)pkg_malloc(sizeof(str));
if(new_body == NULL)
{
LM_ERR("while allocating memory\n");
return NULL;
}
memset(new_body, 0, sizeof(str));
doc = xmlParseMemory(notify_body->s, notify_body->len);
if(doc== NULL)
{
LM_ERR("while parsing the xml body message\n");
goto error;
}
doc_root = xmlDocGetNodeByName(doc,"presence", NULL);
if(doc_root == NULL)
{
LM_ERR("while extracting the presence node\n");
goto error;
}
transf_node = xmlNodeGetChildByName(rule_node, "transformations");
if(transf_node == NULL)
{
LM_DBG("transformations node not found\n");
goto done;
}
for(node = transf_node->children; node; node = node->next )
{
if(xmlStrcasecmp(node->name, (unsigned char*)"text")== 0)
continue;
LM_DBG("transf_node->name:%s\n",node->name);
strcpy((char*)name ,(char*)(node->name + 8));
strcpy(all_name+4, name);
if(xmlStrcasecmp((unsigned char*)name,(unsigned char*)"services") == 0)
strcpy(name, "tuple");
if(strncmp((char*)name,"person", 6) == 0)
name[6] = '\0';
doc_node = xmlNodeGetNodeByName(doc_root, name, NULL);
if(doc_node == NULL)
continue;
LM_DBG("searched doc_node->name:%s\n",name);
content = (char*)xmlNodeGetContent(node);
if(content)
{
LM_DBG("content = %s\n", content);
if(xmlStrcasecmp((unsigned char*)content,
(unsigned char*) "FALSE") == 0)
{
LM_DBG("found content false\n");
while( doc_node )
{
xmlUnlinkNode(doc_node);
xmlFreeNode(doc_node);
doc_node = xmlNodeGetChildByName(doc_root, name);
}
xmlFree(content);
continue;
}
if(xmlStrcasecmp((unsigned char*)content,
(unsigned char*) "TRUE") == 0)
{
LM_DBG("found content true\n");
xmlFree(content);
continue;
}
xmlFree(content);
}
while (doc_node )
{
if (xmlStrcasecmp(doc_node->name,(unsigned char*)"text")==0)
{
doc_node = doc_node->next;
continue;
}
if (xmlStrcasecmp(doc_node->name,(unsigned char*)name)!=0)
{
break;
}
all_node = xmlNodeGetChildByName(node, all_name) ;
if( all_node )
{
LM_DBG("must provide all\n");
doc_node = doc_node->next;
continue;
}
found = 0;
class_cont = xmlNodeGetNodeContentByName(doc_node, "class",
NULL);
if(class_cont == NULL)
LM_DBG("no class tag found\n");
else
LM_DBG("found class = %s\n", class_cont);
occurence_ID = xmlNodeGetAttrContentByName(doc_node, "id");
if(occurence_ID == NULL)
LM_DBG("no id found\n");
else
LM_DBG("found id = %s\n", occurence_ID);
deviceID = xmlNodeGetNodeContentByName(doc_node, "deviceID",
NULL);
if(deviceID== NULL)
LM_DBG("no deviceID found\n");
else
LM_DBG("found deviceID = %s\n", deviceID);
service_uri = xmlNodeGetNodeContentByName(doc_node, "contact",
NULL);
if(service_uri == NULL)
LM_DBG("no service_uri found\n");
else
LM_DBG("found service_uri = %s\n", service_uri);
i = 0;
if(service_uri!= NULL)
{
while(service_uri[i]!= ':')
{
service_uri_scheme[i] = service_uri[i];
i++;
}
service_uri_scheme[i] = '\0';
LM_DBG("service_uri_scheme: %s\n", service_uri_scheme);
}
provide_node = node->children;
while ( provide_node!= NULL )
{
if(xmlStrcasecmp(provide_node->name,(unsigned char*) "text")==0)
{
provide_node = provide_node->next;
continue;
}
if(xmlStrcasecmp(provide_node->name,(unsigned char*)"class")== 0
&& class_cont )
{
content = (char*)xmlNodeGetContent(provide_node);
if(content&& xmlStrcasecmp((unsigned char*)content,
(unsigned char*)class_cont) == 0)
{
found = 1;
LM_DBG("found class= %s", class_cont);
xmlFree(content);
break;
}
if(content)
xmlFree(content);
}
if(xmlStrcasecmp(provide_node->name,
(unsigned char*) "deviceID")==0&&deviceID )
{
content = (char*)xmlNodeGetContent(provide_node);
if(content && xmlStrcasecmp ((unsigned char*)content,
(unsigned char*)deviceID) == 0)
{
found = 1;
LM_DBG("found deviceID= %s", deviceID);
xmlFree(content);
break;
}
if(content)
xmlFree(content);
}
if(xmlStrcasecmp(provide_node->name,
(unsigned char*)"occurence-id")== 0&& occurence_ID)
{
content = (char*)xmlNodeGetContent(provide_node);
if(content && xmlStrcasecmp ((unsigned char*)content,
(unsigned char*)occurence_ID) == 0)
{
found = 1;
LM_DBG("found occurenceID= %s\n", occurence_ID);
xmlFree(content);
break;
}
if(content)
xmlFree(content);
}
if(xmlStrcasecmp(provide_node->name,
(unsigned char*)"service-uri")== 0 && service_uri)
{
content = (char*)xmlNodeGetContent(provide_node);
if(content&& xmlStrcasecmp ((unsigned char*)content,
(unsigned char*)service_uri) == 0)
{
found = 1;
LM_DBG("found service_uri= %s", service_uri);
xmlFree(content);
break;
}
if(content)
xmlFree(content);
}
if(xmlStrcasecmp(provide_node->name,
(unsigned char*)"service-uri-scheme")==0&& i)
{
content = (char*)xmlNodeGetContent(provide_node);
LM_DBG("service_uri_scheme=%s\n",content);
if(content && xmlStrcasecmp((unsigned char*)content,
(unsigned char*)service_uri_scheme) == 0)
{
found = 1;
LM_DBG("found service_uri_scheme= %s", service_uri_scheme);
xmlFree(content);
break;
}
if(content)
xmlFree(content);
}
provide_node = provide_node->next;
}
if(found == 0)
{
LM_DBG("delete node: %s\n", doc_node->name);
dont_provide = doc_node;
doc_node = doc_node->next;
xmlUnlinkNode(dont_provide);
xmlFreeNode(dont_provide);
}
else
doc_node = doc_node->next;
}
}
done:
xmlDocDumpFormatMemory(doc,(xmlChar**)(void*)&new_body->s,
&new_body->len, 1);
LM_DBG("body = \n%.*s\n", new_body->len,
new_body->s);
xmlFreeDoc(doc);
xmlFree(class_cont);
xmlFree(occurence_ID);
xmlFree(deviceID);
xmlFree(service_uri);
xmlCleanupParser();
xmlMemoryDump();
return new_body;
error:
if(doc)
xmlFreeDoc(doc);
if(new_body)
{
if(new_body->s)
xmlFree(new_body->s);
pkg_free(new_body);
}
if(class_cont)
xmlFree(class_cont);
if(occurence_ID)
xmlFree(occurence_ID);
if(deviceID)
xmlFree(deviceID);
if(service_uri)
xmlFree(service_uri);
return NULL;
}
int pres_process_body(publ_info_t* publ, str** fin_body, int ver, str* tuple)
{
xmlDocPtr doc= NULL;
xmlNodePtr node= NULL;
char* tuple_id= NULL, *person_id= NULL;
static char buf[128];
str* body= NULL;
doc= xmlParseMemory(publ->body->s, publ->body->len );
if(doc== NULL)
{
LM_ERR("while parsing xml memory\n");
goto error;
}
node= xmlDocGetNodeByName(doc, "tuple", NULL);
if(node == NULL)
{
LM_ERR("while extracting tuple node\n");
goto error;
}
tuple_id= xmlNodeGetAttrContentByName(node, "id");
if(tuple_id== NULL)
{
/* must be null terminated */
if(tuple->s == 0) /* generate a tuple_id */
{
tuple->s= buf;
tuple->len= sprintf(tuple->s, "%p", publ);
}
tuple_id = buf;
/* add tuple id */
if(!xmlNewProp(node, BAD_CAST "id", BAD_CAST tuple_id))
{
LM_ERR("Failed to add xml node attribute\n");
goto error;
}
}
else
{
if(tuple->s == 0) /* generate a tuple_id */
{
tuple->s= buf;
tuple->len= sprintf(tuple->s, "%s", tuple_id);
}
}
node= xmlDocGetNodeByName(doc, "person", NULL);
if(node)
{
LM_DBG("found person node\n");
person_id= xmlNodeGetAttrContentByName(node, "id");
if(person_id== NULL)
{
if(!xmlNewProp(node, BAD_CAST "id", BAD_CAST tuple_id))
{
LM_ERR("while extracting xml"
" node\n");
goto error;
}
}
else
{
xmlFree(person_id);
}
}
body= (str*)pkg_malloc(sizeof(str));
if(body== NULL)
{
LM_ERR("NO more memory left\n");
goto error;
}
memset(body, 0, sizeof(str));
xmlDocDumpMemory(doc,(xmlChar**)(void*)&body->s, &body->len);
if(body->s== NULL || body->len== 0)
{
LM_ERR("while dumping xml format\n");
goto error;
}
xmlFreeDoc(doc);
doc= NULL;
*fin_body= body;
xmlMemoryDump();
xmlCleanupParser();
return 1;
error:
if(doc)
xmlFreeDoc(doc);
if(body)
pkg_free(body);
return -1;
}
str* agregate_xmls(str* pres_user, str* pres_domain, str** body_array, int n,
char* root_name, char* elem_name)
{
int i, j= 0, append ;
xmlNodePtr p_root= NULL, new_p_root= NULL ;
xmlDocPtr* xml_array ;
xmlNodePtr node = NULL;
xmlNodePtr add_node = NULL ;
str *body= NULL;
char* id= NULL, *elem_id = NULL;
xmlDocPtr pidf_manip_doc= NULL;
str* pidf_doc= NULL;
xml_array = (xmlDocPtr*)pkg_malloc( (n+2)*sizeof(xmlDocPtr));
if(xml_array== NULL)
{
LM_ERR("while alocating memory");
return NULL;
}
memset(xml_array, 0, (n+2)*sizeof(xmlDocPtr)) ;
/* if pidf_manipulation usage is configured */
if(pidf_manipulation)
{
if( get_rules_doc(pres_user, pres_domain, PIDF_MANIPULATION, &pidf_doc)< 0)
{
LM_ERR("while getting xcap tree for doc_type PIDF_MANIPULATION\n");
goto error;
}
if(pidf_doc== NULL)
{
LM_DBG("No PIDF_MANIPULATION doc for [user]= %.*s [domain]= %.*s\n",
pres_user->len, pres_user->s, pres_domain->len, pres_domain->s);
}
else
{
pidf_manip_doc= xmlParseMemory(pidf_doc->s, pidf_doc->len);
pkg_free(pidf_doc->s);
pkg_free(pidf_doc);
if(pidf_manip_doc== NULL)
{
LM_ERR("parsing xml memory\n");
goto error;
}
else
{
xml_array[0]= pidf_manip_doc;
j++;
}
}
}
for(i=0; i<n; i++)
{
if(body_array[i] == NULL )
continue;
xml_array[j] = NULL;
xml_array[j] = xmlParseMemory( body_array[i]->s, body_array[i]->len );
LM_DBG("i = [%d] - body: %.*s\n", i, body_array[i]->len, body_array[i]->s);
if( xml_array[j]== NULL)
{
LM_ERR("while parsing xml body message\n");
goto error;
}
j++;
}
if(j== 0) /* no body */
{
if(xml_array)
pkg_free(xml_array);
return NULL;
}
j--;
p_root = xmlDocGetNodeByName( xml_array[j], root_name, NULL);
if(p_root ==NULL)
{
LM_ERR("while geting the xml_tree root\n");
goto error;
}
for(i= j-1; i>=0; i--)
{
LM_DBG("i = %d\n", i);
new_p_root= xmlDocGetNodeByName( xml_array[i], root_name, NULL);
if(new_p_root ==NULL)
{
LM_ERR("while geting the xml_tree root\n");
goto error;
}
node= xmlNodeGetChildByName(new_p_root, elem_name);
if(node== NULL)
{
LM_DBG("no %s node found\n", elem_name);
append = 1;
goto append_label;
}
elem_id= xmlNodeGetAttrContentByName(node, "id");
if(elem_id== NULL)
{
LM_ERR("while extracting %s id\n", elem_name);
goto error;
}
append= 1;
for (node = p_root->children; node!=NULL; node = node->next)
{
if( xmlStrcasecmp(node->name,(unsigned char*)"text")==0)
continue;
if( xmlStrcasecmp(node->name,(unsigned char*)elem_name)==0)
{
id = xmlNodeGetAttrContentByName(node, "id");
if(id== NULL)
{
LM_ERR("while extracting %s id\n", elem_name);
goto error;
}
if(xmlStrcasecmp((unsigned char*)elem_id,
(unsigned char*)id )== 0)
{
append = 0;
xmlFree(id);
break;
}
xmlFree(id);
}
}
xmlFree(elem_id);
elem_id= NULL;
append_label:
if(append)
{
LM_DBG("in if\n");
for(node= new_p_root->children; node; node= node->next)
{
LM_DBG("adding node [%s]\n", node->name);
add_node= xmlCopyNode(node, 1);
if(add_node== NULL)
{
LM_ERR("while copying node [%s]\n", node->name);
goto error;
}
if(xmlAddChild(p_root, add_node)== NULL)
{
LM_ERR("while adding child\n");
goto error;
}
}
}
}
body = (str*)pkg_malloc(sizeof(str));
if(body == NULL)
{
ERR_MEM(PKG_MEM_STR);
}
xmlDocDumpMemory(xml_array[j],(xmlChar**)(void*)&body->s,
&body->len);
LM_DBG("body = %.*s\n", body->len, body->s);
for(i=0; i<=j; i++)
{
if(xml_array[i]!=NULL)
xmlFreeDoc( xml_array[i]);
}
if(xml_array!=NULL)
pkg_free(xml_array);
return body;
error:
if(xml_array!=NULL)
{
for(i=0; i<=j; i++)
{
if(xml_array[i]!=NULL)
xmlFreeDoc( xml_array[i]);
}
pkg_free(xml_array);
}
if(elem_id)
xmlFree(elem_id);
if(body)
pkg_free(body);
return NULL;
}
static inline int oma_match_external_list_condition(xmlNodePtr condition, subs_t *subs, str *w_uri)
{
int found = 0;
str anchor, uri;
str *normalized_uri;
struct sip_uri sip_uri;
xcap_uri_t anchor_uri;
xmlNodePtr entry_node = NULL;
xmlNodePtr rl_node = NULL, rl_entry = NULL;
xmlDocPtr rl_doc = NULL;
if(!integrated_xcap_server)
{
LM_ERR("<external-list> is not supported in non integrated mode\n");
return 0;
}
if(parse_uri(subs->pres_uri.s, subs->pres_uri.len, &sip_uri) < 0)
{
LM_ERR("failed to parse uri\n");
return 0;
}
for(entry_node = condition->children; entry_node; entry_node = entry_node->next)
{
if(xmlStrcasecmp(entry_node->name, (unsigned char*)"entry") != 0)
continue;
rl_node = NULL;
rl_doc = NULL;
anchor.s = NULL;
uri.s = NULL;
anchor.s = xmlNodeGetAttrContentByName(entry_node, "anc");
if(anchor.s == NULL)
{
LM_ERR("cannot get external-list entry anchor\n");
continue;
}
anchor.len = strlen(anchor.s);
if(xcapParseUri(&anchor, &anchor_uri) != 0)
{
LM_ERR("unable to parse URI for external-list entry anchor\n");
xmlFree(anchor.s);
continue;
}
xmlFree(anchor.s);
/* TODO: validate XUI? */
if(get_resource_list(&sip_uri.user, &sip_uri.host, &anchor_uri.filename, &anchor_uri.selector, &rl_node, &rl_doc) < 0)
{
LM_ERR("error getting resource-list list pointed by external list anchor\n");
continue;
}
for(rl_entry = rl_node->children; rl_entry; rl_entry = rl_entry->next)
{
if(xmlStrcasecmp(rl_entry->name, (unsigned char*)"entry") != 0)
continue;
uri.s = xmlNodeGetAttrContentByName(rl_entry, "uri");
if(uri.s == NULL)
{
LM_ERR("when extracting entry uri attribute\n");
continue;
}
uri.len = strlen(uri.s);
normalized_uri = normalizeSipUri(&uri);
if (normalized_uri->s == NULL || normalized_uri->len == 0)
{
LM_ERR("normalizing URI\n");
xmlFree(uri.s);
continue;
}
xmlFree(uri.s);
if (normalized_uri->len == w_uri->len && strncmp(normalized_uri->s, w_uri->s, w_uri->len) == 0)
{
found = 1;
break;
}
}
xmlFreeDoc(rl_doc);
if (found)
break;
}
return found;
}
static void ietf_get_rules(subs_t* subs, xmlDocPtr xcap_tree, xcap_rule_t **rules)
{
str w_uri= {0, 0};
char* id = NULL, *domain = NULL, *time_cont= NULL;
int apply_rule = -1;
xmlNodePtr ruleset_node = NULL, node1= NULL, node2= NULL;
xmlNodePtr cond_node = NULL, except_node = NULL;
xmlNodePtr identity_node = NULL, sphere_node = NULL;
xmlNodePtr iden_child;
xmlNodePtr validity_node, time_node;
time_t t_init, t_fin, t;
int valid= 0;
xcap_rule_t *rule = NULL;
*rules = NULL;
uandd_to_uri(subs->from_user, subs->from_domain, &w_uri);
if(w_uri.s == NULL)
{
LM_ERR("while creating uri\n");
return;
}
ruleset_node = xmlDocGetNodeByName(xcap_tree, "ruleset", NULL);
if(ruleset_node == NULL)
{
LM_DBG("ruleset_node NULL\n");
goto error;
}
for(node1 = ruleset_node->children ; node1; node1 = node1->next)
{
if(xmlStrcasecmp(node1->name, (unsigned char*)"text")==0 )
continue;
/* process conditions */
LM_DBG("node1->name= %s\n", node1->name);
cond_node = xmlNodeGetChildByName(node1, "conditions");
if(cond_node == NULL)
{
LM_DBG("cond node NULL\n");
goto error;
}
LM_DBG("cond_node->name= %s\n", cond_node->name);
validity_node = xmlNodeGetChildByName(cond_node, "validity");
if(validity_node !=NULL)
{
LM_DBG("found validity tag\n");
t= time(NULL);
/* search all from-until pair */
for(time_node= validity_node->children; time_node;
time_node= time_node->next)
{
if(xmlStrcasecmp(time_node->name, (unsigned char*)"from")!= 0)
{
continue;
}
time_cont= (char*)xmlNodeGetContent(time_node);
t_init= xml_parse_dateTime(time_cont);
xmlFree(time_cont);
if(t_init< 0)
{
LM_ERR("failed to parse xml dateTime\n");
goto error;
}
if(t< t_init)
{
LM_DBG("the lower time limit is not respected\n");
continue;
}
time_node= time_node->next;
while(1)
{
if(time_node== NULL)
{
LM_ERR("bad formatted xml doc:until child not found in"
" validity pair\n");
goto error;
}
if( xmlStrcasecmp(time_node->name,
(unsigned char*)"until")== 0)
break;
time_node= time_node->next;
}
time_cont= (char*)xmlNodeGetContent(time_node);
t_fin= xml_parse_dateTime(time_cont);
xmlFree(time_cont);
if(t_fin< 0)
{
LM_ERR("failed to parse xml dateTime\n");
goto error;
}
if(t <= t_fin)
{
LM_DBG("the rule is active at this time\n");
valid= 1;
}
}
if(!valid)
{
LM_DBG("the rule is not active at this time\n");
continue;
}
}
sphere_node = xmlNodeGetChildByName(cond_node, "sphere");
if(sphere_node!= NULL)
{
/* check to see if matches presentity current sphere */
/* ask presence for sphere information */
char* sphere= pres_get_sphere(&subs->pres_uri);
if(sphere)
{
char* attr= (char*)xmlNodeGetContent(sphere_node);
if(xmlStrcasecmp((unsigned char*)attr, (unsigned char*)sphere)!= 0)
{
LM_DBG("sphere condition not respected\n");
pkg_free(sphere);
xmlFree(attr);
continue;
}
pkg_free(sphere);
xmlFree(attr);
}
else
{
LM_DBG("Noo sphere definition found\n");
continue;
}
/* if the user has not define a sphere
* consider the condition false*/
}
identity_node = xmlNodeGetChildByName(cond_node, "identity");
if(identity_node == NULL)
{
LM_ERR("didn't find identity tag\n");
goto error;
}
iden_child= xmlNodeGetChildByName(identity_node, "one");
if(iden_child)
{
for(node2 = identity_node->children; node2; node2 = node2->next)
{
if(xmlStrcasecmp(node2->name, (unsigned char*)"one")!= 0)
continue;
id = xmlNodeGetAttrContentByName(node2, "id");
if(id== NULL)
{
LM_ERR("while extracting attribute\n");
goto error;
}
if((strlen(id)== w_uri.len &&
(strncmp(id, w_uri.s, w_uri.len)==0)))
{
apply_rule = 1;
xmlFree(id);
break;
}
xmlFree(id);
}
}
/* search for many node*/
iden_child= xmlNodeGetChildByName(identity_node, "many");
if(iden_child)
{
domain = NULL;
for(node2 = identity_node->children; node2; node2 = node2->next)
{
if(xmlStrcasecmp(node2->name, (unsigned char*)"many")!= 0)
continue;
domain = xmlNodeGetAttrContentByName(node2, "domain");
if(domain == NULL)
{
LM_DBG("No domain attribute to many\n");
}
else
{
LM_DBG("<many domain= %s>\n", domain);
if((strlen(domain)!= subs->from_domain.len &&
strncmp(domain, subs->from_domain.s,
subs->from_domain.len) ))
{
xmlFree(domain);
continue;
}
}
xmlFree(domain);
apply_rule = 1;
if(node2->children == NULL) /* there is no exception */
break;
for(except_node = node2->children; except_node;
except_node= except_node->next)
{
if(xmlStrcasecmp(except_node->name, (unsigned char*)"except"))
continue;
id = xmlNodeGetAttrContentByName(except_node, "id");
if(id!=NULL)
{
if((strlen(id)- 1== w_uri.len &&
(strncmp(id, w_uri.s, w_uri.len)==0)))
{
xmlFree(id);
apply_rule = 0;
break;
}
xmlFree(id);
}
else
{
domain = NULL;
domain = xmlNodeGetAttrContentByName(except_node, "domain");
if(domain!=NULL)
{
LM_DBG("Found except domain= %s\n- strlen(domain)= %d\n",
domain, (int)strlen(domain));
if(strlen(domain)==subs->from_domain.len &&
(strncmp(domain,subs->from_domain.s , subs->from_domain.len)==0))
{
LM_DBG("except domain match\n");
xmlFree(domain);
apply_rule = 0;
break;
}
xmlFree(domain);
}
}
}
if(apply_rule== 1) /* if a match was found no need to keep searching*/
break;
}
}
if(apply_rule ==1)
break;
}
LM_DBG("apply_rule= %d\n", apply_rule);
if(w_uri.s!=NULL)
pkg_free(w_uri.s);
if( !apply_rule || !node1)
return;
rule = (xcap_rule_t *)pkg_malloc(sizeof(*rule));
if (rule == NULL)
{
LM_ERR("cannot allocate pkg_mem\n");
return;
}
/* TODO: in IETF mode only the first matching rule is returned */
rule->node = node1;
rule->next = NULL;
*rules = rule;
return;
error:
if(w_uri.s)
pkg_free(w_uri.s);
}
static inline int oma_match_identity_condition(xmlNodePtr condition, subs_t *subs, str *w_uri)
{
int r = 0, many_match = 0;
char *domain = NULL;
str uri;
str *normalized_uri;
xmlNodePtr node = NULL, except_node = NULL;
for(node = condition->children; node; node = node->next)
{
if(xmlStrcasecmp(node->name, (unsigned char*)"one") == 0)
{
uri.s = xmlNodeGetAttrContentByName(node, "id");
if(uri.s == NULL)
{
LM_ERR("when extracting entry attribute\n");
continue;
}
uri.len = strlen(uri.s);
normalized_uri = normalizeSipUri(&uri);
if (normalized_uri->s == NULL || normalized_uri->len == 0)
{
LM_ERR("normalizing URI\n");
xmlFree(uri.s);
continue;
}
xmlFree(uri.s);
if (normalized_uri->len == w_uri->len && strncmp(normalized_uri->s, w_uri->s, w_uri->len) == 0)
{
r = 1;
break;
}
}
else if(xmlStrcasecmp(node->name, (unsigned char*)"many") == 0)
{
domain = xmlNodeGetAttrContentByName(node, "domain");
if(domain == NULL)
{
LM_DBG("No domain attribute in identity many\n");
}
else
{
LM_DBG("<many domain= %s>\n", domain);
if(!(strlen(domain) == subs->from_domain.len &&
strncmp(domain, subs->from_domain.s, subs->from_domain.len) == 0))
{
xmlFree(domain);
continue;
}
xmlFree(domain);
}
many_match = 1;
for(except_node = node->children; except_node; except_node= except_node->next)
{
if(xmlStrcasecmp(except_node->name, (unsigned char*)"except"))
continue;
uri.s = xmlNodeGetAttrContentByName(except_node, "id");
if(uri.s != NULL)
{
uri.len = strlen(uri.s);
normalized_uri = normalizeSipUri(&uri);
if (normalized_uri->s == NULL || normalized_uri->len == 0)
{
LM_ERR("normalizing URI\n");
xmlFree(uri.s);
continue;
}
xmlFree(uri.s);
if (normalized_uri->len == w_uri->len && strncmp(normalized_uri->s, w_uri->s, w_uri->len) == 0)
{
many_match = 0;
break;
}
}
else
{
domain = NULL;
domain = xmlNodeGetAttrContentByName(except_node, "domain");
if(domain != NULL)
{
LM_DBG("Found except domain= %s\n- strlen(domain)= %d\n", domain, (int)strlen(domain));
if(strlen(domain)==subs->from_domain.len &&
(strncmp(domain,subs->from_domain.s , subs->from_domain.len)==0))
{
LM_DBG("except domain match\n");
xmlFree(domain);
many_match = 0;
break;
}
xmlFree(domain);
}
}
}
if(many_match)
{
r = 1;
break;
}
}
}
return r;
}
