Mercurial > pidgin.yaz
comparison libpurple/protocols/gg/gg.c @ 15374:5fe8042783c1
Rename gtk/ and libgaim/ to pidgin/ and libpurple/
author | Sean Egan <seanegan@gmail.com> |
---|---|
date | Sat, 20 Jan 2007 02:32:10 +0000 |
parents | |
children | 0b6f337a46d5 |
comparison
equal
deleted
inserted
replaced
15373:f79e0f4df793 | 15374:5fe8042783c1 |
---|---|
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: */ |