jingle/action-handlers.c
changeset 52 d803c882a182
parent 48 3c08b78be871
child 58 daafe5b8a48d
equal deleted inserted replaced
51:0a13062d0a11 52:d803c882a182
    31 #include <jingle/check.h>
    31 #include <jingle/check.h>
    32 #include <jingle/sessions.h>
    32 #include <jingle/sessions.h>
    33 #include <jingle/register.h>
    33 #include <jingle/register.h>
    34 #include <jingle/send.h>
    34 #include <jingle/send.h>
    35 #include <jingle/action-handlers.h>
    35 #include <jingle/action-handlers.h>
    36 #include <jingle/general-handlers.h>
    36 
    37 
    37 
    38 extern LmMessageHandler* jingle_ack_iq_handler;
    38 extern LmMessageHandler* jingle_ack_iq_handler;
       
    39 
    39 
    40 
    40 void handle_content_accept(JingleNode *jn)
    41 void handle_content_accept(JingleNode *jn)
    41 {
    42 {
    42   GError *err = NULL;
    43   GError *err = NULL;
    43   GSList *child = NULL;
    44   GSList *child = NULL;
    53                   err->message);
    54                   err->message);
    54     jingle_send_iq_error(jn->message, "cancel", "bad-request", NULL);
    55     jingle_send_iq_error(jn->message, "cancel", "bad-request", NULL);
    55     return;
    56     return;
    56   }
    57   }
    57 
    58 
    58   /* it's better if there is at least one content elem */
    59   // it's better if there is at least one content elem
    59   if (g_slist_length(jn->content) < 1) {
    60   if (g_slist_length(jn->content) < 1) {
    60     jingle_send_iq_error(jn->message, "cancel", "bad-request", NULL);
    61     jingle_send_iq_error(jn->message, "cancel", "bad-request", NULL);
    61     return;
    62     return;
    62   }
    63   }
    63   
    64   
    86   const gchar *xmlns;
    87   const gchar *xmlns;
    87   JingleSession *sess;
    88   JingleSession *sess;
    88   JingleNode accept, reject;
    89   JingleNode accept, reject;
    89   JingleContent tmp_cn;
    90   JingleContent tmp_cn;
    90   LmMessage *r;
    91   LmMessage *r;
    91   ack_iq *elem;
    92 
    92 
    93   if (!check_contents(jn, &err)) {
    93   if (!check_contents(jn, &err)) {
    94     scr_log_print(LPRINT_DEBUG, "jingle: One of the content element was invalid (%s)",
    94     scr_log_print(LPRINT_DEBUG, "jingle: One of the content element was invalid (%s)",
    95                   err->message);
    95                   err->message);
    96     jingle_send_iq_error(jn->message, "cancel", "bad-request", NULL);
    96     jingle_send_iq_error(jn->message, "cancel", "bad-request", NULL);
    97     return;
    97     return;
    98   }
    98   }
    99 
    99 
   100   if (g_slist_length(jn->content) < 1) {
   100   /* it's better if there is at least one content elem */
   101     jingle_send_iq_error(jn->message, "cancel", "bad-request", NULL);
   101   if (g_slist_length(jn->content) < 1) {
   102     return;
   102     jingle_send_iq_error(jn->message, "cancel", "bad-request", NULL);
   103   }
   103     return;
   104 
   104   }
       
   105   
       
   106   // if a session with the same sid doesn't already exists
       
   107   if ((sess = session_find(jn)) == NULL) {
   105   if ((sess = session_find(jn)) == NULL) {
   108     jingle_send_iq_error(jn->message, "cancel", "item-not-found", "unknown-session");
   106     jingle_send_iq_error(jn->message, "cancel", "item-not-found", "unknown-session");
   109     return;
   107     return;
   110   }
   108   }
   111 
   109 
   143     session_add_content(sess, cn, JINGLE_SESSION_STATE_ACTIVE);
   141     session_add_content(sess, cn, JINGLE_SESSION_STATE_ACTIVE);
   144     accept.content = g_slist_append(accept.content, cn);
   142     accept.content = g_slist_append(accept.content, cn);
   145   }
   143   }
   146   
   144   
   147   if (g_slist_length(accept.content) != 0) {
   145   if (g_slist_length(accept.content) != 0) {
       
   146     JingleAckHandle *ackhandle = g_new0(JingleAckHandle, 1);
   148     r = lm_message_from_jinglenode(&accept, lm_message_get_from(jn->message));
   147     r = lm_message_from_jinglenode(&accept, lm_message_get_from(jn->message));
   149     if (r) {
   148     if (r) {
   150       elem->id = g_strdup(lm_message_get_id(r));
   149       ackhandle->callback = NULL;
   151       elem->callback = NULL;
   150       ackhandle->user_data = NULL;
   152       elem->udata = NULL;
   151       lm_connection_send_with_reply(lconnection, r,
   153       add_ack_wait(elem);
   152                                     jingle_new_ack_handler(ackhandle), &err);
   154       // TODO: errors
       
   155       lm_connection_send_with_reply(lconnection, r, jingle_ack_iq_handler, &err);
       
   156       lm_message_unref(r);
   153       lm_message_unref(r);
       
   154       if (err != NULL) {
       
   155         // TODO
       
   156       }
   157     }
   157     }
   158   }
   158   }
   159   
   159   
   160   if (g_slist_length(reject.content) != 0) {
   160   if (g_slist_length(reject.content) != 0) {
       
   161     JingleAckHandle *ackhandle = g_new0(JingleAckHandle, 1);
   161     r = lm_message_from_jinglenode(&reject, lm_message_get_from(jn->message));
   162     r = lm_message_from_jinglenode(&reject, lm_message_get_from(jn->message));
   162     if (r) {
   163     if (r) {
   163       elem->id = g_strdup(lm_message_get_id(r));
   164       ackhandle->callback = NULL;
   164       elem->callback = NULL;
   165       ackhandle->user_data = NULL;
   165       elem->udata = NULL;
   166       lm_connection_send_with_reply(lconnection, r,
   166       add_ack_wait(elem);
   167                                     jingle_new_ack_handler(ackhandle), &err);
   167       // TODO: errors
       
   168       lm_connection_send_with_reply(lconnection, r, jingle_ack_iq_handler, &err);
       
   169       lm_message_unref(r);
   168       lm_message_unref(r);
       
   169       if (err != NULL) {
       
   170         // TODO
       
   171       }
   170     }
   172     }
   171   }
   173   }
   172 }
   174 }
   173 
   175 
   174 void handle_content_reject(JingleNode *jn)
   176 void handle_content_reject(JingleNode *jn)
   187                   err->message);
   189                   err->message);
   188     jingle_send_iq_error(jn->message, "cancel", "bad-request", NULL);
   190     jingle_send_iq_error(jn->message, "cancel", "bad-request", NULL);
   189     return;
   191     return;
   190   }
   192   }
   191 
   193 
   192   /* it's better if there is at least one content elem */
   194   if (g_slist_length(jn->content) < 1) {
   193   if (g_slist_length(jn->content) < 1) {
   195     jingle_send_iq_error(jn->message, "cancel", "bad-request", NULL);
   194     jingle_send_iq_error(jn->message, "cancel", "bad-request", NULL);
   196     return;
   195     return;
   197   }
   196   }
   198 
   197   
       
   198   // if a session with the same sid doesn't already exists
       
   199   if ((sess = session_find(jn)) == NULL) {
   199   if ((sess = session_find(jn)) == NULL) {
   200     jingle_send_iq_error(jn->message, "cancel", "item-not-found", "unknown-session");
   200     jingle_send_iq_error(jn->message, "cancel", "item-not-found", "unknown-session");
   201     return;
   201     return;
   202   }
   202   }
   203 
   203 
   261   JingleContent *cn;
   261   JingleContent *cn;
   262   GString *sbuf;
   262   GString *sbuf;
   263   GSList *child = NULL;
   263   GSList *child = NULL;
   264   LmMessage *r;
   264   LmMessage *r;
   265   
   265   
   266   // Make sure the from are an user in our roster
   266   // Make sure the request come from an user in our roster
   267   if (!roster_find(jidtodisp(lm_message_get_from(jn->message)), jidsearch, 0)) {
   267   if (!roster_find(jidtodisp(lm_message_get_from(jn->message)), jidsearch, 0)) {
   268     jingle_send_session_terminate(jn, "decline");
   268     jingle_send_session_terminate(jn, "decline");
   269     jingle_free_jinglenode(jn);
   269     jingle_free_jinglenode(jn);
   270     return;
   270     return;
   271   }
   271   }