presentity.c

Go to the documentation of this file.

/*
 * $Id: presentity.c 5619 2009-02-18 18:33:43Z miconda $
 *
 * presence module - presence server implementation
 *
 * Copyright (C) 2006 Voice Sistem S.R.L.
 *
 * This file is part of Kamailio, a free SIP server.
 *
 * Kamailio is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version
 *
 * Kamailio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License 
 * along with this program; if not, write to the Free Software 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * History:
 * --------
 *  2006-08-15  initial version (anca)
 */

/*! \file
 * \brief Kamailio presence module :: Presentity handling
 * \ingroup presence 
 */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include "../../db/db.h"
#include "../../dprint.h"
#include "../../mem/shm_mem.h"
#include "../../str.h"
#include "../alias_db/alias_db.h"
#include "../../data_lump_rpl.h"
#include "presentity.h"
#include "presence.h" 
#include "notify.h"
#include "publish.h"
#include "hash.h"
#include "utils_func.h"


xmlNodePtr xmlNodeGetNodeByName(xmlNodePtr node, const char *name,
                                       const char *ns);
static str pu_200_rpl  = str_init("OK");
static str pu_412_rpl  = str_init("Conditional request failed");

#define ETAG_LEN  128

char* generate_ETag(int publ_count)
{
   char* etag= NULL;
   int size = 0;

   etag = (char*)pkg_malloc(ETAG_LEN*sizeof(char));
   if(etag ==NULL)
   {
      ERR_MEM(PKG_MEM_STR);
   }
   memset(etag, 0, ETAG_LEN*sizeof(char));
   size = snprintf (etag, ETAG_LEN, "%c.%d.%d.%d.%d",prefix, startup_time, pid, counter, publ_count);
   if( size <0 )
   {
      LM_ERR("unsuccessfull snprintf\n ");
      pkg_free(etag);
      return NULL;
   }
   if(size >= ETAG_LEN)
   {
      LM_ERR("buffer size overflown\n");
      pkg_free(etag);
      return NULL;
   }

   etag[size] = '\0';
   LM_DBG("etag= %s / %d\n ",etag, size);
   return etag;

error:
   return NULL;

}

