purple.c

Go to the documentation of this file.

/* OpenSER PURPLE MODULE
 * 
 * Copyright (C) 2008 Atos Worldline
 * Contact: Eric PTAK <eric.ptak@atosorigin.com>
 *
 * This program 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.
 *
 * This program 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, see <http://www.gnu.org/licenses/>.
 *
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <libxml/parser.h>

#include "../../db/db.h"
#include "../../sr_module.h"
#include "../../data_lump_rpl.h"
#include "../../parser/msg_parser.h"
#include "../../parser/parse_content.h"
#include "../../parser/parse_from.h"
#include "../tm/tm_load.h"
#include "../pua/pua_bind.h"
#include "../pua/pidf.h"

#include "purple.h"
#include "purplepipe.h"
#include "miniclient.h"
#include "namespaces.h"
 
MODULE_VERSION

static int init(void);
static void destroy(void);
static void runprocs(int rank);
static int func_send_message(struct sip_msg* msg);
static int func_handle_publish(struct sip_msg* msg);
static int func_handle_subscribe(struct sip_msg* msg, char* uri, char *expires);
static int fixup_subscribe(void** param, int param_no);

int pipefds[2] = {-1, -1};

db_con_t *pa_db = NULL;
db_func_t pa_dbf;
str db_table = {"purplemap", 0};
str db_url = {DEFAULT_RODB_URL, DEFAULT_RODB_URL_LEN};
str httpProxy_host = {NULL, 0};
int httpProxy_port = 3128;

/* TM functions */
struct tm_binds tmb;

/* functions imported from pua module*/
pua_api_t pua;
send_publish_t pua_send_publish;
send_subscribe_t pua_send_subscribe;
query_dialog_t pua_is_dialog;

/* libxml imported functions */
xmlNodeGetAttrContentByName_t XMLNodeGetAttrContentByName;
xmlDocGetNodeByName_t XMLDocGetNodeByName;
xmlNodeGetNodeByName_t XMLNodeGetNodeByName;
xmlNodeGetNodeContentByName_t XMLNodeGetNodeContentByName;

static proc_export_t procs[] = {
   {"PURPLE Client",  0,  0, runprocs, 1 },
   {0, 0, 0, 0, 0}
};

static cmd_export_t cmds[]={
   {"purple_send_message",    (cmd_function)func_send_message, 0, 0, 0, REQUEST_ROUTE},
   {"purple_handle_publish",  (cmd_function)func_handle_publish,  0, 0, 0, REQUEST_ROUTE},
   {"purple_handle_subscribe",   (cmd_function)func_handle_subscribe,   2, fixup_subscribe, 0, REQUEST_ROUTE},
   {0, 0, 0, 0, 0, 0} 
};

static param_export_t params[]={
   {"db_url",  STR_PARAM, &db_url.s},
   {"db_table",   STR_PARAM, &db_table.s},
   {"httpProxy_host", STR_PARAM, &httpProxy_host.s},
   {"httpProxy_port", INT_PARAM, &httpProxy_port},
   {0, 0, 0}
};

