str* xml_dialog2presence(str* pres_uri, str* body)
{
xmlDocPtr dlg_doc = NULL;
xmlNodePtr node, dialog_node;
unsigned char* state;
int i;
if(body->len == 0)
return NULL;
dlg_doc = xmlParseMemory(body->s, body->len);
if(dlg_doc == NULL)
{
LM_ERR("Wrong formatted xml document\n");
return NULL;
}
dialog_node = xmlNodeGetNodeByName(dlg_doc->children, "dialog", 0);
if(!dialog_node)
{
goto done;
}
node = xmlNodeGetNodeByName(dialog_node, "state", 0);
if(!node)
goto done;
state = xmlNodeGetContent(node);
if(!state)
goto done;
for(i = 0; i< DLG_STATES_NO; i++)
{
if(xmlStrcasecmp(state, BAD_CAST dialog_states[i])==0)
{
break;
}
}
xmlFree(state);
xmlFreeDoc(dlg_doc);
xmlCleanupParser();
xmlMemoryDump();
if(i == DLG_STATES_NO)
{
LM_ERR("Unknown dialog state\n");
return 0;
}
return xml_dialog_gen_presence(pres_uri, i);
done:
xmlFreeDoc(dlg_doc);
return 0;
}
char *xmlNodeGetNodeContentByName(xmlNodePtr root, const char *name, const char *ns)
{
xmlNodePtr node = xmlNodeGetNodeByName(root, name, ns);
if (node)
return (char*)xmlNodeGetContent(node->children);
else
return NULL;
}
char* extract_sphere(str body)
{
/* check for a rpid sphere element */
xmlDocPtr doc= NULL;
xmlNodePtr node;
char* cont, *sphere= NULL;
doc= xmlParseMemory(body.s, body.len);
if(doc== NULL)
{
LM_ERR("failed to parse xml body\n");
return NULL;
}
node= xmlNodeGetNodeByName(doc->children, "sphere", "rpid");
if(node== NULL)
node= xmlNodeGetNodeByName(doc->children, "sphere", "r");
if(node)
{
LM_DBG("found sphere definition\n");
cont= (char*)xmlNodeGetContent(node);
if(cont== NULL)
{
LM_ERR("failed to extract sphere node content\n");
goto error;
}
sphere= (char*)pkg_malloc(strlen(cont)+ 1);
if(sphere== NULL)
{
xmlFree(cont);
ERR_MEM(PKG_MEM_STR);
}
strcpy(sphere, cont);
xmlFree(cont);
}
else
LM_DBG("didn't find sphere definition\n");
error:
xmlFreeDoc(doc);
return sphere;
}
xmlNodePtr xmlNodeGetNodeByName(xmlNodePtr node, const char *name, const char *ns)
{
xmlNodePtr cur = node;
while (cur) {
xmlNodePtr match = NULL;
if (xmlStrcasecmp(cur->name, (unsigned char*)name) == 0) {
if (!ns || (cur->ns && xmlStrcasecmp(cur->ns->prefix,
(unsigned char*)ns) == 0))
return cur;
}
match = xmlNodeGetNodeByName(cur->children, name, ns);
if (match)
return match;
cur = cur->next;
}
return NULL;
}
xmlNodePtr xmlDocGetNodeByName(xmlDocPtr doc, const char *name, const char *ns)
{
xmlNodePtr cur = doc->children;
return xmlNodeGetNodeByName(cur, name, ns);
}
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;
}
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);
goto error;
}
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);
if(presentity != NULL)
pres_free_presentity(presentity, ev);
return retval;
}
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 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;
}
