1 /**
2 * Purple is the legal property of its developers, whose names are too numerous
3 * to list here. Please refer to the COPYRIGHT file distributed with this
4 * source distribution.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
19 */
20
21 #include "internal.h"
22 #include "debug.h"
23 #include "google_session.h"
24 #include "relay.h"
25
26 #include "jingle/jingle.h"
27
28 #ifdef USE_VV
29
30 typedef struct {
31 PurpleMedia *media;
32 gboolean video;
33 GList *remote_audio_candidates; /* list of PurpleMediaCandidate */
34 GList *remote_video_candidates; /* list of PurpleMediaCandidate */
35 gboolean added_streams; /* this indicates if the streams have been
36 to media (ie. after getting relay credentials */
37 } GoogleAVSessionData;
38
39 static gboolean
google_session_id_equal(gconstpointer a,gconstpointer b)40 google_session_id_equal(gconstpointer a, gconstpointer b)
41 {
42 GoogleSessionId *c = (GoogleSessionId*)a;
43 GoogleSessionId *d = (GoogleSessionId*)b;
44
45 return purple_strequal(c->id, d->id) && purple_strequal(c->initiator, d->initiator);
46 }
47
48 static void
google_session_destroy(GoogleSession * session)49 google_session_destroy(GoogleSession *session)
50 {
51 GoogleAVSessionData *session_data =
52 (GoogleAVSessionData *) session->session_data;
53 g_free(session->id.id);
54 g_free(session->id.initiator);
55 g_free(session->remote_jid);
56
57 if (session_data->remote_audio_candidates)
58 purple_media_candidate_list_free(session_data->remote_audio_candidates);
59
60 if (session_data->remote_video_candidates)
61 purple_media_candidate_list_free(session_data->remote_video_candidates);
62
63 if (session->description)
64 xmlnode_free(session->description);
65
66 g_free(session->session_data);
67 g_free(session);
68 }
69
70 static xmlnode *
google_session_create_xmlnode(GoogleSession * session,const char * type)71 google_session_create_xmlnode(GoogleSession *session, const char *type)
72 {
73 xmlnode *node = xmlnode_new("session");
74 xmlnode_set_namespace(node, NS_GOOGLE_SESSION);
75 xmlnode_set_attrib(node, "id", session->id.id);
76 xmlnode_set_attrib(node, "initiator", session->id.initiator);
77 xmlnode_set_attrib(node, "type", type);
78 return node;
79 }
80
81 static void
google_session_send_candidates(PurpleMedia * media,gchar * session_id,gchar * participant,GoogleSession * session)82 google_session_send_candidates(PurpleMedia *media, gchar *session_id,
83 gchar *participant, GoogleSession *session)
84 {
85 PurpleMedia *session_media =
86 ((GoogleAVSessionData *) session->session_data)->media;
87 GList *candidates =
88 purple_media_get_local_candidates(session_media, session_id,
89 session->remote_jid);
90 GList *iter;
91 PurpleMediaCandidate *transport;
92 gboolean video = FALSE;
93
94 if (purple_strequal(session_id, "google-video"))
95 video = TRUE;
96
97 for (iter = candidates; iter; iter = iter->next) {
98 JabberIq *iq;
99 gchar *ip, *port, *username, *password;
100 gchar pref[16];
101 PurpleMediaCandidateType type;
102 xmlnode *sess;
103 xmlnode *candidate;
104 guint component_id;
105 transport = PURPLE_MEDIA_CANDIDATE(iter->data);
106 component_id = purple_media_candidate_get_component_id(
107 transport);
108
109 iq = jabber_iq_new(session->js, JABBER_IQ_SET);
110 sess = google_session_create_xmlnode(session, "candidates");
111 xmlnode_insert_child(iq->node, sess);
112 xmlnode_set_attrib(iq->node, "to", session->remote_jid);
113
114 candidate = xmlnode_new("candidate");
115
116 ip = purple_media_candidate_get_ip(transport);
117 port = g_strdup_printf("%d",
118 purple_media_candidate_get_port(transport));
119 g_ascii_dtostr(pref, 16,
120 purple_media_candidate_get_priority(transport) / 1000.0);
121 username = purple_media_candidate_get_username(transport);
122 password = purple_media_candidate_get_password(transport);
123 type = purple_media_candidate_get_candidate_type(transport);
124
125 xmlnode_set_attrib(candidate, "address", ip);
126 xmlnode_set_attrib(candidate, "port", port);
127 xmlnode_set_attrib(candidate, "name",
128 component_id == PURPLE_MEDIA_COMPONENT_RTP ?
129 video ? "video_rtp" : "rtp" :
130 component_id == PURPLE_MEDIA_COMPONENT_RTCP ?
131 video ? "video_rtcp" : "rtcp" : "none");
132 xmlnode_set_attrib(candidate, "username", username);
133 /*
134 * As of this writing, Farsight 2 in Google compatibility
135 * mode doesn't provide a password. The Gmail client
136 * requires this to be set.
137 */
138 xmlnode_set_attrib(candidate, "password",
139 password != NULL ? password : "");
140 xmlnode_set_attrib(candidate, "preference", pref);
141 xmlnode_set_attrib(candidate, "protocol",
142 purple_media_candidate_get_protocol(transport)
143 == PURPLE_MEDIA_NETWORK_PROTOCOL_UDP ?
144 "udp" : "tcp");
145 xmlnode_set_attrib(candidate, "type", type ==
146 PURPLE_MEDIA_CANDIDATE_TYPE_HOST ? "local" :
147 type ==
148 PURPLE_MEDIA_CANDIDATE_TYPE_SRFLX ? "stun" :
149 type ==
150 PURPLE_MEDIA_CANDIDATE_TYPE_RELAY ? "relay" :
151 NULL);
152 xmlnode_set_attrib(candidate, "generation", "0");
153 xmlnode_set_attrib(candidate, "network", "0");
154 xmlnode_insert_child(sess, candidate);
155
156 g_free(ip);
157 g_free(port);
158 g_free(username);
159 g_free(password);
160
161 jabber_iq_send(iq);
162 }
163 purple_media_candidate_list_free(candidates);
164 }
165
166 static void
google_session_ready(GoogleSession * session)167 google_session_ready(GoogleSession *session)
168 {
169 PurpleMedia *media =
170 ((GoogleAVSessionData *)session->session_data)->media;
171 gboolean video =
172 ((GoogleAVSessionData *)session->session_data)->video;
173 if (purple_media_codecs_ready(media, NULL) &&
174 purple_media_candidates_prepared(media, NULL, NULL)) {
175 gchar *me = g_strdup_printf("%s@%s/%s",
176 session->js->user->node,
177 session->js->user->domain,
178 session->js->user->resource);
179 JabberIq *iq;
180 xmlnode *sess, *desc, *payload;
181 GList *codecs, *iter;
182 gboolean is_initiator = purple_strequal(session->id.initiator, me);
183
184 if (!is_initiator &&
185 !purple_media_accepted(media, NULL, NULL)) {
186 g_free(me);
187 return;
188 }
189
190 iq = jabber_iq_new(session->js, JABBER_IQ_SET);
191
192 if (is_initiator) {
193 xmlnode_set_attrib(iq->node, "to", session->remote_jid);
194 xmlnode_set_attrib(iq->node, "from", session->id.initiator);
195 sess = google_session_create_xmlnode(session, "initiate");
196 } else {
197 google_session_send_candidates(media,
198 "google-voice", session->remote_jid,
199 session);
200 google_session_send_candidates(media,
201 "google-video", session->remote_jid,
202 session);
203 xmlnode_set_attrib(iq->node, "to", session->remote_jid);
204 xmlnode_set_attrib(iq->node, "from", me);
205 sess = google_session_create_xmlnode(session, "accept");
206 }
207 xmlnode_insert_child(iq->node, sess);
208 desc = xmlnode_new_child(sess, "description");
209 if (video)
210 xmlnode_set_namespace(desc, NS_GOOGLE_SESSION_VIDEO);
211 else
212 xmlnode_set_namespace(desc, NS_GOOGLE_SESSION_PHONE);
213
214 codecs = purple_media_get_codecs(media, "google-video");
215
216 for (iter = codecs; iter; iter = g_list_next(iter)) {
217 PurpleMediaCodec *codec = (PurpleMediaCodec*)iter->data;
218 gchar *id = g_strdup_printf("%d",
219 purple_media_codec_get_id(codec));
220 gchar *encoding_name =
221 purple_media_codec_get_encoding_name(codec);
222 payload = xmlnode_new_child(desc, "payload-type");
223 xmlnode_set_attrib(payload, "id", id);
224 xmlnode_set_attrib(payload, "name", encoding_name);
225 xmlnode_set_attrib(payload, "width", "320");
226 xmlnode_set_attrib(payload, "height", "200");
227 xmlnode_set_attrib(payload, "framerate", "30");
228 g_free(encoding_name);
229 g_free(id);
230 }
231 purple_media_codec_list_free(codecs);
232
233 codecs = purple_media_get_codecs(media, "google-voice");
234
235 for (iter = codecs; iter; iter = g_list_next(iter)) {
236 PurpleMediaCodec *codec = (PurpleMediaCodec*)iter->data;
237 gchar *id = g_strdup_printf("%d",
238 purple_media_codec_get_id(codec));
239 gchar *encoding_name =
240 purple_media_codec_get_encoding_name(codec);
241 gchar *clock_rate = g_strdup_printf("%d",
242 purple_media_codec_get_clock_rate(codec));
243 payload = xmlnode_new_child(desc, "payload-type");
244 if (video)
245 xmlnode_set_namespace(payload, NS_GOOGLE_SESSION_PHONE);
246 xmlnode_set_attrib(payload, "id", id);
247 /*
248 * Hack to make Gmail accept speex as the codec.
249 * It shouldn't have to be case sensitive.
250 */
251 if (purple_strequal(encoding_name, "SPEEX"))
252 xmlnode_set_attrib(payload, "name", "speex");
253 else
254 xmlnode_set_attrib(payload, "name", encoding_name);
255 xmlnode_set_attrib(payload, "clockrate", clock_rate);
256 g_free(clock_rate);
257 g_free(encoding_name);
258 g_free(id);
259 }
260 purple_media_codec_list_free(codecs);
261
262 jabber_iq_send(iq);
263
264 if (is_initiator) {
265 google_session_send_candidates(media,
266 "google-voice", session->remote_jid,
267 session);
268 google_session_send_candidates(media,
269 "google-video", session->remote_jid,
270 session);
271 }
272
273 g_signal_handlers_disconnect_by_func(G_OBJECT(media),
274 G_CALLBACK(google_session_ready), session);
275 }
276 }
277
278 static void
google_session_state_changed_cb(PurpleMedia * media,PurpleMediaState state,gchar * sid,gchar * name,GoogleSession * session)279 google_session_state_changed_cb(PurpleMedia *media, PurpleMediaState state,
280 gchar *sid, gchar *name, GoogleSession *session)
281 {
282 if (sid == NULL && name == NULL) {
283 if (state == PURPLE_MEDIA_STATE_END) {
284 google_session_destroy(session);
285 }
286 }
287 }
288
289 static void
google_session_stream_info_cb(PurpleMedia * media,PurpleMediaInfoType type,gchar * sid,gchar * name,gboolean local,GoogleSession * session)290 google_session_stream_info_cb(PurpleMedia *media, PurpleMediaInfoType type,
291 gchar *sid, gchar *name, gboolean local,
292 GoogleSession *session)
293 {
294 if (sid != NULL || name != NULL)
295 return;
296
297 if (type == PURPLE_MEDIA_INFO_HANGUP) {
298 xmlnode *sess;
299 JabberIq *iq = jabber_iq_new(session->js, JABBER_IQ_SET);
300
301 xmlnode_set_attrib(iq->node, "to", session->remote_jid);
302 sess = google_session_create_xmlnode(session, "terminate");
303 xmlnode_insert_child(iq->node, sess);
304
305 jabber_iq_send(iq);
306 } else if (type == PURPLE_MEDIA_INFO_REJECT) {
307 xmlnode *sess;
308 JabberIq *iq = jabber_iq_new(session->js, JABBER_IQ_SET);
309
310 xmlnode_set_attrib(iq->node, "to", session->remote_jid);
311 sess = google_session_create_xmlnode(session, "reject");
312 xmlnode_insert_child(iq->node, sess);
313
314 jabber_iq_send(iq);
315 } else if (type == PURPLE_MEDIA_INFO_ACCEPT && local == TRUE) {
316 google_session_ready(session);
317 }
318 }
319
320 static GParameter *
jabber_google_session_get_params(JabberStream * js,const gchar * relay_ip,guint16 relay_udp,guint16 relay_tcp,guint16 relay_ssltcp,const gchar * relay_username,const gchar * relay_password,guint * num)321 jabber_google_session_get_params(JabberStream *js, const gchar *relay_ip,
322 guint16 relay_udp, guint16 relay_tcp, guint16 relay_ssltcp,
323 const gchar *relay_username, const gchar *relay_password, guint *num)
324 {
325 guint num_params;
326 GParameter *params =
327 jingle_get_params(js, relay_ip, relay_udp, relay_tcp, relay_ssltcp,
328 relay_username, relay_password, &num_params);
329 GParameter *new_params = g_new0(GParameter, num_params + 1);
330
331 memcpy(new_params, params, sizeof(GParameter) * num_params);
332
333 purple_debug_info("jabber", "setting Google jingle compatibility param\n");
334 new_params[num_params].name = "compatibility-mode";
335 g_value_init(&new_params[num_params].value, G_TYPE_UINT);
336 g_value_set_uint(&new_params[num_params].value, 1); /* NICE_COMPATIBILITY_GOOGLE */
337
338 g_free(params);
339 *num = num_params + 1;
340 return new_params;
341 }
342
343
344 static void
jabber_google_relay_response_session_initiate_cb(GoogleSession * session,const gchar * relay_ip,guint relay_udp,guint relay_tcp,guint relay_ssltcp,const gchar * relay_username,const gchar * relay_password)345 jabber_google_relay_response_session_initiate_cb(GoogleSession *session,
346 const gchar *relay_ip, guint relay_udp, guint relay_tcp, guint relay_ssltcp,
347 const gchar *relay_username, const gchar *relay_password)
348 {
349 GParameter *params;
350 guint num_params;
351 JabberStream *js = session->js;
352 GoogleAVSessionData *session_data =
353 (GoogleAVSessionData *) session->session_data;
354
355 session_data->media = purple_media_manager_create_media(
356 purple_media_manager_get(),
357 purple_connection_get_account(js->gc),
358 "fsrtpconference", session->remote_jid, TRUE);
359
360 purple_media_set_prpl_data(session_data->media, session);
361
362 g_signal_connect_swapped(G_OBJECT(session_data->media),
363 "candidates-prepared",
364 G_CALLBACK(google_session_ready), session);
365 g_signal_connect_swapped(G_OBJECT(session_data->media), "codecs-changed",
366 G_CALLBACK(google_session_ready), session);
367 g_signal_connect(G_OBJECT(session_data->media), "state-changed",
368 G_CALLBACK(google_session_state_changed_cb), session);
369 g_signal_connect(G_OBJECT(session_data->media), "stream-info",
370 G_CALLBACK(google_session_stream_info_cb), session);
371
372 params =
373 jabber_google_session_get_params(js, relay_ip, relay_udp, relay_tcp,
374 relay_ssltcp, relay_username, relay_password, &num_params);
375
376 if (purple_media_add_stream(session_data->media, "google-voice",
377 session->remote_jid, PURPLE_MEDIA_AUDIO,
378 TRUE, "nice", num_params, params) == FALSE ||
379 (session_data->video && purple_media_add_stream(
380 session_data->media, "google-video",
381 session->remote_jid, PURPLE_MEDIA_VIDEO,
382 TRUE, "nice", num_params, params) == FALSE)) {
383 purple_media_error(session_data->media, "Error adding stream.");
384 purple_media_end(session_data->media, NULL, NULL);
385 } else {
386 session_data->added_streams = TRUE;
387 }
388
389 g_free(params);
390 }
391
392
393 gboolean
jabber_google_session_initiate(JabberStream * js,const gchar * who,PurpleMediaSessionType type)394 jabber_google_session_initiate(JabberStream *js, const gchar *who, PurpleMediaSessionType type)
395 {
396 GoogleSession *session;
397 JabberBuddy *jb;
398 JabberBuddyResource *jbr;
399 gchar *jid;
400 GoogleAVSessionData *session_data = NULL;
401
402 /* construct JID to send to */
403 jb = jabber_buddy_find(js, who, FALSE);
404 if (!jb) {
405 purple_debug_error("jingle-rtp",
406 "Could not find Jabber buddy\n");
407 return FALSE;
408 }
409 jbr = jabber_buddy_find_resource(jb, NULL);
410 if (!jbr) {
411 purple_debug_error("jingle-rtp",
412 "Could not find buddy's resource\n");
413 }
414
415 if ((strchr(who, '/') == NULL) && jbr && (jbr->name != NULL)) {
416 jid = g_strdup_printf("%s/%s", who, jbr->name);
417 } else {
418 jid = g_strdup(who);
419 }
420
421 session = g_new0(GoogleSession, 1);
422 session->id.id = jabber_get_next_id(js);
423 session->id.initiator = g_strdup_printf("%s@%s/%s", js->user->node,
424 js->user->domain, js->user->resource);
425 session->state = SENT_INITIATE;
426 session->js = js;
427 session->remote_jid = jid;
428 session_data = g_new0(GoogleAVSessionData, 1);
429 session->session_data = session_data;
430
431 if (type & PURPLE_MEDIA_VIDEO)
432 session_data->video = TRUE;
433
434 /* if we got a relay token and relay host in google:jingleinfo, issue an
435 HTTP request to get that data */
436 if (js->google_relay_host && js->google_relay_token) {
437 jabber_google_do_relay_request(js, session,
438 jabber_google_relay_response_session_initiate_cb);
439 } else {
440 jabber_google_relay_response_session_initiate_cb(session, NULL, 0, 0, 0,
441 NULL, NULL);
442 }
443
444 /* we don't actually know yet wether it succeeded... maybe this is very
445 wrong... */
446 return TRUE;
447 }
448
449 static void
jabber_google_relay_response_session_handle_initiate_cb(GoogleSession * session,const gchar * relay_ip,guint relay_udp,guint relay_tcp,guint relay_ssltcp,const gchar * relay_username,const gchar * relay_password)450 jabber_google_relay_response_session_handle_initiate_cb(GoogleSession *session,
451 const gchar *relay_ip, guint relay_udp, guint relay_tcp, guint relay_ssltcp,
452 const gchar *relay_username, const gchar *relay_password)
453 {
454 GParameter *params;
455 guint num_params;
456 JabberStream *js = session->js;
457 xmlnode *codec_element;
458 const gchar *xmlns;
459 PurpleMediaCodec *codec;
460 GList *video_codecs = NULL;
461 GList *codecs = NULL;
462 JabberIq *result;
463 GoogleAVSessionData *session_data =
464 (GoogleAVSessionData *) session->session_data;
465
466 params =
467 jabber_google_session_get_params(js, relay_ip, relay_udp, relay_tcp,
468 relay_ssltcp, relay_username, relay_password, &num_params);
469
470 if (purple_media_add_stream(session_data->media, "google-voice",
471 session->remote_jid, PURPLE_MEDIA_AUDIO, FALSE,
472 "nice", num_params, params) == FALSE ||
473 (session_data->video && purple_media_add_stream(
474 session_data->media, "google-video",
475 session->remote_jid, PURPLE_MEDIA_VIDEO,
476 FALSE, "nice", num_params, params) == FALSE)) {
477 purple_media_error(session_data->media, "Error adding stream.");
478 purple_media_stream_info(session_data->media,
479 PURPLE_MEDIA_INFO_REJECT, NULL, NULL, TRUE);
480 } else {
481 /* successfully added stream(s) */
482 session_data->added_streams = TRUE;
483
484 if (session_data->remote_audio_candidates) {
485 purple_media_add_remote_candidates(session_data->media,
486 "google-voice", session->remote_jid,
487 session_data->remote_audio_candidates);
488 purple_media_candidate_list_free(session_data->remote_audio_candidates);
489 session_data->remote_audio_candidates = NULL;
490 }
491 if (session_data->remote_video_candidates) {
492 purple_media_add_remote_candidates(session_data->media,
493 "google-video", session->remote_jid,
494 session_data->remote_video_candidates);
495 purple_media_candidate_list_free(session_data->remote_video_candidates);
496 session_data->remote_video_candidates = NULL;
497 }
498 }
499
500 g_free(params);
501
502 for (codec_element = xmlnode_get_child(session->description, "payload-type");
503 codec_element; codec_element = codec_element->next) {
504 const char *id, *encoding_name, *clock_rate;
505 gboolean video;
506 if (codec_element->name &&
507 !purple_strequal(codec_element->name, "payload-type"))
508 continue;
509
510 xmlns = xmlnode_get_namespace(codec_element);
511 encoding_name = xmlnode_get_attrib(codec_element, "name");
512 id = xmlnode_get_attrib(codec_element, "id");
513
514 if (!session_data->video ||
515 purple_strequal(xmlns, NS_GOOGLE_SESSION_PHONE)) {
516 clock_rate = xmlnode_get_attrib(
517 codec_element, "clockrate");
518 video = FALSE;
519 } else {
520 /*width = xmlnode_get_attrib(codec_element, "width");
521 height = xmlnode_get_attrib(codec_element, "height");
522 framerate = xmlnode_get_attrib(
523 codec_element, "framerate");*/
524 clock_rate = "90000";
525 video = TRUE;
526 }
527
528 if (id) {
529 codec = purple_media_codec_new(atoi(id), encoding_name,
530 video ? PURPLE_MEDIA_VIDEO :
531 PURPLE_MEDIA_AUDIO,
532 clock_rate ? atoi(clock_rate) : 0);
533 if (video)
534 video_codecs = g_list_append(
535 video_codecs, codec);
536 else
537 codecs = g_list_append(codecs, codec);
538 }
539 }
540
541 if (codecs)
542 purple_media_set_remote_codecs(session_data->media, "google-voice",
543 session->remote_jid, codecs);
544 if (video_codecs)
545 purple_media_set_remote_codecs(session_data->media, "google-video",
546 session->remote_jid, video_codecs);
547
548 purple_media_codec_list_free(codecs);
549 purple_media_codec_list_free(video_codecs);
550
551 result = jabber_iq_new(js, JABBER_IQ_RESULT);
552 jabber_iq_set_id(result, session->iq_id);
553 xmlnode_set_attrib(result->node, "to", session->remote_jid);
554 jabber_iq_send(result);
555 }
556
557 static gboolean
google_session_handle_initiate(JabberStream * js,GoogleSession * session,xmlnode * sess,const char * iq_id)558 google_session_handle_initiate(JabberStream *js, GoogleSession *session, xmlnode *sess, const char *iq_id)
559 {
560 const gchar *xmlns;
561 GoogleAVSessionData *session_data =
562 (GoogleAVSessionData *) session->session_data;
563
564 if (session->state != UNINIT) {
565 google_session_destroy(session);
566 purple_debug_error("jabber", "Received initiate for active session.\n");
567 return FALSE;
568 }
569
570 session->description = xmlnode_copy(xmlnode_get_child(sess, "description"));
571 xmlns = xmlnode_get_namespace(session->description);
572
573 if (purple_strequal(xmlns, NS_GOOGLE_SESSION_PHONE))
574 session_data->video = FALSE;
575 else if (purple_strequal(xmlns, NS_GOOGLE_SESSION_VIDEO))
576 session_data->video = TRUE;
577 else {
578 google_session_destroy(session);
579 purple_debug_error("jabber", "Received initiate with "
580 "invalid namespace %s.\n", xmlns);
581 return FALSE;
582 }
583
584 session_data->media = purple_media_manager_create_media(
585 purple_media_manager_get(),
586 purple_connection_get_account(js->gc),
587 "fsrtpconference", session->remote_jid, FALSE);
588
589 purple_media_set_prpl_data(session_data->media, session);
590
591 g_signal_connect_swapped(G_OBJECT(session_data->media),
592 "candidates-prepared",
593 G_CALLBACK(google_session_ready), session);
594 g_signal_connect_swapped(G_OBJECT(session_data->media), "codecs-changed",
595 G_CALLBACK(google_session_ready), session);
596 g_signal_connect(G_OBJECT(session_data->media), "state-changed",
597 G_CALLBACK(google_session_state_changed_cb), session);
598 g_signal_connect(G_OBJECT(session_data->media), "stream-info",
599 G_CALLBACK(google_session_stream_info_cb), session);
600
601 session->iq_id = g_strdup(iq_id);
602
603 if (js->google_relay_host && js->google_relay_token) {
604 jabber_google_do_relay_request(js, session,
605 jabber_google_relay_response_session_handle_initiate_cb);
606 } else {
607 jabber_google_relay_response_session_handle_initiate_cb(session, NULL,
608 0, 0, 0, NULL, NULL);
609 }
610
611 return TRUE;
612 }
613
614
615 static void
google_session_handle_candidates(JabberStream * js,GoogleSession * session,xmlnode * sess,const char * iq_id)616 google_session_handle_candidates(JabberStream *js, GoogleSession *session, xmlnode *sess, const char *iq_id)
617 {
618 JabberIq *result;
619 GList *list = NULL, *video_list = NULL;
620 xmlnode *cand;
621 static int name = 0;
622 char n[4];
623 GoogleAVSessionData *session_data =
624 (GoogleAVSessionData *) session->session_data;
625
626 for (cand = xmlnode_get_child(sess, "candidate"); cand;
627 cand = xmlnode_get_next_twin(cand)) {
628 PurpleMediaCandidate *info;
629 const gchar *cname = xmlnode_get_attrib(cand, "name");
630 const gchar *type = xmlnode_get_attrib(cand, "type");
631 const gchar *protocol = xmlnode_get_attrib(cand, "protocol");
632 const gchar *address = xmlnode_get_attrib(cand, "address");
633 const gchar *port = xmlnode_get_attrib(cand, "port");
634 const gchar *preference = xmlnode_get_attrib(cand, "preference");
635 guint component_id;
636
637 if (cname && type && address && port) {
638 PurpleMediaCandidateType candidate_type;
639 guint prio = preference ? g_ascii_strtod(preference, NULL) * 1000 : 0;
640
641 g_snprintf(n, sizeof(n), "S%d", name++);
642
643 if (purple_strequal(type, "local"))
644 candidate_type = PURPLE_MEDIA_CANDIDATE_TYPE_HOST;
645 else if (purple_strequal(type, "stun"))
646 candidate_type = PURPLE_MEDIA_CANDIDATE_TYPE_PRFLX;
647 else if (purple_strequal(type, "relay"))
648 candidate_type = PURPLE_MEDIA_CANDIDATE_TYPE_RELAY;
649 else
650 candidate_type = PURPLE_MEDIA_CANDIDATE_TYPE_HOST;
651
652 if (purple_strequal(cname, "rtcp") ||
653 purple_strequal(cname, "video_rtcp"))
654 component_id = PURPLE_MEDIA_COMPONENT_RTCP;
655 else
656 component_id = PURPLE_MEDIA_COMPONENT_RTP;
657
658 info = purple_media_candidate_new(n, component_id,
659 candidate_type,
660 purple_strequal(protocol, "udp") ?
661 PURPLE_MEDIA_NETWORK_PROTOCOL_UDP :
662 PURPLE_MEDIA_NETWORK_PROTOCOL_TCP_PASSIVE,
663 address,
664 atoi(port));
665 g_object_set(info, "username", xmlnode_get_attrib(cand, "username"),
666 "password", xmlnode_get_attrib(cand, "password"),
667 "priority", prio, NULL);
668 if (!strncmp(cname, "video_", 6)) {
669 if (session_data->added_streams) {
670 video_list = g_list_append(video_list, info);
671 } else {
672 session_data->remote_video_candidates =
673 g_list_append(session_data->remote_video_candidates,
674 info);
675 }
676 } else {
677 if (session_data->added_streams) {
678 list = g_list_append(list, info);
679 } else {
680 session_data->remote_audio_candidates =
681 g_list_append(session_data->remote_audio_candidates,
682 info);
683 }
684 }
685 }
686 }
687
688 if (list) {
689 purple_media_add_remote_candidates(session_data->media, "google-voice",
690 session->remote_jid, list);
691 purple_media_candidate_list_free(list);
692 }
693 if (video_list) {
694 purple_media_add_remote_candidates(session_data->media, "google-video",
695 session->remote_jid, video_list);
696 purple_media_candidate_list_free(video_list);
697 }
698
699 result = jabber_iq_new(js, JABBER_IQ_RESULT);
700 jabber_iq_set_id(result, iq_id);
701 xmlnode_set_attrib(result->node, "to", session->remote_jid);
702 jabber_iq_send(result);
703 }
704
705 static void
google_session_handle_accept(JabberStream * js,GoogleSession * session,xmlnode * sess,const char * iq_id)706 google_session_handle_accept(JabberStream *js, GoogleSession *session, xmlnode *sess, const char *iq_id)
707 {
708 xmlnode *desc_element = xmlnode_get_child(sess, "description");
709 xmlnode *codec_element = xmlnode_get_child(
710 desc_element, "payload-type");
711 GList *codecs = NULL, *video_codecs = NULL;
712 JabberIq *result = NULL;
713 const gchar *xmlns = xmlnode_get_namespace(desc_element);
714 gboolean video = purple_strequal(xmlns, NS_GOOGLE_SESSION_VIDEO);
715 GoogleAVSessionData *session_data =
716 (GoogleAVSessionData *) session->session_data;
717
718 for (; codec_element; codec_element = codec_element->next) {
719 const gchar *xmlns, *encoding_name, *id,
720 *clock_rate;
721 gboolean video_codec = FALSE;
722
723 if (!purple_strequal(codec_element->name, "payload-type"))
724 continue;
725
726 xmlns = xmlnode_get_namespace(codec_element);
727 encoding_name = xmlnode_get_attrib(codec_element, "name");
728 id = xmlnode_get_attrib(codec_element, "id");
729
730 if (!video || purple_strequal(xmlns, NS_GOOGLE_SESSION_PHONE))
731 clock_rate = xmlnode_get_attrib(
732 codec_element, "clockrate");
733 else {
734 clock_rate = "90000";
735 /*width = xmlnode_get_attrib(codec_element, "width");
736 height = xmlnode_get_attrib(codec_element, "height");
737 framerate = xmlnode_get_attrib(
738 codec_element, "framerate");*/
739 video_codec = TRUE;
740 }
741
742 if (id && encoding_name) {
743 PurpleMediaCodec *codec = purple_media_codec_new(
744 atoi(id), encoding_name,
745 video_codec ? PURPLE_MEDIA_VIDEO :
746 PURPLE_MEDIA_AUDIO,
747 clock_rate ? atoi(clock_rate) : 0);
748 if (video_codec)
749 video_codecs = g_list_append(
750 video_codecs, codec);
751 else
752 codecs = g_list_append(codecs, codec);
753 }
754 }
755
756 if (codecs)
757 purple_media_set_remote_codecs(session_data->media, "google-voice",
758 session->remote_jid, codecs);
759 if (video_codecs)
760 purple_media_set_remote_codecs(session_data->media, "google-video",
761 session->remote_jid, video_codecs);
762
763 purple_media_stream_info(session_data->media, PURPLE_MEDIA_INFO_ACCEPT,
764 NULL, NULL, FALSE);
765
766 result = jabber_iq_new(js, JABBER_IQ_RESULT);
767 jabber_iq_set_id(result, iq_id);
768 xmlnode_set_attrib(result->node, "to", session->remote_jid);
769 jabber_iq_send(result);
770 }
771
772 static void
google_session_handle_reject(JabberStream * js,GoogleSession * session,xmlnode * sess)773 google_session_handle_reject(JabberStream *js, GoogleSession *session, xmlnode *sess)
774 {
775 GoogleAVSessionData *session_data =
776 (GoogleAVSessionData *) session->session_data;
777 purple_media_end(session_data->media, NULL, NULL);
778 }
779
780 static void
google_session_handle_terminate(JabberStream * js,GoogleSession * session,xmlnode * sess)781 google_session_handle_terminate(JabberStream *js, GoogleSession *session, xmlnode *sess)
782 {
783 GoogleAVSessionData *session_data =
784 (GoogleAVSessionData *) session->session_data;
785 purple_media_end(session_data->media, NULL, NULL);
786 }
787
788 static void
google_session_parse_iq(JabberStream * js,GoogleSession * session,xmlnode * sess,const char * iq_id)789 google_session_parse_iq(JabberStream *js, GoogleSession *session, xmlnode *sess, const char *iq_id)
790 {
791 const char *type = xmlnode_get_attrib(sess, "type");
792
793 if (purple_strequal(type, "initiate")) {
794 google_session_handle_initiate(js, session, sess, iq_id);
795 } else if (purple_strequal(type, "accept")) {
796 google_session_handle_accept(js, session, sess, iq_id);
797 } else if (purple_strequal(type, "reject")) {
798 google_session_handle_reject(js, session, sess);
799 } else if (purple_strequal(type, "terminate")) {
800 google_session_handle_terminate(js, session, sess);
801 } else if (purple_strequal(type, "candidates")) {
802 google_session_handle_candidates(js, session, sess, iq_id);
803 }
804 }
805
806 void
jabber_google_session_parse(JabberStream * js,const char * from,JabberIqType type,const char * iq_id,xmlnode * session_node)807 jabber_google_session_parse(JabberStream *js, const char *from,
808 JabberIqType type, const char *iq_id,
809 xmlnode *session_node)
810 {
811 GoogleSession *session = NULL;
812 GoogleSessionId id;
813
814 xmlnode *desc_node;
815
816 GList *iter = NULL;
817
818 if (type != JABBER_IQ_SET)
819 return;
820
821 id.id = (gchar*)xmlnode_get_attrib(session_node, "id");
822 if (!id.id)
823 return;
824
825 id.initiator = (gchar*)xmlnode_get_attrib(session_node, "initiator");
826 if (!id.initiator)
827 return;
828
829 iter = purple_media_manager_get_media_by_account(
830 purple_media_manager_get(),
831 purple_connection_get_account(js->gc));
832 for (; iter; iter = g_list_delete_link(iter, iter)) {
833 GoogleSession *gsession =
834 purple_media_get_prpl_data(iter->data);
835 if (google_session_id_equal(&(gsession->id), &id)) {
836 session = gsession;
837 break;
838 }
839 }
840 if (iter != NULL) {
841 g_list_free(iter);
842 }
843
844 if (session) {
845 google_session_parse_iq(js, session, session_node, iq_id);
846 return;
847 }
848
849 /* If the session doesn't exist, this has to be an initiate message */
850 if (!purple_strequal(xmlnode_get_attrib(session_node, "type"), "initiate"))
851 return;
852 desc_node = xmlnode_get_child(session_node, "description");
853 if (!desc_node)
854 return;
855 session = g_new0(GoogleSession, 1);
856 session->id.id = g_strdup(id.id);
857 session->id.initiator = g_strdup(id.initiator);
858 session->state = UNINIT;
859 session->js = js;
860 session->remote_jid = g_strdup(session->id.initiator);
861 session->session_data = g_new0(GoogleAVSessionData, 1);
862
863 google_session_handle_initiate(js, session, session_node, iq_id);
864 }
865 #endif /* USE_VV */
866
867
868