jingle-ibb/ibb.c
changeset 133 361d8577ebd1
parent 131 943c3f938cb4
child 141 8bc73e965a07
equal deleted inserted replaced
132:4fef4ced1e97 133:361d8577ebd1
    39 #include "ibb.h"
    39 #include "ibb.h"
    40 
    40 
    41 static LmMessageHandler* jingle_ibb_handler = NULL;
    41 static LmMessageHandler* jingle_ibb_handler = NULL;
    42 
    42 
    43 static gconstpointer check(JingleContent *cn, GError **err);
    43 static gconstpointer check(JingleContent *cn, GError **err);
    44 static gboolean cmp(gconstpointer data1, gconstpointer data2);
       
    45 static void tomessage(gconstpointer data, LmMessageNode *node);
    44 static void tomessage(gconstpointer data, LmMessageNode *node);
    46 static gconstpointer new(void);
    45 static gconstpointer new(void);
    47 static void send(session_content *sc, gconstpointer data, gchar *buf, gsize size);
    46 static void send(session_content *sc, gconstpointer data, gchar *buf, gsize size);
    48 static void init(session_content *sc, gconstpointer data);
    47 static void init(session_content *sc, gconstpointer data);
    49 static void end(session_content *sc, gconstpointer data);
    48 static void end(session_content *sc, gconstpointer data);
    50 static gchar *info(gconstpointer data);
    49 static gchar *info(gconstpointer data);
       
    50 
    51 static void _send_internal(session_content *sc, const gchar *to, gchar *buf,
    51 static void _send_internal(session_content *sc, const gchar *to, gchar *buf,
    52                            gsize size, const gchar *sid, gint64 *seq);
    52                            gsize size, const gchar *sid, gint64 *seq);
    53 
    53                            
    54 static void jingle_ibb_init(void);
    54 static void jingle_ibb_init(void);
    55 static void jingle_ibb_uninit(void);
    55 static void jingle_ibb_uninit(void);
    56 
    56 
    57 
    57 
    58 static guint connect_hid = 0;
    58 static guint connect_hid = 0;
    61 const gchar *deps[] = { "jingle", NULL };
    61 const gchar *deps[] = { "jingle", NULL };
    62 
    62 
    63 static JingleTransportFuncs funcs = {
    63 static JingleTransportFuncs funcs = {
    64   .check     = check,
    64   .check     = check,
    65   .tomessage = tomessage,
    65   .tomessage = tomessage,
    66   .cmp       = cmp,
       
    67   .new       = new,
    66   .new       = new,
    68   .send      = send,
    67   .send      = send,
    69   .init      = init,
    68   .init      = init,
    70   .end       = end,
    69   .end       = end,
    71   .info      = info
    70   .info      = info
    83 };
    82 };
    84 
    83 
    85 /* Hash-Table of all emited JingleIBB struct */
    84 /* Hash-Table of all emited JingleIBB struct */
    86 static GHashTable *JingleIBBs = NULL;
    85 static GHashTable *JingleIBBs = NULL;
    87 
    86 
    88 
       
    89 static gconstpointer check(JingleContent *cn, GError **err)
    87 static gconstpointer check(JingleContent *cn, GError **err)
    90 {
    88 {
    91   JingleIBB *ibb = NULL;
    89   JingleIBB *ibb = NULL;
    92   LmMessageNode *node = cn->transport;
    90   LmMessageNode *node = cn->transport;
    93   const gchar *blocksize;
    91   const gchar *blocksize;
   126 LmHandlerResult jingle_ibb_handle_iq(LmMessageHandler *handler,
   124 LmHandlerResult jingle_ibb_handle_iq(LmMessageHandler *handler,
   127                                  LmConnection *connection, LmMessage *message,
   125                                  LmConnection *connection, LmMessage *message,
   128                                  gpointer user_data)
   126                                  gpointer user_data)
   129 {
   127 {
   130   const gchar *data64;
   128   const gchar *data64;
   131   JingleIBB *jibb = g_new0(JingleIBB, 1);
   129   JingleIBB *jibb = g_new0(JingleIBB, 1), *jibb2;
   132   gsize len;
   130   gsize len;
   133   guchar *data;
   131   guchar *data;
   134   
   132   
   135   LmMessageSubType iqtype = lm_message_get_sub_type(message);
   133   LmMessageSubType iqtype = lm_message_get_sub_type(message);
   136   if (iqtype != LM_MESSAGE_SUB_TYPE_SET)
   134   if (iqtype != LM_MESSAGE_SUB_TYPE_SET)
   142   if (!dnode) // no <data> element found
   140   if (!dnode) // no <data> element found
   143     return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
   141     return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
   144 
   142 
   145   if (g_strcmp0(lm_message_node_get_attribute(dnode, "xmlns"),
   143   if (g_strcmp0(lm_message_node_get_attribute(dnode, "xmlns"),
   146                 NS_TRANSPORT_IBB))
   144                 NS_TRANSPORT_IBB))
   147     return LM_HANDLER_RESULT_REMOVE_MESSAGE;
   145     return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
       
   146 
       
   147   jibb2 = g_hash_table_lookup(JingleIBBs,
       
   148                               lm_message_node_get_attribute(dnode, "sid"));
       
   149   if (jibb2 == NULL)
       
   150     return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
   148 
   151 
   149   jingle_ack_iq(message);
   152   jingle_ack_iq(message);
   150   
   153   
   151   jibb->sid = g_strdup(lm_message_node_get_attribute(dnode, "sid"));
   154   jibb->sid = g_strdup(lm_message_node_get_attribute(dnode, "sid"));
   152   jibb->seq = g_ascii_strtoll(lm_message_node_get_attribute(dnode, "seq"), NULL, 10);
   155   jibb->seq = g_ascii_strtoll(lm_message_node_get_attribute(dnode, "seq"), NULL, 10);
   153   
   156   
   154   data64 = lm_message_node_get_value(dnode);
   157   data64 = lm_message_node_get_value(dnode);
   155   
   158   
   156   data = g_base64_decode(data64, &len);
   159   data = g_base64_decode(data64, &len);
   157   
   160 
   158   handle_trans_data(NS_JINGLE_TRANSPORT_IBB, jibb, (const gchar *)data, (guint)len);
   161   handle_trans_data(jibb2, (const gchar *)data, (guint)len);
   159   
   162   
   160   return LM_HANDLER_RESULT_REMOVE_MESSAGE;
   163   return LM_HANDLER_RESULT_REMOVE_MESSAGE;
   161 }
       
   162 
       
   163 
       
   164 static gboolean cmp(gconstpointer data1, gconstpointer data2)
       
   165 {
       
   166   const JingleIBB *ibb1 = data1, *ibb2 = data2;
       
   167   if(g_strcmp0(ibb1->sid, ibb2->sid))
       
   168     return FALSE;
       
   169   return TRUE;
       
   170 }
   164 }
   171 
   165 
   172 static gchar *new_ibb_sid(void)
   166 static gchar *new_ibb_sid(void)
   173 {
   167 {
   174   gchar *sid;
   168   gchar *sid;