int publ_send200ok(struct sip_msg *msg, int lexpire, str etag)
{
   char buf[128];
   int buf_len= 128, size;
   str hdr_append= {0, 0}, hdr_append2= {0, 0} ;

   LM_DBG("send 200OK reply\n"); 
   LM_DBG("etag= %s - len= %d\n", etag.s, etag.len);
   
   hdr_append.s = buf;
   hdr_append.s[0]='\0';
   hdr_append.len = snprintf(hdr_append.s, buf_len, "Expires: %d\r\n",
         ((lexpire==0)?0:(lexpire-expires_offset)));
   if(hdr_append.len < 0)
   {
      LM_ERR("unsuccessful snprintf\n");
      goto error;
   }
   if(hdr_append.len >= buf_len)
   {
      LM_ERR("buffer size overflown\n");
      goto error;
   }
   hdr_append.s[hdr_append.len]= '\0';
      
   if (add_lump_rpl( msg, hdr_append.s, hdr_append.len, LUMP_RPL_HDR)==0 )
   {
      LM_ERR("unable to add lump_rl\n");
      goto error;
   }

   size= sizeof(char)*(20+etag.len) ;
   hdr_append2.s = (char *)pkg_malloc(size);
   if(hdr_append2.s == NULL)
   {
      ERR_MEM(PKG_MEM_STR);
   }
   hdr_append2.s[0]='\0';
   hdr_append2.len = snprintf(hdr_append2.s, size, "SIP-ETag: %s\r\n", etag.s);
   if(hdr_append2.len < 0)
   {
      LM_ERR("unsuccessful snprintf\n ");
      goto error;
   }
   if(hdr_append2.len >= size)
   {
      LM_ERR("buffer size overflown\n");
      goto error;
   }

   hdr_append2.s[hdr_append2.len]= '\0';
   if (add_lump_rpl(msg, hdr_append2.s, hdr_append2.len, LUMP_RPL_HDR)==0 )
   {
      LM_ERR("unable to add lump_rl\n");
      goto error;
   }

   if( slb.send_reply( msg, 200, &pu_200_rpl)== -1)
   {
      LM_ERR("sending reply\n");
      goto error;
   }

   pkg_free(hdr_append2.s);
   return 0;

error:

   if(hdr_append2.s)
      pkg_free(hdr_append2.s);

   return -1;
}  
presentity_t* new_presentity( str* domain,str* user,int expires, 
      pres_ev_t* event, str* etag, str* sender)
{
   presentity_t *presentity= NULL;
   int size, init_len;
   
   /* allocating memory for presentity */
   size = sizeof(presentity_t)+ domain->len+ user->len+ etag->len +1;
   if(sender)
      size+= sizeof(str)+ sender->len* sizeof(char);
   
   init_len= size;

   presentity = (presentity_t*)pkg_malloc(size);
   if(presentity == NULL)
   {
      ERR_MEM(PKG_MEM_STR);
   }
   memset(presentity, 0, size);
   size= sizeof(presentity_t);

   presentity->domain.s = (char*)presentity+ size;
   strncpy(presentity->domain.s, domain->s, domain->len);
   presentity->domain.len = domain->len;
   size+= domain->len;  
   
   presentity->user.s = (char*)presentity+size;
   strncpy(presentity->user.s, user->s, user->len);
   presentity->user.len = user->len;
   size+= user->len;

   presentity->etag.s = (char*)presentity+ size;
   memcpy(presentity->etag.s, etag->s, etag->len);
   presentity->etag.s[etag->len]= '\0';
   presentity->etag.len = etag->len;

   size+= etag->len+1;
   
   if(sender)
   {
      presentity->sender= (str*)((char*)presentity+ size);
      size+= sizeof(str);
      presentity->sender->s= (char*)presentity + size;
      memcpy(presentity->sender->s, sender->s, sender->len);
      presentity->sender->len= sender->len;
      size+= sender->len;
   }

   if(size> init_len)
   {
      LM_ERR("buffer size overflow init_len= %d, size= %d\n", init_len, size);
      goto error;
   }
   presentity->event= event;
   presentity->expires = expires;
   presentity->received_time= (int)time(NULL);
   return presentity;
    
error:
   if(presentity)
      pkg_free(presentity);
   return NULL;
}

xmlNodePtr xmlNodeGetChildByName(xmlNodePtr node, const char *name)
{
   xmlNodePtr cur = node->children;
   while (cur) {
      if (xmlStrcasecmp(cur->name, (unsigned char*)name) == 0)
         return cur;
      cur = cur->next;
   }
   return NULL;
}

int check_if_dialog(str body, int *is_dialog)
{
   xmlDocPtr doc;
   xmlNodePtr node;

   doc = xmlParseMemory(body.s, body.len);
   if(doc== NULL)
   {
      LM_ERR("failed to parse xml document\n");
      return -1;
   }

   node = doc->children;
   node = xmlNodeGetChildByName(node, "dialog");

   if(node == NULL)
      *is_dialog = 0;
   else
      *is_dialog = 1;

   xmlFreeDoc(doc);
   return 0;
}


