Mercurial > ~mikael > mcabber > hg

comparison mcabber/mcabber/roster.c @ 1668:41c26b7d2890

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Install mcabber headers * Change mcabber headers naming scheme * Move 'src/' -> 'mcabber/' * Add missing include <mcabber/config.h>'s * Create and install clean config.h version in 'include/' * Move "dirty" config.h version to 'mcabber/' * Add $(top_srcdir) to compiler include path * Update modules HOWTO
author Myhailo Danylenko <isbear@ukrpost.net>
date Mon, 18 Jan 2010 15:36:19 +0200
parents mcabber/src/roster.c@c5ee395fbc8c
children b2e0083891cc
comparison
equal deleted inserted replaced
1667:8af0e0ad20ad 1668:41c26b7d2890
1 /*
2 * roster.c -- Local roster implementation
3 *
4 * Copyright (C) 2005-2009 Mikael Berthe <mikael@lilotux.net>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or (at
9 * your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
19 * USA
20 */
21
22 #include <string.h>
23
24 #include "roster.h"
25 #include "utils.h"
26 #include "hooks.h"
27
28 extern void hlog_save_state(void);
29
30 char *strrole[] = { /* Should match enum in roster.h */
31 "none",
32 "moderator",
33 "participant",
34 "visitor"
35 };
36
37 char *straffil[] = { /* Should match enum in roster.h */
38 "none",
39 "owner",
40 "admin",
41 "member",
42 "outcast"
43 };
44
45 char *strprintstatus[] = { /* Should match enum in roster.h */
46 "default",
47 "none",
48 "in_and_out",
49 "all"
50 };
51
52 char *strautowhois[] = { /* Should match enum in roster.h */
53 "default",
54 "off",
55 "on",
56 };
57
58 /* Resource structure */
59
60 typedef struct {
61 gchar *name;
62 gchar prio;
63 enum imstatus status;
64 gchar *status_msg;
65 time_t status_timestamp;
66 enum imrole role;
67 enum imaffiliation affil;
68 gchar *realjid; /* for chatrooms, if buddy's real jid is known */
69 guint events;
70 char *caps;
71 #ifdef JEP0022
72 struct jep0022 jep22;
73 #endif
74 #ifdef JEP0085
75 struct jep0085 jep85;
76 #endif
77 #ifdef HAVE_GPGME
78 struct pgp_data pgpdata;
79 #endif
80 } res;
81
82 /* This is a private structure type for the roster */
83
84 typedef struct {
85 gchar *name;
86 gchar *jid;
87 guint type;
88 enum subscr subscription;
89 GSList *resource;
90
91 /* For groupchats */
92 gchar *nickname;
93 gchar *topic;
94 guint inside_room;
95 guint print_status;
96 guint auto_whois;
97
98 /* on_server is TRUE if the item is present on the server roster */
99 guint on_server;
100
101 /* To keep track of last status message */
102 gchar *offline_status_message;
103
104 /* Flag used for the UI */
105 guint flags;
106
107 // list: user -> points to his group; group -> points to its users list
108 GSList *list;
109 } roster;
110
111
112 /* ### Variables ### */
113
114 static guchar display_filter;
115 static GSList *groups;
116 static GSList *unread_list;
117 static GHashTable *unread_jids;
118 GList *buddylist;
119 GList *current_buddy;
120 GList *alternate_buddy;
121
122 static roster roster_special;
123
124 static int unread_jid_del(const char *jid);
125
126 #define DFILTER_ALL 63
127 #define DFILTER_ONLINE 62
128
129
130 /* ### Initialization ### */
131
132 void roster_init(void)
133 {
134 roster_special.name = SPECIAL_BUFFER_STATUS_ID;
135 roster_special.type = ROSTER_TYPE_SPECIAL;
136 }
137
138 /* ### Resources functions ### */
139
140 static inline void free_resource_data(res *p_res)
141 {
142 if (!p_res)
143 return;
144 g_free((gchar*)p_res->status_msg);
145 g_free((gchar*)p_res->name);
146 g_free((gchar*)p_res->realjid);
147 #ifdef JEP0022
148 g_free(p_res->jep22.last_msgid_sent);
149 g_free(p_res->jep22.last_msgid_rcvd);
150 #endif
151 #ifdef HAVE_GPGME
152 g_free(p_res->pgpdata.sign_keyid);
153 #endif
154 g_free(p_res->caps);
155 g_free(p_res);
156 }
157
158 static void free_all_resources(GSList **reslist)
159 {
160 GSList *lip;
161
162 for (lip = *reslist; lip ; lip = g_slist_next(lip))
163 free_resource_data((res*)lip->data);
164 // Free all nodes but the first (which is static)
165 g_slist_free(*reslist);
166 *reslist = NULL;
167 }
168
169 // Resources are sorted in ascending order
170 static gint resource_compare_prio(res *a, res *b) {
171 //return (a->prio - b->prio);
172 if (a->prio < b->prio) return -1;
173 else return 1;
174 }
175
176 // get_resource(rost, resname)
177 // Return a pointer to the resource with name resname, in rost's resources list
178 // - if rost has no resources, return NULL
179 // - if resname is defined, return the match or NULL
180 // - if resname is NULL, the last resource is returned, currently
181 // This could change in the future, because we should return the best one
182 // (priority? last used? and fall back to the first resource)
183 //
184 static res *get_resource(roster *rost, const char *resname)
185 {
186 GSList *p;
187 res *r = NULL;
188
189 for (p = rost->resource; p; p = g_slist_next(p)) {
190 r = p->data;
191 if (resname && !strcmp(r->name, resname))
192 return r;
193 }
194
195 // The last resource is one of the resources with the highest priority,
196 // however, we don't know if it is the more-recently-used.
197 if (!resname) return r;
198 return NULL;
199 }
200
201 // get_or_add_resource(rost, resname, priority)
202 // - if there is a "resname" resource in rost's resources, return a pointer
203 // on this resource
204 // - if not, add the resource, set the name, and return a pointer on this
205 // new resource
206 static res *get_or_add_resource(roster *rost, const char *resname, gchar prio)
207 {
208 GSList *p;
209 res *nres;
210
211 if (!resname) return NULL;
212
213 for (p = rost->resource; p; p = g_slist_next(p)) {
214 res *r = p->data;
215 if (!strcmp(r->name, resname)) {
216 if (prio != r->prio) {
217 r->prio = prio;
218 rost->resource = g_slist_sort(rost->resource,
219 (GCompareFunc)&resource_compare_prio);
220 }
221 return r;
222 }
223 }
224
225 // Resource not found
226 nres = g_new0(res, 1);
227 nres->name = g_strdup(resname);
228 nres->prio = prio;
229 rost->resource = g_slist_insert_sorted(rost->resource, nres,
230 (GCompareFunc)&resource_compare_prio);
231 return nres;
232 }
233
234 static void del_resource(roster *rost, const char *resname)
235 {
236 GSList *p;
237 GSList *p_res_elt = NULL;
238 res *p_res;
239
240 if (!resname) return;
241
242 for (p = rost->resource; p; p = g_slist_next(p)) {
243 res *r = p->data;
244 if (!strcmp(r->name, resname))
245 p_res_elt = p;
246 }
247
248 if (!p_res_elt) return; // Resource not found
249
250 p_res = p_res_elt->data;
251
252 // Keep a copy of the status message when a buddy goes offline
253 if (g_slist_length(rost->resource) == 1) {
254 g_free(rost->offline_status_message);
255 rost->offline_status_message = p_res->status_msg;
256 p_res->status_msg = NULL;
257 }
258
259 // Free allocations and delete resource node
260 free_resource_data(p_res);
261 rost->resource = g_slist_delete_link(rost->resource, p_res_elt);
262 return;
263 }
264
265
266 /* ### Roster functions ### */
267
268 static inline void free_roster_user_data(roster *roster_usr)
269 {
270 if (!roster_usr)
271 return;
272 g_free((gchar*)roster_usr->jid);
273 g_free((gchar*)roster_usr->name);
274 g_free((gchar*)roster_usr->nickname);
275 g_free((gchar*)roster_usr->topic);
276 g_free((gchar*)roster_usr->offline_status_message);
277 free_all_resources(&roster_usr->resource);
278 g_free(roster_usr);
279 }
280
281 // Comparison function used to search in the roster (compares jids and types)
282 static gint roster_compare_jid_type(roster *a, roster *b) {
283 if (! (a->type & b->type))
284 return -1; // arbitrary (but should be != 0, of course)
285 return strcasecmp(a->jid, b->jid);
286 }
287
288 // Comparison function used to search in the roster (compares names and types)
289 static gint roster_compare_name_type(roster *a, roster *b) {
290 if (! (a->type & b->type))
291 return -1; // arbitrary (but should be != 0, of course)
292 return strcmp(a->name, b->name);
293 }
294
295 // Comparison function used to sort the roster (by name)
296 static gint roster_compare_name(roster *a, roster *b) {
297 return strcmp(a->name, b->name);
298 }
299
300 // Finds a roster element (user, group, agent...), by jid or name
301 // If roster_type is 0, returns match of any type.
302 // Returns the roster GSList element, or NULL if jid/name not found
303 GSList *roster_find(const char *jidname, enum findwhat type, guint roster_type)
304 {
305 GSList *sl_roster_elt = groups;
306 GSList *resource;
307 roster sample;
308 GCompareFunc comp;
309
310 if (!jidname) return NULL;
311
312 if (!roster_type)
313 roster_type = ROSTER_TYPE_USER | ROSTER_TYPE_ROOM |
314 ROSTER_TYPE_AGENT | ROSTER_TYPE_GROUP;
315
316 sample.type = roster_type;
317 if (type == jidsearch) {
318 sample.jid = (gchar*)jidname;
319 comp = (GCompareFunc)&roster_compare_jid_type;
320 } else if (type == namesearch) {
321 sample.name = (gchar*)jidname;
322 comp = (GCompareFunc)&roster_compare_name_type;
323 } else
324 return NULL; // Should not happen...
325
326 while (sl_roster_elt) {
327 roster *roster_elt = (roster*)sl_roster_elt->data;
328 if (roster_type & ROSTER_TYPE_GROUP) {
329 if ((type == namesearch) && !strcmp(jidname, roster_elt->name))
330 return sl_roster_elt;
331 }
332 resource = g_slist_find_custom(roster_elt->list, &sample, comp);
333 if (resource) return resource;
334 sl_roster_elt = g_slist_next(sl_roster_elt);
335 }
336 return NULL;
337 }
338
339 // Returns pointer to new group, or existing group with that name
340 GSList *roster_add_group(const char *name)
341 {
342 roster *roster_grp;
343 GSList *p_group;
344
345 // #1 Check name doesn't already exist
346 p_group = roster_find(name, namesearch, ROSTER_TYPE_GROUP);
347 if (!p_group) {
348 // #2 Create the group node
349 roster_grp = g_new0(roster, 1);
350 roster_grp->name = g_strdup(name);
351 roster_grp->type = ROSTER_TYPE_GROUP;
352 // #3 Insert (sorted)
353 groups = g_slist_insert_sorted(groups, roster_grp,
354 (GCompareFunc)&roster_compare_name);
355 p_group = roster_find(name, namesearch, ROSTER_TYPE_GROUP);
356 }
357 return p_group;
358 }
359
360 // Returns a pointer to the new user, or existing user with that name
361 // Note: if onserver is -1, the flag won't be changed.
362 GSList *roster_add_user(const char *jid, const char *name, const char *group,
363 guint type, enum subscr esub, gint onserver)
364 {
365 roster *roster_usr;
366 roster *my_group;
367 GSList *slist;
368
369 if ((type != ROSTER_TYPE_USER) &&
370 (type != ROSTER_TYPE_ROOM) &&
371 (type != ROSTER_TYPE_AGENT)) {
372 // XXX Error message?
373 return NULL;
374 }
375
376 // Let's be arbitrary: default group has an empty name ("").
377 if (!group) group = "";
378
379 // #1 Check this user doesn't already exist
380 slist = roster_find(jid, jidsearch, 0);
381 if (slist) {
382 char *oldgroupname;
383 // That's an update
384 roster_usr = slist->data;
385 roster_usr->subscription = esub;
386 if (onserver >= 0)
387 buddy_setonserverflag(slist->data, onserver);
388 if (name)
389 buddy_setname(slist->data, (char*)name);
390 // Let's check if the group name has changed
391 oldgroupname = ((roster*)((GSList*)roster_usr->list)->data)->name;
392 if (group && strcmp(oldgroupname, group)) {
393 buddy_setgroup(slist->data, (char*)group);
394 // Note: buddy_setgroup() updates the user lists so we cannot
395 // use slist anymore.
396 return roster_find(jid, jidsearch, 0);
397 }
398 return slist;
399 }
400 // #2 add group if necessary
401 slist = roster_add_group(group);
402 if (!slist) return NULL;
403 my_group = (roster*)slist->data;
404 // #3 Create user node
405 roster_usr = g_new0(roster, 1);
406 roster_usr->jid = g_strdup(jid);
407 if (name) {
408 roster_usr->name = g_strdup(name);
409 } else {
410 gchar *p, *str = g_strdup(jid);
411 p = strchr(str, JID_RESOURCE_SEPARATOR);
412 if (p) *p = '\0';
413 roster_usr->name = g_strdup(str);
414 g_free(str);
415 }
416 if (unread_jid_del(jid)) {
417 roster_usr->flags |= ROSTER_FLAG_MSG;
418 // Append the roster_usr to unread_list
419 unread_list = g_slist_append(unread_list, roster_usr);
420 }
421 roster_usr->type = type;
422 roster_usr->subscription = esub;
423 roster_usr->list = slist; // (my_group SList element)
424 if (onserver == 1)
425 roster_usr->on_server = TRUE;
426 // #4 Insert node (sorted)
427 my_group->list = g_slist_insert_sorted(my_group->list, roster_usr,
428 (GCompareFunc)&roster_compare_name);
429 return roster_find(jid, jidsearch, type);
430 }
431
432 // Removes user (jid) from roster, frees allocated memory
433 void roster_del_user(const char *jid)
434 {
435 GSList *sl_user, *sl_group;
436 GSList **sl_group_listptr;
437 roster *roster_usr;
438 GSList *node;
439
440 sl_user = roster_find(jid, jidsearch,
441 ROSTER_TYPE_USER|ROSTER_TYPE_AGENT|ROSTER_TYPE_ROOM);
442 if (sl_user == NULL)
443 return;
444 roster_usr = (roster*)sl_user->data;
445
446 // Remove (if present) from unread messages list
447 node = g_slist_find(unread_list, roster_usr);
448 if (node) unread_list = g_slist_delete_link(unread_list, node);
449 // If there is a pending unread message, keep track of it
450 if (roster_usr->flags & ROSTER_FLAG_MSG)
451 unread_jid_add(roster_usr->jid);
452
453 sl_group = roster_usr->list;
454
455 // Let's free roster_usr memory (jid, name, status message...)
456 free_roster_user_data(roster_usr);
457
458 // That's a little complex, we need to dereference twice
459 sl_group_listptr = &((roster*)(sl_group->data))->list;
460 *sl_group_listptr = g_slist_delete_link(*sl_group_listptr, sl_user);
461
462 // We need to rebuild the list
463 if (current_buddy)
464 buddylist_build();
465 // TODO What we could do, too, is to check if the deleted node is
466 // current_buddy, in which case we could move current_buddy to the
467 // previous (or next) node.
468 }
469
470 // Free all roster data and call buddylist_build() to free the buddylist.
471 void roster_free(void)
472 {
473 GSList *sl_grp = groups;
474
475 // Free unread_list
476 if (unread_list) {
477 g_slist_free(unread_list);
478 unread_list = NULL;
479 }
480
481 // Walk through groups
482 while (sl_grp) {
483 roster *roster_grp = (roster*)sl_grp->data;
484 GSList *sl_usr = roster_grp->list;
485 // Walk through this group users
486 while (sl_usr) {
487 roster *roster_usr = (roster*)sl_usr->data;
488 // If there is a pending unread message, keep track of it
489 if (roster_usr->flags & ROSTER_FLAG_MSG)
490 unread_jid_add(roster_usr->jid);
491 // Free roster_usr data (jid, name, status message...)
492 free_roster_user_data(roster_usr);
493 sl_usr = g_slist_next(sl_usr);
494 }
495 // Free group's users list
496 if (roster_grp->list)
497 g_slist_free(roster_grp->list);
498 // Free group's name and jid
499 g_free((gchar*)roster_grp->jid);
500 g_free((gchar*)roster_grp->name);
501 g_free(roster_grp);
502 sl_grp = g_slist_next(sl_grp);
503 }
504 // Free groups list
505 if (groups) {
506 g_slist_free(groups);
507 groups = NULL;
508 // Update (i.e. free) buddylist
509 if (buddylist)
510 buddylist_build();
511 }
512 }
513
514 // roster_setstatus()
515 // Note: resname, role, affil and realjid are for room members only
516 void roster_setstatus(const char *jid, const char *resname, gchar prio,
517 enum imstatus bstat, const char *status_msg,
518 time_t status_time,
519 enum imrole role, enum imaffiliation affil,
520 const char *realjid)
521 {
522 GSList *sl_user;
523 roster *roster_usr;
524 res *p_res;
525
526 sl_user = roster_find(jid, jidsearch,
527 ROSTER_TYPE_USER|ROSTER_TYPE_ROOM|ROSTER_TYPE_AGENT);
528 // If we can't find it, we add it
529 if (sl_user == NULL)
530 sl_user = roster_add_user(jid, NULL, NULL, ROSTER_TYPE_USER,
531 sub_none, -1);
532
533 // If there is no resource name, we can leave now
534 if (!resname) return;
535
536 roster_usr = (roster*)sl_user->data;
537
538 // New or updated resource
539 p_res = get_or_add_resource(roster_usr, resname, prio);
540 p_res->status = bstat;
541 if (p_res->status_msg) {
542 g_free((gchar*)p_res->status_msg);
543 p_res->status_msg = NULL;
544 }
545 if (status_msg)
546 p_res->status_msg = g_strdup(status_msg);
547 if (!status_time)
548 time(&status_time);
549 p_res->status_timestamp = status_time;
550
551 p_res->role = role;
552 p_res->affil = affil;
553
554 if (p_res->realjid) {
555 g_free((gchar*)p_res->realjid);
556 p_res->realjid = NULL;
557 }
558 if (realjid)
559 p_res->realjid = g_strdup(realjid);
560
561 // If bstat is offline, we MUST delete the resource, actually
562 if (bstat == offline) {
563 del_resource(roster_usr, resname);
564 return;
565 }
566 }
567
568 // roster_setflags()
569 // Set one or several flags to value (TRUE/FALSE)
570 void roster_setflags(const char *jid, guint flags, guint value)
571 {
572 GSList *sl_user;
573 roster *roster_usr;
574
575 sl_user = roster_find(jid, jidsearch,
576 ROSTER_TYPE_USER|ROSTER_TYPE_ROOM|ROSTER_TYPE_AGENT);
577 if (sl_user == NULL)
578 return;
579
580 roster_usr = (roster*)sl_user->data;
581 if (value)
582 roster_usr->flags |= flags;
583 else
584 roster_usr->flags &= ~flags;
585 }
586
587 // roster_msg_setflag()
588 // Set the ROSTER_FLAG_MSG to the given value for the given jid.
589 // It will update the buddy's group message flag.
590 // Update the unread messages list too.
591 void roster_msg_setflag(const char *jid, guint special, guint value)
592 {
593 GSList *sl_user;
594 roster *roster_usr, *roster_grp;
595 int new_roster_item = FALSE;
596 guint unread_list_modified = FALSE;
597
598 if (special) {
599 //sl_user = roster_find(jid, namesearch, ROSTER_TYPE_SPECIAL);
600 //if (!sl_user) return;
601 //roster_usr = (roster*)sl_user->data;
602 roster_usr = &roster_special;
603 if (value) {
604 if (!(roster_usr->flags & ROSTER_FLAG_MSG))
605 unread_list_modified = TRUE;
606 roster_usr->flags |= ROSTER_FLAG_MSG;
607 // Append the roster_usr to unread_list, but avoid duplicates
608 if (!g_slist_find(unread_list, roster_usr))
609 unread_list = g_slist_append(unread_list, roster_usr);
610 } else {
611 if (roster_usr->flags & ROSTER_FLAG_MSG)
612 unread_list_modified = TRUE;
613 roster_usr->flags &= ~ROSTER_FLAG_MSG;
614 if (unread_list) {
615 GSList *node = g_slist_find(unread_list, roster_usr);
616 if (node)
617 unread_list = g_slist_delete_link(unread_list, node);
618 }
619 }
620 goto roster_msg_setflag_return;
621 }
622
623 sl_user = roster_find(jid, jidsearch,
624 ROSTER_TYPE_USER|ROSTER_TYPE_ROOM|ROSTER_TYPE_AGENT);
625 // If we can't find it, we add it
626 if (sl_user == NULL) {
627 sl_user = roster_add_user(jid, NULL, NULL, ROSTER_TYPE_USER, sub_none, -1);
628 new_roster_item = TRUE;
629 }
630
631 roster_usr = (roster*)sl_user->data;
632 roster_grp = (roster*)roster_usr->list->data;
633 if (value) {
634 if (!(roster_usr->flags & ROSTER_FLAG_MSG))
635 unread_list_modified = TRUE;
636 // Message flag is TRUE. This is easy, we just have to set both flags
637 // to TRUE...
638 roster_usr->flags |= ROSTER_FLAG_MSG;
639 roster_grp->flags |= ROSTER_FLAG_MSG; // group
640 // Append the roster_usr to unread_list, but avoid duplicates
641 if (!g_slist_find(unread_list, roster_usr))
642 unread_list = g_slist_append(unread_list, roster_usr);
643 } else {
644 // Message flag is FALSE.
645 guint msg = FALSE;
646 if (roster_usr->flags & ROSTER_FLAG_MSG)
647 unread_list_modified = TRUE;
648 roster_usr->flags &= ~ROSTER_FLAG_MSG;
649 if (unread_list) {
650 GSList *node = g_slist_find(unread_list, roster_usr);
651 if (node)
652 unread_list = g_slist_delete_link(unread_list, node);
653 }
654 // For the group value we need to watch all buddies in this group;
655 // if one is flagged, then the group will be flagged.
656 // I will re-use sl_user and roster_usr here, as they aren't used
657 // anymore.
658 sl_user = roster_grp->list;
659 while (sl_user) {
660 roster_usr = (roster*)sl_user->data;
661 if (roster_usr->flags & ROSTER_FLAG_MSG) {
662 msg = TRUE;
663 break;
664 }
665 sl_user = g_slist_next(sl_user);
666 }
667 if (!msg)
668 roster_grp->flags &= ~ROSTER_FLAG_MSG;
669 else
670 roster_grp->flags |= ROSTER_FLAG_MSG;
671 // Actually the "else" part is useless, because the group
672 // ROSTER_FLAG_MSG should already be set...
673 }
674
675 if (buddylist && (new_roster_item || !g_list_find(buddylist, roster_usr)))
676 buddylist_build();
677
678 roster_msg_setflag_return:
679 if (unread_list_modified) {
680 guint unread_count = g_slist_length(unread_list);
681 hlog_save_state();
682 /* Call external command */
683 hk_ext_cmd("", 'U', (guchar)MIN(255, unread_count), NULL);
684 }
685 }
686
687 const char *roster_getname(const char *jid)
688 {
689 GSList *sl_user;
690 roster *roster_usr;
691
692 sl_user = roster_find(jid, jidsearch,
693 ROSTER_TYPE_USER|ROSTER_TYPE_ROOM|ROSTER_TYPE_AGENT);
694 if (sl_user == NULL)
695 return NULL; // Not in the roster...
696
697 roster_usr = (roster*)sl_user->data;
698 return roster_usr->name;
699 }
700
701 const char *roster_getnickname(const char *jid)
702 {
703 GSList *sl_user;
704 roster *roster_usr;
705
706 sl_user = roster_find(jid, jidsearch,
707 ROSTER_TYPE_USER|ROSTER_TYPE_ROOM|ROSTER_TYPE_AGENT);
708 if (sl_user == NULL)
709 return NULL; // Not in the roster...
710
711 roster_usr = (roster*)sl_user->data;
712 return roster_usr->nickname;
713 }
714
715 void roster_settype(const char *jid, guint type)
716 {
717 GSList *sl_user;
718 roster *roster_usr;
719
720 if ((sl_user = roster_find(jid, jidsearch, 0)) == NULL)
721 return;
722
723 roster_usr = (roster*)sl_user->data;
724 roster_usr->type = type;
725 }
726
727 enum imstatus roster_getstatus(const char *jid, const char *resname)
728 {
729 GSList *sl_user;
730 roster *roster_usr;
731 res *p_res;
732
733 sl_user = roster_find(jid, jidsearch, ROSTER_TYPE_USER|ROSTER_TYPE_AGENT);
734 if (sl_user == NULL)
735 return offline; // Not in the roster, anyway...
736
737 roster_usr = (roster*)sl_user->data;
738 p_res = get_resource(roster_usr, resname);
739 if (p_res)
740 return p_res->status;
741 return offline;
742 }
743
744 const char *roster_getstatusmsg(const char *jid, const char *resname)
745 {
746 GSList *sl_user;
747 roster *roster_usr;
748 res *p_res;
749
750 sl_user = roster_find(jid, jidsearch, ROSTER_TYPE_USER|ROSTER_TYPE_AGENT);
751 if (sl_user == NULL)
752 return NULL; // Not in the roster, anyway...
753
754 roster_usr = (roster*)sl_user->data;
755 p_res = get_resource(roster_usr, resname);
756 if (p_res)
757 return p_res->status_msg;
758 return roster_usr->offline_status_message;
759 }
760
761 guint roster_gettype(const char *jid)
762 {
763 GSList *sl_user;
764 roster *roster_usr;
765
766 if ((sl_user = roster_find(jid, jidsearch, 0)) == NULL)
767 return 0;
768
769 roster_usr = (roster*)sl_user->data;
770 return roster_usr->type;
771 }
772
773 guint roster_getsubscription(const char *jid)
774 {
775 GSList *sl_user;
776 roster *roster_usr;
777
778 if ((sl_user = roster_find(jid, jidsearch, 0)) == NULL)
779 return 0;
780
781 roster_usr = (roster*)sl_user->data;
782 return roster_usr->subscription;
783 }
784
785 // roster_unsubscribed()
786 // We have lost buddy's presence updates; this function clears the status
787 // message, sets the buddy offline and frees the resources
788 void roster_unsubscribed(const char *jid)
789 {
790 GSList *sl_user;
791 roster *roster_usr;
792
793 sl_user = roster_find(jid, jidsearch, ROSTER_TYPE_USER|ROSTER_TYPE_AGENT);
794 if (sl_user == NULL)
795 return;
796
797 roster_usr = (roster*)sl_user->data;
798 free_all_resources(&roster_usr->resource);
799 }
800
801
802 /* ### BuddyList functions ### */
803
804 // buddylist_set_hide_offline_buddies(hide)
805 // "hide" values: 1=hide 0=show_all -1=invert
806 void buddylist_set_hide_offline_buddies(int hide)
807 {
808 if (hide < 0) { // NEG (invert)
809 if (display_filter == DFILTER_ALL)
810 display_filter = DFILTER_ONLINE;
811 else
812 display_filter = DFILTER_ALL;
813 } else if (hide == 0) { // FALSE (don't hide -- andfo_)
814 display_filter = DFILTER_ALL;
815 } else { // TRUE (hide -- andfo)
816 display_filter = DFILTER_ONLINE;
817 }
818 }
819
820 int buddylist_isset_filter(void)
821 {
822 return (display_filter != DFILTER_ALL);
823 }
824
825 int buddylist_is_status_filtered(enum imstatus status)
826 {
827 return display_filter & (1 << status);
828 }
829
830 void buddylist_set_filter(guchar filter)
831 {
832 display_filter = filter;
833 }
834
835 guchar buddylist_get_filter(void)
836 {
837 return display_filter;
838 }
839
840 // buddylist_build()
841 // Creates the buddylist from the roster entries.
842 void buddylist_build(void)
843 {
844 GSList *sl_roster_elt = groups;
845 roster *roster_elt;
846 roster *roster_current_buddy = NULL;
847 roster *roster_alternate_buddy = NULL;
848 int shrunk_group;
849
850 // We need to remember which buddy is selected.
851 if (current_buddy)
852 roster_current_buddy = BUDDATA(current_buddy);
853 current_buddy = NULL;
854 if (alternate_buddy)
855 roster_alternate_buddy = BUDDATA(alternate_buddy);
856 alternate_buddy = NULL;
857
858 // Destroy old buddylist
859 if (buddylist) {
860 g_list_free(buddylist);
861 buddylist = NULL;
862 }
863
864 buddylist = g_list_append(buddylist, &roster_special);
865
866 // Create the new list
867 while (sl_roster_elt) {
868 GSList *sl_roster_usrelt;
869 roster *roster_usrelt;
870 guint pending_group = TRUE;
871 roster_elt = (roster*) sl_roster_elt->data;
872
873 shrunk_group = roster_elt->flags & ROSTER_FLAG_HIDE;
874
875 sl_roster_usrelt = roster_elt->list;
876 while (sl_roster_usrelt) {
877 roster_usrelt = (roster*) sl_roster_usrelt->data;
878
879 // Buddy will be added if either:
880 // - buddy's status matches the display_filter
881 // - buddy has a lock (for example the buddy window is currently open)
882 // - buddy has a pending (non-read) message
883 // - group isn't hidden (shrunk)
884 // - this is the current_buddy
885 if (roster_usrelt == roster_current_buddy ||
886 buddylist_is_status_filtered(buddy_getstatus((gpointer)roster_usrelt,
887 NULL)) ||
888 (buddy_getflags((gpointer)roster_usrelt) &
889 (ROSTER_FLAG_LOCK | ROSTER_FLAG_USRLOCK | ROSTER_FLAG_MSG))) {
890 // This user should be added. Maybe the group hasn't been added yet?
891 if (pending_group) {
892 // It hasn't been done yet
893 buddylist = g_list_append(buddylist, roster_elt);
894 pending_group = FALSE;
895 }
896 // Add user
897 // XXX Should we add the user if there is a message and
898 // the group is shrunk? If so, we'd need to check LOCK flag too,
899 // perhaps...
900 if (!shrunk_group)
901 buddylist = g_list_append(buddylist, roster_usrelt);
902 }
903
904 sl_roster_usrelt = g_slist_next(sl_roster_usrelt);
905 }
906 sl_roster_elt = g_slist_next(sl_roster_elt);
907 }
908
909 // Check if we can find our saved current_buddy...
910 if (roster_current_buddy)
911 current_buddy = g_list_find(buddylist, roster_current_buddy);
912 if (roster_alternate_buddy)
913 alternate_buddy = g_list_find(buddylist, roster_alternate_buddy);
914 // current_buddy initialization
915 if (!current_buddy || (g_list_position(buddylist, current_buddy) == -1))
916 current_buddy = g_list_first(buddylist);
917 }
918
919 // buddy_hide_group(roster, hide)
920 // "hide" values: 1=hide 0=show_all -1=invert
921 void buddy_hide_group(gpointer rosterdata, int hide)
922 {
923 roster *roster_usr = rosterdata;
924 if (hide > 0) // TRUE (hide)
925 roster_usr->flags |= ROSTER_FLAG_HIDE;
926 else if (hide < 0) // NEG (invert)
927 roster_usr->flags ^= ROSTER_FLAG_HIDE;
928 else // FALSE (don't hide)
929 roster_usr->flags &= ~ROSTER_FLAG_HIDE;
930 }
931
932 const char *buddy_getjid(gpointer rosterdata)
933 {
934 roster *roster_usr = rosterdata;
935 if (!rosterdata)
936 return NULL;
937 return roster_usr->jid;
938 }
939
940 // buddy_setgroup()
941 // Change the group of current buddy
942 //
943 // Note: buddy_setgroup() updates the user lists.
944 //
945 void buddy_setgroup(gpointer rosterdata, char *newgroupname)
946 {
947 roster *roster_usr = rosterdata;
948 GSList **sl_group;
949 GSList *sl_newgroup;
950 roster *my_newgroup;
951
952 // A group has no group :)
953 if (roster_usr->type & ROSTER_TYPE_GROUP) return;
954
955 // Add newgroup if necessary
956 if (!newgroupname) newgroupname = "";
957 sl_newgroup = roster_add_group(newgroupname);
958 if (!sl_newgroup) return;
959 my_newgroup = (roster*)sl_newgroup->data;
960
961 // Remove the buddy from current group
962 sl_group = &((roster*)((GSList*)roster_usr->list)->data)->list;
963 *sl_group = g_slist_remove(*sl_group, rosterdata);
964
965 // Remove old group if it is empty
966 if (!*sl_group) {
967 roster *roster_grp = (roster*)((GSList*)roster_usr->list)->data;
968 g_free((gchar*)roster_grp->jid);
969 g_free((gchar*)roster_grp->name);
970 g_free(roster_grp);
971 groups = g_slist_remove(groups, roster_grp);
972 }
973
974 // Add the buddy to its new group
975 roster_usr->list = sl_newgroup; // (my_newgroup SList element)
976 my_newgroup->list = g_slist_insert_sorted(my_newgroup->list, roster_usr,
977 (GCompareFunc)&roster_compare_name);
978
979 buddylist_build();
980 }
981
982 void buddy_setname(gpointer rosterdata, char *newname)
983 {
984 roster *roster_usr = rosterdata;
985 GSList **sl_group;
986
987 // TODO For groups, we need to check for unicity
988 // However, renaming a group boils down to moving all its buddies to
989 // another group, so calling this function is not really necessary...
990 if (roster_usr->type & ROSTER_TYPE_GROUP) return;
991
992 if (roster_usr->name) {
993 g_free((gchar*)roster_usr->name);
994 roster_usr->name = NULL;
995 }
996 if (newname)
997 roster_usr->name = g_strdup(newname);
998
999 // We need to resort the group list
1000 sl_group = &((roster*)((GSList*)roster_usr->list)->data)->list;
1001 *sl_group = g_slist_sort(*sl_group, (GCompareFunc)&roster_compare_name);
1002
1003 buddylist_build();
1004 }
1005
1006 const char *buddy_getname(gpointer rosterdata)
1007 {
1008 roster *roster_usr = rosterdata;
1009 return roster_usr->name;
1010 }
1011
1012 // buddy_setnickname(buddy, newnickname)
1013 // Only for chatrooms
1014 void buddy_setnickname(gpointer rosterdata, const char *newname)
1015 {
1016 roster *roster_usr = rosterdata;
1017
1018 if (!(roster_usr->type & ROSTER_TYPE_ROOM)) return; // XXX Error message?
1019
1020 if (roster_usr->nickname) {
1021 g_free((gchar*)roster_usr->nickname);
1022 roster_usr->nickname = NULL;
1023 }
1024 if (newname)
1025 roster_usr->nickname = g_strdup(newname);
1026 }
1027
1028 const char *buddy_getnickname(gpointer rosterdata)
1029 {
1030 roster *roster_usr = rosterdata;
1031 return roster_usr->nickname;
1032 }
1033
1034 // buddy_setinsideroom(buddy, inside)
1035 // Only for chatrooms
1036 void buddy_setinsideroom(gpointer rosterdata, guint inside)
1037 {
1038 roster *roster_usr = rosterdata;
1039
1040 if (!(roster_usr->type & ROSTER_TYPE_ROOM)) return;
1041
1042 roster_usr->inside_room = inside;
1043 }
1044
1045 guint buddy_getinsideroom(gpointer rosterdata)
1046 {
1047 roster *roster_usr = rosterdata;
1048 return roster_usr->inside_room;
1049 }
1050
1051 // buddy_settopic(buddy, newtopic)
1052 // Only for chatrooms
1053 void buddy_settopic(gpointer rosterdata, const char *newtopic)
1054 {
1055 roster *roster_usr = rosterdata;
1056
1057 if (!(roster_usr->type & ROSTER_TYPE_ROOM)) return;
1058
1059 if (roster_usr->topic) {
1060 g_free((gchar*)roster_usr->topic);
1061 roster_usr->topic = NULL;
1062 }
1063 if (newtopic)
1064 roster_usr->topic = g_strdup(newtopic);
1065 }
1066
1067 const char *buddy_gettopic(gpointer rosterdata)
1068 {
1069 roster *roster_usr = rosterdata;
1070 return roster_usr->topic;
1071 }
1072
1073 void buddy_setprintstatus(gpointer rosterdata, enum room_printstatus pstatus)
1074 {
1075 roster *roster_usr = rosterdata;
1076 roster_usr->print_status = pstatus;
1077 }
1078
1079 enum room_printstatus buddy_getprintstatus(gpointer rosterdata)
1080 {
1081 roster *roster_usr = rosterdata;
1082 return roster_usr->print_status;
1083 }
1084
1085 void buddy_setautowhois(gpointer rosterdata, enum room_autowhois awhois)
1086 {
1087 roster *roster_usr = rosterdata;
1088 roster_usr->auto_whois = awhois;
1089 }
1090
1091 enum room_autowhois buddy_getautowhois(gpointer rosterdata)
1092 {
1093 roster *roster_usr = rosterdata;
1094 return roster_usr->auto_whois;
1095 }
1096
1097 // buddy_getgroupname()
1098 // Returns a pointer on buddy's group name.
1099 const char *buddy_getgroupname(gpointer rosterdata)
1100 {
1101 roster *roster_usr = rosterdata;
1102
1103 if (roster_usr->type & ROSTER_TYPE_GROUP)
1104 return roster_usr->name;
1105
1106 if (roster_usr->type & ROSTER_TYPE_SPECIAL)
1107 return NULL;
1108
1109 // This is a user
1110 return ((roster*)((GSList*)roster_usr->list)->data)->name;
1111 }
1112
1113 // buddy_getgroup()
1114 // Returns a pointer on buddy's group.
1115 gpointer buddy_getgroup(gpointer rosterdata)
1116 {
1117 roster *roster_usr = rosterdata;
1118
1119 if (roster_usr->type & ROSTER_TYPE_GROUP)
1120 return rosterdata;
1121
1122 if (roster_usr->type & ROSTER_TYPE_SPECIAL)
1123 return NULL;
1124
1125 // This is a user
1126 return (gpointer)((GSList*)roster_usr->list)->data;
1127 }
1128
1129 void buddy_settype(gpointer rosterdata, guint type)
1130 {
1131 roster *roster_usr = rosterdata;
1132 roster_usr->type = type;
1133 }
1134
1135 guint buddy_gettype(gpointer rosterdata)
1136 {
1137 roster *roster_usr = rosterdata;
1138 return roster_usr->type;
1139 }
1140
1141 guint buddy_getsubscription(gpointer rosterdata)
1142 {
1143 roster *roster_usr = rosterdata;
1144 return roster_usr->subscription;
1145 }
1146
1147 enum imstatus buddy_getstatus(gpointer rosterdata, const char *resname)
1148 {
1149 roster *roster_usr = rosterdata;
1150 res *p_res = get_resource(roster_usr, resname);
1151 if (p_res)
1152 return p_res->status;
1153 return offline;
1154 }
1155
1156 const char *buddy_getstatusmsg(gpointer rosterdata, const char *resname)
1157 {
1158 roster *roster_usr = rosterdata;
1159 res *p_res = get_resource(roster_usr, resname);
1160 if (p_res)
1161 return p_res->status_msg;
1162 return roster_usr->offline_status_message;
1163 }
1164
1165 time_t buddy_getstatustime(gpointer rosterdata, const char *resname)
1166 {
1167 roster *roster_usr = rosterdata;
1168 res *p_res = get_resource(roster_usr, resname);
1169 if (p_res)
1170 return p_res->status_timestamp;
1171 return 0;
1172 }
1173
1174 gchar buddy_getresourceprio(gpointer rosterdata, const char *resname)
1175 {
1176 roster *roster_usr = rosterdata;
1177 res *p_res = get_resource(roster_usr, resname);
1178 if (p_res)
1179 return p_res->prio;
1180 return 0;
1181 }
1182
1183 guint buddy_resource_getevents(gpointer rosterdata, const char *resname)
1184 {
1185 roster *roster_usr = rosterdata;
1186 res *p_res = get_resource(roster_usr, resname);
1187 if (p_res)
1188 return p_res->events;
1189 return ROSTER_EVENT_NONE;
1190 }
1191
1192 void buddy_resource_setevents(gpointer rosterdata, const char *resname,
1193 guint events)
1194 {
1195 roster *roster_usr = rosterdata;
1196 res *p_res = get_resource(roster_usr, resname);
1197 if (p_res)
1198 p_res->events = events;
1199 }
1200
1201 char *buddy_resource_getcaps(gpointer rosterdata, const char *resname)
1202 {
1203 roster *roster_usr = rosterdata;
1204 res *p_res = get_resource(roster_usr, resname);
1205 if (p_res)
1206 return p_res->caps;
1207 return NULL;
1208 }
1209
1210 void buddy_resource_setcaps(gpointer rosterdata, const char *resname,
1211 const char *caps)
1212 {
1213 roster *roster_usr = rosterdata;
1214 res *p_res = get_resource(roster_usr, resname);
1215 if (p_res) {
1216 g_free(p_res->caps);
1217 p_res->caps = g_strdup(caps);
1218 }
1219 }
1220
1221 struct jep0022 *buddy_resource_jep22(gpointer rosterdata, const char *resname)
1222 {
1223 #ifdef JEP0022
1224 roster *roster_usr = rosterdata;
1225 res *p_res = get_resource(roster_usr, resname);
1226 if (p_res)
1227 return &p_res->jep22;
1228 #endif
1229 return NULL;
1230 }
1231
1232 struct jep0085 *buddy_resource_jep85(gpointer rosterdata, const char *resname)
1233 {
1234 #ifdef JEP0085
1235 roster *roster_usr = rosterdata;
1236 res *p_res = get_resource(roster_usr, resname);
1237 if (p_res)
1238 return &p_res->jep85;
1239 #endif
1240 return NULL;
1241 }
1242
1243 struct pgp_data *buddy_resource_pgp(gpointer rosterdata, const char *resname)
1244 {
1245 #ifdef HAVE_GPGME
1246 roster *roster_usr = rosterdata;
1247 res *p_res = get_resource(roster_usr, resname);
1248 if (p_res)
1249 return &p_res->pgpdata;
1250 #endif
1251 return NULL;
1252 }
1253
1254 enum imrole buddy_getrole(gpointer rosterdata, const char *resname)
1255 {
1256 roster *roster_usr = rosterdata;
1257 res *p_res = get_resource(roster_usr, resname);
1258 if (p_res)
1259 return p_res->role;
1260 return role_none;
1261 }
1262
1263 enum imaffiliation buddy_getaffil(gpointer rosterdata, const char *resname)
1264 {
1265 roster *roster_usr = rosterdata;
1266 res *p_res = get_resource(roster_usr, resname);
1267 if (p_res)
1268 return p_res->affil;
1269 return affil_none;
1270 }
1271
1272 const char *buddy_getrjid(gpointer rosterdata, const char *resname)
1273 {
1274 roster *roster_usr = rosterdata;
1275 res *p_res = get_resource(roster_usr, resname);
1276 if (p_res)
1277 return p_res->realjid;
1278 return NULL;
1279 }
1280
1281 // buddy_getresources(roster_data)
1282 // Return a singly-linked-list of resource names
1283 // Note: the caller should free the list (and data) after use
1284 // If roster_data is null, the current buddy is selected
1285 GSList *buddy_getresources(gpointer rosterdata)
1286 {
1287 roster *roster_usr = rosterdata;
1288 GSList *reslist = NULL, *lp;
1289
1290 if (!roster_usr) {
1291 if (!current_buddy) return NULL;
1292 roster_usr = BUDDATA(current_buddy);
1293 }
1294 for (lp = roster_usr->resource; lp; lp = g_slist_next(lp))
1295 reslist = g_slist_append(reslist, g_strdup(((res*)lp->data)->name));
1296
1297 return reslist;
1298 }
1299
1300 // buddy_getresources_locale(roster_data)
1301 // Same as buddy_getresources() but names are converted to user's locale
1302 // Note: the caller should free the list (and data) after use
1303 GSList *buddy_getresources_locale(gpointer rosterdata)
1304 {
1305 GSList *reslist, *lp;
1306
1307 reslist = buddy_getresources(rosterdata);
1308 // Convert each item to UI's locale
1309 for (lp = reslist; lp; lp = g_slist_next(lp)) {
1310 gchar *oldname = lp->data;
1311 lp->data = from_utf8(oldname);
1312 if (lp->data)
1313 g_free(oldname);
1314 else
1315 lp->data = oldname;
1316 }
1317 return reslist;
1318 }
1319
1320 /*
1321 // buddy_isresource(roster_data)
1322 // Return true if there is at least one resource
1323 // (which means, for a room, that it isn't empty)
1324 int buddy_isresource(gpointer rosterdata)
1325 {
1326 roster *roster_usr = rosterdata;
1327 if (!roster_usr)
1328 return FALSE;
1329 if (roster_usr->resource)
1330 return TRUE;
1331 return FALSE;
1332 }
1333 */
1334
1335 // buddy_resource_setname(roster_data, oldname, newname)
1336 // Useful for nickname change in a MUC room
1337 void buddy_resource_setname(gpointer rosterdata, const char *resname,
1338 const char *newname)
1339 {
1340 roster *roster_usr = rosterdata;
1341 res *p_res = get_resource(roster_usr, resname);
1342 if (p_res) {
1343 if (p_res->name) {
1344 g_free((gchar*)p_res->name);
1345 p_res->name = NULL;
1346 }
1347 if (newname)
1348 p_res->name = g_strdup(newname);
1349 }
1350 }
1351
1352 // buddy_del_all_resources()
1353 // Remove all resources from the specified buddy
1354 void buddy_del_all_resources(gpointer rosterdata)
1355 {
1356 roster *roster_usr = rosterdata;
1357
1358 while (roster_usr->resource) {
1359 res *r = roster_usr->resource->data;
1360 del_resource(roster_usr, r->name);
1361 }
1362 }
1363
1364 // buddy_setflags()
1365 // Set one or several flags to value (TRUE/FALSE)
1366 void buddy_setflags(gpointer rosterdata, guint flags, guint value)
1367 {
1368 roster *roster_usr = rosterdata;
1369 if (value)
1370 roster_usr->flags |= flags;
1371 else
1372 roster_usr->flags &= ~flags;
1373 }
1374
1375 guint buddy_getflags(gpointer rosterdata)
1376 {
1377 roster *roster_usr = rosterdata;
1378 return roster_usr->flags;
1379 }
1380
1381 // buddy_setonserverflag()
1382 // Set the on_server flag
1383 void buddy_setonserverflag(gpointer rosterdata, guint onserver)
1384 {
1385 roster *roster_usr = rosterdata;
1386 roster_usr->on_server = onserver;
1387 }
1388
1389 guint buddy_getonserverflag(gpointer rosterdata)
1390 {
1391 roster *roster_usr = rosterdata;
1392 return roster_usr->on_server;
1393 }
1394
1395 // buddy_search_jid(jid)
1396 // Look for a buddy with specified jid.
1397 // Search begins at buddylist; if no match is found in the the buddylist,
1398 // return NULL;
1399 GList *buddy_search_jid(const char *jid)
1400 {
1401 GList *buddy;
1402 roster *roster_usr;
1403
1404 if (!buddylist) return NULL;
1405
1406 for (buddy = buddylist; buddy; buddy = g_list_next(buddy)) {
1407 roster_usr = (roster*)buddy->data;
1408 if (roster_usr->jid && !strcasecmp(roster_usr->jid, jid))
1409 return buddy;
1410 }
1411 return NULL;
1412 }
1413
1414 // buddy_search(string)
1415 // Look for a buddy whose name or jid contains string.
1416 // Search begins at current_buddy; if no match is found in the the buddylist,
1417 // return NULL;
1418 GList *buddy_search(char *string)
1419 {
1420 GList *buddy = current_buddy;
1421 roster *roster_usr;
1422 if (!buddylist || !current_buddy) return NULL;
1423 for (;;) {
1424 gchar *jid_locale, *name_locale;
1425 char *found = NULL;
1426
1427 buddy = g_list_next(buddy);
1428 if (!buddy)
1429 buddy = buddylist;
1430
1431 roster_usr = (roster*)buddy->data;
1432
1433 jid_locale = from_utf8(roster_usr->jid);
1434 if (jid_locale) {
1435 found = strcasestr(jid_locale, string);
1436 g_free(jid_locale);
1437 if (found)
1438 return buddy;
1439 }
1440 name_locale = from_utf8(roster_usr->name);
1441 if (name_locale) {
1442 found = strcasestr(name_locale, string);
1443 g_free(name_locale);
1444 if (found)
1445 return buddy;
1446 }
1447
1448 if (buddy == current_buddy)
1449 return NULL; // Back to the beginning, and no match found
1450 }
1451 }
1452
1453 // foreach_buddy(roster_type, pfunction, param)
1454 // Call pfunction(buddy, param) for each buddy from the roster with
1455 // type matching roster_type.
1456 void foreach_buddy(guint roster_type,
1457 void (*pfunc)(gpointer rosterdata, void *param),
1458 void *param)
1459 {
1460 GSList *sl_roster_elt = groups;
1461 roster *roster_elt;
1462 GSList *sl_roster_usrelt;
1463 roster *roster_usrelt;
1464
1465 while (sl_roster_elt) { // group list loop
1466 roster_elt = (roster*) sl_roster_elt->data;
1467 if (roster_elt->type & ROSTER_TYPE_SPECIAL)
1468 continue; // Skip special items
1469 sl_roster_usrelt = roster_elt->list;
1470 while (sl_roster_usrelt) { // user list loop
1471 roster_usrelt = (roster*) sl_roster_usrelt->data;
1472
1473 if (roster_usrelt->type & roster_type)
1474 pfunc(roster_usrelt, param);
1475
1476 sl_roster_usrelt = g_slist_next(sl_roster_usrelt);
1477 }
1478 sl_roster_elt = g_slist_next(sl_roster_elt);
1479 }
1480 }
1481
1482 // foreach_group_member(group, pfunction, param)
1483 // Call pfunction(buddy, param) for each buddy in the specified group.
1484 void foreach_group_member(gpointer groupdata,
1485 void (*pfunc)(gpointer rosterdata, void *param),
1486 void *param)
1487 {
1488 roster *roster_elt;
1489 GSList *sl_roster_usrelt;
1490 roster *roster_usrelt;
1491
1492 roster_elt = groupdata;
1493
1494 if (!(roster_elt->type & ROSTER_TYPE_GROUP))
1495 return;
1496
1497 sl_roster_usrelt = roster_elt->list;
1498 while (sl_roster_usrelt) { // user list loop
1499 roster_usrelt = (roster*) sl_roster_usrelt->data;
1500
1501 pfunc(roster_usrelt, param);
1502 sl_roster_usrelt = g_slist_next(sl_roster_usrelt);
1503 }
1504 }
1505
1506 // compl_list(type)
1507 // Returns a list of jid's or groups. (For commands completion)
1508 // type: ROSTER_TYPE_USER (jid's) or ROSTER_TYPE_GROUP (group names)
1509 // The list should be freed by the caller after use.
1510 GSList *compl_list(guint type)
1511 {
1512 GSList *list = NULL;
1513 GSList *sl_roster_elt = groups;
1514 roster *roster_elt;
1515 GSList *sl_roster_usrelt;
1516 roster *roster_usrelt;
1517
1518 while (sl_roster_elt) { // group list loop
1519 roster_elt = (roster*) sl_roster_elt->data;
1520
1521 if (roster_elt->type & ROSTER_TYPE_SPECIAL)
1522 continue; // Skip special items
1523
1524 if (type == ROSTER_TYPE_GROUP) { // (group names)
1525 if (roster_elt->name && *(roster_elt->name))
1526 list = g_slist_append(list, from_utf8(roster_elt->name));
1527 } else { // ROSTER_TYPE_USER (jid) (or agent, or chatroom...)
1528 sl_roster_usrelt = roster_elt->list;
1529 while (sl_roster_usrelt) { // user list loop
1530 roster_usrelt = (roster*) sl_roster_usrelt->data;
1531
1532 if (roster_usrelt->jid)
1533 list = g_slist_append(list, from_utf8(roster_usrelt->jid));
1534
1535 sl_roster_usrelt = g_slist_next(sl_roster_usrelt);
1536 }
1537 }
1538 sl_roster_elt = g_slist_next(sl_roster_elt);
1539 }
1540
1541 return list;
1542 }
1543
1544 // unread_msg(rosterdata)
1545 // Return the next buddy with an unread message. If the parameter is NULL,
1546 // return the first buddy with an unread message.
1547 gpointer unread_msg(gpointer rosterdata)
1548 {
1549 GSList *unread, *next_unread;
1550
1551 if (!unread_list)
1552 return NULL;
1553
1554 // First unread message
1555 if (!rosterdata)
1556 return unread_list->data;
1557
1558 unread = g_slist_find(unread_list, rosterdata);
1559 if (!unread)
1560 return unread_list->data;
1561
1562 next_unread = g_slist_next(unread);
1563 if (next_unread)
1564 return next_unread->data;
1565 return unread_list->data;
1566 }
1567
1568
1569 /* ### "unread_jids" functions ###
1570 *
1571 * The unread_jids hash table is used to keep track of the buddies with
1572 * unread messages when a disconnection occurs.
1573 * When removing a buddy with an unread message from the roster, the
1574 * jid should be added to the unread_jids table. When adding a buddy to
1575 * the roster, we check if (s)he had a pending unread message.
1576 */
1577
1578 // unread_jid_add(jid)
1579 // Add jid to the unread_jids hash table
1580 void unread_jid_add(const char *jid)
1581 {
1582 if (!unread_jids) {
1583 // Initialize unread_jids hash table
1584 unread_jids = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
1585 }
1586 // The 2nd unread_jids is an arbitrary non-null pointer:
1587 g_hash_table_insert(unread_jids, g_strdup(jid), unread_jids);
1588 }
1589
1590 // unread_jid_del(jid)
1591 // Return TRUE if jid is found in the table (and remove it), FALSE if not
1592 static int unread_jid_del(const char *jid)
1593 {
1594 if (!unread_jids)
1595 return FALSE;
1596 return g_hash_table_remove(unread_jids, jid);
1597 }
1598
1599 // Helper function for unread_jid_get_list()
1600 static void add_to_unreadjids(gpointer key, gpointer value, gpointer udata)
1601 {
1602 GList **listp = udata;
1603 *listp = g_list_append(*listp, key);
1604 }
1605
1606 // unread_jid_get_list()
1607 // Return the JID list.
1608 // The content of the list should not be modified or freed.
1609 // The caller should call g_list_free() after use.
1610 GList *unread_jid_get_list(void)
1611 {
1612 GList *list = NULL;
1613
1614 if (!unread_jids)
1615 return NULL;
1616
1617 // g_hash_table_get_keys() is only in glib >= 2.14
1618 //return g_hash_table_get_keys(unread_jids);
1619
1620 g_hash_table_foreach(unread_jids, add_to_unreadjids, &list);
1621 return list;
1622 }
1623
1624 /* vim: set expandtab cindent cinoptions=>2\:2(0: For Vim users... */