struct module_exports exports= {
        "purple",        /* module's name */
        DEFAULT_DLFLAGS, /* dlopen flags */
        cmds,            /* exported functions */
        params,          /* module parameters */
        0,               /* exported statistics */
        0,               /* exported MI functions */
        0,               /* exported pseudo-variables */
        procs,           /* extra processes */
        init,            /* module initialization function */
        0,               /* response function */
        destroy,         /* destroy function */
   0,               /* per-child init function */
};

 
static int init(void) {
   db_url.len = db_url.s ? strlen(db_url.s) : 0;
        db_table.len = db_table.s ? strlen(db_table.s) : 0;
   httpProxy_host.len = httpProxy_host.s ? strlen(httpProxy_host.s) : 0;

   LM_DBG("db_url=%s/%d/%p\n", ZSW(db_url.s), db_url.len,db_url.s);
   load_tm_f  load_tm;
   bind_pua_t bind_pua;
   bind_libxml_t bind_libxml;
   libxml_api_t libxml_api;

   LM_DBG("initializing...\n");

   /* import DB stuff */
   if (db_bind_mod(&db_url, &pa_dbf)) {
      LM_ERR("Database module not found\n");
      return -1;
   }

   pa_db = pa_dbf.init(&db_url);
   if (!pa_db) {
      LM_ERR("connecting database\n");
      return -1;
   }
   
   if (pa_dbf.use_table(pa_db, &db_table) < 0) {
      LM_ERR("in use_table\n");
      return -1;
   }

   if (pa_db && pa_dbf.close)
      pa_dbf.close(pa_db);


   /* import the TM auto-loading function */
   if((load_tm=(load_tm_f)find_export("load_tm", 0, 0))==NULL) {
      LM_ERR("can't import load_tm\n");
      return -1;
   }
   /* let the auto-loading function load all TM stuff */

   if(load_tm(&tmb)==-1) {
      LM_ERR("can't load tm functions\n");
      return -1;
   }

   /* bind libxml wrapper functions */
   if((bind_libxml= (bind_libxml_t)find_export("bind_libxml_api", 1, 0))== NULL) {
      LM_ERR("can't import bind_libxml_api\n");
      return -1;
   }
   if(bind_libxml(&libxml_api)< 0) {
      LM_ERR("can not bind libxml api\n");
      return -1;
   }

   XMLNodeGetAttrContentByName= libxml_api.xmlNodeGetAttrContentByName;
   XMLDocGetNodeByName= libxml_api.xmlDocGetNodeByName;
   XMLNodeGetNodeByName= libxml_api.xmlNodeGetNodeByName;
   XMLNodeGetNodeContentByName= libxml_api.xmlNodeGetNodeContentByName;

   if(XMLNodeGetAttrContentByName== NULL || XMLDocGetNodeByName== NULL ||
      XMLNodeGetNodeByName== NULL || XMLNodeGetNodeContentByName== NULL)
   {
      LM_ERR("libxml wrapper functions could not be bound\n");
      return -1;
   }

   /* bind pua */
   bind_pua= (bind_pua_t)find_export("bind_pua", 1,0);
   if (!bind_pua) {
      LM_ERR("Can't bind pua\n");
      return -1;
   }
   
   if (bind_pua(&pua) < 0) {
      LM_ERR("Can't bind pua\n");
      return -1;
   }
   if(pua.send_publish == NULL) {
      LM_ERR("Could not import send_publish\n");
      return -1;
   }
   pua_send_publish= pua.send_publish;

   if(pua.send_subscribe == NULL) {
      LM_ERR("Could not import send_subscribe\n");
      return -1;
   }
   pua_send_subscribe= pua.send_subscribe;
   
   if(pua.is_dialog == NULL) {
      LM_ERR("Could not import send_subscribe\n");
      return -1;
   }
   pua_is_dialog= pua.is_dialog;

// if(pua.register_puacb(PURPLE_PUBLISH, publish_reply_handler, NULL)< 0) {
//    LM_ERR("Could not register callback\n");
//    return -1;
// }  


   if (pipe(pipefds) < 0) {
      LM_ERR("pipe() failed\n");
      return -1;
   }

   return 0;
}
 
static void destroy(void) {
   LM_DBG("cleaning up...\n");
   close(pipefds[0]);
}

static void runprocs(int rank) {
   LM_DBG("initializing child process with PID %d\n", (int) getpid());
   close(pipefds[1]);
   
   miniclient_start(pipefds[0]);
}


static int func_send_message(struct sip_msg* msg) {
   str body, from_uri, dst, tagid;
   int mime;

   LM_DBG("handling MESSAGE\n");
   
   /* extract body */
   if (!(body.s = get_body(msg))) {
      LM_ERR("failed to extract body\n");
      return -1;
   }
   if (!msg->content_length) {
      LM_ERR("no content-length found\n");
      return -1;
   }
   body.len = get_content_length(msg);
   if ((mime = parse_content_type_hdr(msg)) < 1) {
      LM_ERR("failed parse content-type\n");
      return -1;
   }
   //if (mime != (TYPE_TEXT << 16) + SUBTYPE_PLAIN && mime != (TYPE_MESSAGE << 16) + SUBTYPE_CPIM) {
   if ((mime >> 16) != TYPE_TEXT) {
      LM_ERR("invalid content-type 0x%x\n", mime);
      return -1;
   }

   /* extract sender */
   if (parse_headers(msg, HDR_TO_F | HDR_FROM_F, 0) == -1 || !msg->to || !msg->from) {
      LM_ERR("no To/From headers\n");
      return -1;
   }
   if (parse_from_header(msg) < 0 || !msg->from->parsed) {
      LM_ERR("failed to parse From header\n");
      return -1;
   }
   from_uri = ((struct to_body *) msg->from->parsed)->uri;
   tagid = ((struct to_body *) msg->from->parsed)->tag_value;
   LM_DBG("message from <%.*s>\n", from_uri.len, from_uri.s);

   /* extract recipient */
   dst.len = 0;
   if (msg->new_uri.len > 0) {
      LM_DBG("using new URI as destination\n");
      dst = msg->new_uri;
   } else if (msg->first_line.u.request.uri.s 
         && msg->first_line.u.request.uri.len > 0) {
      LM_DBG("using R-URI as destination\n");
      dst = msg->first_line.u.request.uri;
   } else if (msg->to->parsed) {
      LM_DBG("using TO-URI as destination\n");
      dst = ((struct to_body *) msg->to->parsed)->uri;
   } else {
      LM_ERR("failed to find a valid destination\n");
      return -1;
   }
   
   if (purple_send_message_cmd(&from_uri, &dst, &body, &tagid) < 0) {
      LM_ERR("error sending message cmd via pipe\n");
      return -1;
   }
   else
      LM_DBG("message parsed and sent to pipe successfully\n");
   return 1;
}

