|
1600
|
1 /* |
|
|
2 * caps.c -- Entity Capabilities Cache for mcabber |
|
|
3 * |
|
|
4 * Copyright (C) 2008 Frank Zschockelt <mcabber@freakysoft.de> |
|
|
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 <glib.h> |
|
|
23 |
|
|
24 typedef struct { |
|
|
25 char *category; |
|
|
26 char *name; |
|
|
27 char *type; |
|
|
28 GHashTable *features; |
|
|
29 } caps; |
|
|
30 |
|
|
31 static GHashTable *caps_cache = NULL; |
|
|
32 |
|
|
33 void caps_destroy(gpointer data) |
|
|
34 { |
|
|
35 caps *c = data; |
|
|
36 g_free(c->category); |
|
|
37 g_free(c->name); |
|
|
38 g_free(c->type); |
|
|
39 g_hash_table_destroy(c->features); |
|
|
40 g_free(c); |
|
|
41 } |
|
|
42 |
|
|
43 void caps_init(void) |
|
|
44 { |
|
|
45 if (!caps_cache) |
|
|
46 caps_cache = g_hash_table_new_full(g_str_hash, g_str_equal, |
|
|
47 g_free, caps_destroy); |
|
|
48 } |
|
|
49 |
|
|
50 void caps_free(void) |
|
|
51 { |
|
|
52 if (caps_cache) { |
|
|
53 g_hash_table_destroy(caps_cache); |
|
|
54 caps_cache = NULL; |
|
|
55 } |
|
|
56 } |
|
|
57 |
|
|
58 void caps_add(char *hash) |
|
|
59 { |
|
|
60 if (!hash) |
|
|
61 return; |
|
|
62 caps *c = g_new0(caps, 1); |
|
|
63 c->features = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); |
|
|
64 g_hash_table_insert(caps_cache, g_strdup(hash), c); |
|
|
65 } |
|
|
66 |
|
|
67 int caps_has_hash(const char *hash) |
|
|
68 { |
|
|
69 return (hash != NULL && (g_hash_table_lookup(caps_cache, hash) != NULL)); |
|
|
70 } |
|
|
71 |
|
|
72 void caps_set_identity(char *hash, |
|
|
73 const char *category, |
|
|
74 const char *name, |
|
|
75 const char *type) |
|
|
76 { |
|
|
77 caps *c; |
|
|
78 if (!hash) |
|
|
79 return; |
|
|
80 |
|
|
81 c = g_hash_table_lookup(caps_cache, hash); |
|
|
82 if (c) { |
|
|
83 c->category = g_strdup(category); |
|
|
84 c->name = g_strdup(name); |
|
|
85 c->type = g_strdup(type); |
|
|
86 } |
|
|
87 } |
|
|
88 |
|
|
89 void caps_add_feature(char *hash, const char *feature) |
|
|
90 { |
|
|
91 caps *c; |
|
|
92 if (!hash) |
|
|
93 return; |
|
|
94 c = g_hash_table_lookup(caps_cache, hash); |
|
|
95 if (c) { |
|
|
96 char *f = g_strdup(feature); |
|
|
97 g_hash_table_insert(c->features, f, f); |
|
|
98 } |
|
|
99 } |
|
|
100 |
|
|
101 int caps_has_feature(char *hash, char *feature) |
|
|
102 { |
|
|
103 caps *c; |
|
|
104 if (!hash) |
|
|
105 return 0; |
|
|
106 c = g_hash_table_lookup(caps_cache, hash); |
|
|
107 if (c) |
|
|
108 return (g_hash_table_lookup(c->features, feature) != NULL); |
|
|
109 return 0; |
|
|
110 } |
|
|
111 |
|
|
112 static GFunc _foreach_function; |
|
|
113 |
|
|
114 void _caps_foreach_helper(gpointer key, gpointer value, gpointer user_data) |
|
|
115 { |
|
|
116 // GFunc func = (GFunc)user_data; |
|
|
117 _foreach_function(value, user_data); |
|
|
118 } |
|
|
119 |
|
|
120 void caps_foreach_feature(const char *hash, GFunc func, gpointer user_data) |
|
|
121 { |
|
|
122 caps *c; |
|
|
123 if (!hash) |
|
|
124 return; |
|
|
125 c = g_hash_table_lookup(caps_cache, hash); |
|
|
126 if (!c) |
|
|
127 return; |
|
|
128 _foreach_function = func; |
|
|
129 g_hash_table_foreach(c->features, _caps_foreach_helper, user_data); |
|
|
130 } |
|
|
131 |
|
|
132 gint _strcmp_sort(gconstpointer a, gconstpointer b) |
|
|
133 { |
|
|
134 return g_strcmp0(a, b); |
|
|
135 } |
|
|
136 |
|
|
137 //generates the sha1 hash for the special capability "" and returns it |
|
|
138 const char *caps_generate(void) |
|
|
139 { |
|
|
140 char *identity; |
|
|
141 GList *features; |
|
|
142 GChecksum *sha1; |
|
|
143 guint8 digest[20]; |
|
|
144 gsize digest_size = 20; |
|
|
145 gchar *hash, *old_hash = NULL; |
|
|
146 caps *old_caps; |
|
|
147 unsigned int i; |
|
|
148 caps *c = g_hash_table_lookup(caps_cache, ""); |
|
|
149 |
|
|
150 g_hash_table_steal(caps_cache, ""); |
|
|
151 sha1 = g_checksum_new(G_CHECKSUM_SHA1); |
|
|
152 identity = g_strdup_printf("%s/%s/%s<", c->category, c->type, c->name); |
|
|
153 g_checksum_update(sha1, (guchar*)identity, -1); |
|
|
154 g_free(identity); |
|
|
155 |
|
|
156 features = g_list_copy(g_hash_table_get_values(c->features)); |
|
|
157 features = g_list_sort(features, _strcmp_sort); |
|
|
158 for (i=0; i < g_list_length(features); i++) { |
|
|
159 g_checksum_update(sha1, g_list_nth_data(features, i), -1); |
|
|
160 g_checksum_update(sha1, (guchar *)"<", -1); |
|
|
161 } |
|
|
162 g_list_free(features); |
|
|
163 |
|
|
164 g_checksum_get_digest(sha1, digest, &digest_size); |
|
|
165 hash = g_base64_encode(digest, digest_size); |
|
|
166 g_checksum_free(sha1); |
|
|
167 g_hash_table_lookup_extended(caps_cache, hash, |
|
|
168 (gpointer *)&old_hash, (gpointer *)&old_caps); |
|
|
169 g_hash_table_insert(caps_cache, hash, c); |
|
|
170 if (old_hash) |
|
|
171 return old_hash; |
|
|
172 else |
|
|
173 return hash; |
|
|
174 } |
|
|
175 |
|
|
176 /* vim: set expandtab cindent cinoptions=>2\:2(0: For Vim users... */ |
