jingle-ibb/ibb.c
changeset 130 da01e4b2d7fa
parent 128 cded9f40039e
child 131 943c3f938cb4
equal deleted inserted replaced
129:2d5c3efda92a 130:da01e4b2d7fa
    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 static guint connect_hid = 0;
    58 static guint connect_hid = 0;
    58 static guint disconn_hid = 0;
    59 static guint disconn_hid = 0;
    59 
    60 
    60 const gchar *deps[] = { "jingle", NULL };
    61 const gchar *deps[] = { "jingle", NULL };
    61 
    62 
    79   .init            = jingle_ibb_init,
    80   .init            = jingle_ibb_init,
    80   .uninit          = jingle_ibb_uninit,
    81   .uninit          = jingle_ibb_uninit,
    81   .next            = NULL,
    82   .next            = NULL,
    82 };
    83 };
    83 
    84 
       
    85 /* Hash-Table of all emited JingleIBB struct */
       
    86 static GHashTable *JingleIBBs = NULL;
       
    87 
       
    88 
    84 static gconstpointer check(JingleContent *cn, GError **err)
    89 static gconstpointer check(JingleContent *cn, GError **err)
    85 {
    90 {
    86   JingleIBB *ibb = NULL;
    91   JingleIBB *ibb = NULL;
    87   LmMessageNode *node = cn->transport;
    92   LmMessageNode *node = cn->transport;
    88   const gchar *blocksize;
    93   const gchar *blocksize;
   113                 "block-size is negative");
   118                 "block-size is negative");
   114     g_free(ibb->sid);
   119     g_free(ibb->sid);
   115     g_free(ibb);
   120     g_free(ibb);
   116     return NULL;
   121     return NULL;
   117   }
   122   }
   118   
   123 
       
   124   g_hash_table_insert(JingleIBBs, ibb->sid, ibb);
   119   return (gconstpointer) ibb;
   125   return (gconstpointer) ibb;
   120 }
   126 }
   121 
   127 
   122 LmHandlerResult jingle_ibb_handle_iq(LmMessageHandler *handler,
   128 LmHandlerResult jingle_ibb_handle_iq(LmMessageHandler *handler,
   123                                  LmConnection *connection, LmMessage *message,
   129                                  LmConnection *connection, LmMessage *message,
   212                                  "block-size", bsize,
   218                                  "block-size", bsize,
   213                                  NULL);
   219                                  NULL);
   214   g_free(bsize);
   220   g_free(bsize);
   215 }
   221 }
   216 
   222 
   217 static void jingle_ibb_handle_ack_iq_send(LmMessage *mess, gpointer data)
   223 static void jingle_ibb_handle_ack_iq_send(JingleAckType type, LmMessage *mess,
       
   224                                           gpointer data)
   218 {
   225 {
   219   // TODO: check the sub type (error ??)
   226   // TODO: check the sub type (error ??)
   220   session_content *sc = (session_content *)data;
   227   session_content *sc = (session_content *)data;
   221   
   228   
   222   JingleSession *sess = session_find_by_sid(sc->sid, sc->from);
   229   JingleSession *sess = session_find_by_sid(sc->sid, sc->from);
   246 {
   253 {
   247   JingleAckHandle *ackhandle;
   254   JingleAckHandle *ackhandle;
   248   LmMessage *r = lm_message_new_with_sub_type(to, LM_MESSAGE_TYPE_IQ,
   255   LmMessage *r = lm_message_new_with_sub_type(to, LM_MESSAGE_TYPE_IQ,
   249                                               LM_MESSAGE_SUB_TYPE_SET);
   256                                               LM_MESSAGE_SUB_TYPE_SET);
   250   LmMessageNode *node = lm_message_get_node(r);
   257   LmMessageNode *node = lm_message_get_node(r);
   251   
   258 
   252   gchar *base64 = g_base64_encode((const guchar *)buf, size);
   259   gchar *base64 = g_base64_encode((const guchar *)buf, size);
   253   gchar *strseq = g_strdup_printf("%" G_GINT64_FORMAT, *seq);
   260   gchar *strseq = g_strdup_printf("%" G_GINT64_FORMAT, *seq);
   254 
   261 
   255   node = lm_message_node_add_child(node, "data", NULL);
   262   node = lm_message_node_add_child(node, "data", NULL);
   256   lm_message_node_set_attributes(node, "xmlns", NS_TRANSPORT_IBB,
   263   lm_message_node_set_attributes(node, "xmlns", NS_TRANSPORT_IBB,
   257                                  "sid", sid,
   264                                  "sid", sid,
   258                                  "seq", strseq,
   265                                  "seq", strseq,
   259                                  NULL);
   266                                  NULL);
   260   lm_message_node_set_value(node, base64);
   267   lm_message_node_set_value(node, base64);
   261   
   268 
   262   ackhandle = g_new0(JingleAckHandle, 1);
   269   ackhandle = g_new0(JingleAckHandle, 1);
   263   ackhandle->callback = jingle_ibb_handle_ack_iq_send;
   270   ackhandle->callback = jingle_ibb_handle_ack_iq_send;
   264   ackhandle->user_data = (gpointer)sc;
   271   ackhandle->user_data = (gpointer)sc;
   265  
   272 
   266   lm_connection_send_with_reply(lconnection, r,
   273   lm_connection_send_with_reply(lconnection, r,
   267                                 jingle_new_ack_handler(ackhandle), NULL);
   274                                 jingle_new_ack_handler(ackhandle), NULL);
   268   lm_message_unref(r);
   275   lm_message_unref(r);
   269   
   276 
   270   // The next packet will be seq++
   277   // The next packet will be seq++
   271   ++(*seq);
   278   ++(*seq);
   272   
   279 
   273   g_free(base64);
   280   g_free(base64);
   274   g_free(strseq);
   281   g_free(strseq);
   275 }
   282 }
   276 
   283 
   277 static void send(session_content *sc, gconstpointer data, gchar *buf,
   284 static void send(session_content *sc, gconstpointer data, gchar *buf,
   372   JingleIBB *jibb = (JingleIBB *)data;
   379   JingleIBB *jibb = (JingleIBB *)data;
   373   gchar *info = g_strdup_printf("IBB %i", jibb->blocksize);
   380   gchar *info = g_strdup_printf("IBB %i", jibb->blocksize);
   374   return info;
   381   return info;
   375 }
   382 }
   376 
   383 
       
   384 static void free_ibb(gpointer data)
       
   385 {
       
   386   JingleIBB *jibb = (JingleIBB *)data;
       
   387   g_free(jibb);
       
   388 }
       
   389 
   377 static void jingle_ibb_init(void)
   390 static void jingle_ibb_init(void)
   378 {
   391 {
   379   jingle_ibb_handler = lm_message_handler_new(jingle_ibb_handle_iq, NULL, NULL);
   392   jingle_ibb_handler = lm_message_handler_new(jingle_ibb_handle_iq, NULL, NULL);
   380   
   393   
   381   connect_hid = hk_add_handler(jingle_ibb_connect_hh, HOOK_POST_CONNECT,
   394   connect_hid = hk_add_handler(jingle_ibb_connect_hh, HOOK_POST_CONNECT,
   386   
   399   
   387   jingle_register_transport(NS_JINGLE_TRANSPORT_IBB, &funcs,
   400   jingle_register_transport(NS_JINGLE_TRANSPORT_IBB, &funcs,
   388                             JINGLE_TRANSPORT_STREAMING,
   401                             JINGLE_TRANSPORT_STREAMING,
   389                             JINGLE_TRANSPORT_LOW);
   402                             JINGLE_TRANSPORT_LOW);
   390   xmpp_add_feature(NS_JINGLE_TRANSPORT_IBB);
   403   xmpp_add_feature(NS_JINGLE_TRANSPORT_IBB);
       
   404   JingleIBBs = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, free_ibb);
   391 }
   405 }
   392 
   406 
   393 static void jingle_ibb_uninit(void)
   407 static void jingle_ibb_uninit(void)
   394 {
   408 {
   395   lm_message_handler_invalidate(jingle_ibb_handler);
   409   lm_message_handler_invalidate(jingle_ibb_handler);