int update_presentity(struct sip_msg* msg, presentity_t* presentity, str* body,
      int new_t, int* sent_reply, char* sphere)
{
   db_key_t query_cols[12], update_keys[8], result_cols[5];
   db_op_t  query_ops[12];
   db_val_t query_vals[12], update_vals[8];
   db_res_t *result= NULL;
   int n_query_cols = 0;
   int n_update_cols = 0;
   char* dot= NULL;
   str etag= {0, 0};
   str cur_etag= {0, 0};
   str* rules_doc= NULL;
   str pres_uri= {0, 0};
   int rez_body_col, rez_sender_col, n_result_cols= 0;
   db_row_t *row = NULL ;
   db_val_t *row_vals = NULL;
   str old_body, sender;
   int is_dialog= 0, bla_update_publish= 1;

   *sent_reply= 0;
   if(presentity->event->req_auth)
   {
      /* get rules_document */
      if(presentity->event->get_rules_doc(&presentity->user,
               &presentity->domain, &rules_doc))
      {
         LM_ERR("getting rules doc\n");
         goto error;
      }
   }
   
   if(uandd_to_uri(presentity->user, presentity->domain, &pres_uri)< 0)
   {
      LM_ERR("constructing uri from user and domain\n");
      goto error;
   }


   query_cols[n_query_cols] = &str_domain_col;
   query_ops[n_query_cols] = OP_EQ;
   query_vals[n_query_cols].type = DB_STR;
   query_vals[n_query_cols].nul = 0;
   query_vals[n_query_cols].val.str_val = presentity->domain;
   n_query_cols++;
   
   query_cols[n_query_cols] = &str_username_col;
   query_ops[n_query_cols] = OP_EQ;
   query_vals[n_query_cols].type = DB_STR;
   query_vals[n_query_cols].nul = 0;
   query_vals[n_query_cols].val.str_val = presentity->user;
   n_query_cols++;

   query_cols[n_query_cols] = &str_event_col;
   query_ops[n_query_cols] = OP_EQ;
   query_vals[n_query_cols].type = DB_STR;
   query_vals[n_query_cols].nul = 0;
   query_vals[n_query_cols].val.str_val = presentity->event->name;
   n_query_cols++;

   query_cols[n_query_cols] = &str_etag_col;
   query_ops[n_query_cols] = OP_EQ;
   query_vals[n_query_cols].type = DB_STR;
   query_vals[n_query_cols].nul = 0;
   query_vals[n_query_cols].val.str_val = presentity->etag;
   n_query_cols++;

   result_cols[rez_body_col= n_result_cols++] = &str_body_col;
   result_cols[rez_sender_col= n_result_cols++] = &str_sender_col;

   if(new_t) 
   {
      /* insert new record in hash_table */
   
      if(insert_phtable(&pres_uri, presentity->event->evp->parsed, sphere)< 0)
      {
         LM_ERR("inserting record in hash table\n");
         goto error;
      }
      
      /* insert new record into database */  
      query_cols[n_query_cols] = &str_expires_col;
      query_vals[n_query_cols].type = DB_INT;
      query_vals[n_query_cols].nul = 0;
      query_vals[n_query_cols].val.int_val = presentity->expires+
            (int)time(NULL);
      n_query_cols++;
   
      if( presentity->sender)
      {
         query_cols[n_query_cols] = &str_sender_col;
         query_vals[n_query_cols].type = DB_STR;
         query_vals[n_query_cols].nul = 0;
         query_vals[n_query_cols].val.str_val.s = presentity->sender->s;
         query_vals[n_query_cols].val.str_val.len = presentity->sender->len;
         n_query_cols++;
      }

      query_cols[n_query_cols] = &str_body_col;
      query_vals[n_query_cols].type = DB_BLOB;
      query_vals[n_query_cols].nul = 0;
      query_vals[n_query_cols].val.str_val = *body;
      n_query_cols++;
      
      query_cols[n_query_cols] = &str_received_time_col;
      query_vals[n_query_cols].type = DB_INT;
      query_vals[n_query_cols].nul = 0;
      query_vals[n_query_cols].val.int_val = presentity->received_time;
      n_query_cols++;
      
      if (pa_dbf.use_table(pa_db, &presentity_table) < 0) 
      {
         LM_ERR("unsuccessful use_table\n");
         goto error;
      }

      LM_DBG("inserting %d cols into table\n",n_query_cols);
            
      if (pa_dbf.insert(pa_db, query_cols, query_vals, n_query_cols) < 0) 
      {
         LM_ERR("inserting new record in database\n");
         goto error;
      }
      if( publ_send200ok(msg, presentity->expires, presentity->etag)< 0)
      {
         LM_ERR("sending 200OK\n");
         goto error;
      }
      *sent_reply= 1;
      goto send_notify;
   }
   else
   {  
      if (pa_dbf.use_table(pa_db, &presentity_table) < 0) 
      {
         LM_ERR("unsuccessful sql use table\n");
         goto error;
      }

      if (pa_dbf.query (pa_db, query_cols, query_ops, query_vals,
          result_cols, n_query_cols, n_result_cols, 0, &result) < 0) 
      {
         LM_ERR("unsuccessful sql query\n");
         goto error;
      }
      if(result== NULL)
         goto error;

      if (result->n > 0)
      {

         if(presentity->event->evp->parsed == EVENT_DIALOG_SLA)
         {
            /* analize if previous body has a dialog */
            row = &result->rows[0];
            row_vals = ROW_VALUES(row);

            old_body.s = (char*)row_vals[rez_body_col].val.string_val;
            old_body.len = strlen(old_body.s);
            if(check_if_dialog(*body, &is_dialog)< 0)
            {
               LM_ERR("failed to check if dialog stored\n");
               goto error;
            }

            if(is_dialog== 1)  /* if the new body has a dialog - overwrite */
               goto after_dialog_check;

            if(check_if_dialog(old_body, &is_dialog)< 0)
            {
               LM_ERR("failed to check if dialog stored\n");
               goto error;
            }

            if(is_dialog==0 ) /* if the old body has no dialog - overwrite */
               goto after_dialog_check;

            sender.s = (char*)row_vals[rez_sender_col].val.string_val;
            sender.len= strlen(sender.s);

            LM_DBG("old_sender = %.*s\n", sender.len, sender.s );
            if(presentity->sender)
            {
               if(!(presentity->sender->len == sender.len && 
               strncmp(presentity->sender->s, sender.s, sender.len)== 0))
                   bla_update_publish= 0;
            }
         }
after_dialog_check:

         pa_dbf.free_result(pa_db, result);
         result= NULL;
         if(presentity->expires == 0) 
         {
            if( publ_send200ok(msg, presentity->expires, presentity->etag)< 0)
            {
               LM_ERR("sending 200OK reply\n");
               goto error;
            }
            *sent_reply= 1;
            if( publ_notify( presentity, pres_uri, body, &presentity->etag, rules_doc)< 0 )
            {
               LM_ERR("while sending notify\n");
               goto error;
            }
            
            if (pa_dbf.use_table(pa_db, &presentity_table) < 0) 
            {
               LM_ERR("unsuccessful sql use table\n");
               goto error;
            }

            LM_DBG("expires =0 -> deleting from database\n");
            if(pa_dbf.delete(pa_db,query_cols,0,query_vals,n_query_cols)<0)
            {
               LM_ERR("unsuccessful sql delete operation");
               goto error;
            }
            LM_DBG("deleted from db %.*s\n", presentity->user.len,
                  presentity->user.s);

            /* delete from hash table */
   
            if(delete_phtable(&pres_uri, presentity->event->evp->parsed)< 0)
            {
               LM_ERR("deleting record from hash table\n");
               goto error;
            }
            goto done;
         }

         n_update_cols= 0;
         /* if event dialog and is_dialog -> if sender not the same as
          * old sender do not overwrite */
         if( (presentity->event->evp->parsed == EVENT_DIALOG_SLA) &&  bla_update_publish==0)
         {
            LM_DBG("drop Publish for BLA from a different sender that"
                  " wants to overwrite an existing dialog\n");
            LM_DBG("sender = %.*s\n",  presentity->sender->len, presentity->sender->s );
            if( publ_send200ok(msg, presentity->expires, presentity->etag)< 0)
            {
               LM_ERR("sending 200OK reply\n");
               goto error;
            }
            *sent_reply= 1;
            goto done;
         }

         if(presentity->event->etag_not_new== 0)
         {  
            /* generate another etag */
            unsigned int publ_nr;
            str str_publ_nr= {0, 0};

            dot= presentity->etag.s+ presentity->etag.len;
            while(*dot!= '.' && str_publ_nr.len< presentity->etag.len)
            {
               str_publ_nr.len++;
               dot--;
            }
            if(str_publ_nr.len== presentity->etag.len)
            {
               LM_ERR("wrong etag\n");
               goto error;
            }  
            str_publ_nr.s= dot+1;
            str_publ_nr.len--;
   
            if( str2int(&str_publ_nr, &publ_nr)< 0)
            {
               LM_ERR("converting string to int\n");
               goto error;
            }
            etag.s = generate_ETag(publ_nr+1);
            if(etag.s == NULL)
            {
               LM_ERR("while generating etag\n");
               goto error;
            }
            etag.len=(strlen(etag.s));
            
            cur_etag= etag;

            update_keys[n_update_cols] = &str_etag_col;
            update_vals[n_update_cols].type = DB_STR;
            update_vals[n_update_cols].nul = 0;
            update_vals[n_update_cols].val.str_val = etag;
            n_update_cols++;

         }
         else
            cur_etag= presentity->etag;
         
         update_keys[n_update_cols] = &str_expires_col;
         update_vals[n_update_cols].type = DB_INT;
         update_vals[n_update_cols].nul = 0;
         update_vals[n_update_cols].val.int_val= presentity->expires +
            (int)time(NULL);
         n_update_cols++;

         update_keys[n_update_cols] = &str_received_time_col;
         update_vals[n_update_cols].type = DB_INT;
         update_vals[n_update_cols].nul = 0;
         update_vals[n_update_cols].val.int_val= presentity->received_time;
         n_update_cols++;

         if(body && body->s)
         {
            update_keys[n_update_cols] = &str_body_col;
            update_vals[n_update_cols].type = DB_BLOB;
            update_vals[n_update_cols].nul = 0;
            update_vals[n_update_cols].val.str_val = *body;
            n_update_cols++;

            /* updated stored sphere */
            if(sphere_enable && 
                  presentity->event->evp->parsed== EVENT_PRESENCE)
            {
               if(update_phtable(presentity, pres_uri, *body)< 0)
               {
                  LM_ERR("failed to update sphere for presentity\n");
                  goto error;
               }
            }
         }
         
         if( presentity->sender)
         {
            update_keys[n_update_cols] = &str_sender_col;
            update_vals[n_update_cols].type = DB_STR;
            update_vals[n_update_cols].nul = 0;
            update_vals[n_update_cols].val.str_val = *presentity->sender;
            n_update_cols++;
         }

         if( pa_dbf.update( pa_db,query_cols, query_ops, query_vals,
               update_keys, update_vals, n_query_cols, n_update_cols )<0) 
         {
            LM_ERR("updating published info in database\n");
            goto error;
         }
         
         /* send 200OK */
         if( publ_send200ok(msg, presentity->expires, cur_etag)< 0)
         {
            LM_ERR("sending 200OK reply\n");
            goto error;
         }
         *sent_reply= 1;
         
         if(etag.s)
            pkg_free(etag.s);
         etag.s= NULL;
         
         if(!body)
            goto done;
      
         goto send_notify;
      }  
      else  /* if there isn't no registration with those 3 values */
      {
         pa_dbf.free_result(pa_db, result);
         result= NULL;
         LM_ERR("No E_Tag match\n");
         if (slb.send_reply(msg, 412, &pu_412_rpl) == -1)
         {
            LM_ERR("sending '412 Conditional request failed' reply\n");
            goto error;
         }
         *sent_reply= 1;
         goto done;
      }
   }

send_notify:
         
   /* send notify with presence information */
   if (publ_notify(presentity, pres_uri, body, NULL, rules_doc)<0)
   {
      LM_ERR("while sending Notify requests to watchers\n");
      goto error;
   }

done:
   if(rules_doc)
   {
      if(rules_doc->s)
         pkg_free(rules_doc->s);
      pkg_free(rules_doc);
   }
   if(pres_uri.s)
      pkg_free(pres_uri.s);

   return 0;

error:
   if(result)
      pa_dbf.free_result(pa_db, result);
   if(etag.s)
      pkg_free(etag.s);
   if(rules_doc)
   {
      if(rules_doc->s)
         pkg_free(rules_doc->s);
      pkg_free(rules_doc);
   }
   if(pres_uri.s)
      pkg_free(pres_uri.s);

   return -1;

}

