diff options
Diffstat (limited to 'src/service/messenger/gnunet-service-messenger_member.c')
-rw-r--r-- | src/service/messenger/gnunet-service-messenger_member.c | 174 |
1 files changed, 109 insertions, 65 deletions
diff --git a/src/service/messenger/gnunet-service-messenger_member.c b/src/service/messenger/gnunet-service-messenger_member.c index 96b26cfb9..c57daa062 100644 --- a/src/service/messenger/gnunet-service-messenger_member.c +++ b/src/service/messenger/gnunet-service-messenger_member.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
3 | Copyright (C) 2020--2021 GNUnet e.V. | 3 | Copyright (C) 2020--2023 GNUnet e.V. |
4 | 4 | ||
5 | GNUnet is free software: you can redistribute it and/or modify it | 5 | GNUnet is free software: you can redistribute it and/or modify it |
6 | under the terms of the GNU Affero General Public License as published | 6 | under the terms of the GNU Affero General Public License as published |
@@ -34,44 +34,50 @@ create_member (struct GNUNET_MESSENGER_MemberStore *store, | |||
34 | { | 34 | { |
35 | GNUNET_assert (store); | 35 | GNUNET_assert (store); |
36 | 36 | ||
37 | struct GNUNET_MESSENGER_Member *member = GNUNET_new(struct GNUNET_MESSENGER_Member); | 37 | struct GNUNET_MESSENGER_Member *member = GNUNET_new (struct |
38 | GNUNET_MESSENGER_Member); | ||
38 | 39 | ||
39 | member->store = store; | 40 | member->store = store; |
40 | 41 | ||
41 | if (id) | 42 | if (id) |
42 | GNUNET_memcpy(&(member->id), id, sizeof(member->id)); | 43 | GNUNET_memcpy (&(member->id), id, sizeof(member->id)); |
43 | else if (GNUNET_YES != generate_free_member_id(&(member->id), store->members)) | 44 | else if (GNUNET_YES != generate_free_member_id (&(member->id), |
45 | store->members)) | ||
44 | { | 46 | { |
45 | GNUNET_free (member); | 47 | GNUNET_free (member); |
46 | return NULL; | 48 | return NULL; |
47 | } | 49 | } |
48 | 50 | ||
49 | member->sessions = GNUNET_CONTAINER_multihashmap_create(2, GNUNET_NO); | 51 | member->sessions = GNUNET_CONTAINER_multihashmap_create (2, GNUNET_NO); |
50 | 52 | ||
51 | return member; | 53 | return member; |
52 | } | 54 | } |
53 | 55 | ||
56 | |||
54 | static int | 57 | static int |
55 | iterate_destroy_session (void *cls, | 58 | iterate_destroy_session (void *cls, |
56 | const struct GNUNET_HashCode *key, | 59 | const struct GNUNET_HashCode *key, |
57 | void *value) | 60 | void *value) |
58 | { | 61 | { |
59 | struct GNUNET_MESSENGER_MemberSession *session = value; | 62 | struct GNUNET_MESSENGER_MemberSession *session = value; |
60 | destroy_member_session(session); | 63 | destroy_member_session (session); |
61 | return GNUNET_YES; | 64 | return GNUNET_YES; |
62 | } | 65 | } |
63 | 66 | ||
67 | |||
64 | void | 68 | void |
65 | destroy_member (struct GNUNET_MESSENGER_Member *member) | 69 | destroy_member (struct GNUNET_MESSENGER_Member *member) |
66 | { | 70 | { |
67 | GNUNET_assert((member) && (member->sessions)); | 71 | GNUNET_assert ((member) && (member->sessions)); |
68 | 72 | ||
69 | GNUNET_CONTAINER_multihashmap_iterate (member->sessions, iterate_destroy_session, NULL); | 73 | GNUNET_CONTAINER_multihashmap_iterate (member->sessions, |
74 | iterate_destroy_session, NULL); | ||
70 | GNUNET_CONTAINER_multihashmap_destroy (member->sessions); | 75 | GNUNET_CONTAINER_multihashmap_destroy (member->sessions); |
71 | 76 | ||
72 | GNUNET_free (member); | 77 | GNUNET_free (member); |
73 | } | 78 | } |
74 | 79 | ||
80 | |||
75 | const struct GNUNET_ShortHashCode* | 81 | const struct GNUNET_ShortHashCode* |
76 | get_member_id (const struct GNUNET_MESSENGER_Member *member) | 82 | get_member_id (const struct GNUNET_MESSENGER_Member *member) |
77 | { | 83 | { |
@@ -80,6 +86,7 @@ get_member_id (const struct GNUNET_MESSENGER_Member *member) | |||
80 | return &(member->id); | 86 | return &(member->id); |
81 | } | 87 | } |
82 | 88 | ||
89 | |||
83 | static int | 90 | static int |
84 | callback_scan_for_sessions (void *cls, | 91 | callback_scan_for_sessions (void *cls, |
85 | const char *filename) | 92 | const char *filename) |
@@ -92,13 +99,14 @@ callback_scan_for_sessions (void *cls, | |||
92 | 99 | ||
93 | GNUNET_asprintf (&directory, "%s%c", filename, DIR_SEPARATOR); | 100 | GNUNET_asprintf (&directory, "%s%c", filename, DIR_SEPARATOR); |
94 | 101 | ||
95 | load_member_session(member, directory); | 102 | load_member_session (member, directory); |
96 | GNUNET_free (directory); | 103 | GNUNET_free (directory); |
97 | } | 104 | } |
98 | 105 | ||
99 | return GNUNET_OK; | 106 | return GNUNET_OK; |
100 | } | 107 | } |
101 | 108 | ||
109 | |||
102 | void | 110 | void |
103 | load_member (struct GNUNET_MESSENGER_MemberStore *store, | 111 | load_member (struct GNUNET_MESSENGER_MemberStore *store, |
104 | const char *directory) | 112 | const char *directory) |
@@ -113,7 +121,8 @@ load_member (struct GNUNET_MESSENGER_MemberStore *store, | |||
113 | if (GNUNET_YES != GNUNET_DISK_file_test (config_file)) | 121 | if (GNUNET_YES != GNUNET_DISK_file_test (config_file)) |
114 | goto free_config; | 122 | goto free_config; |
115 | 123 | ||
116 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Load member configuration: %s\n", config_file); | 124 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load member configuration: %s\n", |
125 | config_file); | ||
117 | 126 | ||
118 | struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create (); | 127 | struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create (); |
119 | 128 | ||
@@ -121,10 +130,11 @@ load_member (struct GNUNET_MESSENGER_MemberStore *store, | |||
121 | { | 130 | { |
122 | struct GNUNET_ShortHashCode id; | 131 | struct GNUNET_ShortHashCode id; |
123 | 132 | ||
124 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "member", "id", &id, sizeof(id))) | 133 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "member", "id", &id, |
134 | sizeof(id))) | ||
125 | goto destroy_config; | 135 | goto destroy_config; |
126 | 136 | ||
127 | member = add_store_member(store, &id); | 137 | member = add_store_member (store, &id); |
128 | } | 138 | } |
129 | 139 | ||
130 | destroy_config: | 140 | destroy_config: |
@@ -132,9 +142,9 @@ destroy_config: | |||
132 | GNUNET_CONFIGURATION_destroy (cfg); | 142 | GNUNET_CONFIGURATION_destroy (cfg); |
133 | 143 | ||
134 | free_config: | 144 | free_config: |
135 | GNUNET_free(config_file); | 145 | GNUNET_free (config_file); |
136 | 146 | ||
137 | if (!member) | 147 | if (! member) |
138 | return; | 148 | return; |
139 | 149 | ||
140 | char *scan_dir; | 150 | char *scan_dir; |
@@ -143,18 +153,20 @@ free_config: | |||
143 | if (GNUNET_OK == GNUNET_DISK_directory_test (scan_dir, GNUNET_YES)) | 153 | if (GNUNET_OK == GNUNET_DISK_directory_test (scan_dir, GNUNET_YES)) |
144 | GNUNET_DISK_directory_scan (scan_dir, callback_scan_for_sessions, member); | 154 | GNUNET_DISK_directory_scan (scan_dir, callback_scan_for_sessions, member); |
145 | 155 | ||
146 | GNUNET_free(scan_dir); | 156 | GNUNET_free (scan_dir); |
147 | } | 157 | } |
148 | 158 | ||
159 | |||
149 | static int | 160 | static int |
150 | iterate_load_next_session (void *cls, | 161 | iterate_load_next_session (void *cls, |
151 | const struct GNUNET_HashCode *key, | 162 | const struct GNUNET_HashCode *key, |
152 | void *value) | 163 | void *value) |
153 | { | 164 | { |
154 | const char* sessions_directory = cls; | 165 | const char *sessions_directory = cls; |
155 | 166 | ||
156 | char* load_dir; | 167 | char *load_dir; |
157 | GNUNET_asprintf (&load_dir, "%s%s%c", sessions_directory, GNUNET_h2s(key), DIR_SEPARATOR); | 168 | GNUNET_asprintf (&load_dir, "%s%s%c", sessions_directory, GNUNET_h2s (key), |
169 | DIR_SEPARATOR); | ||
158 | 170 | ||
159 | struct GNUNET_MESSENGER_MemberSession *session = value; | 171 | struct GNUNET_MESSENGER_MemberSession *session = value; |
160 | 172 | ||
@@ -165,29 +177,33 @@ iterate_load_next_session (void *cls, | |||
165 | return GNUNET_YES; | 177 | return GNUNET_YES; |
166 | } | 178 | } |
167 | 179 | ||
180 | |||
168 | void | 181 | void |
169 | load_member_next_sessions (const struct GNUNET_MESSENGER_Member *member, | 182 | load_member_next_sessions (const struct GNUNET_MESSENGER_Member *member, |
170 | const char *directory) | 183 | const char *directory) |
171 | { | 184 | { |
172 | GNUNET_assert ((member) && (directory)); | 185 | GNUNET_assert ((member) && (directory)); |
173 | 186 | ||
174 | char* load_dir; | 187 | char *load_dir; |
175 | GNUNET_asprintf (&load_dir, "%s%s%c", directory, "sessions", DIR_SEPARATOR); | 188 | GNUNET_asprintf (&load_dir, "%s%s%c", directory, "sessions", DIR_SEPARATOR); |
176 | 189 | ||
177 | GNUNET_CONTAINER_multihashmap_iterate (member->sessions, iterate_load_next_session, load_dir); | 190 | GNUNET_CONTAINER_multihashmap_iterate (member->sessions, |
191 | iterate_load_next_session, load_dir); | ||
178 | 192 | ||
179 | GNUNET_free(load_dir); | 193 | GNUNET_free (load_dir); |
180 | } | 194 | } |
181 | 195 | ||
196 | |||
182 | static int | 197 | static int |
183 | iterate_save_session (void *cls, | 198 | iterate_save_session (void *cls, |
184 | const struct GNUNET_HashCode *key, | 199 | const struct GNUNET_HashCode *key, |
185 | void *value) | 200 | void *value) |
186 | { | 201 | { |
187 | const char* sessions_directory = cls; | 202 | const char *sessions_directory = cls; |
188 | 203 | ||
189 | char* save_dir; | 204 | char *save_dir; |
190 | GNUNET_asprintf (&save_dir, "%s%s%c", sessions_directory, GNUNET_h2s(key), DIR_SEPARATOR); | 205 | GNUNET_asprintf (&save_dir, "%s%s%c", sessions_directory, GNUNET_h2s (key), |
206 | DIR_SEPARATOR); | ||
191 | 207 | ||
192 | struct GNUNET_MESSENGER_MemberSession *session = value; | 208 | struct GNUNET_MESSENGER_MemberSession *session = value; |
193 | 209 | ||
@@ -199,6 +215,7 @@ iterate_save_session (void *cls, | |||
199 | return GNUNET_YES; | 215 | return GNUNET_YES; |
200 | } | 216 | } |
201 | 217 | ||
218 | |||
202 | void | 219 | void |
203 | save_member (struct GNUNET_MESSENGER_Member *member, | 220 | save_member (struct GNUNET_MESSENGER_Member *member, |
204 | const char *directory) | 221 | const char *directory) |
@@ -208,39 +225,43 @@ save_member (struct GNUNET_MESSENGER_Member *member, | |||
208 | char *config_file; | 225 | char *config_file; |
209 | GNUNET_asprintf (&config_file, "%s%s", directory, "member.cfg"); | 226 | GNUNET_asprintf (&config_file, "%s%s", directory, "member.cfg"); |
210 | 227 | ||
211 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Save member configuration: %s\n", config_file); | 228 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save member configuration: %s\n", |
229 | config_file); | ||
212 | 230 | ||
213 | struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create (); | 231 | struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create (); |
214 | 232 | ||
215 | char *id_data = GNUNET_STRINGS_data_to_string_alloc (&(member->id), sizeof(member->id)); | 233 | char *id_data = GNUNET_STRINGS_data_to_string_alloc (&(member->id), |
234 | sizeof(member->id)); | ||
216 | 235 | ||
217 | if (id_data) | 236 | if (id_data) |
218 | { | 237 | { |
219 | GNUNET_CONFIGURATION_set_value_string (cfg, "member", "id", id_data); | 238 | GNUNET_CONFIGURATION_set_value_string (cfg, "member", "id", id_data); |
220 | 239 | ||
221 | GNUNET_free(id_data); | 240 | GNUNET_free (id_data); |
222 | } | 241 | } |
223 | 242 | ||
224 | GNUNET_CONFIGURATION_write (cfg, config_file); | 243 | GNUNET_CONFIGURATION_write (cfg, config_file); |
225 | GNUNET_CONFIGURATION_destroy (cfg); | 244 | GNUNET_CONFIGURATION_destroy (cfg); |
226 | 245 | ||
227 | GNUNET_free(config_file); | 246 | GNUNET_free (config_file); |
228 | 247 | ||
229 | char* save_dir; | 248 | char *save_dir; |
230 | GNUNET_asprintf (&save_dir, "%s%s%c", directory, "sessions", DIR_SEPARATOR); | 249 | GNUNET_asprintf (&save_dir, "%s%s%c", directory, "sessions", DIR_SEPARATOR); |
231 | 250 | ||
232 | if ((GNUNET_YES == GNUNET_DISK_directory_test (save_dir, GNUNET_NO)) || | 251 | if ((GNUNET_YES == GNUNET_DISK_directory_test (save_dir, GNUNET_NO)) || |
233 | (GNUNET_OK == GNUNET_DISK_directory_create (save_dir))) | 252 | (GNUNET_OK == GNUNET_DISK_directory_create (save_dir))) |
234 | GNUNET_CONTAINER_multihashmap_iterate (member->sessions, iterate_save_session, save_dir); | 253 | GNUNET_CONTAINER_multihashmap_iterate (member->sessions, |
254 | iterate_save_session, save_dir); | ||
235 | 255 | ||
236 | GNUNET_free(save_dir); | 256 | GNUNET_free (save_dir); |
237 | } | 257 | } |
238 | 258 | ||
259 | |||
239 | static void | 260 | static void |
240 | sync_session_contact_from_next (struct GNUNET_MESSENGER_MemberSession *session, | 261 | sync_session_contact_from_next (struct GNUNET_MESSENGER_MemberSession *session, |
241 | struct GNUNET_MESSENGER_MemberSession *next) | 262 | struct GNUNET_MESSENGER_MemberSession *next) |
242 | { | 263 | { |
243 | GNUNET_assert((session) && (next)); | 264 | GNUNET_assert ((session) && (next)); |
244 | 265 | ||
245 | if (session == next) | 266 | if (session == next) |
246 | return; | 267 | return; |
@@ -251,6 +272,7 @@ sync_session_contact_from_next (struct GNUNET_MESSENGER_MemberSession *session, | |||
251 | session->contact = next->contact; | 272 | session->contact = next->contact; |
252 | } | 273 | } |
253 | 274 | ||
275 | |||
254 | static int | 276 | static int |
255 | iterate_sync_session_contact (void *cls, | 277 | iterate_sync_session_contact (void *cls, |
256 | const struct GNUNET_HashCode *key, | 278 | const struct GNUNET_HashCode *key, |
@@ -264,14 +286,17 @@ iterate_sync_session_contact (void *cls, | |||
264 | return GNUNET_YES; | 286 | return GNUNET_YES; |
265 | } | 287 | } |
266 | 288 | ||
289 | |||
267 | void | 290 | void |
268 | sync_member_contacts (struct GNUNET_MESSENGER_Member *member) | 291 | sync_member_contacts (struct GNUNET_MESSENGER_Member *member) |
269 | { | 292 | { |
270 | GNUNET_assert ((member) && (member->sessions)); | 293 | GNUNET_assert ((member) && (member->sessions)); |
271 | 294 | ||
272 | GNUNET_CONTAINER_multihashmap_iterate (member->sessions, iterate_sync_session_contact, NULL); | 295 | GNUNET_CONTAINER_multihashmap_iterate (member->sessions, |
296 | iterate_sync_session_contact, NULL); | ||
273 | } | 297 | } |
274 | 298 | ||
299 | |||
275 | struct GNUNET_MESSENGER_MemberSession* | 300 | struct GNUNET_MESSENGER_MemberSession* |
276 | get_member_session (const struct GNUNET_MESSENGER_Member *member, | 301 | get_member_session (const struct GNUNET_MESSENGER_Member *member, |
277 | const struct GNUNET_CRYPTO_PublicKey *public_key) | 302 | const struct GNUNET_CRYPTO_PublicKey *public_key) |
@@ -279,12 +304,14 @@ get_member_session (const struct GNUNET_MESSENGER_Member *member, | |||
279 | GNUNET_assert ((member) && (public_key)); | 304 | GNUNET_assert ((member) && (public_key)); |
280 | 305 | ||
281 | struct GNUNET_HashCode hash; | 306 | struct GNUNET_HashCode hash; |
282 | GNUNET_CRYPTO_hash(public_key, sizeof(*public_key), &hash); | 307 | GNUNET_CRYPTO_hash (public_key, sizeof(*public_key), &hash); |
283 | 308 | ||
284 | return GNUNET_CONTAINER_multihashmap_get(member->sessions, &hash); | 309 | return GNUNET_CONTAINER_multihashmap_get (member->sessions, &hash); |
285 | } | 310 | } |
286 | 311 | ||
287 | struct GNUNET_MESSENGER_ClosureSearchSession { | 312 | |
313 | struct GNUNET_MESSENGER_ClosureSearchSession | ||
314 | { | ||
288 | const struct GNUNET_MESSENGER_Message *message; | 315 | const struct GNUNET_MESSENGER_Message *message; |
289 | const struct GNUNET_HashCode *hash; | 316 | const struct GNUNET_HashCode *hash; |
290 | 317 | ||
@@ -296,45 +323,48 @@ iterate_search_session (void *cls, | |||
296 | const struct GNUNET_HashCode *key, | 323 | const struct GNUNET_HashCode *key, |
297 | void *value) | 324 | void *value) |
298 | { | 325 | { |
299 | struct GNUNET_MESSENGER_ClosureSearchSession* search = cls; | 326 | struct GNUNET_MESSENGER_ClosureSearchSession *search = cls; |
300 | struct GNUNET_MESSENGER_MemberSession *session = value; | 327 | struct GNUNET_MESSENGER_MemberSession *session = value; |
301 | 328 | ||
302 | if (GNUNET_OK != verify_member_session_as_sender(session, search->message, search->hash)) | 329 | if (GNUNET_OK != verify_member_session_as_sender (session, search->message, |
330 | search->hash)) | ||
303 | return GNUNET_YES; | 331 | return GNUNET_YES; |
304 | 332 | ||
305 | search->match = session; | 333 | search->match = session; |
306 | return GNUNET_NO; | 334 | return GNUNET_NO; |
307 | } | 335 | } |
308 | 336 | ||
337 | |||
309 | static struct GNUNET_MESSENGER_MemberSession* | 338 | static struct GNUNET_MESSENGER_MemberSession* |
310 | try_member_session (struct GNUNET_MESSENGER_Member *member, | 339 | try_member_session (struct GNUNET_MESSENGER_Member *member, |
311 | const struct GNUNET_CRYPTO_PublicKey *public_key) | 340 | const struct GNUNET_CRYPTO_PublicKey *public_key) |
312 | { | 341 | { |
313 | struct GNUNET_MESSENGER_MemberSession* session = get_member_session(member, public_key); | 342 | struct GNUNET_MESSENGER_MemberSession *session = get_member_session (member, |
343 | public_key); | ||
314 | 344 | ||
315 | if (session) | 345 | if (session) |
316 | return session; | 346 | return session; |
317 | 347 | ||
318 | session = create_member_session(member, public_key); | 348 | session = create_member_session (member, public_key); |
319 | 349 | ||
320 | if (session) | 350 | if (session) |
321 | add_member_session(member, session); | 351 | add_member_session (member, session); |
322 | 352 | ||
323 | return session; | 353 | return session; |
324 | } | 354 | } |
325 | 355 | ||
356 | |||
326 | struct GNUNET_MESSENGER_MemberSession* | 357 | struct GNUNET_MESSENGER_MemberSession* |
327 | get_member_session_of (struct GNUNET_MESSENGER_Member *member, | 358 | get_member_session_of (struct GNUNET_MESSENGER_Member *member, |
328 | const struct GNUNET_MESSENGER_Message *message, | 359 | const struct GNUNET_MESSENGER_Message *message, |
329 | const struct GNUNET_HashCode *hash) | 360 | const struct GNUNET_HashCode *hash) |
330 | { | 361 | { |
331 | GNUNET_assert ((member) && (message) && (hash) && | 362 | GNUNET_assert ((member) && (message) && (hash) && |
332 | (0 == GNUNET_memcmp(&(member->id), &(message->header.sender_id)))); | 363 | (0 == GNUNET_memcmp (&(member->id), |
364 | &(message->header.sender_id)))); | ||
333 | 365 | ||
334 | if (GNUNET_MESSENGER_KIND_INFO == message->header.kind) | 366 | if (GNUNET_MESSENGER_KIND_JOIN == message->header.kind) |
335 | return try_member_session(member, &(message->body.info.host_key)); | 367 | return try_member_session (member, &(message->body.join.key)); |
336 | else if (GNUNET_MESSENGER_KIND_JOIN == message->header.kind) | ||
337 | return try_member_session(member, &(message->body.join.key)); | ||
338 | 368 | ||
339 | struct GNUNET_MESSENGER_ClosureSearchSession search; | 369 | struct GNUNET_MESSENGER_ClosureSearchSession search; |
340 | 370 | ||
@@ -342,49 +372,59 @@ get_member_session_of (struct GNUNET_MESSENGER_Member *member, | |||
342 | search.hash = hash; | 372 | search.hash = hash; |
343 | 373 | ||
344 | search.match = NULL; | 374 | search.match = NULL; |
345 | GNUNET_CONTAINER_multihashmap_iterate(member->sessions, iterate_search_session, &search); | 375 | GNUNET_CONTAINER_multihashmap_iterate (member->sessions, |
376 | iterate_search_session, &search); | ||
346 | 377 | ||
347 | return search.match; | 378 | return search.match; |
348 | } | 379 | } |
349 | 380 | ||
381 | |||
350 | void | 382 | void |
351 | add_member_session (struct GNUNET_MESSENGER_Member *member, | 383 | add_member_session (struct GNUNET_MESSENGER_Member *member, |
352 | struct GNUNET_MESSENGER_MemberSession *session) | 384 | struct GNUNET_MESSENGER_MemberSession *session) |
353 | { | 385 | { |
354 | if (!session) | 386 | if (! session) |
355 | return; | 387 | return; |
356 | 388 | ||
357 | GNUNET_assert((member) && (session->member == member)); | 389 | GNUNET_assert ((member) && (session->member == member)); |
358 | 390 | ||
359 | const struct GNUNET_CRYPTO_PublicKey *public_key = get_member_session_public_key(session); | 391 | const struct GNUNET_CRYPTO_PublicKey *public_key = |
392 | get_member_session_public_key (session); | ||
360 | 393 | ||
361 | struct GNUNET_HashCode hash; | 394 | struct GNUNET_HashCode hash; |
362 | GNUNET_CRYPTO_hash(public_key, sizeof(*public_key), &hash); | 395 | GNUNET_CRYPTO_hash (public_key, sizeof(*public_key), &hash); |
363 | 396 | ||
364 | if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put( | 397 | if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put ( |
365 | member->sessions, &hash, session, | 398 | member->sessions, &hash, session, |
366 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)) | 399 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)) |
367 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Adding a member session failed: %s\n", | 400 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
368 | GNUNET_h2s(&hash)); | 401 | "Adding a member session failed: %s\n", |
402 | GNUNET_h2s (&hash)); | ||
369 | } | 403 | } |
370 | 404 | ||
405 | |||
371 | void | 406 | void |
372 | remove_member_session (struct GNUNET_MESSENGER_Member *member, | 407 | remove_member_session (struct GNUNET_MESSENGER_Member *member, |
373 | struct GNUNET_MESSENGER_MemberSession *session) | 408 | struct GNUNET_MESSENGER_MemberSession *session) |
374 | { | 409 | { |
375 | GNUNET_assert ((member) && (session) && (session->member == member)); | 410 | GNUNET_assert ((member) && (session) && (session->member == member)); |
376 | 411 | ||
377 | const struct GNUNET_CRYPTO_PublicKey *public_key = get_member_session_public_key(session); | 412 | const struct GNUNET_CRYPTO_PublicKey *public_key = |
413 | get_member_session_public_key (session); | ||
378 | 414 | ||
379 | struct GNUNET_HashCode hash; | 415 | struct GNUNET_HashCode hash; |
380 | GNUNET_CRYPTO_hash(public_key, sizeof(*public_key), &hash); | 416 | GNUNET_CRYPTO_hash (public_key, sizeof(*public_key), &hash); |
381 | 417 | ||
382 | if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove(member->sessions, &hash, session)) | 418 | if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (member->sessions, |
383 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Removing a member session failed: %s\n", | 419 | &hash, session)) |
384 | GNUNET_h2s(&hash)); | 420 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
421 | "Removing a member session failed: %s\n", | ||
422 | GNUNET_h2s (&hash)); | ||
385 | } | 423 | } |
386 | 424 | ||
387 | struct GNUNET_MESSENGER_ClosureIterateSessions { | 425 | |
426 | struct GNUNET_MESSENGER_ClosureIterateSessions | ||
427 | { | ||
388 | GNUNET_MESSENGER_MemberIteratorCallback it; | 428 | GNUNET_MESSENGER_MemberIteratorCallback it; |
389 | void *cls; | 429 | void *cls; |
390 | }; | 430 | }; |
@@ -397,9 +437,11 @@ iterate_member_sessions_it (void *cls, | |||
397 | struct GNUNET_MESSENGER_ClosureIterateSessions *iterate = cls; | 437 | struct GNUNET_MESSENGER_ClosureIterateSessions *iterate = cls; |
398 | struct GNUNET_MESSENGER_MemberSession *session = value; | 438 | struct GNUNET_MESSENGER_MemberSession *session = value; |
399 | 439 | ||
400 | return iterate->it (iterate->cls, get_member_session_public_key(session), session); | 440 | return iterate->it (iterate->cls, get_member_session_public_key (session), |
441 | session); | ||
401 | } | 442 | } |
402 | 443 | ||
444 | |||
403 | int | 445 | int |
404 | iterate_member_sessions (struct GNUNET_MESSENGER_Member *member, | 446 | iterate_member_sessions (struct GNUNET_MESSENGER_Member *member, |
405 | GNUNET_MESSENGER_MemberIteratorCallback it, | 447 | GNUNET_MESSENGER_MemberIteratorCallback it, |
@@ -412,5 +454,7 @@ iterate_member_sessions (struct GNUNET_MESSENGER_Member *member, | |||
412 | iterate.it = it; | 454 | iterate.it = it; |
413 | iterate.cls = cls; | 455 | iterate.cls = cls; |
414 | 456 | ||
415 | return GNUNET_CONTAINER_multihashmap_iterate(member->sessions, iterate_member_sessions_it, &iterate); | 457 | return GNUNET_CONTAINER_multihashmap_iterate (member->sessions, |
458 | iterate_member_sessions_it, | ||
459 | &iterate); | ||
416 | } | 460 | } |