Mercurial > pidgin3 / file comparison

comparison: libgaim/protocols/gg/gg.c

libgaim/protocols/gg/gg.c

branch
gaim
changeset 20470
77693555855f
parent 12970
c2f3b4dcf711
parent 15419
c8f83c72739d
child 20471
1966704b3e42
equal deleted inserted replaced
13071:b98e72d4089a 20470:77693555855f
1 /**
2 * @file gg.c Gadu-Gadu protocol plugin
3 *
4 * gaim
5 *
6 * Copyright (C) 2005 Bartosz Oler <bartosz@bzimage.us>
7 *
8 * Some parts of the code are adapted or taken from the previous implementation
9 * of this plugin written by Arkadiusz Miskiewicz <misiek@pld.org.pl>
10 *
11 * Thanks to Google's Summer of Code Program.
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 #include "internal.h"
29
30 #include "plugin.h"
31 #include "version.h"
32 #include "notify.h"
33 #include "status.h"
34 #include "blist.h"
35 #include "accountopt.h"
36 #include "debug.h"
37 #include "util.h"
38 #include "request.h"
39
40 #include <libgadu.h>
41
42 #include "gg.h"
43 #include "confer.h"
44 #include "search.h"
45 #include "buddylist.h"
46 #include "gg-utils.h"
47
48 static GaimPlugin *my_protocol = NULL;
49
50 /* ---------------------------------------------------------------------- */
51 /* ----- EXTERNAL CALLBACKS --------------------------------------------- */
52 /* ---------------------------------------------------------------------- */
53
54
55 /* ----- HELPERS -------------------------------------------------------- */
56
57 /**
58 * Set up libgadu's proxy.
59 *
60 * @param account Account for which to set up the proxy.
61 *
62 * @return Zero if proxy setup is valid, otherwise -1.
63 */
64 /* static int ggp_setup_proxy(GaimAccount *account) {{{ */
65 static int ggp_setup_proxy(GaimAccount *account)
66 {
67 GaimProxyInfo *gpi;
68
69 gpi = gaim_proxy_get_setup(account);
70
71 if ((gaim_proxy_info_get_type(gpi) != GAIM_PROXY_NONE) &&
72 (gaim_proxy_info_get_host(gpi) == NULL ||
73 gaim_proxy_info_get_port(gpi) <= 0)) {
74
75 gg_proxy_enabled = 0;
76 gaim_notify_error(NULL, NULL, _("Invalid proxy settings"),
77 _("Either the host name or port number specified for your given proxy type is invalid."));
78 return -1;
79 } else if (gaim_proxy_info_get_type(gpi) != GAIM_PROXY_NONE) {
80 gg_proxy_enabled = 1;
81 gg_proxy_host = g_strdup(gaim_proxy_info_get_host(gpi));
82 gg_proxy_port = gaim_proxy_info_get_port(gpi);
83 gg_proxy_username = g_strdup(gaim_proxy_info_get_username(gpi));
84 gg_proxy_password = g_strdup(gaim_proxy_info_get_password(gpi));
85 } else {
86 gg_proxy_enabled = 0;
87 }
88
89 return 0;
90 }
91 /* }}} */
92
93 /*
94 */
95 /* static void ggp_async_token_handler(gpointer _gc, gint fd, GaimInputCondition cond) {{{ */
96 static void ggp_async_token_handler(gpointer _gc, gint fd, GaimInputCondition cond)
97 {
98 GaimConnection *gc = _gc;
99 GGPInfo *info = gc->proto_data;
100 GGPToken *token = info->token;
101 GGPTokenCallback cb;
102
103 struct gg_token *t = NULL;
104
105 gaim_debug_info("gg", "token_handler: token->req: check = %d; state = %d;\n",
106 token->req->check, token->req->state);
107
108 if (gg_token_watch_fd(token->req) == -1 || token->req->state == GG_STATE_ERROR) {
109 gaim_debug_error("gg", "token error (1): %d\n", token->req->error);
110 gaim_input_remove(token->inpa);
111 gg_token_free(token->req);
112 token->req = NULL;
113
114 gaim_notify_error(gaim_connection_get_account(gc),
115 _("Token Error"),
116 _("Unable to fetch the token.\n"), NULL);
117 return;
118 }
119
120 if (token->req->state != GG_STATE_DONE) {
121 gaim_input_remove(token->inpa);
122 token->inpa = gaim_input_add(token->req->fd,
123 (token->req->check == 1)
124 ? GAIM_INPUT_WRITE
125 : GAIM_INPUT_READ,
126 ggp_async_token_handler, gc);
127 return;
128 }
129
130 if (!(t = token->req->data) || !token->req->body) {
131 gaim_debug_error("gg", "token error (2): %d\n", token->req->error);
132 gaim_input_remove(token->inpa);
133 gg_token_free(token->req);
134 token->req = NULL;
135
136 gaim_notify_error(gaim_connection_get_account(gc),
137 _("Token Error"),
138 _("Unable to fetch the token.\n"), NULL);
139 return;
140 }
141
142 gaim_input_remove(token->inpa);
143
144 token->id = g_strdup(t->tokenid);
145 token->size = token->req->body_size;
146 token->data = g_new0(char, token->size);
147 memcpy(token->data, token->req->body, token->size);
148
149 gaim_debug_info("gg", "TOKEN! tokenid = %s; size = %d\n",
150 token->id, token->size);
151
152 gg_token_free(token->req);
153 token->req = NULL;
154 token->inpa = 0;
155
156 cb = token->cb;
157 token->cb = NULL;
158 cb(gc);
159 }
160 /* }}} */
161
162 /*
163 */
164 /* static void ggp_token_request(GaimConnection *gc, GGPTokenCallback cb) {{{ */
165 static void ggp_token_request(GaimConnection *gc, GGPTokenCallback cb)
166 {
167 GaimAccount *account;
168 struct gg_http *req;
169 GGPInfo *info;
170
171 account = gaim_connection_get_account(gc);
172
173 if (ggp_setup_proxy(account) == -1)
174 return;
175
176 info = gc->proto_data;
177
178 if ((req = gg_token(1)) == NULL) {
179 gaim_notify_error(account,
180 _("Token Error"),
181 _("Unable to fetch the token.\n"), NULL);
182 return;
183 }
184
185 info->token = g_new(GGPToken, 1);
186 info->token->cb = cb;
187
188 info->token->req = req;
189 info->token->inpa = gaim_input_add(req->fd, GAIM_INPUT_READ,
190 ggp_async_token_handler, gc);
191 }
192 /* }}} */
193
194 /* ---------------------------------------------------------------------- */
195
196 /**
197 * Request buddylist from the server.
198 * Buddylist is received in the ggp_callback_recv().
199 *
200 * @param Current action handler.
201 */
202 /* static void ggp_action_buddylist_get(GaimPluginAction *action) {{{ */
203 static void ggp_action_buddylist_get(GaimPluginAction *action)
204 {
205 GaimConnection *gc = (GaimConnection *)action->context;
206 GGPInfo *info = gc->proto_data;
207
208 gaim_debug_info("gg", "Downloading...\n");
209
210 gg_userlist_request(info->session, GG_USERLIST_GET, NULL);
211 }
212 /* }}} */
213
214 /**
215 * Upload the buddylist to the server.
216 *
217 * @param action Current action handler.
218 */
219 /* static void ggp_action_buddylist_put(GaimPluginAction *action) {{{ */
220 static void ggp_action_buddylist_put(GaimPluginAction *action)
221 {
222 GaimConnection *gc = (GaimConnection *)action->context;
223 GGPInfo *info = gc->proto_data;
224
225 char *buddylist = ggp_buddylist_dump(gaim_connection_get_account(gc));
226
227 gaim_debug_info("gg", "Uploading...\n");
228
229 if (buddylist == NULL)
230 return;
231
232 gg_userlist_request(info->session, GG_USERLIST_PUT, buddylist);
233 g_free(buddylist);
234 }
235 /* }}} */
236
237 /**
238 * Delete buddylist from the server.
239 *
240 * @param action Current action handler.
241 */
242 /* static void ggp_action_buddylist_delete(GaimPluginAction *action) {{{ */
243 static void ggp_action_buddylist_delete(GaimPluginAction *action)
244 {
245 GaimConnection *gc = (GaimConnection *)action->context;
246 GGPInfo *info = gc->proto_data;
247
248 gaim_debug_info("gg", "Deleting...\n");
249
250 gg_userlist_request(info->session, GG_USERLIST_PUT, NULL);
251 }
252 /* }}} */
253
254 /*
255 */
256 /* static void ggp_callback_buddylist_save_ok(GaimConnection *gc, gchar *file) {{{ */
257 static void ggp_callback_buddylist_save_ok(GaimConnection *gc, gchar *file)
258 {
259 GaimAccount *account = gaim_connection_get_account(gc);
260
261 FILE *fh;
262 char *buddylist = ggp_buddylist_dump(account);
263 gchar *msg;
264
265 gaim_debug_info("gg", "Saving...\n");
266 gaim_debug_info("gg", "file = %s\n", file);
267
268 if (buddylist == NULL) {
269 gaim_notify_info(account, _("Save Buddylist..."),
270 _("Your buddylist is empty, nothing was written to the file."),
271 NULL);
272 return;
273 }
274
275 if ((fh = g_fopen(file, "wb")) == NULL) {
276 msg = g_strconcat(_("Couldn't open file"), ": ", file, "\n", NULL);
277 gaim_debug_error("gg", "Could not open file: %s\n", file);
278 gaim_notify_error(account, _("Couldn't open file"), msg, NULL);
279 g_free(msg);
280 g_free(file);
281 return;
282 }
283
284 fwrite(buddylist, sizeof(char), g_utf8_strlen(buddylist, -1), fh);
285 fclose(fh);
286 g_free(buddylist);
287
288 gaim_notify_info(account, _("Save Buddylist..."),
289 _("Buddylist saved successfully!"), NULL);
290 }
291 /* }}} */
292
293 /*
294 */
295 /* static void ggp_callback_buddylist_load_ok(GaimConnection *gc, gchar *file) {{{ */
296 static void ggp_callback_buddylist_load_ok(GaimConnection *gc, gchar *file)
297 {
298 GaimAccount *account = gaim_connection_get_account(gc);
299 GError *error = NULL;
300 char *buddylist = NULL;
301 gsize length;
302
303 gaim_debug_info("gg", "file_name = %s\n", file);
304
305 if (!g_file_get_contents(file, &buddylist, &length, &error)) {
306 gaim_notify_error(account,
307 _("Couldn't load buddylist"),
308 _("Couldn't load buddylist"),
309 error->message);
310
311 gaim_debug_error("gg",
312 "Couldn't load buddylist. file = %s; error = %s\n",
313 file, error->message);
314
315 g_error_free(error);
316
317 return;
318 }
319
320 ggp_buddylist_load(gc, buddylist);
321 g_free(buddylist);
322
323 gaim_notify_info(account,
324 _("Load Buddylist..."),
325 _("Buddylist loaded successfully!"), NULL);
326 }
327 /* }}} */
328
329 /*
330 */
331 /* static void ggp_action_buddylist_save(GaimPluginAction *action) {{{ */
332 static void ggp_action_buddylist_save(GaimPluginAction *action)
333 {
334 GaimConnection *gc = (GaimConnection *)action->context;
335
336 gaim_request_file(action, _("Save buddylist..."), NULL, TRUE,
337 G_CALLBACK(ggp_callback_buddylist_save_ok), NULL, gc);
338 }
339 /* }}} */
340
341 /*
342 */
343 /* static void ggp_action_buddylist_load(GaimPluginAction *action) {{{ */
344 static void ggp_action_buddylist_load(GaimPluginAction *action)
345 {
346 GaimConnection *gc = (GaimConnection *)action->context;
347
348 gaim_request_file(action, "Load buddylist from file...", NULL, FALSE,
349 G_CALLBACK(ggp_callback_buddylist_load_ok), NULL, gc);
350 }
351 /* }}} */
352
353 /*
354 */
355 /* static void ggp_callback_register_account_ok(GaimConnection *gc, GaimRequestFields *fields) {{{ */
356 static void ggp_callback_register_account_ok(GaimConnection *gc,
357 GaimRequestFields *fields)
358 {
359 GaimAccount *account;
360 GGPInfo *info = gc->proto_data;
361 struct gg_http *h = NULL;
362 struct gg_pubdir *s;
363 uin_t uin;
364 gchar *email, *p1, *p2, *t;
365 GGPToken *token = info->token;
366
367 email = charset_convert(gaim_request_fields_get_string(fields, "email"),
368 "UTF-8", "CP1250");
369 p1 = charset_convert(gaim_request_fields_get_string(fields, "password1"),
370 "UTF-8", "CP1250");
371 p2 = charset_convert(gaim_request_fields_get_string(fields, "password2"),
372 "UTF-8", "CP1250");
373 t = charset_convert(gaim_request_fields_get_string(fields, "token"),
374 "UTF-8", "CP1250");
375
376 account = gaim_connection_get_account(gc);
377
378 if (email == NULL || p1 == NULL || p2 == NULL || t == NULL ||
379 *email == '\0' || *p1 == '\0' || *p2 == '\0' || *t == '\0') {
380 gaim_connection_error(gc, _("Fill in the registration fields."));
381 goto exit_err;
382 }
383
384 if (g_utf8_collate(p1, p2) != 0) {
385 gaim_connection_error(gc, _("Passwords do not match."));
386 goto exit_err;
387 }
388
389 gaim_debug_info("gg", "register_account_ok: token_id = %d; t = %s\n",
390 token->id, t);
391 h = gg_register3(email, p1, token->id, t, 0);
392 if (h == NULL || !(s = h->data) || !s->success) {
393 gaim_connection_error(gc,
394 _("Unable to register new account. Error occurred.\n"));
395 goto exit_err;
396 }
397
398 uin = s->uin;
399 gaim_debug_info("gg", "registered uin: %d\n", uin);
400
401 g_free(t);
402 t = g_strdup_printf("%u", uin);
403 gaim_account_set_username(account, t);
404 /* Save the password if remembering passwords for the account */
405 gaim_account_set_password(account, p1);
406
407 gaim_notify_info(NULL, _("New Gadu-Gadu Account Registered"),
408 _("Registration completed successfully!"), NULL);
409
410 /* TODO: the currently open Accounts Window will not be updated withthe
411 * new username and etc, we need to somehow have it refresh at this
412 * point
413 */
414
415 /* Need to disconnect or actually log in. For now, we disconnect. */
416 gaim_connection_destroy(gc);
417
418 exit_err:
419 gg_register_free(h);
420 g_free(email);
421 g_free(p1);
422 g_free(p2);
423 g_free(t);
424 g_free(token->id);
425 g_free(token);
426 }
427 /* }}} */
428
429 /*
430 */
431 /* static void ggp_callback_register_account_cancel(GaimConnection *gc, GaimRequestFields *fields) {{{ */
432 static void ggp_callback_register_account_cancel(GaimConnection *gc,
433 GaimRequestFields *fields)
434 {
435 GGPInfo *info = gc->proto_data;
436 GGPToken *token = info->token;
437
438 gaim_connection_destroy(gc);
439
440 g_free(token->id);
441 g_free(token->data);
442 g_free(token);
443
444 }
445 /* }}} */
446
447 /*
448 */
449 /* static void ggp_register_user_dialog(GaimConnection *gc) {{{ */
450 static void ggp_register_user_dialog(GaimConnection *gc)
451 {
452 GaimAccount *account;
453 GaimRequestFields *fields;
454 GaimRequestFieldGroup *group;
455 GaimRequestField *field;
456
457 GGPInfo *info = gc->proto_data;
458 GGPToken *token = info->token;
459
460
461 account = gaim_connection_get_account(gc);
462
463 fields = gaim_request_fields_new();
464 group = gaim_request_field_group_new(NULL);
465 gaim_request_fields_add_group(fields, group);
466
467 field = gaim_request_field_string_new("email",
468 _("E-mail"), "", FALSE);
469 gaim_request_field_string_set_masked(field, FALSE);
470 gaim_request_field_group_add_field(group, field);
471
472 field = gaim_request_field_string_new("password1",
473 _("Password"), "", FALSE);
474 gaim_request_field_string_set_masked(field, TRUE);
475 gaim_request_field_group_add_field(group, field);
476
477 field = gaim_request_field_string_new("password2",
478 _("Password (retype)"), "", FALSE);
479 gaim_request_field_string_set_masked(field, TRUE);
480 gaim_request_field_group_add_field(group, field);
481
482 field = gaim_request_field_string_new("token",
483 _("Enter current token"), "", FALSE);
484 gaim_request_field_string_set_masked(field, FALSE);
485 gaim_request_field_group_add_field(group, field);
486
487 /* original size: 60x24 */
488 field = gaim_request_field_image_new("token_img",
489 _("Current token"), token->data, token->size);
490 gaim_request_field_group_add_field(group, field);
491
492 gaim_request_fields(account,
493 _("Register New Gadu-Gadu Account"),
494 _("Register New Gadu-Gadu Account"),
495 _("Please, fill in the following fields"),
496 fields,
497 _("OK"), G_CALLBACK(ggp_callback_register_account_ok),
498 _("Cancel"), G_CALLBACK(ggp_callback_register_account_cancel),
499 gc);
500 }
501 /* }}} */
502
503 /* ----- PUBLIC DIRECTORY SEARCH ---------------------------------------- */
504
505 /*
506 */
507 /* static void ggp_callback_show_next(GaimConnection *gc, GList *row, gpointer user_data) {{{ */
508 static void ggp_callback_show_next(GaimConnection *gc, GList *row, gpointer user_data)
509 {
510 GGPInfo *info = gc->proto_data;
511 GGPSearchForm *form = user_data;
512 guint32 seq;
513
514 g_free(form->offset);
515 form->offset = g_strdup(form->last_uin);
516
517 ggp_search_remove(info->searches, form->seq);
518
519 seq = ggp_search_start(gc, form);
520 ggp_search_add(info->searches, seq, form);
521 }
522 /* }}} */
523
524 /*
525 */
526 /* static void ggp_callback_add_buddy(GaimConnection *gc, GList *row, gpointer user_data) {{{ */
527 static void ggp_callback_add_buddy(GaimConnection *gc, GList *row, gpointer user_data)
528 {
529 gaim_blist_request_add_buddy(gaim_connection_get_account(gc),
530 g_list_nth_data(row, 0), NULL, NULL);
531 }
532 /* }}} */
533
534 /*
535 */
536 /* static void ggp_callback_im(GaimConnection *gc, GList *row, gpointer user_data) {{{ */
537 static void ggp_callback_im(GaimConnection *gc, GList *row, gpointer user_data)
538 {
539 GaimAccount *account;
540 GaimConversation *conv;
541 char *name;
542
543 account = gaim_connection_get_account(gc);
544
545 name = g_list_nth_data(row, 0);
546 conv = gaim_conversation_new(GAIM_CONV_TYPE_IM, account, name);
547 gaim_conversation_present(conv);
548 }
549 /* }}} */
550
551 /*
552 */
553 /* static void ggp_callback_find_buddies(GaimConnection *gc, GaimRequestFields *fields) {{{ */
554 static void ggp_callback_find_buddies(GaimConnection *gc, GaimRequestFields *fields)
555 {
556 GGPInfo *info = gc->proto_data;
557 GGPSearchForm *form;
558 guint32 seq;
559
560 form = ggp_search_form_new(GGP_SEARCH_TYPE_FULL);
561
562 form->user_data = info;
563 form->lastname = charset_convert(
564 gaim_request_fields_get_string(fields, "lastname"),
565 "UTF-8", "CP1250");
566 form->firstname = charset_convert(
567 gaim_request_fields_get_string(fields, "firstname"),
568 "UTF-8", "CP1250");
569 form->nickname = charset_convert(
570 gaim_request_fields_get_string(fields, "nickname"),
571 "UTF-8", "CP1250");
572 form->city = charset_convert(
573 gaim_request_fields_get_string(fields, "city"),
574 "UTF-8", "CP1250");
575 form->birthyear = charset_convert(
576 gaim_request_fields_get_string(fields, "year"),
577 "UTF-8", "CP1250");
578
579 switch (gaim_request_fields_get_choice(fields, "gender")) {
580 case 1:
581 form->gender = g_strdup(GG_PUBDIR50_GENDER_MALE);
582 break;
583 case 2:
584 form->gender = g_strdup(GG_PUBDIR50_GENDER_FEMALE);
585 break;
586 default:
587 form->gender = NULL;
588 break;
589 }
590
591 form->active = gaim_request_fields_get_bool(fields, "active")
592 ? g_strdup(GG_PUBDIR50_ACTIVE_TRUE) : NULL;
593
594 form->offset = g_strdup("0");
595
596 seq = ggp_search_start(gc, form);
597 ggp_search_add(info->searches, seq, form);
598 }
599 /* }}} */
600
601 /*
602 */
603 /* static void ggp_find_buddies(GaimPluginAction *action) {{{ */
604 static void ggp_find_buddies(GaimPluginAction *action)
605 {
606 GaimConnection *gc = (GaimConnection *)action->context;
607
608 GaimRequestFields *fields;
609 GaimRequestFieldGroup *group;
610 GaimRequestField *field;
611
612 fields = gaim_request_fields_new();
613 group = gaim_request_field_group_new(NULL);
614 gaim_request_fields_add_group(fields, group);
615
616 field = gaim_request_field_string_new("lastname",
617 _("Last name"), NULL, FALSE);
618 gaim_request_field_string_set_masked(field, FALSE);
619 gaim_request_field_group_add_field(group, field);
620
621 field = gaim_request_field_string_new("firstname",
622 _("First name"), NULL, FALSE);
623 gaim_request_field_string_set_masked(field, FALSE);
624 gaim_request_field_group_add_field(group, field);
625
626 field = gaim_request_field_string_new("nickname",
627 _("Nickname"), NULL, FALSE);
628 gaim_request_field_string_set_masked(field, FALSE);
629 gaim_request_field_group_add_field(group, field);
630
631 field = gaim_request_field_string_new("city",
632 _("City"), NULL, FALSE);
633 gaim_request_field_string_set_masked(field, FALSE);
634 gaim_request_field_group_add_field(group, field);
635
636 field = gaim_request_field_string_new("year",
637 _("Year of birth"), NULL, FALSE);
638 gaim_request_field_group_add_field(group, field);
639
640 field = gaim_request_field_choice_new("gender", _("Gender"), 0);
641 gaim_request_field_choice_add(field, _("Male or female"));
642 gaim_request_field_choice_add(field, _("Male"));
643 gaim_request_field_choice_add(field, _("Female"));
644 gaim_request_field_group_add_field(group, field);
645
646 field = gaim_request_field_bool_new("active",
647 _("Only online"), FALSE);
648 gaim_request_field_group_add_field(group, field);
649
650 gaim_request_fields(gc,
651 _("Find buddies"),
652 _("Find buddies"),
653 _("Please, enter your search criteria below"),
654 fields,
655 _("OK"), G_CALLBACK(ggp_callback_find_buddies),
656 _("Cancel"), NULL,
657 gc);
658 }
659 /* }}} */
660
661 /* ----- CHANGE PASSWORD ------------------------------------------------ */
662
663 /*
664 */
665 /* static void ggp_callback_change_passwd_ok(GaimConnection *gc, GaimRequestFields *fields) {{{ */
666 static void ggp_callback_change_passwd_ok(GaimConnection *gc, GaimRequestFields *fields)
667 {
668 GaimAccount *account;
669 GGPInfo *info = gc->proto_data;
670 struct gg_http *h;
671 gchar *cur, *p1, *p2, *t;
672
673 cur = charset_convert(
674 gaim_request_fields_get_string(fields, "password_cur"),
675 "UTF-8", "CP1250");
676 p1 = charset_convert(
677 gaim_request_fields_get_string(fields, "password1"),
678 "UTF-8", "CP1250");
679 p2 = charset_convert(
680 gaim_request_fields_get_string(fields, "password2"),
681 "UTF-8", "CP1250");
682 t = charset_convert(
683 gaim_request_fields_get_string(fields, "token"),
684 "UTF-8", "CP1250");
685
686 account = gaim_connection_get_account(gc);
687
688 if (cur == NULL || p1 == NULL || p2 == NULL || t == NULL ||
689 *cur == '\0' || *p1 == '\0' || *p2 == '\0' || *t == '\0') {
690 gaim_notify_error(account, NULL, _("Fill in the fields."), NULL);
691 goto exit_err;
692 }
693
694 if (g_utf8_collate(p1, p2) != 0) {
695 gaim_notify_error(account, NULL,
696 _("New passwords do not match."), NULL);
697 goto exit_err;
698 }
699
700 if (g_utf8_collate(cur, gaim_account_get_password(account)) != 0) {
701 gaim_notify_error(account, NULL,
702 _("Your current password is different from the one that you specified."),
703 NULL);
704 goto exit_err;
705 }
706
707 gaim_debug_info("gg", "Changing password\n");
708
709 /* XXX: this e-mail should be a pref... */
710 h = gg_change_passwd4(ggp_get_uin(account),
711 "user@example.net", gaim_account_get_password(account),
712 p1, info->token->id, t, 0);
713
714 if (h == NULL) {
715 gaim_notify_error(account, NULL,
716 _("Unable to change password. Error occurred.\n"),
717 NULL);
718 goto exit_err;
719 }
720
721 gaim_account_set_password(account, p1);
722
723 gg_change_passwd_free(h);
724
725 gaim_notify_info(account, _("Change password for the Gadu-Gadu account"),
726 _("Password was changed successfully!"), NULL);
727
728 exit_err:
729 g_free(cur);
730 g_free(p1);
731 g_free(p2);
732 g_free(t);
733 g_free(info->token->id);
734 g_free(info->token->data);
735 g_free(info->token);
736 }
737 /* }}} */
738
739 /*
740 */
741 /* static void ggp_change_passwd_dialog(GaimConnection *gc) {{{ */
742 static void ggp_change_passwd_dialog(GaimConnection *gc)
743 {
744 GaimRequestFields *fields;
745 GaimRequestFieldGroup *group;
746 GaimRequestField *field;
747
748 GGPInfo *info = gc->proto_data;
749 GGPToken *token = info->token;
750
751 char *msg;
752
753
754 fields = gaim_request_fields_new();
755 group = gaim_request_field_group_new(NULL);
756 gaim_request_fields_add_group(fields, group);
757
758 field = gaim_request_field_string_new("password_cur",
759 _("Current password"), "", FALSE);
760 gaim_request_field_string_set_masked(field, TRUE);
761 gaim_request_field_group_add_field(group, field);
762
763 field = gaim_request_field_string_new("password1",
764 _("Password"), "", FALSE);
765 gaim_request_field_string_set_masked(field, TRUE);
766 gaim_request_field_group_add_field(group, field);
767
768 field = gaim_request_field_string_new("password2",
769 _("Password (retype)"), "", FALSE);
770 gaim_request_field_string_set_masked(field, TRUE);
771 gaim_request_field_group_add_field(group, field);
772
773 field = gaim_request_field_string_new("token",
774 _("Enter current token"), "", FALSE);
775 gaim_request_field_string_set_masked(field, FALSE);
776 gaim_request_field_group_add_field(group, field);
777
778 /* original size: 60x24 */
779 field = gaim_request_field_image_new("token_img",
780 _("Current token"), token->data, token->size);
781 gaim_request_field_group_add_field(group, field);
782
783 msg = g_strdup_printf("%s %d",
784 _("Please, enter your current password and your new password for UIN: "),
785 ggp_get_uin(gaim_connection_get_account(gc)));
786
787 gaim_request_fields(gc,
788 _("Change Gadu-Gadu Password"),
789 _("Change Gadu-Gadu Password"),
790 msg,
791 fields, _("OK"), G_CALLBACK(ggp_callback_change_passwd_ok),
792 _("Cancel"), NULL, gc);
793
794 g_free(msg);
795 }
796 /* }}} */
797
798 /*
799 */
800 /* static void ggp_change_passwd(GaimPluginAction *action) {{{ */
801 static void ggp_change_passwd(GaimPluginAction *action)
802 {
803 GaimConnection *gc = (GaimConnection *)action->context;
804
805 ggp_token_request(gc, ggp_change_passwd_dialog);
806 }
807 /* }}} */
808
809 /* ----- CONFERENCES ---------------------------------------------------- */
810
811 /*
812 */
813 /* static void ggp_callback_add_to_chat_ok(GaimConnection *gc, GaimRequestFields *fields) {{{ */
814 static void ggp_callback_add_to_chat_ok(GaimConnection *gc, GaimRequestFields *fields)
815 {
816 GGPInfo *info = gc->proto_data;
817 GaimRequestField *field;
818 const GList *sel;
819
820 field = gaim_request_fields_get_field(fields, "name");
821 sel = gaim_request_field_list_get_selected(field);
822
823 ggp_confer_participants_add_uin(gc, sel->data, info->tmp_buddy);
824 info->tmp_buddy = 0;
825 }
826 /* }}} */
827
828 /*
829 */
830 /* static void ggp_bmenu_add_to_chat(GaimBlistNode *node, gpointer ignored) {{{ */
831 static void ggp_bmenu_add_to_chat(GaimBlistNode *node, gpointer ignored)
832 {
833 GaimBuddy *buddy;
834 GaimConnection *gc;
835 GGPInfo *info;
836
837 GaimRequestFields *fields;
838 GaimRequestFieldGroup *group;
839 GaimRequestField *field;
840
841 GList *l;
842 gchar *msg;
843
844 buddy = (GaimBuddy *)node;
845 gc = gaim_account_get_connection(gaim_buddy_get_account(buddy));
846 info = gc->proto_data;
847
848 /* TODO: It tmp_buddy != 0 then stop! */
849 info->tmp_buddy = ggp_str_to_uin(gaim_buddy_get_name(buddy));
850
851 fields = gaim_request_fields_new();
852 group = gaim_request_field_group_new(NULL);
853 gaim_request_fields_add_group(fields, group);
854
855 field = gaim_request_field_list_new("name", "Chat name");
856 for (l = info->chats; l != NULL; l = l->next) {
857 GGPChat *chat = l->data;
858 gaim_request_field_list_add(field, g_strdup(chat->name),
859 g_strdup(chat->name));
860 }
861 gaim_request_field_group_add_field(group, field);
862
863 msg = g_strdup_printf(_("Select a chat for buddy: %s"),
864 gaim_buddy_get_alias(buddy));
865 gaim_request_fields(gc,
866 _("Add to chat..."),
867 _("Add to chat..."),
868 msg,
869 fields,
870 _("Add"), G_CALLBACK(ggp_callback_add_to_chat_ok),
871 _("Cancel"), NULL, gc);
872 g_free(msg);
873 }
874 /* }}} */
875
876 /* ----- BLOCK BUDDIES -------------------------------------------------- */
877
878 /*
879 */
880 /* static void ggp_bmenu_block(GaimBlistNode *node, gpointer ignored) {{{ */
881 static void ggp_bmenu_block(GaimBlistNode *node, gpointer ignored)
882 {
883 GaimConnection *gc;
884 GaimBuddy *buddy;
885 GGPInfo *info;
886 uin_t uin;
887
888 buddy = (GaimBuddy *)node;
889 gc = gaim_account_get_connection(gaim_buddy_get_account(buddy));
890 info = gc->proto_data;
891
892 uin = ggp_str_to_uin(gaim_buddy_get_name(buddy));
893
894 if (gaim_blist_node_get_bool(node, "blocked")) {
895 gaim_blist_node_set_bool(node, "blocked", FALSE);
896 gg_remove_notify_ex(info->session, uin, GG_USER_BLOCKED);
897 gg_add_notify_ex(info->session, uin, GG_USER_NORMAL);
898 gaim_debug_info("gg", "send: uin=%d; mode=NORMAL\n", uin);
899 } else {
900 gaim_blist_node_set_bool(node, "blocked", TRUE);
901 gg_remove_notify_ex(info->session, uin, GG_USER_NORMAL);
902 gg_add_notify_ex(info->session, uin, GG_USER_BLOCKED);
903 gaim_debug_info("gg", "send: uin=%d; mode=BLOCKED\n", uin);
904 }
905 }
906 /* }}} */
907
908 /* ---------------------------------------------------------------------- */
909 /* ----- INTERNAL CALLBACKS --------------------------------------------- */
910 /* ---------------------------------------------------------------------- */
911
912 /* just a prototype */
913 static void ggp_set_status(GaimAccount *account, GaimStatus *status);
914
915 /**
916 * Handle change of the status of the buddy.
917 *
918 * @param gc GaimConnection
919 * @param uin UIN of the buddy.
920 * @param status ID of the status.
921 * @param descr Description.
922 */
923 /* static void ggp_generic_status_handler(GaimConnection *gc, uin_t uin, int status, const char *descr) {{{ */
924 static void ggp_generic_status_handler(GaimConnection *gc, uin_t uin,
925 int status, const char *descr)
926 {
927 gchar *from;
928 const char *st;
929 gchar *msg;
930
931 from = g_strdup_printf("%ld", (unsigned long int)uin);
932 switch (status) {
933 case GG_STATUS_NOT_AVAIL:
934 case GG_STATUS_NOT_AVAIL_DESCR:
935 st = "offline";
936 break;
937 case GG_STATUS_AVAIL:
938 case GG_STATUS_AVAIL_DESCR:
939 st = "available";
940 break;
941 case GG_STATUS_BUSY:
942 case GG_STATUS_BUSY_DESCR:
943 st = "away";
944 break;
945 case GG_STATUS_BLOCKED:
946 /* user is blocking us.... */
947 st = "blocked";
948 break;
949 default:
950 st = "available";
951 gaim_debug_info("gg",
952 "GG_EVENT_NOTIFY: Unknown status: %d\n", status);
953 break;
954 }
955
956 gaim_debug_info("gg", "st = %s\n", st);
957 msg = charset_convert(descr, "CP1250", "UTF-8");
958 gaim_prpl_got_user_status(gaim_connection_get_account(gc),
959 from, st, "message", msg, NULL);
960 g_free(from);
961 g_free(msg);
962 }
963 /* }}} */
964
965 /*
966 */
967 /* static void ggp_sr_close_cb(gpointer user_data) {{{ */
968 static void ggp_sr_close_cb(gpointer user_data)
969 {
970 GGPSearchForm *form = user_data;
971 GGPInfo *info = form->user_data;
972
973 ggp_search_remove(info->searches, form->seq);
974 ggp_search_form_destroy(form);
975 }
976 /* }}} */
977
978 /**
979 * Translate a status' ID to a more user-friendly name.
980 *
981 * @param id The ID of the status.
982 *
983 * @return The user-friendly name of the status.
984 */
985 /* static const char *ggp_status_by_id(unsigned int id) {{{ */
986 static const char *ggp_status_by_id(unsigned int id)
987 {
988 const char *st;
989
990 gaim_debug_info("gg", "ggp_status_by_id: %d\n", id);
991 switch (id) {
992 case GG_STATUS_NOT_AVAIL:
993 st = _("Offline");
994 break;
995 case GG_STATUS_AVAIL:
996 st = _("Available");
997 break;
998 case GG_STATUS_BUSY:
999 st = _("Away");
1000 break;
1001 default:
1002 st = _("Unknown");
1003 break;
1004 }
1005
1006 return st;
1007 }
1008 /* }}} */
1009
1010 /*
1011 */
1012 /* static void ggp_pubdir_handle_info(GaimConnection *gc, gg_pubdir50_t req, GGPSearchForm *form) {{{ */
1013 static void ggp_pubdir_handle_info(GaimConnection *gc, gg_pubdir50_t req,
1014 GGPSearchForm *form)
1015 {
1016 GaimNotifyUserInfo *user_info;
1017 GaimBuddy *buddy;
1018 char *val, *who;
1019
1020 user_info = gaim_notify_user_info_new();
1021
1022 val = ggp_search_get_result(req, 0, GG_PUBDIR50_STATUS);
1023 /* XXX: Use of ggp_str_to_uin() is an ugly hack! */
1024 gaim_notify_user_info_add_pair(user_info, _("Status"), ggp_status_by_id(ggp_str_to_uin(val)));
1025 g_free(val);
1026
1027 who = ggp_search_get_result(req, 0, GG_PUBDIR50_UIN);
1028 gaim_notify_user_info_add_pair(user_info, _("UIN"), who);
1029
1030 val = ggp_search_get_result(req, 0, GG_PUBDIR50_FIRSTNAME);
1031 gaim_notify_user_info_add_pair(user_info, _("First Name"), val);
1032 g_free(val);
1033
1034 val = ggp_search_get_result(req, 0, GG_PUBDIR50_NICKNAME);
1035 gaim_notify_user_info_add_pair(user_info, _("Nickname"), val);
1036 g_free(val);
1037
1038 val = ggp_search_get_result(req, 0, GG_PUBDIR50_CITY);
1039 gaim_notify_user_info_add_pair(user_info, _("City"), val);
1040 g_free(val);
1041
1042 val = ggp_search_get_result(req, 0, GG_PUBDIR50_BIRTHYEAR);
1043 if (strncmp(val, "0", 1)) {
1044 gaim_notify_user_info_add_pair(user_info, _("Birth Year"), val);
1045 }
1046 g_free(val);
1047
1048 /*
1049 * Include a status message, if exists and buddy is in the blist.
1050 */
1051 buddy = gaim_find_buddy(gaim_connection_get_account(gc), who);
1052 if (NULL != buddy) {
1053 GaimStatus *status;
1054 const char *msg;
1055 char *text;
1056
1057 status = gaim_presence_get_active_status(gaim_buddy_get_presence(buddy));
1058 msg = gaim_status_get_attr_string(status, "message");
1059
1060 if (msg != NULL) {
1061 text = g_markup_escape_text(msg, -1);
1062 gaim_notify_user_info_add_pair(user_info, _("Message"), text);
1063 g_free(text);
1064 }
1065 }
1066
1067 val = ggp_buddy_get_name(gc, ggp_str_to_uin(who));
1068 gaim_notify_userinfo(gc, val, user_info, ggp_sr_close_cb, form);
1069 g_free(val);
1070 g_free(who);
1071 gaim_notify_user_info_destroy(user_info);
1072 }
1073 /* }}} */
1074
1075 /*
1076 */
1077 /* static void ggp_pubdir_handle_full(GaimConnection *gc, gg_pubdir50_t req, GGPSearchForm *form) {{{ */
1078 static void ggp_pubdir_handle_full(GaimConnection *gc, gg_pubdir50_t req,
1079 GGPSearchForm *form)
1080 {
1081 GaimNotifySearchResults *results;
1082 GaimNotifySearchColumn *column;
1083 int res_count;
1084 int start;
1085 int i;
1086
1087 g_return_if_fail(form != NULL);
1088
1089 res_count = gg_pubdir50_count(req);
1090 res_count = (res_count > PUBDIR_RESULTS_MAX) ? PUBDIR_RESULTS_MAX : res_count;
1091
1092 results = gaim_notify_searchresults_new();
1093
1094 if (results == NULL) {
1095 gaim_debug_error("gg", "ggp_pubdir_reply_handler: "
1096 "Unable to display the search results.\n");
1097 gaim_notify_error(gc, NULL,
1098 _("Unable to display the search results."),
1099 NULL);
1100 ggp_sr_close_cb(form);
1101 return;
1102 }
1103
1104 column = gaim_notify_searchresults_column_new(_("UIN"));
1105 gaim_notify_searchresults_column_add(results, column);
1106
1107 column = gaim_notify_searchresults_column_new(_("First Name"));
1108 gaim_notify_searchresults_column_add(results, column);
1109
1110 column = gaim_notify_searchresults_column_new(_("Nickname"));
1111 gaim_notify_searchresults_column_add(results, column);
1112
1113 column = gaim_notify_searchresults_column_new(_("City"));
1114 gaim_notify_searchresults_column_add(results, column);
1115
1116 column = gaim_notify_searchresults_column_new(_("Birth Year"));
1117 gaim_notify_searchresults_column_add(results, column);
1118
1119 gaim_debug_info("gg", "Going with %d entries\n", res_count);
1120
1121 start = (int)ggp_str_to_uin(gg_pubdir50_get(req, 0, GG_PUBDIR50_START));
1122 gaim_debug_info("gg", "start = %d\n", start);
1123
1124 for (i = 0; i < res_count; i++) {
1125 GList *row = NULL;
1126 char *birth = ggp_search_get_result(req, i, GG_PUBDIR50_BIRTHYEAR);
1127
1128 /* TODO: Status will be displayed as an icon. */
1129 /* row = g_list_append(row, ggp_search_get_result(req, i, GG_PUBDIR50_STATUS)); */
1130 row = g_list_append(row, ggp_search_get_result(req, i,
1131 GG_PUBDIR50_UIN));
1132 row = g_list_append(row, ggp_search_get_result(req, i,
1133 GG_PUBDIR50_FIRSTNAME));
1134 row = g_list_append(row, ggp_search_get_result(req, i,
1135 GG_PUBDIR50_NICKNAME));
1136 row = g_list_append(row, ggp_search_get_result(req, i,
1137 GG_PUBDIR50_CITY));
1138 row = g_list_append(row,
1139 (birth && strncmp(birth, "0", 1)) ? birth : g_strdup("-"));
1140
1141 gaim_notify_searchresults_row_add(results, row);
1142
1143 if (i == res_count - 1) {
1144 g_free(form->last_uin);
1145 form->last_uin = ggp_search_get_result(req, i, GG_PUBDIR50_UIN);
1146 }
1147 }
1148
1149 gaim_notify_searchresults_button_add(results, GAIM_NOTIFY_BUTTON_CONTINUE,
1150 ggp_callback_show_next);
1151 gaim_notify_searchresults_button_add(results, GAIM_NOTIFY_BUTTON_ADD,
1152 ggp_callback_add_buddy);
1153 gaim_notify_searchresults_button_add(results, GAIM_NOTIFY_BUTTON_IM,
1154 ggp_callback_im);
1155
1156 if (form->window == NULL) {
1157 void *h = gaim_notify_searchresults(gc,
1158 _("Gadu-Gadu Public Directory"),
1159 _("Search results"), NULL, results,
1160 (GaimNotifyCloseCallback)ggp_sr_close_cb,
1161 form);
1162
1163 if (h == NULL) {
1164 gaim_debug_error("gg", "ggp_pubdir_reply_handler: "
1165 "Unable to display the search results.\n");
1166 gaim_notify_error(gc, NULL,
1167 _("Unable to display the search results."),
1168 NULL);
1169 return;
1170 }
1171
1172 form->window = h;
1173 } else {
1174 gaim_notify_searchresults_new_rows(gc, results, form->window);
1175 }
1176 }
1177 /* }}} */
1178
1179 /*
1180 */
1181 /* static void ggp_pubdir_reply_handler(GaimConnection *gc, gg_pubdir50_t req) {{{ */
1182 static void ggp_pubdir_reply_handler(GaimConnection *gc, gg_pubdir50_t req)
1183 {
1184 GGPInfo *info = gc->proto_data;
1185 GGPSearchForm *form;
1186 int res_count;
1187 guint32 seq;
1188
1189 seq = gg_pubdir50_seq(req);
1190 form = ggp_search_get(info->searches, seq);
1191
1192 /*
1193 * this can happen when user will request more results
1194 * and close the results window before they arrive.
1195 */
1196 g_return_if_fail(form != NULL);
1197
1198 res_count = gg_pubdir50_count(req);
1199 if (res_count < 1) {
1200 gaim_debug_info("gg", "GG_EVENT_PUBDIR50_SEARCH_REPLY: Nothing found\n");
1201 gaim_notify_error(gc, NULL,
1202 _("No matching users found"),
1203 _("There are no users matching your search criteria."));
1204 ggp_sr_close_cb(form);
1205 return;
1206 }
1207
1208 switch (form->search_type) {
1209 case GGP_SEARCH_TYPE_INFO:
1210 ggp_pubdir_handle_info(gc, req, form);
1211 break;
1212 case GGP_SEARCH_TYPE_FULL:
1213 ggp_pubdir_handle_full(gc, req, form);
1214 break;
1215 default:
1216 gaim_debug_warning("gg", "Unknown search_type!\n");
1217 break;
1218 }
1219 }
1220 /* }}} */
1221
1222 /**
1223 * Dispatch a message received from a buddy.
1224 *
1225 * @param gc GaimConnection.
1226 * @param ev Gadu-Gadu event structure.
1227 */
1228 /* static void ggp_recv_message_handler(GaimConnection *gc, const struct gg_event *ev) {{{ */
1229 static void ggp_recv_message_handler(GaimConnection *gc, const struct gg_event *ev)
1230 {
1231 GGPInfo *info = gc->proto_data;
1232 GaimConversation *conv;
1233 gchar *from;
1234 gchar *msg;
1235 gchar *tmp;
1236
1237 from = g_strdup_printf("%lu", (unsigned long int)ev->event.msg.sender);
1238
1239 tmp = charset_convert((const char *)ev->event.msg.message,
1240 "CP1250", "UTF-8");
1241 gaim_str_strip_char(tmp, '\r');
1242 msg = g_markup_escape_text(tmp, -1);
1243 g_free(tmp);
1244
1245 gaim_debug_info("gg", "msg form (%s): %s (class = %d; rcpt_count = %d)\n",
1246 from, msg, ev->event.msg.msgclass,
1247 ev->event.msg.recipients_count);
1248
1249 if (ev->event.msg.recipients_count == 0) {
1250 serv_got_im(gc, from, msg, 0, ev->event.msg.time);
1251 } else {
1252 const char *chat_name;
1253 int chat_id;
1254 char *buddy_name;
1255
1256 chat_name = ggp_confer_find_by_participants(gc,
1257 ev->event.msg.recipients,
1258 ev->event.msg.recipients_count);
1259
1260 if (chat_name == NULL) {
1261 chat_name = ggp_confer_add_new(gc, NULL);
1262 serv_got_joined_chat(gc, info->chats_count, chat_name);
1263
1264 ggp_confer_participants_add_uin(gc, chat_name,
1265 ev->event.msg.sender);
1266
1267 ggp_confer_participants_add(gc, chat_name,
1268 ev->event.msg.recipients,
1269 ev->event.msg.recipients_count);
1270 }
1271 conv = ggp_confer_find_by_name(gc, chat_name);
1272 chat_id = gaim_conv_chat_get_id(GAIM_CONV_CHAT(conv));
1273
1274 buddy_name = ggp_buddy_get_name(gc, ev->event.msg.sender);
1275 serv_got_chat_in(gc, chat_id, buddy_name,
1276 GAIM_MESSAGE_RECV, msg, ev->event.msg.time);
1277 g_free(buddy_name);
1278 }
1279 g_free(msg);
1280 g_free(from);
1281 }
1282 /* }}} */
1283
1284 /*
1285 */
1286 /* static void ggp_callback_recv(gpointer _gc, gint fd, GaimInputCondition cond) {{{ */
1287 static void ggp_callback_recv(gpointer _gc, gint fd, GaimInputCondition cond)
1288 {
1289 GaimConnection *gc = _gc;
1290 GGPInfo *info = gc->proto_data;
1291 struct gg_event *ev;
1292 int i;
1293
1294 if (!(ev = gg_watch_fd(info->session))) {
1295 gaim_debug_error("gg",
1296 "ggp_callback_recv: gg_watch_fd failed -- CRITICAL!\n");
1297 gaim_connection_error(gc, _("Unable to read socket"));
1298 return;
1299 }
1300
1301 switch (ev->type) {
1302 case GG_EVENT_NONE:
1303 /* Nothing happened. */
1304 break;
1305 case GG_EVENT_MSG:
1306 ggp_recv_message_handler(gc, ev);
1307 break;
1308 case GG_EVENT_ACK:
1309 gaim_debug_info("gg",
1310 "message sent to: %ld, delivery status=%d, seq=%d\n",
1311 ev->event.ack.recipient, ev->event.ack.status,
1312 ev->event.ack.seq);
1313 break;
1314 case GG_EVENT_NOTIFY:
1315 case GG_EVENT_NOTIFY_DESCR:
1316 {
1317 struct gg_notify_reply *n;
1318 char *descr;
1319
1320 gaim_debug_info("gg", "notify_pre: (%d) status: %d\n",
1321 ev->event.notify->uin,
1322 ev->event.notify->status);
1323
1324 n = (ev->type == GG_EVENT_NOTIFY) ? ev->event.notify
1325 : ev->event.notify_descr.notify;
1326
1327 for (; n->uin; n++) {
1328 descr = (ev->type == GG_EVENT_NOTIFY) ? NULL
1329 : ev->event.notify_descr.descr;
1330
1331 gaim_debug_info("gg",
1332 "notify: (%d) status: %d; descr: %s\n",
1333 n->uin, n->status, descr ? descr : "(null)");
1334
1335 ggp_generic_status_handler(gc,
1336 n->uin, n->status, descr);
1337 }
1338 }
1339 break;
1340 case GG_EVENT_NOTIFY60:
1341 gaim_debug_info("gg",
1342 "notify60_pre: (%d) status=%d; version=%d; descr=%s\n",
1343 ev->event.notify60->uin, ev->event.notify60->status,
1344 ev->event.notify60->version,
1345 ev->event.notify60->descr ? ev->event.notify60->descr : "(null)");
1346
1347 for (i = 0; ev->event.notify60[i].uin; i++) {
1348 gaim_debug_info("gg",
1349 "notify60: (%d) status=%d; version=%d; descr=%s\n",
1350 ev->event.notify60[i].uin,
1351 ev->event.notify60[i].status,
1352 ev->event.notify60[i].version,
1353 ev->event.notify60[i].descr ? ev->event.notify60[i].descr : "(null)");
1354
1355 ggp_generic_status_handler(gc, ev->event.notify60[i].uin,
1356 ev->event.notify60[i].status,
1357 ev->event.notify60[i].descr);
1358 }
1359 break;
1360 case GG_EVENT_STATUS:
1361 gaim_debug_info("gg", "status: (%d) status=%d; descr=%s\n",
1362 ev->event.status.uin, ev->event.status.status,
1363 ev->event.status.descr ? ev->event.status.descr : "(null)");
1364
1365 ggp_generic_status_handler(gc, ev->event.status.uin,
1366 ev->event.status.status, ev->event.status.descr);
1367 break;
1368 case GG_EVENT_STATUS60:
1369 gaim_debug_info("gg",
1370 "status60: (%d) status=%d; version=%d; descr=%s\n",
1371 ev->event.status60.uin, ev->event.status60.status,
1372 ev->event.status60.version,
1373 ev->event.status60.descr ? ev->event.status60.descr : "(null)");
1374
1375 ggp_generic_status_handler(gc, ev->event.status60.uin,
1376 ev->event.status60.status, ev->event.status60.descr);
1377 break;
1378 case GG_EVENT_USERLIST:
1379 if (ev->event.userlist.type == GG_USERLIST_GET_REPLY) {
1380 gaim_debug_info("gg", "GG_USERLIST_GET_REPLY\n");
1381 gaim_notify_info(gc, NULL,
1382 _("Buddy list downloaded"),
1383 _("Your buddy list was downloaded from the server."));
1384 if (ev->event.userlist.reply != NULL) {
1385 ggp_buddylist_load(gc, ev->event.userlist.reply);
1386 }
1387 } else {
1388 gaim_debug_info("gg", "GG_USERLIST_PUT_REPLY\n");
1389 gaim_notify_info(gc, NULL,
1390 _("Buddy list uploaded"),
1391 _("Your buddy list was stored on the server."));
1392 }
1393 break;
1394 case GG_EVENT_PUBDIR50_SEARCH_REPLY:
1395 ggp_pubdir_reply_handler(gc, ev->event.pubdir50);
1396 break;
1397 default:
1398 gaim_debug_error("gg",
1399 "unsupported event type=%d\n", ev->type);
1400 break;
1401 }
1402
1403 gg_free_event(ev);
1404 }
1405 /* }}} */
1406
1407 /*
1408 */
1409 /* static void ggp_async_login_handler(gpointer _gc, gint fd, GaimInputCondition cond) {{{ */
1410 static void ggp_async_login_handler(gpointer _gc, gint fd, GaimInputCondition cond)
1411 {
1412 GaimConnection *gc = _gc;
1413 GGPInfo *info;
1414 struct gg_event *ev;
1415
1416 g_return_if_fail(GAIM_CONNECTION_IS_VALID(gc));
1417
1418 info = gc->proto_data;
1419
1420 gaim_debug_info("gg", "login_handler: session: check = %d; state = %d;\n",
1421 info->session->check, info->session->state);
1422
1423 switch (info->session->state) {
1424 case GG_STATE_RESOLVING:
1425 gaim_debug_info("gg", "GG_STATE_RESOLVING\n");
1426 break;
1427 case GG_STATE_CONNECTING_HUB:
1428 gaim_debug_info("gg", "GG_STATE_CONNECTING_HUB\n");
1429 break;
1430 case GG_STATE_READING_DATA:
1431 gaim_debug_info("gg", "GG_STATE_READING_DATA\n");
1432 break;
1433 case GG_STATE_CONNECTING_GG:
1434 gaim_debug_info("gg", "GG_STATE_CONNECTING_GG\n");
1435 break;
1436 case GG_STATE_READING_KEY:
1437 gaim_debug_info("gg", "GG_STATE_READING_KEY\n");
1438 break;
1439 case GG_STATE_READING_REPLY:
1440 gaim_debug_info("gg", "GG_STATE_READING_REPLY\n");
1441 break;
1442 default:
1443 gaim_debug_error("gg", "unknown state = %d\n",
1444 info->session->state);
1445 break;
1446 }
1447
1448 if (!(ev = gg_watch_fd(info->session))) {
1449 gaim_debug_error("gg", "login_handler: gg_watch_fd failed!\n");
1450 gaim_connection_error(gc, _("Unable to read socket"));
1451 return;
1452 }
1453 gaim_debug_info("gg", "login_handler: session->fd = %d\n", info->session->fd);
1454 gaim_debug_info("gg", "login_handler: session: check = %d; state = %d;\n",
1455 info->session->check, info->session->state);
1456
1457 gaim_input_remove(gc->inpa);
1458
1459 /** XXX I think that this shouldn't be done if ev->type is GG_EVENT_CONN_FAILED or GG_EVENT_CONN_SUCCESS -datallah */
1460 gc->inpa = gaim_input_add(info->session->fd,
1461 (info->session->check == 1) ? GAIM_INPUT_WRITE
1462 : GAIM_INPUT_READ,
1463 ggp_async_login_handler, gc);
1464
1465 switch (ev->type) {
1466 case GG_EVENT_NONE:
1467 /* Nothing happened. */
1468 gaim_debug_info("gg", "GG_EVENT_NONE\n");
1469 break;
1470 case GG_EVENT_CONN_SUCCESS:
1471 {
1472 GaimAccount *account;
1473 GaimPresence *presence;
1474 GaimStatus *status;
1475
1476 gaim_debug_info("gg", "GG_EVENT_CONN_SUCCESS\n");
1477 gaim_input_remove(gc->inpa);
1478 gc->inpa = gaim_input_add(info->session->fd,
1479 GAIM_INPUT_READ,
1480 ggp_callback_recv, gc);
1481
1482 /* gg_change_status(info->session, GG_STATUS_AVAIL); */
1483
1484 account = gaim_connection_get_account(gc);
1485 presence = gaim_account_get_presence(account);
1486 status = gaim_presence_get_active_status(presence);
1487
1488 ggp_set_status(account, status);
1489 gaim_connection_set_state(gc, GAIM_CONNECTED);
1490 ggp_buddylist_send(gc);
1491 }
1492 break;
1493 case GG_EVENT_CONN_FAILED:
1494 gaim_input_remove(gc->inpa);
1495 gc->inpa = 0;
1496 gaim_connection_error(gc, _("Connection failed."));
1497 break;
1498 default:
1499 gaim_debug_error("gg", "strange event: %d\n", ev->type);
1500 break;
1501 }
1502
1503 gg_free_event(ev);
1504 }
1505 /* }}} */
1506
1507 /* ---------------------------------------------------------------------- */
1508 /* ----- GaimPluginProtocolInfo ----------------------------------------- */
1509 /* ---------------------------------------------------------------------- */
1510
1511 /* static const char *ggp_list_icon(GaimAccount *account, GaimBuddy *buddy) {{{ */
1512 static const char *ggp_list_icon(GaimAccount *account, GaimBuddy *buddy)
1513 {
1514 return "gadu-gadu";
1515 }
1516 /* }}} */
1517
1518 /* static void ggp_list_emblems(GaimBuddy *b, const char **se, const char **sw, const char **nw, const char **ne) {{{ */
1519 static void ggp_list_emblems(GaimBuddy *b, const char **se, const char **sw,
1520 const char **nw, const char **ne)
1521 {
1522 GaimPresence *presence = gaim_buddy_get_presence(b);
1523
1524 /*
1525 * Note to myself:
1526 * The only valid status types are those defined
1527 * in prpl_info->status_types.
1528 *
1529 * Usable icons: away, blocked, dnd, extended_away,
1530 * freeforchat, ignored, invisible, na, offline.
1531 */
1532
1533 if (!GAIM_BUDDY_IS_ONLINE(b)) {
1534 *se = "offline";
1535 } else if (gaim_presence_is_status_primitive_active(presence, GAIM_STATUS_AWAY)) {
1536 *se = "away";
1537 } else if (gaim_presence_is_status_active(presence, "blocked")) {
1538 *se = "blocked";
1539 }
1540 }
1541 /* }}} */
1542
1543 /* static char *ggp_status_text(GaimBuddy *b) {{{ */
1544 static char *ggp_status_text(GaimBuddy *b)
1545 {
1546 GaimStatus *status;
1547 const char *msg;
1548 char *text;
1549 char *tmp;
1550
1551 status = gaim_presence_get_active_status(gaim_buddy_get_presence(b));
1552
1553 msg = gaim_status_get_attr_string(status, "message");
1554
1555 if (msg != NULL) {
1556 tmp = gaim_markup_strip_html(msg);
1557 text = g_markup_escape_text(tmp, -1);
1558 g_free(tmp);
1559
1560 return text;
1561 } else {
1562 tmp = gaim_utf8_salvage(gaim_status_get_name(status));
1563 text = g_markup_escape_text(tmp, -1);
1564 g_free(tmp);
1565
1566 return text;
1567 }
1568 }
1569 /* }}} */
1570
1571 /* static void ggp_tooltip_text(GaimBuddy *b, GaimNotifyUserInfo *user_info, gboolean full) {{{ */
1572 static void ggp_tooltip_text(GaimBuddy *b, GaimNotifyUserInfo *user_info, gboolean full)
1573 {
1574 GaimStatus *status;
1575 char *text, *tmp;
1576 const char *msg, *name;
1577
1578 g_return_if_fail(b != NULL);
1579
1580 status = gaim_presence_get_active_status(gaim_buddy_get_presence(b));
1581 msg = gaim_status_get_attr_string(status, "message");
1582 name = gaim_status_get_name(status);
1583
1584 if (msg != NULL) {
1585 text = g_markup_escape_text(msg, -1);
1586 if (GAIM_BUDDY_IS_ONLINE(b)) {
1587 tmp = g_strdup_printf("%s: %s", name, text);
1588 gaim_notify_user_info_add_pair(user_info, _("Status"), tmp);
1589 g_free(tmp);
1590 } else {
1591 gaim_notify_user_info_add_pair(user_info, _("Message"), text);
1592 }
1593 g_free(text);
1594 /* We don't want to duplicate 'Status: Offline'. */
1595 } else if (GAIM_BUDDY_IS_ONLINE(b)) {
1596 gaim_notify_user_info_add_pair(user_info, _("Status"), name);
1597 }
1598 }
1599 /* }}} */
1600
1601 /* static GList *ggp_status_types(GaimAccount *account) {{{ */
1602 static GList *ggp_status_types(GaimAccount *account)
1603 {
1604 GaimStatusType *type;
1605 GList *types = NULL;
1606
1607 type = gaim_status_type_new_with_attrs(
1608 GAIM_STATUS_AVAILABLE, NULL, NULL, TRUE, TRUE, FALSE,
1609 "message", _("Message"), gaim_value_new(GAIM_TYPE_STRING),
1610 NULL);
1611 types = g_list_append(types, type);
1612
1613 /*
1614 * Without this selecting Invisible as own status doesn't
1615 * work. It's not used and not needed to show status of buddies.
1616 */
1617 type = gaim_status_type_new_with_attrs(
1618 GAIM_STATUS_INVISIBLE, NULL, NULL, TRUE, TRUE, FALSE,
1619 "message", _("Message"), gaim_value_new(GAIM_TYPE_STRING),
1620 NULL);
1621 types = g_list_append(types, type);
1622
1623 type = gaim_status_type_new_with_attrs(
1624 GAIM_STATUS_AWAY, NULL, NULL, TRUE, TRUE, FALSE,
1625 "message", _("Message"), gaim_value_new(GAIM_TYPE_STRING),
1626 NULL);
1627 types = g_list_append(types, type);
1628
1629 /*
1630 * This status is necessary to display guys who are blocking *us*.
1631 */
1632 type = gaim_status_type_new_with_attrs(
1633 GAIM_STATUS_INVISIBLE, "blocked", _("Blocked"), TRUE, FALSE, FALSE,
1634 "message", _("Message"), gaim_value_new(GAIM_TYPE_STRING), NULL);
1635 types = g_list_append(types, type);
1636
1637 type = gaim_status_type_new_with_attrs(
1638 GAIM_STATUS_OFFLINE, NULL, NULL, TRUE, TRUE, FALSE,
1639 "message", _("Message"), gaim_value_new(GAIM_TYPE_STRING),
1640 NULL);
1641 types = g_list_append(types, type);
1642
1643 return types;
1644 }
1645 /* }}} */
1646
1647 /* static GList *ggp_blist_node_menu(GaimBlistNode *node) {{{ */
1648 static GList *ggp_blist_node_menu(GaimBlistNode *node)
1649 {
1650 GaimMenuAction *act;
1651 GList *m = NULL;
1652
1653 if (!GAIM_BLIST_NODE_IS_BUDDY(node))
1654 return NULL;
1655
1656 act = gaim_menu_action_new(_("Add to chat"),
1657 GAIM_CALLBACK(ggp_bmenu_add_to_chat),
1658 NULL, NULL);
1659 m = g_list_append(m, act);
1660
1661 /* Using a blist node boolean here is also wrong.
1662 * Once the Block and Unblock actions are added to the core,
1663 * this will have to go. -- rlaager */
1664 if (gaim_blist_node_get_bool(node, "blocked")) {
1665 act = gaim_menu_action_new(_("Unblock"),
1666 GAIM_CALLBACK(ggp_bmenu_block),
1667 NULL, NULL);
1668 } else {
1669 act = gaim_menu_action_new(_("Block"),
1670 GAIM_CALLBACK(ggp_bmenu_block),
1671 NULL, NULL);
1672 }
1673 m = g_list_append(m, act);
1674
1675 return m;
1676 }
1677 /* }}} */
1678
1679 /* static GList *ggp_chat_info(GaimConnection *gc) {{{ */
1680 static GList *ggp_chat_info(GaimConnection *gc)
1681 {
1682 GList *m = NULL;
1683 struct proto_chat_entry *pce;
1684
1685 pce = g_new0(struct proto_chat_entry, 1);
1686 pce->label = _("Chat _name:");
1687 pce->identifier = "name";
1688 pce->required = TRUE;
1689 m = g_list_append(m, pce);
1690
1691 return m;
1692 }
1693 /* }}} */
1694
1695 /* static void ggp_login(GaimAccount *account) {{{ */
1696 static void ggp_login(GaimAccount *account)
1697 {
1698 GaimConnection *gc;
1699 struct gg_login_params *glp;
1700 GGPInfo *info;
1701
1702 if (ggp_setup_proxy(account) == -1)
1703 return;
1704
1705 gc = gaim_account_get_connection(account);
1706 glp = g_new0(struct gg_login_params, 1);
1707 info = g_new0(GGPInfo, 1);
1708
1709 /* Probably this should be moved to *_new() function. */
1710 info->session = NULL;
1711 info->chats = NULL;
1712 info->chats_count = 0;
1713 info->token = NULL;
1714 info->searches = ggp_search_new();
1715
1716 gc->proto_data = info;
1717
1718 glp->uin = ggp_get_uin(account);
1719 glp->password = (char *)gaim_account_get_password(account);
1720
1721 glp->async = 1;
1722 glp->status = GG_STATUS_AVAIL;
1723 glp->tls = 0;
1724
1725 info->session = gg_login(glp);
1726 if (info->session == NULL) {
1727 gaim_connection_error(gc, _("Connection failed."));
1728 g_free(glp);
1729 return;
1730 }
1731 gc->inpa = gaim_input_add(info->session->fd, GAIM_INPUT_READ,
1732 ggp_async_login_handler, gc);
1733 }
1734 /* }}} */
1735
1736 /* static void ggp_close(GaimConnection *gc) {{{ */
1737 static void ggp_close(GaimConnection *gc)
1738 {
1739
1740 if (gc == NULL) {
1741 gaim_debug_info("gg", "gc == NULL\n");
1742 return;
1743 }
1744
1745 if (gc->proto_data) {
1746 GaimAccount *account = gaim_connection_get_account(gc);
1747 GaimStatus *status;
1748 GGPInfo *info = gc->proto_data;
1749
1750 status = gaim_account_get_active_status(account);
1751
1752 if (info->session != NULL) {
1753 ggp_set_status(account, status);
1754 gg_logoff(info->session);
1755 gg_free_session(info->session);
1756 }
1757
1758 /* Immediately close any notifications on this handle since that process depends
1759 * upon the contents of info->searches, which we are about to destroy.
1760 */
1761 gaim_notify_close_with_handle(gc);
1762
1763 ggp_search_destroy(info->searches);
1764 g_free(info);
1765 gc->proto_data = NULL;
1766 }
1767
1768 if (gc->inpa > 0)
1769 gaim_input_remove(gc->inpa);
1770
1771 ggp_buddylist_offline(gc);
1772
1773 gaim_debug_info("gg", "Connection closed.\n");
1774 }
1775 /* }}} */
1776
1777 /* static int ggp_send_im(GaimConnection *gc, const char *who, const char *msg, GaimMessageFlags flags) {{{ */
1778 static int ggp_send_im(GaimConnection *gc, const char *who, const char *msg,
1779 GaimMessageFlags flags)
1780 {
1781 GGPInfo *info = gc->proto_data;
1782 char *tmp, *plain;
1783 int ret = 0;
1784
1785 if (strlen(msg) == 0) {
1786 return 0;
1787 }
1788
1789 gaim_debug_info("gg", "ggp_send_im: msg = %s\n", msg);
1790 plain = gaim_unescape_html(msg);
1791 tmp = charset_convert(plain, "UTF-8", "CP1250");
1792
1793 if (NULL == tmp || strlen(tmp) == 0) {
1794 ret = 0;
1795 } else if (strlen(tmp) > GG_MSG_MAXSIZE) {
1796 ret = -E2BIG;
1797 } else if (gg_send_message(info->session, GG_CLASS_CHAT,
1798 ggp_str_to_uin(who), (unsigned char *)tmp) < 0) {
1799 ret = -1;
1800 } else {
1801 ret = 1;
1802 }
1803
1804 g_free(plain);
1805 g_free(tmp);
1806
1807 return ret;
1808 }
1809 /* }}} */
1810
1811 /* static void ggp_get_info(GaimConnection *gc, const char *name) { {{{ */
1812 static void ggp_get_info(GaimConnection *gc, const char *name)
1813 {
1814 GGPInfo *info = gc->proto_data;
1815 GGPSearchForm *form;
1816 guint32 seq;
1817
1818 form = ggp_search_form_new(GGP_SEARCH_TYPE_INFO);
1819
1820 form->user_data = info;
1821 form->uin = g_strdup(name);
1822 form->offset = g_strdup("0");
1823 form->last_uin = g_strdup("0");
1824
1825 seq = ggp_search_start(gc, form);
1826 ggp_search_add(info->searches, seq, form);
1827 }
1828 /* }}} */
1829
1830 /* static void ggp_set_status(GaimAccount *account, GaimStatus *status) {{{ */
1831 static void ggp_set_status(GaimAccount *account, GaimStatus *status)
1832 {
1833 GaimConnection *gc;
1834 GGPInfo *info;
1835 const char *status_id, *msg;
1836 int new_status, new_status_descr;
1837
1838 if (!gaim_status_is_active(status))
1839 return;
1840
1841 gc = gaim_account_get_connection(account);
1842 info = gc->proto_data;
1843
1844 status_id = gaim_status_get_id(status);
1845
1846 gaim_debug_info("gg", "ggp_set_status: Requested status = %s\n",
1847 status_id);
1848
1849 if (strcmp(status_id, "available") == 0) {
1850 new_status = GG_STATUS_AVAIL;
1851 new_status_descr = GG_STATUS_AVAIL_DESCR;
1852 } else if (strcmp(status_id, "away") == 0) {
1853 new_status = GG_STATUS_BUSY;
1854 new_status_descr = GG_STATUS_BUSY_DESCR;
1855 } else if (strcmp(status_id, "invisible") == 0) {
1856 new_status = GG_STATUS_INVISIBLE;
1857 new_status_descr = GG_STATUS_INVISIBLE_DESCR;
1858 } else if (strcmp(status_id, "offline") == 0) {
1859 new_status = GG_STATUS_NOT_AVAIL;
1860 new_status_descr = GG_STATUS_NOT_AVAIL_DESCR;
1861 } else {
1862 new_status = GG_STATUS_AVAIL;
1863 new_status_descr = GG_STATUS_AVAIL_DESCR;
1864 gaim_debug_info("gg",
1865 "ggp_set_status: uknown status requested (status_id=%s)\n",
1866 status_id);
1867 }
1868
1869 msg = gaim_status_get_attr_string(status, "message");
1870
1871 if (msg == NULL) {
1872 gg_change_status(info->session, new_status);
1873 } else {
1874 gchar *tmp, *new_msg;
1875
1876 tmp = charset_convert(msg, "UTF-8", "CP1250");
1877 new_msg = gaim_markup_strip_html(tmp);
1878 g_free(tmp);
1879
1880 gg_change_status_descr(info->session, new_status_descr, new_msg);
1881 g_free(new_msg);
1882 }
1883 }
1884 /* }}} */
1885
1886 /* static void ggp_add_buddy(GaimConnection *gc, GaimBuddy *buddy, GaimGroup *group) {{{ */
1887 static void ggp_add_buddy(GaimConnection *gc, GaimBuddy *buddy, GaimGroup *group)
1888 {
1889 GGPInfo *info = gc->proto_data;
1890
1891 gg_add_notify(info->session, ggp_str_to_uin(buddy->name));
1892 }
1893 /* }}} */
1894
1895 /* static void ggp_remove_buddy(GaimConnection *gc, GaimBuddy *buddy, GaimGroup *group) {{{ */
1896 static void ggp_remove_buddy(GaimConnection *gc, GaimBuddy *buddy,
1897 GaimGroup *group)
1898 {
1899 GGPInfo *info = gc->proto_data;
1900
1901 gg_remove_notify(info->session, ggp_str_to_uin(buddy->name));
1902 }
1903 /* }}} */
1904
1905 /* static void ggp_join_chat(GaimConnection *gc, GHashTable *data) {{{ */
1906 static void ggp_join_chat(GaimConnection *gc, GHashTable *data)
1907 {
1908 GGPInfo *info = gc->proto_data;
1909 GGPChat *chat;
1910 char *chat_name;
1911 GList *l;
1912 GaimConversation *conv;
1913 GaimAccount *account = gaim_connection_get_account(gc);
1914
1915 chat_name = g_hash_table_lookup(data, "name");
1916
1917 if (chat_name == NULL)
1918 return;
1919
1920 gaim_debug_info("gg", "joined %s chat\n", chat_name);
1921
1922 for (l = info->chats; l != NULL; l = l->next) {
1923 chat = l->data;
1924
1925 if (chat != NULL && g_utf8_collate(chat->name, chat_name) == 0) {
1926 gaim_notify_error(gc, _("Chat error"),
1927 _("This chat name is already in use"), NULL);
1928 return;
1929 }
1930 }
1931
1932 ggp_confer_add_new(gc, chat_name);
1933 conv = serv_got_joined_chat(gc, info->chats_count, chat_name);
1934 gaim_conv_chat_add_user(GAIM_CONV_CHAT(conv),
1935 gaim_account_get_username(account), NULL,
1936 GAIM_CBFLAGS_NONE, TRUE);
1937 }
1938 /* }}} */
1939
1940 /* static char *ggp_get_chat_name(GHashTable *data) { {{{ */
1941 static char *ggp_get_chat_name(GHashTable *data) {
1942 return g_strdup(g_hash_table_lookup(data, "name"));
1943 }
1944 /* }}} */
1945
1946 /* static int ggp_chat_send(GaimConnection *gc, int id, const char *message, GaimMessageFlags flags) {{{ */
1947 static int ggp_chat_send(GaimConnection *gc, int id, const char *message, GaimMessageFlags flags)
1948 {
1949 GaimConversation *conv;
1950 GGPInfo *info = gc->proto_data;
1951 GGPChat *chat = NULL;
1952 GList *l;
1953 char *msg, *plain;
1954 uin_t *uins;
1955 int count = 0;
1956
1957 if ((conv = gaim_find_chat(gc, id)) == NULL)
1958 return -EINVAL;
1959
1960 for (l = info->chats; l != NULL; l = l->next) {
1961 chat = l->data;
1962
1963 if (g_utf8_collate(chat->name, conv->name) == 0) {
1964 break;
1965 }
1966
1967 chat = NULL;
1968 }
1969
1970 if (chat == NULL) {
1971 gaim_debug_error("gg",
1972 "ggp_chat_send: Hm... that's strange. No such chat?\n");
1973 return -EINVAL;
1974 }
1975
1976 uins = g_new0(uin_t, g_list_length(chat->participants));
1977
1978 for (l = chat->participants; l != NULL; l = l->next) {
1979 uin_t uin = GPOINTER_TO_INT(l->data);
1980
1981 uins[count++] = uin;
1982 }
1983
1984 plain = gaim_unescape_html(message);
1985 msg = charset_convert(plain, "UTF-8", "CP1250");
1986 g_free(plain);
1987 gg_send_message_confer(info->session, GG_CLASS_CHAT, count, uins,
1988 (unsigned char *)msg);
1989 g_free(msg);
1990 g_free(uins);
1991
1992 serv_got_chat_in(gc, id,
1993 gaim_account_get_username(gaim_connection_get_account(gc)),
1994 0, message, time(NULL));
1995
1996 return 0;
1997 }
1998 /* }}} */
1999
2000 /* static void ggp_keepalive(GaimConnection *gc) {{{ */
2001 static void ggp_keepalive(GaimConnection *gc)
2002 {
2003 GGPInfo *info = gc->proto_data;
2004
2005 /* gaim_debug_info("gg", "Keeping connection alive....\n"); */
2006
2007 if (gg_ping(info->session) < 0) {
2008 gaim_debug_info("gg", "Not connected to the server "
2009 "or gg_session is not correct\n");
2010 gaim_connection_error(gc, _("Not connected to the server."));
2011 }
2012 }
2013 /* }}} */
2014
2015 /* static void ggp_register_user(GaimAccount *account) {{{ */
2016 static void ggp_register_user(GaimAccount *account)
2017 {
2018 GaimConnection *gc = gaim_account_get_connection(account);
2019 GGPInfo *info;
2020
2021 info = gc->proto_data = g_new0(GGPInfo, 1);
2022
2023 ggp_token_request(gc, ggp_register_user_dialog);
2024 }
2025 /* }}} */
2026
2027 /* static GList *ggp_actions(GaimPlugin *plugin, gpointer context) {{{ */
2028 static GList *ggp_actions(GaimPlugin *plugin, gpointer context)
2029 {
2030 GList *m = NULL;
2031 GaimPluginAction *act;
2032
2033 act = gaim_plugin_action_new(_("Find buddies..."),
2034 ggp_find_buddies);
2035 m = g_list_append(m, act);
2036
2037 m = g_list_append(m, NULL);
2038
2039 act = gaim_plugin_action_new(_("Change password..."),
2040 ggp_change_passwd);
2041 m = g_list_append(m, act);
2042
2043 m = g_list_append(m, NULL);
2044
2045 act = gaim_plugin_action_new(_("Upload buddylist to Server"),
2046 ggp_action_buddylist_put);
2047 m = g_list_append(m, act);
2048
2049 act = gaim_plugin_action_new(_("Download buddylist from Server"),
2050 ggp_action_buddylist_get);
2051 m = g_list_append(m, act);
2052
2053 act = gaim_plugin_action_new(_("Delete buddylist from Server"),
2054 ggp_action_buddylist_delete);
2055 m = g_list_append(m, act);
2056
2057 act = gaim_plugin_action_new(_("Save buddylist to file..."),
2058 ggp_action_buddylist_save);
2059 m = g_list_append(m, act);
2060
2061 act = gaim_plugin_action_new(_("Load buddylist from file..."),
2062 ggp_action_buddylist_load);
2063 m = g_list_append(m, act);
2064
2065 return m;
2066 }
2067 /* }}} */
2068
2069 /* static gboolean ggp_offline_message(const GaimBuddy *buddy) {{{ */
2070 static gboolean ggp_offline_message(const GaimBuddy *buddy)
2071 {
2072 return TRUE;
2073 }
2074 /* }}} */
2075
2076 /* prpl_info setup {{{ */
2077 static GaimPluginProtocolInfo prpl_info =
2078 {
2079 OPT_PROTO_REGISTER_NOSCREENNAME,
2080 NULL, /* user_splits */
2081 NULL, /* protocol_options */
2082 NO_BUDDY_ICONS, /* icon_spec */
2083 ggp_list_icon, /* list_icon */
2084 ggp_list_emblems, /* list_emblems */
2085 ggp_status_text, /* status_text */
2086 ggp_tooltip_text, /* tooltip_text */
2087 ggp_status_types, /* status_types */
2088 ggp_blist_node_menu, /* blist_node_menu */
2089 ggp_chat_info, /* chat_info */
2090 NULL, /* chat_info_defaults */
2091 ggp_login, /* login */
2092 ggp_close, /* close */
2093 ggp_send_im, /* send_im */
2094 NULL, /* set_info */
2095 NULL, /* send_typing */
2096 ggp_get_info, /* get_info */
2097 ggp_set_status, /* set_away */
2098 NULL, /* set_idle */
2099 NULL, /* change_passwd */
2100 ggp_add_buddy, /* add_buddy */
2101 NULL, /* add_buddies */
2102 ggp_remove_buddy, /* remove_buddy */
2103 NULL, /* remove_buddies */
2104 NULL, /* add_permit */
2105 NULL, /* add_deny */
2106 NULL, /* rem_permit */
2107 NULL, /* rem_deny */
2108 NULL, /* set_permit_deny */
2109 ggp_join_chat, /* join_chat */
2110 NULL, /* reject_chat */
2111 ggp_get_chat_name, /* get_chat_name */
2112 NULL, /* chat_invite */
2113 NULL, /* chat_leave */
2114 NULL, /* chat_whisper */
2115 ggp_chat_send, /* chat_send */
2116 ggp_keepalive, /* keepalive */
2117 ggp_register_user, /* register_user */
2118 NULL, /* get_cb_info */
2119 NULL, /* get_cb_away */
2120 NULL, /* alias_buddy */
2121 NULL, /* group_buddy */
2122 NULL, /* rename_group */
2123 NULL, /* buddy_free */
2124 NULL, /* convo_closed */
2125 NULL, /* normalize */
2126 NULL, /* set_buddy_icon */
2127 NULL, /* remove_group */
2128 NULL, /* get_cb_real_name */
2129 NULL, /* set_chat_topic */
2130 NULL, /* find_blist_chat */
2131 NULL, /* roomlist_get_list */
2132 NULL, /* roomlist_cancel */
2133 NULL, /* roomlist_expand_category */
2134 NULL, /* can_receive_file */
2135 NULL, /* send_file */
2136 NULL, /* new_xfer */
2137 ggp_offline_message, /* offline_message */
2138 NULL, /* whiteboard_prpl_ops */
2139 NULL, /* send_raw */
2140 NULL, /* roomlist_room_serialize */
2141 };
2142 /* }}} */
2143
2144 /* GaimPluginInfo setup {{{ */
2145 static GaimPluginInfo info = {
2146 GAIM_PLUGIN_MAGIC, /* magic */
2147 GAIM_MAJOR_VERSION, /* major_version */
2148 GAIM_MINOR_VERSION, /* minor_version */
2149 GAIM_PLUGIN_PROTOCOL, /* plugin type */
2150 NULL, /* ui_requirement */
2151 0, /* flags */
2152 NULL, /* dependencies */
2153 GAIM_PRIORITY_DEFAULT, /* priority */
2154
2155 "prpl-gg", /* id */
2156 "Gadu-Gadu", /* name */
2157 VERSION, /* version */
2158
2159 N_("Gadu-Gadu Protocol Plugin"), /* summary */
2160 N_("Polish popular IM"), /* description */
2161 "boler@sourceforge.net", /* author */
2162 GAIM_WEBSITE, /* homepage */
2163
2164 NULL, /* load */
2165 NULL, /* unload */
2166 NULL, /* destroy */
2167
2168 NULL, /* ui_info */
2169 &prpl_info, /* extra_info */
2170 NULL, /* prefs_info */
2171 ggp_actions /* actions */
2172 };
2173 /* }}} */
2174
2175 /* static void gaim_gg_debug_handler(int level, const char * format, va_list args) {{{ */
2176 static void gaim_gg_debug_handler(int level, const char * format, va_list args) {
2177 GaimDebugLevel gaim_level;
2178 char *msg = g_strdup_vprintf(format, args);
2179
2180 /* This is pretty pointless since the GG_DEBUG levels don't correspond to
2181 * the gaim ones */
2182 switch (level) {
2183 case GG_DEBUG_FUNCTION:
2184 gaim_level = GAIM_DEBUG_INFO;
2185 break;
2186 case GG_DEBUG_MISC:
2187 case GG_DEBUG_NET:
2188 case GG_DEBUG_DUMP:
2189 case GG_DEBUG_TRAFFIC:
2190 default:
2191 gaim_level = GAIM_DEBUG_MISC;
2192 break;
2193 }
2194
2195 gaim_debug(gaim_level, "gg", msg);
2196 g_free(msg);
2197 }
2198 /* }}} */
2199
2200 /*
2201 */
2202 /* static void init_plugin(GaimPlugin *plugin) {{{ */
2203 static void init_plugin(GaimPlugin *plugin)
2204 {
2205 GaimAccountOption *option;
2206
2207 option = gaim_account_option_string_new(_("Nickname"),
2208 "nick", _("Gadu-Gadu User"));
2209 prpl_info.protocol_options = g_list_append(prpl_info.protocol_options,
2210 option);
2211
2212 my_protocol = plugin;
2213
2214 gg_debug_handler = gaim_gg_debug_handler;
2215 }
2216 /* }}} */
2217
2218 GAIM_INIT_PLUGIN(gg, init_plugin, info);
2219
2220 /* vim: set ts=8 sts=0 sw=8 noet: */

Mercurial Repository: pidgin3

mercurial