Mercurial > pidgin.yaz

comparison libpurple/protocols/jabber/google/google_session.c @ 30906:34f586bffe4e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added new files in sub directory google
author Marcus Lundblad <ml@update.uu.se>
date Thu, 25 Mar 2010 20:18:54 +0000
parents
children 721b257bcd8c
comparison
equal deleted inserted replaced
30905:ae615b3d3e47 30906:34f586bffe4e
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
25 #include "jingle/jingle.h"
26
27 #ifdef USE_VV
28
29 typedef struct {
30 char *id;
31 char *initiator;
32 } GoogleSessionId;
33
34 typedef enum {
35 UNINIT,
36 SENT_INITIATE,
37 RECEIVED_INITIATE,
38 IN_PRORESS,
39 TERMINATED
40 } GoogleSessionState;
41
42 typedef struct {
43 GoogleSessionId id;
44 GoogleSessionState state;
45 PurpleMedia *media;
46 JabberStream *js;
47 char *remote_jid;
48 gboolean video;
49 } GoogleSession;
50
51 static gboolean
52 google_session_id_equal(gconstpointer a, gconstpointer b)
53 {
54 GoogleSessionId *c = (GoogleSessionId*)a;
55 GoogleSessionId *d = (GoogleSessionId*)b;
56
57 return !strcmp(c->id, d->id) && !strcmp(c->initiator, d->initiator);
58 }
59
60 static void
61 google_session_destroy(GoogleSession *session)
62 {
63 g_free(session->id.id);
64 g_free(session->id.initiator);
65 g_free(session->remote_jid);
66 g_free(session);
67 }
68
69 static xmlnode *
70 google_session_create_xmlnode(GoogleSession *session, const char *type)
71 {
72 xmlnode *node = xmlnode_new("session");
73 xmlnode_set_namespace(node, NS_GOOGLE_SESSION);
74 xmlnode_set_attrib(node, "id", session->id.id);
75 xmlnode_set_attrib(node, "initiator", session->id.initiator);
76 xmlnode_set_attrib(node, "type", type);
77 return node;
78 }
79
80 static void
81 google_session_send_candidates(PurpleMedia *media, gchar *session_id,
82 gchar *participant, GoogleSession *session)
83 {
84 GList *candidates = purple_media_get_local_candidates(
85 session->media, session_id, session->remote_jid), *iter;
86 PurpleMediaCandidate *transport;
87 gboolean video = FALSE;
88
89 if (!strcmp(session_id, "google-video"))
90 video = TRUE;
91
92 for (iter = candidates; iter; iter = iter->next) {
93 JabberIq *iq;
94 gchar *ip, *port, *username, *password;
95 gchar pref[16];
96 PurpleMediaCandidateType type;
97 xmlnode *sess;
98 xmlnode *candidate;
99 guint component_id;
100 transport = PURPLE_MEDIA_CANDIDATE(iter->data);
101 component_id = purple_media_candidate_get_component_id(
102 transport);
103
104 iq = jabber_iq_new(session->js, JABBER_IQ_SET);
105 sess = google_session_create_xmlnode(session, "candidates");
106 xmlnode_insert_child(iq->node, sess);
107 xmlnode_set_attrib(iq->node, "to", session->remote_jid);
108
109 candidate = xmlnode_new("candidate");
110
111 ip = purple_media_candidate_get_ip(transport);
112 port = g_strdup_printf("%d",
113 purple_media_candidate_get_port(transport));
114 g_ascii_dtostr(pref, 16,
115 purple_media_candidate_get_priority(transport) / 1000.0);
116 username = purple_media_candidate_get_username(transport);
117 password = purple_media_candidate_get_password(transport);
118 type = purple_media_candidate_get_candidate_type(transport);
119
120 xmlnode_set_attrib(candidate, "address", ip);
121 xmlnode_set_attrib(candidate, "port", port);
122 xmlnode_set_attrib(candidate, "name",
123 component_id == PURPLE_MEDIA_COMPONENT_RTP ?
124 video ? "video_rtp" : "rtp" :
125 component_id == PURPLE_MEDIA_COMPONENT_RTCP ?
126 video ? "video_rtcp" : "rtcp" : "none");
127 xmlnode_set_attrib(candidate, "username", username);
128 /*
129 * As of this writing, Farsight 2 in Google compatibility
130 * mode doesn't provide a password. The Gmail client
131 * requires this to be set.
132 */
133 xmlnode_set_attrib(candidate, "password",
134 password != NULL ? password : "");
135 xmlnode_set_attrib(candidate, "preference", pref);
136 xmlnode_set_attrib(candidate, "protocol",
137 purple_media_candidate_get_protocol(transport)
138 == PURPLE_MEDIA_NETWORK_PROTOCOL_UDP ?
139 "udp" : "tcp");
140 xmlnode_set_attrib(candidate, "type", type ==
141 PURPLE_MEDIA_CANDIDATE_TYPE_HOST ? "local" :
142 type ==
143 PURPLE_MEDIA_CANDIDATE_TYPE_SRFLX ? "stun" :
144 type ==
145 PURPLE_MEDIA_CANDIDATE_TYPE_RELAY ? "relay" :
146 NULL);
147 xmlnode_set_attrib(candidate, "generation", "0");
148 xmlnode_set_attrib(candidate, "network", "0");
149 xmlnode_insert_child(sess, candidate);
150
151 g_free(ip);
152 g_free(port);
153 g_free(username);
154 g_free(password);
155
156 jabber_iq_send(iq);
157 }
158 purple_media_candidate_list_free(candidates);
159 }
160
161 static void
162 google_session_ready(GoogleSession *session)
163 {
164 PurpleMedia *media = session->media;
165 if (purple_media_codecs_ready(media, NULL) &&
166 purple_media_candidates_prepared(media, NULL, NULL)) {
167 gchar *me = g_strdup_printf("%s@%s/%s",
168 session->js->user->node,
169 session->js->user->domain,
170 session->js->user->resource);
171 JabberIq *iq;
172 xmlnode *sess, *desc, *payload;
173 GList *codecs, *iter;
174 gboolean is_initiator = !strcmp(session->id.initiator, me);
175
176 if (!is_initiator &&
177 !purple_media_accepted(media, NULL, NULL)) {
178 g_free(me);
179 return;
180 }
181
182 iq = jabber_iq_new(session->js, JABBER_IQ_SET);
183
184 if (is_initiator) {
185 xmlnode_set_attrib(iq->node, "to", session->remote_jid);
186 xmlnode_set_attrib(iq->node, "from", session->id.initiator);
187 sess = google_session_create_xmlnode(session, "initiate");
188 } else {
189 google_session_send_candidates(session->media,
190 "google-voice", session->remote_jid,
191 session);
192 google_session_send_candidates(session->media,
193 "google-video", session->remote_jid,
194 session);
195 xmlnode_set_attrib(iq->node, "to", session->remote_jid);
196 xmlnode_set_attrib(iq->node, "from", me);
197 sess = google_session_create_xmlnode(session, "accept");
198 }
199 xmlnode_insert_child(iq->node, sess);
200 desc = xmlnode_new_child(sess, "description");
201 if (session->video)
202 xmlnode_set_namespace(desc, NS_GOOGLE_SESSION_VIDEO);
203 else
204 xmlnode_set_namespace(desc, NS_GOOGLE_SESSION_PHONE);
205
206 codecs = purple_media_get_codecs(media, "google-video");
207
208 for (iter = codecs; iter; iter = g_list_next(iter)) {
209 PurpleMediaCodec *codec = (PurpleMediaCodec*)iter->data;
210 gchar *id = g_strdup_printf("%d",
211 purple_media_codec_get_id(codec));
212 gchar *encoding_name =
213 purple_media_codec_get_encoding_name(codec);
214 payload = xmlnode_new_child(desc, "payload-type");
215 xmlnode_set_attrib(payload, "id", id);
216 xmlnode_set_attrib(payload, "name", encoding_name);
217 xmlnode_set_attrib(payload, "width", "320");
218 xmlnode_set_attrib(payload, "height", "200");
219 xmlnode_set_attrib(payload, "framerate", "30");
220 g_free(encoding_name);
221 g_free(id);
222 }
223 purple_media_codec_list_free(codecs);
224
225 codecs = purple_media_get_codecs(media, "google-voice");
226
227 for (iter = codecs; iter; iter = g_list_next(iter)) {
228 PurpleMediaCodec *codec = (PurpleMediaCodec*)iter->data;
229 gchar *id = g_strdup_printf("%d",
230 purple_media_codec_get_id(codec));
231 gchar *encoding_name =
232 purple_media_codec_get_encoding_name(codec);
233 gchar *clock_rate = g_strdup_printf("%d",
234 purple_media_codec_get_clock_rate(codec));
235 payload = xmlnode_new_child(desc, "payload-type");
236 if (session->video)
237 xmlnode_set_namespace(payload, NS_GOOGLE_SESSION_PHONE);
238 xmlnode_set_attrib(payload, "id", id);
239 /*
240 * Hack to make Gmail accept speex as the codec.
241 * It shouldn't have to be case sensitive.
242 */
243 if (purple_strequal(encoding_name, "SPEEX"))
244 xmlnode_set_attrib(payload, "name", "speex");
245 else
246 xmlnode_set_attrib(payload, "name", encoding_name);
247 xmlnode_set_attrib(payload, "clockrate", clock_rate);
248 g_free(clock_rate);
249 g_free(encoding_name);
250 g_free(id);
251 }
252 purple_media_codec_list_free(codecs);
253
254 jabber_iq_send(iq);
255
256 if (is_initiator) {
257 google_session_send_candidates(session->media,
258 "google-voice", session->remote_jid,
259 session);
260 google_session_send_candidates(session->media,
261 "google-video", session->remote_jid,
262 session);
263 }
264
265 g_signal_handlers_disconnect_by_func(G_OBJECT(session->media),
266 G_CALLBACK(google_session_ready), session);
267 }
268 }
269
270 static void
271 google_session_state_changed_cb(PurpleMedia *media, PurpleMediaState state,
272 gchar *sid, gchar *name, GoogleSession *session)
273 {
274 if (sid == NULL && name == NULL) {
275 if (state == PURPLE_MEDIA_STATE_END) {
276 google_session_destroy(session);
277 }
278 }
279 }
280
281 static void
282 google_session_stream_info_cb(PurpleMedia *media, PurpleMediaInfoType type,
283 gchar *sid, gchar *name, gboolean local,
284 GoogleSession *session)
285 {
286 if (sid != NULL || name != NULL)
287 return;
288
289 if (type == PURPLE_MEDIA_INFO_HANGUP) {
290 xmlnode *sess;
291 JabberIq *iq = jabber_iq_new(session->js, JABBER_IQ_SET);
292
293 xmlnode_set_attrib(iq->node, "to", session->remote_jid);
294 sess = google_session_create_xmlnode(session, "terminate");
295 xmlnode_insert_child(iq->node, sess);
296
297 jabber_iq_send(iq);
298 } else if (type == PURPLE_MEDIA_INFO_REJECT) {
299 xmlnode *sess;
300 JabberIq *iq = jabber_iq_new(session->js, JABBER_IQ_SET);
301
302 xmlnode_set_attrib(iq->node, "to", session->remote_jid);
303 sess = google_session_create_xmlnode(session, "reject");
304 xmlnode_insert_child(iq->node, sess);
305
306 jabber_iq_send(iq);
307 } else if (type == PURPLE_MEDIA_INFO_ACCEPT && local == TRUE) {
308 google_session_ready(session);
309 }
310 }
311
312 static GParameter *
313 jabber_google_session_get_params(JabberStream *js, guint *num)
314 {
315 guint num_params;
316 GParameter *params = jingle_get_params(js, &num_params);
317 GParameter *new_params = g_new0(GParameter, num_params + 1);
318
319 memcpy(new_params, params, sizeof(GParameter) * num_params);
320
321 purple_debug_info("jabber", "setting Google jingle compatibility param\n");
322 new_params[num_params].name = "compatibility-mode";
323 g_value_init(&new_params[num_params].value, G_TYPE_UINT);
324 g_value_set_uint(&new_params[num_params].value, 1); /* NICE_COMPATIBILITY_GOOGLE */
325
326 g_free(params);
327 *num = num_params + 1;
328 return new_params;
329 }
330
331
332 gboolean
333 jabber_google_session_initiate(JabberStream *js, const gchar *who, PurpleMediaSessionType type)
334 {
335 GoogleSession *session;
336 JabberBuddy *jb;
337 JabberBuddyResource *jbr;
338 gchar *jid;
339 GParameter *params;
340 guint num_params;
341
342 /* construct JID to send to */
343 jb = jabber_buddy_find(js, who, FALSE);
344 if (!jb) {
345 purple_debug_error("jingle-rtp",
346 "Could not find Jabber buddy\n");
347 return FALSE;
348 }
349 jbr = jabber_buddy_find_resource(jb, NULL);
350 if (!jbr) {
351 purple_debug_error("jingle-rtp",
352 "Could not find buddy's resource\n");
353 }
354
355 if ((strchr(who, '/') == NULL) && jbr && (jbr->name != NULL)) {
356 jid = g_strdup_printf("%s/%s", who, jbr->name);
357 } else {
358 jid = g_strdup(who);
359 }
360
361 session = g_new0(GoogleSession, 1);
362 session->id.id = jabber_get_next_id(js);
363 session->id.initiator = g_strdup_printf("%s@%s/%s", js->user->node,
364 js->user->domain, js->user->resource);
365 session->state = SENT_INITIATE;
366 session->js = js;
367 session->remote_jid = jid;
368
369 if (type & PURPLE_MEDIA_VIDEO)
370 session->video = TRUE;
371
372 session->media = purple_media_manager_create_media(
373 purple_media_manager_get(),
374 purple_connection_get_account(js->gc),
375 "fsrtpconference", session->remote_jid, TRUE);
376
377 purple_media_set_prpl_data(session->media, session);
378
379 g_signal_connect_swapped(G_OBJECT(session->media),
380 "candidates-prepared",
381 G_CALLBACK(google_session_ready), session);
382 g_signal_connect_swapped(G_OBJECT(session->media), "codecs-changed",
383 G_CALLBACK(google_session_ready), session);
384 g_signal_connect(G_OBJECT(session->media), "state-changed",
385 G_CALLBACK(google_session_state_changed_cb), session);
386 g_signal_connect(G_OBJECT(session->media), "stream-info",
387 G_CALLBACK(google_session_stream_info_cb), session);
388
389 params = jabber_google_session_get_params(js, &num_params);
390
391 if (purple_media_add_stream(session->media, "google-voice",
392 session->remote_jid, PURPLE_MEDIA_AUDIO,
393 TRUE, "nice", num_params, params) == FALSE ||
394 (session->video && purple_media_add_stream(
395 session->media, "google-video",
396 session->remote_jid, PURPLE_MEDIA_VIDEO,
397 TRUE, "nice", num_params, params) == FALSE)) {
398 purple_media_error(session->media, "Error adding stream.");
399 purple_media_end(session->media, NULL, NULL);
400 g_free(params);
401 return FALSE;
402 }
403
404 g_free(params);
405
406 return (session->media != NULL) ? TRUE : FALSE;
407 }
408
409 static gboolean
410 google_session_handle_initiate(JabberStream *js, GoogleSession *session, xmlnode *sess, const char *iq_id)
411 {
412 JabberIq *result;
413 GList *codecs = NULL, *video_codecs = NULL;
414 xmlnode *desc_element, *codec_element;
415 PurpleMediaCodec *codec;
416 const char *xmlns;
417 GParameter *params;
418 guint num_params;
419
420 if (session->state != UNINIT) {
421 purple_debug_error("jabber", "Received initiate for active session.\n");
422 return FALSE;
423 }
424
425 desc_element = xmlnode_get_child(sess, "description");
426 xmlns = xmlnode_get_namespace(desc_element);
427
428 if (purple_strequal(xmlns, NS_GOOGLE_SESSION_PHONE))
429 session->video = FALSE;
430 else if (purple_strequal(xmlns, NS_GOOGLE_SESSION_VIDEO))
431 session->video = TRUE;
432 else {
433 purple_debug_error("jabber", "Received initiate with "
434 "invalid namespace %s.\n", xmlns);
435 return FALSE;
436 }
437
438 session->media = purple_media_manager_create_media(
439 purple_media_manager_get(),
440 purple_connection_get_account(js->gc),
441 "fsrtpconference", session->remote_jid, FALSE);
442
443 purple_media_set_prpl_data(session->media, session);
444
445 g_signal_connect_swapped(G_OBJECT(session->media),
446 "candidates-prepared",
447 G_CALLBACK(google_session_ready), session);
448 g_signal_connect_swapped(G_OBJECT(session->media), "codecs-changed",
449 G_CALLBACK(google_session_ready), session);
450 g_signal_connect(G_OBJECT(session->media), "state-changed",
451 G_CALLBACK(google_session_state_changed_cb), session);
452 g_signal_connect(G_OBJECT(session->media), "stream-info",
453 G_CALLBACK(google_session_stream_info_cb), session);
454
455 params = jabber_google_session_get_params(js, &num_params);
456
457 if (purple_media_add_stream(session->media, "google-voice",
458 session->remote_jid, PURPLE_MEDIA_AUDIO, FALSE,
459 "nice", num_params, params) == FALSE ||
460 (session->video && purple_media_add_stream(
461 session->media, "google-video",
462 session->remote_jid, PURPLE_MEDIA_VIDEO,
463 FALSE, "nice", num_params, params) == FALSE)) {
464 purple_media_error(session->media, "Error adding stream.");
465 purple_media_stream_info(session->media,
466 PURPLE_MEDIA_INFO_REJECT, NULL, NULL, TRUE);
467 g_free(params);
468 return FALSE;
469 }
470
471 g_free(params);
472
473 for (codec_element = xmlnode_get_child(desc_element, "payload-type");
474 codec_element; codec_element = codec_element->next) {
475 const char *id, *encoding_name, *clock_rate,
476 *width, *height, *framerate;
477 gboolean video;
478 if (codec_element->name &&
479 strcmp(codec_element->name, "payload-type"))
480 continue;
481
482 xmlns = xmlnode_get_namespace(codec_element);
483 encoding_name = xmlnode_get_attrib(codec_element, "name");
484 id = xmlnode_get_attrib(codec_element, "id");
485
486 if (!session->video ||
487 (xmlns && !strcmp(xmlns, NS_GOOGLE_SESSION_PHONE))) {
488 clock_rate = xmlnode_get_attrib(
489 codec_element, "clockrate");
490 video = FALSE;
491 } else {
492 width = xmlnode_get_attrib(codec_element, "width");
493 height = xmlnode_get_attrib(codec_element, "height");
494 framerate = xmlnode_get_attrib(
495 codec_element, "framerate");
496 clock_rate = "90000";
497 video = TRUE;
498 }
499
500 if (id) {
501 codec = purple_media_codec_new(atoi(id), encoding_name,
502 video ? PURPLE_MEDIA_VIDEO :
503 PURPLE_MEDIA_AUDIO,
504 clock_rate ? atoi(clock_rate) : 0);
505 if (video)
506 video_codecs = g_list_append(
507 video_codecs, codec);
508 else
509 codecs = g_list_append(codecs, codec);
510 }
511 }
512
513 if (codecs)
514 purple_media_set_remote_codecs(session->media, "google-voice",
515 session->remote_jid, codecs);
516 if (video_codecs)
517 purple_media_set_remote_codecs(session->media, "google-video",
518 session->remote_jid, video_codecs);
519
520 purple_media_codec_list_free(codecs);
521 purple_media_codec_list_free(video_codecs);
522
523 result = jabber_iq_new(js, JABBER_IQ_RESULT);
524 jabber_iq_set_id(result, iq_id);
525 xmlnode_set_attrib(result->node, "to", session->remote_jid);
526 jabber_iq_send(result);
527
528 return TRUE;
529 }
530
531 static void
532 google_session_handle_candidates(JabberStream *js, GoogleSession *session, xmlnode *sess, const char *iq_id)
533 {
534 JabberIq *result;
535 GList *list = NULL, *video_list = NULL;
536 xmlnode *cand;
537 static int name = 0;
538 char n[4];
539
540 for (cand = xmlnode_get_child(sess, "candidate"); cand;
541 cand = xmlnode_get_next_twin(cand)) {
542 PurpleMediaCandidate *info;
543 const gchar *cname = xmlnode_get_attrib(cand, "name");
544 const gchar *type = xmlnode_get_attrib(cand, "type");
545 const gchar *protocol = xmlnode_get_attrib(cand, "protocol");
546 const gchar *address = xmlnode_get_attrib(cand, "address");
547 const gchar *port = xmlnode_get_attrib(cand, "port");
548 guint component_id;
549
550 if (cname && type && address && port) {
551 PurpleMediaCandidateType candidate_type;
552
553 g_snprintf(n, sizeof(n), "S%d", name++);
554
555 if (g_str_equal(type, "local"))
556 candidate_type = PURPLE_MEDIA_CANDIDATE_TYPE_HOST;
557 else if (g_str_equal(type, "stun"))
558 candidate_type = PURPLE_MEDIA_CANDIDATE_TYPE_PRFLX;
559 else if (g_str_equal(type, "relay"))
560 candidate_type = PURPLE_MEDIA_CANDIDATE_TYPE_RELAY;
561 else
562 candidate_type = PURPLE_MEDIA_CANDIDATE_TYPE_HOST;
563
564 if (purple_strequal(cname, "rtcp") ||
565 purple_strequal(cname, "video_rtcp"))
566 component_id = PURPLE_MEDIA_COMPONENT_RTCP;
567 else
568 component_id = PURPLE_MEDIA_COMPONENT_RTP;
569
570 info = purple_media_candidate_new(n, component_id,
571 candidate_type,
572 purple_strequal(protocol, "udp") ?
573 PURPLE_MEDIA_NETWORK_PROTOCOL_UDP :
574 PURPLE_MEDIA_NETWORK_PROTOCOL_TCP,
575 address,
576 atoi(port));
577 g_object_set(info, "username", xmlnode_get_attrib(cand, "username"),
578 "password", xmlnode_get_attrib(cand, "password"), NULL);
579 if (!strncmp(cname, "video_", 6))
580 video_list = g_list_append(video_list, info);
581 else
582 list = g_list_append(list, info);
583 }
584 }
585
586 if (list)
587 purple_media_add_remote_candidates(
588 session->media, "google-voice",
589 session->remote_jid, list);
590 if (video_list)
591 purple_media_add_remote_candidates(
592 session->media, "google-video",
593 session->remote_jid, video_list);
594 purple_media_candidate_list_free(list);
595 purple_media_candidate_list_free(video_list);
596
597 result = jabber_iq_new(js, JABBER_IQ_RESULT);
598 jabber_iq_set_id(result, iq_id);
599 xmlnode_set_attrib(result->node, "to", session->remote_jid);
600 jabber_iq_send(result);
601 }
602
603 static void
604 google_session_handle_accept(JabberStream *js, GoogleSession *session, xmlnode *sess, const char *iq_id)
605 {
606 xmlnode *desc_element = xmlnode_get_child(sess, "description");
607 xmlnode *codec_element = xmlnode_get_child(
608 desc_element, "payload-type");
609 GList *codecs = NULL, *video_codecs = NULL;
610 JabberIq *result = NULL;
611 const gchar *xmlns = xmlnode_get_namespace(desc_element);
612 gboolean video = (xmlns && !strcmp(xmlns, NS_GOOGLE_SESSION_VIDEO));
613
614 for (; codec_element; codec_element = codec_element->next) {
615 const gchar *xmlns, *encoding_name, *id,
616 *clock_rate, *width, *height, *framerate;
617 gboolean video_codec = FALSE;
618
619 if (!purple_strequal(codec_element->name, "payload-type"))
620 continue;
621
622 xmlns = xmlnode_get_namespace(codec_element);
623 encoding_name = xmlnode_get_attrib(codec_element, "name");
624 id = xmlnode_get_attrib(codec_element, "id");
625
626 if (!video || purple_strequal(xmlns, NS_GOOGLE_SESSION_PHONE))
627 clock_rate = xmlnode_get_attrib(
628 codec_element, "clockrate");
629 else {
630 clock_rate = "90000";
631 width = xmlnode_get_attrib(codec_element, "width");
632 height = xmlnode_get_attrib(codec_element, "height");
633 framerate = xmlnode_get_attrib(
634 codec_element, "framerate");
635 video_codec = TRUE;
636 }
637
638 if (id && encoding_name) {
639 PurpleMediaCodec *codec = purple_media_codec_new(
640 atoi(id), encoding_name,
641 video_codec ? PURPLE_MEDIA_VIDEO :
642 PURPLE_MEDIA_AUDIO,
643 clock_rate ? atoi(clock_rate) : 0);
644 if (video_codec)
645 video_codecs = g_list_append(
646 video_codecs, codec);
647 else
648 codecs = g_list_append(codecs, codec);
649 }
650 }
651
652 if (codecs)
653 purple_media_set_remote_codecs(session->media, "google-voice",
654 session->remote_jid, codecs);
655 if (video_codecs)
656 purple_media_set_remote_codecs(session->media, "google-video",
657 session->remote_jid, video_codecs);
658
659 purple_media_stream_info(session->media, PURPLE_MEDIA_INFO_ACCEPT,
660 NULL, NULL, FALSE);
661
662 result = jabber_iq_new(js, JABBER_IQ_RESULT);
663 jabber_iq_set_id(result, iq_id);
664 xmlnode_set_attrib(result->node, "to", session->remote_jid);
665 jabber_iq_send(result);
666 }
667
668 static void
669 google_session_handle_reject(JabberStream *js, GoogleSession *session, xmlnode *sess)
670 {
671 purple_media_end(session->media, NULL, NULL);
672 }
673
674 static void
675 google_session_handle_terminate(JabberStream *js, GoogleSession *session, xmlnode *sess)
676 {
677 purple_media_end(session->media, NULL, NULL);
678 }
679
680 static void
681 google_session_parse_iq(JabberStream *js, GoogleSession *session, xmlnode *sess, const char *iq_id)
682 {
683 const char *type = xmlnode_get_attrib(sess, "type");
684
685 if (!strcmp(type, "initiate")) {
686 google_session_handle_initiate(js, session, sess, iq_id);
687 } else if (!strcmp(type, "accept")) {
688 google_session_handle_accept(js, session, sess, iq_id);
689 } else if (!strcmp(type, "reject")) {
690 google_session_handle_reject(js, session, sess);
691 } else if (!strcmp(type, "terminate")) {
692 google_session_handle_terminate(js, session, sess);
693 } else if (!strcmp(type, "candidates")) {
694 google_session_handle_candidates(js, session, sess, iq_id);
695 }
696 }
697
698 void
699 jabber_google_session_parse(JabberStream *js, const char *from,
700 JabberIqType type, const char *iq_id,
701 xmlnode *session_node)
702 {
703 GoogleSession *session = NULL;
704 GoogleSessionId id;
705
706 xmlnode *desc_node;
707
708 GList *iter = NULL;
709
710 if (type != JABBER_IQ_SET)
711 return;
712
713 id.id = (gchar*)xmlnode_get_attrib(session_node, "id");
714 if (!id.id)
715 return;
716
717 id.initiator = (gchar*)xmlnode_get_attrib(session_node, "initiator");
718 if (!id.initiator)
719 return;
720
721 iter = purple_media_manager_get_media_by_account(
722 purple_media_manager_get(),
723 purple_connection_get_account(js->gc));
724 for (; iter; iter = g_list_delete_link(iter, iter)) {
725 GoogleSession *gsession =
726 purple_media_get_prpl_data(iter->data);
727 if (google_session_id_equal(&(gsession->id), &id)) {
728 session = gsession;
729 break;
730 }
731 }
732 if (iter != NULL) {
733 g_list_free(iter);
734 }
735
736 if (session) {
737 google_session_parse_iq(js, session, session_node, iq_id);
738 return;
739 }
740
741 /* If the session doesn't exist, this has to be an initiate message */
742 if (strcmp(xmlnode_get_attrib(session_node, "type"), "initiate"))
743 return;
744 desc_node = xmlnode_get_child(session_node, "description");
745 if (!desc_node)
746 return;
747 session = g_new0(GoogleSession, 1);
748 session->id.id = g_strdup(id.id);
749 session->id.initiator = g_strdup(id.initiator);
750 session->state = UNINIT;
751 session->js = js;
752 session->remote_jid = g_strdup(session->id.initiator);
753
754 google_session_handle_initiate(js, session, session_node, iq_id);
755 }
756 #endif /* USE_VV */
757
758