diff options
Diffstat (limited to 'src/core')
-rw-r--r-- | src/core/core.h | 33 | ||||
-rw-r--r-- | src/core/core_api.c | 266 | ||||
-rw-r--r-- | src/core/gnunet-service-core.c | 527 | ||||
-rw-r--r-- | src/core/gnunet-service-core.h | 21 | ||||
-rw-r--r-- | src/core/gnunet-service-core_sessions.c | 285 | ||||
-rw-r--r-- | src/core/gnunet-service-core_sessions.h | 7 | ||||
-rw-r--r-- | src/core/test_core_api.c | 207 |
7 files changed, 542 insertions, 804 deletions
diff --git a/src/core/core.h b/src/core/core.h index bc9638706..95d506fbd 100644 --- a/src/core/core.h +++ b/src/core/core.h | |||
@@ -11,7 +11,7 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
@@ -42,23 +42,23 @@ | |||
42 | * for handlers that were specifically registered are always | 42 | * for handlers that were specifically registered are always |
43 | * transmitted to the client. | 43 | * transmitted to the client. |
44 | */ | 44 | */ |
45 | #define GNUNET_CORE_OPTION_NOTHING 0 | 45 | #define GNUNET_CORE_OPTION_NOTHING 0 |
46 | 46 | ||
47 | /** | 47 | /** |
48 | * Client cares about connectivity changes. | 48 | * Client cares about connectivity changes. |
49 | */ | 49 | */ |
50 | #define GNUNET_CORE_OPTION_SEND_STATUS_CHANGE 4 | 50 | #define GNUNET_CORE_OPTION_SEND_STATUS_CHANGE 4 |
51 | 51 | ||
52 | /** | 52 | /** |
53 | * Client wants all inbound messages in full. | 53 | * Client wants all inbound messages in full. |
54 | */ | 54 | */ |
55 | #define GNUNET_CORE_OPTION_SEND_FULL_INBOUND 8 | 55 | #define GNUNET_CORE_OPTION_SEND_FULL_INBOUND 8 |
56 | 56 | ||
57 | /** | 57 | /** |
58 | * Client just wants the 4-byte message headers of | 58 | * Client just wants the 4-byte message headers of |
59 | * all inbound messages. | 59 | * all inbound messages. |
60 | */ | 60 | */ |
61 | #define GNUNET_CORE_OPTION_SEND_HDR_INBOUND 16 | 61 | #define GNUNET_CORE_OPTION_SEND_HDR_INBOUND 16 |
62 | 62 | ||
63 | /** | 63 | /** |
64 | * Client wants all outbound messages in full. | 64 | * Client wants all outbound messages in full. |
@@ -69,7 +69,7 @@ | |||
69 | * Client just wants the 4-byte message headers of | 69 | * Client just wants the 4-byte message headers of |
70 | * all outbound messages. | 70 | * all outbound messages. |
71 | */ | 71 | */ |
72 | #define GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND 64 | 72 | #define GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND 64 |
73 | 73 | ||
74 | 74 | ||
75 | GNUNET_NETWORK_STRUCT_BEGIN | 75 | GNUNET_NETWORK_STRUCT_BEGIN |
@@ -92,7 +92,6 @@ struct InitMessage | |||
92 | * Options, see GNUNET_CORE_OPTION_ values. | 92 | * Options, see GNUNET_CORE_OPTION_ values. |
93 | */ | 93 | */ |
94 | uint32_t options GNUNET_PACKED; | 94 | uint32_t options GNUNET_PACKED; |
95 | |||
96 | }; | 95 | }; |
97 | 96 | ||
98 | 97 | ||
@@ -117,7 +116,6 @@ struct InitReplyMessage | |||
117 | * Public key of the local peer. | 116 | * Public key of the local peer. |
118 | */ | 117 | */ |
119 | struct GNUNET_PeerIdentity my_identity; | 118 | struct GNUNET_PeerIdentity my_identity; |
120 | |||
121 | }; | 119 | }; |
122 | 120 | ||
123 | 121 | ||
@@ -141,7 +139,6 @@ struct ConnectNotifyMessage | |||
141 | * Identity of the connecting peer. | 139 | * Identity of the connecting peer. |
142 | */ | 140 | */ |
143 | struct GNUNET_PeerIdentity peer; | 141 | struct GNUNET_PeerIdentity peer; |
144 | |||
145 | }; | 142 | }; |
146 | 143 | ||
147 | 144 | ||
@@ -165,7 +162,6 @@ struct DisconnectNotifyMessage | |||
165 | * Identity of the connecting peer. | 162 | * Identity of the connecting peer. |
166 | */ | 163 | */ |
167 | struct GNUNET_PeerIdentity peer; | 164 | struct GNUNET_PeerIdentity peer; |
168 | |||
169 | }; | 165 | }; |
170 | 166 | ||
171 | 167 | ||
@@ -236,7 +232,6 @@ struct SendMessageRequest | |||
236 | * Counter for this peer to match SMRs to replies. | 232 | * Counter for this peer to match SMRs to replies. |
237 | */ | 233 | */ |
238 | uint16_t smr_id GNUNET_PACKED; | 234 | uint16_t smr_id GNUNET_PACKED; |
239 | |||
240 | }; | 235 | }; |
241 | 236 | ||
242 | 237 | ||
@@ -269,7 +264,6 @@ struct SendMessageReady | |||
269 | * Identity of the intended target. | 264 | * Identity of the intended target. |
270 | */ | 265 | */ |
271 | struct GNUNET_PeerIdentity peer; | 266 | struct GNUNET_PeerIdentity peer; |
272 | |||
273 | }; | 267 | }; |
274 | 268 | ||
275 | 269 | ||
@@ -285,7 +279,8 @@ struct SendMessage | |||
285 | struct GNUNET_MessageHeader header; | 279 | struct GNUNET_MessageHeader header; |
286 | 280 | ||
287 | /** | 281 | /** |
288 | * How important is this message? | 282 | * How important is this message? Contains a |
283 | * `enum GNUNET_MQ_PriorityPreferences` in NBO. | ||
289 | */ | 284 | */ |
290 | uint32_t priority GNUNET_PACKED; | 285 | uint32_t priority GNUNET_PACKED; |
291 | 286 | ||
@@ -299,17 +294,6 @@ struct SendMessage | |||
299 | * Identity of the intended receiver. | 294 | * Identity of the intended receiver. |
300 | */ | 295 | */ |
301 | struct GNUNET_PeerIdentity peer; | 296 | struct GNUNET_PeerIdentity peer; |
302 | |||
303 | /** | ||
304 | * #GNUNET_YES if corking is allowed, #GNUNET_NO if not. | ||
305 | */ | ||
306 | uint32_t cork GNUNET_PACKED; | ||
307 | |||
308 | /** | ||
309 | * Always 0. | ||
310 | */ | ||
311 | uint32_t reserved GNUNET_PACKED; | ||
312 | |||
313 | }; | 297 | }; |
314 | 298 | ||
315 | 299 | ||
@@ -338,7 +322,6 @@ struct MonitorNotifyMessage | |||
338 | * How long will we stay in this state (if nothing else happens)? | 322 | * How long will we stay in this state (if nothing else happens)? |
339 | */ | 323 | */ |
340 | struct GNUNET_TIME_AbsoluteNBO timeout; | 324 | struct GNUNET_TIME_AbsoluteNBO timeout; |
341 | |||
342 | }; | 325 | }; |
343 | 326 | ||
344 | 327 | ||
diff --git a/src/core/core_api.c b/src/core/core_api.c index 6adaadabf..6381d9097 100644 --- a/src/core/core_api.c +++ b/src/core/core_api.c | |||
@@ -11,7 +11,7 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
@@ -29,7 +29,7 @@ | |||
29 | #include "gnunet_core_service.h" | 29 | #include "gnunet_core_service.h" |
30 | #include "core.h" | 30 | #include "core.h" |
31 | 31 | ||
32 | #define LOG(kind,...) GNUNET_log_from (kind, "core-api",__VA_ARGS__) | 32 | #define LOG(kind, ...) GNUNET_log_from (kind, "core-api", __VA_ARGS__) |
33 | 33 | ||
34 | 34 | ||
35 | /** | 35 | /** |
@@ -69,7 +69,6 @@ struct PeerRecord | |||
69 | * SendMessageRequest ID generator for this peer. | 69 | * SendMessageRequest ID generator for this peer. |
70 | */ | 70 | */ |
71 | uint16_t smr_id_gen; | 71 | uint16_t smr_id_gen; |
72 | |||
73 | }; | 72 | }; |
74 | 73 | ||
75 | 74 | ||
@@ -144,7 +143,6 @@ struct GNUNET_CORE_Handle | |||
144 | * Did we ever get INIT? | 143 | * Did we ever get INIT? |
145 | */ | 144 | */ |
146 | int have_init; | 145 | int have_init; |
147 | |||
148 | }; | 146 | }; |
149 | 147 | ||
150 | 148 | ||
@@ -170,8 +168,7 @@ reconnect_task (void *cls) | |||
170 | struct GNUNET_CORE_Handle *h = cls; | 168 | struct GNUNET_CORE_Handle *h = cls; |
171 | 169 | ||
172 | h->reconnect_task = NULL; | 170 | h->reconnect_task = NULL; |
173 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 171 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to CORE service after delay\n"); |
174 | "Connecting to CORE service after delay\n"); | ||
175 | reconnect (h); | 172 | reconnect (h); |
176 | } | 173 | } |
177 | 174 | ||
@@ -187,7 +184,7 @@ reconnect_task (void *cls) | |||
187 | */ | 184 | */ |
188 | static int | 185 | static int |
189 | disconnect_and_free_peer_entry (void *cls, | 186 | disconnect_and_free_peer_entry (void *cls, |
190 | const struct GNUNET_PeerIdentity *key, | 187 | const struct GNUNET_PeerIdentity *key, |
191 | void *value) | 188 | void *value) |
192 | { | 189 | { |
193 | struct GNUNET_CORE_Handle *h = cls; | 190 | struct GNUNET_CORE_Handle *h = cls; |
@@ -195,13 +192,9 @@ disconnect_and_free_peer_entry (void *cls, | |||
195 | 192 | ||
196 | GNUNET_assert (pr->h == h); | 193 | GNUNET_assert (pr->h == h); |
197 | if (NULL != h->disconnects) | 194 | if (NULL != h->disconnects) |
198 | h->disconnects (h->cls, | 195 | h->disconnects (h->cls, &pr->peer, pr->client_cls); |
199 | &pr->peer, | ||
200 | pr->client_cls); | ||
201 | GNUNET_assert (GNUNET_YES == | 196 | GNUNET_assert (GNUNET_YES == |
202 | GNUNET_CONTAINER_multipeermap_remove (h->peers, | 197 | GNUNET_CONTAINER_multipeermap_remove (h->peers, key, pr)); |
203 | key, | ||
204 | pr)); | ||
205 | GNUNET_MQ_destroy (pr->mq); | 198 | GNUNET_MQ_destroy (pr->mq); |
206 | GNUNET_assert (NULL == pr->mq); | 199 | GNUNET_assert (NULL == pr->mq); |
207 | if (NULL != pr->env) | 200 | if (NULL != pr->env) |
@@ -231,9 +224,7 @@ reconnect_later (struct GNUNET_CORE_Handle *h) | |||
231 | } | 224 | } |
232 | GNUNET_assert (NULL == h->reconnect_task); | 225 | GNUNET_assert (NULL == h->reconnect_task); |
233 | h->reconnect_task = | 226 | h->reconnect_task = |
234 | GNUNET_SCHEDULER_add_delayed (h->retry_backoff, | 227 | GNUNET_SCHEDULER_add_delayed (h->retry_backoff, &reconnect_task, h); |
235 | &reconnect_task, | ||
236 | h); | ||
237 | GNUNET_CONTAINER_multipeermap_iterate (h->peers, | 228 | GNUNET_CONTAINER_multipeermap_iterate (h->peers, |
238 | &disconnect_and_free_peer_entry, | 229 | &disconnect_and_free_peer_entry, |
239 | h); | 230 | h); |
@@ -249,39 +240,16 @@ reconnect_later (struct GNUNET_CORE_Handle *h) | |||
249 | * @param error error code | 240 | * @param error error code |
250 | */ | 241 | */ |
251 | static void | 242 | static void |
252 | handle_mq_error (void *cls, | 243 | handle_mq_error (void *cls, enum GNUNET_MQ_Error error) |
253 | enum GNUNET_MQ_Error error) | ||
254 | { | 244 | { |
255 | struct GNUNET_CORE_Handle *h = cls; | 245 | struct GNUNET_CORE_Handle *h = cls; |
256 | 246 | ||
257 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 247 | LOG (GNUNET_ERROR_TYPE_DEBUG, "MQ ERROR: %d\n", error); |
258 | "MQ ERROR: %d\n", | ||
259 | error); | ||
260 | reconnect_later (h); | 248 | reconnect_later (h); |
261 | } | 249 | } |
262 | 250 | ||
263 | 251 | ||
264 | /** | 252 | /** |
265 | * Inquire with CORE what options should be set for a message | ||
266 | * so that it is transmitted with the given @a priority and | ||
267 | * the given @a cork value. | ||
268 | * | ||
269 | * @param cork desired corking | ||
270 | * @param priority desired message priority | ||
271 | * @param[out] flags set to `flags` value for #GNUNET_MQ_set_options() | ||
272 | * @return `extra` argument to give to #GNUNET_MQ_set_options() | ||
273 | */ | ||
274 | const void * | ||
275 | GNUNET_CORE_get_mq_options (int cork, | ||
276 | enum GNUNET_CORE_Priority priority, | ||
277 | uint64_t *flags) | ||
278 | { | ||
279 | *flags = ((uint64_t) priority) + (((uint64_t) cork) << 32); | ||
280 | return NULL; | ||
281 | } | ||
282 | |||
283 | |||
284 | /** | ||
285 | * Implement sending functionality of a message queue for | 253 | * Implement sending functionality of a message queue for |
286 | * us sending messages to a peer. | 254 | * us sending messages to a peer. |
287 | * | 255 | * |
@@ -291,8 +259,8 @@ GNUNET_CORE_get_mq_options (int cork, | |||
291 | */ | 259 | */ |
292 | static void | 260 | static void |
293 | core_mq_send_impl (struct GNUNET_MQ_Handle *mq, | 261 | core_mq_send_impl (struct GNUNET_MQ_Handle *mq, |
294 | const struct GNUNET_MessageHeader *msg, | 262 | const struct GNUNET_MessageHeader *msg, |
295 | void *impl_state) | 263 | void *impl_state) |
296 | { | 264 | { |
297 | struct PeerRecord *pr = impl_state; | 265 | struct PeerRecord *pr = impl_state; |
298 | struct GNUNET_CORE_Handle *h = pr->h; | 266 | struct GNUNET_CORE_Handle *h = pr->h; |
@@ -300,9 +268,7 @@ core_mq_send_impl (struct GNUNET_MQ_Handle *mq, | |||
300 | struct SendMessage *sm; | 268 | struct SendMessage *sm; |
301 | struct GNUNET_MQ_Envelope *env; | 269 | struct GNUNET_MQ_Envelope *env; |
302 | uint16_t msize; | 270 | uint16_t msize; |
303 | uint64_t flags; | 271 | enum GNUNET_MQ_PriorityPreferences flags; |
304 | int cork; | ||
305 | enum GNUNET_CORE_Priority priority; | ||
306 | 272 | ||
307 | if (NULL == h->mq) | 273 | if (NULL == h->mq) |
308 | { | 274 | { |
@@ -313,11 +279,7 @@ core_mq_send_impl (struct GNUNET_MQ_Handle *mq, | |||
313 | GNUNET_assert (NULL == pr->env); | 279 | GNUNET_assert (NULL == pr->env); |
314 | /* extract options from envelope */ | 280 | /* extract options from envelope */ |
315 | env = GNUNET_MQ_get_current_envelope (mq); | 281 | env = GNUNET_MQ_get_current_envelope (mq); |
316 | GNUNET_break (NULL == | 282 | flags = GNUNET_MQ_env_get_options (env); |
317 | GNUNET_MQ_env_get_options (env, | ||
318 | &flags)); | ||
319 | cork = (int) (flags >> 32); | ||
320 | priority = (uint32_t) flags; | ||
321 | 283 | ||
322 | /* check message size for sanity */ | 284 | /* check message size for sanity */ |
323 | msize = ntohs (msg->size); | 285 | msize = ntohs (msg->size); |
@@ -333,28 +295,20 @@ core_mq_send_impl (struct GNUNET_MQ_Handle *mq, | |||
333 | "Asking core for transmission of %u bytes to `%s'\n", | 295 | "Asking core for transmission of %u bytes to `%s'\n", |
334 | (unsigned int) msize, | 296 | (unsigned int) msize, |
335 | GNUNET_i2s (&pr->peer)); | 297 | GNUNET_i2s (&pr->peer)); |
336 | env = GNUNET_MQ_msg (smr, | 298 | env = GNUNET_MQ_msg (smr, GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST); |
337 | GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST); | 299 | smr->priority = htonl ((uint32_t) flags); |
338 | smr->priority = htonl ((uint32_t) priority); | ||
339 | smr->peer = pr->peer; | 300 | smr->peer = pr->peer; |
340 | smr->reserved = htonl (0); | ||
341 | smr->size = htons (msize); | 301 | smr->size = htons (msize); |
342 | smr->smr_id = htons (++pr->smr_id_gen); | 302 | smr->smr_id = htons (++pr->smr_id_gen); |
343 | GNUNET_MQ_send (h->mq, | 303 | GNUNET_MQ_send (h->mq, env); |
344 | env); | ||
345 | 304 | ||
346 | /* prepare message with actual transmission data */ | 305 | /* prepare message with actual transmission data */ |
347 | pr->env = GNUNET_MQ_msg_nested_mh (sm, | 306 | pr->env = GNUNET_MQ_msg_nested_mh (sm, GNUNET_MESSAGE_TYPE_CORE_SEND, msg); |
348 | GNUNET_MESSAGE_TYPE_CORE_SEND, | 307 | sm->priority = htonl ((uint32_t) flags); |
349 | msg); | ||
350 | sm->priority = htonl ((uint32_t) priority); | ||
351 | sm->peer = pr->peer; | 308 | sm->peer = pr->peer; |
352 | sm->cork = htonl ((uint32_t) cork); | ||
353 | sm->reserved = htonl (0); | ||
354 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 309 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
355 | "Calling get_message with buffer of %u bytes (%s)\n", | 310 | "Calling get_message with buffer of %u bytes\n", |
356 | (unsigned int) msize, | 311 | (unsigned int) msize); |
357 | cork ? "corked" : "uncorked"); | ||
358 | } | 312 | } |
359 | 313 | ||
360 | 314 | ||
@@ -366,8 +320,7 @@ core_mq_send_impl (struct GNUNET_MQ_Handle *mq, | |||
366 | * @param impl_state state of the implementation | 320 | * @param impl_state state of the implementation |
367 | */ | 321 | */ |
368 | static void | 322 | static void |
369 | core_mq_destroy_impl (struct GNUNET_MQ_Handle *mq, | 323 | core_mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state) |
370 | void *impl_state) | ||
371 | { | 324 | { |
372 | struct PeerRecord *pr = impl_state; | 325 | struct PeerRecord *pr = impl_state; |
373 | 326 | ||
@@ -384,8 +337,7 @@ core_mq_destroy_impl (struct GNUNET_MQ_Handle *mq, | |||
384 | * @param impl_state state specific to the implementation | 337 | * @param impl_state state specific to the implementation |
385 | */ | 338 | */ |
386 | static void | 339 | static void |
387 | core_mq_cancel_impl (struct GNUNET_MQ_Handle *mq, | 340 | core_mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state) |
388 | void *impl_state) | ||
389 | { | 341 | { |
390 | struct PeerRecord *pr = impl_state; | 342 | struct PeerRecord *pr = impl_state; |
391 | 343 | ||
@@ -404,8 +356,7 @@ core_mq_cancel_impl (struct GNUNET_MQ_Handle *mq, | |||
404 | * @param error error code | 356 | * @param error error code |
405 | */ | 357 | */ |
406 | static void | 358 | static void |
407 | core_mq_error_handler (void *cls, | 359 | core_mq_error_handler (void *cls, enum GNUNET_MQ_Error error) |
408 | enum GNUNET_MQ_Error error) | ||
409 | { | 360 | { |
410 | /* struct PeerRecord *pr = cls; */ | 361 | /* struct PeerRecord *pr = cls; */ |
411 | 362 | ||
@@ -423,41 +374,30 @@ core_mq_error_handler (void *cls, | |||
423 | */ | 374 | */ |
424 | static void | 375 | static void |
425 | connect_peer (struct GNUNET_CORE_Handle *h, | 376 | connect_peer (struct GNUNET_CORE_Handle *h, |
426 | const struct GNUNET_PeerIdentity *peer) | 377 | const struct GNUNET_PeerIdentity *peer) |
427 | { | 378 | { |
428 | struct PeerRecord *pr; | 379 | struct PeerRecord *pr; |
429 | uint64_t flags; | ||
430 | const void *extra; | ||
431 | 380 | ||
432 | pr = GNUNET_new (struct PeerRecord); | 381 | pr = GNUNET_new (struct PeerRecord); |
433 | pr->peer = *peer; | 382 | pr->peer = *peer; |
434 | pr->h = h; | 383 | pr->h = h; |
435 | GNUNET_assert (GNUNET_YES == | 384 | GNUNET_assert (GNUNET_YES == |
436 | GNUNET_CONTAINER_multipeermap_put (h->peers, | 385 | GNUNET_CONTAINER_multipeermap_put ( |
437 | &pr->peer, | 386 | h->peers, |
438 | pr, | 387 | &pr->peer, |
439 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 388 | pr, |
389 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | ||
440 | pr->mq = GNUNET_MQ_queue_for_callbacks (&core_mq_send_impl, | 390 | pr->mq = GNUNET_MQ_queue_for_callbacks (&core_mq_send_impl, |
441 | &core_mq_destroy_impl, | 391 | &core_mq_destroy_impl, |
442 | &core_mq_cancel_impl, | 392 | &core_mq_cancel_impl, |
443 | pr, | 393 | pr, |
444 | h->handlers, | 394 | h->handlers, |
445 | &core_mq_error_handler, | 395 | &core_mq_error_handler, |
446 | pr); | 396 | pr); |
447 | /* get our default options */ | ||
448 | extra = GNUNET_CORE_get_mq_options (GNUNET_NO, | ||
449 | GNUNET_CORE_PRIO_BEST_EFFORT, | ||
450 | &flags); | ||
451 | GNUNET_MQ_set_options (pr->mq, | ||
452 | flags, | ||
453 | extra); | ||
454 | if (NULL != h->connects) | 397 | if (NULL != h->connects) |
455 | { | 398 | { |
456 | pr->client_cls = h->connects (h->cls, | 399 | pr->client_cls = h->connects (h->cls, &pr->peer, pr->mq); |
457 | &pr->peer, | 400 | GNUNET_MQ_set_handlers_closure (pr->mq, pr->client_cls); |
458 | pr->mq); | ||
459 | GNUNET_MQ_set_handlers_closure (pr->mq, | ||
460 | pr->client_cls); | ||
461 | } | 401 | } |
462 | } | 402 | } |
463 | 403 | ||
@@ -471,8 +411,7 @@ connect_peer (struct GNUNET_CORE_Handle *h, | |||
471 | * @param m the init reply | 411 | * @param m the init reply |
472 | */ | 412 | */ |
473 | static void | 413 | static void |
474 | handle_init_reply (void *cls, | 414 | handle_init_reply (void *cls, const struct InitReplyMessage *m) |
475 | const struct InitReplyMessage *m) | ||
476 | { | 415 | { |
477 | struct GNUNET_CORE_Handle *h = cls; | 416 | struct GNUNET_CORE_Handle *h = cls; |
478 | GNUNET_CORE_StartupCallback init; | 417 | GNUNET_CORE_StartupCallback init; |
@@ -488,8 +427,7 @@ handle_init_reply (void *cls, | |||
488 | "Connected to core service of peer `%s'.\n", | 427 | "Connected to core service of peer `%s'.\n", |
489 | GNUNET_i2s (&h->me)); | 428 | GNUNET_i2s (&h->me)); |
490 | h->have_init = GNUNET_YES; | 429 | h->have_init = GNUNET_YES; |
491 | init (h->cls, | 430 | init (h->cls, &h->me); |
492 | &h->me); | ||
493 | } | 431 | } |
494 | else | 432 | else |
495 | { | 433 | { |
@@ -508,8 +446,7 @@ handle_init_reply (void *cls, | |||
508 | } | 446 | } |
509 | } | 447 | } |
510 | /* fake 'connect to self' */ | 448 | /* fake 'connect to self' */ |
511 | connect_peer (h, | 449 | connect_peer (h, &h->me); |
512 | &h->me); | ||
513 | } | 450 | } |
514 | 451 | ||
515 | 452 | ||
@@ -521,8 +458,7 @@ handle_init_reply (void *cls, | |||
521 | * @param cnm the connect message | 458 | * @param cnm the connect message |
522 | */ | 459 | */ |
523 | static void | 460 | static void |
524 | handle_connect_notify (void *cls, | 461 | handle_connect_notify (void *cls, const struct ConnectNotifyMessage *cnm) |
525 | const struct ConnectNotifyMessage *cnm) | ||
526 | { | 462 | { |
527 | struct GNUNET_CORE_Handle *h = cls; | 463 | struct GNUNET_CORE_Handle *h = cls; |
528 | struct PeerRecord *pr; | 464 | struct PeerRecord *pr; |
@@ -530,24 +466,20 @@ handle_connect_notify (void *cls, | |||
530 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 466 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
531 | "Received notification about connection from `%s'.\n", | 467 | "Received notification about connection from `%s'.\n", |
532 | GNUNET_i2s (&cnm->peer)); | 468 | GNUNET_i2s (&cnm->peer)); |
533 | if (0 == memcmp (&h->me, | 469 | if (0 == memcmp (&h->me, &cnm->peer, sizeof (struct GNUNET_PeerIdentity))) |
534 | &cnm->peer, | ||
535 | sizeof (struct GNUNET_PeerIdentity))) | ||
536 | { | 470 | { |
537 | /* connect to self!? */ | 471 | /* connect to self!? */ |
538 | GNUNET_break (0); | 472 | GNUNET_break (0); |
539 | return; | 473 | return; |
540 | } | 474 | } |
541 | pr = GNUNET_CONTAINER_multipeermap_get (h->peers, | 475 | pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &cnm->peer); |
542 | &cnm->peer); | ||
543 | if (NULL != pr) | 476 | if (NULL != pr) |
544 | { | 477 | { |
545 | GNUNET_break (0); | 478 | GNUNET_break (0); |
546 | reconnect_later (h); | 479 | reconnect_later (h); |
547 | return; | 480 | return; |
548 | } | 481 | } |
549 | connect_peer (h, | 482 | connect_peer (h, &cnm->peer); |
550 | &cnm->peer); | ||
551 | } | 483 | } |
552 | 484 | ||
553 | 485 | ||
@@ -559,15 +491,12 @@ handle_connect_notify (void *cls, | |||
559 | * @param dnm message about the disconnect event | 491 | * @param dnm message about the disconnect event |
560 | */ | 492 | */ |
561 | static void | 493 | static void |
562 | handle_disconnect_notify (void *cls, | 494 | handle_disconnect_notify (void *cls, const struct DisconnectNotifyMessage *dnm) |
563 | const struct DisconnectNotifyMessage *dnm) | ||
564 | { | 495 | { |
565 | struct GNUNET_CORE_Handle *h = cls; | 496 | struct GNUNET_CORE_Handle *h = cls; |
566 | struct PeerRecord *pr; | 497 | struct PeerRecord *pr; |
567 | 498 | ||
568 | if (0 == memcmp (&h->me, | 499 | if (0 == memcmp (&h->me, &dnm->peer, sizeof (struct GNUNET_PeerIdentity))) |
569 | &dnm->peer, | ||
570 | sizeof (struct GNUNET_PeerIdentity))) | ||
571 | { | 500 | { |
572 | /* disconnect from self!? */ | 501 | /* disconnect from self!? */ |
573 | GNUNET_break (0); | 502 | GNUNET_break (0); |
@@ -577,17 +506,14 @@ handle_disconnect_notify (void *cls, | |||
577 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 506 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
578 | "Received notification about disconnect from `%s'.\n", | 507 | "Received notification about disconnect from `%s'.\n", |
579 | GNUNET_i2s (&dnm->peer)); | 508 | GNUNET_i2s (&dnm->peer)); |
580 | pr = GNUNET_CONTAINER_multipeermap_get (h->peers, | 509 | pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &dnm->peer); |
581 | &dnm->peer); | ||
582 | if (NULL == pr) | 510 | if (NULL == pr) |
583 | { | 511 | { |
584 | GNUNET_break (0); | 512 | GNUNET_break (0); |
585 | reconnect_later (h); | 513 | reconnect_later (h); |
586 | return; | 514 | return; |
587 | } | 515 | } |
588 | disconnect_and_free_peer_entry (h, | 516 | disconnect_and_free_peer_entry (h, &pr->peer, pr); |
589 | &pr->peer, | ||
590 | pr); | ||
591 | } | 517 | } |
592 | 518 | ||
593 | 519 | ||
@@ -599,8 +525,7 @@ handle_disconnect_notify (void *cls, | |||
599 | * @return #GNUNET_OK if the message is well-formed | 525 | * @return #GNUNET_OK if the message is well-formed |
600 | */ | 526 | */ |
601 | static int | 527 | static int |
602 | check_notify_inbound (void *cls, | 528 | check_notify_inbound (void *cls, const struct NotifyTrafficMessage *ntm) |
603 | const struct NotifyTrafficMessage *ntm) | ||
604 | { | 529 | { |
605 | uint16_t msize; | 530 | uint16_t msize; |
606 | const struct GNUNET_MessageHeader *em; | 531 | const struct GNUNET_MessageHeader *em; |
@@ -629,8 +554,7 @@ check_notify_inbound (void *cls, | |||
629 | * @param ntm the message we got from CORE. | 554 | * @param ntm the message we got from CORE. |
630 | */ | 555 | */ |
631 | static void | 556 | static void |
632 | handle_notify_inbound (void *cls, | 557 | handle_notify_inbound (void *cls, const struct NotifyTrafficMessage *ntm) |
633 | const struct NotifyTrafficMessage *ntm) | ||
634 | { | 558 | { |
635 | struct GNUNET_CORE_Handle *h = cls; | 559 | struct GNUNET_CORE_Handle *h = cls; |
636 | const struct GNUNET_MessageHeader *em; | 560 | const struct GNUNET_MessageHeader *em; |
@@ -640,16 +564,14 @@ handle_notify_inbound (void *cls, | |||
640 | "Received inbound message from `%s'.\n", | 564 | "Received inbound message from `%s'.\n", |
641 | GNUNET_i2s (&ntm->peer)); | 565 | GNUNET_i2s (&ntm->peer)); |
642 | em = (const struct GNUNET_MessageHeader *) &ntm[1]; | 566 | em = (const struct GNUNET_MessageHeader *) &ntm[1]; |
643 | pr = GNUNET_CONTAINER_multipeermap_get (h->peers, | 567 | pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &ntm->peer); |
644 | &ntm->peer); | ||
645 | if (NULL == pr) | 568 | if (NULL == pr) |
646 | { | 569 | { |
647 | GNUNET_break (0); | 570 | GNUNET_break (0); |
648 | reconnect_later (h); | 571 | reconnect_later (h); |
649 | return; | 572 | return; |
650 | } | 573 | } |
651 | GNUNET_MQ_inject_message (pr->mq, | 574 | GNUNET_MQ_inject_message (pr->mq, em); |
652 | em); | ||
653 | } | 575 | } |
654 | 576 | ||
655 | 577 | ||
@@ -662,14 +584,12 @@ handle_notify_inbound (void *cls, | |||
662 | * @param smr the message we got | 584 | * @param smr the message we got |
663 | */ | 585 | */ |
664 | static void | 586 | static void |
665 | handle_send_ready (void *cls, | 587 | handle_send_ready (void *cls, const struct SendMessageReady *smr) |
666 | const struct SendMessageReady *smr) | ||
667 | { | 588 | { |
668 | struct GNUNET_CORE_Handle *h = cls; | 589 | struct GNUNET_CORE_Handle *h = cls; |
669 | struct PeerRecord *pr; | 590 | struct PeerRecord *pr; |
670 | 591 | ||
671 | pr = GNUNET_CONTAINER_multipeermap_get (h->peers, | 592 | pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &smr->peer); |
672 | &smr->peer); | ||
673 | if (NULL == pr) | 593 | if (NULL == pr) |
674 | { | 594 | { |
675 | GNUNET_break (0); | 595 | GNUNET_break (0); |
@@ -693,8 +613,7 @@ handle_send_ready (void *cls, | |||
693 | } | 613 | } |
694 | 614 | ||
695 | /* ok, all good, send message out! */ | 615 | /* ok, all good, send message out! */ |
696 | GNUNET_MQ_send (h->mq, | 616 | GNUNET_MQ_send (h->mq, pr->env); |
697 | pr->env); | ||
698 | pr->env = NULL; | 617 | pr->env = NULL; |
699 | GNUNET_MQ_impl_send_continue (pr->mq); | 618 | GNUNET_MQ_impl_send_continue (pr->mq); |
700 | } | 619 | } |
@@ -709,39 +628,34 @@ handle_send_ready (void *cls, | |||
709 | static void | 628 | static void |
710 | reconnect (struct GNUNET_CORE_Handle *h) | 629 | reconnect (struct GNUNET_CORE_Handle *h) |
711 | { | 630 | { |
712 | struct GNUNET_MQ_MessageHandler handlers[] = { | 631 | struct GNUNET_MQ_MessageHandler handlers[] = |
713 | GNUNET_MQ_hd_fixed_size (init_reply, | 632 | {GNUNET_MQ_hd_fixed_size (init_reply, |
714 | GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY, | 633 | GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY, |
715 | struct InitReplyMessage, | 634 | struct InitReplyMessage, |
716 | h), | 635 | h), |
717 | GNUNET_MQ_hd_fixed_size (connect_notify, | 636 | GNUNET_MQ_hd_fixed_size (connect_notify, |
718 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT, | 637 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT, |
719 | struct ConnectNotifyMessage, | 638 | struct ConnectNotifyMessage, |
720 | h), | 639 | h), |
721 | GNUNET_MQ_hd_fixed_size (disconnect_notify, | 640 | GNUNET_MQ_hd_fixed_size (disconnect_notify, |
722 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT, | 641 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT, |
723 | struct DisconnectNotifyMessage, | 642 | struct DisconnectNotifyMessage, |
724 | h), | 643 | h), |
725 | GNUNET_MQ_hd_var_size (notify_inbound, | 644 | GNUNET_MQ_hd_var_size (notify_inbound, |
726 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND, | 645 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND, |
727 | struct NotifyTrafficMessage, | 646 | struct NotifyTrafficMessage, |
728 | h), | 647 | h), |
729 | GNUNET_MQ_hd_fixed_size (send_ready, | 648 | GNUNET_MQ_hd_fixed_size (send_ready, |
730 | GNUNET_MESSAGE_TYPE_CORE_SEND_READY, | 649 | GNUNET_MESSAGE_TYPE_CORE_SEND_READY, |
731 | struct SendMessageReady, | 650 | struct SendMessageReady, |
732 | h), | 651 | h), |
733 | GNUNET_MQ_handler_end () | 652 | GNUNET_MQ_handler_end ()}; |
734 | }; | ||
735 | struct InitMessage *init; | 653 | struct InitMessage *init; |
736 | struct GNUNET_MQ_Envelope *env; | 654 | struct GNUNET_MQ_Envelope *env; |
737 | uint16_t *ts; | 655 | uint16_t *ts; |
738 | 656 | ||
739 | GNUNET_assert (NULL == h->mq); | 657 | GNUNET_assert (NULL == h->mq); |
740 | h->mq = GNUNET_CLIENT_connect (h->cfg, | 658 | h->mq = GNUNET_CLIENT_connect (h->cfg, "core", handlers, &handle_mq_error, h); |
741 | "core", | ||
742 | handlers, | ||
743 | &handle_mq_error, | ||
744 | h); | ||
745 | if (NULL == h->mq) | 659 | if (NULL == h->mq) |
746 | { | 660 | { |
747 | reconnect_later (h); | 661 | reconnect_later (h); |
@@ -750,14 +664,12 @@ reconnect (struct GNUNET_CORE_Handle *h) | |||
750 | env = GNUNET_MQ_msg_extra (init, | 664 | env = GNUNET_MQ_msg_extra (init, |
751 | sizeof (uint16_t) * h->hcnt, | 665 | sizeof (uint16_t) * h->hcnt, |
752 | GNUNET_MESSAGE_TYPE_CORE_INIT); | 666 | GNUNET_MESSAGE_TYPE_CORE_INIT); |
753 | LOG (GNUNET_ERROR_TYPE_INFO, | 667 | LOG (GNUNET_ERROR_TYPE_INFO, "(Re)connecting to CORE service\n"); |
754 | "(Re)connecting to CORE service\n"); | ||
755 | init->options = htonl (0); | 668 | init->options = htonl (0); |
756 | ts = (uint16_t *) &init[1]; | 669 | ts = (uint16_t *) &init[1]; |
757 | for (unsigned int hpos = 0; hpos < h->hcnt; hpos++) | 670 | for (unsigned int hpos = 0; hpos < h->hcnt; hpos++) |
758 | ts[hpos] = htons (h->handlers[hpos].type); | 671 | ts[hpos] = htons (h->handlers[hpos].type); |
759 | GNUNET_MQ_send (h->mq, | 672 | GNUNET_MQ_send (h->mq, env); |
760 | env); | ||
761 | } | 673 | } |
762 | 674 | ||
763 | 675 | ||
@@ -791,15 +703,13 @@ GNUNET_CORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
791 | h->init = init; | 703 | h->init = init; |
792 | h->connects = connects; | 704 | h->connects = connects; |
793 | h->disconnects = disconnects; | 705 | h->disconnects = disconnects; |
794 | h->peers = GNUNET_CONTAINER_multipeermap_create (128, | 706 | h->peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO); |
795 | GNUNET_NO); | ||
796 | h->handlers = GNUNET_MQ_copy_handlers (handlers); | 707 | h->handlers = GNUNET_MQ_copy_handlers (handlers); |
797 | h->hcnt = GNUNET_MQ_count_handlers (handlers); | 708 | h->hcnt = GNUNET_MQ_count_handlers (handlers); |
798 | GNUNET_assert (h->hcnt < | 709 | GNUNET_assert (h->hcnt < |
799 | (GNUNET_MAX_MESSAGE_SIZE - | 710 | (GNUNET_MAX_MESSAGE_SIZE - sizeof (struct InitMessage)) / |
800 | sizeof (struct InitMessage)) / sizeof (uint16_t)); | 711 | sizeof (uint16_t)); |
801 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 712 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to CORE service\n"); |
802 | "Connecting to CORE service\n"); | ||
803 | reconnect (h); | 713 | reconnect (h); |
804 | if (NULL == h->mq) | 714 | if (NULL == h->mq) |
805 | { | 715 | { |
@@ -818,8 +728,7 @@ GNUNET_CORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
818 | void | 728 | void |
819 | GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle) | 729 | GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle) |
820 | { | 730 | { |
821 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 731 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from CORE service\n"); |
822 | "Disconnecting from CORE service\n"); | ||
823 | GNUNET_CONTAINER_multipeermap_iterate (handle->peers, | 732 | GNUNET_CONTAINER_multipeermap_iterate (handle->peers, |
824 | &disconnect_and_free_peer_entry, | 733 | &disconnect_and_free_peer_entry, |
825 | handle); | 734 | handle); |
@@ -849,12 +758,11 @@ GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle) | |||
849 | */ | 758 | */ |
850 | struct GNUNET_MQ_Handle * | 759 | struct GNUNET_MQ_Handle * |
851 | GNUNET_CORE_get_mq (const struct GNUNET_CORE_Handle *h, | 760 | GNUNET_CORE_get_mq (const struct GNUNET_CORE_Handle *h, |
852 | const struct GNUNET_PeerIdentity *pid) | 761 | const struct GNUNET_PeerIdentity *pid) |
853 | { | 762 | { |
854 | struct PeerRecord *pr; | 763 | struct PeerRecord *pr; |
855 | 764 | ||
856 | pr = GNUNET_CONTAINER_multipeermap_get (h->peers, | 765 | pr = GNUNET_CONTAINER_multipeermap_get (h->peers, pid); |
857 | pid); | ||
858 | if (NULL == pr) | 766 | if (NULL == pr) |
859 | return NULL; | 767 | return NULL; |
860 | return pr->mq; | 768 | return pr->mq; |
diff --git a/src/core/gnunet-service-core.c b/src/core/gnunet-service-core.c index e26bb4d5c..740707ce1 100644 --- a/src/core/gnunet-service-core.c +++ b/src/core/gnunet-service-core.c | |||
@@ -11,7 +11,7 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
@@ -107,7 +107,6 @@ struct GSC_Client | |||
107 | * specifically cares about. Size of the @e types array. | 107 | * specifically cares about. Size of the @e types array. |
108 | */ | 108 | */ |
109 | unsigned int tcnt; | 109 | unsigned int tcnt; |
110 | |||
111 | }; | 110 | }; |
112 | 111 | ||
113 | 112 | ||
@@ -150,12 +149,10 @@ static struct GSC_Client *client_tail; | |||
150 | * @return #GNUNET_YES if @a c is interested, #GNUNET_NO if not. | 149 | * @return #GNUNET_YES if @a c is interested, #GNUNET_NO if not. |
151 | */ | 150 | */ |
152 | static int | 151 | static int |
153 | type_match (uint16_t type, | 152 | type_match (uint16_t type, struct GSC_Client *c) |
154 | struct GSC_Client *c) | ||
155 | { | 153 | { |
156 | if ( (0 == c->tcnt) && | 154 | if ((0 == c->tcnt) && (0 != c->options)) |
157 | (0 != c->options) ) | 155 | return GNUNET_YES; /* peer without handlers and inbound/outbond |
158 | return GNUNET_YES; /* peer without handlers and inbound/outbond | ||
159 | callbacks matches ALL */ | 156 | callbacks matches ALL */ |
160 | if (NULL == c->types) | 157 | if (NULL == c->types) |
161 | return GNUNET_NO; | 158 | return GNUNET_NO; |
@@ -174,8 +171,7 @@ type_match (uint16_t type, | |||
174 | * @return #GNUNET_OK if @a im is well-formed | 171 | * @return #GNUNET_OK if @a im is well-formed |
175 | */ | 172 | */ |
176 | static int | 173 | static int |
177 | check_client_init (void *cls, | 174 | check_client_init (void *cls, const struct InitMessage *im) |
178 | const struct InitMessage *im) | ||
179 | { | 175 | { |
180 | return GNUNET_OK; | 176 | return GNUNET_OK; |
181 | } | 177 | } |
@@ -188,8 +184,7 @@ check_client_init (void *cls, | |||
188 | * @param im the `struct InitMessage` | 184 | * @param im the `struct InitMessage` |
189 | */ | 185 | */ |
190 | static void | 186 | static void |
191 | handle_client_init (void *cls, | 187 | handle_client_init (void *cls, const struct InitMessage *im) |
192 | const struct InitMessage *im) | ||
193 | { | 188 | { |
194 | struct GSC_Client *c = cls; | 189 | struct GSC_Client *c = cls; |
195 | struct GNUNET_MQ_Envelope *env; | 190 | struct GNUNET_MQ_Envelope *env; |
@@ -206,24 +201,23 @@ handle_client_init (void *cls, | |||
206 | all_client_options |= c->options; | 201 | all_client_options |= c->options; |
207 | c->types = GNUNET_malloc (msize); | 202 | c->types = GNUNET_malloc (msize); |
208 | GNUNET_assert (GNUNET_YES == | 203 | GNUNET_assert (GNUNET_YES == |
209 | GNUNET_CONTAINER_multipeermap_put (c->connectmap, | 204 | GNUNET_CONTAINER_multipeermap_put ( |
210 | &GSC_my_identity, | 205 | c->connectmap, |
211 | NULL, | 206 | &GSC_my_identity, |
212 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 207 | NULL, |
208 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | ||
213 | for (unsigned int i = 0; i < c->tcnt; i++) | 209 | for (unsigned int i = 0; i < c->tcnt; i++) |
214 | c->types[i] = ntohs (types[i]); | 210 | c->types[i] = ntohs (types[i]); |
215 | GSC_TYPEMAP_add (c->types, | 211 | GSC_TYPEMAP_add (c->types, c->tcnt); |
216 | c->tcnt); | 212 | GNUNET_log ( |
217 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 213 | GNUNET_ERROR_TYPE_DEBUG, |
218 | "Client connecting to core service is interested in %u message types\n", | 214 | "Client connecting to core service is interested in %u message types\n", |
219 | (unsigned int) c->tcnt); | 215 | (unsigned int) c->tcnt); |
220 | /* send init reply message */ | 216 | /* send init reply message */ |
221 | env = GNUNET_MQ_msg (irm, | 217 | env = GNUNET_MQ_msg (irm, GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY); |
222 | GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY); | ||
223 | irm->reserved = htonl (0); | 218 | irm->reserved = htonl (0); |
224 | irm->my_identity = GSC_my_identity; | 219 | irm->my_identity = GSC_my_identity; |
225 | GNUNET_MQ_send (c->mq, | 220 | GNUNET_MQ_send (c->mq, env); |
226 | env); | ||
227 | GSC_SESSIONS_notify_client_about_sessions (c); | 221 | GSC_SESSIONS_notify_client_about_sessions (c); |
228 | GNUNET_SERVICE_client_continue (c->client); | 222 | GNUNET_SERVICE_client_continue (c->client); |
229 | } | 223 | } |
@@ -245,11 +239,11 @@ void | |||
245 | GSC_CLIENTS_reject_request (struct GSC_ClientActiveRequest *car, | 239 | GSC_CLIENTS_reject_request (struct GSC_ClientActiveRequest *car, |
246 | int drop_client) | 240 | int drop_client) |
247 | { | 241 | { |
248 | GNUNET_assert (GNUNET_YES == | 242 | GNUNET_assert ( |
249 | GNUNET_CONTAINER_multipeermap_remove (car-> | 243 | GNUNET_YES == |
250 | client_handle->requests, | 244 | GNUNET_CONTAINER_multipeermap_remove (car->client_handle->requests, |
251 | &car->target, | 245 | &car->target, |
252 | car)); | 246 | car)); |
253 | if (GNUNET_YES == drop_client) | 247 | if (GNUNET_YES == drop_client) |
254 | GNUNET_SERVICE_client_drop (car->client_handle->client); | 248 | GNUNET_SERVICE_client_drop (car->client_handle->client); |
255 | GNUNET_free (car); | 249 | GNUNET_free (car); |
@@ -274,38 +268,31 @@ GSC_CLIENTS_solicit_request (struct GSC_ClientActiveRequest *car) | |||
274 | 268 | ||
275 | c = car->client_handle; | 269 | c = car->client_handle; |
276 | if (GNUNET_YES != | 270 | if (GNUNET_YES != |
277 | GNUNET_CONTAINER_multipeermap_contains (c->connectmap, | 271 | GNUNET_CONTAINER_multipeermap_contains (c->connectmap, &car->target)) |
278 | &car->target)) | ||
279 | { | 272 | { |
280 | /* connection has gone down since, drop request */ | 273 | /* connection has gone down since, drop request */ |
281 | GNUNET_assert (0 != | 274 | GNUNET_assert (0 != memcmp (&car->target, |
282 | memcmp (&car->target, | 275 | &GSC_my_identity, |
283 | &GSC_my_identity, | 276 | sizeof (struct GNUNET_PeerIdentity))); |
284 | sizeof (struct GNUNET_PeerIdentity))); | ||
285 | GSC_SESSIONS_dequeue_request (car); | 277 | GSC_SESSIONS_dequeue_request (car); |
286 | GSC_CLIENTS_reject_request (car, | 278 | GSC_CLIENTS_reject_request (car, GNUNET_NO); |
287 | GNUNET_NO); | ||
288 | return; | 279 | return; |
289 | } | 280 | } |
290 | delay = GNUNET_TIME_absolute_get_duration (car->received_time); | 281 | delay = GNUNET_TIME_absolute_get_duration (car->received_time); |
291 | left = GNUNET_TIME_absolute_get_duration (car->deadline); | 282 | left = GNUNET_TIME_absolute_get_duration (car->deadline); |
292 | if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us) | 283 | if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us) |
293 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 284 | GNUNET_log ( |
294 | "Client waited %s for permission to transmit to `%s'%s (priority %u)\n", | 285 | GNUNET_ERROR_TYPE_WARNING, |
295 | GNUNET_STRINGS_relative_time_to_string (delay, | 286 | "Client waited %s for permission to transmit to `%s'%s (priority %u)\n", |
296 | GNUNET_YES), | 287 | GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES), |
297 | GNUNET_i2s (&car->target), | 288 | GNUNET_i2s (&car->target), |
298 | (0 == left.rel_value_us) | 289 | (0 == left.rel_value_us) ? " (past deadline)" : "", |
299 | ? " (past deadline)" | 290 | car->priority); |
300 | : "", | 291 | env = GNUNET_MQ_msg (smr, GNUNET_MESSAGE_TYPE_CORE_SEND_READY); |
301 | car->priority); | ||
302 | env = GNUNET_MQ_msg (smr, | ||
303 | GNUNET_MESSAGE_TYPE_CORE_SEND_READY); | ||
304 | smr->size = htons (car->msize); | 292 | smr->size = htons (car->msize); |
305 | smr->smr_id = car->smr_id; | 293 | smr->smr_id = car->smr_id; |
306 | smr->peer = car->target; | 294 | smr->peer = car->target; |
307 | GNUNET_MQ_send (c->mq, | 295 | GNUNET_MQ_send (c->mq, env); |
308 | env); | ||
309 | } | 296 | } |
310 | 297 | ||
311 | 298 | ||
@@ -316,51 +303,47 @@ GSC_CLIENTS_solicit_request (struct GSC_ClientActiveRequest *car) | |||
316 | * @param req the `struct SendMessageRequest` | 303 | * @param req the `struct SendMessageRequest` |
317 | */ | 304 | */ |
318 | static void | 305 | static void |
319 | handle_client_send_request (void *cls, | 306 | handle_client_send_request (void *cls, const struct SendMessageRequest *req) |
320 | const struct SendMessageRequest *req) | ||
321 | { | 307 | { |
322 | struct GSC_Client *c = cls; | 308 | struct GSC_Client *c = cls; |
323 | struct GSC_ClientActiveRequest *car; | 309 | struct GSC_ClientActiveRequest *car; |
324 | int is_loopback; | 310 | int is_loopback; |
325 | 311 | ||
326 | if (NULL == c->requests) | 312 | if (NULL == c->requests) |
327 | c->requests = GNUNET_CONTAINER_multipeermap_create (16, | 313 | c->requests = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_NO); |
328 | GNUNET_NO); | ||
329 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 314 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
330 | "Client asked for transmission to `%s'\n", | 315 | "Client asked for transmission to `%s'\n", |
331 | GNUNET_i2s (&req->peer)); | 316 | GNUNET_i2s (&req->peer)); |
332 | is_loopback = | 317 | is_loopback = (0 == memcmp (&req->peer, |
333 | (0 == | 318 | &GSC_my_identity, |
334 | memcmp (&req->peer, | 319 | sizeof (struct GNUNET_PeerIdentity))); |
335 | &GSC_my_identity, | ||
336 | sizeof (struct GNUNET_PeerIdentity))); | ||
337 | if ((! is_loopback) && | 320 | if ((! is_loopback) && |
338 | (GNUNET_YES != | 321 | (GNUNET_YES != |
339 | GNUNET_CONTAINER_multipeermap_contains (c->connectmap, | 322 | GNUNET_CONTAINER_multipeermap_contains (c->connectmap, &req->peer))) |
340 | &req->peer))) | ||
341 | { | 323 | { |
342 | /* neighbour must have disconnected since request was issued, | 324 | /* neighbour must have disconnected since request was issued, |
343 | * ignore (client will realize it once it processes the | 325 | * ignore (client will realize it once it processes the |
344 | * disconnect notification) */ | 326 | * disconnect notification) */ |
345 | GNUNET_STATISTICS_update (GSC_stats, | 327 | GNUNET_STATISTICS_update (GSC_stats, |
346 | gettext_noop | 328 | gettext_noop ( |
347 | ("# send requests dropped (disconnected)"), 1, | 329 | "# send requests dropped (disconnected)"), |
330 | 1, | ||
348 | GNUNET_NO); | 331 | GNUNET_NO); |
349 | GNUNET_SERVICE_client_continue (c->client); | 332 | GNUNET_SERVICE_client_continue (c->client); |
350 | return; | 333 | return; |
351 | } | 334 | } |
352 | 335 | ||
353 | car = GNUNET_CONTAINER_multipeermap_get (c->requests, | 336 | car = GNUNET_CONTAINER_multipeermap_get (c->requests, &req->peer); |
354 | &req->peer); | ||
355 | if (NULL == car) | 337 | if (NULL == car) |
356 | { | 338 | { |
357 | /* create new entry */ | 339 | /* create new entry */ |
358 | car = GNUNET_new (struct GSC_ClientActiveRequest); | 340 | car = GNUNET_new (struct GSC_ClientActiveRequest); |
359 | GNUNET_assert (GNUNET_OK == | 341 | GNUNET_assert (GNUNET_OK == |
360 | GNUNET_CONTAINER_multipeermap_put (c->requests, | 342 | GNUNET_CONTAINER_multipeermap_put ( |
361 | &req->peer, | 343 | c->requests, |
362 | car, | 344 | &req->peer, |
363 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)); | 345 | car, |
346 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)); | ||
364 | car->client_handle = c; | 347 | car->client_handle = c; |
365 | } | 348 | } |
366 | else | 349 | else |
@@ -368,8 +351,9 @@ handle_client_send_request (void *cls, | |||
368 | /* dequeue and recycle memory from pending request, there can only | 351 | /* dequeue and recycle memory from pending request, there can only |
369 | be at most one per client and peer */ | 352 | be at most one per client and peer */ |
370 | GNUNET_STATISTICS_update (GSC_stats, | 353 | GNUNET_STATISTICS_update (GSC_stats, |
371 | gettext_noop ("# dequeuing CAR (duplicate request)"), | 354 | gettext_noop ( |
372 | 1, | 355 | "# dequeuing CAR (duplicate request)"), |
356 | 1, | ||
373 | GNUNET_NO); | 357 | GNUNET_NO); |
374 | GSC_SESSIONS_dequeue_request (car); | 358 | GSC_SESSIONS_dequeue_request (car); |
375 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 359 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
@@ -379,7 +363,7 @@ handle_client_send_request (void *cls, | |||
379 | car->target = req->peer; | 363 | car->target = req->peer; |
380 | car->received_time = GNUNET_TIME_absolute_get (); | 364 | car->received_time = GNUNET_TIME_absolute_get (); |
381 | car->deadline = GNUNET_TIME_absolute_ntoh (req->deadline); | 365 | car->deadline = GNUNET_TIME_absolute_ntoh (req->deadline); |
382 | car->priority = (enum GNUNET_CORE_Priority) ntohl (req->priority); | 366 | car->priority = (enum GNUNET_MQ_PriorityPreferences) ntohl (req->priority); |
383 | car->msize = ntohs (req->size); | 367 | car->msize = ntohs (req->size); |
384 | car->smr_id = req->smr_id; | 368 | car->smr_id = req->smr_id; |
385 | car->was_solicited = GNUNET_NO; | 369 | car->was_solicited = GNUNET_NO; |
@@ -408,13 +392,7 @@ struct TokenizerContext | |||
408 | /** | 392 | /** |
409 | * How important is this message. | 393 | * How important is this message. |
410 | */ | 394 | */ |
411 | enum GNUNET_CORE_Priority priority; | 395 | enum GNUNET_MQ_PriorityPreferences priority; |
412 | |||
413 | /** | ||
414 | * Is corking allowed (set only once we have the real message). | ||
415 | */ | ||
416 | int cork; | ||
417 | |||
418 | }; | 396 | }; |
419 | 397 | ||
420 | 398 | ||
@@ -431,65 +409,57 @@ struct TokenizerContext | |||
431 | * #GNUNET_SYSERR to stop further processing with error | 409 | * #GNUNET_SYSERR to stop further processing with error |
432 | */ | 410 | */ |
433 | static int | 411 | static int |
434 | tokenized_cb (void *cls, | 412 | tokenized_cb (void *cls, const struct GNUNET_MessageHeader *message) |
435 | const struct GNUNET_MessageHeader *message) | ||
436 | { | 413 | { |
437 | struct TokenizerContext *tc = cls; | 414 | struct TokenizerContext *tc = cls; |
438 | struct GSC_ClientActiveRequest *car = tc->car; | 415 | struct GSC_ClientActiveRequest *car = tc->car; |
439 | char buf[92]; | 416 | char buf[92]; |
440 | 417 | ||
441 | GNUNET_snprintf (buf, | 418 | GNUNET_snprintf (buf, |
442 | sizeof (buf), | 419 | sizeof (buf), |
443 | gettext_noop ("# bytes of messages of type %u received"), | 420 | gettext_noop ("# bytes of messages of type %u received"), |
444 | (unsigned int) ntohs (message->type)); | 421 | (unsigned int) ntohs (message->type)); |
445 | GNUNET_STATISTICS_update (GSC_stats, | 422 | GNUNET_STATISTICS_update (GSC_stats, buf, ntohs (message->size), GNUNET_NO); |
446 | buf, | 423 | if (0 == memcmp (&car->target, |
447 | ntohs (message->size), | 424 | &GSC_my_identity, |
448 | GNUNET_NO); | 425 | sizeof (struct GNUNET_PeerIdentity))) |
449 | if (0 == | ||
450 | memcmp (&car->target, | ||
451 | &GSC_my_identity, | ||
452 | sizeof (struct GNUNET_PeerIdentity))) | ||
453 | { | 426 | { |
454 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 427 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
455 | "Delivering message of type %u to myself\n", | 428 | "Delivering message of type %u to myself\n", |
456 | ntohs (message->type)); | 429 | ntohs (message->type)); |
457 | GSC_CLIENTS_deliver_message (&GSC_my_identity, | 430 | GSC_CLIENTS_deliver_message (&GSC_my_identity, |
458 | message, | 431 | message, |
459 | ntohs (message->size), | 432 | ntohs (message->size), |
460 | GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND); | 433 | GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND); |
461 | GSC_CLIENTS_deliver_message (&GSC_my_identity, | 434 | GSC_CLIENTS_deliver_message (&GSC_my_identity, |
462 | message, | 435 | message, |
463 | sizeof (struct GNUNET_MessageHeader), | 436 | sizeof (struct GNUNET_MessageHeader), |
464 | GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND); | 437 | GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND); |
465 | GSC_CLIENTS_deliver_message (&GSC_my_identity, | 438 | GSC_CLIENTS_deliver_message (&GSC_my_identity, |
466 | message, | 439 | message, |
467 | ntohs (message->size), | 440 | ntohs (message->size), |
468 | GNUNET_CORE_OPTION_SEND_FULL_INBOUND); | 441 | GNUNET_CORE_OPTION_SEND_FULL_INBOUND); |
469 | GSC_CLIENTS_deliver_message (&GSC_my_identity, | 442 | GSC_CLIENTS_deliver_message (&GSC_my_identity, |
470 | message, | 443 | message, |
471 | sizeof (struct GNUNET_MessageHeader), | 444 | sizeof (struct GNUNET_MessageHeader), |
472 | GNUNET_CORE_OPTION_SEND_HDR_INBOUND); | 445 | GNUNET_CORE_OPTION_SEND_HDR_INBOUND); |
473 | } | 446 | } |
474 | else | 447 | else |
475 | { | 448 | { |
476 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 449 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
477 | "Delivering message of type %u and size %u to %s\n", | 450 | "Delivering message of type %u and size %u to %s\n", |
478 | ntohs (message->type), | 451 | ntohs (message->type), |
479 | ntohs (message->size), | 452 | ntohs (message->size), |
480 | GNUNET_i2s (&car->target)); | 453 | GNUNET_i2s (&car->target)); |
481 | GSC_CLIENTS_deliver_message (&car->target, | 454 | GSC_CLIENTS_deliver_message (&car->target, |
482 | message, | 455 | message, |
483 | ntohs (message->size), | 456 | ntohs (message->size), |
484 | GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND); | 457 | GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND); |
485 | GSC_CLIENTS_deliver_message (&car->target, | 458 | GSC_CLIENTS_deliver_message (&car->target, |
486 | message, | 459 | message, |
487 | sizeof (struct GNUNET_MessageHeader), | 460 | sizeof (struct GNUNET_MessageHeader), |
488 | GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND); | 461 | GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND); |
489 | GSC_SESSIONS_transmit (car, | 462 | GSC_SESSIONS_transmit (car, message, tc->priority); |
490 | message, | ||
491 | tc->cork, | ||
492 | tc->priority); | ||
493 | } | 463 | } |
494 | return GNUNET_OK; | 464 | return GNUNET_OK; |
495 | } | 465 | } |
@@ -503,8 +473,7 @@ tokenized_cb (void *cls, | |||
503 | * @return #GNUNET_OK if @a sm is well-formed | 473 | * @return #GNUNET_OK if @a sm is well-formed |
504 | */ | 474 | */ |
505 | static int | 475 | static int |
506 | check_client_send (void *cls, | 476 | check_client_send (void *cls, const struct SendMessage *sm) |
507 | const struct SendMessage *sm) | ||
508 | { | 477 | { |
509 | return GNUNET_OK; | 478 | return GNUNET_OK; |
510 | } | 479 | } |
@@ -517,8 +486,7 @@ check_client_send (void *cls, | |||
517 | * @param sm the `struct SendMessage` | 486 | * @param sm the `struct SendMessage` |
518 | */ | 487 | */ |
519 | static void | 488 | static void |
520 | handle_client_send (void *cls, | 489 | handle_client_send (void *cls, const struct SendMessage *sm) |
521 | const struct SendMessage *sm) | ||
522 | { | 490 | { |
523 | struct GSC_Client *c = cls; | 491 | struct GSC_Client *c = cls; |
524 | struct TokenizerContext tc; | 492 | struct TokenizerContext tc; |
@@ -527,9 +495,7 @@ handle_client_send (void *cls, | |||
527 | struct GNUNET_MessageStreamTokenizer *mst; | 495 | struct GNUNET_MessageStreamTokenizer *mst; |
528 | 496 | ||
529 | msize = ntohs (sm->header.size) - sizeof (struct SendMessage); | 497 | msize = ntohs (sm->header.size) - sizeof (struct SendMessage); |
530 | GNUNET_break (0 == ntohl (sm->reserved)); | 498 | tc.car = GNUNET_CONTAINER_multipeermap_get (c->requests, &sm->peer); |
531 | tc.car = GNUNET_CONTAINER_multipeermap_get (c->requests, | ||
532 | &sm->peer); | ||
533 | if (NULL == tc.car) | 499 | if (NULL == tc.car) |
534 | { | 500 | { |
535 | /* Must have been that we first approved the request, then got disconnected | 501 | /* Must have been that we first approved the request, then got disconnected |
@@ -538,43 +504,37 @@ handle_client_send (void *cls, | |||
538 | * might also now be *again* connected. So this can happen (but should be | 504 | * might also now be *again* connected. So this can happen (but should be |
539 | * rare). If it does happen, the message is discarded. */ | 505 | * rare). If it does happen, the message is discarded. */ |
540 | GNUNET_STATISTICS_update (GSC_stats, | 506 | GNUNET_STATISTICS_update (GSC_stats, |
541 | gettext_noop ("# messages discarded (session disconnected)"), | 507 | gettext_noop ( |
508 | "# messages discarded (session disconnected)"), | ||
542 | 1, | 509 | 1, |
543 | GNUNET_NO); | 510 | GNUNET_NO); |
544 | GNUNET_SERVICE_client_continue (c->client); | 511 | GNUNET_SERVICE_client_continue (c->client); |
545 | return; | 512 | return; |
546 | } | 513 | } |
547 | delay = GNUNET_TIME_absolute_get_duration (tc.car->received_time); | 514 | delay = GNUNET_TIME_absolute_get_duration (tc.car->received_time); |
548 | tc.cork = ntohl (sm->cork); | 515 | tc.priority = (enum GNUNET_MQ_PriorityPreferences) ntohl (sm->priority); |
549 | tc.priority = (enum GNUNET_CORE_Priority) ntohl (sm->priority); | ||
550 | if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us) | 516 | if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us) |
551 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 517 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
552 | "Client waited %s for transmission of %u bytes to `%s'%s\n", | 518 | "Client waited %s for transmission of %u bytes to `%s'\n", |
553 | GNUNET_STRINGS_relative_time_to_string (delay, | 519 | GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES), |
554 | GNUNET_YES), | ||
555 | msize, | 520 | msize, |
556 | GNUNET_i2s (&sm->peer), | 521 | GNUNET_i2s (&sm->peer)); |
557 | tc.cork ? " (cork)" : " (uncorked)"); | ||
558 | else | 522 | else |
559 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 523 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
560 | "Client waited %s for transmission of %u bytes to `%s'%s\n", | 524 | "Client waited %s for transmission of %u bytes to `%s'\n", |
561 | GNUNET_STRINGS_relative_time_to_string (delay, | 525 | GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES), |
562 | GNUNET_YES), | ||
563 | msize, | 526 | msize, |
564 | GNUNET_i2s (&sm->peer), | 527 | GNUNET_i2s (&sm->peer)); |
565 | tc.cork ? " (cork)" : " (uncorked)"); | ||
566 | 528 | ||
567 | GNUNET_assert (GNUNET_YES == | 529 | GNUNET_assert ( |
568 | GNUNET_CONTAINER_multipeermap_remove (c->requests, | 530 | GNUNET_YES == |
569 | &sm->peer, | 531 | GNUNET_CONTAINER_multipeermap_remove (c->requests, &sm->peer, tc.car)); |
570 | tc.car)); | 532 | mst = GNUNET_MST_create (&tokenized_cb, &tc); |
571 | mst = GNUNET_MST_create (&tokenized_cb, | ||
572 | &tc); | ||
573 | GNUNET_MST_from_buffer (mst, | 533 | GNUNET_MST_from_buffer (mst, |
574 | (const char *) &sm[1], | 534 | (const char *) &sm[1], |
575 | msize, | 535 | msize, |
576 | GNUNET_YES, | 536 | GNUNET_YES, |
577 | GNUNET_NO); | 537 | GNUNET_NO); |
578 | GNUNET_MST_destroy (mst); | 538 | GNUNET_MST_destroy (mst); |
579 | GSC_SESSIONS_dequeue_request (tc.car); | 539 | GSC_SESSIONS_dequeue_request (tc.car); |
580 | GNUNET_free (tc.car); | 540 | GNUNET_free (tc.car); |
@@ -592,16 +552,16 @@ handle_client_send (void *cls, | |||
592 | */ | 552 | */ |
593 | static int | 553 | static int |
594 | destroy_active_client_request (void *cls, | 554 | destroy_active_client_request (void *cls, |
595 | const struct GNUNET_PeerIdentity *key, | 555 | const struct GNUNET_PeerIdentity *key, |
596 | void *value) | 556 | void *value) |
597 | { | 557 | { |
598 | struct GSC_ClientActiveRequest *car = value; | 558 | struct GSC_ClientActiveRequest *car = value; |
599 | 559 | ||
600 | GNUNET_assert (GNUNET_YES == | 560 | GNUNET_assert ( |
601 | GNUNET_CONTAINER_multipeermap_remove (car-> | 561 | GNUNET_YES == |
602 | client_handle->requests, | 562 | GNUNET_CONTAINER_multipeermap_remove (car->client_handle->requests, |
603 | &car->target, | 563 | &car->target, |
604 | car)); | 564 | car)); |
605 | GSC_SESSIONS_dequeue_request (car); | 565 | GSC_SESSIONS_dequeue_request (car); |
606 | GNUNET_free (car); | 566 | GNUNET_free (car); |
607 | return GNUNET_YES; | 567 | return GNUNET_YES; |
@@ -618,19 +578,16 @@ destroy_active_client_request (void *cls, | |||
618 | */ | 578 | */ |
619 | static void * | 579 | static void * |
620 | client_connect_cb (void *cls, | 580 | client_connect_cb (void *cls, |
621 | struct GNUNET_SERVICE_Client *client, | 581 | struct GNUNET_SERVICE_Client *client, |
622 | struct GNUNET_MQ_Handle *mq) | 582 | struct GNUNET_MQ_Handle *mq) |
623 | { | 583 | { |
624 | struct GSC_Client *c; | 584 | struct GSC_Client *c; |
625 | 585 | ||
626 | c = GNUNET_new (struct GSC_Client); | 586 | c = GNUNET_new (struct GSC_Client); |
627 | c->client = client; | 587 | c->client = client; |
628 | c->mq = mq; | 588 | c->mq = mq; |
629 | c->connectmap = GNUNET_CONTAINER_multipeermap_create (16, | 589 | c->connectmap = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_NO); |
630 | GNUNET_NO); | 590 | GNUNET_CONTAINER_DLL_insert (client_head, client_tail, c); |
631 | GNUNET_CONTAINER_DLL_insert (client_head, | ||
632 | client_tail, | ||
633 | c); | ||
634 | return c; | 591 | return c; |
635 | } | 592 | } |
636 | 593 | ||
@@ -644,17 +601,15 @@ client_connect_cb (void *cls, | |||
644 | */ | 601 | */ |
645 | static void | 602 | static void |
646 | client_disconnect_cb (void *cls, | 603 | client_disconnect_cb (void *cls, |
647 | struct GNUNET_SERVICE_Client *client, | 604 | struct GNUNET_SERVICE_Client *client, |
648 | void *app_ctx) | 605 | void *app_ctx) |
649 | { | 606 | { |
650 | struct GSC_Client *c = app_ctx; | 607 | struct GSC_Client *c = app_ctx; |
651 | 608 | ||
652 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 609 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
653 | "Client %p has disconnected from core service.\n", | 610 | "Client %p has disconnected from core service.\n", |
654 | client); | 611 | client); |
655 | GNUNET_CONTAINER_DLL_remove (client_head, | 612 | GNUNET_CONTAINER_DLL_remove (client_head, client_tail, c); |
656 | client_tail, | ||
657 | c); | ||
658 | if (NULL != c->requests) | 613 | if (NULL != c->requests) |
659 | { | 614 | { |
660 | GNUNET_CONTAINER_multipeermap_iterate (c->requests, | 615 | GNUNET_CONTAINER_multipeermap_iterate (c->requests, |
@@ -666,15 +621,14 @@ client_disconnect_cb (void *cls, | |||
666 | c->connectmap = NULL; | 621 | c->connectmap = NULL; |
667 | if (NULL != c->types) | 622 | if (NULL != c->types) |
668 | { | 623 | { |
669 | GSC_TYPEMAP_remove (c->types, | 624 | GSC_TYPEMAP_remove (c->types, c->tcnt); |
670 | c->tcnt); | ||
671 | GNUNET_free (c->types); | 625 | GNUNET_free (c->types); |
672 | } | 626 | } |
673 | GNUNET_free (c); | 627 | GNUNET_free (c); |
674 | 628 | ||
675 | /* recalculate 'all_client_options' */ | 629 | /* recalculate 'all_client_options' */ |
676 | all_client_options = 0; | 630 | all_client_options = 0; |
677 | for (c = client_head; NULL != c ; c = c->next) | 631 | for (c = client_head; NULL != c; c = c->next) |
678 | all_client_options |= c->options; | 632 | all_client_options |= c->options; |
679 | } | 633 | } |
680 | 634 | ||
@@ -690,10 +644,11 @@ client_disconnect_cb (void *cls, | |||
690 | * @param tmap_new updated type map for the neighbour, NULL for disconnect | 644 | * @param tmap_new updated type map for the neighbour, NULL for disconnect |
691 | */ | 645 | */ |
692 | void | 646 | void |
693 | GSC_CLIENTS_notify_client_about_neighbour (struct GSC_Client *client, | 647 | GSC_CLIENTS_notify_client_about_neighbour ( |
694 | const struct GNUNET_PeerIdentity *neighbour, | 648 | struct GSC_Client *client, |
695 | const struct GSC_TypeMap *tmap_old, | 649 | const struct GNUNET_PeerIdentity *neighbour, |
696 | const struct GSC_TypeMap *tmap_new) | 650 | const struct GSC_TypeMap *tmap_old, |
651 | const struct GSC_TypeMap *tmap_new) | ||
697 | { | 652 | { |
698 | struct GNUNET_MQ_Envelope *env; | 653 | struct GNUNET_MQ_Envelope *env; |
699 | int old_match; | 654 | int old_match; |
@@ -701,12 +656,8 @@ GSC_CLIENTS_notify_client_about_neighbour (struct GSC_Client *client, | |||
701 | 656 | ||
702 | if (GNUNET_YES != client->got_init) | 657 | if (GNUNET_YES != client->got_init) |
703 | return; | 658 | return; |
704 | old_match = GSC_TYPEMAP_test_match (tmap_old, | 659 | old_match = GSC_TYPEMAP_test_match (tmap_old, client->types, client->tcnt); |
705 | client->types, | 660 | new_match = GSC_TYPEMAP_test_match (tmap_new, client->types, client->tcnt); |
706 | client->tcnt); | ||
707 | new_match = GSC_TYPEMAP_test_match (tmap_new, | ||
708 | client->types, | ||
709 | client->tcnt); | ||
710 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 661 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
711 | "Notifying client about neighbour %s (%d/%d)\n", | 662 | "Notifying client about neighbour %s (%d/%d)\n", |
712 | GNUNET_i2s (neighbour), | 663 | GNUNET_i2s (neighbour), |
@@ -714,55 +665,52 @@ GSC_CLIENTS_notify_client_about_neighbour (struct GSC_Client *client, | |||
714 | new_match); | 665 | new_match); |
715 | if (old_match == new_match) | 666 | if (old_match == new_match) |
716 | { | 667 | { |
717 | GNUNET_assert (old_match == | 668 | GNUNET_assert ( |
718 | GNUNET_CONTAINER_multipeermap_contains (client->connectmap, | 669 | old_match == |
719 | neighbour)); | 670 | GNUNET_CONTAINER_multipeermap_contains (client->connectmap, neighbour)); |
720 | return; /* no change */ | 671 | return; /* no change */ |
721 | } | 672 | } |
722 | if (GNUNET_NO == old_match) | 673 | if (GNUNET_NO == old_match) |
723 | { | 674 | { |
724 | struct ConnectNotifyMessage *cnm; | 675 | struct ConnectNotifyMessage *cnm; |
725 | 676 | ||
726 | /* send connect */ | 677 | /* send connect */ |
727 | GNUNET_assert (GNUNET_NO == | 678 | GNUNET_assert ( |
728 | GNUNET_CONTAINER_multipeermap_contains (client->connectmap, | 679 | GNUNET_NO == |
729 | neighbour)); | 680 | GNUNET_CONTAINER_multipeermap_contains (client->connectmap, neighbour)); |
730 | GNUNET_assert (GNUNET_YES == | 681 | GNUNET_assert (GNUNET_YES == |
731 | GNUNET_CONTAINER_multipeermap_put (client->connectmap, | 682 | GNUNET_CONTAINER_multipeermap_put ( |
732 | neighbour, | 683 | client->connectmap, |
733 | NULL, | 684 | neighbour, |
734 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 685 | NULL, |
735 | env = GNUNET_MQ_msg (cnm, | 686 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); |
736 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT); | 687 | env = GNUNET_MQ_msg (cnm, GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT); |
737 | cnm->reserved = htonl (0); | 688 | cnm->reserved = htonl (0); |
738 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 689 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
739 | "Sending NOTIFY_CONNECT message about peer %s to client.\n", | 690 | "Sending NOTIFY_CONNECT message about peer %s to client.\n", |
740 | GNUNET_i2s (neighbour)); | 691 | GNUNET_i2s (neighbour)); |
741 | cnm->peer = *neighbour; | 692 | cnm->peer = *neighbour; |
742 | GNUNET_MQ_send (client->mq, | 693 | GNUNET_MQ_send (client->mq, env); |
743 | env); | ||
744 | } | 694 | } |
745 | else | 695 | else |
746 | { | 696 | { |
747 | struct DisconnectNotifyMessage *dcm; | 697 | struct DisconnectNotifyMessage *dcm; |
748 | 698 | ||
749 | /* send disconnect */ | 699 | /* send disconnect */ |
750 | GNUNET_assert (GNUNET_YES == | 700 | GNUNET_assert ( |
751 | GNUNET_CONTAINER_multipeermap_contains (client->connectmap, | 701 | GNUNET_YES == |
752 | neighbour)); | 702 | GNUNET_CONTAINER_multipeermap_contains (client->connectmap, neighbour)); |
753 | GNUNET_assert (GNUNET_YES == | 703 | GNUNET_assert (GNUNET_YES == |
754 | GNUNET_CONTAINER_multipeermap_remove (client->connectmap, | 704 | GNUNET_CONTAINER_multipeermap_remove (client->connectmap, |
755 | neighbour, | 705 | neighbour, |
756 | NULL)); | 706 | NULL)); |
757 | env = GNUNET_MQ_msg (dcm, | 707 | env = GNUNET_MQ_msg (dcm, GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT); |
758 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT); | ||
759 | dcm->reserved = htonl (0); | 708 | dcm->reserved = htonl (0); |
760 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 709 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
761 | "Sending NOTIFY_DISCONNECT message about peer %s to client.\n", | 710 | "Sending NOTIFY_DISCONNECT message about peer %s to client.\n", |
762 | GNUNET_i2s (neighbour)); | 711 | GNUNET_i2s (neighbour)); |
763 | dcm->peer = *neighbour; | 712 | dcm->peer = *neighbour; |
764 | GNUNET_MQ_send (client->mq, | 713 | GNUNET_MQ_send (client->mq, env); |
765 | env); | ||
766 | } | 714 | } |
767 | } | 715 | } |
768 | 716 | ||
@@ -777,17 +725,18 @@ GSC_CLIENTS_notify_client_about_neighbour (struct GSC_Client *client, | |||
777 | * @param tmap_new updated type map for the neighbour, NULL for disconnect | 725 | * @param tmap_new updated type map for the neighbour, NULL for disconnect |
778 | */ | 726 | */ |
779 | void | 727 | void |
780 | GSC_CLIENTS_notify_clients_about_neighbour (const struct GNUNET_PeerIdentity *neighbour, | 728 | GSC_CLIENTS_notify_clients_about_neighbour ( |
781 | const struct GSC_TypeMap *tmap_old, | 729 | const struct GNUNET_PeerIdentity *neighbour, |
782 | const struct GSC_TypeMap *tmap_new) | 730 | const struct GSC_TypeMap *tmap_old, |
731 | const struct GSC_TypeMap *tmap_new) | ||
783 | { | 732 | { |
784 | struct GSC_Client *c; | 733 | struct GSC_Client *c; |
785 | 734 | ||
786 | for (c = client_head; NULL != c; c = c->next) | 735 | for (c = client_head; NULL != c; c = c->next) |
787 | GSC_CLIENTS_notify_client_about_neighbour (c, | 736 | GSC_CLIENTS_notify_client_about_neighbour (c, |
788 | neighbour, | 737 | neighbour, |
789 | tmap_old, | 738 | tmap_old, |
790 | tmap_new); | 739 | tmap_new); |
791 | } | 740 | } |
792 | 741 | ||
793 | 742 | ||
@@ -815,15 +764,14 @@ GSC_CLIENTS_deliver_message (const struct GNUNET_PeerIdentity *sender, | |||
815 | GNUNET_break (0); | 764 | GNUNET_break (0); |
816 | return; | 765 | return; |
817 | } | 766 | } |
818 | if (! ( (0 != (all_client_options & options)) || | 767 | if (! ((0 != (all_client_options & options)) || |
819 | (0 != (options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) )) | 768 | (0 != (options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)))) |
820 | return; /* no client cares about this message notification */ | 769 | return; /* no client cares about this message notification */ |
821 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 770 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
822 | "Core service passes message from `%s' of type %u to client.\n", | 771 | "Core service passes message from `%s' of type %u to client.\n", |
823 | GNUNET_i2s (sender), | 772 | GNUNET_i2s (sender), |
824 | (unsigned int) ntohs (msg->type)); | 773 | (unsigned int) ntohs (msg->type)); |
825 | GSC_SESSIONS_add_to_typemap (sender, | 774 | GSC_SESSIONS_add_to_typemap (sender, ntohs (msg->type)); |
826 | ntohs (msg->type)); | ||
827 | 775 | ||
828 | for (struct GSC_Client *c = client_head; NULL != c; c = c->next) | 776 | for (struct GSC_Client *c = client_head; NULL != c; c = c->next) |
829 | { | 777 | { |
@@ -833,18 +781,17 @@ GSC_CLIENTS_deliver_message (const struct GNUNET_PeerIdentity *sender, | |||
833 | unsigned int qlen; | 781 | unsigned int qlen; |
834 | int tm; | 782 | int tm; |
835 | 783 | ||
836 | tm = type_match (ntohs (msg->type), | 784 | tm = type_match (ntohs (msg->type), c); |
837 | c); | 785 | if (! ((0 != (c->options & options)) || |
838 | if (! ( (0 != (c->options & options)) || | 786 | ((0 != (options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) && |
839 | ( (0 != (options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) && | 787 | (GNUNET_YES == tm)))) |
840 | (GNUNET_YES == tm) ) ) ) | 788 | continue; /* neither options nor type match permit the message */ |
841 | continue; /* neither options nor type match permit the message */ | 789 | if ((0 != (options & GNUNET_CORE_OPTION_SEND_HDR_INBOUND)) && |
842 | if ( (0 != (options & GNUNET_CORE_OPTION_SEND_HDR_INBOUND)) && | 790 | ((0 != (c->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) || |
843 | ( (0 != (c->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) || | 791 | (GNUNET_YES == tm))) |
844 | (GNUNET_YES == tm) ) ) | ||
845 | continue; | 792 | continue; |
846 | if ( (0 != (options & GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND)) && | 793 | if ((0 != (options & GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND)) && |
847 | (0 != (c->options & GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND)) ) | 794 | (0 != (c->options & GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND))) |
848 | continue; | 795 | continue; |
849 | 796 | ||
850 | /* Drop messages if: | 797 | /* Drop messages if: |
@@ -862,54 +809,50 @@ GSC_CLIENTS_deliver_message (const struct GNUNET_PeerIdentity *sender, | |||
862 | (ACK, queries) which may be cummulative or highly redundant, | 809 | (ACK, queries) which may be cummulative or highly redundant, |
863 | and cheap to drop than data traffic. */ | 810 | and cheap to drop than data traffic. */ |
864 | qlen = GNUNET_MQ_get_length (c->mq); | 811 | qlen = GNUNET_MQ_get_length (c->mq); |
865 | if ( (qlen >= HARD_MAX_QUEUE) || | 812 | if ((qlen >= HARD_MAX_QUEUE) || |
866 | ( (qlen > SOFT_MAX_QUEUE) && | 813 | ((qlen > SOFT_MAX_QUEUE) && |
867 | ( (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, | 814 | ((GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, |
868 | ntohs (msg->size)) ) < | 815 | ntohs (msg->size))) < |
869 | (qlen - SOFT_MAX_QUEUE) * 0x8000 / | 816 | (qlen - SOFT_MAX_QUEUE) * 0x8000 / |
870 | (HARD_MAX_QUEUE - SOFT_MAX_QUEUE) ) ) ) | 817 | (HARD_MAX_QUEUE - SOFT_MAX_QUEUE)))) |
871 | { | 818 | { |
872 | char buf[1024]; | 819 | char buf[1024]; |
873 | 820 | ||
874 | GNUNET_log (GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK, | 821 | GNUNET_log ( |
875 | "Dropping decrypted message of type %u as client is too busy (queue full)\n", | 822 | GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK, |
876 | (unsigned int) ntohs (msg->type)); | 823 | "Dropping decrypted message of type %u as client is too busy (queue full)\n", |
824 | (unsigned int) ntohs (msg->type)); | ||
877 | GNUNET_snprintf (buf, | 825 | GNUNET_snprintf (buf, |
878 | sizeof (buf), | 826 | sizeof (buf), |
879 | gettext_noop ("# messages of type %u discarded (client busy)"), | 827 | gettext_noop ( |
828 | "# messages of type %u discarded (client busy)"), | ||
880 | (unsigned int) ntohs (msg->type)); | 829 | (unsigned int) ntohs (msg->type)); |
881 | GNUNET_STATISTICS_update (GSC_stats, | 830 | GNUNET_STATISTICS_update (GSC_stats, buf, 1, GNUNET_NO); |
882 | buf, | ||
883 | 1, | ||
884 | GNUNET_NO); | ||
885 | continue; | 831 | continue; |
886 | } | 832 | } |
887 | 833 | ||
888 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 834 | GNUNET_log ( |
889 | "Sending %u message with %u bytes to client interested in messages of type %u.\n", | 835 | GNUNET_ERROR_TYPE_DEBUG, |
890 | options, | 836 | "Sending %u message with %u bytes to client interested in messages of type %u.\n", |
891 | ntohs (msg->size), | 837 | options, |
892 | (unsigned int) ntohs (msg->type)); | 838 | ntohs (msg->size), |
839 | (unsigned int) ntohs (msg->type)); | ||
893 | 840 | ||
894 | if (0 != (options & (GNUNET_CORE_OPTION_SEND_FULL_INBOUND | GNUNET_CORE_OPTION_SEND_HDR_INBOUND))) | 841 | if (0 != (options & (GNUNET_CORE_OPTION_SEND_FULL_INBOUND | |
842 | GNUNET_CORE_OPTION_SEND_HDR_INBOUND))) | ||
895 | mtype = GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND; | 843 | mtype = GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND; |
896 | else | 844 | else |
897 | mtype = GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND; | 845 | mtype = GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND; |
898 | env = GNUNET_MQ_msg_extra (ntm, | 846 | env = GNUNET_MQ_msg_extra (ntm, msize, mtype); |
899 | msize, | ||
900 | mtype); | ||
901 | ntm->peer = *sender; | 847 | ntm->peer = *sender; |
902 | GNUNET_memcpy (&ntm[1], | 848 | GNUNET_memcpy (&ntm[1], msg, msize); |
903 | msg, | 849 | |
904 | msize); | 850 | GNUNET_assert ( |
905 | 851 | (0 == (c->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) || | |
906 | GNUNET_assert ( (0 == (c->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) || | 852 | (GNUNET_YES != tm) || |
907 | (GNUNET_YES != tm) || | 853 | (GNUNET_YES == |
908 | (GNUNET_YES == | 854 | GNUNET_CONTAINER_multipeermap_contains (c->connectmap, sender))); |
909 | GNUNET_CONTAINER_multipeermap_contains (c->connectmap, | 855 | GNUNET_MQ_send (c->mq, env); |
910 | sender)) ); | ||
911 | GNUNET_MQ_send (c->mq, | ||
912 | env); | ||
913 | } | 856 | } |
914 | } | 857 | } |
915 | 858 | ||
@@ -925,8 +868,7 @@ shutdown_task (void *cls) | |||
925 | { | 868 | { |
926 | struct GSC_Client *c; | 869 | struct GSC_Client *c; |
927 | 870 | ||
928 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 871 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Core service shutting down.\n"); |
929 | "Core service shutting down.\n"); | ||
930 | while (NULL != (c = client_head)) | 872 | while (NULL != (c = client_head)) |
931 | GNUNET_SERVICE_client_drop (c->client); | 873 | GNUNET_SERVICE_client_drop (c->client); |
932 | GSC_SESSIONS_done (); | 874 | GSC_SESSIONS_done (); |
@@ -934,8 +876,7 @@ shutdown_task (void *cls) | |||
934 | GSC_TYPEMAP_done (); | 876 | GSC_TYPEMAP_done (); |
935 | if (NULL != GSC_stats) | 877 | if (NULL != GSC_stats) |
936 | { | 878 | { |
937 | GNUNET_STATISTICS_destroy (GSC_stats, | 879 | GNUNET_STATISTICS_destroy (GSC_stats, GNUNET_NO); |
938 | GNUNET_NO); | ||
939 | GSC_stats = NULL; | 880 | GSC_stats = NULL; |
940 | } | 881 | } |
941 | GSC_cfg = NULL; | 882 | GSC_cfg = NULL; |
@@ -953,7 +894,7 @@ shutdown_task (void *cls) | |||
953 | */ | 894 | */ |
954 | static void | 895 | static void |
955 | handle_client_monitor_peers (void *cls, | 896 | handle_client_monitor_peers (void *cls, |
956 | const struct GNUNET_MessageHeader *message) | 897 | const struct GNUNET_MessageHeader *message) |
957 | { | 898 | { |
958 | struct GSC_Client *c = cls; | 899 | struct GSC_Client *c = cls; |
959 | 900 | ||
@@ -978,21 +919,19 @@ run (void *cls, | |||
978 | char *keyfile; | 919 | char *keyfile; |
979 | 920 | ||
980 | GSC_cfg = c; | 921 | GSC_cfg = c; |
981 | if (GNUNET_OK != | 922 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (GSC_cfg, |
982 | GNUNET_CONFIGURATION_get_value_filename (GSC_cfg, | 923 | "PEER", |
983 | "PEER", | 924 | "PRIVATE_KEY", |
984 | "PRIVATE_KEY", | 925 | &keyfile)) |
985 | &keyfile)) | ||
986 | { | 926 | { |
987 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 927 | GNUNET_log ( |
988 | _("Core service is lacking HOSTKEY configuration setting. Exiting.\n")); | 928 | GNUNET_ERROR_TYPE_ERROR, |
929 | _ ("Core service is lacking HOSTKEY configuration setting. Exiting.\n")); | ||
989 | GNUNET_SCHEDULER_shutdown (); | 930 | GNUNET_SCHEDULER_shutdown (); |
990 | return; | 931 | return; |
991 | } | 932 | } |
992 | GSC_stats = GNUNET_STATISTICS_create ("core", | 933 | GSC_stats = GNUNET_STATISTICS_create ("core", GSC_cfg); |
993 | GSC_cfg); | 934 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); |
994 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, | ||
995 | NULL); | ||
996 | GNUNET_SERVICE_suspend (service); | 935 | GNUNET_SERVICE_suspend (service); |
997 | GSC_TYPEMAP_init (); | 936 | GSC_TYPEMAP_init (); |
998 | pk = GNUNET_CRYPTO_eddsa_key_create_from_file (keyfile); | 937 | pk = GNUNET_CRYPTO_eddsa_key_create_from_file (keyfile); |
@@ -1006,7 +945,7 @@ run (void *cls, | |||
1006 | GSC_SESSIONS_init (); | 945 | GSC_SESSIONS_init (); |
1007 | GNUNET_SERVICE_resume (service); | 946 | GNUNET_SERVICE_resume (service); |
1008 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 947 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1009 | _("Core service of `%s' ready.\n"), | 948 | _ ("Core service of `%s' ready.\n"), |
1010 | GNUNET_i2s (&GSC_my_identity)); | 949 | GNUNET_i2s (&GSC_my_identity)); |
1011 | } | 950 | } |
1012 | 951 | ||
@@ -1014,30 +953,30 @@ run (void *cls, | |||
1014 | /** | 953 | /** |
1015 | * Define "main" method using service macro. | 954 | * Define "main" method using service macro. |
1016 | */ | 955 | */ |
1017 | GNUNET_SERVICE_MAIN | 956 | GNUNET_SERVICE_MAIN ( |
1018 | ("core", | 957 | "core", |
1019 | GNUNET_SERVICE_OPTION_NONE, | 958 | GNUNET_SERVICE_OPTION_NONE, |
1020 | &run, | 959 | &run, |
1021 | &client_connect_cb, | 960 | &client_connect_cb, |
1022 | &client_disconnect_cb, | 961 | &client_disconnect_cb, |
1023 | NULL, | 962 | NULL, |
1024 | GNUNET_MQ_hd_var_size (client_init, | 963 | GNUNET_MQ_hd_var_size (client_init, |
1025 | GNUNET_MESSAGE_TYPE_CORE_INIT, | 964 | GNUNET_MESSAGE_TYPE_CORE_INIT, |
1026 | struct InitMessage, | 965 | struct InitMessage, |
1027 | NULL), | 966 | NULL), |
1028 | GNUNET_MQ_hd_fixed_size (client_monitor_peers, | 967 | GNUNET_MQ_hd_fixed_size (client_monitor_peers, |
1029 | GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS, | 968 | GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS, |
1030 | struct GNUNET_MessageHeader, | 969 | struct GNUNET_MessageHeader, |
1031 | NULL), | 970 | NULL), |
1032 | GNUNET_MQ_hd_fixed_size (client_send_request, | 971 | GNUNET_MQ_hd_fixed_size (client_send_request, |
1033 | GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST, | 972 | GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST, |
1034 | struct SendMessageRequest, | 973 | struct SendMessageRequest, |
1035 | NULL), | 974 | NULL), |
1036 | GNUNET_MQ_hd_var_size (client_send, | 975 | GNUNET_MQ_hd_var_size (client_send, |
1037 | GNUNET_MESSAGE_TYPE_CORE_SEND, | 976 | GNUNET_MESSAGE_TYPE_CORE_SEND, |
1038 | struct SendMessage, | 977 | struct SendMessage, |
1039 | NULL), | 978 | NULL), |
1040 | GNUNET_MQ_handler_end ()); | 979 | GNUNET_MQ_handler_end ()); |
1041 | 980 | ||
1042 | 981 | ||
1043 | /* end of gnunet-service-core.c */ | 982 | /* end of gnunet-service-core.c */ |
diff --git a/src/core/gnunet-service-core.h b/src/core/gnunet-service-core.h index 00461c5ab..154596933 100644 --- a/src/core/gnunet-service-core.h +++ b/src/core/gnunet-service-core.h | |||
@@ -11,7 +11,7 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
@@ -81,7 +81,7 @@ struct GSC_ClientActiveRequest | |||
81 | /** | 81 | /** |
82 | * How important is this request. | 82 | * How important is this request. |
83 | */ | 83 | */ |
84 | enum GNUNET_CORE_Priority priority; | 84 | enum GNUNET_MQ_PriorityPreferences priority; |
85 | 85 | ||
86 | /** | 86 | /** |
87 | * Has this request been solicited yet? | 87 | * Has this request been solicited yet? |
@@ -97,7 +97,6 @@ struct GSC_ClientActiveRequest | |||
97 | * Unique request ID (in big endian). | 97 | * Unique request ID (in big endian). |
98 | */ | 98 | */ |
99 | uint16_t smr_id; | 99 | uint16_t smr_id; |
100 | |||
101 | }; | 100 | }; |
102 | 101 | ||
103 | 102 | ||
@@ -140,10 +139,11 @@ GSC_CLIENTS_reject_request (struct GSC_ClientActiveRequest *car, | |||
140 | * @param tmap_new updated type map for the neighbour, NULL for disconnect | 139 | * @param tmap_new updated type map for the neighbour, NULL for disconnect |
141 | */ | 140 | */ |
142 | void | 141 | void |
143 | GSC_CLIENTS_notify_client_about_neighbour (struct GSC_Client *client, | 142 | GSC_CLIENTS_notify_client_about_neighbour ( |
144 | const struct GNUNET_PeerIdentity *neighbour, | 143 | struct GSC_Client *client, |
145 | const struct GSC_TypeMap *tmap_old, | 144 | const struct GNUNET_PeerIdentity *neighbour, |
146 | const struct GSC_TypeMap *tmap_new); | 145 | const struct GSC_TypeMap *tmap_old, |
146 | const struct GSC_TypeMap *tmap_new); | ||
147 | 147 | ||
148 | 148 | ||
149 | /** | 149 | /** |
@@ -174,9 +174,10 @@ GSC_CLIENTS_deliver_message (const struct GNUNET_PeerIdentity *sender, | |||
174 | * @param tmap_new updated type map for the neighbour, NULL for disconnect | 174 | * @param tmap_new updated type map for the neighbour, NULL for disconnect |
175 | */ | 175 | */ |
176 | void | 176 | void |
177 | GSC_CLIENTS_notify_clients_about_neighbour (const struct GNUNET_PeerIdentity *neighbour, | 177 | GSC_CLIENTS_notify_clients_about_neighbour ( |
178 | const struct GSC_TypeMap *tmap_old, | 178 | const struct GNUNET_PeerIdentity *neighbour, |
179 | const struct GSC_TypeMap *tmap_new); | 179 | const struct GSC_TypeMap *tmap_old, |
180 | const struct GSC_TypeMap *tmap_new); | ||
180 | 181 | ||
181 | 182 | ||
182 | /** | 183 | /** |
diff --git a/src/core/gnunet-service-core_sessions.c b/src/core/gnunet-service-core_sessions.c index 4f678c784..8ff61ec20 100644 --- a/src/core/gnunet-service-core_sessions.c +++ b/src/core/gnunet-service-core_sessions.c | |||
@@ -11,7 +11,7 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
@@ -59,7 +59,7 @@ struct SessionMessageEntry | |||
59 | /** | 59 | /** |
60 | * How important is this message. | 60 | * How important is this message. |
61 | */ | 61 | */ |
62 | enum GNUNET_CORE_Priority priority; | 62 | enum GNUNET_MQ_PriorityPreferences priority; |
63 | 63 | ||
64 | /** | 64 | /** |
65 | * Flag set to #GNUNET_YES if this is a typemap message. | 65 | * Flag set to #GNUNET_YES if this is a typemap message. |
@@ -84,7 +84,6 @@ struct SessionMessageEntry | |||
84 | * MessageEntry` itself!) | 84 | * MessageEntry` itself!) |
85 | */ | 85 | */ |
86 | size_t size; | 86 | size_t size; |
87 | |||
88 | }; | 87 | }; |
89 | 88 | ||
90 | 89 | ||
@@ -177,7 +176,6 @@ struct TypeMapConfirmationMessage | |||
177 | * Hash of the (decompressed) type map that was received. | 176 | * Hash of the (decompressed) type map that was received. |
178 | */ | 177 | */ |
179 | struct GNUNET_HashCode tm_hash; | 178 | struct GNUNET_HashCode tm_hash; |
180 | |||
181 | }; | 179 | }; |
182 | 180 | ||
183 | GNUNET_NETWORK_STRUCT_END | 181 | GNUNET_NETWORK_STRUCT_END |
@@ -201,8 +199,7 @@ find_session (const struct GNUNET_PeerIdentity *peer) | |||
201 | { | 199 | { |
202 | if (NULL == sessions) | 200 | if (NULL == sessions) |
203 | return NULL; | 201 | return NULL; |
204 | return GNUNET_CONTAINER_multipeermap_get (sessions, | 202 | return GNUNET_CONTAINER_multipeermap_get (sessions, peer); |
205 | peer); | ||
206 | } | 203 | } |
207 | 204 | ||
208 | 205 | ||
@@ -233,15 +230,13 @@ GSC_SESSIONS_end (const struct GNUNET_PeerIdentity *pid) | |||
233 | while (NULL != (car = session->active_client_request_head)) | 230 | while (NULL != (car = session->active_client_request_head)) |
234 | { | 231 | { |
235 | GNUNET_CONTAINER_DLL_remove (session->active_client_request_head, | 232 | GNUNET_CONTAINER_DLL_remove (session->active_client_request_head, |
236 | session->active_client_request_tail, car); | 233 | session->active_client_request_tail, |
237 | GSC_CLIENTS_reject_request (car, | 234 | car); |
238 | GNUNET_NO); | 235 | GSC_CLIENTS_reject_request (car, GNUNET_NO); |
239 | } | 236 | } |
240 | while (NULL != (sme = session->sme_head)) | 237 | while (NULL != (sme = session->sme_head)) |
241 | { | 238 | { |
242 | GNUNET_CONTAINER_DLL_remove (session->sme_head, | 239 | GNUNET_CONTAINER_DLL_remove (session->sme_head, session->sme_tail, sme); |
243 | session->sme_tail, | ||
244 | sme); | ||
245 | GNUNET_free (sme); | 240 | GNUNET_free (sme); |
246 | } | 241 | } |
247 | if (NULL != session->typemap_task) | 242 | if (NULL != session->typemap_task) |
@@ -251,13 +246,12 @@ GSC_SESSIONS_end (const struct GNUNET_PeerIdentity *pid) | |||
251 | } | 246 | } |
252 | GSC_CLIENTS_notify_clients_about_neighbour (session->peer, | 247 | GSC_CLIENTS_notify_clients_about_neighbour (session->peer, |
253 | session->tmap, | 248 | session->tmap, |
254 | NULL); | 249 | NULL); |
255 | GNUNET_assert (GNUNET_YES == | 250 | GNUNET_assert ( |
256 | GNUNET_CONTAINER_multipeermap_remove (sessions, | 251 | GNUNET_YES == |
257 | session->peer, | 252 | GNUNET_CONTAINER_multipeermap_remove (sessions, session->peer, session)); |
258 | session)); | ||
259 | GNUNET_STATISTICS_set (GSC_stats, | 253 | GNUNET_STATISTICS_set (GSC_stats, |
260 | gettext_noop ("# peers connected"), | 254 | gettext_noop ("# peers connected"), |
261 | GNUNET_CONTAINER_multipeermap_size (sessions), | 255 | GNUNET_CONTAINER_multipeermap_size (sessions), |
262 | GNUNET_NO); | 256 | GNUNET_NO); |
263 | GSC_TYPEMAP_destroy (session->tmap); | 257 | GSC_TYPEMAP_destroy (session->tmap); |
@@ -286,20 +280,15 @@ transmit_typemap_task (void *cls) | |||
286 | delay = session->typemap_delay; | 280 | delay = session->typemap_delay; |
287 | /* randomize a bit to avoid spont. sync */ | 281 | /* randomize a bit to avoid spont. sync */ |
288 | delay.rel_value_us += | 282 | delay.rel_value_us += |
289 | GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, | 283 | GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 1000 * 1000); |
290 | 1000 * 1000); | ||
291 | session->typemap_task = | 284 | session->typemap_task = |
292 | GNUNET_SCHEDULER_add_delayed (delay, | 285 | GNUNET_SCHEDULER_add_delayed (delay, &transmit_typemap_task, session); |
293 | &transmit_typemap_task, | ||
294 | session); | ||
295 | GNUNET_STATISTICS_update (GSC_stats, | 286 | GNUNET_STATISTICS_update (GSC_stats, |
296 | gettext_noop ("# type map refreshes sent"), | 287 | gettext_noop ("# type map refreshes sent"), |
297 | 1, | 288 | 1, |
298 | GNUNET_NO); | 289 | GNUNET_NO); |
299 | hdr = GSC_TYPEMAP_compute_type_map_message (); | 290 | hdr = GSC_TYPEMAP_compute_type_map_message (); |
300 | GSC_KX_encrypt_and_transmit (session->kx, | 291 | GSC_KX_encrypt_and_transmit (session->kx, hdr, ntohs (hdr->size)); |
301 | hdr, | ||
302 | ntohs (hdr->size)); | ||
303 | GNUNET_free (hdr); | 292 | GNUNET_free (hdr); |
304 | } | 293 | } |
305 | 294 | ||
@@ -315,10 +304,9 @@ start_typemap_task (struct Session *session) | |||
315 | if (NULL != session->typemap_task) | 304 | if (NULL != session->typemap_task) |
316 | GNUNET_SCHEDULER_cancel (session->typemap_task); | 305 | GNUNET_SCHEDULER_cancel (session->typemap_task); |
317 | session->typemap_delay = GNUNET_TIME_UNIT_SECONDS; | 306 | session->typemap_delay = GNUNET_TIME_UNIT_SECONDS; |
318 | session->typemap_task = | 307 | session->typemap_task = GNUNET_SCHEDULER_add_delayed (session->typemap_delay, |
319 | GNUNET_SCHEDULER_add_delayed (session->typemap_delay, | 308 | &transmit_typemap_task, |
320 | &transmit_typemap_task, | 309 | session); |
321 | session); | ||
322 | } | 310 | } |
323 | 311 | ||
324 | 312 | ||
@@ -342,17 +330,16 @@ GSC_SESSIONS_create (const struct GNUNET_PeerIdentity *peer, | |||
342 | session->peer = peer; | 330 | session->peer = peer; |
343 | session->kx = kx; | 331 | session->kx = kx; |
344 | GNUNET_assert (GNUNET_OK == | 332 | GNUNET_assert (GNUNET_OK == |
345 | GNUNET_CONTAINER_multipeermap_put (sessions, | 333 | GNUNET_CONTAINER_multipeermap_put ( |
346 | session->peer, | 334 | sessions, |
347 | session, | 335 | session->peer, |
348 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 336 | session, |
337 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | ||
349 | GNUNET_STATISTICS_set (GSC_stats, | 338 | GNUNET_STATISTICS_set (GSC_stats, |
350 | gettext_noop ("# peers connected"), | 339 | gettext_noop ("# peers connected"), |
351 | GNUNET_CONTAINER_multipeermap_size (sessions), | 340 | GNUNET_CONTAINER_multipeermap_size (sessions), |
352 | GNUNET_NO); | 341 | GNUNET_NO); |
353 | GSC_CLIENTS_notify_clients_about_neighbour (peer, | 342 | GSC_CLIENTS_notify_clients_about_neighbour (peer, NULL, session->tmap); |
354 | NULL, | ||
355 | session->tmap); | ||
356 | start_typemap_task (session); | 343 | start_typemap_task (session); |
357 | } | 344 | } |
358 | 345 | ||
@@ -406,15 +393,15 @@ GSC_SESSIONS_confirm_typemap (const struct GNUNET_PeerIdentity *peer, | |||
406 | return; | 393 | return; |
407 | } | 394 | } |
408 | cmsg = (const struct TypeMapConfirmationMessage *) msg; | 395 | cmsg = (const struct TypeMapConfirmationMessage *) msg; |
409 | if (GNUNET_YES != | 396 | if (GNUNET_YES != GSC_TYPEMAP_check_hash (&cmsg->tm_hash)) |
410 | GSC_TYPEMAP_check_hash (&cmsg->tm_hash)) | ||
411 | { | 397 | { |
412 | /* our typemap has changed in the meantime, do not | 398 | /* our typemap has changed in the meantime, do not |
413 | accept confirmation */ | 399 | accept confirmation */ |
414 | GNUNET_STATISTICS_update (GSC_stats, | 400 | GNUNET_STATISTICS_update (GSC_stats, |
415 | gettext_noop | 401 | gettext_noop ( |
416 | ("# outdated typemap confirmations received"), | 402 | "# outdated typemap confirmations received"), |
417 | 1, GNUNET_NO); | 403 | 1, |
404 | GNUNET_NO); | ||
418 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 405 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
419 | "Got outdated typemap confirmated from peer `%s'\n", | 406 | "Got outdated typemap confirmated from peer `%s'\n", |
420 | GNUNET_i2s (session->peer)); | 407 | GNUNET_i2s (session->peer)); |
@@ -429,9 +416,10 @@ GSC_SESSIONS_confirm_typemap (const struct GNUNET_PeerIdentity *peer, | |||
429 | session->typemap_task = NULL; | 416 | session->typemap_task = NULL; |
430 | } | 417 | } |
431 | GNUNET_STATISTICS_update (GSC_stats, | 418 | GNUNET_STATISTICS_update (GSC_stats, |
432 | gettext_noop | 419 | gettext_noop ( |
433 | ("# valid typemap confirmations received"), | 420 | "# valid typemap confirmations received"), |
434 | 1, GNUNET_NO); | 421 | 1, |
422 | GNUNET_NO); | ||
435 | } | 423 | } |
436 | 424 | ||
437 | 425 | ||
@@ -453,7 +441,7 @@ notify_client_about_session (void *cls, | |||
453 | 441 | ||
454 | GSC_CLIENTS_notify_client_about_neighbour (client, | 442 | GSC_CLIENTS_notify_client_about_neighbour (client, |
455 | session->peer, | 443 | session->peer, |
456 | NULL, /* old TMAP: none */ | 444 | NULL, /* old TMAP: none */ |
457 | session->tmap); | 445 | session->tmap); |
458 | return GNUNET_OK; | 446 | return GNUNET_OK; |
459 | } | 447 | } |
@@ -503,16 +491,14 @@ GSC_SESSIONS_queue_request (struct GSC_ClientActiveRequest *car) | |||
503 | { | 491 | { |
504 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 492 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
505 | "Dropped client request for transmission (am disconnected)\n"); | 493 | "Dropped client request for transmission (am disconnected)\n"); |
506 | GNUNET_break (0); /* should have been rejected earlier */ | 494 | GNUNET_break (0); /* should have been rejected earlier */ |
507 | GSC_CLIENTS_reject_request (car, | 495 | GSC_CLIENTS_reject_request (car, GNUNET_NO); |
508 | GNUNET_NO); | ||
509 | return; | 496 | return; |
510 | } | 497 | } |
511 | if (car->msize > GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE) | 498 | if (car->msize > GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE) |
512 | { | 499 | { |
513 | GNUNET_break (0); | 500 | GNUNET_break (0); |
514 | GSC_CLIENTS_reject_request (car, | 501 | GSC_CLIENTS_reject_request (car, GNUNET_YES); |
515 | GNUNET_YES); | ||
516 | return; | 502 | return; |
517 | } | 503 | } |
518 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 504 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
@@ -535,10 +521,9 @@ GSC_SESSIONS_dequeue_request (struct GSC_ClientActiveRequest *car) | |||
535 | { | 521 | { |
536 | struct Session *session; | 522 | struct Session *session; |
537 | 523 | ||
538 | if (0 == | 524 | if (0 == memcmp (&car->target, |
539 | memcmp (&car->target, | 525 | &GSC_my_identity, |
540 | &GSC_my_identity, | 526 | sizeof (struct GNUNET_PeerIdentity))) |
541 | sizeof (struct GNUNET_PeerIdentity))) | ||
542 | return; | 527 | return; |
543 | session = find_session (&car->target); | 528 | session = find_session (&car->target); |
544 | GNUNET_assert (NULL != session); | 529 | GNUNET_assert (NULL != session); |
@@ -560,21 +545,20 @@ GSC_SESSIONS_dequeue_request (struct GSC_ClientActiveRequest *car) | |||
560 | * @param msize how many bytes do we have already | 545 | * @param msize how many bytes do we have already |
561 | */ | 546 | */ |
562 | static void | 547 | static void |
563 | solicit_messages (struct Session *session, | 548 | solicit_messages (struct Session *session, size_t msize) |
564 | size_t msize) | ||
565 | { | 549 | { |
566 | struct GSC_ClientActiveRequest *car; | 550 | struct GSC_ClientActiveRequest *car; |
567 | struct GSC_ClientActiveRequest *nxt; | 551 | struct GSC_ClientActiveRequest *nxt; |
568 | size_t so_size; | 552 | size_t so_size; |
569 | enum GNUNET_CORE_Priority pmax; | 553 | enum GNUNET_MQ_PriorityPreferences pmax; |
570 | 554 | ||
571 | so_size = msize; | 555 | so_size = msize; |
572 | pmax = GNUNET_CORE_PRIO_BACKGROUND; | 556 | pmax = GNUNET_MQ_PRIO_BACKGROUND; |
573 | for (car = session->active_client_request_head; NULL != car; car = car->next) | 557 | for (car = session->active_client_request_head; NULL != car; car = car->next) |
574 | { | 558 | { |
575 | if (GNUNET_YES == car->was_solicited) | 559 | if (GNUNET_YES == car->was_solicited) |
576 | continue; | 560 | continue; |
577 | pmax = GNUNET_MAX (pmax, car->priority); | 561 | pmax = GNUNET_MAX (pmax, car->priority & GNUNET_MQ_PRIORITY_MASK); |
578 | } | 562 | } |
579 | nxt = session->active_client_request_head; | 563 | nxt = session->active_client_request_head; |
580 | while (NULL != (car = nxt)) | 564 | while (NULL != (car = nxt)) |
@@ -631,11 +615,11 @@ try_transmission (struct Session *session) | |||
631 | size_t msize; | 615 | size_t msize; |
632 | struct GNUNET_TIME_Absolute now; | 616 | struct GNUNET_TIME_Absolute now; |
633 | struct GNUNET_TIME_Absolute min_deadline; | 617 | struct GNUNET_TIME_Absolute min_deadline; |
634 | enum GNUNET_CORE_Priority maxp; | 618 | enum GNUNET_MQ_PriorityPreferences maxp; |
635 | enum GNUNET_CORE_Priority maxpc; | 619 | enum GNUNET_MQ_PriorityPreferences maxpc; |
636 | struct GSC_ClientActiveRequest *car; | 620 | struct GSC_ClientActiveRequest *car; |
637 | int excess; | 621 | int excess; |
638 | 622 | ||
639 | msize = 0; | 623 | msize = 0; |
640 | min_deadline = GNUNET_TIME_UNIT_FOREVER_ABS; | 624 | min_deadline = GNUNET_TIME_UNIT_FOREVER_ABS; |
641 | /* if the peer has excess bandwidth, background traffic is allowed, | 625 | /* if the peer has excess bandwidth, background traffic is allowed, |
@@ -649,9 +633,9 @@ try_transmission (struct Session *session) | |||
649 | } | 633 | } |
650 | excess = GSC_NEIGHBOURS_check_excess_bandwidth (session->kx); | 634 | excess = GSC_NEIGHBOURS_check_excess_bandwidth (session->kx); |
651 | if (GNUNET_YES == excess) | 635 | if (GNUNET_YES == excess) |
652 | maxp = GNUNET_CORE_PRIO_BACKGROUND; | 636 | maxp = GNUNET_MQ_PRIO_BACKGROUND; |
653 | else | 637 | else |
654 | maxp = GNUNET_CORE_PRIO_BEST_EFFORT; | 638 | maxp = GNUNET_MQ_PRIO_BEST_EFFORT; |
655 | /* determine highest priority of 'ready' messages we already solicited from clients */ | 639 | /* determine highest priority of 'ready' messages we already solicited from clients */ |
656 | pos = session->sme_head; | 640 | pos = session->sme_head; |
657 | while ((NULL != pos) && | 641 | while ((NULL != pos) && |
@@ -659,32 +643,33 @@ try_transmission (struct Session *session) | |||
659 | { | 643 | { |
660 | GNUNET_assert (pos->size < GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE); | 644 | GNUNET_assert (pos->size < GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE); |
661 | msize += pos->size; | 645 | msize += pos->size; |
662 | maxp = GNUNET_MAX (maxp, pos->priority); | 646 | maxp = GNUNET_MAX (maxp, pos->priority & GNUNET_MQ_PRIORITY_MASK); |
663 | min_deadline = GNUNET_TIME_absolute_min (min_deadline, | 647 | min_deadline = GNUNET_TIME_absolute_min (min_deadline, pos->deadline); |
664 | pos->deadline); | ||
665 | pos = pos->next; | 648 | pos = pos->next; |
666 | } | 649 | } |
667 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 650 | GNUNET_log ( |
668 | "Calculating transmission set with %u priority (%s) and %s earliest deadline\n", | 651 | GNUNET_ERROR_TYPE_DEBUG, |
669 | maxp, | 652 | "Calculating transmission set with %u priority (%s) and %s earliest deadline\n", |
670 | (GNUNET_YES == excess) ? "excess bandwidth" : "limited bandwidth", | 653 | maxp, |
671 | GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (min_deadline), | 654 | (GNUNET_YES == excess) ? "excess bandwidth" : "limited bandwidth", |
672 | GNUNET_YES)); | 655 | GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining ( |
673 | 656 | min_deadline), | |
674 | if (maxp < GNUNET_CORE_PRIO_CRITICAL_CONTROL) | 657 | GNUNET_YES)); |
658 | |||
659 | if (maxp < GNUNET_MQ_PRIO_CRITICAL_CONTROL) | ||
675 | { | 660 | { |
676 | /* if highest already solicited priority from clients is not critical, | 661 | /* if highest already solicited priority from clients is not critical, |
677 | check if there are higher-priority messages to be solicited from clients */ | 662 | check if there are higher-priority messages to be solicited from clients */ |
678 | if (GNUNET_YES == excess) | 663 | if (GNUNET_YES == excess) |
679 | maxpc = GNUNET_CORE_PRIO_BACKGROUND; | 664 | maxpc = GNUNET_MQ_PRIO_BACKGROUND; |
680 | else | 665 | else |
681 | maxpc = GNUNET_CORE_PRIO_BEST_EFFORT; | 666 | maxpc = GNUNET_MQ_PRIO_BEST_EFFORT; |
682 | for (car = session->active_client_request_head; NULL != car; car = car->next) | 667 | for (car = session->active_client_request_head; NULL != car; |
668 | car = car->next) | ||
683 | { | 669 | { |
684 | if (GNUNET_YES == car->was_solicited) | 670 | if (GNUNET_YES == car->was_solicited) |
685 | continue; | 671 | continue; |
686 | maxpc = GNUNET_MAX (maxpc, | 672 | maxpc = GNUNET_MAX (maxpc, car->priority & GNUNET_MQ_PRIORITY_MASK); |
687 | car->priority); | ||
688 | } | 673 | } |
689 | if (maxpc > maxp) | 674 | if (maxpc > maxp) |
690 | { | 675 | { |
@@ -703,41 +688,40 @@ try_transmission (struct Session *session) | |||
703 | { | 688 | { |
704 | /* never solicit more, we have critical messages to process */ | 689 | /* never solicit more, we have critical messages to process */ |
705 | excess = GNUNET_NO; | 690 | excess = GNUNET_NO; |
706 | maxpc = GNUNET_CORE_PRIO_BACKGROUND; | 691 | maxpc = GNUNET_MQ_PRIO_BACKGROUND; |
707 | } | 692 | } |
708 | now = GNUNET_TIME_absolute_get (); | 693 | now = GNUNET_TIME_absolute_get (); |
709 | if ( ( (GNUNET_YES == excess) || | 694 | if (((GNUNET_YES == excess) || (maxpc >= GNUNET_MQ_PRIO_BEST_EFFORT)) && |
710 | (maxpc >= GNUNET_CORE_PRIO_BEST_EFFORT) ) && | 695 | ((0 == msize) || |
711 | ( (0 == msize) || | 696 | ((msize < GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE / 2) && |
712 | ( (msize < GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE / 2) && | 697 | (min_deadline.abs_value_us > now.abs_value_us)))) |
713 | (min_deadline.abs_value_us > now.abs_value_us))) ) | ||
714 | { | 698 | { |
715 | /* not enough ready yet (tiny message & cork possible), or no messages at all, | 699 | /* not enough ready yet (tiny message & cork possible), or no messages at all, |
716 | and either excess bandwidth or best-effort or higher message waiting at | 700 | and either excess bandwidth or best-effort or higher message waiting at |
717 | client; in this case, we try to solicit more */ | 701 | client; in this case, we try to solicit more */ |
718 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 702 | GNUNET_log ( |
719 | "Soliciting messages (excess %d, maxpc %d, message size %u, deadline %s)\n", | 703 | GNUNET_ERROR_TYPE_DEBUG, |
720 | excess, | 704 | "Soliciting messages (excess %d, maxpc %d, message size %u, deadline %s)\n", |
721 | maxpc, | 705 | excess, |
722 | (unsigned int) msize, | 706 | maxpc, |
723 | GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (min_deadline), | 707 | (unsigned int) msize, |
724 | GNUNET_YES)); | 708 | GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining ( |
725 | solicit_messages (session, | 709 | min_deadline), |
726 | msize); | 710 | GNUNET_YES)); |
711 | solicit_messages (session, msize); | ||
727 | if (msize > 0) | 712 | if (msize > 0) |
728 | { | 713 | { |
729 | /* if there is data to send, just not yet, make sure we do transmit | 714 | /* if there is data to send, just not yet, make sure we do transmit |
730 | * it once the deadline is reached */ | 715 | * it once the deadline is reached */ |
731 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 716 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
732 | "Corking until %s\n", | 717 | "Corking until %s\n", |
733 | GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (min_deadline), | 718 | GNUNET_STRINGS_relative_time_to_string ( |
734 | GNUNET_YES)); | 719 | GNUNET_TIME_absolute_get_remaining (min_deadline), |
720 | GNUNET_YES)); | ||
735 | if (NULL != session->cork_task) | 721 | if (NULL != session->cork_task) |
736 | GNUNET_SCHEDULER_cancel (session->cork_task); | 722 | GNUNET_SCHEDULER_cancel (session->cork_task); |
737 | session->cork_task | 723 | session->cork_task = |
738 | = GNUNET_SCHEDULER_add_at (min_deadline, | 724 | GNUNET_SCHEDULER_add_at (min_deadline, &pop_cork_task, session); |
739 | &pop_cork_task, | ||
740 | session); | ||
741 | } | 725 | } |
742 | else | 726 | else |
743 | { | 727 | { |
@@ -753,26 +737,21 @@ try_transmission (struct Session *session) | |||
753 | { | 737 | { |
754 | static unsigned long long total_bytes; | 738 | static unsigned long long total_bytes; |
755 | static unsigned int total_msgs; | 739 | static unsigned int total_msgs; |
756 | char pbuf[msize]; /* plaintext */ | 740 | char pbuf[msize]; /* plaintext */ |
757 | size_t used; | 741 | size_t used; |
758 | 742 | ||
759 | used = 0; | 743 | used = 0; |
760 | while ( (NULL != (pos = session->sme_head)) && | 744 | while ((NULL != (pos = session->sme_head)) && (used + pos->size <= msize)) |
761 | (used + pos->size <= msize) ) | ||
762 | { | 745 | { |
763 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 746 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
764 | "Adding message of type %d (%d/%d) to payload for %s\n", | 747 | "Adding message of type %d (%d/%d) to payload for %s\n", |
765 | ntohs (((const struct GNUNET_MessageHeader *)&pos[1])->type), | 748 | ntohs (((const struct GNUNET_MessageHeader *) &pos[1])->type), |
766 | pos->is_typemap, | 749 | pos->is_typemap, |
767 | pos->is_typemap_confirm, | 750 | pos->is_typemap_confirm, |
768 | GNUNET_i2s (session->peer)); | 751 | GNUNET_i2s (session->peer)); |
769 | GNUNET_memcpy (&pbuf[used], | 752 | GNUNET_memcpy (&pbuf[used], &pos[1], pos->size); |
770 | &pos[1], | ||
771 | pos->size); | ||
772 | used += pos->size; | 753 | used += pos->size; |
773 | GNUNET_CONTAINER_DLL_remove (session->sme_head, | 754 | GNUNET_CONTAINER_DLL_remove (session->sme_head, session->sme_tail, pos); |
774 | session->sme_tail, | ||
775 | pos); | ||
776 | GNUNET_free (pos); | 755 | GNUNET_free (pos); |
777 | } | 756 | } |
778 | /* compute average payload size */ | 757 | /* compute average payload size */ |
@@ -789,9 +768,7 @@ try_transmission (struct Session *session) | |||
789 | total_bytes / total_msgs, | 768 | total_bytes / total_msgs, |
790 | GNUNET_NO); | 769 | GNUNET_NO); |
791 | /* now actually transmit... */ | 770 | /* now actually transmit... */ |
792 | GSC_KX_encrypt_and_transmit (session->kx, | 771 | GSC_KX_encrypt_and_transmit (session->kx, pbuf, used); |
793 | pbuf, | ||
794 | used); | ||
795 | } | 772 | } |
796 | } | 773 | } |
797 | 774 | ||
@@ -823,23 +800,17 @@ do_restart_typemap_message (void *cls, | |||
823 | { | 800 | { |
824 | if (GNUNET_YES == sme->is_typemap) | 801 | if (GNUNET_YES == sme->is_typemap) |
825 | { | 802 | { |
826 | GNUNET_CONTAINER_DLL_remove (session->sme_head, | 803 | GNUNET_CONTAINER_DLL_remove (session->sme_head, session->sme_tail, sme); |
827 | session->sme_tail, | ||
828 | sme); | ||
829 | GNUNET_free (sme); | 804 | GNUNET_free (sme); |
830 | break; | 805 | break; |
831 | } | 806 | } |
832 | } | 807 | } |
833 | sme = GNUNET_malloc (sizeof (struct SessionMessageEntry) + size); | 808 | sme = GNUNET_malloc (sizeof (struct SessionMessageEntry) + size); |
834 | sme->is_typemap = GNUNET_YES; | 809 | sme->is_typemap = GNUNET_YES; |
835 | GNUNET_memcpy (&sme[1], | 810 | GNUNET_memcpy (&sme[1], hdr, size); |
836 | hdr, | ||
837 | size); | ||
838 | sme->size = size; | 811 | sme->size = size; |
839 | sme->priority = GNUNET_CORE_PRIO_CRITICAL_CONTROL; | 812 | sme->priority = GNUNET_MQ_PRIO_CRITICAL_CONTROL; |
840 | GNUNET_CONTAINER_DLL_insert (session->sme_head, | 813 | GNUNET_CONTAINER_DLL_insert (session->sme_head, session->sme_tail, sme); |
841 | session->sme_tail, | ||
842 | sme); | ||
843 | try_transmission (session); | 814 | try_transmission (session); |
844 | start_typemap_task (session); | 815 | start_typemap_task (session); |
845 | return GNUNET_OK; | 816 | return GNUNET_OK; |
@@ -876,8 +847,8 @@ GSC_SESSIONS_solicit (const struct GNUNET_PeerIdentity *pid) | |||
876 | struct Session *session; | 847 | struct Session *session; |
877 | 848 | ||
878 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 849 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
879 | "Transport solicits for %s\n", | 850 | "Transport solicits for %s\n", |
880 | GNUNET_i2s (pid)); | 851 | GNUNET_i2s (pid)); |
881 | session = find_session (pid); | 852 | session = find_session (pid); |
882 | if (NULL == session) | 853 | if (NULL == session) |
883 | return; | 854 | return; |
@@ -891,14 +862,12 @@ GSC_SESSIONS_solicit (const struct GNUNET_PeerIdentity *pid) | |||
891 | * @param car original request that was queued and then solicited; | 862 | * @param car original request that was queued and then solicited; |
892 | * this handle will now be 'owned' by the SESSIONS subsystem | 863 | * this handle will now be 'owned' by the SESSIONS subsystem |
893 | * @param msg message to transmit | 864 | * @param msg message to transmit |
894 | * @param cork is corking allowed? | ||
895 | * @param priority how important is this message | 865 | * @param priority how important is this message |
896 | */ | 866 | */ |
897 | void | 867 | void |
898 | GSC_SESSIONS_transmit (struct GSC_ClientActiveRequest *car, | 868 | GSC_SESSIONS_transmit (struct GSC_ClientActiveRequest *car, |
899 | const struct GNUNET_MessageHeader *msg, | 869 | const struct GNUNET_MessageHeader *msg, |
900 | int cork, | 870 | enum GNUNET_MQ_PriorityPreferences priority) |
901 | enum GNUNET_CORE_Priority priority) | ||
902 | { | 871 | { |
903 | struct Session *session; | 872 | struct Session *session; |
904 | struct SessionMessageEntry *sme; | 873 | struct SessionMessageEntry *sme; |
@@ -910,21 +879,18 @@ GSC_SESSIONS_transmit (struct GSC_ClientActiveRequest *car, | |||
910 | return; | 879 | return; |
911 | msize = ntohs (msg->size); | 880 | msize = ntohs (msg->size); |
912 | sme = GNUNET_malloc (sizeof (struct SessionMessageEntry) + msize); | 881 | sme = GNUNET_malloc (sizeof (struct SessionMessageEntry) + msize); |
913 | GNUNET_memcpy (&sme[1], | 882 | GNUNET_memcpy (&sme[1], msg, msize); |
914 | msg, | ||
915 | msize); | ||
916 | sme->size = msize; | 883 | sme->size = msize; |
917 | sme->priority = priority; | 884 | sme->priority = priority; |
918 | if (GNUNET_YES == cork) | 885 | if (0 != (GNUNET_MQ_PREF_CORK_ALLOWED & priority)) |
919 | { | 886 | { |
920 | sme->deadline = | 887 | sme->deadline = |
921 | GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_MAX_CORK_DELAY); | 888 | GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_MAX_CORK_DELAY); |
922 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 889 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
923 | "Mesage corked, delaying transmission\n"); | 890 | "Mesage corked, delaying transmission\n"); |
924 | } | 891 | } |
925 | pos = session->sme_head; | 892 | pos = session->sme_head; |
926 | while ( (NULL != pos) && | 893 | while ((NULL != pos) && (pos->priority >= sme->priority)) |
927 | (pos->priority >= sme->priority) ) | ||
928 | pos = pos->next; | 894 | pos = pos->next; |
929 | if (NULL == pos) | 895 | if (NULL == pos) |
930 | GNUNET_CONTAINER_DLL_insert_tail (session->sme_head, | 896 | GNUNET_CONTAINER_DLL_insert_tail (session->sme_head, |
@@ -959,7 +925,7 @@ GSC_SESSIONS_set_typemap (const struct GNUNET_PeerIdentity *peer, | |||
959 | if (NULL == nmap) | 925 | if (NULL == nmap) |
960 | { | 926 | { |
961 | GNUNET_break_op (0); | 927 | GNUNET_break_op (0); |
962 | return; /* malformed */ | 928 | return; /* malformed */ |
963 | } | 929 | } |
964 | session = find_session (peer); | 930 | session = find_session (peer); |
965 | if (NULL == session) | 931 | if (NULL == session) |
@@ -975,9 +941,7 @@ GSC_SESSIONS_set_typemap (const struct GNUNET_PeerIdentity *peer, | |||
975 | { | 941 | { |
976 | if (GNUNET_YES == sme->is_typemap_confirm) | 942 | if (GNUNET_YES == sme->is_typemap_confirm) |
977 | { | 943 | { |
978 | GNUNET_CONTAINER_DLL_remove (session->sme_head, | 944 | GNUNET_CONTAINER_DLL_remove (session->sme_head, session->sme_tail, sme); |
979 | session->sme_tail, | ||
980 | sme); | ||
981 | GNUNET_free (sme); | 945 | GNUNET_free (sme); |
982 | break; | 946 | break; |
983 | } | 947 | } |
@@ -986,21 +950,16 @@ GSC_SESSIONS_set_typemap (const struct GNUNET_PeerIdentity *peer, | |||
986 | sizeof (struct TypeMapConfirmationMessage)); | 950 | sizeof (struct TypeMapConfirmationMessage)); |
987 | sme->deadline = GNUNET_TIME_absolute_get (); | 951 | sme->deadline = GNUNET_TIME_absolute_get (); |
988 | sme->size = sizeof (struct TypeMapConfirmationMessage); | 952 | sme->size = sizeof (struct TypeMapConfirmationMessage); |
989 | sme->priority = GNUNET_CORE_PRIO_CRITICAL_CONTROL; | 953 | sme->priority = GNUNET_MQ_PRIO_CRITICAL_CONTROL; |
990 | sme->is_typemap_confirm = GNUNET_YES; | 954 | sme->is_typemap_confirm = GNUNET_YES; |
991 | tmc = (struct TypeMapConfirmationMessage *) &sme[1]; | 955 | tmc = (struct TypeMapConfirmationMessage *) &sme[1]; |
992 | tmc->header.size = htons (sizeof (struct TypeMapConfirmationMessage)); | 956 | tmc->header.size = htons (sizeof (struct TypeMapConfirmationMessage)); |
993 | tmc->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_CONFIRM_TYPE_MAP); | 957 | tmc->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_CONFIRM_TYPE_MAP); |
994 | tmc->reserved = htonl (0); | 958 | tmc->reserved = htonl (0); |
995 | GSC_TYPEMAP_hash (nmap, | 959 | GSC_TYPEMAP_hash (nmap, &tmc->tm_hash); |
996 | &tmc->tm_hash); | 960 | GNUNET_CONTAINER_DLL_insert (session->sme_head, session->sme_tail, sme); |
997 | GNUNET_CONTAINER_DLL_insert (session->sme_head, | ||
998 | session->sme_tail, | ||
999 | sme); | ||
1000 | try_transmission (session); | 961 | try_transmission (session); |
1001 | GSC_CLIENTS_notify_clients_about_neighbour (peer, | 962 | GSC_CLIENTS_notify_clients_about_neighbour (peer, session->tmap, nmap); |
1002 | session->tmap, | ||
1003 | nmap); | ||
1004 | GSC_TYPEMAP_destroy (session->tmap); | 963 | GSC_TYPEMAP_destroy (session->tmap); |
1005 | session->tmap = nmap; | 964 | session->tmap = nmap; |
1006 | } | 965 | } |
@@ -1021,21 +980,14 @@ GSC_SESSIONS_add_to_typemap (const struct GNUNET_PeerIdentity *peer, | |||
1021 | struct Session *session; | 980 | struct Session *session; |
1022 | struct GSC_TypeMap *nmap; | 981 | struct GSC_TypeMap *nmap; |
1023 | 982 | ||
1024 | if (0 == memcmp (peer, | 983 | if (0 == memcmp (peer, &GSC_my_identity, sizeof (struct GNUNET_PeerIdentity))) |
1025 | &GSC_my_identity, | ||
1026 | sizeof (struct GNUNET_PeerIdentity))) | ||
1027 | return; | 984 | return; |
1028 | session = find_session (peer); | 985 | session = find_session (peer); |
1029 | GNUNET_assert (NULL != session); | 986 | GNUNET_assert (NULL != session); |
1030 | if (GNUNET_YES == GSC_TYPEMAP_test_match (session->tmap, | 987 | if (GNUNET_YES == GSC_TYPEMAP_test_match (session->tmap, &type, 1)) |
1031 | &type, 1)) | 988 | return; /* already in it */ |
1032 | return; /* already in it */ | 989 | nmap = GSC_TYPEMAP_extend (session->tmap, &type, 1); |
1033 | nmap = GSC_TYPEMAP_extend (session->tmap, | 990 | GSC_CLIENTS_notify_clients_about_neighbour (peer, session->tmap, nmap); |
1034 | &type, | ||
1035 | 1); | ||
1036 | GSC_CLIENTS_notify_clients_about_neighbour (peer, | ||
1037 | session->tmap, | ||
1038 | nmap); | ||
1039 | GSC_TYPEMAP_destroy (session->tmap); | 991 | GSC_TYPEMAP_destroy (session->tmap); |
1040 | session->tmap = nmap; | 992 | session->tmap = nmap; |
1041 | } | 993 | } |
@@ -1047,8 +999,7 @@ GSC_SESSIONS_add_to_typemap (const struct GNUNET_PeerIdentity *peer, | |||
1047 | void | 999 | void |
1048 | GSC_SESSIONS_init () | 1000 | GSC_SESSIONS_init () |
1049 | { | 1001 | { |
1050 | sessions = GNUNET_CONTAINER_multipeermap_create (128, | 1002 | sessions = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES); |
1051 | GNUNET_YES); | ||
1052 | } | 1003 | } |
1053 | 1004 | ||
1054 | 1005 | ||
@@ -1083,7 +1034,7 @@ GSC_SESSIONS_done () | |||
1083 | { | 1034 | { |
1084 | GNUNET_CONTAINER_multipeermap_iterate (sessions, | 1035 | GNUNET_CONTAINER_multipeermap_iterate (sessions, |
1085 | &free_session_helper, | 1036 | &free_session_helper, |
1086 | NULL); | 1037 | NULL); |
1087 | GNUNET_CONTAINER_multipeermap_destroy (sessions); | 1038 | GNUNET_CONTAINER_multipeermap_destroy (sessions); |
1088 | sessions = NULL; | 1039 | sessions = NULL; |
1089 | } | 1040 | } |
diff --git a/src/core/gnunet-service-core_sessions.h b/src/core/gnunet-service-core_sessions.h index 9f5070d57..e92ce0962 100644 --- a/src/core/gnunet-service-core_sessions.h +++ b/src/core/gnunet-service-core_sessions.h | |||
@@ -11,7 +11,7 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
@@ -114,14 +114,12 @@ GSC_SESSIONS_dequeue_request (struct GSC_ClientActiveRequest *car); | |||
114 | * @param car original request that was queued and then solicited, | 114 | * @param car original request that was queued and then solicited, |
115 | * ownership does not change (dequeue will be called soon). | 115 | * ownership does not change (dequeue will be called soon). |
116 | * @param msg message to transmit | 116 | * @param msg message to transmit |
117 | * @param cork is corking allowed? | ||
118 | * @param priority how important is this message | 117 | * @param priority how important is this message |
119 | */ | 118 | */ |
120 | void | 119 | void |
121 | GSC_SESSIONS_transmit (struct GSC_ClientActiveRequest *car, | 120 | GSC_SESSIONS_transmit (struct GSC_ClientActiveRequest *car, |
122 | const struct GNUNET_MessageHeader *msg, | 121 | const struct GNUNET_MessageHeader *msg, |
123 | int cork, | 122 | enum GNUNET_MQ_PriorityPreferences priority); |
124 | enum GNUNET_CORE_Priority priority); | ||
125 | 123 | ||
126 | 124 | ||
127 | /** | 125 | /** |
@@ -182,5 +180,4 @@ void | |||
182 | GSC_SESSIONS_done (void); | 180 | GSC_SESSIONS_done (void); |
183 | 181 | ||
184 | 182 | ||
185 | |||
186 | #endif | 183 | #endif |
diff --git a/src/core/test_core_api.c b/src/core/test_core_api.c index 0cf88a324..1e268c3a6 100644 --- a/src/core/test_core_api.c +++ b/src/core/test_core_api.c | |||
@@ -11,7 +11,7 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
@@ -54,7 +54,16 @@ static struct GNUNET_SCHEDULER_Task *err_task; | |||
54 | 54 | ||
55 | static int ok; | 55 | static int ok; |
56 | 56 | ||
57 | #define OKPP do { ok++; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Now at stage %u at %s:%u\n", ok, __FILE__, __LINE__); } while (0) | 57 | #define OKPP \ |
58 | do \ | ||
59 | { \ | ||
60 | ok++; \ | ||
61 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, \ | ||
62 | "Now at stage %u at %s:%u\n", \ | ||
63 | ok, \ | ||
64 | __FILE__, \ | ||
65 | __LINE__); \ | ||
66 | } while (0) | ||
58 | 67 | ||
59 | 68 | ||
60 | static void | 69 | static void |
@@ -67,8 +76,7 @@ offer_hello_done (void *cls) | |||
67 | 76 | ||
68 | 77 | ||
69 | static void | 78 | static void |
70 | process_hello (void *cls, | 79 | process_hello (void *cls, const struct GNUNET_MessageHeader *message) |
71 | const struct GNUNET_MessageHeader *message) | ||
72 | { | 80 | { |
73 | struct PeerContext *p = cls; | 81 | struct PeerContext *p = cls; |
74 | 82 | ||
@@ -76,14 +84,11 @@ process_hello (void *cls, | |||
76 | "Received (my) HELLO from transport service\n"); | 84 | "Received (my) HELLO from transport service\n"); |
77 | GNUNET_assert (message != NULL); | 85 | GNUNET_assert (message != NULL); |
78 | if ((p == &p1) && (NULL == p2.oh)) | 86 | if ((p == &p1) && (NULL == p2.oh)) |
79 | p2.oh = GNUNET_TRANSPORT_offer_hello (p2.cfg, message, | 87 | p2.oh = |
80 | &offer_hello_done, | 88 | GNUNET_TRANSPORT_offer_hello (p2.cfg, message, &offer_hello_done, &p2); |
81 | &p2); | ||
82 | if ((p == &p2) && (NULL == p1.oh)) | 89 | if ((p == &p2) && (NULL == p1.oh)) |
83 | p1.oh = GNUNET_TRANSPORT_offer_hello (p1.cfg, | 90 | p1.oh = |
84 | message, | 91 | GNUNET_TRANSPORT_offer_hello (p1.cfg, message, &offer_hello_done, &p1); |
85 | &offer_hello_done, | ||
86 | &p1); | ||
87 | } | 92 | } |
88 | 93 | ||
89 | 94 | ||
@@ -131,9 +136,7 @@ terminate_task (void *cls) | |||
131 | static void | 136 | static void |
132 | terminate_task_error (void *cls) | 137 | terminate_task_error (void *cls) |
133 | { | 138 | { |
134 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 139 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ENDING ANGRILY %u\n", ok); |
135 | "ENDING ANGRILY %u\n", | ||
136 | ok); | ||
137 | GNUNET_break (0); | 140 | GNUNET_break (0); |
138 | terminate_peer (&p1); | 141 | terminate_peer (&p1); |
139 | terminate_peer (&p2); | 142 | terminate_peer (&p2); |
@@ -144,15 +147,13 @@ terminate_task_error (void *cls) | |||
144 | static void * | 147 | static void * |
145 | connect_notify (void *cls, | 148 | connect_notify (void *cls, |
146 | const struct GNUNET_PeerIdentity *peer, | 149 | const struct GNUNET_PeerIdentity *peer, |
147 | struct GNUNET_MQ_Handle *mq) | 150 | struct GNUNET_MQ_Handle *mq) |
148 | { | 151 | { |
149 | struct PeerContext *pc = cls; | 152 | struct PeerContext *pc = cls; |
150 | struct GNUNET_MQ_Envelope *env; | 153 | struct GNUNET_MQ_Envelope *env; |
151 | struct GNUNET_MessageHeader *msg; | 154 | struct GNUNET_MessageHeader *msg; |
152 | 155 | ||
153 | if (0 == memcmp (&pc->id, | 156 | if (0 == memcmp (&pc->id, peer, sizeof (struct GNUNET_PeerIdentity))) |
154 | peer, | ||
155 | sizeof (struct GNUNET_PeerIdentity))) | ||
156 | return (void *) peer; | 157 | return (void *) peer; |
157 | GNUNET_assert (pc->connect_status == 0); | 158 | GNUNET_assert (pc->connect_status == 0); |
158 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 159 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
@@ -161,26 +162,18 @@ connect_notify (void *cls, | |||
161 | pc->connect_status = 1; | 162 | pc->connect_status = 1; |
162 | if (pc == &p1) | 163 | if (pc == &p1) |
163 | { | 164 | { |
164 | uint64_t flags; | ||
165 | const void *extra; | ||
166 | |||
167 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 165 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
168 | "Asking core (1) for transmission to peer `%s'\n", | 166 | "Asking core (1) for transmission to peer `%s'\n", |
169 | GNUNET_i2s (&p2.id)); | 167 | GNUNET_i2s (&p2.id)); |
170 | env = GNUNET_MQ_msg (msg, | 168 | env = GNUNET_MQ_msg (msg, MTYPE); |
171 | MTYPE); | ||
172 | /* enable corking for this test */ | 169 | /* enable corking for this test */ |
173 | extra = GNUNET_CORE_get_mq_options (GNUNET_YES, | ||
174 | GNUNET_CORE_PRIO_BEST_EFFORT, | ||
175 | &flags); | ||
176 | GNUNET_MQ_env_set_options (env, | 170 | GNUNET_MQ_env_set_options (env, |
177 | flags, | 171 | GNUNET_MQ_PRIO_BEST_EFFORT | |
178 | extra); | 172 | GNUNET_MQ_PREF_CORK_ALLOWED); |
179 | /* now actually transmit message */ | 173 | /* now actually transmit message */ |
180 | GNUNET_assert (ok == 4); | 174 | GNUNET_assert (ok == 4); |
181 | OKPP; | 175 | OKPP; |
182 | GNUNET_MQ_send (mq, | 176 | GNUNET_MQ_send (mq, env); |
183 | env); | ||
184 | } | 177 | } |
185 | return (void *) peer; | 178 | return (void *) peer; |
186 | } | 179 | } |
@@ -188,25 +181,22 @@ connect_notify (void *cls, | |||
188 | 181 | ||
189 | static void | 182 | static void |
190 | disconnect_notify (void *cls, | 183 | disconnect_notify (void *cls, |
191 | const struct GNUNET_PeerIdentity *peer, | 184 | const struct GNUNET_PeerIdentity *peer, |
192 | void *internal_cls) | 185 | void *internal_cls) |
193 | { | 186 | { |
194 | struct PeerContext *pc = cls; | 187 | struct PeerContext *pc = cls; |
195 | 188 | ||
196 | if (0 == memcmp (&pc->id, | 189 | if (0 == memcmp (&pc->id, peer, sizeof (struct GNUNET_PeerIdentity))) |
197 | peer, | ||
198 | sizeof (struct GNUNET_PeerIdentity))) | ||
199 | return; | 190 | return; |
200 | pc->connect_status = 0; | 191 | pc->connect_status = 0; |
201 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 192 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
202 | "Encrypted connection to `%s' cut\n", | 193 | "Encrypted connection to `%s' cut\n", |
203 | GNUNET_i2s (peer)); | 194 | GNUNET_i2s (peer)); |
204 | } | 195 | } |
205 | 196 | ||
206 | 197 | ||
207 | static void | 198 | static void |
208 | handle_test (void *cls, | 199 | handle_test (void *cls, const struct GNUNET_MessageHeader *message) |
209 | const struct GNUNET_MessageHeader *message) | ||
210 | { | 200 | { |
211 | const struct GNUNET_PeerIdentity *peer = cls; | 201 | const struct GNUNET_PeerIdentity *peer = cls; |
212 | 202 | ||
@@ -216,23 +206,17 @@ handle_test (void *cls, | |||
216 | GNUNET_assert (ok == 5); | 206 | GNUNET_assert (ok == 5); |
217 | OKPP; | 207 | OKPP; |
218 | GNUNET_SCHEDULER_cancel (err_task); | 208 | GNUNET_SCHEDULER_cancel (err_task); |
219 | err_task = GNUNET_SCHEDULER_add_now (&terminate_task, | 209 | err_task = GNUNET_SCHEDULER_add_now (&terminate_task, NULL); |
220 | NULL); | ||
221 | } | 210 | } |
222 | 211 | ||
223 | 212 | ||
224 | static void | 213 | static void |
225 | init_notify (void *cls, | 214 | init_notify (void *cls, const struct GNUNET_PeerIdentity *my_identity) |
226 | const struct GNUNET_PeerIdentity *my_identity) | ||
227 | { | 215 | { |
228 | struct PeerContext *p = cls; | 216 | struct PeerContext *p = cls; |
229 | struct GNUNET_MQ_MessageHandler handlers[] = { | 217 | struct GNUNET_MQ_MessageHandler handlers[] = |
230 | GNUNET_MQ_hd_fixed_size (test, | 218 | {GNUNET_MQ_hd_fixed_size (test, MTYPE, struct GNUNET_MessageHeader, NULL), |
231 | MTYPE, | 219 | GNUNET_MQ_handler_end ()}; |
232 | struct GNUNET_MessageHeader, | ||
233 | NULL), | ||
234 | GNUNET_MQ_handler_end () | ||
235 | }; | ||
236 | 220 | ||
237 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 221 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
238 | "Core connection to `%s' established\n", | 222 | "Core connection to `%s' established\n", |
@@ -244,50 +228,46 @@ init_notify (void *cls, | |||
244 | OKPP; | 228 | OKPP; |
245 | /* connect p2 */ | 229 | /* connect p2 */ |
246 | p2.ch = GNUNET_CORE_connect (p2.cfg, | 230 | p2.ch = GNUNET_CORE_connect (p2.cfg, |
247 | &p2, | 231 | &p2, |
248 | &init_notify, | 232 | &init_notify, |
249 | &connect_notify, | 233 | &connect_notify, |
250 | &disconnect_notify, | 234 | &disconnect_notify, |
251 | handlers); | 235 | handlers); |
252 | } | 236 | } |
253 | else | 237 | else |
254 | { | 238 | { |
255 | GNUNET_assert (ok == 3); | 239 | GNUNET_assert (ok == 3); |
256 | OKPP; | 240 | OKPP; |
257 | GNUNET_assert (cls == &p2); | 241 | GNUNET_assert (cls == &p2); |
258 | p1.ats_sh = GNUNET_ATS_connectivity_suggest (p1.ats, | 242 | p1.ats_sh = GNUNET_ATS_connectivity_suggest (p1.ats, &p2.id, 1); |
259 | &p2.id, | ||
260 | 1); | ||
261 | } | 243 | } |
262 | } | 244 | } |
263 | 245 | ||
264 | 246 | ||
265 | static void | 247 | static void |
266 | setup_peer (struct PeerContext *p, | 248 | setup_peer (struct PeerContext *p, const char *cfgname) |
267 | const char *cfgname) | ||
268 | { | 249 | { |
269 | char *binary; | 250 | char *binary; |
270 | 251 | ||
271 | binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm"); | 252 | binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm"); |
272 | p->cfg = GNUNET_CONFIGURATION_create (); | 253 | p->cfg = GNUNET_CONFIGURATION_create (); |
273 | p->arm_proc = | 254 | p->arm_proc = GNUNET_OS_start_process (GNUNET_YES, |
274 | GNUNET_OS_start_process (GNUNET_YES, | 255 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, |
275 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | 256 | NULL, |
276 | NULL, NULL, NULL, | 257 | NULL, |
277 | binary, | 258 | NULL, |
278 | "gnunet-service-arm", | 259 | binary, |
279 | "-c", | 260 | "gnunet-service-arm", |
280 | cfgname, | 261 | "-c", |
281 | NULL); | 262 | cfgname, |
282 | GNUNET_assert (GNUNET_OK == | 263 | NULL); |
283 | GNUNET_CONFIGURATION_load (p->cfg, | 264 | GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); |
284 | cfgname)); | ||
285 | p->ats = GNUNET_ATS_connectivity_init (p->cfg); | 265 | p->ats = GNUNET_ATS_connectivity_init (p->cfg); |
286 | GNUNET_assert (NULL != p->ats); | 266 | GNUNET_assert (NULL != p->ats); |
287 | p->ghh = GNUNET_TRANSPORT_hello_get (p->cfg, | 267 | p->ghh = GNUNET_TRANSPORT_hello_get (p->cfg, |
288 | GNUNET_TRANSPORT_AC_ANY, | 268 | GNUNET_TRANSPORT_AC_ANY, |
289 | &process_hello, | 269 | &process_hello, |
290 | p); | 270 | p); |
291 | GNUNET_free (binary); | 271 | GNUNET_free (binary); |
292 | } | 272 | } |
293 | 273 | ||
@@ -298,47 +278,36 @@ run (void *cls, | |||
298 | const char *cfgfile, | 278 | const char *cfgfile, |
299 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 279 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
300 | { | 280 | { |
301 | struct GNUNET_MQ_MessageHandler handlers[] = { | 281 | struct GNUNET_MQ_MessageHandler handlers[] = |
302 | GNUNET_MQ_hd_fixed_size (test, | 282 | {GNUNET_MQ_hd_fixed_size (test, MTYPE, struct GNUNET_MessageHeader, NULL), |
303 | MTYPE, | 283 | GNUNET_MQ_handler_end ()}; |
304 | struct GNUNET_MessageHeader, | ||
305 | NULL), | ||
306 | GNUNET_MQ_handler_end () | ||
307 | }; | ||
308 | 284 | ||
309 | GNUNET_assert (ok == 1); | 285 | GNUNET_assert (ok == 1); |
310 | OKPP; | 286 | OKPP; |
311 | setup_peer (&p1, | 287 | setup_peer (&p1, "test_core_api_peer1.conf"); |
312 | "test_core_api_peer1.conf"); | 288 | setup_peer (&p2, "test_core_api_peer2.conf"); |
313 | setup_peer (&p2, | 289 | err_task = GNUNET_SCHEDULER_add_delayed ( |
314 | "test_core_api_peer2.conf"); | 290 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300), |
315 | err_task = | 291 | &terminate_task_error, |
316 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply | 292 | NULL); |
317 | (GNUNET_TIME_UNIT_SECONDS, 300), | 293 | p1.ch = GNUNET_CORE_connect (p1.cfg, |
318 | &terminate_task_error, NULL); | 294 | &p1, |
319 | p1.ch = | 295 | &init_notify, |
320 | GNUNET_CORE_connect (p1.cfg, | 296 | &connect_notify, |
321 | &p1, | 297 | &disconnect_notify, |
322 | &init_notify, | 298 | handlers); |
323 | &connect_notify, | ||
324 | &disconnect_notify, | ||
325 | handlers); | ||
326 | } | 299 | } |
327 | 300 | ||
328 | 301 | ||
329 | static void | 302 | static void |
330 | stop_arm (struct PeerContext *p) | 303 | stop_arm (struct PeerContext *p) |
331 | { | 304 | { |
332 | if (0 != GNUNET_OS_process_kill (p->arm_proc, | 305 | if (0 != GNUNET_OS_process_kill (p->arm_proc, GNUNET_TERM_SIG)) |
333 | GNUNET_TERM_SIG)) | 306 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); |
334 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, | 307 | if (GNUNET_OK != GNUNET_OS_process_wait (p->arm_proc)) |
335 | "kill"); | 308 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); |
336 | if (GNUNET_OK != | ||
337 | GNUNET_OS_process_wait (p->arm_proc)) | ||
338 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, | ||
339 | "waitpid"); | ||
340 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 309 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
341 | "ARM process %u stopped\n", | 310 | "ARM process %u stopped\n", |
342 | GNUNET_OS_process_get_pid (p->arm_proc)); | 311 | GNUNET_OS_process_get_pid (p->arm_proc)); |
343 | GNUNET_OS_process_destroy (p->arm_proc); | 312 | GNUNET_OS_process_destroy (p->arm_proc); |
344 | p->arm_proc = NULL; | 313 | p->arm_proc = NULL; |
@@ -347,29 +316,19 @@ stop_arm (struct PeerContext *p) | |||
347 | 316 | ||
348 | 317 | ||
349 | int | 318 | int |
350 | main (int argc, | 319 | main (int argc, char *argv1[]) |
351 | char *argv1[]) | ||
352 | { | 320 | { |
353 | char *const argv[] = { | 321 | char *const argv[] = {"test-core-api", "-c", "test_core_api_data.conf", NULL}; |
354 | "test-core-api", | 322 | struct GNUNET_GETOPT_CommandLineOption options[] = {GNUNET_GETOPT_OPTION_END}; |
355 | "-c", | ||
356 | "test_core_api_data.conf", | ||
357 | NULL | ||
358 | }; | ||
359 | struct GNUNET_GETOPT_CommandLineOption options[] = { | ||
360 | GNUNET_GETOPT_OPTION_END | ||
361 | }; | ||
362 | ok = 1; | 323 | ok = 1; |
363 | GNUNET_log_setup ("test-core-api", | 324 | GNUNET_log_setup ("test-core-api", "WARNING", NULL); |
364 | "WARNING", | ||
365 | NULL); | ||
366 | GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, | 325 | GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, |
367 | argv, | 326 | argv, |
368 | "test-core-api", | 327 | "test-core-api", |
369 | "nohelp", | 328 | "nohelp", |
370 | options, | 329 | options, |
371 | &run, | 330 | &run, |
372 | &ok); | 331 | &ok); |
373 | stop_arm (&p1); | 332 | stop_arm (&p1); |
374 | stop_arm (&p2); | 333 | stop_arm (&p2); |
375 | GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-1"); | 334 | GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-1"); |