Mercurial > pidgin3 / file comparison

comparison: src/protocols/sametime/meanwhile/st_list.c

src/protocols/sametime/meanwhile/st_list.c

changeset 12496
788b20ccec91
parent 12495
4b2c27ae504a
child 12497
a17568773be3
equal deleted inserted replaced
12495:4b2c27ae504a 12496:788b20ccec91
1
2 /*
3 Meanwhile - Unofficial Lotus Sametime Community Client Library
4 Copyright (C) 2004 Christopher (siege) O'Brien
5
6 This library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Library General Public
8 License as published by the Free Software Foundation; either
9 version 2 of the License, or (at your option) any later version.
10
11 This library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Library General Public License for more details.
15
16 You should have received a copy of the GNU Library General Public
17 License along with this library; if not, write to the Free
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include <stdio.h>
22 #include <string.h>
23 #include <glib/gstring.h>
24
25 #include "mw_debug.h"
26 #include "mw_util.h"
27 #include "mw_st_list.h"
28
29
30 struct mwSametimeList {
31 guint ver_major;
32 guint ver_minor;
33 guint ver_micro;
34
35 GList *groups;
36 };
37
38
39 struct mwSametimeGroup {
40 struct mwSametimeList *list;
41
42 enum mwSametimeGroupType type;
43 char *name;
44 char *alias;
45 gboolean open;
46
47 GList *users;
48 };
49
50
51 struct mwSametimeUser {
52 struct mwSametimeGroup *group;
53
54 enum mwSametimeUserType type;
55 struct mwIdBlock id;
56 char *name;
57 char *alias;
58 };
59
60
61 static void user_free(struct mwSametimeUser *u) {
62 struct mwSametimeGroup *g;
63
64 g = u->group;
65 g->users = g_list_remove(g->users, u);
66
67 mwIdBlock_clear(&u->id);
68 g_free(u->name);
69 g_free(u->alias);
70 g_free(u);
71 }
72
73
74 static void group_free(struct mwSametimeGroup *g) {
75 struct mwSametimeList *l;
76
77 l = g->list;
78 l->groups = g_list_remove(l->groups, g);
79
80 while(g->users)
81 mwSametimeUser_free(g->users->data);
82
83 g_free(g->name);
84 g_free(g->alias);
85 g_free(g);
86 }
87
88
89 static void list_free(struct mwSametimeList *l) {
90 while(l->groups)
91 mwSametimeGroup_free(l->groups->data);
92
93 g_free(l);
94 }
95
96
97 struct mwSametimeList *
98 mwSametimeList_new() {
99
100 struct mwSametimeList *stl;
101
102 stl = g_new0(struct mwSametimeList, 1);
103 stl->ver_major = ST_LIST_MAJOR;
104 stl->ver_minor = ST_LIST_MINOR;
105 stl->ver_micro = ST_LIST_MICRO;
106
107 return stl;
108 }
109
110
111 void mwSametimeList_setMajor(struct mwSametimeList *l, guint v) {
112 g_return_if_fail(l != NULL);
113 l->ver_major = v;
114 }
115
116
117 guint mwSametimeList_getMajor(struct mwSametimeList *l) {
118 g_return_val_if_fail(l != NULL, 0);
119 return l->ver_major;
120 }
121
122
123 void mwSametimeList_setMinor(struct mwSametimeList *l, guint v) {
124 g_return_if_fail(l != NULL);
125 l->ver_minor = v;
126 }
127
128
129 guint mwSametimeList_getMinor(struct mwSametimeList *l) {
130 g_return_val_if_fail(l != NULL, 0);
131 return l->ver_minor;
132 }
133
134
135 void mwSametimeList_setMicro(struct mwSametimeList *l, guint v) {
136 g_return_if_fail(l != NULL);
137 l->ver_micro = v;
138 }
139
140
141 guint mwSametimeList_getMicro(struct mwSametimeList *l) {
142 g_return_val_if_fail(l != NULL, 0);
143 return l->ver_micro;
144 }
145
146
147 GList *mwSametimeList_getGroups(struct mwSametimeList *l) {
148 g_return_val_if_fail(l != NULL, NULL);
149 return g_list_copy(l->groups);
150 }
151
152
153 struct mwSametimeGroup *
154 mwSametimeList_findGroup(struct mwSametimeList *l,
155 const char *name) {
156 GList *s;
157
158 g_return_val_if_fail(l != NULL, NULL);
159 g_return_val_if_fail(name != NULL, NULL);
160 g_return_val_if_fail(*name != '\0', NULL);
161
162 for(s = l->groups; s; s = s->next) {
163 struct mwSametimeGroup *g = s->data;
164 if(! strcmp(g->name, name)) return g;
165 }
166
167 return NULL;
168 }
169
170
171 void mwSametimeList_free(struct mwSametimeList *l) {
172 g_return_if_fail(l != NULL);
173 list_free(l);
174 }
175
176
177 struct mwSametimeGroup *
178 mwSametimeGroup_new(struct mwSametimeList *list,
179 enum mwSametimeGroupType type,
180 const char *name) {
181
182 struct mwSametimeGroup *stg;
183
184 g_return_val_if_fail(list != NULL, NULL);
185 g_return_val_if_fail(name != NULL, NULL);
186 g_return_val_if_fail(*name != '\0', NULL);
187
188 stg = g_new0(struct mwSametimeGroup, 1);
189 stg->list = list;
190 stg->type = type;
191 stg->name = g_strdup(name);
192
193 list->groups = g_list_append(list->groups, stg);
194
195 return stg;
196 }
197
198
199 enum mwSametimeGroupType mwSametimeGroup_getType(struct mwSametimeGroup *g) {
200 g_return_val_if_fail(g != NULL, mwSametimeGroup_UNKNOWN);
201 return g->type;
202 }
203
204
205 const char *mwSametimeGroup_getName(struct mwSametimeGroup *g) {
206 g_return_val_if_fail(g != NULL, NULL);
207 return g->name;
208 }
209
210
211 void mwSametimeGroup_setAlias(struct mwSametimeGroup *g,
212 const char *alias) {
213 g_return_if_fail(g != NULL);
214
215 g_free(g->alias);
216 g->alias = g_strdup(alias);
217 }
218
219
220 const char *mwSametimeGroup_getAlias(struct mwSametimeGroup *g) {
221 g_return_val_if_fail(g != NULL, NULL);
222 return g->alias;
223 }
224
225
226 void mwSametimeGroup_setOpen(struct mwSametimeGroup *g, gboolean open) {
227 g_return_if_fail(g != NULL);
228 g->open = open;
229 }
230
231
232 gboolean mwSametimeGroup_isOpen(struct mwSametimeGroup *g) {
233 g_return_val_if_fail(g != NULL, FALSE);
234 return g->open;
235 }
236
237
238 struct mwSametimeList *mwSametimeGroup_getList(struct mwSametimeGroup *g) {
239 g_return_val_if_fail(g != NULL, NULL);
240 return g->list;
241 }
242
243
244 GList *mwSametimeGroup_getUsers(struct mwSametimeGroup *g) {
245 g_return_val_if_fail(g != NULL, NULL);
246 return g_list_copy(g->users);
247 }
248
249
250 struct mwSametimeUser *
251 mwSametimeGroup_findUser(struct mwSametimeGroup *g,
252 struct mwIdBlock *user) {
253 GList *s;
254
255 g_return_val_if_fail(g != NULL, NULL);
256 g_return_val_if_fail(user != NULL, NULL);
257
258 for(s = g->users; s; s = s->next) {
259 struct mwSametimeUser *u = s->data;
260 if(mwIdBlock_equal(user, &u->id)) return u;
261 }
262
263 return NULL;
264 }
265
266
267 void mwSametimeGroup_free(struct mwSametimeGroup *g) {
268 g_return_if_fail(g != NULL);
269 g_return_if_fail(g->list != NULL);
270 group_free(g);
271 }
272
273
274 struct mwSametimeUser *
275 mwSametimeUser_new(struct mwSametimeGroup *group,
276 enum mwSametimeUserType type,
277 struct mwIdBlock *id) {
278
279 struct mwSametimeUser *stu;
280
281 g_return_val_if_fail(group != NULL, NULL);
282 g_return_val_if_fail(id != NULL, NULL);
283
284 stu = g_new0(struct mwSametimeUser, 1);
285 stu->group = group;
286 stu->type = type;
287 mwIdBlock_clone(&stu->id, id);
288
289 group->users = g_list_append(group->users, stu);
290
291 return stu;
292 }
293
294
295 struct mwSametimeGroup *mwSametimeUser_getGroup(struct mwSametimeUser *u) {
296 g_return_val_if_fail(u != NULL, NULL);
297 return u->group;
298 }
299
300
301 enum mwSametimeUserType mwSametimeUser_getType(struct mwSametimeUser *u) {
302 g_return_val_if_fail(u != NULL, mwSametimeUser_UNKNOWN);
303 return u->type;
304 }
305
306
307 const char *mwSametimeUser_getUser(struct mwSametimeUser *u) {
308 g_return_val_if_fail(u != NULL, NULL);
309 return u->id.user;
310 }
311
312
313 const char *mwSametimeUser_getCommunity(struct mwSametimeUser *u) {
314 g_return_val_if_fail(u != NULL, NULL);
315 return u->id.community;
316 }
317
318
319 void mwSametimeUser_setShortName(struct mwSametimeUser *u, const char *name) {
320 g_return_if_fail(u != NULL);
321 g_free(u->name);
322 u->name = g_strdup(name);
323 }
324
325
326 const char *mwSametimeUser_getShortName(struct mwSametimeUser *u) {
327 g_return_val_if_fail(u != NULL, NULL);
328 return u->name;
329 }
330
331
332 void mwSametimeUser_setAlias(struct mwSametimeUser *u, const char *alias) {
333 g_return_if_fail(u != NULL);
334 g_free(u->alias);
335 u->alias = g_strdup(alias);
336 }
337
338
339 const char *mwSametimeUser_getAlias(struct mwSametimeUser *u) {
340 g_return_val_if_fail(u != NULL, NULL);
341 return u->alias;
342 }
343
344
345 void mwSametimeUser_free(struct mwSametimeUser *u) {
346 g_return_if_fail(u != NULL);
347 g_return_if_fail(u->group != NULL);
348 user_free(u);
349 }
350
351
352 static void str_replace(char *str, char from, char to) {
353 if(! str) return;
354 for(; *str; str++) if(*str == from) *str = to;
355 }
356
357
358 static char user_type_to_char(enum mwSametimeUserType type) {
359 switch(type) {
360 case mwSametimeUser_NORMAL: return '1';
361 case mwSametimeUser_EXTERNAL: return '2';
362 case mwSametimeUser_UNKNOWN:
363 default: return '9';
364 }
365 }
366
367
368 static enum mwSametimeUserType user_char_to_type(char type) {
369 switch(type) {
370 case '1': return mwSametimeUser_NORMAL;
371 case '2': return mwSametimeUser_EXTERNAL;
372 default: return mwSametimeUser_UNKNOWN;
373 }
374 }
375
376
377 static void user_put(GString *str, struct mwSametimeUser *u) {
378 char *id, *name, *alias;
379 char type;
380
381 id = g_strdup(u->id.user);
382 name = g_strdup(u->name);
383 alias = g_strdup(u->alias);
384 type = user_type_to_char(u->type);
385
386 if(id) str_replace(id, ' ', ';');
387 if(name) str_replace(name, ' ', ';');
388 if(alias) str_replace(alias, ' ', ';');
389
390 if(!name && alias) {
391 name = alias;
392 alias = NULL;
393 }
394
395 g_string_append_printf(str, "U %s%c:: %s,%s\r\n",
396 id, type, (name? name: ""), (alias? alias: ""));
397
398 g_free(id);
399 g_free(name);
400 g_free(alias);
401 }
402
403
404 static char group_type_to_char(enum mwSametimeGroupType type) {
405 switch(type) {
406 case mwSametimeGroup_NORMAL: return '2';
407 case mwSametimeGroup_DYNAMIC: return '3';
408 case mwSametimeGroup_UNKNOWN:
409 default: return '9';
410 }
411 }
412
413
414 static enum mwSametimeGroupType group_char_to_type(char type) {
415 switch(type) {
416 case '2': return mwSametimeGroup_NORMAL;
417 case '3': return mwSametimeGroup_DYNAMIC;
418 default: return mwSametimeGroup_UNKNOWN;
419 }
420 }
421
422
423 static void group_put(GString *str, struct mwSametimeGroup *g) {
424 char *name, *alias;
425 char type;
426 GList *gl;
427
428 name = g_strdup(g->name);
429 alias = g_strdup((g->alias)? g->alias: name);
430 type = group_type_to_char(g->type);
431
432 str_replace(name, ' ', ';');
433 str_replace(alias, ' ', ';');
434
435 g_string_append_printf(str, "G %s%c %s %c\r\n",
436 name, type, alias, (g->open? 'O':'C'));
437
438 for(gl = g->users; gl; gl = gl->next) {
439 user_put(str, gl->data);
440 }
441
442 g_free(name);
443 g_free(alias);
444 }
445
446
447 /** composes a GString with the written contents of a sametime list */
448 static GString *list_store(struct mwSametimeList *l) {
449 GString *str;
450 GList *gl;
451
452 g_return_val_if_fail(l != NULL, NULL);
453
454 str = g_string_new(NULL);
455 g_string_append_printf(str, "Version=%u.%u.%u\r\n",
456 l->ver_major, l->ver_minor, l->ver_micro);
457
458 for(gl = l->groups; gl; gl = gl->next) {
459 group_put(str, gl->data);
460 }
461
462 return str;
463 }
464
465
466 char *mwSametimeList_store(struct mwSametimeList *l) {
467 GString *str;
468 char *s;
469
470 g_return_val_if_fail(l != NULL, NULL);
471
472 str = list_store(l);
473 s = str->str;
474 g_string_free(str, FALSE);
475 return s;
476 }
477
478
479 void mwSametimeList_put(struct mwPutBuffer *b, struct mwSametimeList *l) {
480 GString *str;
481 guint16 len;
482
483 g_return_if_fail(l != NULL);
484 g_return_if_fail(b != NULL);
485
486 str = list_store(l);
487 len = (guint16) str->len;
488 guint16_put(b, len);
489 mwPutBuffer_write(b, str->str, len);
490
491 g_string_free(str, TRUE);
492 }
493
494
495 static void get_version(const char *line, struct mwSametimeList *l) {
496 guint major = 0, minor = 0, micro = 0;
497 int ret;
498
499 ret = sscanf(line, "Version=%u.%u.%u\n", &major, &minor, &micro);
500 if(ret != 3) {
501 g_warning("strange sametime list version line:\n%s", line);
502 }
503
504 l->ver_major = major;
505 l->ver_minor = minor;
506 l->ver_micro = micro;
507 }
508
509
510 static struct mwSametimeGroup *get_group(const char *line,
511 struct mwSametimeList *l) {
512 struct mwSametimeGroup *group;
513 char *name, *alias;
514 char type = '2', open = 'O';
515 int ret;
516
517 ret = strlen(line);
518 name = g_malloc0(ret);
519 alias = g_malloc0(ret);
520
521 ret = sscanf(line, "G %s %s %c\n",
522 name, alias, &open);
523
524 if(ret < 3) {
525 g_warning("strange sametime list group line:\n%s", line);
526 }
527
528 str_replace(name, ';', ' ');
529 str_replace(alias, ';', ' ');
530
531 if(name && *name) {
532 int l = strlen(name)-1;
533 type = name[l];
534 name[l] = '\0';
535 }
536
537 group = g_new0(struct mwSametimeGroup, 1);
538 group->list = l;
539 group->name = name;
540 group->type = group_char_to_type(type);
541 group->alias = alias;
542 group->open = (open == 'O');
543
544 l->groups = g_list_append(l->groups, group);
545
546 return group;
547 }
548
549
550 static void get_user(const char *line, struct mwSametimeGroup *g) {
551 struct mwSametimeUser *user;
552 struct mwIdBlock idb = { 0, 0 };
553 char *name, *alias = NULL;
554 char type = '1';
555 int ret;
556
557 ret = strlen(line);
558 idb.user = g_malloc0(ret);
559 name = g_malloc0(ret);
560
561 ret = sscanf(line, "U %s %s",
562 idb.user, name);
563
564 if(ret < 2) {
565 g_warning("strange sametime list user line:\n%s", line);
566 }
567
568 str_replace(idb.user, ';', ' ');
569 str_replace(name, ';', ' ');
570
571 if(idb.user && *idb.user) {
572 char *tmp = strstr(idb.user, "::");
573 if(tmp--) {
574 type = *(tmp);
575 *tmp = '\0';
576 }
577 }
578
579 if(name && *name) {
580 char *tmp = strrchr(name, ',');
581 if(tmp) {
582 *tmp++ = '\0';
583 if(*tmp) alias = tmp;
584 }
585 }
586
587 user = g_new0(struct mwSametimeUser, 1);
588 user->group = g;
589 user->id.user = idb.user;
590 user->type = user_char_to_type(type);
591 user->name = name;
592 user->alias = g_strdup(alias);
593
594 g->users = g_list_append(g->users, user);
595 }
596
597
598 /** returns a line from str, and advances str */
599 static char *fetch_line(char **str) {
600 char *start = *str;
601 char *end;
602
603 /* move to first non-whitespace character */
604 while(*start && g_ascii_isspace(*start)) start++;
605 if(! *start) return NULL;
606
607 for(end = start + 1; *end; end++) {
608 if(*end == '\n' || *end == '\r') {
609 *(end++) = '\0';
610 break;
611 }
612 }
613
614 *str = end;
615 return start;
616 }
617
618
619 void list_get(const char *lines, struct mwSametimeList *l) {
620 char *s = (char *) lines;
621 char *line;
622
623 struct mwSametimeGroup *g = NULL;
624
625 while( (line = fetch_line(&s)) ) {
626 switch(*line) {
627 case 'V':
628 get_version(line, l);
629 break;
630
631 case 'G':
632 g = get_group(line, l);
633 break;
634
635 case 'U':
636 get_user(line, g);
637 break;
638
639 default:
640 g_warning("unknown sametime list data line:\n%s", line);
641 }
642 }
643 }
644
645
646 struct mwSametimeList *mwSametimeList_load(const char *data) {
647 struct mwSametimeList *l;
648
649 g_return_val_if_fail(data != NULL, NULL);
650
651 l = mwSametimeList_new();
652 list_get(data, l);
653
654 return l;
655 }
656
657
658 void mwSametimeList_get(struct mwGetBuffer *b, struct mwSametimeList *l) {
659 char *str = NULL;
660
661 g_return_if_fail(l != NULL);
662 g_return_if_fail(b != NULL);
663
664 mwString_get(b, &str);
665 list_get(str, l);
666 g_free(str);
667 }
668

Mercurial Repository: pidgin3

mercurial