static int func_handle_publish(struct sip_msg* msg) {
   str body, from_uri, tagid, note;
   enum purple_publish_basic basic;
   PurpleStatusPrimitive primitive;
   xmlDocPtr sip_doc= NULL;
   xmlNodePtr sip_root= NULL;
   xmlNodePtr node = NULL;
   char* basicstr= NULL, *notestr, notebuff[512];
   int mime;
   note.s = notebuff;
   note.len = 0;
   notebuff[0] = 0;

   LM_DBG("handling PUBLISH\n");
   
   /* extract body */
   if (!(body.s = get_body(msg))) {
      LM_ERR("failed to extract body\n");
      return -1;
   }
   if (!msg->content_length) {
      LM_ERR("no content-length found\n");
      return -1;
   }
   body.len = get_content_length(msg);
   mime = parse_content_type_hdr(msg);

   /* extract sender */
   if (parse_headers(msg, HDR_TO_F | HDR_FROM_F, 0) == -1 || !msg->to || !msg->from) {
      LM_ERR("no To/From headers\n");
      return -1;
   }
   if (parse_from_header(msg) < 0 || !msg->from->parsed) {
      LM_ERR("failed to parse From header\n");
      return -1;
   }
   from_uri = ((struct to_body *) msg->from->parsed)->uri;
   tagid = ((struct to_body *) msg->from->parsed)->tag_value;
   LM_DBG("publish from <%.*s>\n", from_uri.len, from_uri.s);

   if (mime == 0) {
      LM_DBG("no content-type\n");
      basic = PURPLE_BASIC_CLOSED;
      primitive = PURPLE_STATUS_OFFLINE;  
           if (purple_send_publish_cmd(basic, primitive, &from_uri, &tagid, &note) < 0) {
         LM_ERR("error sending publish cmd via pipe\n");
                   return -1;
      }
      LM_DBG("message parsed and sent to pipe successfully\n");
           return 1;       
   }

   /*extractiong the information from the sip message body*/
   sip_doc= xmlParseMemory(body.s, body.len);
   if(sip_doc== NULL) {
      LM_ERR("while parsing xml memory\n");
      return -1;
   }
   sip_root= XMLDocGetNodeByName(sip_doc, "presence", NULL);
   if(sip_root== NULL) {
      LM_ERR("while extracting 'presence' node\n");
      goto error;
   }
   
   node = XMLNodeGetNodeByName(sip_root, "basic", NULL);
   if(node== NULL) {
      LM_ERR("while extracting status basic node\n");
      goto error;
   }
   basicstr= (char*)xmlNodeGetContent(node);
   if(basicstr== NULL)  {
      LM_ERR("while extracting status basic node content\n");
      goto error;
   }
   if(xmlStrcasecmp( (unsigned char*)basicstr,(unsigned char*) "closed")==0 ) {
      basic = PURPLE_BASIC_CLOSED;
      primitive = PURPLE_STATUS_OFFLINE;
   }/* else the status is open so no type attr should be added */
   else {
      basic = PURPLE_BASIC_OPEN;
      primitive = PURPLE_STATUS_AVAILABLE;
   }
   
   node = NULL;
   node = XMLNodeGetNodeByName(sip_root, "note", "dm");
   if (node) {
      notestr = (char*) xmlNodeGetContent(node);
      if (notestr) {
         LM_DBG("found <dm:note>%s</dm:node>\n", notestr);
         if (xmlStrcasecmp((unsigned char*)notestr, (unsigned char*) "Busy")==0)
            primitive = PURPLE_STATUS_UNAVAILABLE;
         else if (xmlStrcasecmp((unsigned char*)notestr, (unsigned char*) "On the Phone")==0) {
            primitive = PURPLE_STATUS_UNAVAILABLE;
            note.len = sprintf(note.s, "On the Phone");
         }
         else if (xmlStrcasecmp((unsigned char*)notestr, (unsigned char*) "Away")==0)
            primitive = PURPLE_STATUS_AWAY;
         else if (xmlStrcasecmp((unsigned char*)notestr, (unsigned char*) "Idle")==0) {
            primitive = PURPLE_STATUS_AVAILABLE;
            note.len = sprintf(note.s, "Idle");
         }
         else
            note.len = sprintf(note.s, notestr);
      }
   }

   node = NULL;
   node = XMLNodeGetNodeByName(sip_root, "user-input", "rpid");
   if (node) {
      notestr = (char*) xmlNodeGetContent(node);
      if (notestr) {
         LM_DBG("found <rpid:user-input>%s</rpid:user-input>\n", notestr);
         note.len = sprintf(note.s, "%s", notestr);
      }
   }  

   if (purple_send_publish_cmd(basic, primitive, &from_uri, &tagid, &note) < 0) {
      LM_ERR("error sending publish cmd via pipe\n");
      return -1;
   }
   LM_DBG("message parsed and sent to pipe successfully\n");
   return 1;
   
error:
   if(sip_doc)
      xmlFreeDoc(sip_doc);
   xmlCleanupParser();
   xmlMemoryDump();

   return -1;  
   
}