int pres_htable_restore(void)
{
   /* query all records from presentity table and insert records 
    * in presentity table */
   db_key_t result_cols[6];
   db_res_t *result= NULL;
   db_row_t *row= NULL ;   
   db_val_t *row_vals;
   int  i;
   str user, domain, ev_str, uri, body;
   int n_result_cols= 0;
   int user_col, domain_col, event_col, expires_col, body_col = 0;
   int event;
   event_t ev;
   char* sphere= NULL;

   result_cols[user_col= n_result_cols++]= &str_username_col;
   result_cols[domain_col= n_result_cols++]= &str_domain_col;
   result_cols[event_col= n_result_cols++]= &str_event_col;
   result_cols[expires_col= n_result_cols++]= &str_expires_col;
   if(sphere_enable)
      result_cols[body_col= n_result_cols++]= &str_body_col;

   if (pa_dbf.use_table(pa_db, &presentity_table) < 0)
   {
      LM_ERR("unsuccessful use table sql operation\n");
      goto error;
   }
   static str query_str = str_init("username");
   if (pa_dbf.query (pa_db, 0, 0, 0,result_cols,0, n_result_cols,
            &query_str, &result) < 0)
   {
      LM_ERR("querying presentity\n");
      goto error;
   }
   if(result== NULL)
      goto error;

   if(result->n<= 0)
   {
      pa_dbf.free_result(pa_db, result);
      return 0;
   }
      
   for(i= 0; i< result->n; i++)
   {
      row = &result->rows[i];
      row_vals = ROW_VALUES(row);

      if(row_vals[expires_col].val.int_val< (int)time(NULL))
         continue;
      
      sphere= NULL;
      user.s= (char*)row_vals[user_col].val.string_val;
      user.len= strlen(user.s);
      domain.s= (char*)row_vals[domain_col].val.string_val;
      domain.len= strlen(domain.s);
      ev_str.s= (char*)row_vals[event_col].val.string_val;
      ev_str.len= strlen(ev_str.s);

      if(event_parser(ev_str.s, ev_str.len, &ev)< 0)
      {
         LM_ERR("parsing event\n");
         free_event_params(ev.params, PKG_MEM_TYPE);
         goto error;
      }
      event= ev.parsed;
      free_event_params(ev.params, PKG_MEM_TYPE);

      if(uandd_to_uri(user, domain, &uri)< 0)
      {
         LM_ERR("constructing uri\n");
         goto error;
      }
      /* insert in hash_table*/
   
      if(sphere_enable && event== EVENT_PRESENCE )
      {
         body.s= (char*)row_vals[body_col].val.string_val;
         body.len= strlen(body.s);
         sphere= extract_sphere(body);
      }

      if(insert_phtable(&uri, event, sphere)< 0)
      {
         LM_ERR("inserting record in presentity hash table");
         pkg_free(uri.s);
         if(sphere)
            pkg_free(sphere);
         goto error;
      }
      if(sphere)
         pkg_free(sphere);
      pkg_free(uri.s);
   }
   pa_dbf.free_result(pa_db, result);

   return 0;

error:
   if(result)
      pa_dbf.free_result(pa_db, result);
   return -1;  
}

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)*sizeof(char));
      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;
}

