5228
|
1 /*
|
|
2 * gaim
|
|
3 *
|
|
4 * Copyright (C) 2003, Sean Egan <sean.egan@binghamton.edu>
|
|
5 * Copyright (C) 1998-1999, Mark Spencer <markster@marko.net>
|
|
6 *
|
|
7 * This program is free software; you can redistribute it and/or modify
|
|
8 * it under the terms of the GNU General Public License as published by
|
|
9 * the Free Software Foundation; either version 2 of the License, or
|
|
10 * (at your option) any later version.
|
|
11 *
|
|
12 * This program is distributed in the hope that it will be useful,
|
|
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
15 * GNU General Public License for more details.
|
|
16 *
|
|
17 * You should have received a copy of the GNU General Public License
|
|
18 * along with this program; if not, write to the Free Software
|
|
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
20 *
|
|
21 */
|
|
22
|
|
23 #ifdef HAVE_CONFIG_H
|
|
24 #include <config.h>
|
|
25 #endif
|
|
26 #include <string.h>
|
|
27 #include <stdlib.h>
|
|
28 #include <sys/types.h>
|
|
29 #include <sys/stat.h>
|
|
30 #ifndef _WIN32
|
|
31 #include <unistd.h>
|
|
32 #else
|
|
33 #include <direct.h>
|
|
34 #endif
|
|
35 #include <ctype.h>
|
|
36 #include "gaim.h"
|
|
37 #include "prpl.h"
|
|
38 #include "blist.h"
|
|
39
|
|
40 #ifdef _WIN32
|
|
41 #include "win32dep.h"
|
|
42 #endif
|
|
43
|
|
44 #define PATHSIZE 1024
|
|
45
|
|
46 struct gaim_buddy_list *gaimbuddylist = NULL;
|
|
47 static struct gaim_blist_ui_ops *blist_ui_ops = NULL;
|
|
48
|
|
49 /*****************************************************************************
|
|
50 * Private Utility functions *
|
|
51 *****************************************************************************/
|
|
52 static GaimBlistNode *gaim_blist_get_last_sibling(GaimBlistNode *node)
|
|
53 {
|
|
54 GaimBlistNode *n = node;
|
|
55 if (!n)
|
|
56 return NULL;
|
|
57 while (n->next)
|
|
58 n = n->next;
|
|
59 return n;
|
|
60 }
|
|
61 static GaimBlistNode *gaim_blist_get_last_child(GaimBlistNode *node)
|
|
62 {
|
|
63 if (!node)
|
|
64 return NULL;
|
|
65 return gaim_blist_get_last_sibling(node->child);
|
|
66 }
|
|
67
|
|
68 /*****************************************************************************
|
|
69 * Public API functions *
|
|
70 *****************************************************************************/
|
|
71
|
|
72 struct gaim_buddy_list *gaim_blist_new()
|
|
73 {
|
|
74 struct gaim_buddy_list *gbl = g_new0(struct gaim_buddy_list, 1);
|
|
75
|
|
76 gbl->ui_ops = gaim_get_blist_ui_ops();
|
|
77
|
|
78 if (gbl->ui_ops != NULL && gbl->ui_ops->new_list != NULL)
|
|
79 gbl->ui_ops->new_list(gbl);
|
|
80
|
|
81 return gbl;
|
|
82 }
|
|
83
|
|
84 void
|
|
85 gaim_set_blist(struct gaim_buddy_list *list)
|
|
86 {
|
|
87 gaimbuddylist = list;
|
|
88 }
|
|
89
|
|
90 struct gaim_buddy_list *
|
|
91 gaim_get_blist(void)
|
|
92 {
|
|
93 return gaimbuddylist;
|
|
94 }
|
|
95
|
|
96 void gaim_blist_show ()
|
|
97 {
|
|
98 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
99 if (ops)
|
|
100 ops->show(gaimbuddylist);
|
|
101 }
|
|
102
|
|
103 void gaim_blist_destroy()
|
|
104 {
|
|
105 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
106 if (ops)
|
|
107 ops->destroy(gaimbuddylist);
|
|
108 }
|
|
109
|
|
110 void gaim_blist_set_visible (gboolean show)
|
|
111 {
|
|
112 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
113 if (ops)
|
|
114 ops->set_visible(gaimbuddylist, show);
|
|
115 }
|
|
116
|
|
117 void gaim_blist_update_buddy_status (struct buddy *buddy, int status)
|
|
118 {
|
|
119 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
120 buddy->uc = status;
|
|
121
|
|
122 if(!(status & UC_UNAVAILABLE))
|
|
123 gaim_event_broadcast(event_buddy_back, buddy->account->gc, buddy->name);
|
|
124 else
|
|
125 gaim_event_broadcast(event_buddy_away, buddy->account->gc, buddy->name);
|
|
126
|
|
127 if (ops)
|
|
128 ops->update(gaimbuddylist, (GaimBlistNode*)buddy);
|
|
129 }
|
|
130
|
|
131 static gboolean presence_update_timeout_cb(struct buddy *buddy) {
|
|
132 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
133
|
|
134 if(buddy->present == GAIM_BUDDY_SIGNING_ON) {
|
|
135 buddy->present = GAIM_BUDDY_ONLINE;
|
|
136 gaim_event_broadcast(event_buddy_signon, buddy->account->gc, buddy->name);
|
|
137 } else if(buddy->present == GAIM_BUDDY_SIGNING_OFF) {
|
|
138 buddy->present = GAIM_BUDDY_OFFLINE;
|
|
139 }
|
|
140
|
|
141 buddy->timer = 0;
|
|
142
|
|
143 if (ops)
|
|
144 ops->update(gaimbuddylist, (GaimBlistNode*)buddy);
|
|
145
|
|
146 return FALSE;
|
|
147 }
|
|
148
|
|
149 void gaim_blist_update_buddy_presence(struct buddy *buddy, int presence) {
|
|
150 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
151 gboolean do_timer = FALSE;
|
|
152
|
|
153 if (!GAIM_BUDDY_IS_ONLINE(buddy) && presence) {
|
|
154 buddy->present = GAIM_BUDDY_SIGNING_ON;
|
|
155 gaim_event_broadcast(event_buddy_signon, buddy->account->gc, buddy->name);
|
|
156 do_timer = TRUE;
|
|
157 } else if(GAIM_BUDDY_IS_ONLINE(buddy) && !presence) {
|
|
158 buddy->present = GAIM_BUDDY_SIGNING_OFF;
|
|
159 gaim_event_broadcast(event_buddy_signoff, buddy->account->gc, buddy->name);
|
|
160 do_timer = TRUE;
|
|
161 }
|
|
162
|
|
163 if(do_timer) {
|
|
164 if(buddy->timer > 0)
|
|
165 g_source_remove(buddy->timer);
|
|
166 buddy->timer = g_timeout_add(10000, (GSourceFunc)presence_update_timeout_cb, buddy);
|
|
167 }
|
|
168
|
|
169 if (ops)
|
|
170 ops->update(gaimbuddylist, (GaimBlistNode*)buddy);
|
|
171 }
|
|
172
|
|
173
|
|
174 void gaim_blist_update_buddy_idle (struct buddy *buddy, int idle)
|
|
175 {
|
|
176 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
177 buddy->idle = idle;
|
|
178 if (ops)
|
|
179 ops->update(gaimbuddylist, (GaimBlistNode*)buddy);
|
|
180 }
|
|
181 void gaim_blist_update_buddy_evil (struct buddy *buddy, int warning)
|
|
182 {
|
|
183 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
184 buddy->evil = warning;
|
|
185 if (ops)
|
|
186 ops->update(gaimbuddylist,(GaimBlistNode*)buddy);
|
|
187 }
|
|
188 void gaim_blist_update_buddy_icon(struct buddy *buddy) {
|
|
189 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
190 if(ops)
|
|
191 ops->update(gaimbuddylist, (GaimBlistNode*)buddy);
|
|
192 }
|
|
193 void gaim_blist_rename_buddy (struct buddy *buddy, const char *name)
|
|
194 {
|
|
195 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
196 g_free(buddy->name);
|
|
197 buddy->name = g_strdup(name);
|
|
198 if (ops)
|
|
199 ops->update(gaimbuddylist, (GaimBlistNode*)buddy);
|
|
200 }
|
5234
|
201
|
|
202 void gaim_blist_alias_chat(struct chat *chat, const char *alias)
|
|
203 {
|
|
204 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
205
|
|
206 if(!alias || !strlen(alias))
|
|
207 return;
|
|
208
|
|
209 g_free(chat->alias);
|
|
210 chat->alias = g_strdup(alias);
|
|
211 if(ops)
|
|
212 ops->update(gaimbuddylist, (GaimBlistNode*)chat);
|
|
213 }
|
|
214
|
5228
|
215 void gaim_blist_alias_buddy (struct buddy *buddy, const char *alias)
|
|
216 {
|
|
217 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
218 struct gaim_conversation *conv;
|
|
219
|
|
220 g_free(buddy->alias);
|
|
221
|
|
222 if(alias && strlen(alias))
|
|
223 buddy->alias = g_strdup(alias);
|
|
224 else
|
|
225 buddy->alias = NULL;
|
|
226
|
|
227 if (ops)
|
|
228 ops->update(gaimbuddylist, (GaimBlistNode*)buddy);
|
|
229
|
|
230 conv = gaim_find_conversation_with_account(buddy->name, buddy->account);
|
|
231
|
|
232 if (conv)
|
|
233 gaim_conversation_autoset_title(conv);
|
|
234 }
|
|
235
|
|
236 void gaim_blist_rename_group(struct group *group, const char *name)
|
|
237 {
|
|
238 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
239 g_free(group->name);
|
|
240 group->name = g_strdup(name);
|
|
241 if (ops)
|
|
242 ops->update(gaimbuddylist, (GaimBlistNode*)group);
|
|
243 }
|
5234
|
244
|
|
245 struct chat *gaim_chat_new(struct gaim_account *account, const char *alias, GHashTable *components)
|
|
246 {
|
|
247 struct chat *chat;
|
|
248 struct gaim_blist_ui_ops *ops;
|
|
249
|
|
250 if(!alias || !strlen(alias) || !components)
|
|
251 return NULL;
|
|
252
|
|
253 chat = g_new0(struct chat, 1);
|
|
254 chat->account = account;
|
|
255 chat->alias = g_strdup(alias);
|
|
256 chat->components = components;
|
|
257
|
|
258 ((GaimBlistNode*)chat)->type = GAIM_BLIST_CHAT_NODE;
|
|
259
|
|
260 ops = gaim_get_blist_ui_ops();
|
|
261
|
|
262 if (ops != NULL && ops->new_node != NULL)
|
|
263 ops->new_node((GaimBlistNode *)chat);
|
|
264
|
|
265 return chat;
|
|
266 }
|
|
267
|
5228
|
268 struct buddy *gaim_buddy_new(struct gaim_account *account, const char *screenname, const char *alias)
|
|
269 {
|
|
270 struct buddy *b;
|
|
271 struct gaim_blist_ui_ops *ops;
|
|
272
|
|
273 b = g_new0(struct buddy, 1);
|
|
274 b->account = account;
|
|
275 b->name = g_strdup(screenname);
|
|
276 b->alias = g_strdup(alias);
|
|
277 b->settings = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
|
|
278 ((GaimBlistNode*)b)->type = GAIM_BLIST_BUDDY_NODE;
|
|
279
|
|
280 ops = gaim_get_blist_ui_ops();
|
|
281
|
|
282 if (ops != NULL && ops->new_node != NULL)
|
|
283 ops->new_node((GaimBlistNode *)b);
|
|
284
|
|
285 return b;
|
|
286 }
|
5234
|
287 void gaim_blist_add_chat(struct chat *chat, struct group *group, GaimBlistNode *node)
|
|
288 {
|
|
289 GaimBlistNode *n = node, *cnode = (GaimBlistNode*)chat;
|
|
290 struct group *g = group;
|
|
291 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
292 gboolean save = FALSE;
|
|
293
|
|
294 if (!n) {
|
|
295 if (!g) {
|
|
296 g = gaim_group_new(_("Chats"));
|
|
297 gaim_blist_add_group(g, NULL);
|
|
298 }
|
|
299 n = gaim_blist_get_last_child((GaimBlistNode*)g);
|
|
300 } else {
|
|
301 g = (struct group*)n->parent;
|
|
302 }
|
|
303
|
|
304 /* if we're moving to overtop of ourselves, do nothing */
|
|
305 if(cnode == n)
|
|
306 return;
|
|
307
|
|
308 if (cnode->parent) {
|
|
309 /* This chat was already in the list and is
|
|
310 * being moved.
|
|
311 */
|
|
312 if(cnode->next)
|
|
313 cnode->next->prev = cnode->prev;
|
|
314 if(cnode->prev)
|
|
315 cnode->prev->next = cnode->next;
|
|
316 if(cnode->parent->child == cnode)
|
|
317 cnode->parent->child = cnode->next;
|
|
318
|
|
319 ops->remove(gaimbuddylist, cnode);
|
|
320
|
|
321 save = TRUE;
|
|
322 }
|
|
323
|
|
324 if (n) {
|
|
325 if(n->next)
|
|
326 n->next->prev = cnode;
|
|
327 cnode->next = n->next;
|
|
328 cnode->prev = n;
|
|
329 cnode->parent = n->parent;
|
|
330 n->next = cnode;
|
|
331 } else {
|
|
332 ((GaimBlistNode*)g)->child = cnode;
|
|
333 cnode->next = cnode->prev = NULL;
|
|
334 cnode->parent = (GaimBlistNode*)g;
|
|
335 }
|
|
336
|
|
337 if (ops)
|
|
338 ops->update(gaimbuddylist, (GaimBlistNode*)cnode);
|
|
339 if (save)
|
|
340 gaim_blist_save();
|
|
341 }
|
|
342
|
5228
|
343 void gaim_blist_add_buddy (struct buddy *buddy, struct group *group, GaimBlistNode *node)
|
|
344 {
|
|
345 GaimBlistNode *n = node, *bnode = (GaimBlistNode*)buddy;
|
|
346 struct group *g = group;
|
|
347 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
348 gboolean save = FALSE;
|
|
349
|
|
350 if (!n) {
|
|
351 if (!g) {
|
|
352 g = gaim_group_new(_("Buddies"));
|
|
353 gaim_blist_add_group(g, NULL);
|
|
354 }
|
|
355 n = gaim_blist_get_last_child((GaimBlistNode*)g);
|
|
356 } else {
|
|
357 g = (struct group*)n->parent;
|
|
358 }
|
|
359
|
|
360 /* if we're moving to overtop of ourselves, do nothing */
|
|
361 if(bnode == n)
|
|
362 return;
|
|
363
|
|
364 if (bnode->parent) {
|
|
365 /* This buddy was already in the list and is
|
|
366 * being moved.
|
|
367 */
|
|
368 if(bnode->next)
|
|
369 bnode->next->prev = bnode->prev;
|
|
370 if(bnode->prev)
|
|
371 bnode->prev->next = bnode->next;
|
|
372 if(bnode->parent->child == bnode)
|
|
373 bnode->parent->child = bnode->next;
|
|
374
|
|
375 ops->remove(gaimbuddylist, bnode);
|
|
376
|
|
377 if (bnode->parent != ((GaimBlistNode*)g))
|
|
378 serv_move_buddy(buddy, (struct group*)bnode->parent, g);
|
|
379 save = TRUE;
|
|
380 }
|
|
381
|
|
382 if (n) {
|
|
383 if(n->next)
|
|
384 n->next->prev = (GaimBlistNode*)buddy;
|
|
385 ((GaimBlistNode*)buddy)->next = n->next;
|
|
386 ((GaimBlistNode*)buddy)->prev = n;
|
|
387 ((GaimBlistNode*)buddy)->parent = n->parent;
|
|
388 n->next = (GaimBlistNode*)buddy;
|
|
389 } else {
|
|
390 ((GaimBlistNode*)g)->child = (GaimBlistNode*)buddy;
|
|
391 ((GaimBlistNode*)buddy)->next = NULL;
|
|
392 ((GaimBlistNode*)buddy)->prev = NULL;
|
|
393 ((GaimBlistNode*)buddy)->parent = (GaimBlistNode*)g;
|
|
394 }
|
|
395
|
|
396 if (ops)
|
|
397 ops->update(gaimbuddylist, (GaimBlistNode*)buddy);
|
|
398 if (save)
|
|
399 gaim_blist_save();
|
|
400 }
|
|
401
|
|
402 struct group *gaim_group_new(const char *name)
|
|
403 {
|
|
404 struct group *g = gaim_find_group(name);
|
|
405
|
|
406 if (!g) {
|
|
407 struct gaim_blist_ui_ops *ops;
|
|
408 g= g_new0(struct group, 1);
|
|
409 g->name = g_strdup(name);
|
|
410 g->settings = g_hash_table_new_full(g_str_hash, g_str_equal,
|
|
411 g_free, g_free);
|
|
412 ((GaimBlistNode*)g)->type = GAIM_BLIST_GROUP_NODE;
|
|
413
|
|
414 ops = gaim_get_blist_ui_ops();
|
|
415
|
|
416 if (ops != NULL && ops->new_node != NULL)
|
|
417 ops->new_node((GaimBlistNode *)g);
|
|
418
|
|
419 }
|
|
420 return g;
|
|
421 }
|
|
422
|
|
423 void gaim_blist_add_group (struct group *group, GaimBlistNode *node)
|
|
424 {
|
|
425 struct gaim_blist_ui_ops *ops;
|
|
426 GaimBlistNode *gnode = (GaimBlistNode*)group;
|
|
427 gboolean save = FALSE;
|
|
428
|
|
429 if (!gaimbuddylist)
|
|
430 gaimbuddylist = gaim_blist_new();
|
|
431 ops = gaimbuddylist->ui_ops;
|
|
432
|
|
433 if (!gaimbuddylist->root) {
|
|
434 gaimbuddylist->root = gnode;
|
|
435 return;
|
|
436 }
|
|
437
|
|
438 if (!node)
|
|
439 node = gaim_blist_get_last_sibling(gaimbuddylist->root);
|
|
440
|
|
441 /* if we're moving to overtop of ourselves, do nothing */
|
|
442 if(gnode == node)
|
|
443 return;
|
|
444
|
|
445 if (gaim_find_group(group->name)) {
|
|
446 /* This is just being moved */
|
|
447
|
|
448 ops->remove(gaimbuddylist, (GaimBlistNode*)group);
|
|
449
|
|
450 if(gnode == gaimbuddylist->root)
|
|
451 gaimbuddylist->root = gnode->next;
|
|
452 if(gnode->prev)
|
|
453 gnode->prev->next = gnode->next;
|
|
454 if(gnode->next)
|
|
455 gnode->next->prev = gnode->prev;
|
|
456
|
|
457 save = TRUE;
|
|
458 }
|
|
459
|
|
460 gnode->next = node->next;
|
|
461 gnode->prev = node;
|
|
462 if(node->next)
|
|
463 node->next->prev = gnode;
|
|
464 node->next = gnode;
|
|
465
|
|
466 if (ops) {
|
|
467 ops->update(gaimbuddylist, gnode);
|
|
468 for(node = gnode->child; node; node = node->next)
|
|
469 ops->update(gaimbuddylist, node);
|
|
470 }
|
|
471 if (save)
|
|
472 gaim_blist_save();
|
|
473 }
|
|
474
|
|
475 void gaim_blist_remove_buddy (struct buddy *buddy)
|
|
476 {
|
|
477 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
478
|
|
479 GaimBlistNode *gnode, *node = (GaimBlistNode*)buddy;
|
|
480 struct group *group;
|
|
481
|
|
482 gnode = node->parent;
|
|
483 group = (struct group *)gnode;
|
|
484
|
|
485 if(gnode->child == node)
|
|
486 gnode->child = node->next;
|
|
487 if (node->prev)
|
|
488 node->prev->next = node->next;
|
|
489 if (node->next)
|
|
490 node->next->prev = node->prev;
|
|
491
|
|
492 ops->remove(gaimbuddylist, node);
|
|
493 g_hash_table_destroy(buddy->settings);
|
|
494 g_free(buddy->name);
|
|
495 g_free(buddy->alias);
|
|
496 g_free(buddy);
|
|
497 }
|
|
498
|
5234
|
499 void gaim_blist_remove_chat (struct chat *chat)
|
|
500 {
|
|
501 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
502
|
|
503 GaimBlistNode *gnode, *node = (GaimBlistNode*)chat;
|
|
504 struct group *group;
|
|
505
|
|
506 gnode = node->parent;
|
|
507 group = (struct group *)gnode;
|
|
508
|
|
509 if(gnode->child == node)
|
|
510 gnode->child = node->next;
|
|
511 if (node->prev)
|
|
512 node->prev->next = node->next;
|
|
513 if (node->next)
|
|
514 node->next->prev = node->prev;
|
|
515
|
|
516 ops->remove(gaimbuddylist, node);
|
|
517 g_hash_table_destroy(chat->components);
|
|
518 g_free(chat->alias);
|
|
519 g_free(chat);
|
|
520 }
|
|
521
|
5228
|
522 void gaim_blist_remove_group (struct group *group)
|
|
523 {
|
|
524 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
525 GaimBlistNode *node = (GaimBlistNode*)group;
|
|
526
|
|
527 if(node->child) {
|
|
528 char *buf;
|
|
529 int count = 0;
|
|
530 GaimBlistNode *child = node->child;
|
|
531
|
|
532 while(child) {
|
|
533 count++;
|
|
534 child = child->next;
|
|
535 }
|
|
536
|
|
537 buf = g_strdup_printf(_("%d buddies from group %s were not "
|
|
538 "removed because their accounts were not logged in. These "
|
|
539 "buddies, and the group were not removed.\n"),
|
|
540 count, group->name);
|
|
541 do_error_dialog(_("Group Not Removed"), buf, GAIM_ERROR);
|
|
542 g_free(buf);
|
|
543 return;
|
|
544 }
|
|
545
|
|
546 if(gaimbuddylist->root == node)
|
|
547 gaimbuddylist->root = node->next;
|
|
548 if (node->prev)
|
|
549 node->prev->next = node->next;
|
|
550 if (node->next)
|
|
551 node->next->prev = node->prev;
|
|
552
|
|
553 ops->remove(gaimbuddylist, node);
|
|
554 g_free(group->name);
|
|
555 g_free(group);
|
|
556 }
|
|
557
|
|
558 char *gaim_get_buddy_alias_only(struct buddy *b) {
|
|
559 if(!b)
|
|
560 return NULL;
|
|
561 if(b->alias && b->alias[0])
|
|
562 return b->alias;
|
|
563 else if((misc_options & OPT_MISC_USE_SERVER_ALIAS) && b->server_alias)
|
|
564 return b->server_alias;
|
|
565 return NULL;
|
|
566 }
|
|
567
|
|
568 char * gaim_get_buddy_alias (struct buddy *buddy)
|
|
569 {
|
|
570 char *ret = gaim_get_buddy_alias_only(buddy);
|
|
571 if(!ret)
|
|
572 return buddy ? buddy->name : _("Unknown");
|
|
573 return ret;
|
|
574
|
|
575 }
|
|
576
|
|
577 struct buddy *gaim_find_buddy(struct gaim_account *account, const char *name)
|
|
578 {
|
|
579 GaimBlistNode *group;
|
|
580 GaimBlistNode *buddy;
|
|
581 char *norm_name = g_strdup(normalize(name));
|
|
582
|
|
583 if (!gaimbuddylist)
|
|
584 return NULL;
|
|
585
|
|
586 group = gaimbuddylist->root;
|
|
587 while (group) {
|
|
588 buddy = group->child;
|
|
589 while (buddy) {
|
5234
|
590 if(GAIM_BLIST_NODE_IS_BUDDY(buddy)) {
|
|
591 if (!gaim_utf8_strcasecmp(normalize(((struct buddy*)buddy)->name), norm_name) && account == ((struct buddy*)buddy)->account) {
|
|
592 g_free(norm_name);
|
|
593 return (struct buddy*)buddy;
|
|
594 }
|
5228
|
595 }
|
|
596 buddy = buddy->next;
|
|
597 }
|
|
598 group = group->next;
|
|
599 }
|
|
600 g_free(norm_name);
|
|
601 return NULL;
|
|
602 }
|
|
603
|
|
604 struct group *gaim_find_group(const char *name)
|
|
605 {
|
|
606 GaimBlistNode *node;
|
|
607 if (!gaimbuddylist)
|
|
608 return NULL;
|
|
609 node = gaimbuddylist->root;
|
|
610 while(node) {
|
|
611 if (!strcmp(((struct group*)node)->name, name))
|
|
612 return (struct group*)node;
|
|
613 node = node->next;
|
|
614 }
|
|
615 return NULL;
|
|
616 }
|
|
617 struct group *gaim_find_buddys_group(struct buddy *buddy)
|
|
618 {
|
|
619 if (!buddy)
|
|
620 return NULL;
|
|
621 return (struct group*)(((GaimBlistNode*)buddy)->parent);
|
|
622 }
|
|
623
|
|
624 GSList *gaim_group_get_accounts(struct group *g)
|
|
625 {
|
|
626 GSList *l = NULL;
|
|
627 GaimBlistNode *child = ((GaimBlistNode *)g)->child;
|
|
628
|
|
629 while (child) {
|
|
630 if (!g_slist_find(l, ((struct buddy*)child)->account))
|
|
631 l = g_slist_append(l, ((struct buddy*)child)->account);
|
|
632 child = child->next;
|
|
633 }
|
|
634 return l;
|
|
635 }
|
|
636
|
5234
|
637 void gaim_blist_add_account(struct gaim_account *account)
|
|
638 {
|
|
639 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
|
640 GaimBlistNode *group, *buddy;
|
|
641
|
|
642 if(!gaimbuddylist)
|
|
643 return;
|
|
644
|
|
645 for(group = gaimbuddylist->root; group; group = group->next) {
|
|
646 if(!GAIM_BLIST_NODE_IS_GROUP(group))
|
|
647 continue;
|
|
648 for(buddy = group->child; buddy; buddy = buddy->next) {
|
|
649 if(GAIM_BLIST_NODE_IS_BUDDY(buddy)) {
|
|
650 if (account == ((struct buddy*)buddy)->account) {
|
|
651 if(ops)
|
|
652 ops->update(gaimbuddylist, buddy);
|
|
653 }
|
|
654 } else if(GAIM_BLIST_NODE_IS_CHAT(buddy)) {
|
|
655 if (account == ((struct chat*)buddy)->account) {
|
|
656 if(ops)
|
|
657 ops->update(gaimbuddylist, buddy);
|
|
658 }
|
|
659 }
|
|
660 }
|
|
661 }
|
|
662 }
|
|
663
|
5228
|
664 void gaim_blist_remove_account(struct gaim_account *account)
|
|
665 {
|
|
666 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops;
|
5234
|
667 GaimBlistNode *group, *buddy;
|
|
668
|
5228
|
669 if (!gaimbuddylist)
|
|
670 return;
|
5234
|
671
|
|
672 for(group = gaimbuddylist->root; group; group = group->next) {
|
|
673 if(!GAIM_BLIST_NODE_IS_GROUP(group))
|
|
674 continue;
|
|
675 for(buddy = group->child; buddy; buddy = buddy->next) {
|
|
676 if(GAIM_BLIST_NODE_IS_BUDDY(buddy)) {
|
|
677 if (account == ((struct buddy*)buddy)->account) {
|
|
678 ((struct buddy*)buddy)->present = GAIM_BUDDY_OFFLINE;
|
|
679 if(ops)
|
|
680 ops->remove(gaimbuddylist, buddy);
|
|
681 }
|
|
682 } else if(GAIM_BLIST_NODE_IS_CHAT(buddy)) {
|
|
683 if (account == ((struct chat*)buddy)->account) {
|
|
684 if(ops)
|
|
685 ops->remove(gaimbuddylist, buddy);
|
|
686 }
|
5228
|
687 }
|
|
688 }
|
|
689 }
|
|
690 }
|
|
691
|
|
692 void parse_toc_buddy_list(struct gaim_account *account, char *config)
|
|
693 {
|
|
694 char *c;
|
|
695 char current[256];
|
|
696 GList *bud = NULL;
|
|
697
|
|
698
|
|
699 if (config != NULL) {
|
|
700
|
|
701 /* skip "CONFIG:" (if it exists) */
|
|
702 c = strncmp(config + 6 /* sizeof(struct sflap_hdr) */ , "CONFIG:", strlen("CONFIG:")) ?
|
|
703 strtok(config, "\n") :
|
|
704 strtok(config + 6 /* sizeof(struct sflap_hdr) */ + strlen("CONFIG:"), "\n");
|
|
705 do {
|
|
706 if (c == NULL)
|
|
707 break;
|
|
708 if (*c == 'g') {
|
|
709 char *utf8 = NULL;
|
|
710 utf8 = gaim_try_conv_to_utf8(c + 2);
|
|
711 if (utf8 == NULL) {
|
|
712 g_strlcpy(current, _("Invalid Groupname"), sizeof(current));
|
|
713 } else {
|
|
714 g_strlcpy(current, utf8, sizeof(current));
|
|
715 g_free(utf8);
|
|
716 }
|
|
717 if (!gaim_find_group(current)) {
|
|
718 struct group *g = gaim_group_new(current);
|
|
719 gaim_blist_add_group(g, NULL);
|
|
720 }
|
|
721 } else if (*c == 'b') { /*&& !gaim_find_buddy(user, c + 2)) {*/
|
|
722 char nm[80], sw[388], *a, *utf8 = NULL;
|
|
723
|
|
724 if ((a = strchr(c + 2, ':')) != NULL) {
|
|
725 *a++ = '\0'; /* nul the : */
|
|
726 }
|
|
727
|
|
728 g_strlcpy(nm, c + 2, sizeof(nm));
|
|
729 if (a) {
|
|
730 utf8 = gaim_try_conv_to_utf8(a);
|
|
731 if (utf8 == NULL) {
|
|
732 gaim_debug(GAIM_DEBUG_ERROR, "toc blist",
|
|
733 "Failed to convert alias for "
|
|
734 "'%s' to UTF-8\n", nm);
|
|
735 }
|
|
736 }
|
|
737 if (utf8 == NULL) {
|
|
738 sw[0] = '\0';
|
|
739 } else {
|
|
740 /* This can leave a partial sequence at the end,
|
|
741 * but who cares? */
|
|
742 g_strlcpy(sw, utf8, sizeof(sw));
|
|
743 g_free(utf8);
|
|
744 }
|
|
745
|
|
746 if (!gaim_find_buddy(account, nm)) {
|
|
747 struct buddy *b = gaim_buddy_new(account, nm, sw);
|
|
748 struct group *g = gaim_find_group(current);
|
|
749 gaim_blist_add_buddy(b, g, NULL);
|
|
750 bud = g_list_append(bud, g_strdup(nm));
|
|
751 }
|
|
752 } else if (*c == 'p') {
|
|
753 gaim_privacy_permit_add(account, c + 2);
|
|
754 } else if (*c == 'd') {
|
|
755 gaim_privacy_deny_add(account, c + 2);
|
|
756 } else if (!strncmp("toc", c, 3)) {
|
|
757 sscanf(c + strlen(c) - 1, "%d", &account->permdeny);
|
|
758 gaim_debug(GAIM_DEBUG_MISC, "toc blist",
|
|
759 "permdeny: %d\n", account->permdeny);
|
|
760 if (account->permdeny == 0)
|
|
761 account->permdeny = 1;
|
|
762 } else if (*c == 'm') {
|
|
763 sscanf(c + 2, "%d", &account->permdeny);
|
|
764 gaim_debug(GAIM_DEBUG_MISC, "toc blist",
|
|
765 "permdeny: %d\n", account->permdeny);
|
|
766 if (account->permdeny == 0)
|
|
767 account->permdeny = 1;
|
|
768 }
|
|
769 } while ((c = strtok(NULL, "\n")));
|
|
770
|
|
771 if(account->gc) {
|
|
772 if(bud) {
|
|
773 GList *node = bud;
|
|
774 serv_add_buddies(account->gc, bud);
|
|
775 while(node) {
|
|
776 g_free(node->data);
|
|
777 node = node->next;
|
|
778 }
|
|
779 }
|
|
780 serv_set_permit_deny(account->gc);
|
|
781 }
|
|
782 g_list_free(bud);
|
|
783 }
|
|
784 }
|
|
785
|
|
786 #if 0
|
|
787 /* translate an AIM 3 buddylist (*.lst) to a Gaim buddylist */
|
|
788 static GString *translate_lst(FILE *src_fp)
|
|
789 {
|
|
790 char line[BUF_LEN], *line2;
|
|
791 char *name;
|
|
792 int i;
|
|
793
|
|
794 GString *dest = g_string_new("m 1\n");
|
|
795
|
|
796 while (fgets(line, BUF_LEN, src_fp)) {
|
|
797 line2 = g_strchug(line);
|
|
798 if (strstr(line2, "group") == line2) {
|
|
799 name = strpbrk(line2, " \t\n\r\f") + 1;
|
|
800 dest = g_string_append(dest, "g ");
|
|
801 for (i = 0; i < strcspn(name, "\n\r"); i++)
|
|
802 if (name[i] != '\"')
|
|
803 dest = g_string_append_c(dest, name[i]);
|
|
804 dest = g_string_append_c(dest, '\n');
|
|
805 }
|
|
806 if (strstr(line2, "buddy") == line2) {
|
|
807 name = strpbrk(line2, " \t\n\r\f") + 1;
|
|
808 dest = g_string_append(dest, "b ");
|
|
809 for (i = 0; i < strcspn(name, "\n\r"); i++)
|
|
810 if (name[i] != '\"')
|
|
811 dest = g_string_append_c(dest, name[i]);
|
|
812 dest = g_string_append_c(dest, '\n');
|
|
813 }
|
|
814 }
|
|
815
|
|
816 return dest;
|
|
817 }
|
|
818
|
|
819
|
|
820 /* translate an AIM 4 buddylist (*.blt) to Gaim format */
|
|
821 static GString *translate_blt(FILE *src_fp)
|
|
822 {
|
|
823 int i;
|
|
824 char line[BUF_LEN];
|
|
825 char *buddy;
|
|
826
|
|
827 GString *dest = g_string_new("m 1\n");
|
|
828
|
|
829 while (strstr(fgets(line, BUF_LEN, src_fp), "Buddy") == NULL);
|
|
830 while (strstr(fgets(line, BUF_LEN, src_fp), "list") == NULL);
|
|
831
|
|
832 while (1) {
|
|
833 fgets(line, BUF_LEN, src_fp); g_strchomp(line);
|
|
834 if (strchr(line, '}') != NULL)
|
|
835 break;
|
|
836
|
|
837 if (strchr(line, '{') != NULL) {
|
|
838 /* Syntax starting with "<group> {" */
|
|
839
|
|
840 dest = g_string_append(dest, "g ");
|
|
841 buddy = g_strchug(strtok(line, "{"));
|
|
842 for (i = 0; i < strlen(buddy); i++)
|
|
843 if (buddy[i] != '\"')
|
|
844 dest = g_string_append_c(dest, buddy[i]);
|
|
845 dest = g_string_append_c(dest, '\n');
|
|
846 while (strchr(fgets(line, BUF_LEN, src_fp), '}') == NULL) {
|
|
847 gboolean pounce = FALSE;
|
|
848 char *e;
|
|
849 g_strchomp(line);
|
|
850 buddy = g_strchug(line);
|
|
851 gaim_debug(GAIM_DEBUG_MISC, "AIM 4 blt import",
|
|
852 "buddy: \"%s\"\n", buddy);
|
|
853 dest = g_string_append(dest, "b ");
|
|
854 if (strchr(buddy, '{') != NULL) {
|
|
855 /* buddy pounce, etc */
|
|
856 char *pos = strchr(buddy, '{') - 1;
|
|
857 *pos = 0;
|
|
858 pounce = TRUE;
|
|
859 }
|
|
860 if ((e = strchr(buddy, '\"')) != NULL) {
|
|
861 *e = '\0';
|
|
862 buddy++;
|
|
863 }
|
|
864 dest = g_string_append(dest, buddy);
|
|
865 dest = g_string_append_c(dest, '\n');
|
|
866 if (pounce)
|
|
867 do
|
|
868 fgets(line, BUF_LEN, src_fp);
|
|
869 while (!strchr(line, '}'));
|
|
870 }
|
|
871 } else {
|
|
872
|
|
873 /* Syntax "group buddy buddy ..." */
|
|
874 buddy = g_strchug(strtok(line, " \n"));
|
|
875 dest = g_string_append(dest, "g ");
|
|
876 if (strchr(buddy, '\"') != NULL) {
|
|
877 dest = g_string_append(dest, &buddy[1]);
|
|
878 dest = g_string_append_c(dest, ' ');
|
|
879 buddy = g_strchug(strtok(NULL, " \n"));
|
|
880 while (strchr(buddy, '\"') == NULL) {
|
|
881 dest = g_string_append(dest, buddy);
|
|
882 dest = g_string_append_c(dest, ' ');
|
|
883 buddy = g_strchug(strtok(NULL, " \n"));
|
|
884 }
|
|
885 buddy[strlen(buddy) - 1] = '\0';
|
|
886 dest = g_string_append(dest, buddy);
|
|
887 } else {
|
|
888 dest = g_string_append(dest, buddy);
|
|
889 }
|
|
890 dest = g_string_append_c(dest, '\n');
|
|
891 while ((buddy = g_strchug(strtok(NULL, " \n"))) != NULL) {
|
|
892 dest = g_string_append(dest, "b ");
|
|
893 if (strchr(buddy, '\"') != NULL) {
|
|
894 dest = g_string_append(dest, &buddy[1]);
|
|
895 dest = g_string_append_c(dest, ' ');
|
|
896 buddy = g_strchug(strtok(NULL, " \n"));
|
|
897 while (strchr(buddy, '\"') == NULL) {
|
|
898 dest = g_string_append(dest, buddy);
|
|
899 dest = g_string_append_c(dest, ' ');
|
|
900 buddy = g_strchug(strtok(NULL, " \n"));
|
|
901 }
|
|
902 buddy[strlen(buddy) - 1] = '\0';
|
|
903 dest = g_string_append(dest, buddy);
|
|
904 } else {
|
|
905 dest = g_string_append(dest, buddy);
|
|
906 }
|
|
907 dest = g_string_append_c(dest, '\n');
|
|
908 }
|
|
909 }
|
|
910 }
|
|
911
|
|
912 return dest;
|
|
913 }
|
|
914
|
|
915 static GString *translate_gnomeicu(FILE *src_fp)
|
|
916 {
|
|
917 char line[BUF_LEN];
|
|
918 GString *dest = g_string_new("m 1\ng Buddies\n");
|
|
919
|
|
920 while (strstr(fgets(line, BUF_LEN, src_fp), "NewContacts") == NULL);
|
|
921
|
|
922 while (fgets(line, BUF_LEN, src_fp)) {
|
|
923 char *eq;
|
|
924 g_strchomp(line);
|
|
925 if (line[0] == '\n' || line[0] == '[')
|
|
926 break;
|
|
927 eq = strchr(line, '=');
|
|
928 if (!eq)
|
|
929 break;
|
|
930 *eq = ':';
|
|
931 eq = strchr(eq, ',');
|
|
932 if (eq)
|
|
933 *eq = '\0';
|
|
934 dest = g_string_append(dest, "b ");
|
|
935 dest = g_string_append(dest, line);
|
|
936 dest = g_string_append_c(dest, '\n');
|
|
937 }
|
|
938
|
|
939 return dest;
|
|
940 }
|
|
941 #endif
|
|
942
|
|
943 static gchar *get_screenname_filename(const char *name)
|
|
944 {
|
|
945 gchar **split;
|
|
946 gchar *good;
|
|
947 gchar *ret;
|
|
948
|
|
949 split = g_strsplit(name, G_DIR_SEPARATOR_S, -1);
|
|
950 good = g_strjoinv(NULL, split);
|
|
951 g_strfreev(split);
|
|
952
|
|
953 ret = g_utf8_strup(good, -1);
|
|
954
|
|
955 g_free(good);
|
|
956
|
|
957 return ret;
|
|
958 }
|
|
959
|
|
960 static gboolean gaim_blist_read(const char *filename);
|
|
961
|
|
962
|
|
963 static void do_import(struct gaim_account *account, const char *filename)
|
|
964 {
|
|
965 GString *buf = NULL;
|
|
966 char first[64];
|
|
967 char path[PATHSIZE];
|
|
968 int len;
|
|
969 FILE *f;
|
|
970 struct stat st;
|
|
971
|
|
972 if (filename) {
|
|
973 g_snprintf(path, sizeof(path), "%s", filename);
|
|
974 } else {
|
|
975 char *g_screenname = get_screenname_filename(account->username);
|
|
976 char *file = gaim_user_dir();
|
|
977 int protocol = (account->protocol == GAIM_PROTO_OSCAR) ? (isalpha(account->username[0]) ? GAIM_PROTO_TOC : GAIM_PROTO_ICQ): account->protocol;
|
|
978
|
|
979 if (file != (char *)NULL) {
|
|
980 sprintf(path, "%s" G_DIR_SEPARATOR_S "%s.%d.blist", file, g_screenname, protocol);
|
|
981 g_free(g_screenname);
|
|
982 } else {
|
|
983 g_free(g_screenname);
|
|
984 return;
|
|
985 }
|
|
986 }
|
|
987
|
|
988 if (stat(path, &st)) {
|
|
989 gaim_debug(GAIM_DEBUG_ERROR, "blist import", "Unable to stat %s.\n",
|
|
990 path);
|
|
991 return;
|
|
992 }
|
|
993
|
|
994 if (!(f = fopen(path, "r"))) {
|
|
995 gaim_debug(GAIM_DEBUG_ERROR, "blist import", "Unable to open %s.\n",
|
|
996 path);
|
|
997 return;
|
|
998 }
|
|
999
|
|
1000 fgets(first, 64, f);
|
|
1001
|
|
1002 if ((first[0] == '\n') || (first[0] == '\r' && first[1] == '\n'))
|
|
1003 fgets(first, 64, f);
|
|
1004
|
|
1005 #if 0
|
|
1006 if (!g_strncasecmp(first, "<xml", strlen("<xml"))) {
|
|
1007 /* new gaim XML buddy list */
|
|
1008 gaim_blist_read(path);
|
|
1009
|
|
1010 /* We really don't need to bother doing stuf like translating AIM 3 buddy lists anymore */
|
|
1011
|
|
1012 } else if (!g_strncasecmp(first, "Config {", strlen("Config {"))) {
|
|
1013 /* AIM 4 buddy list */
|
|
1014 gaim_debug(GAIM_DEBUG_MISC, "blist import", "aim 4\n");
|
|
1015 rewind(f);
|
|
1016 buf = translate_blt(f);
|
|
1017 } else if (strstr(first, "group") != NULL) {
|
|
1018 /* AIM 3 buddy list */
|
|
1019 gaim_debug(GAIM_DEBUG_MISC, "blist import", "aim 3\n");
|
|
1020 rewind(f);
|
|
1021 buf = translate_lst(f);
|
|
1022 } else if (!g_strncasecmp(first, "[User]", strlen("[User]"))) {
|
|
1023 /* GnomeICU (hopefully) */
|
|
1024 gaim_debug(GAIM_DEBUG_MISC, "blist import", "gnomeicu\n");
|
|
1025 rewind(f);
|
|
1026 buf = translate_gnomeicu(f);
|
|
1027
|
|
1028 } else
|
|
1029 #endif
|
|
1030 if (first[0] == 'm') {
|
|
1031 /* Gaim buddy list - no translation */
|
|
1032 char buf2[BUF_LONG * 2];
|
|
1033 buf = g_string_new("");
|
|
1034 rewind(f);
|
|
1035 while (1) {
|
|
1036 len = fread(buf2, 1, BUF_LONG * 2 - 1, f);
|
|
1037 if (len <= 0)
|
|
1038 break;
|
|
1039 buf2[len] = '\0';
|
|
1040 buf = g_string_append(buf, buf2);
|
|
1041 if (len != BUF_LONG * 2 - 1)
|
|
1042 break;
|
|
1043 }
|
|
1044 }
|
|
1045
|
|
1046 fclose(f);
|
|
1047
|
|
1048 if (buf) {
|
|
1049 buf = g_string_prepend(buf, "toc_set_config {");
|
|
1050 buf = g_string_append(buf, "}\n");
|
|
1051 parse_toc_buddy_list(account, buf->str);
|
|
1052 g_string_free(buf, TRUE);
|
|
1053 }
|
|
1054 }
|
|
1055
|
|
1056 gboolean gaim_group_on_account(struct group *g, struct gaim_account *account) {
|
|
1057 GaimBlistNode *bnode;
|
|
1058 for(bnode = g->node.child; bnode; bnode = bnode->next) {
|
|
1059 struct buddy *b = (struct buddy *)bnode;
|
|
1060 if(!GAIM_BLIST_NODE_IS_BUDDY(bnode))
|
|
1061 continue;
|
|
1062 if((!account && b->account->gc) || b->account == account)
|
|
1063 return TRUE;
|
|
1064 }
|
|
1065 return FALSE;
|
|
1066 }
|
|
1067
|
|
1068 static gboolean blist_safe_to_write = FALSE;
|
|
1069
|
|
1070 static char *blist_parser_group_name = NULL;
|
|
1071 static char *blist_parser_person_name = NULL;
|
|
1072 static char *blist_parser_account_name = NULL;
|
|
1073 static int blist_parser_account_protocol = 0;
|
5234
|
1074 static char *blist_parser_chat_alias = NULL;
|
|
1075 static char *blist_parser_component_name = NULL;
|
|
1076 static char *blist_parser_component_value = NULL;
|
5228
|
1077 static char *blist_parser_buddy_name = NULL;
|
|
1078 static char *blist_parser_buddy_alias = NULL;
|
|
1079 static char *blist_parser_setting_name = NULL;
|
|
1080 static char *blist_parser_setting_value = NULL;
|
|
1081 static GHashTable *blist_parser_buddy_settings = NULL;
|
|
1082 static GHashTable *blist_parser_group_settings = NULL;
|
5234
|
1083 static GHashTable *blist_parser_chat_components = NULL;
|
5228
|
1084 static int blist_parser_privacy_mode = 0;
|
|
1085 static GList *tag_stack = NULL;
|
|
1086 enum {
|
|
1087 BLIST_TAG_GAIM,
|
|
1088 BLIST_TAG_BLIST,
|
|
1089 BLIST_TAG_GROUP,
|
5234
|
1090 BLIST_TAG_CHAT,
|
|
1091 BLIST_TAG_COMPONENT,
|
5228
|
1092 BLIST_TAG_PERSON,
|
|
1093 BLIST_TAG_BUDDY,
|
|
1094 BLIST_TAG_NAME,
|
|
1095 BLIST_TAG_ALIAS,
|
|
1096 BLIST_TAG_SETTING,
|
|
1097 BLIST_TAG_PRIVACY,
|
|
1098 BLIST_TAG_ACCOUNT,
|
|
1099 BLIST_TAG_PERMIT,
|
|
1100 BLIST_TAG_BLOCK,
|
|
1101 BLIST_TAG_IGNORE
|
|
1102 };
|
|
1103 static gboolean blist_parser_error_occurred = FALSE;
|
|
1104
|
|
1105 static void blist_start_element_handler (GMarkupParseContext *context,
|
|
1106 const gchar *element_name,
|
|
1107 const gchar **attribute_names,
|
|
1108 const gchar **attribute_values,
|
|
1109 gpointer user_data,
|
|
1110 GError **error) {
|
|
1111 int i;
|
|
1112
|
|
1113 if(!strcmp(element_name, "gaim")) {
|
|
1114 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_GAIM));
|
|
1115 } else if(!strcmp(element_name, "blist")) {
|
|
1116 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_BLIST));
|
|
1117 } else if(!strcmp(element_name, "group")) {
|
|
1118 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_GROUP));
|
|
1119 for(i=0; attribute_names[i]; i++) {
|
|
1120 if(!strcmp(attribute_names[i], "name")) {
|
|
1121 g_free(blist_parser_group_name);
|
|
1122 blist_parser_group_name = g_strdup(attribute_values[i]);
|
|
1123 }
|
|
1124 }
|
|
1125 if(blist_parser_group_name) {
|
|
1126 struct group *g = gaim_group_new(blist_parser_group_name);
|
|
1127 gaim_blist_add_group(g,NULL);
|
|
1128 }
|
5234
|
1129 } else if(!strcmp(element_name, "chat")) {
|
|
1130 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_CHAT));
|
|
1131 for(i=0; attribute_names[i]; i++) {
|
|
1132 if(!strcmp(attribute_names[i], "account")) {
|
|
1133 g_free(blist_parser_account_name);
|
|
1134 blist_parser_account_name = g_strdup(attribute_values[i]);
|
|
1135 } else if(!strcmp(attribute_names[i], "protocol")) {
|
|
1136 blist_parser_account_protocol = atoi(attribute_values[i]);
|
|
1137 }
|
|
1138 }
|
5228
|
1139 } else if(!strcmp(element_name, "person")) {
|
|
1140 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_PERSON));
|
|
1141 for(i=0; attribute_names[i]; i++) {
|
|
1142 if(!strcmp(attribute_names[i], "name")) {
|
|
1143 g_free(blist_parser_person_name);
|
|
1144 blist_parser_person_name = g_strdup(attribute_values[i]);
|
|
1145 }
|
|
1146 }
|
|
1147 } else if(!strcmp(element_name, "buddy")) {
|
|
1148 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_BUDDY));
|
|
1149 for(i=0; attribute_names[i]; i++) {
|
|
1150 if(!strcmp(attribute_names[i], "account")) {
|
|
1151 g_free(blist_parser_account_name);
|
|
1152 blist_parser_account_name = g_strdup(attribute_values[i]);
|
|
1153 } else if(!strcmp(attribute_names[i], "protocol")) {
|
|
1154 blist_parser_account_protocol = atoi(attribute_values[i]);
|
|
1155 }
|
|
1156 }
|
|
1157 } else if(!strcmp(element_name, "name")) {
|
|
1158 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_NAME));
|
|
1159 } else if(!strcmp(element_name, "alias")) {
|
|
1160 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_ALIAS));
|
|
1161 } else if(!strcmp(element_name, "setting")) {
|
|
1162 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_SETTING));
|
|
1163 for(i=0; attribute_names[i]; i++) {
|
|
1164 if(!strcmp(attribute_names[i], "name")) {
|
|
1165 g_free(blist_parser_setting_name);
|
|
1166 blist_parser_setting_name = g_strdup(attribute_values[i]);
|
|
1167 }
|
|
1168 }
|
5234
|
1169 } else if(!strcmp(element_name, "component")) {
|
|
1170 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_COMPONENT));
|
|
1171 for(i=0; attribute_names[i]; i++) {
|
|
1172 if(!strcmp(attribute_names[i], "name")) {
|
|
1173 g_free(blist_parser_component_name);
|
|
1174 blist_parser_component_name = g_strdup(attribute_values[i]);
|
|
1175 }
|
|
1176 }
|
|
1177
|
5228
|
1178 } else if(!strcmp(element_name, "privacy")) {
|
|
1179 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_PRIVACY));
|
|
1180 } else if(!strcmp(element_name, "account")) {
|
|
1181 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_ACCOUNT));
|
|
1182 for(i=0; attribute_names[i]; i++) {
|
|
1183 if(!strcmp(attribute_names[i], "protocol"))
|
|
1184 blist_parser_account_protocol = atoi(attribute_values[i]);
|
|
1185 else if(!strcmp(attribute_names[i], "mode"))
|
|
1186 blist_parser_privacy_mode = atoi(attribute_values[i]);
|
|
1187 else if(!strcmp(attribute_names[i], "name")) {
|
|
1188 g_free(blist_parser_account_name);
|
|
1189 blist_parser_account_name = g_strdup(attribute_values[i]);
|
|
1190 }
|
|
1191 }
|
|
1192 } else if(!strcmp(element_name, "permit")) {
|
|
1193 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_PERMIT));
|
|
1194 } else if(!strcmp(element_name, "block")) {
|
|
1195 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_BLOCK));
|
|
1196 } else if(!strcmp(element_name, "ignore")) {
|
|
1197 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_IGNORE));
|
|
1198 }
|
|
1199 }
|
|
1200
|
|
1201 static void blist_end_element_handler(GMarkupParseContext *context,
|
|
1202 const gchar *element_name, gpointer user_data, GError **error) {
|
|
1203 if(!strcmp(element_name, "gaim")) {
|
|
1204 tag_stack = g_list_delete_link(tag_stack, tag_stack);
|
|
1205 } else if(!strcmp(element_name, "blist")) {
|
|
1206 tag_stack = g_list_delete_link(tag_stack, tag_stack);
|
|
1207 } else if(!strcmp(element_name, "group")) {
|
|
1208 if(blist_parser_group_settings) {
|
|
1209 struct group *g = gaim_find_group(blist_parser_group_name);
|
|
1210 g_hash_table_destroy(g->settings);
|
|
1211 g->settings = blist_parser_group_settings;
|
|
1212 }
|
|
1213 tag_stack = g_list_delete_link(tag_stack, tag_stack);
|
|
1214 blist_parser_group_settings = NULL;
|
5234
|
1215 } else if(!strcmp(element_name, "chat")) {
|
|
1216 struct gaim_account *account = gaim_account_find(blist_parser_account_name,
|
|
1217 blist_parser_account_protocol);
|
|
1218 if(account && blist_parser_chat_alias) {
|
|
1219 struct chat *chat = gaim_chat_new(account, blist_parser_chat_alias, blist_parser_chat_components);
|
|
1220 struct group *g = gaim_find_group(blist_parser_group_name);
|
|
1221 gaim_blist_add_chat(chat,g,NULL);
|
|
1222 }
|
|
1223 g_free(blist_parser_chat_alias);
|
|
1224 blist_parser_chat_alias = NULL;
|
|
1225 g_free(blist_parser_account_name);
|
|
1226 blist_parser_account_name = NULL;
|
|
1227 blist_parser_chat_components = NULL;
|
|
1228 tag_stack = g_list_delete_link(tag_stack, tag_stack);
|
5228
|
1229 } else if(!strcmp(element_name, "person")) {
|
|
1230 g_free(blist_parser_person_name);
|
|
1231 blist_parser_person_name = NULL;
|
|
1232 tag_stack = g_list_delete_link(tag_stack, tag_stack);
|
|
1233 } else if(!strcmp(element_name, "buddy")) {
|
|
1234 struct gaim_account *account = gaim_account_find(blist_parser_account_name,
|
|
1235 blist_parser_account_protocol);
|
|
1236 if(account) {
|
|
1237 struct buddy *b = gaim_buddy_new(account, blist_parser_buddy_name, blist_parser_buddy_alias);
|
|
1238 struct group *g = gaim_find_group(blist_parser_group_name);
|
|
1239 gaim_blist_add_buddy(b,g,NULL);
|
|
1240 if(blist_parser_buddy_settings) {
|
|
1241 g_hash_table_destroy(b->settings);
|
|
1242 b->settings = blist_parser_buddy_settings;
|
|
1243 }
|
|
1244 }
|
|
1245 g_free(blist_parser_buddy_name);
|
|
1246 blist_parser_buddy_name = NULL;
|
|
1247 g_free(blist_parser_buddy_alias);
|
|
1248 blist_parser_buddy_alias = NULL;
|
|
1249 g_free(blist_parser_account_name);
|
|
1250 blist_parser_account_name = NULL;
|
|
1251 blist_parser_buddy_settings = NULL;
|
|
1252 tag_stack = g_list_delete_link(tag_stack, tag_stack);
|
|
1253 } else if(!strcmp(element_name, "name")) {
|
|
1254 tag_stack = g_list_delete_link(tag_stack, tag_stack);
|
|
1255 } else if(!strcmp(element_name, "alias")) {
|
|
1256 tag_stack = g_list_delete_link(tag_stack, tag_stack);
|
5234
|
1257 } else if(!strcmp(element_name, "component")) {
|
|
1258 if(!blist_parser_chat_components)
|
|
1259 blist_parser_chat_components = g_hash_table_new_full(g_str_hash,
|
|
1260 g_str_equal, g_free, g_free);
|
|
1261 if(blist_parser_component_name && blist_parser_component_value) {
|
|
1262 g_hash_table_replace(blist_parser_chat_components,
|
|
1263 g_strdup(blist_parser_component_name),
|
|
1264 g_strdup(blist_parser_component_value));
|
|
1265 }
|
|
1266 g_free(blist_parser_component_name);
|
|
1267 g_free(blist_parser_component_value);
|
|
1268 blist_parser_component_name = NULL;
|
|
1269 blist_parser_component_value = NULL;
|
|
1270 tag_stack = g_list_delete_link(tag_stack, tag_stack);
|
5228
|
1271 } else if(!strcmp(element_name, "setting")) {
|
|
1272 if(GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_BUDDY) {
|
|
1273 if(!blist_parser_buddy_settings)
|
|
1274 blist_parser_buddy_settings = g_hash_table_new_full(g_str_hash,
|
|
1275 g_str_equal, g_free, g_free);
|
|
1276 if(blist_parser_setting_name && blist_parser_setting_value) {
|
|
1277 g_hash_table_replace(blist_parser_buddy_settings,
|
|
1278 g_strdup(blist_parser_setting_name),
|
|
1279 g_strdup(blist_parser_setting_value));
|
|
1280 }
|
|
1281 } else if(GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_GROUP) {
|
|
1282 if(!blist_parser_group_settings)
|
|
1283 blist_parser_group_settings = g_hash_table_new_full(g_str_hash,
|
|
1284 g_str_equal, g_free, g_free);
|
|
1285 if(blist_parser_setting_name && blist_parser_setting_value) {
|
|
1286 g_hash_table_replace(blist_parser_group_settings,
|
|
1287 g_strdup(blist_parser_setting_name),
|
|
1288 g_strdup(blist_parser_setting_value));
|
|
1289 }
|
|
1290 }
|
|
1291 g_free(blist_parser_setting_name);
|
|
1292 g_free(blist_parser_setting_value);
|
|
1293 blist_parser_setting_name = NULL;
|
|
1294 blist_parser_setting_value = NULL;
|
|
1295 tag_stack = g_list_delete_link(tag_stack, tag_stack);
|
|
1296 } else if(!strcmp(element_name, "privacy")) {
|
|
1297 tag_stack = g_list_delete_link(tag_stack, tag_stack);
|
|
1298 } else if(!strcmp(element_name, "account")) {
|
|
1299 struct gaim_account *account = gaim_account_find(blist_parser_account_name,
|
|
1300 blist_parser_account_protocol);
|
|
1301 if(account) {
|
|
1302 account->permdeny = blist_parser_privacy_mode;
|
|
1303 }
|
|
1304 g_free(blist_parser_account_name);
|
|
1305 blist_parser_account_name = NULL;
|
|
1306 tag_stack = g_list_delete_link(tag_stack, tag_stack);
|
|
1307 } else if(!strcmp(element_name, "permit")) {
|
|
1308 struct gaim_account *account = gaim_account_find(blist_parser_account_name,
|
|
1309 blist_parser_account_protocol);
|
|
1310 if(account) {
|
|
1311 gaim_privacy_permit_add(account, blist_parser_buddy_name);
|
|
1312 }
|
|
1313 g_free(blist_parser_buddy_name);
|
|
1314 blist_parser_buddy_name = NULL;
|
|
1315 tag_stack = g_list_delete_link(tag_stack, tag_stack);
|
|
1316 } else if(!strcmp(element_name, "block")) {
|
|
1317 struct gaim_account *account = gaim_account_find(blist_parser_account_name,
|
|
1318 blist_parser_account_protocol);
|
|
1319 if(account) {
|
|
1320 gaim_privacy_deny_add(account, blist_parser_buddy_name);
|
|
1321 }
|
|
1322 g_free(blist_parser_buddy_name);
|
|
1323 blist_parser_buddy_name = NULL;
|
|
1324 tag_stack = g_list_delete_link(tag_stack, tag_stack);
|
|
1325 } else if(!strcmp(element_name, "ignore")) {
|
|
1326 /* we'll apparently do something with this later */
|
|
1327 tag_stack = g_list_delete_link(tag_stack, tag_stack);
|
|
1328 }
|
|
1329 }
|
|
1330
|
|
1331 static void blist_text_handler(GMarkupParseContext *context, const gchar *text,
|
|
1332 gsize text_len, gpointer user_data, GError **error) {
|
|
1333 switch(GPOINTER_TO_INT(tag_stack->data)) {
|
|
1334 case BLIST_TAG_NAME:
|
|
1335 blist_parser_buddy_name = g_strndup(text, text_len);
|
|
1336 break;
|
|
1337 case BLIST_TAG_ALIAS:
|
5234
|
1338 if(tag_stack->next &&
|
|
1339 GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_BUDDY)
|
|
1340 blist_parser_buddy_alias = g_strndup(text, text_len);
|
|
1341 else if(tag_stack->next &&
|
|
1342 GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_CHAT)
|
|
1343 blist_parser_chat_alias = g_strndup(text, text_len);
|
5228
|
1344 break;
|
|
1345 case BLIST_TAG_PERMIT:
|
|
1346 case BLIST_TAG_BLOCK:
|
|
1347 case BLIST_TAG_IGNORE:
|
|
1348 blist_parser_buddy_name = g_strndup(text, text_len);
|
|
1349 break;
|
5234
|
1350 case BLIST_TAG_COMPONENT:
|
|
1351 blist_parser_component_value = g_strndup(text, text_len);
|
|
1352 break;
|
5228
|
1353 case BLIST_TAG_SETTING:
|
|
1354 blist_parser_setting_value = g_strndup(text, text_len);
|
|
1355 break;
|
|
1356 default:
|
|
1357 break;
|
|
1358 }
|
|
1359 }
|
|
1360
|
|
1361 static void blist_error_handler(GMarkupParseContext *context, GError *error,
|
|
1362 gpointer user_data) {
|
|
1363 blist_parser_error_occurred = TRUE;
|
|
1364 gaim_debug(GAIM_DEBUG_ERROR, "blist import",
|
|
1365 "Error parsing blist.xml: %s\n", error->message);
|
|
1366 }
|
|
1367
|
|
1368 static GMarkupParser blist_parser = {
|
|
1369 blist_start_element_handler,
|
|
1370 blist_end_element_handler,
|
|
1371 blist_text_handler,
|
|
1372 NULL,
|
|
1373 blist_error_handler
|
|
1374 };
|
|
1375
|
|
1376 static gboolean gaim_blist_read(const char *filename) {
|
|
1377 gchar *contents = NULL;
|
|
1378 gsize length;
|
|
1379 GMarkupParseContext *context;
|
|
1380 GError *error = NULL;
|
|
1381
|
|
1382 gaim_debug(GAIM_DEBUG_INFO, "blist import",
|
|
1383 "Reading %s\n", filename);
|
|
1384 if(!g_file_get_contents(filename, &contents, &length, &error)) {
|
|
1385 gaim_debug(GAIM_DEBUG_ERROR, "blist import",
|
|
1386 "Error reading blist: %s\n", error->message);
|
|
1387 g_error_free(error);
|
|
1388 return FALSE;
|
|
1389 }
|
|
1390
|
|
1391 context = g_markup_parse_context_new(&blist_parser, 0, NULL, NULL);
|
|
1392
|
|
1393 if(!g_markup_parse_context_parse(context, contents, length, NULL)) {
|
|
1394 g_markup_parse_context_free(context);
|
|
1395 g_free(contents);
|
|
1396 return FALSE;
|
|
1397 }
|
|
1398
|
|
1399 if(!g_markup_parse_context_end_parse(context, NULL)) {
|
|
1400 gaim_debug(GAIM_DEBUG_ERROR, "blist import",
|
|
1401 "Error parsing %s\n", filename);
|
|
1402 g_markup_parse_context_free(context);
|
|
1403 g_free(contents);
|
|
1404 return FALSE;
|
|
1405 }
|
|
1406
|
|
1407 g_markup_parse_context_free(context);
|
|
1408 g_free(contents);
|
|
1409
|
|
1410 if(blist_parser_error_occurred)
|
|
1411 return FALSE;
|
|
1412
|
|
1413 gaim_debug(GAIM_DEBUG_INFO, "blist import", "Finished reading %s\n",
|
|
1414 filename);
|
|
1415
|
|
1416 return TRUE;
|
|
1417 }
|
|
1418
|
|
1419 void gaim_blist_load() {
|
|
1420 GSList *accts;
|
|
1421 char *user_dir = gaim_user_dir();
|
|
1422 char *filename;
|
|
1423 char *msg;
|
|
1424
|
|
1425 blist_safe_to_write = TRUE;
|
|
1426
|
|
1427 if(!user_dir)
|
|
1428 return;
|
|
1429
|
|
1430 filename = g_build_filename(user_dir, "blist.xml", NULL);
|
|
1431
|
|
1432 if(g_file_test(filename, G_FILE_TEST_EXISTS)) {
|
|
1433 if(!gaim_blist_read(filename)) {
|
|
1434 msg = g_strdup_printf(_("An error was encountered parsing your "
|
|
1435 "buddy list. It has not been loaded."));
|
|
1436 do_error_dialog(_("Buddy List Error"), msg, GAIM_ERROR);
|
|
1437 g_free(msg);
|
|
1438 }
|
|
1439 } else if(g_slist_length(gaim_accounts)) {
|
|
1440 /* rob wants to inform the user that their buddy lists are
|
|
1441 * being converted */
|
|
1442 msg = g_strdup_printf(_("Gaim is converting your old buddy lists "
|
|
1443 "to a new format, which will now be located at %s"),
|
|
1444 filename);
|
|
1445 do_error_dialog(_("Converting Buddy List"), msg, GAIM_INFO);
|
|
1446 g_free(msg);
|
|
1447
|
|
1448 /* now, let gtk actually display the dialog before we start anything */
|
|
1449 while(gtk_events_pending())
|
|
1450 gtk_main_iteration();
|
|
1451
|
|
1452 /* read in the old lists, then save to the new format */
|
|
1453 for(accts = gaim_accounts; accts; accts = accts->next) {
|
|
1454 do_import(accts->data, NULL);
|
|
1455 }
|
|
1456 gaim_blist_save();
|
|
1457 }
|
|
1458
|
|
1459 g_free(filename);
|
|
1460 }
|
|
1461
|
|
1462 static void blist_print_group_settings(gpointer key, gpointer data,
|
|
1463 gpointer user_data) {
|
|
1464 char *key_val;
|
|
1465 char *data_val;
|
|
1466 FILE *file = user_data;
|
|
1467
|
|
1468 if(!key || !data)
|
|
1469 return;
|
|
1470
|
|
1471 key_val = g_markup_escape_text(key, -1);
|
|
1472 data_val = g_markup_escape_text(data, -1);
|
|
1473
|
|
1474 fprintf(file, "\t\t\t<setting name=\"%s\">%s</setting>\n", key_val,
|
|
1475 data_val);
|
|
1476 g_free(key_val);
|
|
1477 g_free(data_val);
|
|
1478 }
|
|
1479
|
|
1480 static void blist_print_buddy_settings(gpointer key, gpointer data,
|
|
1481 gpointer user_data) {
|
|
1482 char *key_val;
|
|
1483 char *data_val;
|
|
1484 FILE *file = user_data;
|
|
1485
|
|
1486 if(!key || !data)
|
|
1487 return;
|
|
1488
|
|
1489 key_val = g_markup_escape_text(key, -1);
|
|
1490 data_val = g_markup_escape_text(data, -1);
|
|
1491
|
|
1492 fprintf(file, "\t\t\t\t\t<setting name=\"%s\">%s</setting>\n", key_val,
|
|
1493 data_val);
|
|
1494 g_free(key_val);
|
|
1495 g_free(data_val);
|
|
1496 }
|
|
1497
|
5234
|
1498 static void blist_print_chat_components(gpointer key, gpointer data,
|
|
1499 gpointer user_data) {
|
|
1500 char *key_val;
|
|
1501 char *data_val;
|
|
1502 FILE *file = user_data;
|
|
1503
|
|
1504 if(!key || !data)
|
|
1505 return;
|
|
1506
|
|
1507 key_val = g_markup_escape_text(key, -1);
|
|
1508 data_val = g_markup_escape_text(data, -1);
|
|
1509
|
|
1510 fprintf(file, "\t\t\t\t<component name=\"%s\">%s</component>\n", key_val,
|
|
1511 data_val);
|
|
1512 g_free(key_val);
|
|
1513 g_free(data_val);
|
|
1514 }
|
|
1515
|
5228
|
1516 static void gaim_blist_write(FILE *file, struct gaim_account *exp_acct) {
|
|
1517 GSList *accounts, *buds;
|
|
1518 GaimBlistNode *gnode,*bnode;
|
|
1519 struct group *group;
|
|
1520 struct buddy *bud;
|
|
1521 fprintf(file, "<?xml version='1.0' encoding='UTF-8' ?>\n");
|
|
1522 fprintf(file, "<gaim version=\"1\">\n");
|
|
1523 fprintf(file, "\t<blist>\n");
|
|
1524
|
|
1525 for(gnode = gaimbuddylist->root; gnode; gnode = gnode->next) {
|
|
1526 if(!GAIM_BLIST_NODE_IS_GROUP(gnode))
|
|
1527 continue;
|
|
1528 group = (struct group *)gnode;
|
|
1529 if(!exp_acct || gaim_group_on_account(group, exp_acct)) {
|
|
1530 char *group_name = g_markup_escape_text(group->name, -1);
|
|
1531 fprintf(file, "\t\t<group name=\"%s\">\n", group_name);
|
|
1532 g_hash_table_foreach(group->settings, blist_print_group_settings, file);
|
|
1533 for(bnode = gnode->child; bnode; bnode = bnode->next) {
|
5234
|
1534 if(GAIM_BLIST_NODE_IS_BUDDY(bnode)) {
|
|
1535 bud = (struct buddy *)bnode;
|
|
1536 if(!exp_acct || bud->account == exp_acct) {
|
|
1537 char *bud_name = g_markup_escape_text(bud->name, -1);
|
|
1538 char *bud_alias = NULL;
|
|
1539 char *acct_name = g_markup_escape_text(bud->account->username, -1);
|
|
1540 if(bud->alias)
|
|
1541 bud_alias= g_markup_escape_text(bud->alias, -1);
|
|
1542 fprintf(file, "\t\t\t<person name=\"%s\">\n",
|
|
1543 bud_alias ? bud_alias : bud_name);
|
|
1544 fprintf(file, "\t\t\t\t<buddy protocol=\"%d\" "
|
|
1545 "account=\"%s\">\n", bud->account->protocol,
|
|
1546 acct_name);
|
|
1547 fprintf(file, "\t\t\t\t\t<name>%s</name>\n", bud_name);
|
|
1548 if(bud_alias) {
|
|
1549 fprintf(file, "\t\t\t\t\t<alias>%s</alias>\n",
|
|
1550 bud_alias);
|
|
1551 }
|
|
1552 g_hash_table_foreach(bud->settings,
|
|
1553 blist_print_buddy_settings, file);
|
|
1554 fprintf(file, "\t\t\t\t</buddy>\n");
|
|
1555 fprintf(file, "\t\t\t</person>\n");
|
|
1556 g_free(bud_name);
|
|
1557 g_free(bud_alias);
|
|
1558 g_free(acct_name);
|
5228
|
1559 }
|
5234
|
1560 } else if(GAIM_BLIST_NODE_IS_CHAT(bnode)) {
|
|
1561 struct chat *chat = (struct chat *)bnode;
|
|
1562 if(!exp_acct || chat->account == exp_acct) {
|
|
1563 char *chat_alias = g_markup_escape_text(chat->alias, -1);
|
|
1564 char *acct_name = g_markup_escape_text(chat->account->username, -1);
|
|
1565 fprintf(file, "\t\t\t<chat protocol=\"%d\" account=\"%s\">\n", chat->account->protocol, acct_name);
|
|
1566 fprintf(file, "\t\t\t\t<alias>%s</alias>\n", chat_alias);
|
|
1567 g_hash_table_foreach(chat->components,
|
|
1568 blist_print_chat_components, file);
|
|
1569 fprintf(file, "\t\t\t</chat>\n");
|
|
1570 }
|
5228
|
1571 }
|
|
1572 }
|
|
1573 fprintf(file, "\t\t</group>\n");
|
|
1574 g_free(group_name);
|
|
1575 }
|
|
1576 }
|
|
1577
|
|
1578 fprintf(file, "\t</blist>\n");
|
|
1579 fprintf(file, "\t<privacy>\n");
|
|
1580
|
|
1581 for(accounts = gaim_accounts; accounts; accounts = accounts->next) {
|
|
1582 struct gaim_account *account = accounts->data;
|
|
1583 char *acct_name = g_markup_escape_text(account->username, -1);
|
|
1584 if(!exp_acct || account == exp_acct) {
|
|
1585 fprintf(file, "\t\t<account protocol=\"%d\" name=\"%s\" "
|
|
1586 "mode=\"%d\">\n", account->protocol, acct_name, account->permdeny);
|
|
1587 for(buds = account->permit; buds; buds = buds->next) {
|
|
1588 char *bud_name = g_markup_escape_text(buds->data, -1);
|
|
1589 fprintf(file, "\t\t\t<permit>%s</permit>\n", bud_name);
|
|
1590 g_free(bud_name);
|
|
1591 }
|
|
1592 for(buds = account->deny; buds; buds = buds->next) {
|
|
1593 char *bud_name = g_markup_escape_text(buds->data, -1);
|
|
1594 fprintf(file, "\t\t\t<block>%s</block>\n", bud_name);
|
|
1595 g_free(bud_name);
|
|
1596 }
|
|
1597 fprintf(file, "\t\t</account>\n");
|
|
1598 }
|
|
1599 g_free(acct_name);
|
|
1600 }
|
|
1601
|
|
1602 fprintf(file, "\t</privacy>\n");
|
|
1603 fprintf(file, "</gaim>\n");
|
|
1604 }
|
|
1605
|
|
1606 void gaim_blist_save() {
|
|
1607 FILE *file;
|
|
1608 char *user_dir = gaim_user_dir();
|
|
1609 char *filename;
|
|
1610 char *filename_real;
|
|
1611
|
|
1612 if(!user_dir)
|
|
1613 return;
|
|
1614 if(!blist_safe_to_write) {
|
|
1615 gaim_debug(GAIM_DEBUG_WARNING, "blist save",
|
|
1616 "AHH!! Tried to write the blist before we read it!\n");
|
|
1617 return;
|
|
1618 }
|
|
1619
|
|
1620 file = fopen(user_dir, "r");
|
|
1621 if(!file)
|
|
1622 mkdir(user_dir, S_IRUSR | S_IWUSR | S_IXUSR);
|
|
1623 else
|
|
1624 fclose(file);
|
|
1625
|
|
1626 filename = g_build_filename(user_dir, "blist.xml.save", NULL);
|
|
1627
|
|
1628 if((file = fopen(filename, "w"))) {
|
|
1629 gaim_blist_write(file, NULL);
|
|
1630 fclose(file);
|
|
1631 chmod(filename, S_IRUSR | S_IWUSR);
|
|
1632 } else {
|
|
1633 gaim_debug(GAIM_DEBUG_ERROR, "blist save", "Unable to write %s\n",
|
|
1634 filename);
|
|
1635 }
|
|
1636
|
|
1637 filename_real = g_build_filename(user_dir, "blist.xml", NULL);
|
|
1638
|
|
1639 if(rename(filename, filename_real) < 0)
|
|
1640 gaim_debug(GAIM_DEBUG_ERROR, "blist save",
|
|
1641 "Error renaming %s to %s\n", filename, filename_real);
|
|
1642
|
|
1643
|
|
1644 g_free(filename);
|
|
1645 g_free(filename_real);
|
|
1646 }
|
|
1647
|
|
1648 gboolean gaim_privacy_permit_add(struct gaim_account *account, const char *who) {
|
|
1649 GSList *d = account->permit;
|
|
1650 char *n = g_strdup(normalize(who));
|
|
1651 while(d) {
|
|
1652 if(!gaim_utf8_strcasecmp(n, normalize(d->data)))
|
|
1653 break;
|
|
1654 d = d->next;
|
|
1655 }
|
|
1656 g_free(n);
|
|
1657 if(!d) {
|
|
1658 account->permit = g_slist_append(account->permit, g_strdup(who));
|
|
1659 return TRUE;
|
|
1660 }
|
|
1661
|
|
1662 return FALSE;
|
|
1663 }
|
|
1664
|
|
1665 gboolean gaim_privacy_permit_remove(struct gaim_account *account, const char *who) {
|
|
1666 GSList *d = account->permit;
|
|
1667 char *n = g_strdup(normalize(who));
|
|
1668 while(d) {
|
|
1669 if(!gaim_utf8_strcasecmp(n, normalize(d->data)))
|
|
1670 break;
|
|
1671 d = d->next;
|
|
1672 }
|
|
1673 g_free(n);
|
|
1674 if(d) {
|
|
1675 account->permit = g_slist_remove(account->permit, d->data);
|
|
1676 g_free(d->data);
|
|
1677 return TRUE;
|
|
1678 }
|
|
1679 return FALSE;
|
|
1680 }
|
|
1681
|
|
1682 gboolean gaim_privacy_deny_add(struct gaim_account *account, const char *who) {
|
|
1683 GSList *d = account->deny;
|
|
1684 char *n = g_strdup(normalize(who));
|
|
1685 while(d) {
|
|
1686 if(!gaim_utf8_strcasecmp(n, normalize(d->data)))
|
|
1687 break;
|
|
1688 d = d->next;
|
|
1689 }
|
|
1690 g_free(n);
|
|
1691 if(!d) {
|
|
1692 account->deny = g_slist_append(account->deny, g_strdup(who));
|
|
1693 return TRUE;
|
|
1694 }
|
|
1695
|
|
1696 return FALSE;
|
|
1697 }
|
|
1698
|
|
1699 gboolean gaim_privacy_deny_remove(struct gaim_account *account, const char *who) {
|
|
1700 GSList *d = account->deny;
|
|
1701 char *n = g_strdup(normalize(who));
|
|
1702 while(d) {
|
|
1703 if(!gaim_utf8_strcasecmp(n, normalize(d->data)))
|
|
1704 break;
|
|
1705 d = d->next;
|
|
1706 }
|
|
1707 g_free(n);
|
|
1708 if(d) {
|
|
1709 account->deny = g_slist_remove(account->deny, d->data);
|
|
1710 g_free(d->data);
|
|
1711 return TRUE;
|
|
1712 }
|
|
1713 return FALSE;
|
|
1714 }
|
|
1715
|
|
1716 void gaim_group_set_setting(struct group *g, const char *key,
|
|
1717 const char *value) {
|
|
1718 if(!g)
|
|
1719 return;
|
|
1720 g_hash_table_replace(g->settings, g_strdup(key), g_strdup(value));
|
|
1721 }
|
|
1722
|
|
1723 char *gaim_group_get_setting(struct group *g, const char *key) {
|
|
1724 if(!g)
|
|
1725 return NULL;
|
|
1726 return g_strdup(g_hash_table_lookup(g->settings, key));
|
|
1727 }
|
|
1728
|
|
1729 void gaim_buddy_set_setting(struct buddy *b, const char *key,
|
|
1730 const char *value) {
|
|
1731 if(!b)
|
|
1732 return;
|
|
1733 g_hash_table_replace(b->settings, g_strdup(key), g_strdup(value));
|
|
1734 }
|
|
1735
|
|
1736 char *gaim_buddy_get_setting(struct buddy *b, const char *key) {
|
|
1737 if(!b)
|
|
1738 return NULL;
|
|
1739 return g_strdup(g_hash_table_lookup(b->settings, key));
|
|
1740 }
|
|
1741
|
|
1742 void gaim_set_blist_ui_ops(struct gaim_blist_ui_ops *ops)
|
|
1743 {
|
|
1744 blist_ui_ops = ops;
|
|
1745 }
|
|
1746
|
|
1747 struct gaim_blist_ui_ops *
|
|
1748 gaim_get_blist_ui_ops(void)
|
|
1749 {
|
|
1750 return blist_ui_ops;
|
|
1751 }
|
|
1752
|
|
1753 int gaim_blist_get_group_size(struct group *group, gboolean offline) {
|
|
1754 GaimBlistNode *node;
|
|
1755 int count = 0;
|
|
1756
|
|
1757 if(!group)
|
|
1758 return 0;
|
|
1759
|
|
1760 for(node = group->node.child; node; node = node->next) {
|
|
1761 if(GAIM_BLIST_NODE_IS_BUDDY(node)) {
|
|
1762 struct buddy *b = (struct buddy *)node;
|
|
1763 if(b->account->gc || offline)
|
|
1764 count++;
|
5234
|
1765 } else if(GAIM_BLIST_NODE_IS_CHAT(node)) {
|
|
1766 struct chat *chat = (struct chat *)node;
|
|
1767 if(chat->account->gc || offline)
|
|
1768 count++;
|
5228
|
1769 }
|
|
1770 }
|
|
1771
|
|
1772 return count;
|
|
1773 }
|
|
1774
|
|
1775 int gaim_blist_get_group_online_count(struct group *group) {
|
|
1776 GaimBlistNode *node;
|
|
1777 int count = 0;
|
|
1778
|
|
1779 if(!group)
|
|
1780 return 0;
|
|
1781
|
|
1782 for(node = group->node.child; node; node = node->next) {
|
|
1783 if(GAIM_BLIST_NODE_IS_BUDDY(node)) {
|
|
1784 struct buddy *b = (struct buddy *)node;
|
|
1785 if(GAIM_BUDDY_IS_ONLINE(b))
|
|
1786 count++;
|
5234
|
1787 } else if(GAIM_BLIST_NODE_IS_CHAT(node)) {
|
|
1788 count++;
|
5228
|
1789 }
|
|
1790 }
|
|
1791
|
|
1792 return count;
|
|
1793 }
|
|
1794
|
|
1795
|