static int func_handle_subscribe(struct sip_msg* msg, char* uri, char* expires) {
   str from, to;
   int iexpires = -1;
   char ruri_buff[512], expires_buff[512];
   int ruri_len = 511, expires_len = 511;
   
   if (pv_printf(msg, (pv_elem_t*)uri, ruri_buff, &ruri_len) < 0) {
      LM_ERR("cannot print ruri into the format\n");
      return -1;
   }
   
   if (pv_printf(msg, (pv_elem_t*)expires, expires_buff, &expires_len) < 0) {
      LM_ERR("cannot print expires into the format\n");
      return -1;
   }

   iexpires = atoi(expires_buff);
   
   /* extract sender */
   LM_DBG("handling SUBSCRIBE %s (%s)\n", ruri_buff, expires_buff);
   if (parse_headers(msg, HDR_TO_F | HDR_FROM_F, 0) == -1 || !msg->to || !msg->from) {
      LM_ERR("no To/From headers\n");
      return -1;
   }
   if (parse_from_header(msg) < 0 || !msg->from->parsed) {
      LM_ERR("failed to parse From header\n");
      return -1;
   }
   from.len = 0;
   from = ((struct to_body *) msg->from->parsed)->uri;

   /* extract recipient */
   to.len = 0;
   /*
   if (msg->new_uri.len > 0) {
      LM_DBG("using new URI as destination\n");
      to = msg->new_uri;
   } else if (msg->first_line.u.request.uri.s 
         && msg->first_line.u.request.uri.len > 0) {
      LM_DBG("using R-URI as destination\n");
      to = msg->first_line.u.request.uri;
   } else */
   if (msg->to->parsed) {
      LM_DBG("using TO-URI as destination\n");
      to = ((struct to_body *) msg->to->parsed)->uri;
   } else {
      LM_ERR("failed to find a valid destination\n");
      return -1;
   }
   
   if (purple_send_subscribe_cmd(&from, &to, iexpires) < 0) {
      LM_ERR("error sending subscribe cmd via pipe\n");
      return -1;
   }
   LM_DBG("subscribe parsed and sent to pipe successfully\n");
   return 1;
}

static int fixup_subscribe(void** param, int param_no) {
   pv_elem_t *model;
   str s;
   if(*param) {
      s.s = (char*)(*param); s.len = strlen(s.s);
      if(pv_parse_format(&s, &model)<0) {
         LM_ERR("wrong format[%s]\n",(char*)(*param));
         return E_UNSPEC;
      }
      *param = (void*)model;
      return 1;
   }
   LM_ERR("null format\n");
   return E_UNSPEC;
}