Mercurial > pidgin3 / file comparison

comparison: src/protocols/yahoo/yahoochat.c

src/protocols/yahoo/yahoochat.c

branch
gaim
changeset 20470
77693555855f
parent 13071
b98e72d4089a
parent 20469
b2836a24d81e
child 20471
1966704b3e42
equal deleted inserted replaced
13071:b98e72d4089a 20470:77693555855f
1 /*
2 * gaim
3 *
4 * Gaim is the legal property of its developers, whose names are too numerous
5 * to list here. Please refer to the COPYRIGHT file distributed with this
6 * source distribution.
7 *
8 * Some code copyright 2003 Tim Ringenbach <omarvo@hotmail.com>
9 * (marv on irc.freenode.net)
10 * Some code borrowed from libyahoo2, copyright (C) 2002, Philip
11 * S Tellis <philip . tellis AT gmx . net>
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 *
27 */
28
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32
33 #include "debug.h"
34 #include "privacy.h"
35 #include "prpl.h"
36
37 #include "conversation.h"
38 #include "notify.h"
39 #include "util.h"
40 #include "internal.h"
41
42 #include "yahoo.h"
43 #include "yahoo_packet.h"
44 #include "yahoochat.h"
45 #include "ycht.h"
46
47 #define YAHOO_CHAT_ID (1)
48
49 /* prototype(s) */
50 static void yahoo_chat_leave(GaimConnection *gc, const char *room, const char *dn, gboolean logout);
51
52 /* special function to log us on to the yahoo chat service */
53 static void yahoo_chat_online(GaimConnection *gc)
54 {
55 struct yahoo_data *yd = gc->proto_data;
56 struct yahoo_packet *pkt;
57
58 if (yd->wm) {
59 ycht_connection_open(gc);
60 return;
61 }
62
63 pkt = yahoo_packet_new(YAHOO_SERVICE_CHATONLINE, YAHOO_STATUS_AVAILABLE,0);
64 yahoo_packet_hash(pkt, "sss", 1, gaim_connection_get_display_name(gc),
65 109, gaim_connection_get_display_name(gc), 6, "abcde");
66 yahoo_packet_send_and_free(pkt, yd);
67 }
68
69 /* this is slow, and different from the gaim_* version in that it (hopefully) won't add a user twice */
70 void yahoo_chat_add_users(GaimConvChat *chat, GList *newusers)
71 {
72 GList *i;
73
74 for (i = newusers; i; i = i->next) {
75 if (gaim_conv_chat_find_user(chat, i->data))
76 continue;
77 gaim_conv_chat_add_user(chat, i->data, NULL, GAIM_CBFLAGS_NONE, TRUE);
78 }
79 }
80
81 void yahoo_chat_add_user(GaimConvChat *chat, const char *user, const char *reason)
82 {
83 if (gaim_conv_chat_find_user(chat, user))
84 return;
85
86 gaim_conv_chat_add_user(chat, user, reason, GAIM_CBFLAGS_NONE, TRUE);
87 }
88
89 static GaimConversation *yahoo_find_conference(GaimConnection *gc, const char *name)
90 {
91 struct yahoo_data *yd;
92 GSList *l;
93
94 yd = gc->proto_data;
95
96 for (l = yd->confs; l; l = l->next) {
97 GaimConversation *c = l->data;
98 if (!gaim_utf8_strcasecmp(gaim_conversation_get_name(c), name))
99 return c;
100 }
101 return NULL;
102 }
103
104
105 void yahoo_process_conference_invite(GaimConnection *gc, struct yahoo_packet *pkt)
106 {
107 GSList *l;
108 char *room = NULL;
109 char *who = NULL;
110 char *msg = NULL;
111 GString *members = NULL;
112 GHashTable *components;
113
114 if (pkt->status == 2)
115 return; /* XXX */
116
117 members = g_string_sized_new(512);
118
119 for (l = pkt->hash; l; l = l->next) {
120 struct yahoo_pair *pair = l->data;
121
122 switch (pair->key) {
123 case 1: /* us, but we already know who we are */
124 break;
125 case 57:
126 room = yahoo_string_decode(gc, pair->value, FALSE);
127 break;
128 case 50: /* inviter */
129 who = pair->value;
130 g_string_append_printf(members, "%s\n", who);
131 break;
132 case 52: /* invitee (me) */
133 case 53: /* members */
134 g_string_append_printf(members, "%s\n", pair->value);
135 break;
136 case 58:
137 msg = yahoo_string_decode(gc, pair->value, FALSE);
138 break;
139 case 13: /* ? */
140 break;
141 }
142 }
143
144 if (!room) {
145 g_string_free(members, TRUE);
146 return;
147 }
148
149 components = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
150 g_hash_table_replace(components, g_strdup("room"), room);
151 if (msg)
152 g_hash_table_replace(components, g_strdup("topic"), msg);
153 g_hash_table_replace(components, g_strdup("type"), g_strdup("Conference"));
154 if (members) {
155 g_hash_table_replace(components, g_strdup("members"), g_strdup(members->str));
156 }
157 if (!yahoo_privacy_check(gc, who) ||
158 (gaim_account_get_bool(gaim_connection_get_account(gc), "ignore_invites", FALSE))) {
159 gaim_debug_info("yahoo",
160 "Invite to conference %s from %s has been dropped.\n", room, who);
161 g_string_free(members, TRUE);
162 return;
163 }
164 serv_got_chat_invite(gc, room, who, msg, components);
165
166 g_string_free(members, TRUE);
167 }
168
169 void yahoo_process_conference_decline(GaimConnection *gc, struct yahoo_packet *pkt)
170 {
171 GSList *l;
172 char *room = NULL;
173 char *who = NULL;
174 char *msg = NULL;
175
176 for (l = pkt->hash; l; l = l->next) {
177 struct yahoo_pair *pair = l->data;
178
179 switch (pair->key) {
180 case 57:
181 room = yahoo_string_decode(gc, pair->value, FALSE);
182 break;
183 case 54:
184 who = pair->value;
185 break;
186 case 14:
187 msg = yahoo_string_decode(gc, pair->value, FALSE);
188 break;
189 }
190 }
191 if (!yahoo_privacy_check(gc, who)) {
192 g_free(room);
193 if (msg != NULL)
194 g_free(msg);
195 return;
196 }
197
198 if (who && room) {
199 /* make sure we're in the room before we process a decline message for it */
200 if(yahoo_find_conference(gc, room)) {
201 char *tmp;
202
203 tmp = g_strdup_printf(_("%s declined your conference invitation to room \"%s\" because \"%s\"."),
204 who, room, msg?msg:"");
205 gaim_notify_info(gc, NULL, _("Invitation Rejected"), tmp);
206 g_free(tmp);
207 }
208
209 g_free(room);
210 if (msg)
211 g_free(msg);
212 }
213 }
214
215 void yahoo_process_conference_logon(GaimConnection *gc, struct yahoo_packet *pkt)
216 {
217 GSList *l;
218 char *room = NULL;
219 char *who = NULL;
220 GaimConversation *c;
221
222 for (l = pkt->hash; l; l = l->next) {
223 struct yahoo_pair *pair = l->data;
224
225 switch (pair->key) {
226 case 57:
227 room = yahoo_string_decode(gc, pair->value, FALSE);
228 break;
229 case 53:
230 who = pair->value;
231 break;
232 }
233 }
234
235 if (who && room) {
236 c = yahoo_find_conference(gc, room);
237 if (c)
238 yahoo_chat_add_user(GAIM_CONV_CHAT(c), who, NULL);
239 g_free(room);
240 }
241 }
242
243 void yahoo_process_conference_logoff(GaimConnection *gc, struct yahoo_packet *pkt)
244 {
245 GSList *l;
246 char *room = NULL;
247 char *who = NULL;
248 GaimConversation *c;
249
250 for (l = pkt->hash; l; l = l->next) {
251 struct yahoo_pair *pair = l->data;
252
253 switch (pair->key) {
254 case 57:
255 room = yahoo_string_decode(gc, pair->value, FALSE);
256 break;
257 case 56:
258 who = pair->value;
259 break;
260 }
261 }
262
263 if (who && room) {
264 c = yahoo_find_conference(gc, room);
265 if (c)
266 gaim_conv_chat_remove_user(GAIM_CONV_CHAT(c), who, NULL);
267 g_free(room);
268 }
269 }
270
271 void yahoo_process_conference_message(GaimConnection *gc, struct yahoo_packet *pkt)
272 {
273 GSList *l;
274 char *room = NULL;
275 char *who = NULL;
276 char *msg = NULL;
277 char *msg2;
278 int utf8 = 0;
279 GaimConversation *c;
280
281 for (l = pkt->hash; l; l = l->next) {
282 struct yahoo_pair *pair = l->data;
283
284 switch (pair->key) {
285 case 57:
286 room = yahoo_string_decode(gc, pair->value, FALSE);
287 break;
288 case 3:
289 who = pair->value;
290 break;
291 case 14:
292 msg = pair->value;
293 break;
294 case 97:
295 utf8 = strtol(pair->value, NULL, 10);
296 break;
297 }
298 }
299
300 if (room && who && msg) {
301 msg2 = yahoo_string_decode(gc, msg, utf8);
302 c = yahoo_find_conference(gc, room);
303 if (!c)
304 return;
305 msg = yahoo_codes_to_html(msg2);
306 serv_got_chat_in(gc, gaim_conv_chat_get_id(GAIM_CONV_CHAT(c)), who, 0, msg, time(NULL));
307 g_free(msg);
308 g_free(msg2);
309 }
310 if (room)
311 g_free(room);
312 }
313
314
315 /* this is a confirmation of yahoo_chat_online(); */
316 void yahoo_process_chat_online(GaimConnection *gc, struct yahoo_packet *pkt)
317 {
318 struct yahoo_data *yd = (struct yahoo_data *) gc->proto_data;
319
320 if (pkt->status == 1)
321 yd->chat_online = 1;
322 }
323
324 /* this is basicly the opposite of chat_online */
325 void yahoo_process_chat_logout(GaimConnection *gc, struct yahoo_packet *pkt)
326 {
327 struct yahoo_data *yd = (struct yahoo_data *) gc->proto_data;
328 GSList *l;
329
330 for (l = pkt->hash; l; l = l->next) {
331 struct yahoo_pair *pair = l->data;
332
333 if (pair->key == 1)
334 if (g_ascii_strcasecmp(pair->value,
335 gaim_connection_get_display_name(gc)))
336 return;
337 }
338
339 if (pkt->status == 1) {
340 yd->chat_online = 0;
341 if (yd->in_chat)
342 yahoo_c_leave(gc, YAHOO_CHAT_ID);
343 }
344 }
345
346 void yahoo_process_chat_join(GaimConnection *gc, struct yahoo_packet *pkt)
347 {
348 GaimAccount *account = gaim_connection_get_account(gc);
349 struct yahoo_data *yd = (struct yahoo_data *) gc->proto_data;
350 GaimConversation *c = NULL;
351 GSList *l;
352 GList *members = NULL;
353 GList *roomies = NULL;
354 char *room = NULL;
355 char *topic = NULL;
356 char *someid, *someotherid, *somebase64orhashosomething, *somenegativenumber;
357
358 if (pkt->status == -1) {
359 /* We can't join */
360 struct yahoo_pair *pair = pkt->hash->data;
361 gchar const *failed_to_join = _("Failed to join chat");
362 switch (atoi(pair->value)) {
363 case 0xFFFFFFFA: /* -6 */
364 gaim_notify_error(gc, NULL, failed_to_join, _("Unknown room"));
365 break;
366 case 0xFFFFFFF1: /* -15 */
367 gaim_notify_error(gc, NULL, failed_to_join, _("Maybe the room is full"));
368 break;
369 case 0xFFFFFFDD: /* -35 */
370 gaim_notify_error(gc, NULL, failed_to_join, _("Not available"));
371 break;
372 default:
373 gaim_notify_error(gc, NULL, failed_to_join,
374 _("Unknown error. You may need to logout and wait five minutes before being able to rejoin a chatroom"));
375 }
376 return;
377 }
378
379 for (l = pkt->hash; l; l = l->next) {
380 struct yahoo_pair *pair = l->data;
381
382 switch (pair->key) {
383
384 case 104:
385 room = yahoo_string_decode(gc, pair->value, TRUE);
386 break;
387 case 105:
388 topic = yahoo_string_decode(gc, pair->value, TRUE);
389 break;
390 case 128:
391 someid = pair->value;
392 break;
393 case 108: /* number of joiners */
394 break;
395 case 129:
396 someotherid = pair->value;
397 break;
398 case 130:
399 somebase64orhashosomething = pair->value;
400 break;
401 case 126:
402 somenegativenumber = pair->value;
403 break;
404 case 13: /* this is 1. maybe its the type of room? (normal, user created, private, etc?) */
405 break;
406 case 61: /*this looks similar to 130 */
407 break;
408
409 /* the previous section was just room info. this next section is
410 info about individual room members, (including us) */
411
412 case 109: /* the yahoo id */
413 members = g_list_append(members, pair->value);
414 break;
415 case 110: /* age */
416 break;
417 case 141: /* nickname */
418 break;
419 case 142: /* location */
420 break;
421 case 113: /* bitmask */
422 break;
423 }
424 }
425
426 if (room && yd->chat_name && gaim_utf8_strcasecmp(room, yd->chat_name))
427 yahoo_chat_leave(gc, room,
428 gaim_connection_get_display_name(gc), FALSE);
429
430 c = gaim_find_chat(gc, YAHOO_CHAT_ID);
431
432 if (room && (!c || gaim_conv_chat_has_left(GAIM_CONV_CHAT(c))) && members &&
433 ((g_list_length(members) > 1) ||
434 !g_ascii_strcasecmp(members->data, gaim_connection_get_display_name(gc)))) {
435 int i;
436 GList *flags = NULL;
437 for (i = 0; i < g_list_length(members); i++)
438 flags = g_list_append(flags, GINT_TO_POINTER(GAIM_CBFLAGS_NONE));
439 if (c && gaim_conv_chat_has_left(GAIM_CONV_CHAT(c))) {
440 /* this might be a hack, but oh well, it should nicely */
441 char *tmpmsg;
442
443 gaim_conversation_set_name(c, room);
444
445 c = serv_got_joined_chat(gc, YAHOO_CHAT_ID, room);
446 if (topic)
447 gaim_conv_chat_set_topic(GAIM_CONV_CHAT(c), NULL, topic);
448 yd->in_chat = 1;
449 yd->chat_name = g_strdup(room);
450 gaim_conv_chat_add_users(GAIM_CONV_CHAT(c), members, NULL, flags, FALSE);
451
452 tmpmsg = g_strdup_printf(_("You are now chatting in %s."), room);
453 gaim_conv_chat_write(GAIM_CONV_CHAT(c), "", tmpmsg, GAIM_MESSAGE_SYSTEM, time(NULL));
454 g_free(tmpmsg);
455 } else {
456 c = serv_got_joined_chat(gc, YAHOO_CHAT_ID, room);
457 if (topic)
458 gaim_conv_chat_set_topic(GAIM_CONV_CHAT(c), NULL, topic);
459 yd->in_chat = 1;
460 yd->chat_name = g_strdup(room);
461 gaim_conv_chat_add_users(GAIM_CONV_CHAT(c), members, NULL, flags, FALSE);
462 }
463 } else if (c) {
464 yahoo_chat_add_users(GAIM_CONV_CHAT(c), members);
465 }
466
467 if (account->deny && c) {
468 GaimConversationUiOps *ops = gaim_conversation_get_ui_ops(c);
469 for (l = account->deny; l != NULL; l = l->next) {
470 for (roomies = members; roomies; roomies = roomies->next) {
471 if (!gaim_utf8_strcasecmp((char *)l->data, roomies->data)) {
472 gaim_debug_info("yahoo", "Ignoring room member %s in room %s\n" , roomies->data, room ? room : "");
473 gaim_conv_chat_ignore(GAIM_CONV_CHAT(c),roomies->data);
474 ops->chat_update_user(c, roomies->data);
475 }
476 }
477 }
478 }
479 g_list_free(roomies);
480 g_list_free(members);
481 g_free(room);
482 g_free(topic);
483 }
484
485 void yahoo_process_chat_exit(GaimConnection *gc, struct yahoo_packet *pkt)
486 {
487 char *who = NULL;
488 char *room = NULL;
489 GSList *l;
490 struct yahoo_data *yd;
491
492 yd = gc->proto_data;
493
494 for (l = pkt->hash; l; l = l->next) {
495 struct yahoo_pair *pair = l->data;
496
497 if (pair->key == 104)
498 room = yahoo_string_decode(gc, pair->value, TRUE);
499 if (pair->key == 109)
500 who = pair->value;
501 }
502
503 if (who && room) {
504 GaimConversation *c = gaim_find_chat(gc, YAHOO_CHAT_ID);
505 if (c && !gaim_utf8_strcasecmp(gaim_conversation_get_name(c), room))
506 gaim_conv_chat_remove_user(GAIM_CONV_CHAT(c), who, NULL);
507
508 }
509 if (room)
510 g_free(room);
511 }
512
513 void yahoo_process_chat_message(GaimConnection *gc, struct yahoo_packet *pkt)
514 {
515 char *room = NULL, *who = NULL, *msg = NULL, *msg2;
516 int msgtype = 1, utf8 = 1; /* default to utf8 */
517 GaimConversation *c = NULL;
518 GSList *l;
519
520 for (l = pkt->hash; l; l = l->next) {
521 struct yahoo_pair *pair = l->data;
522
523 switch (pair->key) {
524
525 case 97:
526 utf8 = strtol(pair->value, NULL, 10);
527 break;
528 case 104:
529 room = yahoo_string_decode(gc, pair->value, TRUE);
530 break;
531 case 109:
532 who = pair->value;
533 break;
534 case 117:
535 msg = pair->value;
536 break;
537 case 124:
538 msgtype = strtol(pair->value, NULL, 10);
539 break;
540 }
541 }
542
543 c = gaim_find_chat(gc, YAHOO_CHAT_ID);
544 if (!who || !c) {
545 if (room)
546 g_free(room);
547 /* we still get messages after we part, funny that */
548 return;
549 }
550
551 if (!msg) {
552 gaim_debug(GAIM_DEBUG_MISC, "yahoo", "Got a message packet with no message.\nThis probably means something important, but we're ignoring it.\n");
553 return;
554 }
555 msg2 = yahoo_string_decode(gc, msg, utf8);
556 msg = yahoo_codes_to_html(msg2);
557 g_free(msg2);
558
559 if (msgtype == 2 || msgtype == 3) {
560 char *tmp;
561 tmp = g_strdup_printf("/me %s", msg);
562 g_free(msg);
563 msg = tmp;
564 }
565
566 serv_got_chat_in(gc, YAHOO_CHAT_ID, who, 0, msg, time(NULL));
567 g_free(msg);
568 g_free(room);
569 }
570
571 void yahoo_process_chat_addinvite(GaimConnection *gc, struct yahoo_packet *pkt)
572 {
573 GSList *l;
574 char *room = NULL;
575 char *msg = NULL;
576 char *who = NULL;
577
578 for (l = pkt->hash; l; l = l->next) {
579 struct yahoo_pair *pair = l->data;
580
581 switch (pair->key) {
582 case 104:
583 room = yahoo_string_decode(gc, pair->value, TRUE);
584 break;
585 case 129: /* room id? */
586 break;
587 case 126: /* ??? */
588 break;
589 case 117:
590 msg = yahoo_string_decode(gc, pair->value, FALSE);
591 break;
592 case 119:
593 who = pair->value;
594 break;
595 case 118: /* us */
596 break;
597 }
598 }
599
600 if (room && who) {
601 GHashTable *components;
602
603 components = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
604 g_hash_table_replace(components, g_strdup("room"), g_strdup(room));
605 if (!yahoo_privacy_check(gc, who) ||
606 (gaim_account_get_bool(gaim_connection_get_account(gc), "ignore_invites", FALSE))) {
607 gaim_debug_info("yahoo",
608 "Invite to room %s from %s has been dropped.\n", room, who);
609 if (room != NULL)
610 g_free(room);
611 if (msg != NULL)
612 g_free(msg);
613 return;
614 }
615 serv_got_chat_invite(gc, room, who, msg, components);
616 }
617 if (room)
618 g_free(room);
619 if (msg)
620 g_free(msg);
621 }
622
623 void yahoo_process_chat_goto(GaimConnection *gc, struct yahoo_packet *pkt)
624 {
625 if (pkt->status == -1)
626 gaim_notify_error(gc, NULL, _("Failed to join buddy in chat"),
627 _("Maybe they're not in a chat?"));
628 }
629
630 /*
631 * Functions dealing with conferences
632 * I think conference names are always ascii.
633 */
634
635 void yahoo_conf_leave(struct yahoo_data *yd, const char *room, const char *dn, GList *who)
636 {
637 struct yahoo_packet *pkt;
638 GList *w;
639
640 gaim_debug_misc("yahoo", "leaving conference %s\n", room);
641
642 pkt = yahoo_packet_new(YAHOO_SERVICE_CONFLOGOFF, YAHOO_STATUS_AVAILABLE, 0);
643
644 yahoo_packet_hash_str(pkt, 1, dn);
645 for (w = who; w; w = w->next) {
646 const char *name = gaim_conv_chat_cb_get_name(w->data);
647 yahoo_packet_hash_str(pkt, 3, name);
648 }
649
650 yahoo_packet_hash_str(pkt, 57, room);
651 yahoo_packet_send_and_free(pkt, yd);
652 }
653
654 static int yahoo_conf_send(GaimConnection *gc, const char *dn, const char *room,
655 GList *members, const char *what)
656 {
657 struct yahoo_data *yd = gc->proto_data;
658 struct yahoo_packet *pkt;
659 GList *who;
660 char *msg, *msg2;
661 int utf8 = 1;
662
663 msg = yahoo_html_to_codes(what);
664 msg2 = yahoo_string_encode(gc, msg, &utf8);
665
666 pkt = yahoo_packet_new(YAHOO_SERVICE_CONFMSG, YAHOO_STATUS_AVAILABLE, 0);
667
668 yahoo_packet_hash_str(pkt, 1, dn);
669 for (who = members; who; who = who->next) {
670 const char *name = gaim_conv_chat_cb_get_name(who->data);
671 yahoo_packet_hash_str(pkt, 53, name);
672 }
673 yahoo_packet_hash(pkt, "ss", 57, room, 14, msg2);
674 if (utf8)
675 yahoo_packet_hash_str(pkt, 97, "1"); /* utf-8 */
676
677 yahoo_packet_send_and_free(pkt, yd);
678 g_free(msg);
679 g_free(msg2);
680
681 return 0;
682 }
683
684 static void yahoo_conf_join(struct yahoo_data *yd, GaimConversation *c, const char *dn, const char *room,
685 const char *topic, const char *members)
686 {
687 struct yahoo_packet *pkt;
688 char **memarr = NULL;
689 int i;
690
691 if (members)
692 memarr = g_strsplit(members, "\n", 0);
693
694 pkt = yahoo_packet_new(YAHOO_SERVICE_CONFLOGON, YAHOO_STATUS_AVAILABLE, 0);
695
696 yahoo_packet_hash(pkt, "sss", 1, dn, 3, dn, 57, room);
697 if (memarr) {
698 for(i = 0 ; memarr[i]; i++) {
699 if (!strcmp(memarr[i], "") || !strcmp(memarr[i], dn))
700 continue;
701 yahoo_packet_hash_str(pkt, 3, memarr[i]);
702 gaim_conv_chat_add_user(GAIM_CONV_CHAT(c), memarr[i], NULL, GAIM_CBFLAGS_NONE, TRUE);
703 }
704 }
705 yahoo_packet_send_and_free(pkt, yd);
706
707 if (memarr)
708 g_strfreev(memarr);
709 }
710
711 static void yahoo_conf_invite(GaimConnection *gc, GaimConversation *c,
712 const char *dn, const char *buddy, const char *room, const char *msg)
713 {
714 struct yahoo_data *yd = gc->proto_data;
715 struct yahoo_packet *pkt;
716 GList *members;
717 char *msg2 = NULL;
718
719 if (msg)
720 msg2 = yahoo_string_encode(gc, msg, NULL);
721
722 members = gaim_conv_chat_get_users(GAIM_CONV_CHAT(c));
723
724 pkt = yahoo_packet_new(YAHOO_SERVICE_CONFADDINVITE, YAHOO_STATUS_AVAILABLE, 0);
725
726 yahoo_packet_hash(pkt, "sssss", 1, dn, 51, buddy, 57, room, 58, msg?msg2:"", 13, "0");
727 for(; members; members = members->next) {
728 const char *name = gaim_conv_chat_cb_get_name(members->data);
729 if (!strcmp(name, dn))
730 continue;
731 yahoo_packet_hash(pkt, "ss", 52, name, 53, name);
732 }
733
734 yahoo_packet_send_and_free(pkt, yd);
735 g_free(msg2);
736 }
737
738 /*
739 * Functions dealing with chats
740 */
741
742 static void yahoo_chat_leave(GaimConnection *gc, const char *room, const char *dn, gboolean logout)
743 {
744 struct yahoo_data *yd = gc->proto_data;
745 struct yahoo_packet *pkt;
746 GaimConversation *c;
747
748 char *eroom;
749 gboolean utf8 = 1;
750
751 if (yd->wm) {
752 g_return_if_fail(yd->ycht != NULL);
753
754 ycht_chat_leave(yd->ycht, room, logout);
755 return;
756 }
757
758 eroom = yahoo_string_encode(gc, room, &utf8);
759
760 pkt = yahoo_packet_new(YAHOO_SERVICE_CHATEXIT, YAHOO_STATUS_AVAILABLE, 0);
761 yahoo_packet_hash(pkt, "sss", 104, eroom, 109, dn, 108, "1");
762 yahoo_packet_hash_str(pkt, 112, "0"); /* what does this one mean? */
763 yahoo_packet_send_and_free(pkt, yd);
764
765 yd->in_chat = 0;
766 if (yd->chat_name) {
767 g_free(yd->chat_name);
768 yd->chat_name = NULL;
769 }
770
771 if ((c = gaim_find_chat(gc, YAHOO_CHAT_ID)))
772 serv_got_chat_left(gc, YAHOO_CHAT_ID);
773
774 if (!logout)
775 return;
776
777 pkt = yahoo_packet_new(YAHOO_SERVICE_CHATLOGOUT,
778 YAHOO_STATUS_AVAILABLE, 0);
779 yahoo_packet_hash_str(pkt, 1, dn);
780 yahoo_packet_send_and_free(pkt, yd);
781
782 yd->chat_online = 0;
783 g_free(eroom);
784 }
785
786 /* borrowed from gtkconv.c */
787 static gboolean
788 meify(char *message, size_t len)
789 {
790 /*
791 * Read /me-ify: If the message (post-HTML) starts with /me,
792 * remove the "/me " part of it (including that space) and return TRUE.
793 */
794 char *c;
795 gboolean inside_html = 0;
796
797 /* Umm.. this would be very bad if this happens. */
798 g_return_val_if_fail(message != NULL, FALSE);
799
800 if (len == -1)
801 len = strlen(message);
802
803 for (c = message; *c != '\0'; c++, len--) {
804 if (inside_html) {
805 if (*c == '>')
806 inside_html = FALSE;
807 }
808 else {
809 if (*c == '<')
810 inside_html = TRUE;
811 else
812 break;
813 }
814 }
815
816 if (*c != '\0' && !g_ascii_strncasecmp(c, "/me ", 4)) {
817 memmove(c, c + 4, len - 3);
818 return TRUE;
819 }
820
821 return FALSE;
822 }
823
824 static int yahoo_chat_send(GaimConnection *gc, const char *dn, const char *room, const char *what, GaimMessageFlags flags)
825 {
826 struct yahoo_data *yd = gc->proto_data;
827 struct yahoo_packet *pkt;
828 int me = 0;
829 char *msg1, *msg2, *room2;
830 gboolean utf8 = TRUE;
831
832 if (yd->wm) {
833 g_return_val_if_fail(yd->ycht != NULL, 1);
834
835 return ycht_chat_send(yd->ycht, room, what);
836 }
837
838 msg1 = g_strdup(what);
839
840 if (meify(msg1, -1))
841 me = 1;
842
843 msg2 = yahoo_html_to_codes(msg1);
844 g_free(msg1);
845 msg1 = yahoo_string_encode(gc, msg2, &utf8);
846 g_free(msg2);
847 room2 = yahoo_string_encode(gc, room, NULL);
848
849 pkt = yahoo_packet_new(YAHOO_SERVICE_COMMENT, YAHOO_STATUS_AVAILABLE, 0);
850
851 yahoo_packet_hash(pkt, "sss", 1, dn, 104, room2, 117, msg1);
852 if (me)
853 yahoo_packet_hash_str(pkt, 124, "2");
854 else
855 yahoo_packet_hash_str(pkt, 124, "1");
856 /* fixme: what about /think? (124=3) */
857 if (utf8)
858 yahoo_packet_hash_str(pkt, 97, "1");
859
860 yahoo_packet_send_and_free(pkt, yd);
861 g_free(msg1);
862 g_free(room2);
863
864 return 0;
865 }
866
867 static void yahoo_chat_join(GaimConnection *gc, const char *dn, const char *room, const char *topic)
868 {
869 struct yahoo_data *yd = gc->proto_data;
870 struct yahoo_packet *pkt;
871 char *room2;
872 gboolean utf8 = TRUE;
873
874 if (yd->wm) {
875 g_return_if_fail(yd->ycht != NULL);
876 ycht_chat_join(yd->ycht, room);
877 return;
878 }
879
880 /* apparently room names are always utf8, or else always not utf8,
881 * so we don't have to actually pass the flag in the packet. Or something. */
882 room2 = yahoo_string_encode(gc, room, &utf8);
883
884 pkt = yahoo_packet_new(YAHOO_SERVICE_CHATJOIN, YAHOO_STATUS_AVAILABLE, 0);
885 yahoo_packet_hash(pkt, "ssss", 1, gaim_connection_get_display_name(gc),
886 62, "2", 104, room2, 129, "0");
887 yahoo_packet_send_and_free(pkt, yd);
888 g_free(room2);
889 }
890
891 static void yahoo_chat_invite(GaimConnection *gc, const char *dn, const char *buddy,
892 const char *room, const char *msg)
893 {
894 struct yahoo_data *yd = gc->proto_data;
895 struct yahoo_packet *pkt;
896 char *room2, *msg2 = NULL;
897 gboolean utf8 = TRUE;
898
899 if (yd->wm) {
900 g_return_if_fail(yd->ycht != NULL);
901 ycht_chat_send_invite(yd->ycht, room, buddy, msg);
902 return;
903 }
904
905 room2 = yahoo_string_encode(gc, room, &utf8);
906 if (msg)
907 msg2 = yahoo_string_encode(gc, msg, NULL);
908
909 pkt = yahoo_packet_new(YAHOO_SERVICE_CHATADDINVITE, YAHOO_STATUS_AVAILABLE, 0);
910 yahoo_packet_hash(pkt, "sssss", 1, dn, 118, buddy, 104, room2, 117, (msg2?msg2:""), 129, "0");
911 yahoo_packet_send_and_free(pkt, yd);
912
913 g_free(room2);
914 g_free(msg2);
915 }
916
917 void yahoo_chat_goto(GaimConnection *gc, const char *name)
918 {
919 struct yahoo_data *yd;
920 struct yahoo_packet *pkt;
921
922 yd = gc->proto_data;
923
924 if (yd->wm) {
925 g_return_if_fail(yd->ycht != NULL);
926 ycht_chat_goto_user(yd->ycht, name);
927 return;
928 }
929
930 if (!yd->chat_online)
931 yahoo_chat_online(gc);
932
933 pkt = yahoo_packet_new(YAHOO_SERVICE_CHATGOTO, YAHOO_STATUS_AVAILABLE, 0);
934 yahoo_packet_hash(pkt, "sss", 109, name, 1, gaim_connection_get_display_name(gc), 62, "2");
935 yahoo_packet_send_and_free(pkt, yd);
936 }
937 /*
938 * These are the functions registered with the core
939 * which get called for both chats and conferences.
940 */
941
942 void yahoo_c_leave(GaimConnection *gc, int id)
943 {
944 struct yahoo_data *yd = (struct yahoo_data *) gc->proto_data;
945 GaimConversation *c;
946
947 if (!yd)
948 return;
949
950 c = gaim_find_chat(gc, id);
951 if (!c)
952 return;
953
954 if (id != YAHOO_CHAT_ID) {
955 yahoo_conf_leave(yd, gaim_conversation_get_name(c),
956 gaim_connection_get_display_name(gc), gaim_conv_chat_get_users(GAIM_CONV_CHAT(c)));
957 yd->confs = g_slist_remove(yd->confs, c);
958 } else {
959 yahoo_chat_leave(gc, gaim_conversation_get_name(c), gaim_connection_get_display_name(gc), TRUE);
960 }
961
962 serv_got_chat_left(gc, id);
963 }
964
965 int yahoo_c_send(GaimConnection *gc, int id, const char *what, GaimMessageFlags flags)
966 {
967 GaimConversation *c;
968 int ret;
969 struct yahoo_data *yd;
970
971 yd = (struct yahoo_data *) gc->proto_data;
972 if (!yd)
973 return -1;
974
975 c = gaim_find_chat(gc, id);
976 if (!c)
977 return -1;
978
979 if (id != YAHOO_CHAT_ID) {
980 ret = yahoo_conf_send(gc, gaim_connection_get_display_name(gc),
981 gaim_conversation_get_name(c), gaim_conv_chat_get_users(GAIM_CONV_CHAT(c)), what);
982 } else {
983 ret = yahoo_chat_send(gc, gaim_connection_get_display_name(gc),
984 gaim_conversation_get_name(c), what, flags);
985 if (!ret)
986 serv_got_chat_in(gc, gaim_conv_chat_get_id(GAIM_CONV_CHAT(c)),
987 gaim_connection_get_display_name(gc), 0, what, time(NULL));
988 }
989 return ret;
990 }
991
992 GList *yahoo_c_info(GaimConnection *gc)
993 {
994 GList *m = NULL;
995 struct proto_chat_entry *pce;
996
997 pce = g_new0(struct proto_chat_entry, 1);
998 pce->label = _("_Room:");
999 pce->identifier = "room";
1000 pce->required = TRUE;
1001 m = g_list_append(m, pce);
1002
1003 return m;
1004 }
1005
1006 GHashTable *yahoo_c_info_defaults(GaimConnection *gc, const char *chat_name)
1007 {
1008 GHashTable *defaults;
1009
1010 defaults = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, g_free);
1011
1012 if (chat_name != NULL)
1013 g_hash_table_insert(defaults, "room", g_strdup(chat_name));
1014
1015 return defaults;
1016 }
1017
1018 char *yahoo_get_chat_name(GHashTable *data)
1019 {
1020 return g_strdup(g_hash_table_lookup(data, "room"));
1021 }
1022
1023 void yahoo_c_join(GaimConnection *gc, GHashTable *data)
1024 {
1025 struct yahoo_data *yd;
1026 char *room, *topic, *members, *type;
1027 int id;
1028 GaimConversation *c;
1029
1030 yd = (struct yahoo_data *) gc->proto_data;
1031 if (!yd)
1032 return;
1033
1034 room = g_hash_table_lookup(data, "room");
1035 if (!room)
1036 return;
1037
1038 topic = g_hash_table_lookup(data, "topic");
1039 if (!topic)
1040 topic = "";
1041
1042 members = g_hash_table_lookup(data, "members");
1043
1044 if ((type = g_hash_table_lookup(data, "type")) && !strcmp(type, "Conference")) {
1045 id = yd->conf_id++;
1046 c = serv_got_joined_chat(gc, id, room);
1047 yd->confs = g_slist_prepend(yd->confs, c);
1048 gaim_conv_chat_set_topic(GAIM_CONV_CHAT(c), gaim_connection_get_display_name(gc), topic);
1049 yahoo_conf_join(yd, c, gaim_connection_get_display_name(gc), room, topic, members);
1050 return;
1051 } else {
1052 if (yd->in_chat)
1053 yahoo_chat_leave(gc, room,
1054 gaim_connection_get_display_name(gc),
1055 FALSE);
1056 if (!yd->chat_online)
1057 yahoo_chat_online(gc);
1058 yahoo_chat_join(gc, gaim_connection_get_display_name(gc), room, topic);
1059 return;
1060 }
1061 }
1062
1063 void yahoo_c_invite(GaimConnection *gc, int id, const char *msg, const char *name)
1064 {
1065 GaimConversation *c;
1066
1067 c = gaim_find_chat(gc, id);
1068 if (!c || !c->name)
1069 return;
1070
1071 if (id != YAHOO_CHAT_ID) {
1072 yahoo_conf_invite(gc, c, gaim_connection_get_display_name(gc), name,
1073 gaim_conversation_get_name(c), msg);
1074 } else {
1075 yahoo_chat_invite(gc, gaim_connection_get_display_name(gc), name,
1076 gaim_conversation_get_name(c), msg);
1077 }
1078 }
1079
1080 struct yahoo_roomlist {
1081 int fd;
1082 int inpa;
1083 guchar *rxqueue;
1084 int rxlen;
1085 gboolean started;
1086 char *path;
1087 char *host;
1088 GaimRoomlist *list;
1089 GaimRoomlistRoom *cat;
1090 GaimRoomlistRoom *ucat;
1091 GMarkupParseContext *parse;
1092 };
1093
1094 static void yahoo_roomlist_destroy(struct yahoo_roomlist *yrl)
1095 {
1096 if (yrl->inpa)
1097 gaim_input_remove(yrl->inpa);
1098 if (yrl->rxqueue)
1099 g_free(yrl->rxqueue);
1100 if (yrl->path)
1101 g_free(yrl->path);
1102 if (yrl->host)
1103 g_free(yrl->host);
1104 if (yrl->parse)
1105 g_markup_parse_context_free(yrl->parse);
1106 g_free(yrl);
1107 }
1108
1109 enum yahoo_room_type {
1110 yrt_yahoo,
1111 yrt_user,
1112 };
1113
1114 struct yahoo_chatxml_state {
1115 GaimRoomlist *list;
1116 struct yahoo_roomlist *yrl;
1117 GQueue *q;
1118 struct {
1119 enum yahoo_room_type type;
1120 char *name;
1121 char *topic;
1122 char *id;
1123 int users, voices, webcams;
1124 } room;
1125 };
1126
1127 struct yahoo_lobby {
1128 int count, users, voices, webcams;
1129 };
1130
1131 static struct yahoo_chatxml_state *yahoo_chatxml_state_new(GaimRoomlist *list, struct yahoo_roomlist *yrl)
1132 {
1133 struct yahoo_chatxml_state *s;
1134
1135 s = g_new0(struct yahoo_chatxml_state, 1);
1136 s->list = list;
1137 s->yrl = yrl;
1138 s->q = g_queue_new();
1139
1140 return s;
1141 }
1142
1143 static void yahoo_chatxml_state_destroy(struct yahoo_chatxml_state *s)
1144 {
1145 g_queue_free(s->q);
1146 if (s->room.name)
1147 g_free(s->room.name);
1148 if (s->room.topic)
1149 g_free(s->room.topic);
1150 if (s->room.id)
1151 g_free(s->room.id);
1152 g_free(s);
1153 }
1154
1155 static void yahoo_chatlist_start_element(GMarkupParseContext *context,
1156 const gchar *ename, const gchar **anames,
1157 const gchar **avalues, gpointer user_data,
1158 GError **error)
1159 {
1160 struct yahoo_chatxml_state *s = user_data;
1161 GaimRoomlist *list = s->list;
1162 GaimRoomlistRoom *r;
1163 GaimRoomlistRoom *parent;
1164 int i;
1165
1166 if (!strcmp(ename, "category")) {
1167 const gchar *name = NULL, *id = NULL;
1168
1169 for (i = 0; anames[i]; i++) {
1170 if (!strcmp(anames[i], "id"))
1171 id = avalues[i];
1172 if (!strcmp(anames[i], "name"))
1173 name = avalues[i];
1174 }
1175 if (!name || !id)
1176 return;
1177
1178 parent = g_queue_peek_head(s->q);
1179 r = gaim_roomlist_room_new(GAIM_ROOMLIST_ROOMTYPE_CATEGORY, name, parent);
1180 gaim_roomlist_room_add_field(list, r, (gpointer)name);
1181 gaim_roomlist_room_add_field(list, r, (gpointer)id);
1182 gaim_roomlist_room_add(list, r);
1183 g_queue_push_head(s->q, r);
1184 } else if (!strcmp(ename, "room")) {
1185 s->room.users = s->room.voices = s->room.webcams = 0;
1186
1187 for (i = 0; anames[i]; i++) {
1188 if (!strcmp(anames[i], "id")) {
1189 if (s->room.id)
1190 g_free(s->room.id);
1191 s->room.id = g_strdup(avalues[i]);
1192 } else if (!strcmp(anames[i], "name")) {
1193 if (s->room.name)
1194 g_free(s->room.name);
1195 s->room.name = g_strdup(avalues[i]);
1196 } else if (!strcmp(anames[i], "topic")) {
1197 if (s->room.topic)
1198 g_free(s->room.topic);
1199 s->room.topic = g_strdup(avalues[i]);
1200 } else if (!strcmp(anames[i], "type")) {
1201 if (!strcmp("yahoo", avalues[i]))
1202 s->room.type = yrt_yahoo;
1203 else
1204 s->room.type = yrt_user;
1205 }
1206 }
1207
1208 } else if (!strcmp(ename, "lobby")) {
1209 struct yahoo_lobby *lob = g_new0(struct yahoo_lobby, 1);
1210
1211 for (i = 0; anames[i]; i++) {
1212 if (!strcmp(anames[i], "count")) {
1213 lob->count = strtol(avalues[i], NULL, 10);
1214 } else if (!strcmp(anames[i], "users")) {
1215 s->room.users += lob->users = strtol(avalues[i], NULL, 10);
1216 } else if (!strcmp(anames[i], "voices")) {
1217 s->room.voices += lob->voices = strtol(avalues[i], NULL, 10);
1218 } else if (!strcmp(anames[i], "webcams")) {
1219 s->room.webcams += lob->webcams = strtol(avalues[i], NULL, 10);
1220 }
1221 }
1222 g_queue_push_head(s->q, lob);
1223 }
1224 }
1225
1226 static void yahoo_chatlist_end_element(GMarkupParseContext *context, const gchar *ename,
1227 gpointer user_data, GError **error)
1228 {
1229 struct yahoo_chatxml_state *s = user_data;
1230
1231 if (!strcmp(ename, "category")) {
1232 g_queue_pop_head(s->q);
1233 } else if (!strcmp(ename, "room")) {
1234 struct yahoo_lobby *lob;
1235 GaimRoomlistRoom *r, *l;
1236
1237 if (s->room.type == yrt_yahoo)
1238 r = gaim_roomlist_room_new(GAIM_ROOMLIST_ROOMTYPE_CATEGORY|GAIM_ROOMLIST_ROOMTYPE_ROOM,
1239 s->room.name, s->yrl->cat);
1240 else
1241 r = gaim_roomlist_room_new(GAIM_ROOMLIST_ROOMTYPE_CATEGORY|GAIM_ROOMLIST_ROOMTYPE_ROOM,
1242 s->room.name, s->yrl->ucat);
1243
1244 gaim_roomlist_room_add_field(s->list, r, s->room.name);
1245 gaim_roomlist_room_add_field(s->list, r, s->room.id);
1246 gaim_roomlist_room_add_field(s->list, r, GINT_TO_POINTER(s->room.users));
1247 gaim_roomlist_room_add_field(s->list, r, GINT_TO_POINTER(s->room.voices));
1248 gaim_roomlist_room_add_field(s->list, r, GINT_TO_POINTER(s->room.webcams));
1249 gaim_roomlist_room_add_field(s->list, r, s->room.topic);
1250 gaim_roomlist_room_add(s->list, r);
1251
1252 while ((lob = g_queue_pop_head(s->q))) {
1253 char *name = g_strdup_printf("%s:%d", s->room.name, lob->count);
1254 l = gaim_roomlist_room_new(GAIM_ROOMLIST_ROOMTYPE_ROOM, name, r);
1255
1256 gaim_roomlist_room_add_field(s->list, l, name);
1257 gaim_roomlist_room_add_field(s->list, l, s->room.id);
1258 gaim_roomlist_room_add_field(s->list, l, GINT_TO_POINTER(lob->users));
1259 gaim_roomlist_room_add_field(s->list, l, GINT_TO_POINTER(lob->voices));
1260 gaim_roomlist_room_add_field(s->list, l, GINT_TO_POINTER(lob->webcams));
1261 gaim_roomlist_room_add_field(s->list, l, s->room.topic);
1262 gaim_roomlist_room_add(s->list, l);
1263
1264 g_free(name);
1265 g_free(lob);
1266 }
1267 }
1268 }
1269
1270 static GMarkupParser parser = {
1271 yahoo_chatlist_start_element,
1272 yahoo_chatlist_end_element,
1273 NULL,
1274 NULL,
1275 NULL
1276 };
1277
1278 static void yahoo_roomlist_cleanup(GaimRoomlist *list, struct yahoo_roomlist *yrl)
1279 {
1280 gaim_roomlist_set_in_progress(list, FALSE);
1281
1282 if (yrl) {
1283 list->proto_data = g_list_remove(list->proto_data, yrl);
1284 yahoo_roomlist_destroy(yrl);
1285 }
1286
1287 gaim_roomlist_unref(list);
1288 }
1289
1290 static void yahoo_roomlist_pending(gpointer data, gint source, GaimInputCondition cond)
1291 {
1292 struct yahoo_roomlist *yrl = data;
1293 GaimRoomlist *list = yrl->list;
1294 char buf[1024];
1295 int len;
1296 guchar *start;
1297 struct yahoo_chatxml_state *s;
1298
1299 len = read(yrl->fd, buf, sizeof(buf));
1300
1301 if (len <= 0) {
1302 if (yrl->parse)
1303 g_markup_parse_context_end_parse(yrl->parse, NULL);
1304 yahoo_roomlist_cleanup(list, yrl);
1305 return;
1306 }
1307
1308 yrl->rxqueue = g_realloc(yrl->rxqueue, len + yrl->rxlen);
1309 memcpy(yrl->rxqueue + yrl->rxlen, buf, len);
1310 yrl->rxlen += len;
1311
1312 if (!yrl->started) {
1313 yrl->started = TRUE;
1314 start = (guchar *)g_strstr_len((char *)yrl->rxqueue, yrl->rxlen, "\r\n\r\n");
1315 if (!start || (start - yrl->rxqueue + 4) >= yrl->rxlen)
1316 return;
1317 start += 4;
1318 } else {
1319 start = yrl->rxqueue;
1320 }
1321
1322 if (yrl->parse == NULL) {
1323 s = yahoo_chatxml_state_new(list, yrl);
1324 yrl->parse = g_markup_parse_context_new(&parser, 0, s,
1325 (GDestroyNotify)yahoo_chatxml_state_destroy);
1326 }
1327
1328 if (!g_markup_parse_context_parse(yrl->parse, (char *)start, (yrl->rxlen - (start - yrl->rxqueue)), NULL)) {
1329
1330 yahoo_roomlist_cleanup(list, yrl);
1331 return;
1332 }
1333
1334 yrl->rxlen = 0;
1335 }
1336
1337 static void yahoo_roomlist_got_connected(gpointer data, gint source, GaimInputCondition cond)
1338 {
1339 struct yahoo_roomlist *yrl = data;
1340 GaimRoomlist *list = yrl->list;
1341 char *buf, *cookie;
1342 struct yahoo_data *yd = gaim_account_get_connection(list->account)->proto_data;
1343
1344 if (source < 0) {
1345 gaim_notify_error(gaim_account_get_connection(list->account), NULL, _("Unable to connect"), _("Fetching the room list failed."));
1346 yahoo_roomlist_cleanup(list, yrl);
1347 return;
1348 }
1349
1350 yrl->fd = source;
1351
1352 cookie = g_strdup_printf("Y=%s; T=%s", yd->cookie_y, yd->cookie_t);
1353 buf = g_strdup_printf("GET http://%s/%s HTTP/1.0\r\nHost: %s\r\nCookie: %s\r\n\r\n",
1354 yrl->host, yrl->path, yrl->host, cookie);
1355 write(yrl->fd, buf, strlen(buf));
1356 g_free(cookie);
1357 g_free(buf);
1358 yrl->inpa = gaim_input_add(yrl->fd, GAIM_INPUT_READ, yahoo_roomlist_pending, yrl);
1359
1360 }
1361
1362 GaimRoomlist *yahoo_roomlist_get_list(GaimConnection *gc)
1363 {
1364 struct yahoo_roomlist *yrl;
1365 GaimRoomlist *rl;
1366 const char *rll;
1367 char *url;
1368 GList *fields = NULL;
1369 GaimRoomlistField *f;
1370
1371 rll = gaim_account_get_string(gaim_connection_get_account(gc),
1372 "room_list_locale", YAHOO_ROOMLIST_LOCALE);
1373
1374 if (rll != NULL && *rll != '\0') {
1375 url = g_strdup_printf("%s?chatcat=0&intl=%s",
1376 gaim_account_get_string(gaim_connection_get_account(gc),
1377 "room_list", YAHOO_ROOMLIST_URL), rll);
1378 } else {
1379 url = g_strdup_printf("%s?chatcat=0",
1380 gaim_account_get_string(gaim_connection_get_account(gc),
1381 "room_list", YAHOO_ROOMLIST_URL));
1382 }
1383
1384 yrl = g_new0(struct yahoo_roomlist, 1);
1385 rl = gaim_roomlist_new(gaim_connection_get_account(gc));
1386 yrl->list = rl;
1387
1388 gaim_url_parse(url, &(yrl->host), NULL, &(yrl->path), NULL, NULL);
1389 g_free(url);
1390
1391 f = gaim_roomlist_field_new(GAIM_ROOMLIST_FIELD_STRING, "", "room", TRUE);
1392 fields = g_list_append(fields, f);
1393
1394 f = gaim_roomlist_field_new(GAIM_ROOMLIST_FIELD_STRING, "", "id", TRUE);
1395 fields = g_list_append(fields, f);
1396
1397 f = gaim_roomlist_field_new(GAIM_ROOMLIST_FIELD_INT, _("Users"), "users", FALSE);
1398 fields = g_list_append(fields, f);
1399
1400 f = gaim_roomlist_field_new(GAIM_ROOMLIST_FIELD_INT, _("Voices"), "voices", FALSE);
1401 fields = g_list_append(fields, f);
1402
1403 f = gaim_roomlist_field_new(GAIM_ROOMLIST_FIELD_INT, _("Webcams"), "webcams", FALSE);
1404 fields = g_list_append(fields, f);
1405
1406 f = gaim_roomlist_field_new(GAIM_ROOMLIST_FIELD_STRING, _("Topic"), "topic", FALSE);
1407 fields = g_list_append(fields, f);
1408
1409 gaim_roomlist_set_fields(rl, fields);
1410
1411 if (gaim_proxy_connect(gaim_connection_get_account(gc),
1412 yrl->host, 80, yahoo_roomlist_got_connected, yrl) != 0)
1413 {
1414 gaim_notify_error(gc, NULL, _("Connection problem"), _("Unable to fetch room list."));
1415 yahoo_roomlist_cleanup(rl, yrl);
1416 return NULL;
1417 }
1418
1419 rl->proto_data = g_list_append(rl->proto_data, yrl);
1420
1421 gaim_roomlist_set_in_progress(rl, TRUE);
1422 return rl;
1423 }
1424
1425 void yahoo_roomlist_cancel(GaimRoomlist *list)
1426 {
1427 GList *l, *k;
1428
1429 k = l = list->proto_data;
1430 list->proto_data = NULL;
1431
1432 gaim_roomlist_set_in_progress(list, FALSE);
1433
1434 for (; l; l = l->next) {
1435 yahoo_roomlist_destroy(l->data);
1436 gaim_roomlist_unref(list);
1437 }
1438 g_list_free(k);
1439 }
1440
1441 void yahoo_roomlist_expand_category(GaimRoomlist *list, GaimRoomlistRoom *category)
1442 {
1443 struct yahoo_roomlist *yrl;
1444 char *url;
1445 char *id;
1446 const char *rll;
1447
1448 if (category->type != GAIM_ROOMLIST_ROOMTYPE_CATEGORY)
1449 return;
1450
1451 if (!(id = g_list_nth_data(category->fields, 1))) {
1452 gaim_roomlist_set_in_progress(list, FALSE);
1453 return;
1454 }
1455
1456 rll = gaim_account_get_string(list->account, "room_list_locale",
1457 YAHOO_ROOMLIST_LOCALE);
1458
1459 if (rll != NULL && *rll != '\0') {
1460 url = g_strdup_printf("%s?chatroom_%s=0&intl=%s",
1461 gaim_account_get_string(list->account,"room_list",
1462 YAHOO_ROOMLIST_URL), id, rll);
1463 } else {
1464 url = g_strdup_printf("%s?chatroom_%s=0",
1465 gaim_account_get_string(list->account,"room_list",
1466 YAHOO_ROOMLIST_URL), id);
1467 }
1468
1469 yrl = g_new0(struct yahoo_roomlist, 1);
1470 yrl->list = list;
1471 yrl->cat = category;
1472 list->proto_data = g_list_append(list->proto_data, yrl);
1473
1474 gaim_url_parse(url, &(yrl->host), NULL, &(yrl->path), NULL, NULL);
1475 g_free(url);
1476
1477 yrl->ucat = gaim_roomlist_room_new(GAIM_ROOMLIST_ROOMTYPE_CATEGORY, _("User Rooms"), yrl->cat);
1478 gaim_roomlist_room_add(list, yrl->ucat);
1479
1480 if (gaim_proxy_connect(list->account,
1481 yrl->host, 80, yahoo_roomlist_got_connected, yrl) != 0)
1482 {
1483 gaim_notify_error(gaim_account_get_connection(list->account),
1484 NULL, _("Connection problem"), _("Unable to fetch room list."));
1485 gaim_roomlist_ref(list);
1486 yahoo_roomlist_cleanup(list, yrl);
1487 return;
1488 }
1489
1490 gaim_roomlist_set_in_progress(list, TRUE);
1491 gaim_roomlist_ref(list);
1492 }

Mercurial Repository: pidgin3

mercurial