char* get_sphere(str* pres_uri)
{
   unsigned int hash_code;
   char* sphere= NULL;
   pres_entry_t* p;
   db_key_t query_cols[6];
   db_val_t query_vals[6];
   db_key_t result_cols[6];
   db_res_t *result = NULL;
   db_row_t *row= NULL ;   
   db_val_t *row_vals;
   int n_result_cols = 0;
   int n_query_cols = 0;
   struct sip_uri uri;
   str body;


   if(!sphere_enable)
      return NULL;

   /* search in hash table*/
   hash_code= core_hash(pres_uri, NULL, phtable_size);

   lock_get(&pres_htable[hash_code].lock);

   p= search_phtable(pres_uri, EVENT_PRESENCE, hash_code);

   if(p)
   {
      if(p->sphere)
      {
         sphere= (char*)pkg_malloc(strlen(p->sphere)* sizeof(char));
         if(sphere== NULL)
         {
            lock_release(&pres_htable[hash_code].lock);
            ERR_MEM(PKG_MEM_STR);
         }
         strcpy(sphere, p->sphere);
      }
      lock_release(&pres_htable[hash_code].lock);
      return sphere;
   }
   lock_release(&pres_htable[hash_code].lock);


   /* if record not found and fallback2db query database*/
   if(!fallback2db)
   {
      return NULL;
   }

   if(parse_uri(pres_uri->s, pres_uri->len, &uri)< 0)
   {
      LM_ERR("failed to parse presentity uri\n");
      goto error;
   }

   query_cols[n_query_cols] = &str_domain_col;
   query_vals[n_query_cols].type = DB_STR;
   query_vals[n_query_cols].nul = 0;
   query_vals[n_query_cols].val.str_val = uri.host;
   n_query_cols++;

   query_cols[n_query_cols] = &str_username_col;
   query_vals[n_query_cols].type = DB_STR;
   query_vals[n_query_cols].nul = 0;
   query_vals[n_query_cols].val.str_val = uri.user;
   n_query_cols++;

   query_cols[n_query_cols] = &str_event_col;
   query_vals[n_query_cols].type = DB_STR;
   query_vals[n_query_cols].nul = 0;
   query_vals[n_query_cols].val.str_val.s= "presence";
   query_vals[n_query_cols].val.str_val.len= 8;
   n_query_cols++;

   result_cols[n_result_cols++] = &str_body_col;
   
   if (pa_dbf.use_table(pa_db, &presentity_table) < 0) 
   {
      LM_ERR("in use_table\n");
      return NULL;
   }

   static str query_str = str_init("received_time");
   if (pa_dbf.query (pa_db, query_cols, 0, query_vals,
       result_cols, n_query_cols, n_result_cols, &query_str ,  &result) < 0) 
   {
      LM_ERR("failed to query %.*s table\n", presentity_table.len, presentity_table.s);
      if(result)
         pa_dbf.free_result(pa_db, result);
      return NULL;
   }
   
   if(result== NULL)
      return NULL;

   if (result->n<=0 )
   {
      LM_DBG("no published record found in database\n");
      pa_dbf.free_result(pa_db, result);
      return NULL;
   }

   row = &result->rows[result->n-1];
   row_vals = ROW_VALUES(row);
   if(row_vals[0].val.string_val== NULL)
   {
      LM_ERR("NULL notify body record\n");
      goto error;
   }

   body.s= (char*)row_vals[0].val.string_val;
   body.len= strlen(body.s);
   if(body.len== 0)
   {
      LM_ERR("Empty notify body record\n");
      goto error;
   }
   
   sphere= extract_sphere(body);

   pa_dbf.free_result(pa_db, result);

   return sphere;

error:
   if(result)
      pa_dbf.free_result(pa_db, result);
   return NULL;

}