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;
}
int presxml_check_basic(struct sip_msg *msg, str presentity_uri, str status)
{
str *presentity = NULL;
struct sip_uri parsed_uri;
pres_ev_t *ev;
static str event = str_init("presence");
int retval = -1;
xmlDocPtr xmlDoc = NULL;
xmlNodePtr tuple = NULL, basicNode = NULL;
char *basicVal = NULL;
if (parse_uri(presentity_uri.s, presentity_uri.len, &parsed_uri) < 0)
{
LM_ERR("bad uri: %.*s\n", presentity_uri.len, presentity_uri.s);
return -1;
}
ev = pres_contains_event(&event, NULL);
if (ev == NULL)
{
LM_ERR("event presence is not registered\n");
return -1;
}
presentity = pres_get_presentity(presentity_uri, ev, NULL, NULL);
if (presentity == NULL || presentity->len <= 0 || presentity->s == NULL)
{
LM_DBG("cannot get presentity for %.*s\n", presentity_uri.len, presentity_uri.s);
return -1;
}
if ((xmlDoc = xmlParseMemory(presentity->s, presentity->len)) == NULL)
{
LM_ERR("while parsing XML memory\n");
goto error;
}
if ((tuple = xmlDocGetNodeByName(xmlDoc, "tuple", NULL)) == NULL)
{
LM_ERR("unable to extract 'tuple'\n");
goto error;
}
while (tuple != NULL)
{
if (xmlStrcasecmp(tuple->name, (unsigned char *) "tuple") == 0)
{
if ((basicNode = xmlNodeGetNodeByName(tuple, "basic", NULL)) == NULL)
{
LM_ERR("while extracting 'basic' node\n");
goto error;
}
if ((basicVal = (char *) xmlNodeGetContent(basicNode)) == NULL)
{
LM_ERR("while getting 'basic' content\n");
goto error;
}
if (strncasecmp(basicVal, status.s, status.len) == 0)
retval = 1;
xmlFree(basicVal);
}
tuple = tuple->next;
}
error:
if (xmlDoc != NULL)
xmlFreeDoc(xmlDoc);
pres_free_presentity(presentity, ev);
return retval;
}
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, sphere_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;
}
}
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 NULL;
return node1;
error:
if(w_uri.s)
pkg_free(w_uri.s);
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;
}
int presxml_check_activities(struct sip_msg *msg, str presentity_uri, str activity)
{
str *presentity = NULL;
struct sip_uri parsed_uri;
pres_ev_t *ev;
static str event = str_init("presence");
char *nodeName = NULL;
int retval = -1;
xmlDocPtr xmlDoc = NULL;
xmlNodePtr person = NULL, activitiesNode = NULL, activityNode = NULL;
if (parse_uri(presentity_uri.s, presentity_uri.len, &parsed_uri) < 0)
{
LM_ERR("bad uri: %.*s\n", presentity_uri.len, presentity_uri.s);
return -1;
}
ev = pres_contains_event(&event, NULL);
if (ev == NULL)
{
LM_ERR("event presence is not registered\n");
return -1;
}
if ((nodeName = pkg_malloc(activity.len + 1)) == NULL)
{
LM_ERR("cannot pkg_malloc for nodeName\n");
return -1;
}
memcpy(nodeName, activity.s, activity.len);
nodeName[activity.len] = '\0';
presentity = pres_get_presentity(presentity_uri, ev, NULL, NULL);
if (presentity == NULL || presentity->len <= 0 || presentity->s == NULL)
{
LM_DBG("cannot get presentity for %.*s\n", presentity_uri.len, presentity_uri.s);
return -1;
}
if ((xmlDoc = xmlParseMemory(presentity->s, presentity->len)) == NULL)
{
LM_ERR("while parsing XML memory\n");
goto error;
}
if ((person = xmlDocGetNodeByName(xmlDoc, "person", NULL)) == NULL)
{
LM_DBG("unable to extract 'person'\n");
retval = -2;
goto error;
}
while (person != NULL)
{
if (xmlStrcasecmp(person->name, (unsigned char *) "person") == 0)
{
if ((activitiesNode = xmlNodeGetNodeByName(person, "activities", NULL)) == NULL)
{
LM_DBG("unable to extract 'activities' node\n");
if (retval <= 0)
{
retval = -2;
}
break;
}
if (activitiesNode->children == NULL)
{
LM_DBG("activities node has no children\n");
if (retval <= 0)
{
retval = -2;
}
break;
}
if ((activityNode = xmlNodeGetNodeByName(activitiesNode, nodeName, NULL)) != NULL)
{
retval = 1;
}
}
person = person->next;
}
error:
if (nodeName != NULL)
pkg_free(nodeName);
if (xmlDoc != NULL)
xmlFreeDoc(xmlDoc);
pres_free_presentity(presentity, ev);
return retval;
}
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;
}
alloc_tuple= 1;
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;
}
}
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;
}
int bla_process_body(publ_info_t* publ, str** fin_body, int ver, str** tuple)
{
xmlNodePtr node= NULL;
xmlDocPtr doc= NULL;
char* version;
str* body= NULL;
int len;
str* init_body;
init_body= publ->body;
doc= xmlParseMemory(init_body->s, init_body->len );
if(doc== NULL)
{
LM_ERR("while parsing xml memory\n");
goto error;
}
/* change version and state*/
node= xmlDocGetNodeByName(doc, "dialog-info", NULL);
if(node == NULL)
{
LM_ERR("while extracting dialog-info node\n");
goto error;
}
version= int2str(ver,&len);
version[len]= '\0';
if( xmlSetProp(node, (const xmlChar *)"version",(const xmlChar*)version)== NULL)
{
LM_ERR("while setting version attribute\n");
goto error;
}
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);
xmlFreeDoc(doc);
doc= NULL;
*fin_body= body;
if(*fin_body== NULL)
LM_DBG("NULL fin_body\n");
xmlMemoryDump();
xmlCleanupParser();
LM_DBG("successful\n");
return 1;
error:
if(doc)
xmlFreeDoc(doc);
if(body)
pkg_free(body);
xmlMemoryDump();
xmlCleanupParser();
return -1;
}
str* offline_nbody(str* body)
{
xmlDocPtr doc= NULL;
xmlDocPtr new_doc= NULL;
xmlNodePtr node, tuple_node= NULL, status_node;
xmlNodePtr root_node, add_node, pres_node;
str* new_body;
doc= xmlParseMemory(body->s, body->len);
if(doc== NULL)
{
LM_ERR("while parsing xml memory\n");
return NULL;
}
node= xmlDocGetNodeByName(doc, "basic", NULL);
if(node== NULL)
{
LM_ERR("while extracting basic node\n");
goto error;
}
xmlNodeSetContent(node, (const unsigned char*)"closed");
tuple_node= xmlDocGetNodeByName(doc, "tuple", NULL);
if(tuple_node== NULL)
{
LM_ERR("while extracting tuple node\n");
goto error;
}
status_node= xmlDocGetNodeByName(doc, "status", NULL);
if(status_node== NULL)
{
LM_ERR("while extracting tuple node\n");
goto error;
}
pres_node= xmlDocGetNodeByName(doc, "presence", NULL);
if(node== NULL)
{
LM_ERR("while extracting presence node\n");
goto error;
}
new_doc = xmlNewDoc(BAD_CAST "1.0");
if(new_doc==0)
goto error;
root_node= xmlCopyNode(pres_node, 2);
if(root_node== NULL)
{
LM_ERR("while copying node\n");
goto error;
}
xmlDocSetRootElement(new_doc, root_node);
tuple_node= xmlCopyNode(tuple_node, 2);
if(tuple_node== NULL)
{
LM_ERR("while copying node\n");
goto error;
}
xmlAddChild(root_node, tuple_node);
add_node= xmlCopyNode(status_node, 1);
if(add_node== NULL)
{
LM_ERR("while copying node\n");
goto error;
}
xmlAddChild(tuple_node, add_node);
new_body = (str*)pkg_malloc(sizeof(str));
if(new_body == NULL)
{
ERR_MEM(PKG_MEM_STR);
}
memset(new_body, 0, sizeof(str));
xmlDocDumpFormatMemory(new_doc,(xmlChar**)(void*)&new_body->s,
&new_body->len, 1);
xmlFreeDoc(doc);
xmlFreeDoc(new_doc);
xmlCleanupParser();
xmlMemoryDump();
return new_body;
error:
if(doc)
xmlFreeDoc(doc);
if(new_doc)
xmlFreeDoc(new_doc);
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;
xmlNodePtr body_node;
char* body_content= 0;
char* body_type= 0;
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;
body_node = xmlNodeGetChildByName(node, "body");
if(body_node)
{
body_type = (char *)xmlNodeGetAttrContentByName(body_node, "type");
if (body_type == NULL)
{
LM_ERR("Bad formatted scenario document. Empty body content type\n");
goto error;
}
body_content = (char*)xmlNodeGetContent(body_node);
if(body_content == NULL)
{
LM_ERR("Bad formatted scenario document. Empty body\n");
xmlFree(body_type);
goto error;
}
/* we move everything in pkg to be able to strip them */
scenario->body_type.len = strlen(body_type);
scenario->body_type.s = body_type;
scenario->body.len = strlen(body_content);
scenario->body.s = body_content;
}
}
/* 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);
if(scenario->body.s)
xmlFree(scenario->body.s);
if(scenario->body_type.s)
xmlFree(scenario->body_type.s);
pkg_free(scenario);
}
return -1;
}
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;
}
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;
}
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;
}
int presence_offline_body(str* body, str** offline_body)
{
xmlDocPtr doc= NULL;
xmlDocPtr new_doc= NULL;
xmlNodePtr node, tuple_node= NULL, status_node;
xmlNodePtr root_node, add_node, pres_node;
xmlErrorPtr xml_error;
str* new_body;
char *err_msg;
int rc = OFFB_STATUS_ERROR;
doc= xmlParseMemory(body->s, body->len);
if(doc== NULL)
{
GET_LAST_XML_ERROR(xml_error, err_msg);
LM_ERR("xml memory parsing failed: %s\n", err_msg);
goto done;
}
node= xmlDocGetNodeByName(doc, "basic", NULL);
if(node== NULL)
{
LM_ERR("while extracting basic node\n");
goto done;
}
xmlNodeSetContent(node, (const unsigned char*)"closed");
tuple_node= xmlDocGetNodeByName(doc, "tuple", NULL);
if(tuple_node== NULL)
{
LM_ERR("while extracting tuple node\n");
goto done;
}
status_node= xmlDocGetNodeByName(doc, "status", NULL);
if(status_node== NULL)
{
LM_ERR("while extracting tuple node\n");
goto done;
}
pres_node= xmlDocGetNodeByName(doc, "presence", NULL);
if(node== NULL)
{
LM_ERR("while extracting presence node\n");
goto done;
}
new_doc = xmlNewDoc(BAD_CAST "1.0");
if(new_doc==0)
{
GET_LAST_XML_ERROR(xml_error, err_msg);
LM_ERR("failed to create new XML document: %s\n", err_msg);
goto done;
}
root_node= xmlCopyNode(pres_node, 2);
if(root_node== NULL)
{
GET_LAST_XML_ERROR(xml_error, err_msg);
LM_ERR("failed to copy root node: %s\n", err_msg);
goto done;
}
xmlNewProp(root_node, BAD_CAST "xmlns",
BAD_CAST "urn:ietf:params:xml:ns:pidf");
xmlDocSetRootElement(new_doc, root_node);
tuple_node= xmlCopyNode(tuple_node, 2);
if(tuple_node== NULL)
{
GET_LAST_XML_ERROR(xml_error, err_msg);
LM_ERR("failed to copy tuple node: %s\n", err_msg);
goto done;
}
xmlAddChild(root_node, tuple_node);
add_node= xmlCopyNode(status_node, 1);
if(add_node== NULL)
{
GET_LAST_XML_ERROR(xml_error, err_msg);
LM_ERR("failed to copy status node: %s\n", err_msg);
goto done;
}
xmlAddChild(tuple_node, add_node);
new_body = (str*)pkg_malloc(sizeof(str));
if(new_body == NULL)
{
LM_ERR("No more pkg memory");
goto done;
}
memset(new_body, 0, sizeof(str));
xmlDocDumpMemory(new_doc,(xmlChar**)(void*)&new_body->s,
&new_body->len);
*offline_body = new_body;
rc = OFFB_STATUS_OK;
done:
if(doc)
xmlFreeDoc(doc);
if(new_doc)
xmlFreeDoc(new_doc);
return rc;
}
static void oma_get_rules(subs_t* subs, xmlDocPtr xcap_tree, xcap_rule_t **rules)
{
int apply_rule = 0, current_node_type = -1;
str w_uri = {0, 0};
xmlNodePtr ruleset_node = NULL, cond_node = NULL;
xmlNodePtr node1 = NULL, node2 = NULL, current_node = NULL;
xcap_rule_t *tmp_rule = NULL;
xcap_rule_t *identity_rules = NULL, *external_rules = NULL, *anonymous_rules = NULL, *other_identity_rules = NULL;
xcap_rule_t *identity_tail = NULL, *external_tail = NULL, *anonymous_tail = NULL, *other_identity_tail = 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_ERR("ruleset_node not found\n");
pkg_free(w_uri.s);
return;
}
for(node1 = ruleset_node->children; node1; node1 = node1->next)
{
if(xmlStrcasecmp(node1->name, (unsigned char*)"text")==0)
continue;
cond_node = xmlNodeGetChildByName(node1, "conditions");
if(cond_node == NULL)
{
LM_WARN("condition node not found\n");
continue;
}
apply_rule = 0;
current_node = node1;
current_node_type = -1;
for(node2 = cond_node->children; node2; node2 = node2->next)
{
if(xmlStrcasecmp(node2->name, (unsigned char*)"identity") == 0)
{
current_node_type = IDENTITY_RULE;
apply_rule = oma_match_identity_condition(node2, subs, &w_uri);
break;
}
else if(xmlStrcasecmp(node2->name, (unsigned char*)"external-list") == 0)
{
current_node_type = EXTERNAL_LIST_RULE;
apply_rule = oma_match_external_list_condition(node2, subs, &w_uri);
break;
}
else if(xmlStrcasecmp(node2->name, (unsigned char*)"anonymous-request") == 0)
{
current_node_type = ANONYMOUS_REQUEST_RULE;
apply_rule = oma_match_anonymous_condition(node2, subs, &w_uri);
break;
}
else if(xmlStrcasecmp(node2->name, (unsigned char*)"other-identity") == 0)
{
current_node_type = OTHER_IDENTITY_RULE;
apply_rule = 1;
break;
}
else
{
/* unknown condition */
continue;
}
}
/* finished scanning all conditions for a given rule */
if (apply_rule)
{
tmp_rule = (xcap_rule_t *)pkg_malloc(sizeof(*tmp_rule));
if (tmp_rule == NULL)
{
LM_ERR("pkg mem\n");
goto error;
}
tmp_rule->node = current_node;
tmp_rule->next = NULL;
switch (current_node_type)
{
case IDENTITY_RULE:
if(identity_rules == NULL)
identity_rules = tmp_rule;
else
identity_tail->next = tmp_rule;
identity_tail = tmp_rule;
break;
case EXTERNAL_LIST_RULE:
if(external_rules == NULL)
external_rules = tmp_rule;
else
external_tail->next = tmp_rule;
external_tail = tmp_rule;
break;
case ANONYMOUS_REQUEST_RULE:
if(anonymous_rules == NULL)
anonymous_rules = tmp_rule;
else
anonymous_tail->next = tmp_rule;
anonymous_tail = tmp_rule;
break;
case OTHER_IDENTITY_RULE:
if(other_identity_rules == NULL)
other_identity_rules = tmp_rule;
else
other_identity_tail->next = tmp_rule;
other_identity_tail = tmp_rule;
break;
default:
/* this will never happen */
break;
}
}
}
if (anonymous_rules)
{
*rules = anonymous_rules;
free_rules(identity_rules);
free_rules(external_rules);
free_rules(other_identity_rules);
}
else if (identity_rules)
{
*rules = identity_rules;
free_rules(external_rules);
free_rules(anonymous_rules);
free_rules(other_identity_rules);
}
else if (external_rules)
{
*rules = external_rules;
free_rules(identity_rules);
free_rules(anonymous_rules);
free_rules(other_identity_rules);
}
else if (other_identity_rules)
{
*rules = other_identity_rules;
free_rules(identity_rules);
free_rules(external_rules);
free_rules(anonymous_rules);
}
else
{
*rules = NULL;
LM_DBG("no matching rules found\n");
}
pkg_free(w_uri.s);
return;
error:
if (w_uri.s)
pkg_free(w_uri.s);
free_rules(identity_rules);
free_rules(external_rules);
free_rules(anonymous_rules);
free_rules(other_identity_rules);
}
